Bibliothèque de circuits
qiskit.circuit.library
La bibliothèque de circuits est un ensemble de circuits quantiques qui servent de modules algorithmiques, d'outils d'évaluation comparative et d'exemples dont on suppose qu'ils sont difficiles à simuler de manière classique. L'objectif est de proposer des circuits clairement définis, largement applicables et faciles à réutiliser dans différents flux de travail.
Les critères d'intégration d'un circuit dans la bibliothèque sont les suivants :
Bien défini
Le circuit présente une structure claire ou un fonctionnement mathématique, étayé par un article ou une référence.
Largement utilisé et pertinent
Ce circuit constitue un choix canonique ou le plus couramment retenu pour une tâche bien définie, sert de référence standard ou de base commune, ou encore a joué un rôle historique fondamental dans un sous-domaine important de l'informatique quantique.
Autonome
Le circuit est autonome, ce qui signifie qu'il peut être généré efficacement sans nécessiter de nouvelles dépendances externes.
Les éléments de la bibliothèque de circuits sont soit QuantumCircuits, soit Instructions, ce qui permet de les analyser facilement ou de les intégrer à d'autres circuits. Cela permet un prototypage rapide et la conception de circuits à des niveaux d'abstraction plus élevés.
Par exemple :
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
hamiltonian = SparsePauliOp(["ZZI", "IZZ", "IXI"], coeffs=[1, 1, -1])
gate = PauliEvolutionGate(hamiltonian)
circuit = QuantumCircuit(hamiltonian.num_qubits)
circuit.append(gate, circuit.qubits)
circuit.draw("mpl")
Cette bibliothèque est organisée en différentes sections :
Nous distinguons différentes catégories d'opérations :
Portes standard
Il s'agit de portes quantiques fondamentales, dont un sous-ensemble constitue généralement un ensemble de portes de base sur un ordinateur quantique. Il s'agit d'opérations unitaires représentées par Gate. La bibliothèque fournit également des directives de compilation standard (a Barrier) et des opérations non unitaires (comme Measure).
Opérations abstraites
Cette catégorie regroupe les opérations qui sont définies par une action mathématique, mais qui peuvent être mises en œuvre à l'aide de différentes décompositions. Par exemple, une opération à contrôles multiples XGate inverse le qubit cible si tous les qubits de contrôle sont à l'état « », et il existe divers circuits concrets mettant en œuvre cette opération à l'aide de portes de niveau inférieur. Ces opérations abstraites sont représentées par Gate ou Instruction. Cela permet de construire le circuit sans avoir à choisir une implémentation concrète pour chaque bloc et, au final, de laisser le compilateur (ou vous-même, en tant qu'utilisateur) choisir la décomposition optimale. Par exemple :
from qiskit.circuit.library import MCXGate
mcx = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(mcx, [0, 1, 4, 2, 3])
circuit.draw("mpl")
Pour les circuits avec des opérations abstraites, le contexte du circuit est pris en compte lors de la transpilation. Par exemple, si des qubits inactifs sont disponibles, ils peuvent être utilisés pour obtenir un circuit moins profond :
from qiskit import transpile
small_circuit = QuantumCircuit(5) # here we have no idle qubits
small_circuit.append(mcx, [0, 1, 4, 2, 3])
small_tqc = transpile(small_circuit, basis_gates=["u", "cx"])
print("No aux:", small_tqc.count_ops())
large_circuit = QuantumCircuit(10) # now we will have 5 idle qubits
large_circuit.append(mcx, [0, 1, 4, 2, 3])
large_tqc = transpile(large_circuit, basis_gates=["u", "cx"])
print("With aux:", large_tqc.count_ops())Qui imprime :
No aux: OrderedDict([('u', 41), ('cx', 36)])
With aux: OrderedDict([('u', 24), ('cx', 18)])Opérations structurelles
Ces opérations ont une décomposition unique. Comme le compilateur n'a pas besoin de raisonner à leur sujet à un niveau supérieur, elles sont implémentées comme des fonctions qui renvoient un QuantumCircuit objet. Par exemple :
from qiskit.circuit.library import real_amplitudes
ansatz = real_amplitudes(5, entanglement="pairwise")
ansatz.draw("mpl")
Portails standard
GateCes opérations sont des portes unitaires réversibles et elles appartiennent toutes à la sous-classe de. Par conséquent, elles disposent toutes des méthodes to_matrix(), power(), et control(), que l'on ne peut généralement appliquer qu'à des opérations unitaires.
Par exemple :
from qiskit.circuit.library import XGate
gate = XGate()
print(gate.to_matrix()) # X gate
print(gate.power(1/2).to_matrix()) # √X gate -- see also the SXGate
print(gate.control(1).to_matrix()) # CX (controlled X) gate[[0.+0.j 1.+0.j]
[1.+0.j 0.+0.j]]
[[0.5+0.5j 0.5-0.5j]
[0.5-0.5j 0.5+0.5j]]
[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]
[0.+0.j 0.+0.j 0.+0.j 1.+0.j]
[0.+0.j 0.+0.j 1.+0.j 0.+0.j]
[0.+0.j 1.+0.j 0.+0.j 0.+0.j]]La fonction get_standard_gate_name_mapping() permet d'afficher les portes et les opérations standard disponibles.
get_standard_gate_name_mapping
qiskit.circuit.library.get_standard_gate_name_mapping()
Renvoi d'un dictionnaire associant le nom des portes et instructions standard à un objet correspondant à ce nom.
Exemples
from qiskit.circuit.library import get_standard_gate_name_mapping
gate_name_map = get_standard_gate_name_mapping()
cx_object = gate_name_map["cx"]
print(cx_object)
print(type(cx_object))Instruction(name='cx', num_qubits=2, num_clbits=0, params=[])
_SingletonCXGatePortes standard à 1 qubit
HGate(*args[, _force_mutable] ) | Porte de Hadamard à un qubit. |
IGate(*args[, _force_mutable] ) | Porte d'identité. |
PhaseGate(thêta[, étiquette] ) | Rotation d'un qubit autour de l'axe Z. |
RGate(thêta, phi[, étiquette] ) | Rotation autour de l'axe . |
RXGate(thêta[, étiquette] ) | Rotation d'un qubit autour de l'axe X. |
RYGate(thêta[, étiquette] ) | Rotation d'un qubit autour de l'axe Y. |
RZGate(phi[, étiquette] ) | Rotation d'un qubit autour de l'axe Z. |
SGate(*args[, _force_mutable] ) | Porte S à un seul qubit ( ). |
SdgGate(*args[, _force_mutable] ) | Porte S-adjointe à un seul qubit ( ). |
SXGate(*args[, _force_mutable] ) | La porte Sqrt(X) à qubit unique ( ). |
SXdgGate(*args[, _force_mutable] ) | La porte inverse Sqrt(X) à un qubit. |
TGate(*args[, _force_mutable] ) | Porte T à un seul qubit ( ). |
TdgGate(*args[, _force_mutable] ) | Porte T-adjointe à un seul qubit ( ). |
UGate(thêta, phi, lambda[, étiquette] ) | Rotation générique d'un qubit unique en termes d'angles d'Euler ZYZ. |
U1Gate(thêta[, étiquette] ) | Rotation d'un qubit autour de l'axe Z. |
U2Gate(phi, lam[, label] ) | Rotation d'un qubit autour de l'axe X+Z. |
U3Gate(thêta, phi, lambda[, étiquette] ) | Porte de rotation générique à un qubit avec 3 angles d'Euler. |
XGate(*args[, _force_mutable] ) | La porte Pauli-X à qubit unique ( ). |
YGate(*args[, _force_mutable] ) | La porte Pauli-Y à qubit unique ( ). |
ZGate(*args[, _force_mutable] ) | La porte Pauli-Z à qubit unique ( ). |
Portes standard à 2 qubits
CHGate(*args[, _force_mutable] ) | Porte Hadamard contrôlée. |
CPhaseGate(theta[, étiquette, ctrl_state,...] ) | Porte à phase contrôlée. |
CRXGate(thêta[, étiquette, ctrl_état, _base_étiquette] ) | Porte de réception contrôlée. |
CRYGate(thêta[, étiquette, ctrl_état, _base_étiquette] ) | Porte contrôlée-RY. |
CRZGate(thêta[, étiquette, ctrl_état, _base_étiquette] ) | Porte RZ contrôlée. |
CSGate(*args[, _force_mutable] ) | Porte S contrôlée. |
CSdgGate(*args[, _force_mutable] ) | Portail à commande . |
CSXGate(*args[, _force_mutable] ) | Porte contrôlée-√X. |
CUGate(thêta, phi, lambda, gamma[, label,...] ) | Porte U contrôlée (porte à deux qubits à 4 paramètres). |
CU1Gate(thêta[, étiquette, ctrl_état, _base_étiquette] ) | Controlled-U1 porte. |
CU3Gate(thêta, phi, lambda[, label,...] ) | Controlled-U3 (porte à deux qubits à 3 paramètres). |
CXGate(*args[, _force_mutable] ) | Porte X contrôlée. |
CYGate(*args[, _force_mutable] ) | Porte Y contrôlée. |
CZGate(*args[, _force_mutable] ) | Porte Z contrôlée. |
DCXGate(*args[, _force_mutable] ) | Porte Double-CX. |
ECRGate(*args[, _force_mutable] ) | Une porte de résonance croisée en écho. |
iSwapGate(*args[, _force_mutable] ) | iSWAP porte. |
RXXGate(thêta[, étiquette] ) | Une interaction paramétrique à 2 qubits (rotation autour de XX). |
RYYGate(thêta[, étiquette] ) | Interaction paramétrique à 2 qubits (rotation autour de YY). |
RZXGate(thêta[, étiquette] ) | Une interaction paramétrique à 2 qubits (rotation autour de ZX). |
RZZGate(thêta[, étiquette] ) | Une interaction paramétrique à 2 qubits (rotation autour de ZZ). |
SwapGate(*args[, _force_mutable] ) | La porte SWAP. |
XXMinusYYGate(thêta[, bêta, étiquette] ) | Porte d'interaction XX-YY. |
XXPlusYYGate(thêta[, bêta, étiquette] ) | Porte d'interaction XX+YY. |
Portes standard à 3 qubits ou plus
C3SXGate(*args[, _force_mutable] ) | La porte sqrt-X contrôlée par 3 qubits. |
C3XGate(*args[, _force_mutable] ) | La porte X est contrôlée par 3 qubits. |
C4XGate(*args[, _force_mutable] ) | La porte X contrôlée par 4 qubits. |
CCXGate(*args[, _force_mutable] ) | Porte CCX, également connue sous le nom de porte de Toffoli. |
CCZGate(*args[, _force_mutable] ) | Porte CCZ. |
CSwapGate(*args[, _force_mutable] ) | Porte SWAP contrôlée, également connue sous le nom de porte de Fredkin. |
RCCXGate(*args[, _force_mutable] ) | La porte de Toffoli simplifiée, également appelée porte de Margolus. |
RC3XGate(*args[, _force_mutable] ) | La porte de Toffoli simplifiée à trois commandes. |
Portails standard mondiaux
La porte suivante est globale et ne prend aucun argument qubit.
GlobalPhaseGate(phase[, étiquette] ) | La porte de phase globale ( ). |
Directives standard
Les directives sont des opérations sur la pile quantique destinées à être interprétées par le backend ou le transpileur. En général, le transpondeur ou le backend peut éventuellement les ignorer s'il n'existe pas d'implémentation pour eux.
Opérations standard
Les opérations sont des changements non réversibles de l'état quantique du circuit.
En plus de Measurecela, il existe une mesure conjointe de Pauli généralisée, utilisée comme opération de base dans le calcul basé sur Pauli.
PauliProductMeasurement(Pauli[, label] ) | Instructions de mesure des produits Pauli. |
Portails généralisés
Ce module étend les portes standard avec une collection plus large de portes de base. Il s'agit notamment de portes variadiques, ce qui signifie que le nombre de qubits dépend de l'entrée. Par exemple :
from qiskit.circuit.library import DiagonalGate
diagonal = DiagonalGate([1, 1j])
print(diagonal.num_qubits)
diagonal = DiagonalGate([1, 1, 1, -1])
print(diagonal.num_qubits)qui s'imprime :
1
2DiagonalGate(diag) | Une porte quantique diagonale générique. |
PermutationGate(motif) | Une porte qui permute les qubits. |
MCMTGate(porte, nombre_de_qubits_de_contrôle,...[,...] ) | La porte multicible multi-contrôlée, pour une porte cible arbitraire à commande unique. |
MCPhaseGate(lam, num_ctrl_qubits[, label,...] ) | Porte à phases multiples contrôlées. |
MCXGate( [num_ctrl_qubits, label,...] ) | La porte X générale et multicommandée. |
MSGate(num_qubits, theta[, label] ) | La porte Mølmer-Sørensen. |
RVGate(v_x, v_y, v_z[, base] ) | Rotation autour d'un axe de rotation arbitraire où est l'angle de rotation en radians. |
PauliGate(étiquette) | Une porte de Pauli multiqubit. |
PauliProductRotationGate(pauli, angle[, étiquette] ) | Une rotation de Pauli générique. |
LinearFunction(linéaire[, validate_input] ) | Un circuit linéaire réversible sur n qubits. |
Isometry(isométrie, num_ancillas_zero,...[,...] ) | Décomposition d'isométries arbitraires de à qubits. |
UnitaryGate(données[, libellé, vérification_saisie,...] ) | Classe de portes quantiques définies par une matrice unitaire. |
UCGate(liste_des_portes[, jusqu'à_la_diagonale, multiplexeur_simple] ) | Porte à commande uniforme (également appelée porte multiplexée). |
UCPauliRotGate(angle_list, rot_axis) | Rotations de Pauli uniformément contrôlées. |
UCRXGate(angle_list) | Rotations Pauli-X uniformément contrôlées. |
UCRYGate(angle_list) | Rotations de Pauli-Y uniformément contrôlées. |
UCRZGate(angle_list) | Rotations Pauli-Z uniformément contrôlées. |
Les objets ci-dessus dérivent Gate ou Instruction, ce qui permet au compilateur de les analyser à un niveau abstrait. Nous vous recommandons donc de les utiliser à la place des éléments suivants, qui sont dérivés QuantumCircuit et construits de manière anticipée.
Diagonal(diag) | Circuit mettant en œuvre une transformation diagonale. |
MCMT(porte, nombre_qubits_de_contrôle, nombre_qubits_cibles) | La porte multicible multi-contrôlée, pour une porte cible arbitraire à commande unique. |
MCMTVChain(porte, nombre_de_qubits_de_contrôle,...) | La mise en œuvre du MCMT à l'aide de la chaîne en V CCX. |
MCXGrayCode( [num_ctrl_qubits, label,...] ) | Implémentez la porte X multi-contrôlée à l'aide du code Gray. |
MCXRecursive( [num_ctrl_qubits, label,...] ) | Implémenter la porte X multi-contrôlée en utilisant la récursivité. |
MCXVChain( [num_ctrl_qubits, dirty_ancillas,...] ) | Implémentez la porte X multicommandée en utilisant une chaîne en V de portes CX. |
Permutation(nombre_de_qubits[, motif, graine] ) | Un circuit n_qubit qui permute les qubits. |
GMS(num_qubits, theta) | Porte globale Mølmer-Sørensen. |
GR(num_qubits, thêta, phi) | Porte R globale. |
GRX(num_qubits, theta) | Porte RX globale. |
GRY(num_qubits, theta) | Portail mondial RY. |
GRZ(num_qubits, phi) | Porte RZ globale. |
Logique booléenne
Ces Gateéléments mettent en œuvre des opérations logiques booléennes, telles que la logique or d'un ensemble d'états de qubits.
AndGate(nombre_de_qubits_variables[, indicateurs] ) | Porte représentant l'opération logique ET sur un certain nombre de qubits. |
OrGate(nombre_de_qubits_variables[, indicateurs] ) | Une porte représentant l'opération logique OU sur un certain nombre de qubits. |
BitwiseXorGate(nombre de qubits, montant) | Une porte à n-qubits pour l'oxydation bit à bit de l'entrée avec un certain nombre entier amount. |
InnerProductGate(nombre de qubits) | Une fonction booléenne 2n-qubit qui calcule le produit intérieur de deux vecteurs de n-qubits sur . |
Les objets ci-dessus dérivent Gate de ce type (ou le renvoient), ce qui permet au compilateur de les analyser à un niveau abstrait. Nous vous recommandons donc de les utiliser à la place des éléments suivants, qui sont dérivés QuantumCircuit et construits de manière anticipée.
AND(num_variable_qubits[, flags, mcx_mode] ) | Circuit mettant en œuvre l'opération logique ET sur un certain nombre de qubits. |
OR(num_variable_qubits[, flags, mcx_mode] ) | Circuit mettant en œuvre l'opération logique OU sur un certain nombre de qubits. |
XOR(num_qubits[, amount, seed] ) | Un circuit n_qubit pour l'oxydation bit à bit de l'entrée avec un certain nombre entier amount. |
InnerProduct(nombre de qubits) | Une fonction booléenne 2n-qubit qui calcule le produit intérieur de deux vecteurs de n-qubits sur . |
Un circuit aléatoire bitwise xor peut être directement généré en utilisant :
random_bitwise_xor(num_qubits, seed) | Créez un fichier aléatoire BitwiseXorGate. |
Changement de base
Ces portes effectuent des transformations de base des états des qubits. Par exemple, dans le cas de la transformée de Fourier quantique (QFT), elle transforme la base de calcul en base de Fourier.
QFTGate(nombre de qubits) | Porte de transformée de Fourier quantique. |
L'objet ci-dessus dérive Gatede, ce qui permet au compilateur de l'analyser à un niveau abstrait. Nous suggérons donc d'utiliser ceci plutôt que ce qui suit, qui est dérivé QuantumCircuit et construit de manière anticipée.
QFT( [nombre_de_qubits, degré_d'approximation,...] ) | Circuit de transformée de Fourier quantique. |
Arithmétique
Ces portes et circuits effectuent des opérations arithmétiques classiques, telles que l'addition ou la multiplication.
Vipères
Les additionneurs calculent la somme de deux registres -qubit, c'est-à-dire
où la taille du registre de sortie dépend du type d'additionneur utilisé.
ModularAdderGate(nombre de qubits d'état[, étiquette] ) | Calculer la somme modulo de deux registres de qubits de taille . |
HalfAdderGate(nombre de qubits d'état[, étiquette] ) | Calculer la somme de deux registres de qubits de taille égale, y compris un bit de report. |
FullAdderGate(nombre de qubits d'état[, étiquette] ) | Calculer la somme de deux registres de qubits de taille , y compris les bits d'entrée et de sortie. |
Les objets ci-dessus dérivent Gate, ce qui permet au compilateur de les analyser à un niveau abstrait. Nous vous recommandons donc de les utiliser à la place des éléments suivants, qui sont dérivés QuantumCircuit et construits de manière anticipée.
DraperQFTAdder(nombre_de_qubits_d'état[, type, nom] ) | Un circuit qui utilise la QFT pour effectuer une addition in-place sur deux registres de qubits. |
CDKMRippleCarryAdder(nombre de qubits d'état[,...] ) | Un circuit de transport d'ondulation pour effectuer une addition sur place sur deux registres de qubits. |
VBERippleCarryAdder(nombre de qubits d'état[,...] ) | L'additionneur de retenue de l'ondulation VBE [1]. |
multiplicateurs
Les multiplicateurs calculent le produit de deux registres -qubit, c'est-à-dire
où est le nombre de bits utilisés pour représenter le résultat.
MultiplierGate(nombre de qubits d'état[,...] ) | Calculer le produit de deux registres de qubits de taille égale dans un nouveau registre. |
L'objet ci-dessus dérive Gatede, ce qui permet au compilateur de l'analyser à un niveau abstrait. Nous suggérons donc d'utiliser ceci plutôt que les éléments suivants, qui sont dérivés QuantumCircuit et construits de manière anticipée.
HRSCumulativeMultiplier(nombre de qubits d'état[,...] ) | Un circuit de multiplication pour stocker le produit de deux registres d'entrée hors place. |
RGQFTMultiplier(nombre de qubits d'état[,...] ) | Un circuit de multiplication QFT pour stocker le produit de deux registres d'entrée hors place. |
Fonctions d'amplitude
Une fonction d'amplitude est une fonction approximative appliquée aux amplitudes des qubits . Voir la docstring de la classe pour plus d'informations.
LinearAmplitudeFunctionGate(...[, ...]) | Un circuit mettant en œuvre une fonction linéaire (par morceaux) sur les amplitudes des qubits. |
L'objet ci-dessus dérive Gatede, ce qui permet au compilateur de l'analyser à un niveau abstrait. Nous suggérons donc d'utiliser ceci plutôt que ce qui suit, qui est dérivé QuantumCircuit et construit de manière anticipée.
LinearAmplitudeFunction(nombre de qubits d'état,...) | Un circuit mettant en œuvre une fonction linéaire (par morceaux) sur les amplitudes des qubits. |
Rotations de Pauli fonctionnelles
Les rotations fonctionnelles de Pauli mettent en œuvre des opérations de la forme
en utilisant les rotations de Pauli- pour différents types de fonctions , telles que les fonctions linéaires, polynomiales ou une version par morceaux de ces fonctions. Elles sont similaires aux fonctions d'amplitude ci-dessus, mais sans prétraitement ni post-traitement pour le domaine et l'image de la fonction cible.
LinearPauliRotationsGate(nombre de qubits d'état[,...] ) | Rotation X, Y ou Z à commande linéaire. |
PolynomialPauliRotationsGate(nombre de qubits d'état) | Une porte mettant en œuvre des rotations de Pauli polynomiales. |
PiecewiseLinearPauliRotationsGate([...]) | Rotations de Pauli contrôlées de manière linéaire et fragmentaire. |
PiecewisePolynomialPauliRotationsGate(...[, ...]) | Rotations de Pauli contrôlées par la polynomie. |
PiecewiseChebyshevGate(f_x, nombre_de_qubits d'état) | Approche de Chebyshev par morceaux d'une fonction d'entrée. |
Les objets ci-dessus dérivent Gate, ce qui permet au compilateur de les analyser à un niveau abstrait. Nous vous recommandons donc de les utiliser à la place des éléments suivants, qui sont dérivés QuantumCircuit et construits de manière anticipée.
FunctionalPauliRotations( [nombre de qubits d'état,...] ) | Classe de base pour les rotations de Pauli fonctionnelles. |
LinearPauliRotations( [nombre de qubits d'état,...] ) | Rotation X, Y ou Z à commande linéaire. |
PolynomialPauliRotations( [nombre de qubits d'état,...] ) | Un circuit mettant en œuvre des rotations polynomiales de Pauli. |
PiecewiseLinearPauliRotations([...]) | Rotations de Pauli contrôlées de manière linéaire et fragmentaire. |
PiecewisePolynomialPauliRotations([...]) | Rotations de Pauli contrôlées par la polynomie. |
PiecewiseChebyshev(f_x[, degré,...] ) | Approche de Chebyshev par morceaux d'une fonction d'entrée. |
Autres fonctions arithmétiques
Nous énumérons ici d'autres circuits arithmétiques. Voir la documentation de chaque classe pour plus de détails.
ExactReciprocalGate(nombre de qubits d'état, mise à l'échelle) | Met en œuvre une fonction réciproque exacte. |
IntegerComparatorGate(nombre_de_qubits_d'état, valeur) | Effectuer un (ou ) sur un registre de qubits par rapport à un entier classique. |
QuadraticFormGate( [num_result_qubits,...] ) | Met en œuvre une forme quadratique sur des variables binaires encodées dans des registres de qubits. |
WeightedSumGate(nombre de qubits d'état[, poids,...] ) | Une porte pour calculer la somme pondérée de registres de qubits. |
Les objets ci-dessus dérivent Gate, ce qui permet au compilateur de les analyser à un niveau abstrait. Nous vous recommandons donc de les utiliser à la place des éléments suivants, qui sont dérivés QuantumCircuit et construits de manière anticipée.
ExactReciprocal(nombre de qubits d'état, mise à l'échelle[,...] ) | Réciproque exacte |
IntegerComparator( [nombre_de_qubits_d'état, valeur,...] ) | Comparateur d'entiers. |
QuadraticForm( [num_result_qubits,...] ) | Met en œuvre une forme quadratique sur des variables binaires encodées dans des registres de qubits. |
WeightedAdder( [nombre_de_qubits_d'état, poids, nom] ) | Un circuit pour calculer la somme pondérée des registres de qubits. |
Circuits quantiques particuliers
Les portes et circuits quantiques suivants définissent des opérations spécifiques intéressantes :
fourier_checking(f, g) | Circuit de vérification de Fourier. |
hidden_linear_function(matrice d'adjacence) | Circuit pour résoudre le problème de la fonction linéaire cachée. |
iqp(interactions) | Circuit à temps polynomial quantique instantané (IQP). |
random_iqp(num_qubits[, seed] ) | Un circuit aléatoire à temps polynomial quantique instantané (IQP). |
quantum_volume(nombre de qubits[, profondeur, graine] ) | Un circuit à volume quantique. |
phase_estimation(nombre de qubits d'évaluation, unitaire) | Circuit d'estimation de phase. |
grover_operator(oracle[, state_preparation,...] ) | Construire l'opérateur Grover. |
unitary_overlap(unitary1, unitary2[, ...]) | Circuit qui renvoie le chevauchement entre deux unitaires . |
GraphStateGate(matrice d'adjacence) | Une porte représentant l'état d'un graphe. |
PauliEvolutionGate(opérateur[, heure, étiquette,...] ) | Evolution temporelle d'un opérateur constitué de Paulis. |
HamiltonianGate(données, heure[, libellé] ) | Classe permettant de représenter l'évolution d'un opérateur hamiltonien sous la forme d'une porte. |
Nous fournissons ci-dessous les mêmes opérations que les classes dérivant de QuantumCircuit. Pour une meilleure exécution et de meilleures performances du compilateur, nous suggérons toutefois d'utiliser les fonctions et les portes ci-dessus.
FourierChecking(f, g) | Circuit de vérification de Fourier. |
GraphState(matrice d'adjacence) | Circuit de préparation d'un état graphique. |
HiddenLinearFunction(matrice d'adjacence) | Circuit pour résoudre le problème de la fonction linéaire cachée. |
IQP(interactions) | Circuit polynomial quantique instantané (IQP). |
QuantumVolume(nombre de qubits[, profondeur, graine,...] ) | Un circuit à volume quantique. |
PhaseEstimation(nombre de qubits d'évaluation, unitaire) | Circuit d'estimation de phase. |
GroverOperator(oracle[, state_preparation,...] ) | L'opérateur Grover. |
UnitaryOverlap(unitary1, unitary2[, ...]) | Circuit qui renvoie le chevauchement entre deux unitaires . |
Circuits N-locaux
Les fonctions suivantes renvoient un QuantumCircuit paramétré à utiliser comme ansatz dans un large éventail d'algorithmes quantiques variationnels.
Par exemple, nous pouvons construire un circuit variationnel
from qiskit.circuit.library import efficient_su2
num_qubits = 4
ansatz = efficient_su2(num_qubits, entanglement="pairwise")
ansatz.draw("mpl")
et le combiner avec
from qiskit.circuit.library import zz_feature_map
circuit = zz_feature_map(num_qubits)
circuit.barrier()
circuit.compose(ansatz, inplace=True)
circuit.draw("mpl")
pour obtenir un circuit de classification quantique variationnelle.
Les fonctions suivantes construisent toutes des circuits variationnels et sont optimisées pour une construction rapide :
n_local(nombre_de_qubits, blocs_de_rotation,...[,...] ) | Construire un circuit variationnel n-local. |
efficient_su2(num_qubits[, su2_gates,...] ) | Le circuit 2-local de , efficace sur le plan matériel. |
real_amplitudes(nombre de qubits[, intrication,...] ) | Construire un circuit 2-local à amplitudes réelles. |
pauli_two_design(nombre de qubits[, nombre de répétitions, graine,...] ) | Construire un ansatz de conception de Pauli à deux niveaux. |
excitation_preserving(n_qubits[, mode,...] ) | L'ansatz heuristique de la fonction d'onde préservant l'excitation. |
qaoa_ansatz(coût_opérateur[, nombre de répétitions,...] ) | Un circuit quantique QAOA généralisé avec un support d'états initiaux et de mélangeurs personnalisés. |
hamiltonian_variational_ansatz(hamiltonien) | Construire un ansatz variationnel hamiltonien. |
evolved_operator_ansatz(opérateurs[, représentants, etc.] ) | Construire un ansatz à partir des évolutions des opérateurs. |
Bien que nous suggérions d'utiliser les fonctions ci-dessus, nous continuons également à soutenir les fonctions suivantes BlueprintCircuit, qui enveloppent les circuits dans un bloc et permettent des mutations sur place des circuits :
NLocal( [nombre_de_qubits, blocs_de_rotation,...] ) | La classe de circuit n-local. |
TwoLocal( [nombre_de_qubits, blocs_de_rotation,...] ) | Le circuit bi-local. |
PauliTwoDesign( [nombre de qubits, nombre de répétitions, graine,...] ) | L'ansatz de Pauli à deux conceptions. |
RealAmplitudes( [nombre de qubits, intrication,...] ) | Le circuit 2-local des amplitudes réelles. |
EfficientSU2( [num_qubits, su2_gates,...] ) | Le circuit SU(2) 2-local efficace sur le plan matériel. |
EvolvedOperatorAnsatz( [opérateurs, représentants, etc.] ) | L'ansatz de l'opérateur évolué. |
ExcitationPreserving( [n_qubits, mode,...] ) | L'ansatz heuristique de la fonction d'onde préservant l'excitation. |
QAOAAnsatz( [coût_opérateur, nombre de répétitions,...] ) | Un circuit quantique QAOA généralisé avec un support d'états initiaux et de mélangeurs personnalisés. |
Circuits de codage de données
Les fonctions suivantes renvoient un QuantumCircuit à utiliser comme circuits d'encodage de données dans une série d'algorithmes quantiques variationnels :
pauli_feature_map(caractéristique_dimension[, nombre de répétitions,...] ) | Le circuit d'expansion de Pauli. |
z_feature_map(caractéristique_dimension[, nombre de répétitions,...] ) | Le circuit de Pauli Z-évolution du premier ordre. |
zz_feature_map(caractéristique_dimension[, nombre de répétitions,...] ) | Circuit d'évolution Pauli-Z du second ordre. |
Bien que nous suggérions d'utiliser les fonctions ci-dessus, nous continuons également à soutenir les fonctions suivantes BlueprintCircuit, qui enveloppent les circuits dans un bloc et permettent des mutations sur place des circuits :
PauliFeatureMap( [caractéristique_dimension, nombre de répétitions,...] ) | Le circuit de l'expansion de Pauli. |
ZFeatureMap(caractéristique_dimension[, nombre de répétitions,...] ) | Le circuit de Pauli Z-évolution du premier ordre. |
ZZFeatureMap(caractéristique_dimension[, nombre de répétitions,...] ) | Circuit d'évolution Pauli-Z du second ordre. |
Circuits de préparation de données
Les opérations suivantes sont utilisées pour la préparation de l'état :
StatePreparation(params[, num_qubits,...] ) | Préparation d'états d'amplitude complexe. |
Initialize(params[, num_qubits, normalize] ) | Initialisation de l'amplitude complexe. |
Oracle
Un "oracle" peut se référer à une variété d'opérations de boîte noire sur des états quantiques. Nous considérons ici des oracles mettant en œuvre des fonctions booléennes par le biais de changements de phase
ou des changements de bits
Ceux-ci sont mis en œuvre dans
PhaseOracleGate(expression[, var_order, étiquette] ) | Implémente un oracle de phase. |
BitFlipOracleGate(expression[, var_order, étiquette] ) | Implémente un oracle de retournement de bits |
et un élément fondamental de l'algorithme de Grover (voir grover_operator()).
Outre l'implémentation Gatebasée sur [...], nous prenons également en charge la QuantumCircuitversion [...], de l'oracle de renversement de phase
PhaseOracle(expression[, var_order] ) | Phase Oracle. |
Circuits modèles
Les modèles sont des fonctions qui renvoient des circuits qui calculent l'identité. Ils sont utilisés pour l'optimisation des circuits lorsque la correspondance d'une partie du modèle permet au compilateur de remplacer la correspondance par l'inverse du reste du modèle.
Dans cet exemple, la constante d'identité d'un modèle est vérifiée :
from qiskit.circuit.library.templates import template_nct_4b_1
from qiskit.quantum_info import Operator
import numpy as np
template = template_nct_4b_1()
identity = np.identity(2 ** len(template.qubits), dtype=complex)
data = Operator(template).data
np.allclose(data, identity) # True, template_nct_4b_1 is the identityCircuits modèles NCT (Not-CNOT-Toffoli)
XGateCircuits types pour les portes, CXGate, et CCXGate (Toffoli).
Références :
Maslov, D. et Dueck, G. W. et Miller, D. M., Techniques de synthèse des réseaux de Toffoli réversibles, 2007 https://dx.doi.org/10.1145/1278349.1278355
template_nct_2a_1
qiskit.circuit.library.templates.nct.template_nct_2a_1()
Modèle 2a_1:
┌───┐┌───┐
q_0: ┤ X ├┤ X ├
└───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_2a_2
qiskit.circuit.library.templates.nct.template_nct_2a_2()
Modèle 2a_2:
q_0: ──■────■──
┌─┴─┐┌─┴─┐
q_1: ┤ X ├┤ X ├
└───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_2a_3
qiskit.circuit.library.templates.nct.template_nct_2a_3()
Modèle 2a_3:
q_0: ──■────■──
│ │
q_1: ──■────■──
┌─┴─┐┌─┴─┐
q_2: ┤ X ├┤ X ├
└───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_4a_1
qiskit.circuit.library.templates.nct.template_nct_4a_1()
Modèle 4a_1:
q_0: ───────■─────────■──
│ │
q_1: ──■────┼────■────┼──
│ │ │ │
q_2: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_3: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_4: ┤ X ├─────┤ X ├─────
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_4a_2
qiskit.circuit.library.templates.nct.template_nct_4a_2()
Modèle 4a_2:
q_0: ──■─────────■───────
│ │
q_1: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_2: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_3: ┤ X ├─────┤ X ├─────
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_4a_3
qiskit.circuit.library.templates.nct.template_nct_4a_3()
Modèle 4a_3:
q_0: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_2: ┤ X ├─────┤ X ├─────
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_4b_1
qiskit.circuit.library.templates.nct.template_nct_4b_1()
Modèle 4b_1:
q_0: ───────■─────────■──
│ │
q_1: ──■────┼────■────┼──
│ │ │ │
q_2: ──■────■────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_3: ┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_4b_2
qiskit.circuit.library.templates.nct.template_nct_4b_2()
Modèle 4b_2:
q_0: ──■─────────■───────
│ │
q_1: ──■────■────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_2: ┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_5a_1
qiskit.circuit.library.templates.nct.template_nct_5a_1()
Modèle 5a_1:
q_0: ──■────■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_5a_2
qiskit.circuit.library.templates.nct.template_nct_5a_2()
Modèle 5a_2:
q_0: ──■─────────■─────────■──
│ ┌───┐ │ ┌───┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_5a_3
qiskit.circuit.library.templates.nct.template_nct_5a_3()
Modèle 5a_3:
q_0: ───────■─────────■────■──
┌─┴─┐ ┌─┴─┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_5a_4
qiskit.circuit.library.templates.nct.template_nct_5a_4()
Modèle 5a_4:
┌───┐ ┌───┐
q_0: ──■──┤ X ├──■──┤ X ├
┌─┴─┐└───┘┌─┴─┐├───┤
q_1: ┤ X ├─────┤ X ├┤ X ├
└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6a_1
qiskit.circuit.library.templates.nct.template_nct_6a_1()
Modèle 6a_1:
┌───┐ ┌───┐ ┌───┐
q_0: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_1: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6a_2
qiskit.circuit.library.templates.nct.template_nct_6a_2()
Modèle 6a_2:
q_0: ──■────■────■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6a_3
qiskit.circuit.library.templates.nct.template_nct_6a_3()
Modèle 6a_3:
q_0: ───────■─────────■────■────■──
┌─┴─┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6a_4
qiskit.circuit.library.templates.nct.template_nct_6a_4()
Modèle 6a_4:
q_0: ───────■──────────────■───────
┌─┴─┐ ┌───┐ │ ┌───┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6b_1
qiskit.circuit.library.templates.nct.template_nct_6b_1()
Modèle 6b_1:
q_0: ──■─────────■────■─────────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────■──┤ X ├──■────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6b_2
qiskit.circuit.library.templates.nct.template_nct_6b_2()
Modèle 6b_2:
q_0: ───────■────■─────────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────■──┤ X ├──■────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_6c_1
qiskit.circuit.library.templates.nct.template_nct_6c_1()
Modèle 6c_1:
q_0: ──■─────────■─────────■────■──
│ ┌───┐ │ ┌───┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_7a_1
qiskit.circuit.library.templates.nct.template_nct_7a_1()
Modèle 7a_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└─┬─┘┌─┴─┐ │ ┌─┴─┐└─┬─┘ │
q_1: ──■──┤ X ├──■────■──┤ X ├──■────■──
└───┘┌─┴─┐┌─┴─┐└───┘ ┌─┴─┐
q_2: ──────────┤ X ├┤ X ├──────────┤ X ├
└───┘└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_7b_1
qiskit.circuit.library.templates.nct.template_nct_7b_1()
Modèle 7b_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├──■────■──┤ X ├───────■──
└───┘┌─┴─┐┌─┴─┐└───┘ ┌─┴─┐
q_2: ──────────┤ X ├┤ X ├──────────┤ X ├
└───┘└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_7c_1
qiskit.circuit.library.templates.nct.template_nct_7c_1()
Modèle 7c_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├──■────■──┤ X ├───────■──
└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_7d_1
qiskit.circuit.library.templates.nct.template_nct_7d_1()
Modèle 7d_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└─┬─┘┌─┴─┐ │ ┌─┴─┐└─┬─┘ │
q_1: ──■──┤ X ├──■────■──┤ X ├──■────■──
└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_7e_1
qiskit.circuit.library.templates.nct.template_nct_7e_1()
Modèle 7e_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├───────┼──┤ X ├───────┼──
└─┬─┘┌───┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9a_1
qiskit.circuit.library.templates.nct.template_nct_9a_1()
Modèle 9a_1:
┌───┐ ┌───┐ ┌───┐
q_0: ┤ X ├──■──┤ X ├──■────■──┤ X ├──■──
└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├
└─┬─┘ │ ├───┤└─┬─┘┌───┐└─┬─┘
q_2: ───────■────■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_1
qiskit.circuit.library.templates.nct.template_nct_9c_1()
Modèle 9c_1:
┌───┐ ┌───┐┌───┐ ┌───┐ ┌───┐
q_0: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_1: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_2
qiskit.circuit.library.templates.nct.template_nct_9c_2()
Modèle 9c_2:
q_0: ───────■────■──────────────■────■─────────■──
┌───┐ │ ┌─┴─┐┌───┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_3
qiskit.circuit.library.templates.nct.template_nct_9c_3()
Modèle 9c_3:
q_0: ───────■────────────────────────■────────────
┌───┐ │ ┌───┐┌───┐ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_4
qiskit.circuit.library.templates.nct.template_nct_9c_4()
Modèle 9c_4:
q_0: ──■────■─────────■──────────────■────────────
┌─┴─┐ │ ┌───┐┌─┴─┐ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_5
qiskit.circuit.library.templates.nct.template_nct_9c_5()
Modèle 9c_5:
q_0: ────────────■─────────■──────────────■───────
┌───┐ ┌─┴─┐┌───┐ │ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_6
qiskit.circuit.library.templates.nct.template_nct_9c_6()
Modèle 9c_6:
q_0: ───────■────■─────────■─────────■────■───────
┌───┐ │ ┌─┴─┐┌───┐ │ ┌───┐ │ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_7
qiskit.circuit.library.templates.nct.template_nct_9c_7()
Modèle 9c_7:
q_0: ──■────■────■────■────■─────────■────■───────
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ │ ┌───┐ │ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_8
qiskit.circuit.library.templates.nct.template_nct_9c_8()
Modèle 9c_8:
q_0: ──■─────────■────■─────────■──────────────■──
┌─┴─┐ ┌─┴─┐┌─┴─┐ ┌─┴─┐ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_9
qiskit.circuit.library.templates.nct.template_nct_9c_9()
Modèle 9c_9:
q_0: ──■────■────■────■─────────■────■─────────■──
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_10
qiskit.circuit.library.templates.nct.template_nct_9c_10()
Modèle 9c_10:
q_0: ──■─────────■────■────■────■─────────■────■──
┌─┴─┐ ┌─┴─┐┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_11
qiskit.circuit.library.templates.nct.template_nct_9c_11()
Modèle 9c_11:
q_0: ───────■────■─────────■────■────■────■────■──
┌───┐ │ ┌─┴─┐┌───┐ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9c_12
qiskit.circuit.library.templates.nct.template_nct_9c_12()
Modèle 9c_12:
q_0: ──■────■────■────■────■────■────■────■────■──
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_1
qiskit.circuit.library.templates.nct.template_nct_9d_1()
Modèle 9d_1:
┌───┐ ┌───┐ ┌───┐
q_0: ──■───────┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌───┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_1: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_2
qiskit.circuit.library.templates.nct.template_nct_9d_2()
Modèle 9d_2:
q_0: ──■────■────■──────────────■──────────────■──
│ │ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_3
qiskit.circuit.library.templates.nct.template_nct_9d_3()
Modèle 9d_3:
q_0: ──■────■───────────────────■─────────────────
│ │ ┌───┐ ┌─┴─┐ ┌───┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_4
qiskit.circuit.library.templates.nct.template_nct_9d_4()
Modèle 9d_4:
q_0: ───────■─────────■──────────────■────────────
│ ┌───┐ │ ┌───┐ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_5
qiskit.circuit.library.templates.nct.template_nct_9d_5()
Modèle 9d_5:
q_0: ──■────■─────────■─────────■────■────────────
│ │ ┌───┐ │ ┌─┴─┐ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_6
qiskit.circuit.library.templates.nct.template_nct_9d_6()
Modèle 9d_6:
q_0: ──■────■──────────────■────■─────────■───────
│ │ ┌───┐ │ ┌─┴─┐ │ ┌───┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_7
qiskit.circuit.library.templates.nct.template_nct_9d_7()
Modèle 9d_7:
q_0: ──■────■─────────■────■────■────■────■───────
│ │ ┌───┐ │ │ ┌─┴─┐ │ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_8
qiskit.circuit.library.templates.nct.template_nct_9d_8()
Modèle 9d_8:
q_0: ──■────■────■────■─────────■────■─────────■──
│ │ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_9
qiskit.circuit.library.templates.nct.template_nct_9d_9()
Modèle 9d_9:
q_0: ──■────■────■─────────■────■─────────■────■──
│ │ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
template_nct_9d_10
qiskit.circuit.library.templates.nct.template_nct_9d_10()
Modèle 9d_10:
q_0: ──■────■────■────■────■────■────■────■────■──
│ │ ┌─┴─┐ │ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘Retours
comme un circuit quantique.
Type de retour
Circuits à gabarit Clifford
Circuits modèles sur les portes de Clifford.
clifford_2_1
qiskit.circuit.library.clifford_2_1()
Modèle Clifford 2_1 :
q_0: ─■──■─
│ │
q_1: ─■──■─Retours
comme un circuit quantique.
Type de retour
clifford_2_2
qiskit.circuit.library.clifford_2_2()
Modèle de Clifford 2_2 :
q_0: ──■────■──
┌─┴─┐┌─┴─┐
q_1: ┤ X ├┤ X ├
└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_2_3
qiskit.circuit.library.clifford_2_3()
Modèle de Clifford 2_3 :
┌───┐┌───┐
q_0: ┤ H ├┤ H ├
└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_2_4
qiskit.circuit.library.clifford_2_4()
Modèle de Clifford 2_4 :
q_0: ─X──X─
│ │
q_1: ─X──X─Retours
comme un circuit quantique.
Type de retour
clifford_3_1
qiskit.circuit.library.clifford_3_1()
Modèle Clifford 3_1 :
┌───┐┌───┐┌───┐
q_0: ┤ S ├┤ S ├┤ Z ├
└───┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_4_1
qiskit.circuit.library.clifford_4_1()
Modèle Clifford 4_1 :
┌───┐
q_0: ──■──┤ X ├──■───X─
┌─┴─┐└─┬─┘┌─┴─┐ │
q_1: ┤ X ├──■──┤ X ├─X─
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
clifford_4_2
qiskit.circuit.library.clifford_4_2()
Modèle de Clifford 4_2 :
q_0: ───────■────────■─
┌───┐┌─┴─┐┌───┐ │
q_1: ┤ H ├┤ X ├┤ H ├─■─
└───┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_4_3
qiskit.circuit.library.clifford_4_3()
Modèle de Clifford 4_3 :
┌───┐ ┌─────┐
q_0: ┤ S ├──■──┤ SDG ├──■──
└───┘┌─┴─┐└─────┘┌─┴─┐
q_1: ─────┤ X ├───────┤ X ├
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
clifford_4_4
qiskit.circuit.library.clifford_4_4()
Modèle de Clifford 4_4 :
┌───┐ ┌─────┐
q_0: ┤ S ├─■─┤ SDG ├─■─
└───┘ │ └─────┘ │
q_1: ──────■─────────■─Retours
comme un circuit quantique.
Type de retour
clifford_5_1
qiskit.circuit.library.clifford_5_1()
Modèle Clifford 5_1 :
q_0: ──■─────────■─────────■── ┌─┴─┐ ┌─┴─┐ │ q_1: ┤ X ├──■──┤ X ├──■────┼── └───┘┌─┴─┐└───┘┌─┴─┐┌─┴─┐ q_2: ─────┤ X ├─────┤ X ├┤ X ├ └───┘ └───┘└───┘
Retours
comme un circuit quantique.
Type de retour
clifford_6_1
qiskit.circuit.library.clifford_6_1()
Gabarit Clifford 6_1 :
┌───┐ ┌───┐┌───┐ q_0: ┤ H ├──■──┤ H ├┤ X ├ ├───┤┌─┴─┐├───┤└─┬─┘ q_1: ┤ H ├┤ X ├┤ H ├──■── └───┘└───┘└───┘
Retours
comme un circuit quantique.
Type de retour
clifford_6_2
qiskit.circuit.library.clifford_6_2()
Modèle de Clifford 6_2 :
┌───┐ q_0: ┤ S ├──■───────────■───■─ ├───┤┌─┴─┐┌─────┐┌─┴─┐ │ q_1: ┤ S ├┤ X ├┤ SDG ├┤ X ├─■─ └───┘└───┘└─────┘└───┘
Retours
comme un circuit quantique.
Type de retour
clifford_6_3
qiskit.circuit.library.clifford_6_3()
Modèle de Clifford 6_3 :
┌───┐ ┌───┐
q_0: ─X──■─┤ H ├──■──┤ X ├─────
│ │ └───┘┌─┴─┐└─┬─┘┌───┐
q_1: ─X──■──────┤ X ├──■──┤ H ├
└───┘ └───┘Retours
comme un circuit quantique.
Type de retour
clifford_6_4
qiskit.circuit.library.clifford_6_4()
Modèle Clifford 6_4 :
global phase: 7π/4
┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐
q: ┤ S ├┤ H ├┤ S ├┤ H ├┤ S ├┤ H ├
└───┘└───┘└───┘└───┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_6_5
qiskit.circuit.library.clifford_6_5()
Modèle Clifford 6_5 :
┌───┐
q_0: ─■───■───┤ S ├───■───────
│ ┌─┴─┐┌┴───┴┐┌─┴─┐┌───┐
q_1: ─■─┤ X ├┤ SDG ├┤ X ├┤ S ├
└───┘└─────┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_8_1
qiskit.circuit.library.clifford_8_1()
Modèle Clifford 8_1 :
┌───┐ ┌───┐ ┌───┐┌─────┐
q_0: ──■───────┤ X ├─┤ S ├─┤ X ├┤ SDG ├
┌─┴─┐┌───┐└─┬─┘┌┴───┴┐└─┬─┘└┬───┬┘
q_1: ┤ X ├┤ H ├──■──┤ SDG ├──■───┤ H ├─
└───┘└───┘ └─────┘ └───┘Retours
comme un circuit quantique.
Type de retour
clifford_8_2
qiskit.circuit.library.clifford_8_2()
Modèle de Clifford 8_2 :
┌───┐
q_0: ──■─────────■───┤ S ├───■────────────
┌─┴─┐┌───┐┌─┴─┐┌┴───┴┐┌─┴─┐┌───┐┌───┐
q_1: ┤ X ├┤ H ├┤ X ├┤ SDG ├┤ X ├┤ S ├┤ H ├
└───┘└───┘└───┘└─────┘└───┘└───┘└───┘Retours
comme un circuit quantique.
Type de retour
clifford_8_3
qiskit.circuit.library.clifford_8_3()
Modèle de Clifford 8_3 :
q_0: ─────────────────■───────────────────────■──
┌───┐┌───┐┌───┐┌─┴─┐┌─────┐┌───┐┌─────┐┌─┴─┐
q_1: ┤ S ├┤ H ├┤ S ├┤ X ├┤ SDG ├┤ H ├┤ SDG ├┤ X ├
└───┘└───┘└───┘└───┘└─────┘└───┘└─────┘└───┘Retours
comme un circuit quantique.
Type de retour
Circuits modèles RZXGate
Circuits types avec RZXGate.
rzx_yz
qiskit.circuit.library.rzx_yz(theta=None)
Modèle basé sur RZX pour CX - RYGate - CX.
┌────────┐ ┌─────────┐┌─────────┐┌──────────┐
q_0: ──■──┤ RY(-ϴ) ├──■──┤ RX(π/2) ├┤0 ├┤ RX(-π/2) ├
┌─┴─┐└────────┘┌─┴─┐└─────────┘│ RZX(ϴ) │└──────────┘
q_1: ┤ X ├──────────┤ X ├───────────┤1 ├────────────
└───┘ └───┘ └─────────┘Paramètres
theta (ParameterExpression |float | None)
rzx_xz
qiskit.circuit.library.rzx_xz(theta=None)
Modèle basé sur RZX pour CX - RXGate - CX.
global phase: π
┌───┐ ┌───┐┌─────────┐┌─────────┐┌─────────┐┌──────────┐»
q_0: ┤ X ├─────────┤ X ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤0 ├»
└─┬─┘┌───────┐└─┬─┘└─────────┘└─────────┘└─────────┘│ Rzx(-ϴ) │»
q_1: ──■──┤ Rx(ϴ) ├──■───────────────────────────────────┤1 ├»
└───────┘ └──────────┘»
« ┌─────────┐┌─────────┐┌─────────┐
«q_0: ┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └─────────┘└─────────┘└─────────┘
«q_1: ─────────────────────────────────
«Paramètres
theta (ParameterExpression |float | None)
rzx_cy
qiskit.circuit.library.rzx_cy(theta=None)
Modèle basé sur RZX pour CX - RYGate - CX.
┌──────────┐
q_0: ──■─────────────■─────────────────────────────────┤0 ├───────────
┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌──────────┐┌───────┐│ RZX(-ϴ) │┌─────────┐
q_1: ┤ X ├┤ RY(ϴ) ├┤ X ├┤ RY(-ϴ) ├┤ RZ(-π/2) ├┤ RX(ϴ) ├┤1 ├┤ RZ(π/2) ├
└───┘└───────┘└───┘└────────┘└──────────┘└───────┘└──────────┘└─────────┘Paramètres
theta (ParameterExpression |float | None)
rzx_zz1
qiskit.circuit.library.rzx_zz1(theta=None)
Modèle basé sur RZX pour CX - RZGate - CX.
global phase: π/2
»
q_0: ──■────────────────────────────────────────────■───────────────────────»
┌─┴─┐┌───────┐┌────┐┌───────┐┌────┐┌────────┐┌─┴─┐┌────────┐┌─────────┐»
q_1: ┤ X ├┤ Rz(ϴ) ├┤ √X ├┤ Rz(π) ├┤ √X ├┤ Rz(3π) ├┤ X ├┤ Rz(-ϴ) ├┤ Rz(π/2) ├»
└───┘└───────┘└────┘└───────┘└────┘└────────┘└───┘└────────┘└─────────┘»
« ┌──────────┐ »
«q_0: ───────────────────────────────┤0 ├──────────────────────»
« ┌─────────┐┌─────────┐┌───────┐│ Rzx(-ϴ) │┌─────────┐┌─────────┐»
«q_1: ┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├»
« └─────────┘└─────────┘└───────┘└──────────┘└─────────┘└─────────┘»
«
«q_0: ───────────
« ┌─────────┐
«q_1: ┤ Rz(π/2) ├
« └─────────┘Paramètres
theta (ParameterExpression |float | None)
rzx_zz2
qiskit.circuit.library.rzx_zz2(theta=None)
Modèle basé sur RZX pour CX - PhaseGate - CX.
global phase: π
»
q_0: ──■────────────■─────────────────────────────────────────────────────»
┌─┴─┐┌──────┐┌─┴─┐┌───────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
q_1: ┤ X ├┤ P(ϴ) ├┤ X ├┤ P(-ϴ) ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├»
└───┘└──────┘└───┘└───────┘└─────────┘└─────────┘└─────────┘└───────┘»
« ┌──────────┐
«q_0: ┤0 ├─────────────────────────────────
« │ Rzx(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
«q_1: ┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └──────────┘└─────────┘└─────────┘└─────────┘Paramètres
theta (ParameterExpression |float | None)
rzx_zz3
qiskit.circuit.library.rzx_zz3(theta=None)
Modèle basé sur RZX pour CX - RZGate - CX.
global phase: π
»
q_0: ──■─────────────■──────────────────────────────────────────────────────»
┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
q_1: ┤ X ├┤ Rz(ϴ) ├┤ X ├┤ Rz(-ϴ) ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├»
└───┘└───────┘└───┘└────────┘└─────────┘└─────────┘└─────────┘└───────┘»
« ┌──────────┐
«q_0: ┤0 ├─────────────────────────────────
« │ Rzx(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
«q_1: ┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └──────────┘└─────────┘└─────────┘└─────────┘Paramètres
theta (ParameterExpression |float | None)