Effiziente Simulation von Stabilisierungsschaltungen mit Qiskit Aer-Primitiven

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

  qiskit[all]~=2.5.2
  qiskit-aer~=0.17
  

Diese Seite zeigt, wie Qiskit Aer Primitive verwendet werden können, um Stabilisatorschaltungen effizient zu simulieren, einschließlich solcher, die Pauli-Rauschen unterliegen.

Stabilisatorschaltungen, auch bekannt als Clifford-Schaltungen, sind eine wichtige eingeschränkte Klasse von Quantenschaltungen, die effizient klassisch simuliert werden können. Es gibt mehrere gleichwertige Möglichkeiten, Stabilisierungsschaltungen zu definieren. Eine Definition besagt, dass eine Stabilisierungsschaltung eine Quantenschaltung ist, die ausschließlich aus den folgenden Gattern besteht:

• CX
• Hadamard
• S
• Messwert

Man beachte, dass man mit Hilfe von Hadamard und S ein beliebiges Pauli-Drehungstor konstruieren kann ( $R_x$, $R_y$, und $R_z$ ) konstruieren kann, dessen Winkel in der Menge $\{0, \frac{\pi}{2}, \pi, \frac{3\pi}{2}\}$ (bis zur globalen Phase) enthalten ist, so dass wir auch diese Gatter in die Definition einbeziehen können.

Stabilisierungsschaltungen sind wichtig für die Untersuchung der Quantenfehlerkorrektur. Aufgrund ihrer klassischen Simulierbarkeit eignen sie sich auch zur Überprüfung der Leistung von Quantencomputern. Nehmen wir zum Beispiel an, Sie wollen einen Quantenschaltkreis mit 100 Qubits auf einem Quantencomputer ausführen. Woher weiß man, dass sich der Quantencomputer korrekt verhält? Ein Quantenschaltkreis mit 100 Qubits übersteigt die Möglichkeiten einer klassischen Brute-force-Simulation. Indem Sie Ihre Schaltung so modifizieren, dass sie zu einer Stabilisierungsschaltung wird, können Sie auf dem Quantencomputer Schaltungen ausführen, die eine ähnliche Struktur wie Ihre gewünschte Schaltung haben, die Sie aber auf einem klassischen Computer simulieren können. Wenn Sie die Leistung des Quantencomputers an den Stabilisatorschaltungen überprüfen, können Sie sicher sein, dass er sich auch an den Nicht-Stabilisatorschaltungen korrekt verhält. Ein Beispiel für diese Idee in der Praxis finden Sie unter Beweise für den Nutzen der Quanteninformatik vor der Fehlertoleranz.

Exakte und verrauschte Simulationen mit Qiskit Aer Primitiven zeigt, wie man Qiskit Aer verwendet, um exakte und verrauschte Simulationen von generischen Quantenschaltungen durchzuführen. Betrachten Sie die in diesem Artikel verwendete Beispielschaltung, eine 8-Qubit-Schaltung, die mit efficient_su2 gebaut wurde:

from qiskit.circuit.library import efficient_su2

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

Output:

Mit Qiskit Aer konnten wir diese Schaltung leicht simulieren. Nehmen wir jedoch an, wir setzen die Anzahl der Qubits auf 500:

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

Da die Kosten für die Simulation von Quantenschaltungen exponentiell mit der Anzahl der Qubits skalieren, würde eine so große Schaltung im Allgemeinen selbst die Möglichkeiten eines Hochleistungssimulators wie Qiskit Aer übersteigen. Die klassische Simulation allgemeiner Quantenschaltungen wird undurchführbar, wenn die Anzahl der Qubits etwa 50 bis 100 Qubits übersteigt. Beachten Sie jedoch, dass die efficient_su2 Schaltung durch Winkel auf $R_y$ und $R_z$ Gattern parametrisiert ist. Wenn alle diese Winkel in der Menge $\{0, \frac{\pi}{2}, \pi, \frac{3\pi}{2}\}$ enthalten sind, dann ist die Schaltung eine Stabilisatorschaltung, und sie kann effizient simuliert werden!

In der folgenden Zelle führen wir die Schaltung mit dem Sampler-Primitiv aus, das durch den Stabilisator-Schaltungssimulator unterstützt wird, und verwenden dabei zufällig ausgewählte Parameter, so dass die Schaltung garantiert eine Stabilisator-Schaltung ist.

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

Der Stabilisator-Schaltungssimulator unterstützt auch die Simulation von Rauschen, allerdings nur für eine begrenzte Klasse von Rauschmodellen. Insbesondere muss jedes Quantenrauschen durch einen Pauli-Fehlerkanal gekennzeichnet sein. Der Depolarisationsfehler fällt in diese Kategorie, so dass er ebenfalls simuliert werden kann. Klassische Rauschkanäle wie Auslesefehler können ebenfalls simuliert werden.

Die folgende Codezelle führt dieselbe Simulation wie zuvor aus, aber diesmal mit einem Rauschmodell, das jedem CX-Gatter einen Depolarisationsfehler von 2 % hinzufügt, sowie einen Auslesefehler, der jedes gemessene Bit mit einer Wahrscheinlichkeit von 5 % umkehrt.

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

Verwenden wir nun das Estimator-Primitiv, das vom Stabilisatorsimulator unterstützt wird, um den Erwartungswert der Beobachtungsgröße $ZZ \cdots Z$ zu berechnen. Aufgrund der besonderen Struktur von Stabilisatorschaltungen ist das Ergebnis sehr wahrscheinlich 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

Nächste Schritte