Inicio rápido

Esta guía muestra un ejemplo mínimo y funcional del paquete qiskit-paulice . Utilizamos comprobaciones de Pauli en el espaciotiempo para detectar errores durante la ejecución de un circuito de Clifford y, a continuación, seleccionamos a posteriori únicamente las muestras en las que no se ha detectado ningún error. Para conocer un flujo de trabajo completo y más detallado que cuantifica la mejora de la fidelidad, consulta el tutorial detallado.

Pasos de flujo de trabajo

1. Prepara los datos de entrada: un circuito de carga útil de Clifford, los qubits objetivo y auxiliares que albergarán las comprobaciones, y un modelo de ruido.
2. Busca buenas comprobaciones de Pauli en el espaciotiempo y añádelas al circuito.
3. Comprueba el circuito marcado.
4. Selecciona únicamente las muestras en las que no se haya detectado ningún error.

1. Preparar los datos de entrada

add_pauli_checks toma un circuito de Clifford con al menos una medición en un terminal, los qubits objetivo que se utilizarán para implementar las comprobaciones y un modelo de ruido que se emplea para evaluar las comprobaciones candidatas. ibm_bostonAquí construimos un circuito de Clifford aleatorio de poca profundidad, lo distribuimos en una cadena « 1D » de qubits físicos, emparejamos cada qubit de carga útil con un qubit auxiliar vecino (de modo que una comprobación no requiera puertas SWAP) e inferimos un modelo aproximado de ruido despolarizante a partir de los datos de referencia del backend.

import numpy as np
from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_paulice.layout import get_check_qubits
from qiskit_paulice.noise_models import NoiseModel

# Backend and a 1D chain of physical qubits to run on
backend = QiskitRuntimeService().backend("ibm_boston")
layout = [68, 69, 78, 89, 90, 91, 98, 111, 112, 113, 119, 133]

# A shallow brickwork random Clifford payload circuit
rng = np.random.default_rng(1764)
circuit = QuantumCircuit(len(layout))
circuit.h(range(circuit.num_qubits))
for d in range(4):
    for i in range(d % 2, circuit.num_qubits - 1, 2):
        circuit.cz(i, i + 1)
    for q in range(circuit.num_qubits):
        if rng.integers(0, 2):
            circuit.sx(q)
        if rng.integers(0, 2):
            circuit.s(q)
circuit.measure_all()

# Pair each payload qubit with a neighboring ancilla to host a check (no SWAPs needed)
target_qubits, ancilla_qubits = get_check_qubits(backend.coupling_map, layout)

# A rough depolarizing noise model from backend benchmark data, used to score checks
noise_model = NoiseModel.from_backend(
    backend, layout, uniform_gate_noise=True
)

circuit.draw("mpl", fold=-1)

Output:

2. Buscar e incorporar comprobaciones de Pauli en el espaciotiempo

add_pauli_checks busca comprobaciones eficaces y de bajo peso para cada qubit objetivo y las añade al circuito, devolviendo una secuencia de CheckedCircuit instancias. Las CheckedCircuit instancias contienen un número creciente de comprobaciones, desde 0 comprobaciones hasta una comprobación por qubit objetivo. Cada comprobación mejora la capacidad de detección de errores, a costa de un ligero aumento de la profundidad del circuito. En este ejemplo utilizaremos el circuito con una comprobación en cada qubit objetivo.

from qiskit_paulice import add_pauli_checks

# The circuit has virtual qubits, so we specify our target qubits with virtual indices
target_qubits_v = [layout.index(q) for q in target_qubits]

# Add spacetime Pauli checks
checked_circuit = add_pauli_checks(circuit, target_qubits_v, noise_model)[-1]
checked_circuit.circuit.draw("mpl", fold=-1, scale=0.4, idle_wires=False)

Output:

3. Realizar una prueba del circuito comprobado

ibm_bostonAntes de realizar el muestreo, transpilamos el circuito comprobado a qubits físicos (initial_layout = layout + ancilla_qubits) y al conjunto de puertas de la base nativa de. Para emular una QPU con ruido, realizamos un muestreo con un backend estabilizador Aer con ruido cuyas tasas de error coinciden con las noise_model utilizadas para seleccionar las comprobaciones.

from qiskit import transpile
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel as AerNoiseModel
from qiskit_aer.noise import ReadoutError, depolarizing_error

# Transpile once: lay the checked circuit out on our qubits and into the native basis
isa_circuit = transpile(
    checked_circuit.circuit,
    backend,
    initial_layout=layout + ancilla_qubits,
    optimization_level=0,
)

# Build an Aer noise model matching the depolarizing model used to pick checks
aer_noise = AerNoiseModel()
aer_noise.add_all_qubit_quantum_error(
    depolarizing_error(noise_model.gate_noise, 2), ["cz"]
)
p = noise_model.readout_noise
aer_noise.add_all_qubit_readout_error(ReadoutError([[1 - p, p], [p, 1 - p]]))
simulator = AerSimulator(method="stabilizer", noise_model=aer_noise)

counts = (
    simulator.run(isa_circuit, shots=1000, seed_simulator=1764)
    .result()
    .get_counts()
)
print(f"sampled {sum(counts.values())} shots")

Output:

sampled 1000 shots

4. Muestras seleccionadas a posteriori en las que no se ha detectado ningún error

get_postselection_method asigna cada toma a su vector de síndrome; solo conservamos las tomas con un síndrome compuesto íntegramente por ceros, es decir, aquellas en las que ninguna comprobación detectó ningún error. Al descartar las tomas marcadas, se eliminan los errores detectados de la distribución resultante, lo que mejora su fidelidad a costa de una menor frecuencia de muestreo. Consulta el tutorial para ver una comparación cuantitativa de la fidelidad.

# Keep only the shots in which no check reported an error
ps_fn = checked_circuit.get_postselection_method()
counts_postselected = {
    bs: n for bs, n in counts.items() if not ps_fn(bs).any()
}

kept, total = sum(counts_postselected.values()), sum(counts.values())
print(f"kept {kept} of {total} shots ({kept / total:.0%})")

Output:

kept 927 of 1000 shots (93%)