# Circuit Synthesis (`qiskit.synthesis`)#

## Evolution Synthesis#

 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. 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#

qiskit.synthesis.synth_cnot_count_full_pmh(state, section_size=2)[source]#

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 x n matrix.

Parameters:
• state (list[list] or ndarray) β n x n boolean invertible matrix, describing the state of the input circuit

• section_size (int) β the size of each section, used in the PatelβMarkovβHayes algorithm [1]. section_size must be a factor of num_qubits.

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]

qiskit.synthesis.synth_cnot_depth_line_kms(mat)[source]#

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

Synthesis algorithm for linear reversible circuits from [1], Chapter 7. Synthesizes any linear reversible circuit of n qubits over linear nearest-neighbor architecture using CX gates with depth at most 5*n.

Parameters:

mat (np.ndarray]) β A boolean invertible matrix.

Returns:

the synthesized quantum circuit.

Return type:

QuantumCircuit

Raises:

QiskitError β if mat is not invertible.

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

## Linear-Phase Synthesis#

qiskit.synthesis.synth_cz_depth_line_mr(mat)[source]#

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 CX and phase (S, Sdg or Z) gates.

Parameters:

mat (ndarray) β 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 2*n+2 for LNN connectivity.

Return type:

QuantumCircuit

Reference:
1. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176.

qiskit.synthesis.synth_cx_cz_depth_line_my(mat_x, mat_z)[source]#

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:
• mat_z (ndarray) β a boolean symmetric matrix representing a CZ circuit. Mz[i][j]=1 represents a CZ(i,j) gate

• mat_x (ndarray) β a boolean invertible matrix representing a CX circuit.

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

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

2. Dmitri Maslov, Willers Yang, CNOT circuits need little help to implement arbitrary Hadamard-free Clifford transformations they generate, arXiv:2210.16195.

## Permutation Synthesis#

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)[source]#

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

This is the permutation synthesis algorithm from https://arxiv.org/abs/quant-ph/0701194, Chapter 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 (Union[list[int], np.ndarray]) β 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

qiskit.synthesis.synth_permutation_basic(pattern)[source]#

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 (Union[list[int], np.ndarray]) β 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

qiskit.synthesis.synth_permutation_acg(pattern)[source]#

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 Theorem 2 in the paper βRouting Permutations on Graphs Via Matchingsβ (1993), available at https://www.cs.tau.ac.il/~nogaa/PDFS/r.pdf.

Parameters:

pattern (Union[list[int], np.ndarray]) β 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

## Clifford Synthesis#

qiskit.synthesis.synth_clifford_full(clifford, method=None)[source]#

Decompose a Clifford operator into a QuantumCircuit.

For N <= 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) β Optional, a synthesis method (βAGβ or βgreedyβ). If set this overrides optimal decomposition for N <=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]

2. S. Aaronson, D. Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196

3. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Clifford Circuit Optimization with Templates and Symbolic Pauli Gates, arXiv:2105.02291 [quant-ph]

qiskit.synthesis.synth_clifford_ag(clifford)[source]#

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

Parameters:

clifford (Clifford) β a clifford operator.

Returns:

a circuit implementation of the Clifford.

Return type:

QuantumCircuit

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

qiskit.synthesis.synth_clifford_bm(clifford)[source]#

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

Parameters:

clifford (Clifford) β a clifford operator.

Returns:

a circuit implementation of the Clifford.

Return type:

QuantumCircuit

Raises:

QiskitError β if clifford is on more than 3 qubits.

Reference:
1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_greedy(clifford)[source]#

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.

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

Parameters:

clifford (Clifford) β a clifford operator.

Returns:

a circuit implementation of the Clifford.

Return type:

QuantumCircuit

Raises:

QiskitError β if symplectic Gaussian elimination fails.

Reference:
1. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin, Clifford Circuit Optimization with Templates and Symbolic Pauli Gates, arXiv:2105.02291 [quant-ph]

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)[source]#

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

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) β a function to decompose the CX sub-circuit. It gets as input a boolean invertible matrix, and outputs a QuantumCircuit.

• cz_synth_func (Callable) β 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

Reference:
1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_depth_lnn(cliff)[source]#

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

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

Parameters:

cliff (Clifford) β a clifford operator.

Returns:

a circuit implementation of the Clifford.

Return type:

QuantumCircuit

Reference:
1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph]

2. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176.

3. Dmitri Maslov, Willers Yang, CNOT circuits need little help to implement arbitrary Hadamard-free Clifford transformations they generate, arXiv:2210.16195.

## CNOTDihedral Synthesis#

qiskit.synthesis.synth_cnotdihedral_full(elem)[source]#

Decompose a CNOTDihedral element into a QuantumCircuit. For N <= 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

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).

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)[source]#

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

Parameters:

elem (CNOTDihedral) β a CNOTDihedral element.

Returns:

a circuit implementation of the CNOTDihedral element.

Return type:

QuantumCircuit

Raises:

QiskitError β if the element in not 1-qubit or 2-qubit CNOTDihedral.

Reference:
1. Shelly Garion and Andrew W. Cross, On the structure of the CNOT-Dihedral group, arXiv:2006.12042 [quant-ph]

qiskit.synthesis.synth_cnotdihedral_general(elem)[source]#

Decompose a CNOTDihedral element into a QuantumCircuit.

Decompose a general CNOTDihedral elements. The number of CNOT 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.

Return type:

QuantumCircuit

Raises:

QiskitError β if the element could not be decomposed into a circuit.

Reference:
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#

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

Synthesis of a stabilizer state into layers.

It provides a similar decomposition to the synthesis described in Lemma 8 of Bravyi and Maslov, 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:
• stab (StabilizerState) β a stabilizer state.

• cz_synth_func (Callable) β a function to decompose the CZ sub-circuit. It gets as input a boolean symmetric matrix, and outputs a QuantumCircuit.

• 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 stabilizer state.

Return type:

QuantumCircuit

Raises:

QiskitError β if the input is not a StabilizerState.

Reference:
1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_stabilizer_depth_lnn(stab)[source]#

Synthesis of an n-qubit stabilizer state for linear-nearest neighbour connectivity, in 2-qubit depth 2*n+2 and two distinct CX layers, using CX and phase gates (S, Sdg or Z).

Parameters:

stab (StabilizerState) β a stabilizer state.

Returns:

a circuit implementation of the stabilizer state.

Return type:

QuantumCircuit

Reference:
1. S. Bravyi, D. Maslov, Hadamard-free circuits expose the structure of the Clifford group, arXiv:2003.09412 [quant-ph]

2. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176.

## Discrete Basis Synthesis#

 The Solovay Kitaev discrete decomposition algorithm.
qiskit.synthesis.generate_basic_approximations(basis_gates, depth, filename=None)[source]#

Generates a list of `GateSequence``s with the gates in ``basic_gates`.

Parameters:
• basis_gates (list[str | Gate]) β The gates from which to create the sequences of gates.

• depth (int) β The maximum depth of the approximations.

• filename (str | None) β If provided, the basic approximations are stored in this file.

Returns:

List of `GateSequences` using the gates in `basic_gates`.

Raises:

ValueError β If `basis_gates` contains an invalid gate identifier.

Return type:

list[GateSequence]