# Circuit Synthesis

qiskit.synthesis

## Evolution Synthesis

EvolutionSynthesis()Interface for evolution synthesis algorithms.
ProductFormula(order[, reps, ...])Product formula base class for the decomposition of non-commuting operator exponentials.
LieTrotter([reps, insert_barriers, ...])The Lie-Trotter product formula.
SuzukiTrotter([order, reps, ...])The (higher order) Suzuki-Trotter product formula.
MatrixExponential()Exact operator evolution via matrix exponentiation and unitary synthesis.
QDrift([reps, insert_barriers, ...])The QDrift Trotterization method, which selects each each term in the Trotterization randomly, with a probability proportional to its weight.

## Linear Function Synthesis

### synth_cnot_count_full_pmh

qiskit.synthesis.synth_cnot_count_full_pmh(state, section_size=2)

GitHub(opens in a new tab)

Synthesize linear reversible circuits for all-to-all architecture using Patel, Markov and Hayes method.

This function is an implementation of the Patel, Markov and Hayes algorithm from [1] for optimal synthesis of linear reversible circuits for all-to-all architecture, as specified by an $n \times n$ matrix.

Parameters

Returns

a CX-only circuit implementing the linear transformation.

Return type

QuantumCircuit

Raises

QiskitError – when variable state isn’t of type numpy.ndarray

References

1. Patel, Ketan N., Igor L. Markov, and John P. Hayes, Optimal synthesis of linear reversible circuits, Quantum Information & Computation 8.3 (2008): 282-294. arXiv:quant-ph/0302002 [quant-ph](opens in a new tab)

### synth_cnot_depth_line_kms

qiskit.synthesis.synth_cnot_depth_line_kms(mat)

GitHub(opens in a new tab)

Synthesize linear reversible circuit for linear nearest-neighbor architectures using Kutin, Moulton, Smithline method.

Synthesis algorithm for linear reversible circuits from [1], section 7. This algorithm synthesizes any linear reversible circuit of $n$ qubits over a linear nearest-neighbor architecture using CX gates with depth at most $5n$.

Parameters

mat (ndarray(opens in a new tab)[bool(opens in a new tab)]) – A boolean invertible matrix.

Returns

The synthesized quantum circuit.

Raises

QiskitError – if mat is not invertible.

Return type

QuantumCircuit

References

1. Kutin, S., Moulton, D. P., Smithline, L., Computation at a distance, Chicago J. Theor. Comput. Sci., vol. 2007, (2007), arXiv:quant-ph/0701194(opens in a new tab)

## Linear-Phase Synthesis

### synth_cz_depth_line_mr

qiskit.synthesis.synth_cz_depth_line_mr(mat)

GitHub(opens in a new tab)

Synthesis of a CZ circuit for linear nearest neighbour (LNN) connectivity, based on Maslov and Roetteler.

Note that this method reverts the order of qubits in the circuit, and returns a circuit containing CXGates and phase gates (SGate, SdgGate or ZGate).

Parameters

mat (ndarray(opens in a new tab)) – an upper-diagonal matrix representing the CZ circuit. mat[i][j]=1 for i<j represents a cz(i,j) gate

Returns

A circuit implementation of the CZ circuit of depth $2n+2$ for LNN connectivity.

Return type

QuantumCircuit

References

1. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176(opens in a new tab).

### synth_cx_cz_depth_line_my

qiskit.synthesis.synth_cx_cz_depth_line_my(mat_x, mat_z)

GitHub(opens in a new tab)

Joint synthesis of a -CZ-CX- circuit for linear nearest neighbour (LNN) connectivity, with 2-qubit depth at most 5n, based on Maslov and Yang. This method computes the CZ circuit inside the CX circuit via phase gate insertions.

Parameters

Returns

A circuit implementation of a CX circuit following a CZ circuit, denoted as a -CZ-CX- circuit,in two-qubit depth at most 5n, for LNN connectivity.

Return type

QuantumCircuit

References

1. Kutin, S., Moulton, D. P., Smithline, L., Computation at a distance, Chicago J. Theor. Comput. Sci., vol. 2007, (2007), arXiv:quant-ph/0701194(opens in a new tab)
2. Dmitri Maslov, Willers Yang, CNOT circuits need little help to implement arbitrary Hadamard-free Clifford transformations they generate, arXiv:2210.16195(opens in a new tab).

### synth_cnot_phase_aam

qiskit.synthesis.synth_cnot_phase_aam(cnots, angles, section_size=2)

GitHub(opens in a new tab)

This function is an implementation of the GraySynth algorithm of Amy, Azimadeh and Mosca.

GraySynth is a heuristic algorithm from [1] for synthesizing small parity networks. It is inspired by Gray codes. Given a set of binary strings $S$ (called cnots bellow), the algorithm synthesizes a parity network for $S$ by repeatedly choosing an index $i$ to expand and then effectively recursing on the co-factors $S_0$ and $S_1$, consisting of the strings $y \in S$, with $y_i = 0$ or $1$ respectively. As a subset $S$ is recursively expanded, cx gates are applied so that a designated target bit contains the (partial) parity $\chi_y(x)$ where $y_i = 1$ if and only if $y'_i = 1$ for all $y' \in S$. If $S$ contains a single element $\{y'\}$, then $y = y'$, and the target bit contains the value $\chi_{y'}(x)$ as desired.

Notably, rather than uncomputing this sequence of cx (CNOT) gates when a subset $S$ is finished being synthesized, the algorithm maintains the invariant that the remaining parities to be computed are expressed over the current state of bits. This allows the algorithm to avoid the ‘backtracking’ inherent in uncomputing-based methods.

The algorithm is described in detail in section 4 of [1].

Parameters

• A matrix whose columns are the parities to be synthesized e.g.:

[[0, 1, 1, 1, 1, 1],
[1, 0, 0, 1, 1, 1],
[1, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0]]

corresponds to:

x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1
• angles (list(opens in a new tab)[str(opens in a new tab)]) – A list containing all the phase-shift gates which are to be applied, in the same order as in cnots. A number is interpreted as the angle of $p(angle)$, otherwise the elements have to be 't', 'tdg', 's', 'sdg' or 'z'.

• section_size (int(opens in a new tab)) – The size of every section in the Patel–Markov–Hayes algorithm. section_size must be a factor of the number of qubits.

Returns

The decomposed quantum circuit.

Raises

QiskitError – when dimensions of cnots and angles don’t align.

Return type

QuantumCircuit

References

1. Matthew Amy, Parsiad Azimzadeh, and Michele Mosca. On the controlled-NOT complexity of controlled-NOT–phase circuits., Quantum Science and Technology 4.1 (2018): 015002. arXiv:1712.01859(opens in a new tab)

## Permutation Synthesis

### synth_permutation_depth_lnn_kms

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)

GitHub(opens in a new tab)

Synthesize a permutation circuit for a linear nearest-neighbor architecture using the Kutin, Moulton, Smithline method.

This is the permutation synthesis algorithm from [1], section 6. It synthesizes any permutation of n qubits over linear nearest-neighbor architecture using SWAP gates with depth at most $n$ and size at most $n(n-1)/2$ (where both depth and size are measured with respect to SWAPs).

Parameters

pattern (list(opens in a new tab)[int(opens in a new tab)] | np.ndarray[int(opens in a new tab)]) – Permutation pattern, describing which qubits occupy the positions 0, 1, 2, etc. after applying the permutation. That is, pattern[k] = m when the permutation maps qubit m to position k. As an example, the pattern [2, 4, 3, 0, 1] means that qubit 2 goes to position 0, qubit 4 goes to position 1, etc.

Returns

The synthesized quantum circuit.

Return type

QuantumCircuit

References

1. Samuel A. Kutin, David Petrie Moulton and Lawren M. Smithline. Computation at a distance., arXiv:quant-ph/0701194v1(opens in a new tab)

### synth_permutation_basic

qiskit.synthesis.synth_permutation_basic(pattern)

GitHub(opens in a new tab)

Synthesize a permutation circuit for a fully-connected architecture using sorting.

More precisely, if the input permutation is a cycle of length m, then this creates a quantum circuit with m-1 SWAPs (and of depth m-1); if the input permutation consists of several disjoint cycles, then each cycle is essentially treated independently.

Parameters

pattern (list(opens in a new tab)[int(opens in a new tab)] | np.ndarray[int(opens in a new tab)]) – Permutation pattern, describing which qubits occupy the positions 0, 1, 2, etc. after applying the permutation. That is, pattern[k] = m when the permutation maps qubit m to position k. As an example, the pattern [2, 4, 3, 0, 1] means that qubit 2 goes to position 0, qubit 4 goes to position 1, etc.

Returns

The synthesized quantum circuit.

Return type

QuantumCircuit

### synth_permutation_acg

qiskit.synthesis.synth_permutation_acg(pattern)

GitHub(opens in a new tab)

Synthesize a permutation circuit for a fully-connected architecture using the Alon, Chung, Graham method.

This produces a quantum circuit of depth 2 (measured in the number of SWAPs).

This implementation is based on the Proposition 4.1 in reference [1] with the detailed proof given in Theorem 2 in reference [2]

Parameters

pattern (list(opens in a new tab)[int(opens in a new tab)] | np.ndarray[int(opens in a new tab)]) – Permutation pattern, describing which qubits occupy the positions 0, 1, 2, etc. after applying the permutation. That is, pattern[k] = m when the permutation maps qubit m to position k. As an example, the pattern [2, 4, 3, 0, 1] means that qubit 2 goes to position 0, qubit 4 goes to position 1, etc.

Returns

The synthesized quantum circuit.

Return type

QuantumCircuit

References

1. N. Alon, F. R. K. Chung, and R. L. Graham. Routing Permutations on Graphs Via Matchings., Proceedings of the Twenty-Fifth Annual ACM Symposium on Theory of Computing(1993). Pages 583–591. (Extended abstract) 10.1145/167088.167239(opens in a new tab)
2. N. Alon, F. R. K. Chung, and R. L. Graham. Routing Permutations on Graphs Via Matchings., (Full paper)(opens in a new tab)

## Clifford Synthesis

### synth_clifford_full

qiskit.synthesis.synth_clifford_full(clifford, method=None)

GitHub(opens in a new tab)

Decompose a Clifford operator into a QuantumCircuit.

For $N \leq 3$ qubits this is based on optimal CX-cost decomposition from reference [1]. For $N > 3$ qubits this is done using the general non-optimal greedy compilation routine from reference [3], which typically yields better CX cost compared to the AG method in [2].

Parameters

• clifford (Clifford) – A Clifford operator.
• method (str(opens in a new tab) | None) – Optional, a synthesis method ('AG' or 'greedy'). If set this overrides optimal decomposition for $N \leq 3$ qubits.

Returns

A circuit implementation of the Clifford.

Return type

QuantumCircuit

References

1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph](opens in a new tab)
2. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196(opens in a new tab)
3. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Clifford Circuit Optimization with Templates and Symbolic Pauli Gates, arXiv:2105.02291 [quant-ph](opens in a new tab)

### synth_clifford_ag

qiskit.synthesis.synth_clifford_ag(clifford)

GitHub(opens in a new tab)

Decompose a Clifford operator into a QuantumCircuit based on Aaronson-Gottesman method [1].

Parameters

clifford (Clifford) – A Clifford operator.

Returns

A circuit implementation of the Clifford.

Return type

QuantumCircuit

References

1. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196(opens in a new tab)

### synth_clifford_bm

qiskit.synthesis.synth_clifford_bm(clifford)

GitHub(opens in a new tab)

Optimal CX-cost decomposition of a Clifford operator on 2 qubits or 3 qubits into a QuantumCircuit based on the Bravyi-Maslov method [1].

Parameters

clifford (Clifford) – A Clifford operator.

Returns

A circuit implementation of the Clifford.

Raises

QiskitError – if Clifford is on more than 3 qubits.

Return type

QuantumCircuit

References

1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph](opens in a new tab)

### synth_clifford_greedy

qiskit.synthesis.synth_clifford_greedy(clifford)

GitHub(opens in a new tab)

Decompose a Clifford operator into a QuantumCircuit based on the greedy Clifford compiler that is described in Appendix A of Bravyi, Hu, Maslov and Shaydulin [1].

This method typically yields better CX cost compared to the Aaronson-Gottesman method.

Note that this function only implements the greedy Clifford compiler from Appendix A of [1], and not the templates and symbolic Pauli gates optimizations that are mentioned in the same paper.

Parameters

clifford (Clifford) – A Clifford operator.

Returns

A circuit implementation of the Clifford.

Raises

QiskitError – if symplectic Gaussian elimination fails.

Return type

QuantumCircuit

References

1. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Clifford Circuit Optimization with Templates and Symbolic Pauli Gates, arXiv:2105.02291 [quant-ph](opens in a new tab)

### synth_clifford_layers

qiskit.synthesis.synth_clifford_layers(cliff, cx_synth_func=<function _default_cx_synth_func>, cz_synth_func=<function _default_cz_synth_func>, cx_cz_synth_func=None, cz_func_reverse_qubits=False, validate=False)

GitHub(opens in a new tab)

Synthesis of a Clifford into layers, it provides a similar decomposition to the synthesis described in Lemma 8 of Bravyi and Maslov [1].

For example, a 5-qubit Clifford circuit is decomposed into the following layers:

     ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
│     ││     ││        ││     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1       ├┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
│     ││     ││        ││     ││     ││     ││     ││        │
q_2: ┤2 S2 ├┤2 CZ ├┤2 CX_dg ├┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
│     ││     ││        ││     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3       ├┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
│     ││     ││        ││     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4       ├┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
└─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

This decomposition is for the default cz_synth_func and cx_synth_func functions, with other functions one may see slightly different decomposition.

Parameters

• cliff (Clifford) – A Clifford operator.
• cx_synth_func (Callable[[np.ndarray], QuantumCircuit]) – A function to decompose the CX sub-circuit. It gets as input a boolean invertible matrix, and outputs a QuantumCircuit.
• cz_synth_func (Callable[[np.ndarray], QuantumCircuit]) – A function to decompose the CZ sub-circuit. It gets as input a boolean symmetric matrix, and outputs a QuantumCircuit.
• cx_cz_synth_func (Callable) – optional, a function to decompose both sub-circuits CZ and CX.
• validate (Boolean) – if True, validates the synthesis process.
• cz_func_reverse_qubits (Boolean) – True only if cz_synth_func is synth_cz_depth_line_mr(), since this function returns a circuit that reverts the order of qubits.

Returns

A circuit implementation of the Clifford.

Return type

QuantumCircuit

References

1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph](opens in a new tab)

### synth_clifford_depth_lnn

qiskit.synthesis.synth_clifford_depth_lnn(cliff)

GitHub(opens in a new tab)

Synthesis of a Clifford into layers for linear-nearest neighbour connectivity.

The depth of the synthesized n-qubit circuit is bounded by $7n+2$, which is not optimal. It should be replaced by a better algorithm that provides depth bounded by $7n-4$ [3].

Parameters

cliff (Clifford) – a Clifford operator.

Returns

a circuit implementation of the Clifford.

Return type

QuantumCircuit

References

1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph](opens in a new tab)
2. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176(opens in a new tab).
3. Dmitri Maslov, Willers Yang, CNOT circuits need little help to implement arbitrary Hadamard-free Clifford transformations they generate, arXiv:2210.16195(opens in a new tab).

## CNOTDihedral Synthesis

### synth_cnotdihedral_full

qiskit.synthesis.synth_cnotdihedral_full(elem)

GitHub(opens in a new tab)

Decompose a CNOTDihedral element into a QuantumCircuit.

For $N \leq 2$ qubits this is based on optimal CX-cost decomposition from reference [1]. For $N > 2$ qubits this is done using the general non-optimal compilation routine from reference [2].

Parameters

elem (CNOTDihedral) – A CNOTDihedral element.

Returns

A circuit implementation of the CNOTDihedral element.

Return type

QuantumCircuit

References

1. Shelly Garion and Andrew W. Cross, Synthesis of CNOT-Dihedral circuits with optimal number of two qubit gates, Quantum 4(369), 2020(opens in a new tab)
2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta, Scalable randomised benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

### synth_cnotdihedral_two_qubits

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)

GitHub(opens in a new tab)

Decompose a CNOTDihedral element on a single qubit and two qubits into a QuantumCircuit. This decomposition has an optimal number of CXGates.

Parameters

elem (CNOTDihedral) – A CNOTDihedral element.

Returns

A circuit implementation of the CNOTDihedral element.

Raises

QiskitError – if the element in not 1-qubit or 2-qubit CNOTDihedral.

Return type

QuantumCircuit

References

1. Shelly Garion and Andrew W. Cross, On the structure of the CNOT-Dihedral group, arXiv:2006.12042 [quant-ph](opens in a new tab)

### synth_cnotdihedral_general

qiskit.synthesis.synth_cnotdihedral_general(elem)

GitHub(opens in a new tab)

Decompose a CNOTDihedral element into a QuantumCircuit.

Decompose a general CNOTDihedral elements. The number of CX gates is not necessarily optimal. For a decomposition of a 1-qubit or 2-qubit element, call synth_cnotdihedral_two_qubits().

Parameters

elem (CNOTDihedral) – A CNOTDihedral element.

Returns

A circuit implementation of the CNOTDihedral element.

Raises

QiskitError – if the element could not be decomposed into a circuit.

Return type

QuantumCircuit

References

1. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta, Scalable randomised benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

## Stabilizer State Synthesis

### synth_stabilizer_layers

qiskit.synthesis.synth_stabilizer_layers(stab, cz_synth_func=<function _default_cz_synth_func>, cz_func_reverse_qubits=False, validate=False)

GitHub(opens in a new tab)

Synthesis of a stabilizer state into layers.

It provides a similar decomposition to the synthesis described in Lemma 8 of reference [1], without the initial Hadamard-free sub-circuit which do not affect the stabilizer state.

For example, a 5-qubit stabilizer state is decomposed into the following layers:

     ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
│     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
│     ││     ││     ││     ││        │
q_2: ┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
│     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
│     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
└─────┘└─────┘└─────┘└─────┘└────────┘

Parameters

Returns

A circuit implementation of the stabilizer state.

Raises

QiskitError – if the input is not a StabilizerState.

Return type

QuantumCircuit

References

1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph](opens in a new tab)

### synth_stabilizer_depth_lnn

qiskit.synthesis.synth_stabilizer_depth_lnn(stab)

GitHub(opens in a new tab)

Synthesis of an n-qubit stabilizer state for linear-nearest neighbour connectivity, in 2-qubit depth $2n+2$ and two distinct CX layers, using CXGates and phase gates (SGate, SdgGate or ZGate).

Parameters

stab (StabilizerState) – A stabilizer state.

Returns

A circuit implementation of the stabilizer state.

Return type

QuantumCircuit

References

1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph](opens in a new tab)
2. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176(opens in a new tab).

### synth_circuit_from_stabilizers

qiskit.synthesis.synth_circuit_from_stabilizers(stabilizers, allow_redundant=False, allow_underconstrained=False, invert=False)

GitHub(opens in a new tab)

Synthesis of a circuit that generates a state stabilized by the stabilizers using Gaussian elimination with Clifford gates. If the stabilizers are underconstrained, and allow_underconstrained is True, the circuit will output one of the states stabilized by the stabilizers. Based on stim implementation.

Parameters

Returns

A circuit that generates a state stabilized by stabilizers.

Raises

QiskitError – if the stabilizers are invalid, do not commute, or contradict each other, if the list is underconstrained and allow_underconstrained is False, or if the list is redundant and allow_redundant is False.

Return type

QuantumCircuit

References

## Discrete Basis Synthesis

SolovayKitaevDecomposition([...])The Solovay Kitaev discrete decomposition algorithm.

### generate_basic_approximations

qiskit.synthesis.generate_basic_approximations(basis_gates, depth, filename=None)

GitHub(opens in a new tab)

Generates a list of GateSequences with the gates in basis_gates.

Parameters

Returns

List of GateSequences using the gates in basis_gates.

Raises

ValueError(opens in a new tab) – If basis_gates contains an invalid gate identifier.

Return type

list(opens in a new tab)[GateSequence]

## Basis Change Synthesis

### synth_qft_line

qiskit.synthesis.synth_qft_line(num_qubits, do_swaps=True, approximation_degree=0)

GitHub(opens in a new tab)

Synthesis of a QFT circuit for a linear nearest neighbor connectivity. Based on Fig 2.b in Fowler et al. [1].

Note that this method reverts the order of qubits in the circuit, compared to the original QFT code. Hence, the default value of the do_swaps parameter is True since it produces a circuit with fewer CX gates.

Parameters

Returns

A circuit implementation of the QFT circuit.

Return type

QuantumCircuit

References

1. A. G. Fowler, S. J. Devitt, and L. C. L. Hollenberg, Implementation of Shor’s algorithm on a linear nearest neighbour qubit array, Quantum Info. Comput. 4, 4 (July 2004), 237–251. arXiv:quant-ph/0402196 [quant-ph](opens in a new tab)

## Unitary Synthesis

Decomposition of general $2^n \times 2^n$ unitary matrices for any number of qubits.

### qs_decomposition

qiskit.synthesis.qs_decomposition(mat, opt_a1=True, opt_a2=True, decomposer_1q=None, decomposer_2q=None, *, _depth=0)

GitHub(opens in a new tab)

Decomposes a unitary matrix into one and two qubit gates using Quantum Shannon Decomposition,

This decomposition is described in Shende et al. [1].

  ┌───┐               ┌───┐     ┌───┐     ┌───┐
─┤   ├─       ───────┤ Rz├─────┤ Ry├─────┤ Rz├─────
│   │    ≃     ┌───┐└─┬─┘┌───┐└─┬─┘┌───┐└─┬─┘┌───┐
/─┤   ├─       /─┤   ├──□──┤   ├──□──┤   ├──□──┤   ├
└───┘          └───┘     └───┘     └───┘     └───┘

The number of CXGates generated with the decomposition without optimizations is:

$\frac{9}{16} 4^n - \frac{3}{2} 2^n$

If opt_a1 = True, the default, the CX count is reduced by:

$\frac{1}{3} 4^{n - 2} - 1.$

If opt_a2 = True, the default, the CX count is reduced by:

$4^{n-2} - 1.$

Parameters

Returns

Decomposed quantum circuit.

Return type

QuantumCircuit

References

1. Shende, Bullock, Markov, Synthesis of Quantum Logic Circuits, arXiv:0406176 [quant-ph](opens in a new tab)

The Approximate Quantum Compiler is available here:

qiskit.synthesis.unitary.aqcApproximate Quantum Compiler (qiskit.synthesis.unitary.aqc)

## One-Qubit Synthesis

OneQubitEulerDecomposer([basis, use_dag])A class for decomposing 1-qubit unitaries into Euler angle rotations.

## Two-Qubit Synthesis

TwoQubitBasisDecomposer(gate[, ...])A class for decomposing 2-qubit unitaries into minimal number of uses of a 2-qubit basis gate.
XXDecomposer([basis_fidelity, euler_basis, ...])A class for optimal decomposition of 2-qubit unitaries into 2-qubit basis gates of XX type (i.e., each locally equivalent to $CAN(\alpha, 0, 0)$ for a possibly varying $alpha$).
TwoQubitWeylDecomposition(unitary_matrix, *)Two-qubit Weyl decomposition.

### two_qubit_cnot_decompose

qiskit.synthesis.two_qubit_cnot_decompose(*args, **kwargs)

This is an instance of TwoQubitBasisDecomposer that always uses cx as the KAK gate for the basis decomposition. You can use this function as a quick access to cx-based 2-qubit decompositions.

Parameters

Returns

The synthesized circuit of the input unitary.

Return type

QuantumCircuit