Simulation efficace des circuits stabilisateurs avec les primitives Aer de Qiskit

• 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
  qiskit-aer~=0.17
  

Cette page montre comment utiliser les primitives de Qiskit Aer pour simuler efficacement des circuits stabilisateurs, y compris ceux soumis au bruit de Pauli.

Les circuits stabilisateurs, également connus sous le nom de circuits de Clifford, constituent une classe restreinte importante de circuits quantiques qui peuvent être efficacement simulés de manière classique. Il existe plusieurs façons équivalentes de définir les circuits stabilisateurs. Une définition est qu'un circuit stabilisateur est un circuit quantique composé uniquement des portes suivantes :

• expérience client
• Hadamard
• S
• Mesure

Notez qu'en utilisant Hadamard et S, nous pouvons construire n'importe quelle porte de rotation de Pauli ( $R_x$, $R_y$, et $R_z$ ) dont l'angle est contenu dans l'ensemble $\{0, \frac{\pi}{2}, \pi, \frac{3\pi}{2}\}$ (jusqu'à la phase globale), de sorte que nous pouvons également inclure ces portes dans la définition.

Les circuits stabilisateurs sont importants pour l'étude de la correction quantique des erreurs. Leur simulabilité classique les rend également utiles pour vérifier les résultats des ordinateurs quantiques. Par exemple, supposons que vous souhaitiez exécuter un circuit quantique utilisant 100 qubits sur un ordinateur quantique. Comment savoir si l'ordinateur quantique se comporte correctement? Un circuit quantique de 100 qubits est hors de portée d'une simulation classique par force brute. En modifiant votre circuit pour qu'il devienne un circuit stabilisateur, vous pouvez exécuter sur l'ordinateur quantique des circuits dont la structure est similaire à celle du circuit souhaité, mais que vous pouvez simuler sur un ordinateur classique. En vérifiant la sortie de l'ordinateur quantique sur les circuits stabilisateurs, vous pouvez être sûr qu'il se comporte correctement sur les circuits non stabilisateurs également. Voir Evidence for the utility of quantum computing before fault tolerance pour un exemple de cette idée en pratique.

La simulation exacte et bruyante avec les primitives Qiskit Aer montre comment utiliser Qiskit Aer pour effectuer des simulations exactes et bruyantes de circuits quantiques génériques. Prenons l'exemple du circuit utilisé dans cet article, un circuit de 8 qubits construit à l'aide d'un système efficace (efficient_su2) :

from qiskit.circuit.library import efficient_su2

n_qubits = 8
circuit = efficient_su2(n_qubits)
circuit.draw("mpl")

Output:

En utilisant Qiskit Aer, nous avons pu simuler ce circuit facilement. Cependant, supposons que nous fixions le nombre de qubits à 500 :

n_qubits = 500
circuit = efficient_su2(n_qubits)
# don't try to draw the circuit because it's too large

Étant donné que le coût de la simulation des circuits quantiques augmente de façon exponentielle avec le nombre de qubits, un circuit de cette taille dépasserait généralement les capacités d'un simulateur aussi performant que Qiskit Aer. La simulation classique de circuits quantiques génériques devient infaisable lorsque le nombre de qubits dépasse environ 50 à 100 qubits. Il convient toutefois de noter que le circuit efficient_su2 est paramétré par des angles sur les portes $R_y$ et $R_z$. Si tous ces angles sont contenus dans l'ensemble $\{0, \frac{\pi}{2}, \pi, \frac{3\pi}{2}\}$, alors le circuit est un circuit stabilisateur et il peut être simulé efficacement!

Dans la cellule suivante, nous exécutons le circuit avec la primitive Échantillonneur soutenue par le simulateur de circuit stabilisateur, en utilisant des paramètres choisis au hasard de sorte que le circuit soit garanti comme étant un circuit stabilisateur.

import numpy as np
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import SamplerV2 as Sampler

measured_circuit = circuit.copy()
measured_circuit.measure_all()

rng = np.random.default_rng(1234)
params = rng.choice(
    [0, np.pi / 2, np.pi, 3 * np.pi / 2],
    size=circuit.num_parameters,
)

# Initialize a Sampler backed by the stabilizer circuit simulator
exact_sampler = Sampler(
    options=dict(backend_options=dict(method="stabilizer"))
)
# The circuit needs to be transpiled to the AerSimulator target
pass_manager = generate_preset_pass_manager(
    1, AerSimulator(method="stabilizer")
)
isa_circuit = pass_manager.run(measured_circuit)
pub = (isa_circuit, params)
job = exact_sampler.run([pub])
result = job.result()
pub_result = result[0]
counts = pub_result.data.meas.get_counts()

Le simulateur de circuit de stabilisation prend également en charge la simulation bruyante, mais seulement pour une classe restreinte de modèles de bruit. Plus précisément, tout bruit quantique doit être caractérisé par un canal d' erreur de Pauli. L' erreur de dépolarisation entre dans cette catégorie et peut donc être simulée. Les canaux de bruit classiques tels que l' erreur de lecture peuvent également être simulés.

La cellule de code suivante exécute la même simulation que précédemment, mais en spécifiant cette fois un modèle de bruit qui ajoute une erreur de dépolarisation de 2 % à chaque porte CX, ainsi qu'une erreur de lecture qui renverse chaque bit mesuré avec une probabilité de 5 %.

from qiskit_aer.noise import NoiseModel, depolarizing_error, ReadoutError

noise_model = NoiseModel()
cx_depolarizing_prob = 0.02
bit_flip_prob = 0.05
noise_model.add_all_qubit_quantum_error(
    depolarizing_error(cx_depolarizing_prob, 2), ["cx"]
)
noise_model.add_all_qubit_readout_error(
    ReadoutError(
        [
            [1 - bit_flip_prob, bit_flip_prob],
            [bit_flip_prob, 1 - bit_flip_prob],
        ]
    )
)

noisy_sampler = Sampler(
    options=dict(
        backend_options=dict(method="stabilizer", noise_model=noise_model)
    )
)
job = noisy_sampler.run([pub])
result = job.result()
pub_result = result[0]
counts = pub_result.data.meas.get_counts()

Utilisons maintenant la primitive Estimateur soutenue par le simulateur de stabilisateur pour calculer la valeur de l'espérance de l'observable $ZZ \cdots Z$. En raison de la structure particulière des circuits stabilisateurs, le résultat a de fortes chances d'être égal à 0.

from qiskit.quantum_info import SparsePauliOp
from qiskit_aer.primitives import EstimatorV2 as Estimator

observable = SparsePauliOp("Z" * n_qubits)

exact_estimator = Estimator(
    options=dict(backend_options=dict(method="stabilizer")),
)
isa_circuit = pass_manager.run(circuit)
pub = (isa_circuit, observable, params)
job = exact_estimator.run([pub])
result = job.result()
pub_result = result[0]
exact_value = float(pub_result.data.evs)
exact_value

Output:

0.0

Etapes suivantes