Bibliothèque de circuits

• Versions de package

  Le code de cette page a été développé en tenant compte des exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

  qiskit[all]~=2.5.1
  

Le SDK Qiskit comprend une bibliothèque de circuits populaires à utiliser comme blocs de construction dans vos propres programmes. L'utilisation de circuits prédéfinis permet de gagner du temps dans la recherche, l'écriture du code et le débogage. La bibliothèque comprend des circuits populaires en informatique quantique, des circuits difficiles à simuler classiquement et des circuits utiles pour l'évaluation comparative du matériel quantique.

Cette page présente les différentes catégories de circuits proposées par la bibliothèque. Pour une liste complète des circuits, voir la documentation de l'API de la bibliothèque de circuits.

Portails standard

La bibliothèque de circuits comprend également des portes quantiques standard. Certaines sont des portes plus fondamentales (comme la porte UGate), et d'autres sont des portes multi-qubits qui doivent généralement être construites à partir de portes à un ou deux qubits. Pour ajouter des portes importées à votre circuit, utilisez la méthode append ; le premier argument est la porte, et le suivant une liste de qubits auxquels appliquer la porte.

Par exemple, la cellule de code suivante crée un circuit avec une porte de Hadamard et une porte X multicontrôlée.

from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, MCXGate

mcx_gate = MCXGate(3)
hadamard_gate = HGate()

qc = QuantumCircuit(4)
qc.append(hadamard_gate, [0])
qc.append(mcx_gate, [0, 1, 2, 3])
qc.draw("mpl")

Output:

Voir Portes standard dans la documentation API de la bibliothèque de circuits.

Circuits N-locaux

Ces circuits alternent des couches de portes de rotation à quotient unique avec des couches de portes d'enchevêtrement à quotient multiple.

Cette famille de circuits est populaire dans les algorithmes quantiques variationnels car ils peuvent produire une large gamme d'états quantiques. Les algorithmes variationnels ajustent les paramètres de la porte pour trouver des états présentant certaines propriétés (par exemple, des états représentant une bonne solution à un problème d'optimisation). À cette fin, de nombreux circuits de la bibliothèque sont paramétrés, ce qui signifie que vous pouvez les définir sans valeurs fixes.

La cellule de code suivante importe un circuit n_local , dans lequel les portes d'intrication sont des portes à deux qubits. Ce circuit entrelace des blocs de portes paramétrées à un qubit, suivis de blocs enchevêtrés de portes à deux qubits. Le code suivant crée un circuit à trois qubits, avec des portes RX à un qubit et des portes CZ à deux qubits.

from qiskit.circuit.library import n_local

two_local = n_local(3, "rx", "cz")
two_local.draw("mpl")

Output:

L'attribut parameters permet d'obtenir un objet de type liste des paramètres du circuit.

two_local.parameters

Output:

ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])

Vous pouvez également l'utiliser pour affecter ces paramètres à des valeurs réelles à l'aide d'un dictionnaire de la forme { Parameter: number }. En guise de démonstration, la cellule de code suivante affecte chaque paramètre du circuit à 0.

bound_circuit = two_local.assign_parameters(
    {p: 0 for p in two_local.parameters}
)
bound_circuit.decompose().draw("mpl")

Output:

Pour plus d'informations, voir les portes N-locales dans la documentation API de la bibliothèque de circuits ou suivre le cours de conception d'algorithmes variationnels sur IBM Quantum Learning.

Circuits de codage de données

Ces circuits paramétrés encodent des données dans des états quantiques qui sont traités par des algorithmes d'apprentissage automatique quantique. Les circuits pris en charge par Qiskit sont les suivants

• Le codage de l'amplitude, qui code chaque nombre en fonction de l'amplitude d'un état de base. Cette méthode permet de stocker $2^n$ numéros dans un seul état, mais sa mise en œuvre peut s'avérer coûteuse.
• Le codage de base, qui code un entier $k$ en préparant l'état de base correspondant $|k\rangle$.
• Le codage angulaire, qui définit chaque nombre dans les données comme un angle de rotation dans un circuit paramétré.

La meilleure approche dépend des spécificités de votre application. Sur les ordinateurs quantiques actuels, cependant, nous utilisons souvent des circuits de codage d'angle tels que le zz_feature_map.

from qiskit.circuit.library import zz_feature_map

features = [0.2, 0.4, 0.8]
feature_map = zz_feature_map(feature_dimension=len(features))

encoded = feature_map.assign_parameters(features)
encoded.draw("mpl")

Output:

Voir circuits de codage des données dans la documentation API de la bibliothèque de circuits.

Circuits à évolution temporelle

Ces circuits simulent un état quantique évoluant dans le temps. Utiliser des circuits d'évolution temporelle pour étudier des effets physiques tels que le transfert de chaleur ou les transitions de phase dans un système. Les circuits d'évolution temporelle sont également un élément fondamental des fonctions d'onde de la chimie (telles que les états d'essai unitaires couplés-cluster) et de l'algorithme QAOA que nous utilisons pour les problèmes d'optimisation.

from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp


# Prepare an initial state with a Hadamard on the middle qubit
state = QuantumCircuit(3)
state.h(1)

hamiltonian = SparsePauliOp(["ZZI", "IZZ"])
evolution = PauliEvolutionGate(hamiltonian, time=1)

# Evolve state by appending the evolution gate
state.compose(evolution, inplace=True)

state.draw("mpl")

Output:

Consultez la documentation de l'API PauliEvolutionGate .

Circuits de référence et théorie de la complexité

Les circuits d'étalonnage nous donnent une idée de la qualité du fonctionnement de notre matériel, et les circuits de la théorie de la complexité nous aident à comprendre la difficulté des problèmes que nous voulons résoudre.

Par exemple, le critère "volume quantique" mesure la précision avec laquelle un ordinateur quantique exécute un type de circuit quantique aléatoire. Le score de l'ordinateur quantique augmente avec la taille du circuit qu'il peut exécuter de manière fiable. Cela prend en compte tous les aspects de l'ordinateur, y compris le nombre de qubits, la fidélité des instructions, la connectivité des qubits et la pile logicielle qui transpose et post-traite les résultats. Pour en savoir plus sur le volume quantique, consultez l' article original sur le volume quantique.

Le code suivant montre un exemple de circuit de volume quantique construit dans Qiskit qui fonctionne sur quatre qubits (les blocs unitary sont des portes aléatoires à deux qubits).

from qiskit.circuit.library import quantum_volume

quantum_volume(4).draw("mpl")

Output:

La bibliothèque de circuits comprend également des circuits considérés comme difficiles à simuler classiquement, tels que les circuits polynomiaux quantiques instantanés (iqp). Ces circuits prennent en sandwich certaines portes diagonales (dans la base de calcul) entre des blocs de portes de Hadamard.

D'autres circuits comprennent grover_operator pour l'algorithme de Grover et le circuit fourier_checking pour le problème de vérification de Fourier. Voir ces circuits dans la section Circuits quantiques particuliers de la documentation API de la bibliothèque de circuits.

Circuits arithmétiques

Les opérations arithmétiques sont des fonctions classiques, telles que l'addition de nombres entiers et les opérations sur les bits. Ceux-ci peuvent être utiles pour des algorithmes tels que l'estimation d'amplitude pour les applications financières, et pour des algorithmes tels que l'algorithme HHL, qui résout des systèmes d'équations linéaires.

À titre d'exemple, essayons d'additionner deux nombres de trois bits à l'aide d'un circuit "ripple-carry" pour effectuer une addition in-place (FullAdderGate). Cet additionneur additionne deux nombres (que nous appellerons "A" et "B") et écrit le résultat dans le registre qui contenait B. Dans l'exemple suivant, A=2 et B=3.

from qiskit.circuit.library import FullAdderGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

adder = FullAdderGate(3)  # Adder of 3-bit numbers

# Create the number A=2
reg_a = QuantumRegister(3, "a")
number_a = QuantumCircuit(reg_a)
number_a.initialize(2)  # Number 2; |010>

# Create the number B=3
reg_b = QuantumRegister(3, "b")
number_b = QuantumCircuit(reg_b)
number_b.initialize(3)  # Number 3; |011>

# Create a circuit to hold everything, including a classical register for
# the result
qregs = [
    QuantumRegister(1, "cin"),
    QuantumRegister(3, "a"),
    QuantumRegister(3, "b"),
    QuantumRegister(1, "cout"),
]
reg_result = ClassicalRegister(3)
circuit = QuantumCircuit(*qregs, reg_result)

# Compose number initializers with the adder. Adder stores the result to
# register B, so we'll measure those qubits.
circuit = (
    circuit.compose(number_a, qubits=reg_a)
    .compose(number_b, qubits=reg_b)
    .compose(adder)
)
circuit.measure(reg_b, reg_result)
circuit.draw("mpl")

Output:

La simulation du circuit montre qu'il émet 5 pour tous les tirs 1024 (c'est-à-dire qu'il est mesuré avec la probabilité 1.0).

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([circuit]).result()

print(f"Count data:\n {result[0].data.c0.get_int_counts()}")

Output:

Count data:
 {5: 1024}

Voir Arithmétique dans la documentation API de la bibliothèque de circuits.

Etapes suivantes