Synthèse de circuits

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

Synthétiser des circuits linéaires réversibles pour l'architecture all-to-all en utilisant les méthodes de Patel, Markov et Hayes.

Cette fonction est une implémentation de l'algorithme de Patel, Markov et Hayes de [1] pour la synthèse optimale de circuits linéaires réversibles pour une architecture "all-to-all", comme spécifié par une matrice $n \times n$.

Paramètres

• state (list[list[bool]] | ndarray[bool]) – $n \times n$ matrice booléenne inversible, décrivant l'état du circuit d'entrée.
• section_size (int | None) – La taille de chaque section dans l'algorithme de Patel-Markov-Hayes [1]. Si None , il est choisi d'être $\max(2, \alpha\log_2(n))$ avec $\alpha = 0.56$, ce qui minimise approximativement la limite supérieure du nombre d'opérations sur les lignes donnée dans [1] Eq. (3).

Retours

Un circuit CX seul mettant en œuvre la transformation linéaire.

Augmentations

ValueError - Lorsque section_size est plus grand que le nombre de colonnes.

Type de retour

QuantumCircuit

Références

1. Patel, Ketan N., Igor L. Markov, et 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)

Synthèse d'un circuit linéaire réversible pour les architectures linéaires à plus proche voisin en utilisant la méthode Kutin, Moulton, Smithline.

Algorithme de synthèse pour les circuits linéaires réversibles du point [1], section 7. Cet algorithme synthétise tout circuit linéaire réversible de $n$ qubits sur une architecture linéaire à plus proche voisin en utilisant des portes CX d'une profondeur maximale de $5n$.

Paramètres

mat (ndarray[bool]) – Une matrice booléenne inversable.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError - si mat n'est pas inversible.

Type de retour

QuantumCircuit

Références

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

qiskit.synthesis.synth_cz_depth_line_mr(mat)

Synthèse d'un circuit CZ pour la connectivité du plus proche voisin linéaire (LNN), basée sur Maslov et Roetteler.

CXGateNotez que cette méthode inverse l'ordre des qubits dans le circuit et renvoie un circuit contenant des portes de phase et des portes s (SGate, SdgGate ou ZGate).

Paramètres

mat (ndarray) – une matrice carrée de type booléen, à diagonale supérieure, représentant le circuit CZ. mat[i][j]=1 for i<j représente une cz(i,j) porte. Seul le triangle supérieur est pris en compte; la diagonale et le triangle inférieur n'ont aucun effet.

Retours

Implémentation du circuit CZ de profondeur $2n+2$ pour la connectivité LNN.

Type de retour

QuantumCircuit

Références

1. Dmitri Maslov, Martin Roetteler, Circuits stabilisateurs plus courts via la décomposition de Bruhat et les transformations de circuits quantiques, arXiv:1705.09176.

qiskit.synthesis.synth_cx_cz_depth_line_my(mat_x, mat_z)

Synthèse conjointe d'un circuit -CZ-CX- pour la connectivité linéaire du plus proche voisin (LNN), avec une profondeur de 2 qubits au maximum 5n, basée sur Maslov et Yang. Cette méthode calcule le circuit CZ à l'intérieur du circuit CX via des insertions de portes de phase.

Paramètres

• mat_z (ndarray) – une matrice booléenne symétrique représentant un circuit CZ. mat_z[i][j]=1 représente une porte cz(i,j)
• mat_x (ndarray) – une matrice booléenne inversable représentant un circuit CX.

Retours

Implémentation d'un circuit CX suivant un circuit CZ, dénommé circuit -CZ-CX-, d'une profondeur de deux qubits au plus égale à 5n, pour une connectivité LNN.

Type de retour

QuantumCircuit

Références

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, Les circuits CNOT ont besoin de peu d'aide pour mettre en œuvre les transformations de Clifford arbitraires sans Hadamard qu'ils génèrent, arXiv:2210.16195.

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

Cette fonction est une implémentation de l'algorithme GraySynth d'Amy, Azimadeh et Mosca.

GraySynth est un algorithme heuristique issu de [[1]] permettant de synthétiser de petits réseaux de parité. Il s'inspire des codes de Gray. À partir d'un ensemble de chaînes binaires $S$ (appelées cnots ci-dessous), l'algorithme synthétise un réseau de parité pour $S$ en choisissant de manière répétée un indice $i$ à développer, puis en effectuant une récursion sur les cofacteurs $S_0$ et $S_1$, constitués respectivement des chaînes $y \in S$, avec $y_i = 0$ ou $1$. Au fur et à mesure que l'ensemble partiel $S$ est développé de manière récursive, cx des portes logiques sont appliquées de telle sorte qu'un bit cible désigné contienne l' $\chi_y(x)$ de parité (partielle) où $y_i = 1$ si et seulement si $y'_i = 1$ pour tout $y' \in S$. Si $S$ contient un seul élément $\{y'\}$, alors $y = y'$, et le bit cible contient la valeur $\chi_{y'}(x)$ comme souhaité.

Notamment, au lieu de décompter cette séquence de portes cx (CNOT) lorsqu'un sous-ensemble $S$ a fini d'être synthétisé, l'algorithme maintient l'invariant selon lequel les parités restantes à calculer sont exprimées sur l'état actuel des bits. Cela permet à l'algorithme d'éviter le "retour en arrière" inhérent aux méthodes non basées sur le calcul.

L'algorithme est décrit en détail dans la section 4. [1].

Paramètres

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

  Une matrice dont les colonnes sont les parités à synthétiser 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]]

  correspond à :

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

• angles (list[str]) – Une liste contenant toutes les portes de déphasage à appliquer, dans le même ordre que dans cnots. Un nombre est interprété comme l'angle de $p(angle)$, sinon les éléments doivent être 't', 'tdg', 's', 'sdg' ou 'z'.

• section_size (int) – La taille de chaque section dans l'algorithme Patel-Markov-Hayes. section_size doit être un facteur du nombre de qubits.

Retours

Le circuit quantique décomposé.

Augmentations

QiskitError - lorsque les dimensions de cnots et angles ne sont pas alignées.

Type de retour

QuantumCircuit

Références

1. Matthew Amy, Parsiad Azimzadeh et Michele Mosca. Sur la complexité contrôlée-NOT des circuits contrôlés-NOT-phase.., Quantum Science and Technology 4.1 (2018) : 015002. arXiv:1712.01859

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)

Synthétiser un circuit de permutation pour une architecture linéaire à plus proche voisin en utilisant la méthode Kutin, Moulton, Smithline.

Il s'agit de l'algorithme de synthèse des permutations du point [1], section 6. Il synthétise n'importe quelle permutation de n qubits sur une architecture linéaire du plus proche voisin à l'aide de portes SWAP d'une profondeur maximale de $n$ et d'une taille maximale de $n(n-1)/2$ (la profondeur et la taille étant mesurées par rapport aux portes SWAP).

Paramètres

pattern (list[int] | ndarray[int]) – Modèle de permutation, décrivant quels qubits occupent les positions 0, 1, 2, etc. après application de la permutation. C'est-à-dire, pattern[k] = m lorsque la permutation mappe le qubit m à la position k. À titre d'exemple, le motif [2, 4, 3, 0, 1] signifie que le qubit 2 va à la position 0, le qubit 4 va à la position 1, etc.

Retours

Le circuit quantique synthétisé.

Type de retour

QuantumCircuit

Références

1. Samuel A. Kutin, David Petrie Moulton et Lawren M. Smithline. Le calcul à distance, arXiv:quant-ph/0701194v1

qiskit.synthesis.synth_permutation_basic(pattern)

Synthétiser un circuit de permutation pour une architecture entièrement connectée en utilisant le tri.

Plus précisément, si la permutation d'entrée est un cycle de longueur m, cela crée un circuit quantique avec m-1 SWAPs (et de profondeur m-1); si la permutation d'entrée consiste en plusieurs cycles disjoints, chaque cycle est essentiellement traité indépendamment.

Paramètres

pattern (list[int] | ndarray[int]) – Modèle de permutation, décrivant quels qubits occupent les positions 0, 1, 2, etc. après application de la permutation. C'est-à-dire, pattern[k] = m lorsque la permutation mappe le qubit m à la position k. À titre d'exemple, le motif [2, 4, 3, 0, 1] signifie que le qubit 2 va à la position 0, le qubit 4 va à la position 1, etc.

Retours

Le circuit quantique synthétisé.

Type de retour

QuantumCircuit

qiskit.synthesis.synth_permutation_acg(pattern)

Synthétiser un circuit de permutation pour une architecture entièrement connectée en utilisant la méthode Alon, Chung, Graham.

On obtient ainsi un circuit quantique de profondeur 2 (mesuré en nombre de SWAP).

Cette implémentation est basée sur la proposition 4.1 dans la référence [1] avec la preuve détaillée donnée dans le théorème 2 dans la référence [2]

Paramètres

pattern (list[int] | ndarray[int]) – Modèle de permutation, décrivant quels qubits occupent les positions 0, 1, 2, etc. après application de la permutation. C'est-à-dire, pattern[k] = m lorsque la permutation mappe le qubit m à la position k. À titre d'exemple, le motif [2, 4, 3, 0, 1] signifie que le qubit 2 va à la position 0, le qubit 4 va à la position 1, etc.

Retours

Le circuit quantique synthétisé.

Type de retour

QuantumCircuit

Références

1. Virginie Alon, F. R. K. Chung et R. L. Graham. Routing Permutations on Graphs Via Matchings, Actes du vingt-cinquième symposium annuel de l'ACM sur la théorie de l'informatique (1993). Pages 583-591. (Résumé étendu) 10.1145/167088.167239
2. Virginie Alon, F. R. K. Chung et R. L. Graham. Routing Permutations on Graphs Via Matchings, (Article complet)

qiskit.synthesis.synth_permutation_reverse_lnn_kms(num_qubits)

Synthétiser la permutation inverse pour les architectures linéaires à plus proche voisin en utilisant la méthode Kutin, Moulton, Smithline.

Algorithme de synthèse pour la permutation inverse du point [1], section 5. Cet algorithme synthétise la permutation inverse sur $n$ qubits sur une architecture linéaire à plus proche voisin en utilisant des portes CX de profondeur $2 * n + 2$.

Paramètres

num_qubits (int) – Le nombre de qubits.

Retours

Le circuit quantique synthétisé.

Type de retour

QuantumCircuit

Références

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

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

Décomposer un Clifford opérateur en un QuantumCircuit.

Pour $N \leq 3$ qubits, cela est basé sur la décomposition optimale des coûts CX de la référence [1.] Pour $N > 3$ qubits, cette opération est réalisée à l'aide de la routine générale de compilation non optimale de la référence [3], qui permet généralement d'obtenir un meilleur coût CX que la méthode AG de la référence [2.]

Paramètres

• clifford (Clifford) – Un opérateur de Clifford.
• method (str | None) – une méthode de synthèse ('AG' ou 'greedy'). Si cette option est activée, elle remplace la décomposition optimale pour les qubits de type « $N \leq 3$ ».

Retours

Un circuit de mise en œuvre de la méthode de Clifford.

Type de retour

QuantumCircuit

Références

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)

Décomposer un Clifford opérateur en un QuantumCircuit selon la méthode d'Aaronson-Gottesman [n° 1].

Paramètres

clifford (Clifford) – Un opérateur de Clifford.

Retours

Un circuit de mise en œuvre de la méthode de Clifford.

Type de retour

QuantumCircuit

Références

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)

Décomposition optimale du coût CX d'un Clifford opérateur sur 2 ou 3 qubits en un opérateur QuantumCircuit basé sur la méthode de Bravyi-Maslov [1].

Paramètres

clifford (Clifford) – Un opérateur de Clifford.

Retours

Un circuit de mise en œuvre de la méthode de Clifford.

Augmentations

QiskitError - si Clifford est sur plus de 3 qubits.

Type de retour

QuantumCircuit

Références

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)

Décomposer un Clifford opérateur en un QuantumCircuit à l'aide du compilateur de Clifford « glouton » décrit dans l'annexe A de l'ouvrage de Bravyi, Hu, Maslov et Shaydulin [1].

Cette méthode permet généralement d'obtenir un meilleur coût CX que la méthode Aaronson-Gottesman.

Notez que cette fonction n'implémente que le compilateur de Clifford gourmand de l'annexe A du [document 1], et non les optimisations des modèles et des portes de Pauli symboliques qui sont mentionnées dans le même document.

Paramètres

clifford (Clifford) – Un opérateur de Clifford.

Retours

Un circuit de mise en œuvre de la méthode de Clifford.

Augmentations

QiskitError - si l'élimination gaussienne symplectique échoue.

Type de retour

QuantumCircuit

Références

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)

La synthèse de a Clifford en couches fournit une décomposition similaire à celle décrite dans le lemme 8 de Bravyi et Maslov [1].

Par exemple, un circuit de Clifford à 5 qubits est décomposé dans les couches suivantes :

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

Cette décomposition concerne les fonctions par défaut cz_synth_func et cx_synth_func . Avec d'autres fonctions, la décomposition peut être légèrement différente.

Paramètres

• cliff (Clifford) – Un opérateur de Clifford.
• cx_synth_func (Callable[[ndarray], QuantumCircuit]) – Une fonction permettant de décomposer le sous-circuit CX. Il reçoit en entrée une matrice booléenne inversible et renvoie une QuantumCircuit.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Une fonction pour décomposer le sous-circuit CZ. Il reçoit en entrée une matrice symétrique booléenne, et produit un QuantumCircuit.
• cx_cz_synth_func (Callable) – optionnel, une fonction permettant de décomposer les deux sous-circuits CZ et CX.
• validate (Boolean) – si True, valide le processus de synthèse.
• cz_func_reverse_qubits (Boolean) – Vrai seulement si cz_synth_func est synth_cz_depth_line_mr()puisque cette fonction renvoie un circuit qui inverse l'ordre des qubits.

Retours

Un circuit de mise en œuvre de la méthode de Clifford.

Type de retour

QuantumCircuit

Références

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)

Synthèse d'un Clifford en couches pour une connectivité linéaire par le plus proche voisin.

La profondeur du circuit n-qubit synthétisé est limitée par $7n+2$, ce qui n'est pas optimal. Il devrait être remplacé par un meilleur algorithme qui fournit une profondeur limitée par $7n-4$ [3].

Paramètres

cliff (Clifford) – un opérateur de Clifford.

Retours

un circuit de mise en œuvre du Clifford.

Type de retour

QuantumCircuit

Références

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, Circuits stabilisateurs plus courts via la décomposition de Bruhat et les transformations de circuits quantiques, arXiv:1705.09176.
3. Dmitri Maslov, Willers Yang, Les circuits CNOT ont besoin de peu d'aide pour mettre en œuvre les transformations de Clifford arbitraires sans Hadamard qu'ils génèrent, arXiv:2210.16195.

qiskit.synthesis.synth_cnotdihedral_full(elem)

Décomposer un CNOTDihedral élément en un QuantumCircuit.

Pour $N \leq 2$ qubits, cela est basé sur la décomposition optimale des coûts CX de la référence [1.] Pour les qubits $N > 2$, cette opération est réalisée à l'aide de la routine de compilation générale non optimale de la référence [2.]

Paramètres

elem (CNOTDihedral) – Un CNOTDihedral élément.

Retours

Une implémentation sous forme de circuit de CNOTDihedral l'élément.

Type de retour

QuantumCircuit

Références

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

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)

Décomposer un CNOTDihedral élément sur un qubit unique et sur deux qubits en un QuantumCircuit. Cette décomposition présente un nombre optimal de CXGates.

Paramètres

elem (CNOTDihedral) – Un CNOTDihedral élément.

Retours

Une implémentation sous forme de circuit de CNOTDihedral l'élément.

Augmentations

CNOTDihedralQiskitError – si l'élément n'est pas un qubit à 1 ou à 2.

Type de retour

QuantumCircuit

Références

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

qiskit.synthesis.synth_cnotdihedral_general(elem)

Décomposer un CNOTDihedral élément en un QuantumCircuit.

Décomposer un élément général CNOTDihedral en éléments. Le nombre de portes CX n'est pas forcément optimal. Pour obtenir la décomposition d'un élément à 1 ou 2 qubits, appelez synth_cnotdihedral_two_qubits().

Paramètres

elem (CNOTDihedral) – Un CNOTDihedral élément.

Retours

Une implémentation sous forme de circuit de CNOTDihedral l'élément.

Augmentations

QiskitError - si l'élément n'a pas pu être décomposé en circuit.

Type de retour

QuantumCircuit

Références

1. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin et 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)

Synthèse d'un état stabilisateur en couches.

Elle fournit une décomposition similaire à la synthèse décrite dans le lemme 8 de la référence [1], sans le sous-circuit initial sans Hadamard qui n'affecte pas l'état du stabilisateur.

Par exemple, un état stabilisateur à 5 qubits est décomposé dans les couches suivantes :

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

Paramètres

• stab (StabilizerState) – Un état stabilisateur.
• cz_synth_func (Callable[[ndarray], QuantumCircuit]) – Une fonction pour décomposer le sous-circuit CZ. Il reçoit en entrée une matrice symétrique booléenne, et produit un QuantumCircuit.
• cz_func_reverse_qubits (bool) – True uniquement si cz_synth_func est synth_cz_depth_line_mr()puisque cette fonction renvoie un circuit qui inverse l'ordre des qubits.
• validate (bool) – Si True, valide le processus de synthèse.

Retours

Un circuit de mise en œuvre de l'état stabilisateur.

Augmentations

QiskitError – si l'entrée n'est pas un fichier StabilizerState.

Type de retour

QuantumCircuit

Références

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)

Synthèse d’un état stabilisateur à n qubits pour une connectivité linéaire entre voisins les plus proches, avec une profondeur de 2 qubits $2n+2$ et deux couches CX distinctes, à l’aide de CXGateportes s et de portes de phase (SGate, SdgGate ou ZGate).

Paramètres

stab (StabilizerState) – Un état stabilisateur.

Retours

Un circuit de mise en œuvre de l'état stabilisateur.

Type de retour

QuantumCircuit

Références

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, Circuits stabilisateurs plus courts via la décomposition de Bruhat et les transformations de circuits quantiques, arXiv:1705.09176.

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

Synthèse d'un circuit qui génère un état stabilisé par les stabilisateurs en utilisant l'élimination gaussienne avec des portes de Clifford. Si les stabilisateurs sont sous-contraints et que allow_underconstrained est True, le circuit produira l'un des états stabilisés par les stabilisateurs. Sur la base d'une mise en œuvre stim.

Paramètres

• stabilizers (Collection[str]) – Liste des cordes stabilisatrices
• allow_redundant (bool) – Autoriser les stabilisateurs redondants (c'est-à-dire que certains stabilisateurs peuvent être des produits d'autres stabilisateurs)
• allow_underconstrained (bool) – Autoriser un ensemble de stabilisateurs sous-contraints (c'est-à-dire que les stabilisateurs ne déterminent pas un état unique)
• invert (bool) – Retour circuit inverse

Retours

Un circuit qui génère un état stabilisé par stabilizers.

Augmentations

QiskitError - si les stabilisateurs ne sont pas valides, ne sont pas commutés ou se contredisent, si la liste est sous-contrainte et que allow_underconstrained est False, ou si la liste est redondante et que allow_redundant est False.

Type de retour

QuantumCircuit

Références

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)

Rotation RZ approximative à l'aide de l'algorithme de Ross-Selinger.

L'algorithme est décrit au point [1]. Le code source (en Rust) est disponible à l'adresse https://github.com/qiskit-community/rsgridsynth.

Paramètres

• angle (float) – Spécifie l'angle de rotation RZ.
• epsilon (float) – L'erreur d'approximation autorisée.

Retours

Circuit à un qubit approximant RZ(angle).

Type de retour

QuantumCircuit

Références :

[1] Neil J. Ross, Peter Selinger, Approximation optimale sans ancilla Clifford+T des rotations z,

arXiv:1403.2975

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

Approximer une matrice unitaire à 1 qubit à l'aide de l'algorithme de Ross-Selinger.

L'algorithme est décrit au point [1]. Le code source (en Rust) est disponible à l'adresse https://github.com/qiskit-community/rsgridsynth.

Paramètres

• matrix (ndarray) – Une matrice unitaire d' $2 imes 2$.
• epsilon (float) – L'erreur d'approximation autorisée.

Retours

Circuit à un qubit approximant matrix.

Type de retour

QuantumCircuit

Références :

[1] Neil J. Ross, Peter Selinger, Approximation optimale sans ancilla Clifford+T des rotations z,

arXiv:1403.2975

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

Génère une liste de GateSequences avec les portes de basis_gates.

Paramètres

• basis_gates (list[str |Gate]) – Les portes à partir desquelles créer les séquences de portes.
• depth (int) – La profondeur maximale des approximations.
• filename (str | None) – S'il est fourni, les approximations de base sont stockées dans ce fichier.

Retours

Liste des GateSequenceutilisant les portes dans basis_gates.

Augmentations

ValueError - Si basis_gates contient un identifiant de porte non valide.

Type de retour

liste [GateSequence]

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

Construire un circuit pour la transformée de Fourier quantique en utilisant la connectivité linéaire de voisinage.

La construction est basée sur la figure 2.b de Fowler et al. [1].

Paramètres

• num_qubits (int) – Le nombre de qubits sur lesquels agit la transformée de Fourier quantique.
• approximation_degree (int) – Le degré d'approximation (0 pour aucune approximation). Il est possible d'implémenter approximativement la QFT en ignorant les rotations en phase contrôlée dont l'angle est inférieur à un seuil. Cette question est abordée plus en détail dans https://arxiv.org/abs/quant-ph/9601018 ou https://arxiv.org/abs/quant-ph/0403071.
• do_swaps (bool) – Synthèse de l'opération "QFT" ou "QFT avec inversion".

Retours

Un circuit mettant en œuvre l'opération QFT.

Type de retour

QuantumCircuit

Références

1. A. G. Fowler, S. J. Devitt, et L. C. L. Hollenberg, Implementation of Shor's algorithm on a linear nearest neighbour qubit array, Quantum Info. Comput. 4, 4 (juillet 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)

Construire un circuit pour la transformée de Fourier quantique en utilisant la connectivité tout-à-tout.

Paramètres

• num_qubits (int) – Le nombre de qubits sur lesquels agit la transformée de Fourier quantique.
• do_swaps (bool) – Synthèse de l'opération "QFT" ou "QFT avec inversion".
• approximation_degree (int) – Le degré d'approximation (0 pour aucune approximation). Il est possible d'implémenter approximativement la QFT en ignorant les rotations en phase contrôlée dont l'angle est inférieur à un seuil. Cette question est abordée plus en détail dans https://arxiv.org/abs/quant-ph/9601018 ou https://arxiv.org/abs/quant-ph/0403071.
• insert_barriers (bool) – Si True, des barrières sont insérées pour améliorer la visualisation.
• inverse (bool) – Si True, la transformée de Fourier quantique inverse est construite.
• name (str | None) – Le nom du circuit.

Retours

Un circuit mettant en œuvre l'opération QFT.

Type de retour

QuantumCircuit

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

Décompose une matrice unitaire en portes à un ou deux qubits à l'aide de la décomposition quantique de Shannon, basée sur la décomposition en blocs ZXZ.

Cette décomposition est décrite dans Krol et Al-Ars [2] et améliore la méthode de Shende et al. [1].

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

Sans ces optimisations, le nombre de CXGates générés par la décomposition est identique à celui de la méthode non optimisée décrite au point [1] :

L' A.1 d'optimisation, qui améliore [la version 1] et est appliquée automatiquement, permet de gagner deux CXGatesecondes au lieu d'une à chaque étape de la récursion, ce qui réduit le nombre de CX de :

L' A.2 d'optimisation, comme dans le cas [n° 1], décompose les opérateurs unitaires à deux qubits en une porte diagonale et un opérateur unitaire à deux CX, ce qui réduit encore le nombre de CX de :

Étant donné que cette optimisation ne doit pas être effectuée si l'opérateur unitaire d'origine est contrôlé, elle est appliquée automatiquement, sauf si la matrice d'entrée est équivalente à un opérateur unitaire contrôlé (diagonale par blocs).

Par conséquent, le nombre de CXGates générés par la décomposition après application des deux optimisations est :

Paramètres

• mat (ndarray) – matrice unitaire à décomposer
• opt_a1 (bool | None) – Cet argument est obsolète; l'optimisation est appliquée automatiquement ( None par défaut).
• opt_a2 (bool | None) – Cet argument est obsolète; l'optimisation est appliquée automatiquement ( None par défaut).
• decomposer_1q (Callable[[ndarray], QuantumCircuit] | None) – décomposeur facultatif de type « 1Q », une instance de OneQubitEulerDecomposer. Si None, la décomposition par défaut d'un qubit est utilisée.
• decomposer_2q (Callable[[ndarray], QuantumCircuit] | None) – décomposeur facultatif de type « 2Q », une instance de TwoQubitBasisDecomposer. Dans ce cas None, on utilise la décomposition par défaut à deux qubits.

Retours

Circuit quantique décomposé.

Type de retour

QuantumCircuit

Références

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)

Il s'agit d'un cas où TwoQubitBasisDecomposer l'on utilise cx toujours comme porte KAK pour la décomposition en bases. cxVous pouvez utiliser cette fonction pour accéder rapidement aux décompositions à 2 qubits basées sur.

Paramètres

• unitary (Operator or np.ndarray) – L'unité « 4x4 » à synthétiser.
• basis_fidelity (float or None) – Si l'on considère la fidélité supposée pour les applications de CXGate.
• approximate (bool) – Si True approximativement si basis_fidelity est inférieur à 1.0.

Retours

Le circuit synthétisé de l'unité d'entrée.

Type de retour

QuantumCircuit

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

Synthétiser les MCMT à l'aide d'une chaîne en V.

Il s'agit d'une chaîne de portes CCX, utilisant des qubits auxiliaires num_ctrl_qubits - 1 .

Par exemple, une porte H à 3 contrôles et 2 cibles sera synthétisée comme suit :

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

Paramètres

• gate (Gate) – Porte de base à appliquer aux cibles.
• num_ctrl_qubits (int) – Nombre de qubits de contrôle.
• num_target_qubits (int) – Nombre de qubits cibles.
• ctrl_state (int | None) – État de contrôle facultatif sous la forme d'un nombre entier.

Retours

Le circuit synthétisé pour la porte MCMT.

Type de retour

QuantumCircuit

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

Synthétiser la porte MCMT X.

Cette méthode utilise une structure de circuit spéciale qui est efficace pour les portes X MCMT. Il ne nécessite pas de qubits auxiliaires et bénéficie de décompositions MCX efficaces.

E.g. une porte X à 3 contrôles et 3 cibles sera synthétisée comme suit :

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

Paramètres

• num_ctrl_qubits (int) – Nombre de qubits de contrôle.
• num_target_qubits (int) – Nombre de qubits cibles.
• ctrl_state (int | None) – État de contrôle facultatif sous la forme d'un nombre entier.

Retours

Le circuit synthétisé pour la porte MCMT X.

Type de retour

QuantumCircuit

qiskit.synthesis.synth_mcx_1_clean_kg24(num_ctrl_qubits)

Synthétisez une porte X à contrôles multiples avec des commandes de type « $k\ge 3$ » en utilisant des qubits auxiliaires propres de type « $1$ », afin d'obtenir un circuit comportant des portes Toffoli de type « $2k-3$ » ou des portes CX de type « $6k-6$ », ainsi qu'une profondeur de « $O(k)$ », comme décrit dans la section 5.1 de [1]. Pour l'opération « $k\le 2$ », le circuit renvoyé se compose d'une seule porte X, CX ou CCX (correspondant respectivement aux opérations « $k = 0, 1, 2$ ») et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Khattar et Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits arXiv:2407.17966

qiskit.synthesis.synth_mcx_1_dirty_kg24(num_ctrl_qubits)

Synthétisez une porte X à contrôles multiples avec des commandes de type « $k\ge 3$ » en utilisant un qubit auxiliaire «dirty» de type « $1$ », afin d'obtenir un circuit comportant des portes Toffoli de type « $4k-8$ » ou des portes CX de type « $12k-18$ », ainsi qu'une profondeur de type « $O(k)$ », comme décrit dans la section. 5.3 de [1]. Pour l'opération « $k\le 2$ », le circuit renvoyé se compose d'une seule porte X, CX ou CCX (correspondant respectivement aux opérations « $k = 0, 1, 2$ ») et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Khattar et Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_clean_kg24(num_ctrl_qubits)

Synthétiser une porte X à contrôles multiples avec des commandes de type « $k\ge 3$ » en utilisant des qubits auxiliaires propres de type « $2$ », afin d'obtenir un circuit comportant des portes Toffoli de type « $2k-3$ » ou des portes CX de type « $6k-6$ » et une profondeur de « $O(\log(k))$ », comme décrit dans la section 5.2 de [1]. Pour l'opération « $k\le 2$ », le circuit renvoyé se compose d'une seule porte X, CX ou CCX (correspondant respectivement aux opérations « $k = 0, 1, 2$ ») et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Khattar et Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits arXiv:2407.17966

qiskit.synthesis.synth_mcx_2_dirty_kg24(num_ctrl_qubits)

Synthétiser une porte X à contrôles multiples avec des commandes de type « $k\ge 3$ » en utilisant des qubits auxiliaires «dirty» de type « $2$ », afin d'obtenir un circuit comportant des portes Toffoli de type « $4k-8$ » ou des portes CX de type « $12k-18$ » et une profondeur de type « $O(\log(k))$ », comme décrit dans la section 5.4 de [1]. Pour l'opération « $k\le 2$ », le circuit renvoyé se compose d'une seule porte X, CX ou CCX (correspondant respectivement aux opérations « $k = 0, 1, 2$ ») et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Khattar et Gidney, Rise of conditionally clean ancillae for optimizing quantum circuits arXiv:2407.17966

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

Synthétiser une porte X multi-contrôlée avec $k$ contrôles sur la base de l'article d'Iten et al. [1].

Pour l'opération « $k\ge 4$ », la méthode utilise $k - 2$ qubits auxiliaires «dirty», ce qui donne un circuit comportant $2 * k - 1$ qubits et au maximum $8 * k - 6$ portes CX. Pour l' $k\le 3$ e, on utilise plutôt des circuits efficaces conçus expressément à cet effet, qui ne nécessitent aucun qubit auxiliaire.

Paramètres

• num_ctrl_qubits (int) – Le nombre de qubits de contrôle.
• relative_phase (bool) – lorsqu'elle est définie sur True, la méthode applique la porte X optimisée à commande multiple jusqu'à une phase relative, de telle sorte que, par le lemme 8 de [1], les phases relatives de action part s'annulent avec les phases de reset part.
• action_only (bool) – lorsqu'il est fixé à True, la méthode n'applique que le action part du lemme 8 de [1].

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Iten et al. et al., Circuits quantiques pour les isométries, Phys. Rév. A 93, 23 mars 2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_n_clean_m15(num_ctrl_qubits)

Synthétiser une porte X à contrôles multiples avec des commandes de type « $k\ge 3$ » en utilisant des qubits auxiliaires propres de type « $k - 2$ », en produisant un circuit comportant des qubits de type « $2 * k - 1$ » et au plus $6 * k - 6$ portes CX, selon Maslov [1]. Pour l'opération « $k\le 2$ », le circuit renvoyé se compose d'une seule porte X, CX ou CCX (correspondant respectivement aux opérations « $k = 0, 1, 2$ ») et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

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

qiskit.synthesis.synth_mcx_1_clean_b95(num_ctrl_qubits)

Synthétisez une porte X à contrôles multiples avec des commandes de type « $k\ge 3$ » à l'aide d'un seul qubit auxiliaire propre, de manière à obtenir un circuit comportant $k + 2$ qubits et au plus $16 * k - 24$ portes CX, par [1], [2]. Pour l'opération « $k\le 2$ », le circuit renvoyé se compose d'une seule porte X, CX ou CCX (correspondant respectivement aux opérations « $k = 0, 1, 2$ ») et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Barenco et. al, Portes élémentaires pour l'informatique quantique, Phys.Rev. A52 3457 (1995), arXiv:quant-ph/9503016
2. Iten et al. et al., Circuits quantiques pour les isométries, Phys. Rév. A 93, 23 mars 2018 (2016), arXiv:1501.06911

qiskit.synthesis.synth_mcx_noaux_v24(num_ctrl_qubits)

Synthétiser une porte X multi-contrôlée avec des contrôles $k$ sur la base de l'implémentation pour MCPhaseGate.

À son tour, la porte MCPhase utilise la décomposition des unités spéciales multicontrôlées décrite au point [1.]

Produit un circuit quantique avec $k + 1$ qubits. Le nombre de portes CX est quadratique dans $k$.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

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)

Synthétiser une porte X multi-contrôlée avec des contrôles $k$ basés sur le travail de Huang et Palsberg.

Produit un circuit quantique avec $k + 1$ qubits. Le nombre de portes CX est linéaire dans $k$.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Retours

Le circuit quantique synthétisé.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Type de retour

QuantumCircuit

Références

1. Huang and 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)

Synthétisez une porte X à entrées multiples avec des commandes de type « $k\ge 3$ » en utilisant le code de Gray.

Génère un circuit quantique comportant $k + 1$ qubits. Cette méthode génère un nombre exponentiel de portes CX et ne doit être utilisée que pour de petites valeurs d' $k$. Pour $k\le 2$, le circuit obtenu se compose d'une seule porte X, CX ou CCX (correspondant respectivement à $k = 0, 1, 2$ ) et n'utilise aucun qubit auxiliaire.

Paramètres

num_ctrl_qubits (int) – Le nombre de qubits de contrôle.

Augmentations

QiskitError – si num_ctrl_qubits est illégal.

Retours

Le circuit quantique synthétisé.

Type de retour

QuantumCircuit

qiskit.synthesis.synth_c3x()

Synthèse efficace d'une porte X contrôlée par 3.

Type de retour

QuantumCircuit

qiskit.synthesis.synth_c4x()

Synthèse efficace d'une porte X à 4 contrôles.

Type de retour

QuantumCircuit

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

Un circuit qui utilise la QFT pour effectuer une addition in-place sur deux registres de qubits.

Pour les registres comportant des qubits de type « $n$ », l'additionneur QFT peut effectuer une addition modulo « $2^n$ » (avec kind="fixed") ou une addition ordinaire en ajoutant un qubit de report (avec kind="half"). L'additionneur fixe utilise des opérateurs de type « $(3n^2 - n)/2$CPhaseGate », avec un « $n$ » supplémentaire pour le demi-additionneur.

A titre d'exemple, un circuit additionneur QFT à point fixe qui effectue une addition sur deux registres de 2 qubits est le suivant :

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

Paramètres

• num_state_qubits (int) – Le nombre de qubits dans l'un ou l'autre des registres d'entrée pour l'état $|a\rangle$ ou $|b\rangle$. Les deux registres d'entrée doivent avoir le même nombre de qubits.
• kind (str) – Le type d'additionneur peut être "half" pour un demi-additionneur ou "fixed" pour un additionneur de taille fixe. Un demi-additionneur contient un report pour représenter le bit de poids fort, ce qui n'est pas le cas de l'additionneur à taille fixe, qui effectue donc une addition modulo 2 ** num_state_qubits.
• annotated (bool) – Si True, crée les opérations de contrôle et d'inversion appropriées en tant qu'objets AnnotatedOperation .

Type de retour

QuantumCircuit

Références :

[1] T. G. Draper, Addition on a Quantum Computer, 2000. arXiv:quant-ph/0008033

[2] Ruiz-Perez et al, Arithmétique quantique avec la transformée de Fourier quantique, 2017. arXiv:1411.5949

[3] Vedral et al, Réseaux quantiques pour les opérations arithmétiques élémentaires, 1995. arXiv:quant-ph/9511018

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

Un circuit de transport d'ondulation pour effectuer une addition sur place sur deux registres de qubits.

Ce circuit utilise les portes $2n + O(1)$ CCX et $5n + O(1)$ CX, à une profondeur de $2n + O(1)$ [1.] La constante dépend du type d'additionneur mis en œuvre.

A titre d'exemple, un circuit additionneur à portage ondulé qui effectue l'addition sur deux registres de 3 qubits avec un bit de portage (kind="full") est le suivant :

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

Les portes MAJ et UMA correspondent aux portes introduites en [1.] Notez que dans cette implémentation, les qubits du registre d'entrée sont ordonnés comme suit : tous les qubits du premier registre d'entrée, suivis de tous les qubits du deuxième registre d'entrée.

Deux types d'additionneurs différents sont pris en charge. En définissant l'argument kind , vous pouvez également choisir un demi-adder, qui n'a pas de carry-in, et un fixed-size-adder, qui n'a ni carry-in ni carry-out, et agit donc sur des registres de taille fixe. Contrairement à l'ordre complet, ces circuits ont besoin d'un qubit d'aide supplémentaire.

Le schéma du circuit de l'additionneur à virgule fixe (kind="fixed") pour des entrées de la taille de 3 qubits est le suivant

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

Il a un qubit de moins que l'ordre complet puisqu'il n'a pas de report, mais il utilise un qubit d'aide à la place du report, de sorte qu'il n'a qu'un qubit de moins, et non deux.

Paramètres

• num_state_qubits (int) – Le nombre de qubits dans l'un ou l'autre des registres d'entrée pour l'état $|a\rangle$ ou $|b\rangle$. Les deux registres d'entrée doivent avoir le même nombre de qubits.
• kind (str) – Le type d'additionneur peut être "full" pour un additionneur complet, "half" pour un demi-additionneur ou "fixed" pour un additionneur de taille fixe. Un additionneur complet comprend à la fois l'entrée et la sortie, un demi-additionneur seulement l'entrée, et un additionneur de taille fixe ni l'entrée ni la sortie.

Augmentations

ValueError - Si num_state_qubits est inférieur à 1.

Type de retour

QuantumCircuit

Références :

[1] Cuccaro et al, Un nouveau circuit quantique d'addition de l'ondulation de la charge, 2004. arXiv:quant-ph/0410184

[2] Vedral et al, Réseaux quantiques pour les opérations arithmétiques élémentaires, 1995. arXiv:quant-ph/9511018

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

L'additionneur de retenue de l'ondulation VBE [1].

Cette méthode utilise les portes $4n + O(1)$ CCX et $4n + 1$ CX à une profondeur de $6n - 2$ [2].

Ce circuit effectue l'addition sur place de deux registres quantiques de taille égale. À titre d'exemple, un circuit additionneur classique qui effectue une addition complète (c'est-à-dire incluant un bit de report) sur deux registres de 2 qubits est le suivant :

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

Les portes Carry et Sum correspondent aux portes présentées au point [1]. Carry_dg correspond à l'inverse de la porte Carry. Notez que dans cette implémentation, les qubits du registre d'entrée sont ordonnés comme suit : tous les qubits du premier registre d'entrée, suivis de tous les qubits du deuxième registre d'entrée. Il s'agit d'une commande différente par rapport à la figure 2 en [1], ce qui conduit à un dessin différent du circuit.

Paramètres

• num_state_qubits (int) – La taille du registre.
• kind (str) – Le type d'additionneur peut être "full" pour un additionneur complet, "half" pour un demi-additionneur ou "fixed" pour un additionneur de taille fixe. Un additionneur complet comprend à la fois l'entrée et la sortie, un demi-additionneur seulement l'entrée, et un additionneur de taille fixe ni l'entrée ni la sortie.

Augmentations

ValueError - Si num_state_qubits est inférieur à 1.

Type de retour

QuantumCircuit

Références :

[1] Vedral et al, Réseaux quantiques pour les opérations arithmétiques élémentaires, 1995. arXiv:quant-ph/9511018

[2] Cuccaro et al, Un nouveau circuit quantique d'addition de l'ondulation de la charge, 2004. arXiv:quant-ph/0410184

qiskit.synthesis.adder_ripple_r25(num_qubits)

L'additionneur à retenue ondulée RV [1]. Construire un circuit additionneur quantique sans ancilla avec une profondeur sous-linéaire basé sur l'additionneur RV ripple-carry montré en [1.] L'implémentation a une profondeur de $O(\log^2 n)$ et utilise math:O(n log n) portes.

A titre d'exemple, un circuit additionneur à portage ondulé qui effectue l'addition sur deux registres de 4 qubits est le suivant :

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

Ici LAD_1 et LAD_2 sont les échelles CX et CCX respectivement introduites en [1.] Notez que dans cette implémentation, les qubits du registre d'entrée sont ordonnés comme suit : tous les qubits du premier registre d'entrée, suivis de tous les qubits du deuxième registre d'entrée.

Paramètres

num_qubits (int) – La taille du registre.

Retours

Le circuit quantique mettant en œuvre l'additionneur de carry ripple RV.

Augmentations

ValueError - Si num_qubits est inférieur à 1.

Type de retour

QuantumCircuit

Références :

1. Remaud et Vandaele, Ancilla-free Quantum Adder with Sublinear Depth, 2025. arXiv:2501.16802

qiskit.synthesis.adder_modular_v17(num_qubits)

Construisez un circuit additionneur modulaire sans qubits auxiliaires basé sur l'additionneur de type Van Rentergem de la Fig. 15 de [1]. L'implémentation utilise au maximum $16k - 13$ portes CX pour un additionneur avec k qubits dans chaque registre, où k = num_qubits.

Paramètres

num_qubits (int) – La taille du registre.

Retours

Le circuit quantique mettant en œuvre l'additionneur modulaire.

Augmentations

ValueError - Si num_qubits est inférieur à 1.

Type de retour

QuantumCircuit

Références :

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

Un circuit de multiplication pour stocker le produit de deux registres d'entrée hors place.

Le circuit utilise l'approche de Ref. [1]. Par exemple, un circuit multiplicateur qui effectue une multiplication non modulaire sur deux registres d'une taille de 3 qubits est :

from qiskit.synthesis.arithmetic import multiplier_cumulative_h18

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

La multiplication dans ce circuit est mise en œuvre selon une approche classique en effectuant une série d'additions décalées en utilisant l'un des registres d'entrée tandis que les qubits de l'autre registre d'entrée agissent comme des qubits de contrôle pour les additionneurs.

Paramètres

• num_state_qubits (int) – Le nombre de qubits dans l'un ou l'autre des registres d'entrée pour l'état $|a\rangle$ ou $|b\rangle$. Les deux registres d'entrée doivent avoir le même nombre de qubits.
• num_result_qubits (int | None) – Le nombre de qubits de résultat à limiter à la sortie. Si le nombre de qubits de résultat est $n$, une multiplication modulo $2^n$ est effectuée pour limiter la sortie au nombre de qubits spécifié. La valeur par défaut est 2 * num_state_qubits pour représenter tout résultat possible de la multiplication des deux entrées.

Augmentations

ValueError - Si num_result_qubits est donné et n'est pas valide, cela signifie qu'il ne figure pas dans [num_state_qubits, 2 * num_state_qubits].

Type de retour

QuantumCircuit

Références :

[1] Häner et al, Optimisation des circuits quantiques pour l'arithmétique, 2018. arXiv:1805.12445

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

Un circuit de multiplication QFT pour stocker le produit de deux registres d'entrée hors place.

La multiplication dans ce circuit est mise en œuvre en utilisant la procédure de la figure 3 en [1], où les rotations de la somme pondérée sont mises en œuvre comme indiqué dans la figure 5 en [1]. Le QFT est utilisé sur le registre de sortie et est suivi par des rotations contrôlées par les registres d'entrée. Les rotations transforment l'état en produit de deux registres d'entrée dans la base QFT, qui est inversée à partir de la base QFT à l'aide de la QFT inverse. Par exemple, sur des qubits à 3 états, un multiplicateur complet est donné par :

from qiskit.synthesis.arithmetic import multiplier_qft_r17

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

Paramètres

• num_state_qubits (int) – Le nombre de qubits dans l'un ou l'autre des registres d'entrée pour l'état $|a\rangle$ ou $|b\rangle$. Les deux registres d'entrée doivent avoir le même nombre de qubits.
• num_result_qubits (int | None) – Le nombre de qubits de résultat à limiter à la sortie. Si le nombre de qubits de résultat est $n$, une multiplication modulo $2^n$ est effectuée pour limiter la sortie au nombre de qubits spécifié. La valeur par défaut est 2 * num_state_qubits pour représenter tout résultat possible de la multiplication des deux entrées.

Augmentations

ValueError - Si num_result_qubits est donné et n'est pas valide, cela signifie qu'il ne figure pas dans [num_state_qubits, 2 * num_state_qubits].

Type de retour

QuantumCircuit

Références :

[1] Ruiz-Perez et al, Arithmétique quantique avec la transformée de Fourier quantique, 2017. arXiv:1411.5949

qiskit.synthesis.synth_weighted_sum_carry(weighted_sum)

Synthétiser une porte à somme pondérée, en fonction du nombre de qubits d'état et des poids des qubits.

Cette méthode est décrite à l'annexe A du point [1.]

Référence :

[1] Stamatopoulos et al. Évaluation des options à l'aide d'ordinateurs quantiques (2020)

Quantum 4, 291

Paramètres

weighted_sum (WeightedSumGate)

Type de retour

QuantumCircuit

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

Implémenter une comparaison d'entiers basée sur le complément à 2s.

Ceci est basé sur l'annexe B de [1.]

Paramètres

• num_state_qubits (int) – Le nombre de qubits codant la valeur à comparer.
• value (int) – La valeur à comparer.
• geq (bool) – Si True inverse le bit cible si l'état du qubit est $\geq$ supérieur à la valeur, sinon mettre en œuvre $<$.

Retours

Un circuit mettant en œuvre le comparateur de nombres entiers.

Type de retour

QuantumCircuit

Références

[1] J. Gacon et al. "Quantum-enhanced simulation-based optimization" (optimisation basée sur la simulation améliorée par les quanta)

arXiv:2005.10780.

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

Mise en œuvre d'une comparaison d'entiers basée sur une comparaison valeur par valeur.

Pour value plus petit que 2 ** (num_state_qubits - 1) , ce circuit met en œuvre des portes multicontrôlées value avec des états de contrôle 0, 1,..., value - 1, de sorte que le qubit cible est inversé si l'état du qubit représente l'une des valeurs autorisées. Pour les value plus grands, geq est inversé. Cette mise en œuvre peut nécessiter un nombre exponentiel de portes. Si des qubits auxiliaires sont disponibles, l'implémentation fournie par synth_integer_comparator_2s() est plus efficace.

Paramètres

• num_state_qubits (int) – Le nombre de qubits codant la valeur à comparer.
• value (int) – La valeur à comparer.
• geq (bool) – Si True inverse le bit cible si l'état du qubit est $\geq$ supérieur à la valeur, sinon mettre en œuvre $<$.

Retours

Un circuit mettant en œuvre le comparateur de nombres entiers.

Type de retour

QuantumCircuit