Simulazione efficiente dei circuiti stabilizzatori con le primitive Aer di Qiskit

• Versioni del pacchetto

  Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti. Si consiglia di utilizzare queste versioni o versioni più recenti.

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

Questa pagina mostra come utilizzare le primitive di Qiskit Aer per simulare in modo efficiente i circuiti stabilizzatori, compresi quelli soggetti al rumore di Pauli.

I circuiti stabilizzatori, noti anche come circuiti di Clifford, sono un'importante classe ristretta di circuiti quantistici che possono essere simulati in modo efficiente in modo classico. Esistono diversi modi equivalenti per definire i circuiti stabilizzatori. Una definizione è che un circuito stabilizzatore è un circuito quantistico che consiste unicamente nelle seguenti porte:

• CX
• Hadamard
• S
• Misurazione

Si noti che utilizzando Hadamard e S, possiamo costruire qualsiasi porta di rotazione di Pauli ( $R_x$, $R_y$, e $R_z$ ) che ha un angolo contenuto nell'insieme $\{0, \frac{\pi}{2}, \pi, \frac{3\pi}{2}\}$ (fino alla fase globale), quindi possiamo includere anche questi gate nella definizione.

I circuiti stabilizzatori sono importanti per lo studio della correzione quantistica degli errori. La loro simulabilità classica li rende utili anche per verificare l'output dei computer quantistici. Ad esempio, supponiamo di voler eseguire un circuito quantistico che utilizza 100 qubit su un computer quantistico. Come si fa a sapere che il computer quantistico si comporta correttamente? Un circuito quantistico su 100 qubit è fuori dalla portata della simulazione classica a forza bruta. Modificando il circuito in modo che diventi un circuito stabilizzatore, è possibile eseguire sul computer quantistico circuiti che hanno una struttura simile al circuito desiderato, ma che è possibile simulare su un computer classico. Controllando l'uscita del computer quantistico sui circuiti stabilizzatori, si può avere la certezza che si comporti correttamente anche sui circuiti non stabilizzatori. Per un esempio di questa idea nella pratica, si veda Evidence for the utility of quantum computing before fault tolerance.

Simulazione esatta e rumorosa con le primitive di Qiskit Aer mostra come utilizzare Qiskit Aer per eseguire simulazioni esatte e rumorose di generici circuiti quantistici. Si consideri il circuito di esempio utilizzato in quell'articolo, un circuito a 8-qubit costruito utilizzando l' efficiente Su2 :

from qiskit.circuit.library import efficient_su2

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

Output:

Utilizzando Qiskit Aer, siamo riusciti a simulare facilmente questo circuito. Tuttavia, supponiamo di impostare il numero di qubit a 500:

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

Poiché il costo della simulazione dei circuiti quantistici scala esponenzialmente con il numero di qubit, un circuito di tali dimensioni supererebbe in genere le capacità anche di un simulatore ad alte prestazioni come Qiskit Aer. La simulazione classica di circuiti quantistici generici diventa impraticabile quando il numero di qubit supera approssimativamente i 50-100 qubit. Tuttavia, si noti che il circuito efficient_su2 è parametrizzato dagli angoli sulle porte $R_y$ e $R_z$. Se tutti questi angoli sono contenuti nell'insieme $\{0, \frac{\pi}{2}, \pi, \frac{3\pi}{2}\}$, allora il circuito è un circuito stabilizzatore e può essere simulato in modo efficiente!

Nella cella seguente, eseguiamo il circuito con la primitiva Sampler supportata dal simulatore di circuito stabilizzatore, utilizzando parametri scelti a caso in modo che il circuito sia garantito come circuito stabilizzatore.

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

Il simulatore di circuiti stabilizzatori supporta anche la simulazione rumorosa, ma solo per una classe ristretta di modelli di rumore. In particolare, qualsiasi rumore quantistico deve essere caratterizzato da un canale di errore Pauli. L 'errore di depolarizzazione rientra in questa categoria, quindi può essere simulato. È possibile simulare anche canali di rumore classici come l' errore di lettura.

La cella di codice seguente esegue la stessa simulazione di prima, ma questa volta specificando un modello di rumore che aggiunge un errore di depolarizzazione del 2% a ciascun gate CX, nonché un errore di lettura che capovolge ogni bit misurato con una probabilità del 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()

Utilizziamo ora la primitiva Estimator supportata dal simulatore di stabilizzatori per calcolare il valore di aspettativa dell'osservabile $ZZ \cdots Z$. A causa della particolare struttura dei circuiti di stabilizzazione, è molto probabile che il risultato sia pari a 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

Passi successivi