Mabilisang simula

Ipinapakita ng gabay na ito ang isang minimal na gumaganang halimbawa ng package na qiskit-paulice. Gumagamit tayo ng spacetime Pauli checks para madetect ang mga error habang tumatakbo ang isang Clifford circuit, tapos pinipili lang natin ang mga sample na walang natukoy na error (postselection). Para sa mas detalyadong end-to-end na workflow na sumusukat sa pagbuti ng fidelity, tingnan ang malalimang tutorial.

Mga hakbang ng workflow

1. Ihanda ang mga input: isang Clifford payload circuit, ang mga target/ancilla qubit na magho-host ng mga check, at isang noise model.
2. Maghanap ng magagandang spacetime Pauli checks at idagdag ang mga ito sa circuit.
3. I-sample ang circuit na may checks.
4. I-postselect lang ang mga sample na walang natukoy na error.

1. Ihanda ang mga input

Ang add_pauli_checks ay kumukuha ng isang Clifford circuit na nagtatapos sa mga measurement (o, gamit ang stabilizers kwarg, isang walang measurement, tulad ng sa spacetime codes guide), ang mga target qubit na gagamitin para ipatupad ang mga check, at isang noise model na ginagamit para i-score ang mga kandidatong check. Dito, gumagawa tayo ng mababaw na random Clifford circuit, inilalatag ito sa 1D chain ng mga pisikal na qubit sa ibm_boston, ipinapares ang bawat payload qubit sa katabing ancilla (para hindi na kailangan ng SWAP gates ang check), at tinatantya ang magaspang na depolarizing noise model mula sa benchmark data ng backend.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "qiskit_paulice": "qiskit-paulice"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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)

2. Maghanap at magdagdag ng spacetime Pauli checks

Ang add_pauli_checks ay naghahanap ng epektibo at low-weight na mga check sa bawat target qubit at idinadagdag ang mga ito sa circuit, at nagbabalik ng sequence ng mga CheckedCircuit instance. Ang mga CheckedCircuit instance ay may paparaming bilang ng checks, mula sa 0 checks hanggang isang check bawat target qubit. Pinapabuti ng bawat check ang kakayahang mag-detect ng error kapalit ng bahagyang pagtaas ng circuit depth. Sa halimbawang ito, gagamitin natin ang circuit na may check sa bawat target qubit.

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)

3. I-sample ang circuit na may checks

Bago tayo mag-sample, ita-transpile natin ang circuit na may checks papunta sa mga pisikal na qubit (initial_layout = layout + ancilla_qubits) at sa native basis gate set ng ibm_boston. Para gayahin ang maingay na QPU, nagsa-sample tayo gamit ang maingay na Aer stabilizer backend na ang mga error rate ay tugma sa noise_model na ginamit sa pagpili ng mga check.

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

sampled 1000 shots

4. I-postselect ang mga sample na walang natukoy na error

Ang get_postselection_method ay nagma-map ng bawat shot sa syndrome vector nito; pinapanatili lang natin ang mga shot na may all-zero syndrome — yung mga hindi nakatukoy ng error ang anumang check. Ang pagtatapon ng mga na-flag na shot ay nag-aalis ng mga natukoy na error sa natitirang distribution, na nagpapabuti ng fidelity nito kapalit ng mas mababang sampling rate. Tingnan ang tutorial para sa quantitative na paghahambing ng fidelity.

# 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%})")

kept 927 of 1000 shots (93%)