Schaltungssynthese

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

Synthese linearer reversibler Schaltungen für eine All-to-All-Architektur unter Verwendung der Patel-, Markov- und Hayes-Methode.

Diese Funktion ist eine Implementierung des Patel-, Markov- und Hayes-Algorithmus aus [1] zur optimalen Synthese linearer reversibler Schaltungen für eine All-to-All-Architektur, die durch eine $n \times n$ -Matrix spezifiziert wird.

Parameter

• state (list[list[bool]] | ndarray[bool]) – $n \times n$ Boolesche invertierbare Matrix, die den Zustand der Eingangsschaltung beschreibt.
• section_size (int | None) – Die Größe der einzelnen Abschnitte im Patel-Markov-Hayes-Algorithmus [1]. Wenn None so gewählt wird, dass $\max(2, \alpha\log_2(n))$ mit $\alpha = 0.56$ übereinstimmt, wird die obere Schranke für die Anzahl der Zeilenoperationen gemäß Gleichung [1] annähernd minimiert. (3).

Rückgabe

Ein reiner CX-Schaltkreis zur Umsetzung der linearen Transformation.

Erhöht

ValueError - Wenn section_size größer ist als die Anzahl der Spalten.

Rückgabetyp

QuantumCircuit

Referenzen

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)

Synthese linearer reversibler Schaltungen für lineare Nearest-Neighbor-Architekturen unter Verwendung der Methode von Kutin, Moulton und Smithline.

Synthesealgorithmus für lineare reversible Schaltungen aus [1], Abschnitt 7. Dieser Algorithmus synthetisiert jede lineare reversible Schaltung von $n$ Qubits über eine lineare Nearest-Neighbor-Architektur mit CX-Gattern mit einer Tiefe von höchstens $5n$.

Parameter

mat (ndarray[bool]) – Eine boolesche invertierbare Matrix.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError - wenn mat nicht invertierbar ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Kutin, S., Moulton, D. P., Smithline, L., Computation at a distance, Chicago J. Theor. Computer. Naturwissenschaft, bd. 2007, (2007), arXiv:quant-ph/0701194

qiskit.synthesis.synth_cz_depth_line_mr(mat)

Synthese eines CZ-Schaltkreises für lineare Nächste-Nachbarn-Verbindungen (LNN), basierend auf Maslov und Roetteler.

Beachten Sie, dass diese Methode die Reihenfolge der Qubits im Schaltkreis umkehrt und einen Schaltkreis zurückgibt, der CXGates- und Phasengatter (SGate, SdgGate oder ZGate) enthält.

Parameter

mat (ndarray) – eine quadratische, oberdiagonale Matrix aus Booleschen Werten, die die CZ-Schaltung darstellt. mat[i][j]=1 for i<j stellt ein cz(i,j) Tor dar. Es wird nur das obere Dreieck ausgelesen; die Diagonale und das untere Dreieck haben keine Auswirkung.

Rückgabe

Eine Schaltungsimplementierung der CZ-Schaltung der Tiefe $2n+2$ für LNN-Verbindungen.

Rückgabetyp

QuantumCircuit

Referenzen

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)

Gemeinsame Synthese eines -CZ-CX-Schaltkreises für lineare Nächste-Nachbarn-Verbindungen (LNN) mit einer 2-Qubit-Tiefe von höchstens 5n, basierend auf Maslov und Yang. Bei dieser Methode wird die CZ-Schaltung innerhalb der CX-Schaltung durch Einfügen von Phasentoren berechnet.

Parameter

• mat_z (ndarray) – eine boolesche symmetrische Matrix, die eine CZ-Schaltung darstellt. mat_z[i][j]=1 stellt ein cz(i,j) Tor dar
• mat_x (ndarray) – eine boolesche invertierbare Matrix, die eine CX-Schaltung darstellt.

Rückgabe

Eine Schaltungsimplementierung einer CX-Schaltung, die auf eine CZ-Schaltung folgt, bezeichnet als -CZ-CX-Schaltung, mit einer Zwei-Qubit-Tiefe von höchstens 5n, für LNN-Konnektivität.

Rückgabetyp

QuantumCircuit

Referenzen

1. Kutin, S., Moulton, D. P., Smithline, L., Computation at a distance, Chicago J. Theor. Computer. Naturwissenschaft, bd. 2007, (2007), arXiv:quant-ph/0701194
2. Dmitri Maslov, Willers Yang, CNOT-Schaltungen brauchen wenig Hilfe, um beliebige Hadamard-freie Clifford-Transformationen zu implementieren, die sie erzeugen, arXiv:2210.16195.

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

Diese Funktion ist eine Implementierung des GraySynth Algorithmus von Amy, Azimadeh und Mosca.

GraySynth ist ein heuristischer Algorithmus aus [[1]] zur Synthese kleiner Paritätsnetzwerke. Es ist von Gray-Codes inspiriert. Ausgehend von einer Menge binärer Zeichenfolgen $S$ (im cnots Folgenden als bezeichnet) synthetisiert der Algorithmus ein Paritätsnetzwerk für $S$, indem er wiederholt einen Index $i$ zur Erweiterung auswählt und dann effektiv rekursiv auf die Kofaktoren $S_0$ und $S_1$ anwendet, die aus den Zeichenfolgen $y \in S$ bestehen, wobei jeweils $y_i = 0$ oder $1$ verwendet wird. Während eine Teilmenge $S$ rekursiv erweitert wird, werden cx Gatter so angewendet, dass ein bestimmtes Zielbit die (Teil-)Paritäts $\chi_y(x)$ enthält, wobei $y_i = 1$ genau dann gilt, wenn $y'_i = 1$ für alle $y' \in S$ gilt. Wenn $S$ ein einzelnes Element $\{y'\}$ enthält, dann gilt $y = y'$, und das Zielbit enthält wie gewünscht den Wert $\chi_{y'}(x)$.

Anstatt diese Folge von cx (CNOT) Gattern zu berechnen, wenn eine Teilmenge $S$ fertig synthetisiert ist, behält der Algorithmus die Invariante bei, dass die verbleibenden zu berechnenden Paritäten über den aktuellen Zustand der Bits ausgedrückt werden. Dadurch kann der Algorithmus das "Backtracking" vermeiden, das bei nicht rechnergestützten Methoden auftritt.

Der Algorithmus wird in Abschnitt 4 von [1] ausführlich beschrieben.

Parameter

• cnots (list[list[int]]) –

  Eine Matrix, deren Spalten die zu synthetisierenden Paritäten sind 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]]

  entspricht:

  x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1

• angles (list[str]) – Eine Liste mit allen Phasenverschiebungsgattern, die angewendet werden sollen, in der gleichen Reihenfolge wie in cnots. Eine Zahl wird als der Winkel von $p(angle)$ interpretiert, andernfalls müssen die Elemente 't', 'tdg', 's', 'sdg' oder 'z' sein.

• section_size (int) – Die Größe der einzelnen Abschnitte im Patel-Markov-Hayes-Algorithmus. section_size muss ein Faktor der Anzahl der Qubits sein.

Rückgabe

Die zerlegte Quantenschaltung.

Erhöht

QiskitError - wenn die Abmessungen von cnots und angles nicht übereinstimmen.

Rückgabetyp

QuantumCircuit

Referenzen

1. Matthew Amy, Parsiad Azimzadeh, und Michele Mosca. Über die kontrollierte-NOT-Komplexität von Schaltungen mit kontrollierter-NOT-Phase.., Quantenwissenschaft und -technologie 4.1 (2018): 015002. arXiv:1712.01859

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)

Synthese einer Permutationsschaltung für eine lineare Nearest-Neighbor-Architektur unter Verwendung der Methode von Kutin, Moulton und Smithline.

Dies ist der Permutationssynthese-Algorithmus aus [1], Abschnitt 6. Es synthetisiert jede Permutation von n Qubits über eine lineare Nearest-Neighbor-Architektur unter Verwendung von SWAP-Gattern mit einer Tiefe von höchstens $n$ und einer Größe von höchstens $n(n-1)/2$ (wobei sowohl Tiefe als auch Größe in Bezug auf SWAPs gemessen werden).

Parameter

pattern (list[int] | ndarray[int]) – Permutationsmuster, das beschreibt, welche Qubits nach Anwendung der Permutation die Positionen 0, 1, 2 usw. einnehmen. Das heißt, pattern[k] = m wenn die Permutation das Qubit m auf die Position kabbildet. Als Beispiel bedeutet das [2, 4, 3, 0, 1] Muster, dass Qubit an Position 2 geht 0, Qubit an Position 4 1geht usw.

Rückgabe

Die synthetisierte Quantenschaltung.

Rückgabetyp

QuantumCircuit

Referenzen

1. Samuel A. Kutin, David Petrie Moulton und Lawren M. Smithline. Berechnung aus der Ferne.., arXiv:quant-ph/0701194v1

qiskit.synthesis.synth_permutation_basic(pattern)

Synthese einer Permutationsschaltung für eine vollständig verbundene Architektur mit Hilfe von Sortierung.

Genauer gesagt, wenn die Eingabe-Permutation ein Zyklus der Länge m ist, dann entsteht ein Quantenschaltkreis mit m-1 SWAPs (und der Tiefe m-1); wenn die Eingabe-Permutation aus mehreren disjunkten Zyklen besteht, dann wird jeder Zyklus im Wesentlichen unabhängig behandelt.

Parameter

pattern (list[int] | ndarray[int]) – Permutationsmuster, das beschreibt, welche Qubits nach Anwendung der Permutation die Positionen 0, 1, 2 usw. einnehmen. Das heißt, pattern[k] = m wenn die Permutation das Qubit m auf die Position kabbildet. Als Beispiel bedeutet das [2, 4, 3, 0, 1] Muster, dass Qubit an Position 2 geht 0, Qubit an Position 4 1geht usw.

Rückgabe

Die synthetisierte Quantenschaltung.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_permutation_acg(pattern)

Synthese einer Permutationsschaltung für eine vollständig verbundene Architektur unter Verwendung der Methode von Alon, Chung und Graham.

Daraus ergibt sich ein Quantenkreis der Tiefe 2 (gemessen an der Anzahl der SWAPs).

Diese Implementierung basiert auf der Proposition 4.1 in Referenz [1] mit dem detaillierten Beweis in Theorem 2 in Referenz [2]

Parameter

pattern (list[int] | ndarray[int]) – Permutationsmuster, das beschreibt, welche Qubits nach Anwendung der Permutation die Positionen 0, 1, 2 usw. einnehmen. Das heißt, pattern[k] = m wenn die Permutation das Qubit m auf die Position kabbildet. Als Beispiel bedeutet das [2, 4, 3, 0, 1] Muster, dass Qubit an Position 2 geht 0, Qubit an Position 4 1geht usw.

Rückgabe

Die synthetisierte Quantenschaltung.

Rückgabetyp

QuantumCircuit

Referenzen

1. :NONE. Alon, F. R. K. Chung, und R. L. Graham. Routing-Permutationen auf Graphen über Matchings., Proceedings of the Twenty-Fifth Annual ACM Symposium on Theory of Computing(1993). Seiten 583-591. (Erweiterte Zusammenfassung) 10.1145/167088.167239
2. :NONE. Alon, F. R. K. Chung, und R. L. Graham. Routing-Permutationen auf Graphen über Matchings., (Vollständiges Papier)

qiskit.synthesis.synth_permutation_reverse_lnn_kms(num_qubits)

Synthese der umgekehrten Permutation für lineare Nearest-Neighbor-Architekturen mit der Methode von Kutin, Moulton und Smithline.

Synthesealgorithmus für die umgekehrte Permutation aus [1], Abschnitt 5. Dieser Algorithmus synthetisiert die umgekehrte Permutation auf $n$ Qubits über eine lineare Nearest-Neighbor-Architektur unter Verwendung von CX-Gattern mit der Tiefe $2 * n + 2$.

Parameter

num_qubits (int) – Die Anzahl der Qubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Rückgabetyp

QuantumCircuit

Referenzen

1. Kutin, S., Moulton, D. P., Smithline, L., Computation at a distance, Chicago J. Theor. Computer. Naturwissenschaft, bd. 2007, (2007), arXiv:quant-ph/0701194

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

Zerlege einen Clifford Operator in einen QuantumCircuit.

Für $N \leq 3$ Qubits basiert dies auf der optimalen CX-Kostenzerlegung aus Referenz [1]. Für $N > 3$ Qubits wird dies mit der allgemeinen nicht-optimalen gierigen Kompilierungsroutine aus Referenz [3] durchgeführt, die typischerweise bessere CX-Kosten im Vergleich zur AG-Methode in [2] liefert.

Parameter

• clifford (Clifford) – Ein Clifford-Operator.
• method (str | None) – ein Syntheseverfahren ('AG' oder 'greedy'). Wenn diese Option aktiviert ist, wird die optimale Zerlegung für $N \leq 3$ -Qubits außer Kraft gesetzt.

Rückgabe

Eine Schaltungsimplementierung des Clifford.

Rückgabetyp

QuantumCircuit

Referenzen

1. S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, 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)

Zerlege einen Clifford Operator in einen QuantumCircuit Operator nach der Aaronson-Gottesman-Methode [1].

Parameter

clifford (Clifford) – Ein Clifford-Operator.

Rückgabe

Eine Schaltungsimplementierung des Clifford.

Rückgabetyp

QuantumCircuit

Referenzen

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)

Optimale CX-Kostenzerlegung eines Clifford Operators auf 2 oder 3 Qubits in einen QuantumCircuit Operator auf der Grundlage der Bravyi-Maslov-Methode [1].

Parameter

clifford (Clifford) – Ein Clifford-Operator.

Rückgabe

Eine Schaltungsimplementierung des Clifford.

Erhöht

QiskitError - wenn Clifford auf mehr als 3 Qubits ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_greedy(clifford)

Zerlege einen Clifford Operator in einen QuantumCircuit auf der Grundlage des „greedy“ Clifford-Compilers, der in Anhang A von Bravyi, Hu, Maslov und Shaydulin [1] beschrieben wird.

Mit dieser Methode lassen sich in der Regel bessere CX-Kosten erzielen als mit der Aaronson-Gottesman-Methode.

Beachten Sie, dass diese Funktion nur den gierigen Clifford-Compiler aus Anhang A von [1] implementiert und nicht die Optimierungen für Templates und symbolische Pauli-Gatter, die in demselben Papier erwähnt werden.

Parameter

clifford (Clifford) – Ein Clifford-Operator.

Rückgabe

Eine Schaltungsimplementierung des Clifford.

Erhöht

QiskitError - wenn die symplektische Gaußsche Eliminierung fehlschlägt.

Rückgabetyp

QuantumCircuit

Referenzen

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)

Die Synthese von a Clifford in Schichten liefert eine ähnliche Zerlegung wie die in Lemma 8 von Bravyi und Maslov [1] beschriebene Synthese.

Eine 5-Qubit-Clifford-Schaltung wird beispielsweise in die folgenden Schichten zerlegt:

     ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
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       ├
     └─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

Diese Zerlegung gilt für die Standardfunktionen cz_synth_func und cx_synth_func , bei anderen Funktionen kann die Zerlegung etwas anders aussehen.

Parameter

• cliff (Clifford) – Ein Clifford-Operator.
• cx_synth_func (Callable[[ndarray], QuantumCircuit]) – Eine Funktion zur Zerlegung des CX-Teilkreises. Es erhält als Eingabe eine boolesche invertierbare Matrix und gibt eine aus QuantumCircuit.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Eine Funktion zur Zerlegung des CZ-Teilstromkreises. Es erhält als Eingabe eine boolesche symmetrische Matrix und gibt eine QuantumCircuit.
• cx_cz_synth_func (Callable) – optional, eine Funktion zur Zerlegung der beiden Teilstromkreise CZ und CX.
• validate (Boolean) – wenn True, validiert den Syntheseprozess.
• cz_func_reverse_qubits (Boolean) – Wahr nur, wenn cz_synth_func ist synth_cz_depth_line_mr()ist, da diese Funktion eine Schaltung liefert, die die Reihenfolge der Qubits umkehrt.

Rückgabe

Eine Schaltungsimplementierung des Clifford.

Rückgabetyp

QuantumCircuit

Referenzen

1. S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_clifford_depth_lnn(cliff)

Synthese von a Clifford in Schichten für eine lineare „Nearest-Neighbor“-Konnektivität.

Die Tiefe der synthetisierten n-Qubit-Schaltung ist durch $7n+2$ begrenzt, was nicht optimal ist. Er sollte durch einen besseren Algorithmus ersetzt werden, der eine durch $7n-4$ [3] begrenzte Tiefe bietet.

Parameter

cliff (Clifford) – ein Clifford-Operator.

Rückgabe

eine schaltungstechnische Umsetzung des Clifford.

Rückgabetyp

QuantumCircuit

Referenzen

1. S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, 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-Schaltungen brauchen wenig Hilfe, um beliebige Hadamard-freie Clifford-Transformationen zu implementieren, die sie erzeugen, arXiv:2210.16195.

qiskit.synthesis.synth_cnotdihedral_full(elem)

Zerlege ein CNOTDihedral Element in ein QuantumCircuit.

Für $N \leq 2$ Qubits basiert dies auf der optimalen CX-Kostenzerlegung aus Referenz [1]. Für $N > 2$ qubits wird dies mit der allgemeinen nicht-optimalen Kompilierungsroutine aus Referenz [2] durchgeführt.

Parameter

elem (CNOTDihedral) – Ein CNOTDihedral Element.

Rückgabe

Eine Schaltungsumsetzung des CNOTDihedral Elements.

Rückgabetyp

QuantumCircuit

Referenzen

1. Shelly Garion und 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 und Jay M. Gambetta, Scalable randomized benchmarking of non-Clifford gates, npj Quantum Inf 2, 16012 (2016).

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)

Zerlege ein CNOTDihedral Element auf einem einzelnen Qubit und zwei Qubits in ein QuantumCircuit. Diese Zerlegung hat eine optimale Anzahl von CXGates.

Parameter

elem (CNOTDihedral) – Ein CNOTDihedral Element.

Rückgabe

Eine Schaltungsumsetzung des CNOTDihedral Elements.

Erhöht

CNOTDihedralQiskitError – wenn das Element kein 1-Qubit oder 2-Qubit ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Shelly Garion und Andrew W. Cross, Über die Struktur der CNOT-Dihedral-Gruppe, arXiv:2006.12042 [quant-ph]

qiskit.synthesis.synth_cnotdihedral_general(elem)

Zerlege ein CNOTDihedral Element in ein QuantumCircuit.

Zerlege ein allgemeines CNOTDihedral in seine Elemente. Die Anzahl der CX-Gates ist nicht unbedingt optimal. synth_cnotdihedral_two_qubits()Für eine Zerlegung eines 1-Qubit- oder 2-Qubit-Elements rufen Sie die Funktion auf.

Parameter

elem (CNOTDihedral) – Ein CNOTDihedral Element.

Rückgabe

Eine Schaltungsumsetzung des CNOTDihedral Elements.

Erhöht

QiskitError - wenn das Element nicht in einen Stromkreis zerlegt werden kann.

Rückgabetyp

QuantumCircuit

Referenzen

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

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

Synthese eines Stabilisierungszustands in Schichten.

Sie liefert eine ähnliche Zerlegung wie die in Lemma 8 von Referenz [1] beschriebene Synthese, jedoch ohne den anfänglichen Hadamard-freien Teilkreis, der den Stabilisatorzustand nicht beeinflusst.

Beispielsweise wird ein 5-Qubit-Stabilisatorzustand in die folgenden Schichten zerlegt:

     ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
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       ├
     └─────┘└─────┘└─────┘└─────┘└────────┘

Parameter

• stab (StabilizerState) – Ein stabiler Zustand.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Eine Funktion zur Zerlegung des CZ-Teilstromkreises. Es erhält als Eingabe eine boolesche symmetrische Matrix und gibt eine QuantumCircuit.
• cz_func_reverse_qubits (bool) – True nur wenn cz_synth_func ist synth_cz_depth_line_mr()ist, da diese Funktion eine Schaltung liefert, die die Reihenfolge der Qubits umkehrt.
• validate (bool) – Wenn True, wird der Syntheseprozess bestätigt.

Rückgabe

Eine schaltungstechnische Umsetzung des Stabilisierungszustands.

Erhöht

StabilizerStateQiskitError – wenn die Eingabe kein. ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, arXiv:2003.09412 [quant-ph]

qiskit.synthesis.synth_stabilizer_depth_lnn(stab)

Synthese eines n-Qubit-Stabilisatorzustands für lineare „Nearest-Neighbor“-Konnektivität bei einer 2-Qubit-Tiefe $2n+2$ und zwei unterschiedlichen CX-Schichten unter Verwendung von CXGates- und Phasengattern (SGate, SdgGate oder ZGate).

Parameter

stab (StabilizerState) – Ein stabiler Zustand.

Rückgabe

Eine schaltungstechnische Umsetzung des Stabilisierungszustands.

Rückgabetyp

QuantumCircuit

Referenzen

1. S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, arXiv:2003.09412 [quant-ph]
2. Dmitri Maslov, Martin Roetteler, Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations, arXiv:1705.09176.

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

Synthese einer Schaltung, die einen durch die Stabilisatoren stabilisierten Zustand erzeugt, unter Verwendung der Gaußschen Eliminierung mit Clifford-Gattern. Wenn die Stabilisatoren unterfordert sind und allow_underconstrained True lautet, gibt die Schaltung einen der von den Stabilisatoren stabilisierten Zustände aus. Auf der Grundlage einer stimulierenden Implementierung.

Parameter

• stabilizers (Collection[str]) – Liste der Stabilisierungsfäden
• allow_redundant (bool) – Redundante Stabilisatoren zulassen (d. h., einige Stabilisatoren können sich aus anderen ergeben)
• allow_underconstrained (bool) – Unterbeschränkte Stabilisatoren zulassen (d. h., die Stabilisatoren legen keinen eindeutigen Zustand fest)
• invert (bool) – Rücklauf Umkehrschaltung

Rückgabe

Eine Schaltung, die einen durch stabilizers stabilisierten Zustand erzeugt.

Erhöht

QiskitError - wenn die Stabilisatoren ungültig, nicht kommutabel oder widersprüchlich sind, wenn die Liste unterbeschränkt ist und allow_underconstrained False ist, oder wenn die Liste redundant ist und allow_redundant False ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. https://github.com/quantumlib/Stim/blob/c0dd0b1c8125b2096cd54b6f72884a459e47fe3e/src/stim/stabilizers/conversions.inl#L469
2. https://quantumcomputing.stackexchange.com/questions/12721/how-to-calculate-destabilizer-group-of-toric-and-other-codes

qiskit.synthesis.gridsynth_rz(angle, epsilon=1e-10)

Ungefähre RZ-Rotation unter Verwendung des Ross-Selinger-Algorithmus.

Der Algorithmus wird in [1] beschrieben. Der Quellcode (in Rust) ist verfügbar unter https://github.com/qiskit-community/rsgridsynth.

Parameter

• angle (float) – Gibt den Winkel der RZ-Drehung an.
• epsilon (float) – Der zulässige Näherungsfehler.

Rückgabe

Ein Ein-Qubit-Schaltkreis, der sich annähert an RZ(angle).

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Neil J. Ross, Peter Selinger, Optimale ancilla-freie Clifford+T-Näherung von z-Rotationen,

arXiv:1403.2975

qiskit.synthesis.gridsynth_unitary(matrix, epsilon=1e-10)

Nähern Sie sich einer 1-Qubit-Unitary-Matrix unter Verwendung des Ross-Selinger-Algorithmus an.

Der Algorithmus wird in [1] beschrieben. Der Quellcode (in Rust) ist verfügbar unter https://github.com/qiskit-community/rsgridsynth.

Parameter

• matrix (ndarray) – Eine unitäre Matrix mit $2 imes 2$.
• epsilon (float) – Der zulässige Näherungsfehler.

Rückgabe

Ein Ein-Qubit-Schaltkreis, der sich annähert an matrix.

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Neil J. Ross, Peter Selinger, Optimale ancilla-freie Clifford+T-Näherung von z-Rotationen,

arXiv:1403.2975

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

Erzeugt eine Liste von GateSequences mit den Gates in basis_gates.

Parameter

• basis_gates (list[str |Gate]) – Die Gatter, aus denen die Gatterfolgen gebildet werden sollen.
• depth (int) – Die maximale Tiefe der Approximationen.
• filename (str | None) – Falls angegeben, werden die Grundannäherungen in dieser Datei gespeichert.

Rückgabe

Liste der GateSequences, die die Gates in basis_gates verwenden.

Erhöht

ValueError - Wenn basis_gates einen ungültigen Gate-Identifikator enthält.

Rückgabetyp

Liste [GateSequence]

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

Konstruieren Sie eine Schaltung für die Quanten-Fourier-Transformation unter Verwendung der linearen Nachbarschaftskonnektivität.

Die Konstruktion basiert auf der Abbildung 2.b in Fowler et al. [1].

Parameter

• num_qubits (int) – Die Anzahl der Qubits, auf die die Quanten-Fourier-Transformation wirkt.
• approximation_degree (int) – Der Grad der Angleichung (0 für keine Angleichung). Es ist möglich, die QFT näherungsweise zu implementieren, indem Drehungen mit kontrollierter Phase, deren Winkel unter einem Schwellenwert liegt, ignoriert werden. Dies wird ausführlicher behandelt in https://arxiv.org/abs/quant-ph/9601018 oder https://arxiv.org/abs/quant-ph/0403071.
• do_swaps (bool) – Ob die "QFT"- oder die "QFT-mit-Umkehrung"-Operation synthetisiert werden soll.

Rückgabe

Eine Schaltung zur Durchführung der QFT-Operation.

Rückgabetyp

QuantumCircuit

Referenzen

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. Computer. 4, 4 (Juli 2004), 237-251. arXiv:quant-ph/0402196 [quant-ph]

qiskit.synthesis.synth_qft_full(num_qubits, do_swaps=True, approximation_degree=0, insert_barriers=False, inverse=False, name=None)

Konstruieren Sie eine Schaltung für die Quanten-Fourier-Transformation unter Verwendung von All-zu-All-Verbindungen.

Parameter

• num_qubits (int) – Die Anzahl der Qubits, auf die die Quanten-Fourier-Transformation wirkt.
• do_swaps (bool) – Ob die "QFT"- oder die "QFT-mit-Umkehrung"-Operation synthetisiert werden soll.
• approximation_degree (int) – Der Grad der Angleichung (0 für keine Angleichung). Es ist möglich, die QFT näherungsweise zu implementieren, indem Drehungen mit kontrollierter Phase, deren Winkel unter einem Schwellenwert liegt, ignoriert werden. Dies wird ausführlicher behandelt in https://arxiv.org/abs/quant-ph/9601018 oder https://arxiv.org/abs/quant-ph/0403071.
• insert_barriers (bool) – Unter True werden zur besseren Visualisierung Barrieren eingefügt.
• inverse (bool) – Wenn True, wird die inverse Quanten-Fourier-Transformation konstruiert.
• name (str | None) – Der Name des Stromkreises.

Rückgabe

Eine Schaltung zur Durchführung der QFT-Operation.

Rückgabetyp

QuantumCircuit

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

Zerlegt eine unitäre Matrix in Ein- und Zwei-Qubit-Gatter mit Hilfe der Quanten-Shannon-Zerlegung, die auf der Block-ZXZ-Zerlegung basiert.

Diese Zersetzung wird in Krol und Al-Ars [2] beschrieben und verbessert die Methode von Shende et al. [1].

  ┌───┐              ┌───┐     ┌───┐
 ─┤   ├─      ────□──┤ H ├──□──┤ H ├──□──
  │   │    ≃    ┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
/─┤   ├─      ──┤ C ├─────┤ B ├─────┤ A ├
  └───┘         └───┘     └───┘     └───┘

Ohne die Optimierungen wäre die Anzahl der CXGate Das durch die Zerlegung erzeugte s ist dasselbe wie das nicht optimierte Verfahren in [1] :

Der Optimierungs A.1 us, der [1] verbessert und automatisch angewendet wird, spart in jedem Schritt der Rekursion zwei CXGateSekunden statt einer und reduziert so die Anzahl der CX um:

Die Optimierungs A.2 zerlegt, wie in [1] beschrieben, Zwei-Qubit-Unitarien in ein Diagonal-Gate und ein Zwei-CX-Unitar, wodurch die Anzahl der CX-Operationen um weitere reduziert wird:

Da diese Optimierung nicht durchgeführt werden sollte, wenn die ursprüngliche Unitarität kontrolliert ist, wird sie automatisch angewendet, es sei denn, die Eingabematrix entspricht einer kontrollierten (blockdiagonalen) Unitarität.

Daher beträgt die Anzahl der durch die Zerlegung unter Anwendung beider Optimierungen erzeugten CXGates:

Parameter

• mat (ndarray) – unitäre Matrix zerlegen
• opt_a1 (bool | None) – Dieses Argument ist veraltet; die Optimierung wird automatisch angewendet, wenn None (Standardeinstellung).
• opt_a2 (bool | None) – Dieses Argument ist veraltet; die Optimierung wird automatisch angewendet, wenn None (Standardeinstellung).
• decomposer_1q (Callable[[ndarray], QuantumCircuit] | None) – optionaler „ 1Q “-Dekompositor, eine Instanz von OneQubitEulerDecomposer. In Nonediesem Fall wird die Standard-Ein-Qubit-Zerlegung verwendet.
• decomposer_2q (Callable[[ndarray], QuantumCircuit] | None) – optionaler „ 2Q “-Dekompositor, eine Instanz von TwoQubitBasisDecomposer. In Nonediesem Fall wird die standardmäßige Zwei-Qubit-Zerlegung verwendet.

Rückgabe

Dekomponierte Quantenschaltung.

Rückgabetyp

QuantumCircuit

Referenzen

1. Shende, Bullock, Markov, Synthesis of Quantum Logic Circuits, arXiv:0406176 [quant-ph]
2. Krol, Al-Ars, Beyond Quantum Shannon: Circuit Construction for General n-Qubit Gates Based on Block ZXZ-Decomposition, arXiv:2403.13692

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

Dies ist ein Fall, TwoQubitBasisDecomposer bei dem für die Basisdecomposition stets als KAK-Gatter verwendet cx wird. Mit dieser Funktion können Sie schnell auf cx-basierte 2-Qubit-Zerlegungen zugreifen.

Parameter

• unitary (Operator or np.ndarray) – Die Funktion 4x4 ist einfach zu synthetisieren.
• basis_fidelity (float or None) – Wenn man die angenommene Genauigkeit für Anwendungen von CXGate.
• approximate (bool) – Wenn True annähernd, wenn basis_fidelity kleiner als 1.0 ist.

Rückgabe

Die synthetisierte Schaltung der Eingangs-Unitary.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_mcmt_vchain(gate, num_ctrl_qubits, num_target_qubits, ctrl_state=None)

Synthetisieren Sie MCMT mit Hilfe einer V-Kette.

Dabei wird eine Kette von CCX-Gattern verwendet, die num_ctrl_qubits - 1 Hilfsqubits nutzen.

Zum Beispiel wird ein 3-Steuer- und 2-Ziel-H-Gatter wie folgt synthetisiert:

q_0: ──■────────────────────────■──
       │                        │
q_1: ──■────────────────────────■──
       │                        │
q_2: ──┼────■──────────────■────┼──
       │    │  ┌───┐       │    │
q_3: ──┼────┼──┤ H ├───────┼────┼──
       │    │  └─┬─┘┌───┐  │    │
q_4: ──┼────┼────┼──┤ H ├──┼────┼──
     ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
q_5: ┤ X ├──■────┼────┼────■──┤ X ├
     └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
q_6: ─────┤ X ├──■────■──┤ X ├─────
          └───┘          └───┘

Parameter

• gate (Gate) – Basisgatter, das auf die Ziele angewendet werden soll.
• num_ctrl_qubits (int) – Anzahl der Kontrollqubits.
• num_target_qubits (int) – Anzahl der Zielqubits.
• ctrl_state (int | None) – Optionaler Kontrollstatus als Ganzzahl.

Rückgabe

Die synthetisierte Schaltung für das MCMT-Gatter.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_mcmt_xgate(num_ctrl_qubits, num_target_qubits, ctrl_state=None)

MCMT X-Gatter synthetisieren.

Dabei wird eine spezielle Schaltungsstruktur verwendet, die für MCMT-X-Gatter effizient ist. Es benötigt keine zusätzlichen Qubits und profitiert von effizienten MCX-Zerlegungen.

E.g. ein 3-Kontroll-, 3-Ziel-X-Gatter wird wie folgt synthetisiert:

q_0: ─────────────■────────────
                  |
q_1: ─────────────■────────────
                  |
q_2: ─────────────■────────────
                ┌─┴─┐
q_3: ────────■──┤ X ├──■───────
           ┌─┴─┐└───┘┌─┴─┐
q_4: ───■──┤ X ├─────┤ X ├──■──
      ┌─┴─┐└───┘     └───┘┌─┴─┐
q_5: ─┤ X ├───────────────┤ X ├
      └───┘               └───┘

Parameter

• num_ctrl_qubits (int) – Anzahl der Kontrollqubits.
• num_target_qubits (int) – Anzahl der Zielqubits.
• ctrl_state (int | None) – Optionaler Kontrollstatus als Ganzzahl.

Rückgabe

Die synthetisierte Schaltung für das MCMT-X-Gatter.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_mcx_1_clean_kg24(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gates mit $k\ge 3$ -Steuerungen unter Verwendung eines sauberen Hilfsqubits $1$, wodurch eine Schaltung mit $2k-3$ Toffoli-Gates oder $6k-6$ CX-Gates und einer Tiefe $O(k)$ entsteht, wie in Abschnitt beschrieben. 5.1 von [1]. Bei $k\le 2$ besteht der zurückgesendete Schaltkreis aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine zusätzlichen Qubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Khattar und Gidney, Aufstieg der bedingt reinen Ancillae zur Optimierung von Quantenschaltungen arXiv:2407.17966

qiskit.synthesis.synth_mcx_1_dirty_kg24(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gates mit den Steuerungen $k\ge 3$ unter Verwendung eines „dirty“ Hilfsqubits $1$, wodurch eine Schaltung mit $4k-8$ Toffoli-Gates oder $12k-18$ CX-Gates und einer Tiefe $O(k)$ entsteht, wie in Abschnitt 5.3 von [1]. Bei $k\le 2$ besteht der zurückgesendete Schaltkreis aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine zusätzlichen Qubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Khattar und Gidney, Aufstieg der bedingt reinen Ancillae zur Optimierung von Quantenschaltungen arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_clean_kg24(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gates mit $k\ge 3$ -Steuerungen unter Verwendung von $2$ sauberen Hilfsqubits, wodurch eine Schaltung mit $2k-3$ Toffoli-Gates oder $6k-6$ CX-Gates und einer Tiefe von $O(\log(k))$ entsteht, wie in Abschnitt 5.2 von [1]. Bei $k\le 2$ besteht der zurückgesendete Schaltkreis aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine zusätzlichen Qubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Khattar und Gidney, Aufstieg der bedingt reinen Ancillae zur Optimierung von Quantenschaltungen arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_dirty_kg24(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gates mit $k\ge 3$ -Steuerungen unter Verwendung von $2$ „dirty“ Hilfsqubits, wodurch eine Schaltung mit $4k-8$ Toffoli-Gates oder $12k-18$ CX-Gates und einer Tiefe von $O(\log(k))$ entsteht, wie in Abschnitt 5.4 von [1]. Bei $k\le 2$ besteht der zurückgesendete Schaltkreis aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine zusätzlichen Qubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Khattar und Gidney, Aufstieg der bedingt reinen Ancillae zur Optimierung von Quantenschaltungen arXiv:2407.17966

qiskit.synthesis.synth_mcx_n_dirty_i15(num_ctrl_qubits, relative_phase=False, action_only=False)

Synthese eines mehrfach gesteuerten X-Gatters mit $k$ Steuerungen auf der Grundlage der Arbeit von Iten et al. [1].

Für $k\ge 4$ verwendet die Methode $k - 2$ „dirty“ Hilfsqubits, wodurch eine Schaltung mit $2 * k - 1$ Qubits und höchstens $8 * k - 6$ CX-Gates entsteht. Bei $k\le 3$ werden stattdessen explizit konstruierte, effiziente Schaltungen verwendet, die keine zusätzlichen Qubits erfordern.

Parameter

• num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.
• relative_phase (bool) – wenn sie auf True eingestellt ist, wendet die Methode das optimierte mehrfach gesteuerte X-Gatter bis zu einer relativen Phase an, und zwar so, dass sich nach Lemma 8 von [1] die relativen Phasen der action part mit den Phasen der reset part aufheben.
• action_only (bool) – auf True gesetzt wird, wendet die Methode nur die action part von Lemma 8 von [1] an.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Iten et al. et al., Quantenschaltungen für Isometrien, Phys. Rev. A 93, 23.03.2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_n_clean_m15(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gates mit den Steuerungen $k\ge 3$ unter Verwendung von $k - 2$ sauberen Hilfsqubits, wobei eine Schaltung mit $2 * k - 1$ Qubits und höchstens $6 * k - 6$ CX-Gates erzeugt wird, gemäß Maslov [1]. Bei $k\le 2$ besteht der zurückgesendete Schaltkreis aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine zusätzlichen Qubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Maslov., Phys. Rev. A 93, 022311 (2016), arXiv:1508.03273

qiskit.synthesis.synth_mcx_1_clean_b95(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gates mit den Steuerungen $k\ge 3$ unter Verwendung eines einzigen sauberen Hilfsqubits, wobei eine Schaltung mit $k + 2$ Qubits und höchstens $16 * k - 24$ CX-Gates entsteht, von [1], [2]. Bei $k\le 2$ besteht der zurückgesendete Schaltkreis aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine zusätzlichen Qubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Barenco et. al., Elementare Gatter für Quantenberechnungen, Phys.Rev. A52 3457 (1995), arXiv:quant-ph/9503016
2. Iten et al. et al., Quantenschaltungen für Isometrien, Phys. Rev. A 93, 23.03.2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_noaux_v24(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gatters mit $k$ Steuerungen auf der Grundlage der Implementierung für MCPhaseGate.

Das MCPhase-Gate wiederum verwendet die unter [1.] beschriebene Zerlegung für mehrfach kontrollierte Spezialeinheiten.

Erzeugt einen Quantenschaltkreis mit $k + 1$ Qubits. Die Anzahl der CX-Tore ist quadratisch in $k$.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Vale et. al., Circuit Decomposition of Multicontrolled Special Unitary Single-Qubit Gates, IEEE TCAD 43(3) (2024), arXiv:2302.06377

qiskit.synthesis.synth_mcx_noaux_hp24(num_ctrl_qubits)

Synthese eines mehrfach gesteuerten X-Gatters mit $k$ Steuerungen auf der Grundlage der Arbeit von Huang und Palsberg.

Erzeugt einen Quantenschaltkreis mit $k + 1$ Qubits. Die Anzahl der CX-Tore ist linear zu $k$.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Rückgabe

Die synthetisierte Quantenschaltung.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabetyp

QuantumCircuit

Referenzen

1. Huang und Palsberg, Compiling Conditional Quantum Gates without Using Helper Qubits, PLDI (2024), <https://dl.acm.org/doi/10.1145/3656436> `_

qiskit.synthesis.synth_mcx_gray_code(num_ctrl_qubits)

Entwickeln Sie ein X-Gatter mit mehreren Eingängen und einer Steuerung nach dem Prinzip $k\ge 3$ unter Verwendung des Gray-Codes.

Erzeugt einen Quantenschaltkreis mit $k + 1$ en Qubits. Diese Methode erzeugt exponentiell viele CX-Gatter und sollte nur für kleine Werte von $k$ verwendet werden. Bei $k\le 2$ besteht die zurückgegebene Schaltung aus einem einzelnen X-, CX- oder CCX-Gatter (entsprechend $k = 0, 1, 2$) und verwendet keine Zusatzqubits.

Parameter

num_ctrl_qubits (int) – Die Anzahl der Kontrollqubits.

Erhöht

QiskitError – wenn num_ctrl_qubits unzulässig ist.

Rückgabe

Die synthetisierte Quantenschaltung.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_c3x()

Effiziente Synthese von 3-kontrollierten X-Gates.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_c4x()

Effiziente Synthese von 4 gesteuerten X-Gates.

Rückgabetyp

QuantumCircuit

qiskit.synthesis.adder_qft_d00(num_state_qubits, kind='half', annotated=False)

Eine Schaltung, die QFT verwendet, um die Addition von zwei Qubit-Registern an Ort und Stelle durchzuführen.

Bei Registern mit $n$ -Qubits kann der QFT-Addierer eine Addition modulo $2^n$ (mit kind="fixed") oder eine gewöhnliche Addition durch Hinzufügen eines Übertrag-Qubits (mit kind="half") durchführen. Der Festkomma-Addierer verwendet die Operatoren „ $(3n^2 - n)/2$CPhaseGate “, wobei für den Halbaddierer zusätzlich „ $n$ “ zum Einsatz kommt.

Ein Beispiel für eine QFT-Addierschaltung ohne Festkomma, die zwei 2-Qubit-Register addiert, sieht wie folgt aus

 a_0: ─────────■──────■────────■──────────────────────────────────
               │      │        │
 a_1: ─────────┼──────┼────────┼────────■──────■──────────────────
      ┌──────┐ │      │        │P(π/4)  │      │P(π/2) ┌─────────┐
 b_0: ┤0     ├─┼──────┼────────■────────┼──────■───────┤0        ├
      │      │ │      │P(π/2)           │P(π)          │         │
 b_1: ┤1 Qft ├─┼──────■─────────────────■──────────────┤1 qft_dg ├
      │      │ │P(π)                                   │         │
cout: ┤2     ├─■───────────────────────────────────────┤2        ├
      └──────┘                                         └─────────┘

Parameter

• num_state_qubits (int) – Die Anzahl der Qubits in einem der beiden Eingangsregister für den Zustand $|a\rangle$ oder $|b\rangle$. Die beiden Eingangsregister müssen die gleiche Anzahl von Qubits haben.
• kind (str) – Die Art des Addierers kann "half" für einen Halbaddierer oder "fixed" für einen Addierer fester Größe sein. Ein halber Addierer enthält einen Übertrag, um das höchstwertige Bit darzustellen, aber der Addierer mit fester Größe hat keinen Übertrag und führt daher die Addition modulo 2 ** num_state_qubits durch.
• annotated (bool) – Wenn True, werden die entsprechenden Kontroll- und Umkehroperationen als AnnotatedOperation Objekte erstellt.

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] T. G. Draper, Addition auf einem Quantencomputer, 2000. arXiv:quant-ph/0008033

[2] Ruiz-Perez et al, Quantenarithmetik mit der Quanten-Fourier-Transformation, 2017. arXiv:1411.5949

[3] Vedral et al., Quantennetzwerke für elementare arithmetische Operationen, 1995. arXiv:quant-ph/9511018

qiskit.synthesis.adder_ripple_c04(num_state_qubits, kind='half')

Eine Ripple-Carry-Schaltung zur Durchführung von In-Place-Addition auf zwei Qubit-Registern.

Diese Schaltung verwendet $2n + O(1)$ CCX-Gatter und $5n + O(1)$ CX-Gatter, mit einer Tiefe von $2n + O(1)$ [1]. Die Konstante hängt von der Art des implementierten Addierers ab.

Ein Beispiel für eine Ripple-Carry-Addierschaltung, die zwei 3-Qubit-Register mit einem Carry-In-Bit (kind="full") addiert, sieht wie folgt aus:

        ┌──────┐                                     ┌──────┐
 cin_0: ┤2     ├─────────────────────────────────────┤2     ├
        │      │┌──────┐                     ┌──────┐│      │
   a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐     ┌──────┐│      ││      │
   a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
        │      ││      ││      │     │      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
        │      ││      ││      │  │  │      ││      ││      │
   b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
        └──────┘│      ││      │  │  │      ││      │└──────┘
   b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
                └──────┘│      │  │  │      │└──────┘
   b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
                        └──────┘┌─┴─┐└──────┘
cout_0: ────────────────────────┤ X ├────────────────────────
                                └───┘

Die MAJ- und UMA-Tore entsprechen den unter [1]. vorgestellten Toren. Beachten Sie, dass in dieser Implementierung die Qubits der Eingangsregister in der Reihenfolge angeordnet sind, dass alle Qubits aus dem ersten Eingangsregister, gefolgt von allen Qubits aus dem zweiten Eingangsregister kommen.

Es werden zwei verschiedene Arten von Addierern unterstützt. Mit dem Argument kind können Sie auch einen Halbaddierer wählen, der keinen Übertrag hat, und einen Festgrößenaddierer, der weder Übertrag noch Übertrag hat und daher auf feste Registergrößen wirkt. Anders als die Volladdierer benötigen diese Schaltungen ein zusätzliches Hilfsqubit.

Der Schaltplan für den Festkomma-Addierer (kind="fixed") mit 3-Qubit großen Eingängen lautet

        ┌──────┐┌──────┐                ┌──────┐┌──────┐
   a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐┌──────┐│      ││      │
   a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
        │      ││      ││      ││      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
        │      ││      ││      ││      ││      ││      │
   b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
        │      ││      ││      ││      ││      ││      │
   b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
        │      │└──────┘│      ││      │└──────┘│      │
   b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
        │      │        └──────┘└──────┘        │      │
help_0: ┤2     ├────────────────────────────────┤2     ├
        └──────┘                                └──────┘

Er hat ein Qubit weniger als der Full-Adder, da er keinen Carry-Out hat, aber statt des Carry-In ein Helper-Qubit verwendet, so dass er nur ein Qubit weniger hat, nicht zwei.

Parameter

• num_state_qubits (int) – Die Anzahl der Qubits in einem der beiden Eingangsregister für den Zustand $|a\rangle$ oder $|b\rangle$. Die beiden Eingangsregister müssen die gleiche Anzahl von Qubits haben.
• kind (str) – Die Art des Addierers kann "full" für einen Volladdierer, "half" für einen Halbaddierer oder "fixed" für einen Addierer fester Größe sein. Ein Volladdierer enthält sowohl Übertrag als auch Übertrag, ein Halbaddierer nur Übertrag, und ein Addierer fester Größe weder Übertrag noch Übertrag.

Erhöht

ValueError - Wenn num_state_qubits kleiner als 1 ist.

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Cuccaro et al, Eine neue Quanten-Ripple-Carry-Additionsschaltung, 2004. arXiv:quant-ph/0410184

[2] Vedral et al., Quantennetzwerke für elementare arithmetische Operationen, 1995. arXiv:quant-ph/9511018

qiskit.synthesis.adder_ripple_v95(num_state_qubits, kind='half')

Der VBE-Ripple-Carry-Addierer [1].

Bei dieser Methode werden $4n + O(1)$ CCX-Gatter und $4n + 1$ CX-Gatter mit einer Tiefe von $6n - 2$ [2] verwendet.

Diese Schaltung führt eine Inplace-Addition zweier gleich großer Quantenregister durch. Ein Beispiel für eine klassische Addierschaltung, die eine vollständige Addition (d. h. einschließlich eines Übertragsbits) auf zwei 2-Qubit-Registern durchführt, sieht wie folgt aus:

          ┌────────┐                       ┌───────────┐┌──────┐
   cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
          │        │                       │           ││      │
     a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
          │        │┌────────┐     ┌──────┐│           ││  Sum │
     a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
          │        ││        │  │  │      ││           ││      │
     b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
          │        ││        │┌─┴─┐│      ││           │└──────┘
     b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
          │        ││        │└───┘│      ││           │
  cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
          │        ││        │     │      ││           │
helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
          └────────┘└────────┘     └──────┘└───────────┘

Hier entsprechen die Carry- und Sum-Gates den in [1.] eingeführten Gates. Carry_dg entsprechen der Umkehrung des Carry-Gatters. Beachten Sie, dass in dieser Implementierung die Qubits der Eingangsregister in der Reihenfolge angeordnet sind, dass alle Qubits aus dem ersten Eingangsregister, gefolgt von allen Qubits aus dem zweiten Eingangsregister kommen. Dies ist eine andere Anordnung als in Abbildung 2 in [1], was zu einer anderen Zeichnung der Schaltung führt.

Parameter

• num_state_qubits (int) – Die Größe des Registers.
• kind (str) – Die Art des Addierers kann "full" für einen Volladdierer, "half" für einen Halbaddierer oder "fixed" für einen Addierer fester Größe sein. Ein Volladdierer enthält sowohl Übertrag als auch Übertrag, ein Halbaddierer nur Übertrag, und ein Addierer fester Größe weder Übertrag noch Übertrag.

Erhöht

ValueError - Wenn num_state_qubits kleiner als 1 ist.

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Vedral et al, Quantennetzwerke für elementare arithmetische Operationen, 1995. arXiv:quant-ph/9511018

[2] Cuccaro et al., Eine neue Quanten-Ripple-Carry-Additionsschaltung, 2004. arXiv:quant-ph/0410184

qiskit.synthesis.adder_ripple_r25(num_qubits)

Der RV-Ripple-Carry-Addierer [1]. Konstruieren Sie eine ancillafreie Quantenaddiererschaltung mit sublinearer Tiefe auf der Grundlage des in [1] dargestellten RV-Ripple-Carry-Addierers. Die Implementierung hat eine Tiefe von $O(\log^2 n)$ und verwendet math:O(n log n) Gatter.

Ein Beispiel für eine Ripple-Carry-Addierer-Schaltung, die zwei 4-Qubit-Register addiert, sieht wie folgt aus:

                               ┌───────────┐                    ┌────────┐
 a_0: ─────────────────────────┤0          ├────────────────────┤0       ├───────────────■─────────────────
                     ┌────────┐│           │                    │        │┌───────────┐  │
 a_1: ──■────────────┤0       ├┤2          ├──■─────────────────┤2       ├┤0          ├──┼────■────────────
        │            │        ││           │  │                 │        ││           │  │    │
 a_2: ──┼────■───────┤1       ├┤4          ├──┼────■────────────┤4       ├┤1 LAD_1_dg ├──┼────┼────■───────
        │    │       │        ││           │  │    │            │        ││           │  │    │    │
 a_3: ──┼────┼────■──┤2       ├┤6          ├──┼────┼────■───────┤6 LAD_2 ├┤2          ├──┼────┼────┼────■──
        │    │    │  │        ││           │  │    │    │       │        │└───────────┘┌─┴─┐  │    │    │
 b_0: ──┼────┼────┼──┤        ├┤1 LAD_2_dg ├──┼────┼────┼───────┤1       ├─────────────┤ X ├──┼────┼────┼──
      ┌─┴─┐  │    │  │  LAD_1 ││           │┌─┴─┐  │    │  ┌───┐│        │    ┌───┐    └───┘┌─┴─┐  │    │
 b_1: ┤ X ├──┼────┼──┤        ├┤3          ├┤ X ├──┼────┼──┤ X ├┤3       ├────┤ X ├─────────┤ X ├──┼────┼──
      └───┘┌─┴─┐  │  │        ││           │└───┘┌─┴─┐  │  ├───┤│        │    ├───┤         └───┘┌─┴─┐  │
 b_2: ─────┤ X ├──┼──┤        ├┤5          ├─────┤ X ├──┼──┤ X ├┤5       ├────┤ X ├──────────────┤ X ├──┼──
           └───┘┌─┴─┐│        ││           │     └───┘┌─┴─┐└───┘└────────┘    └───┘              └───┘┌─┴─┐
 b_3: ──────────┤ X ├┤        ├┤7          ├──────────┤ X ├───────────────────────────────────────────┤ X ├
                └───┘│        ││           │          └───┘                                           └───┘
cout: ───────────────┤3       ├┤8          ├───────────────────────────────────────────────────────────────
                     └────────┘└───────────┘

Hier LAD_1 und LAD_2 die in [1] eingeführten CX- bzw. CCX-Leiter. Beachten Sie, dass in dieser Implementierung die Qubits der Eingangsregister in der Reihenfolge angeordnet sind, dass alle Qubits aus dem ersten Eingangsregister, gefolgt von allen Qubits aus dem zweiten Eingangsregister kommen.

Parameter

num_qubits (int) – Die Größe des Registers.

Rückgabe

Die Quantenschaltung zur Implementierung des RV-Ripple-Carry-Addierers.

Erhöht

ValueError - Wenn num_qubits kleiner als 1 ist.

Rückgabetyp

QuantumCircuit

Quellenangaben:

1. Remaud und Vandaele, Ancilla-freier Quantenaddierer mit sublinearer Tiefe, 2025. arXiv:2501.16802

qiskit.synthesis.adder_modular_v17(num_qubits)

Konstruieren Sie eine modulare Addierschaltung ohne zusätzliche Qubits auf der Grundlage des Van-Rentergem-Addierers in Abb. 15 von [1]. Die Implementierung verwendet höchstens $16k - 13$ CX-Gatter für einen Addierer mit k Qubits in jedem Register, wobei k = num_qubits.

Parameter

num_qubits (int) – Die Größe des Registers.

Rückgabe

Die Quantenschaltung zur Implementierung des modularen Addierers.

Erhöht

ValueError - Wenn num_qubits kleiner als 1 ist.

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Gidney, Factoring with n+2 clean qubits and n-1 dirty qubits, 2017. arxiv:1706.07884

qiskit.synthesis.multiplier_cumulative_h18(num_state_qubits, num_result_qubits=None)

Eine Multiplikationsschaltung zur Speicherung des Produkts zweier Eingangsregister an einer anderen Stelle.

Die Schaltung verwendet den Ansatz aus Ref. [1]. Ein Beispiel ist eine Multiplikatorschaltung, die eine nicht-modulare Multiplikation mit zwei 3-Qubit-Registern ausführt:

from qiskit.synthesis.arithmetic import multiplier_cumulative_h18

num_state_qubits = 3
circuit = multiplier_cumulative_h18(num_state_qubits)
circuit.draw("mpl")

Die Multiplikation in dieser Schaltung wird in einem klassischen Ansatz durch eine Reihe von verschobenen Additionen unter Verwendung eines der Eingangsregister durchgeführt, während die Qubits aus dem anderen Eingangsregister als Steuer-Qubits für die Addierer dienen.

Parameter

• num_state_qubits (int) – Die Anzahl der Qubits in einem der beiden Eingangsregister für den Zustand $|a\rangle$ oder $|b\rangle$. Die beiden Eingangsregister müssen die gleiche Anzahl von Qubits haben.
• num_result_qubits (int | None) – Die Anzahl der Ergebnis-Qubits, auf die die Ausgabe beschränkt werden soll. Wenn die Anzahl der Ergebnis-Qubits $n$ ist, wird die Multiplikation modulo $2^n$ durchgeführt, um die Ausgabe auf die angegebene Anzahl von Qubits zu begrenzen. Der Standardwert ist 2 * num_state_qubits , um jedes mögliche Ergebnis der Multiplikation der beiden Eingänge darzustellen.

Erhöht

ValueError - Wenn num_result_qubits angegeben wird und nicht gültig ist, d.h. nicht in [num_state_qubits, 2 * num_state_qubits].

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Häner et al., Optimierung von Quantenschaltungen für die Arithmetik, 2018. arXiv:1805.12445

qiskit.synthesis.multiplier_qft_r17(num_state_qubits, num_result_qubits=None)

Eine QFT-Multiplikationsschaltung zur Speicherung des Produkts zweier Eingangsregister an einer anderen Stelle.

Die Multiplikation in dieser Schaltung erfolgt nach dem Verfahren von Abb. 3 in [1], wobei die gewichteten Summenrotationen wie in Abb. 5 in [1] dargestellt implementiert werden. QFT wird auf das Ausgangsregister angewandt, gefolgt von Drehungen, die von den Eingangsregistern gesteuert werden. Die Drehungen wandeln den Zustand in das Produkt zweier Eingangsregister in QFT-Basis um, das mittels inverser QFT aus der QFT-Basis zurückgeführt wird. Bei 3 Zustands-Qubits ist ein vollständiger Multiplikator zum Beispiel gegeben durch:

from qiskit.synthesis.arithmetic import multiplier_qft_r17

num_state_qubits = 3
circuit = multiplier_qft_r17(num_state_qubits)
circuit.draw("mpl")

Parameter

• num_state_qubits (int) – Die Anzahl der Qubits in einem der beiden Eingangsregister für den Zustand $|a\rangle$ oder $|b\rangle$. Die beiden Eingangsregister müssen die gleiche Anzahl von Qubits haben.
• num_result_qubits (int | None) – Die Anzahl der Ergebnis-Qubits, auf die die Ausgabe beschränkt werden soll. Wenn die Anzahl der Ergebnis-Qubits $n$ ist, wird die Multiplikation modulo $2^n$ durchgeführt, um die Ausgabe auf die angegebene Anzahl von Qubits zu begrenzen. Der Standardwert ist 2 * num_state_qubits , um jedes mögliche Ergebnis der Multiplikation der beiden Eingänge darzustellen.

Erhöht

ValueError - Wenn num_result_qubits angegeben wird und nicht gültig ist, d.h. nicht in [num_state_qubits, 2 * num_state_qubits].

Rückgabetyp

QuantumCircuit

Quellenangaben:

[1] Ruiz-Perez et al, Quantenarithmetik mit der Quanten-Fourier-Transformation, 2017. arXiv:1411.5949

qiskit.synthesis.synth_weighted_sum_carry(weighted_sum)

Synthetisieren Sie ein gewichtetes Summengatter anhand der Anzahl der Zustands-Qubits und der Qubit-Gewichte.

Diese Methode ist in Anhang A von [1] beschrieben.

Referenz:

[1] Stamatopoulos et al. Optionspreisgestaltung mit Quantencomputern (2020)

Quantum 4, 291

Parameter

weighted_sum (WeightedSumGate)

Rückgabetyp

QuantumCircuit

qiskit.synthesis.synth_integer_comparator_2s(num_state_qubits, value, geq=True)

Implementieren Sie einen Integer-Vergleich auf der Grundlage des 2s -Komplements.

Dies basiert auf Anhang B von [1.]

Parameter

• num_state_qubits (int) – Die Anzahl der Qubits, die den Wert kodieren, mit dem verglichen werden soll.
• value (int) – Der Wert, mit dem verglichen werden soll.
• geq (bool) – Bei True wird das Zielbit umgedreht, wenn der Zustand des Qubits $\geq$ größer als der Wert ist, andernfalls wird $<$ implementiert.

Rückgabe

Eine Schaltung, die den Integer-Komparator implementiert.

Rückgabetyp

QuantumCircuit

Referenzen

[1] J. Gacon et al. "Quantengestützte simulationsbasierte Optimierung"

arXiv:2005.10780.

qiskit.synthesis.synth_integer_comparator_greedy(num_state_qubits, value, geq=True)

Implementierung eines Integer-Vergleichs auf der Grundlage eines Wert-für-Wert-Vergleichs.

Für value kleiner als 2 ** (num_state_qubits - 1) implementiert diese Schaltung value mehrfach gesteuerte Gatter mit den Steuerzuständen 0, 1,..., value - 1, so dass das Ziel-Qubit umgedreht wird, wenn der Zustand des Qubits einen der erlaubten Werte darstellt. Für value , die größer ist als diese, wird geq umgedreht. Diese Implementierung kann eine exponentielle Anzahl von Gattern erfordern. Wenn Hilfsqubits zur Verfügung stehen, ist die Implementierung, die von synth_integer_comparator_2s() ist effizienter.

Parameter

• num_state_qubits (int) – Die Anzahl der Qubits, die den Wert kodieren, mit dem verglichen werden soll.
• value (int) – Der Wert, mit dem verglichen werden soll.
• geq (bool) – Bei True wird das Zielbit umgedreht, wenn der Zustand des Qubits $\geq$ größer als der Wert ist, andernfalls wird $<$ implementiert.

Rückgabe

Eine Schaltung, die den Integer-Komparator implementiert.

Rückgabetyp

QuantumCircuit