{
"cells": [
{
"cell_type": "markdown",
"id": "frontmatter",
"metadata": {},
"source": [
"---\n",
"title: \"Rilevamento degli errori a basso overhead con codici spazio-temporali\"\n",
"description: \"Inserire automaticamente i controlli di Pauli nello spazio-tempo con qiskit-paulice e aumentare la fedeltà dei circuiti di Clifford campionati tramite post-selezione sui sindromi di controllo.\"\n",
"---\n",
"\n",
"{/* cspell:ignore postsel, frameon, virt */}\n",
"\n",
"\n",
"\n",
"# Rilevamento degli errori a basso overhead con codici spazio-temporali\n",
"\n",
"Stima del tempo di *esecuzione: 4 minuti su un processore Heron (`ibm_kingston` o equivalente) (NOTA: si tratta solo di una stima). (La durata potrebbe variare.)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "learning-outcomes",
"metadata": {},
"source": [
"\n",
"\n",
"## Risultati di apprendimento\n",
"\n",
"Al termine di questo tutorial, avrai acquisito le seguenti conoscenze:\n",
"\n",
"* In che modo i controlli di Pauli sullo spazio-tempo individuano gli errori logici nei circuiti di Clifford e in che modo la post-selezione sulle loro sindromi aumenta la fedeltà di una distribuzione campionata.\n",
"* Come utilizzare il pacchetto `qiskit-paulice` per individuare e inserire automaticamente controlli ottimizzati a livello hardware con `get_check_qubits`, `NoiseModel`, e `add_pauli_checks`.\n",
"* Come stimare la fedeltà di uno stato stabilizzatore mediante campionamento dei suoi stabilizzatori e post-selezione sui sindromi di controllo.\n",
"* Come eseguire il flusso di lavoro completo di rilevamento degli errori su un hardware \" IBM Quantum® \" e confrontare le fedeltà \"noisy\" e \"postselected\".\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "prerequisites",
"metadata": {},
"source": [
"\n",
"\n",
"## Prerequisiti\n",
"\n",
"Si consiglia di approfondire i seguenti argomenti:\n",
"\n",
"* [Nozioni fondamentali sull'hardware](/learning/courses/utility-scale-quantum-computing/hardware) per il calcolo quantistico su scala industriale.\n",
"* Il formalismo di Clifford e dello stabilizzatore, compreso il modo in cui un gruppo stabilizzatore descrive uno stato stabilizzatore puro.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "background",
"metadata": {},
"source": [
"\n",
"\n",
"## Sfondo\n",
"\n",
"[L'articolo \"Rilevamento degli errori a basso overhead con codici spazio-temporali](https://arxiv.org/abs/2504.15725)[ \" \\[1\\]](#references) di Simon Martiel e Ali Javadi-Abhari introduce un metodo per il rilevamento degli errori logici nei circuiti dominati da Clifford che si colloca a metà strada tra la correzione completa degli errori e la mitigazione degli errori, che comporta un carico inferiore. L'idea si basa sui controlli di Pauli coerenti (CPC) descritti nell'articolo \" [Mitigazione degli errori in](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.5.033193) modalità single-shot tramite controlli di Pauli coerenti [\" \\[2\\]](#references) di van den Berg e altri. In entrambi gli approcci, un circuito Clifford “payload” viene intrecciato con i qubit ancillari per verificare determinati invarianti. La misurazione delle ancille genera una sindrome che segnala se è stato rilevato un errore durante l'esecuzione. Mantenere solo i campioni in cui non è stato rilevato alcun errore migliora la fedeltà della distribuzione campionaria, a scapito di un tasso di post-selezione ridotto.\n",
"\n",
"La differenza fondamentale tra i controlli coerenti di Pauli e i controlli spazio-temporali risiede negli operatori che misurano. I controlli di Pauli coerenti misurano operatori localizzati nel tempo e ad alto peso. Nelle topologie di qubit con connettività limitata, come l’“heavy hex”, tali verifiche richiedono un numero elevato di porte SWAP e spesso rendono il circuito troppo complesso per poter essere eseguito nella pratica. Implementando invece i controlli come codici spazio-temporali, ciascun controllo viene distribuito lungo il circuito di carico utile nello spazio e nel tempo. Ciò consente una codifica efficiente dal punto di vista hardware, che rimane efficace nel rilevare gli errori logici mantenendo al contempo basso il sovraccarico in termini di qubit e profondità.\n",
"\n",
"\n",
"\n",
"### Cosa fa il pacchetto `qiskit-paulice`\n",
"\n",
"Il pacchetto `qiskit-paulice` automatizza la creazione di questi controlli, in modo da non doverli creare manualmente. Il suo ruolo principale è quello di individuare e inserire controlli di Pauli spazio-temporali validi nei punti del circuito che massimizzano il rilevamento degli errori riducendo al minimo il sovraccarico dei qubit. Un controllo è *valido* quando i suoi operatori lasciano inalterata l’azione logica del circuito di carico utile, *è a basso peso* quando utilizza poche porte di entanglement ed *è efficace* quando rileva una porzione consistente degli errori, rispetto al rumore introdotto dal controllo stesso. Il pacchetto valuta i controlli dei candidati rispetto a un modello di rumore e inserisce quelli migliori nel circuito. Questo tutorial utilizza tre metodi API:\n",
"\n",
"* `get_check_qubits` esamina una mappa di accoppiamento del backend e restituisce coppie di qubit bersaglio e ancilla. Un controllo su utilizza `target_qubits[i]` `ancilla_qubits[i]`.\n",
"* `NoiseModel.from_backend` crea un modello approssimativo del rumore sulla base dei dati dei benchmark del backend. Il modello assegna un punteggio ai controlli dei candidati, pertanto non è necessario un modello di rumore esatto e appreso. Per un modello di Pauli-Lindblad appreso, si veda [`NoiseModel.from_pauli_lindblad_maps`](/docs/api/qiskit-addon-paulice/qiskit-paulice-noise-models#from_pauli_lindblad_maps).\n",
"* `add_pauli_checks` individua e inserisce i controlli in un circuito. Restituisce una sequenza di `CheckedCircuit` oggetti con un numero crescente di controlli, e ciascun oggetto fornisce una funzione `get_postselection_method` che mappa una stringa di bit misurata su un vettore di sindrome. L'argomento `cost` seleziona la funzione che assegna un punteggio a un controllo (`gamma`, il sovraccarico di campionamento del canale di rumore inverso post-selezionato, oppure `LER`, il tasso di errore logico). L'argomento `method` seleziona la strategia di ricerca (`windowed`, `genetic`, o `windowed_genetic`). Questo tutorial utilizza e `cost=\"gamma\"` `method=\"windowed\"`, che insieme garantiscono una selezione dei test deterministica e riproducibile.\n",
"\n",
"\n",
"\n",
"### Stima della fedeltà a partire dal campionamento dello stabilizzatore\n",
"\n",
"Per valutare l'efficacia del sistema di rilevamento degli errori, è possibile stimare la fedeltà tra lo stato stabilizzato $|\\psi\\rangle = U|0\\rangle^{\\otimes n}$ che il circuito prepara idealmente e lo stato soggetto a rumore $\\rho$ che l'hardware emette effettivamente. La proiezione su uno stato puro dello stabilizzatore $|\\psi\\rangle$ è pari alla media uniforme sugli elementi $2^n$ del suo gruppo stabilizzatore $\\mathcal{S}$ :\n",
"\n",
"$|\\psi\\rangle\\langle\\psi| = \\frac{1}{2^n}\\sum_{G \\in \\mathcal{S}} G.$\n",
"\n",
"Sostituendo questo nell'espressione della fedeltà, si ottiene che la fedeltà di $\\rho$ è pari al valore atteso medio di ogni stabilizzatore $G \\in \\mathcal{S}$ rispetto a $\\rho$ :\n",
"\n",
"$F = \\mathrm{Tr}(\\rho|\\psi\\rangle\\langle\\psi|) = \\frac{1}{2^n} \\sum_{G \\in \\mathcal{S}} \\mathrm{Tr}(\\rho G) = \\frac{1}{2^n} \\sum_{G \\in \\mathcal{S}} \\langle G \\rangle_\\rho.$\n",
"\n",
"Per problemi di dimensioni maggiori, è impossibile enumerare tutti gli stabilizzatori $2^n$, pertanto è possibile stimare la fedeltà a partire da un campione casuale. Estraendo in modo casuale e uniforme gli stabilizzatori $M$ $G_1, \\ldots, G_M$ da $\\mathcal{S}$ si ottiene una stima non distorta:\n",
"\n",
"$\\hat F_M = \\frac{1}{M} \\sum_{i=1}^M \\langle G_i \\rangle_\\rho.$\n",
"\n",
"Poiché un circuito di Clifford prepara uno stato stabilizzato, è possibile stimarne la fedeltà direttamente dai valori attesi campionati dei suoi stabilizzatori. Questo tutorial illustra innanzitutto il flusso di lavoro su un simulatore con un circuito di piccole dimensioni, per poi eseguire lo stesso flusso di lavoro su hardware con un circuito più grande e complesso. Man mano che i circuiti includono un numero crescente di operazioni non Clifford, il numero di verifiche valide diminuisce rapidamente; pertanto, il metodo funziona al meglio per i circuiti dominati da operazioni Clifford.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "requirements",
"metadata": {},
"source": [
"\n",
"\n",
"## Requisiti\n",
"\n",
"Prima di iniziare questo tutorial, assicurati di avere installato quanto segue:\n",
"\n",
"* Qiskit SDK v2.0 o versioni successive, con supporto [alla visualizzazione](/docs/api/qiskit/visualization)\n",
"* Qiskit Runtime v0.40 o versioni successive (`pip install qiskit-ibm-runtime`)\n",
"* Qiskit Aer v0.17 o versione successiva (`pip install qiskit-aer`)\n",
"* Qiskit Paulice (`pip install qiskit-paulice`)\n",
"* tqdm (`pip install tqdm`)\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "setup",
"metadata": {},
"source": [
"\n",
"\n",
"## Configura\n",
"\n",
"Importa le librerie necessarie e definisci le funzioni di supporto che non sono disponibili come importazioni. La funzione `random_clifford_circuit` genera un payload Clifford casuale di tipo \"brickwork\", `find_check_layout` cerca in una mappa di accoppiamento del backend un percorso di qubit a basso errore con molti ancilla disponibili, `learned_noise_model` converte `NoiseLearner` l'output in un modello di rumore `qiskit-paulice` , `append_basis_rotation` ruota un circuito in modo che uno stabilizzatore venga misurato nella base computazionale, `expectation` calcola il valore atteso dello stabilizzatore a partire dai conteggi campionati e `cum_mean_sem` tiene traccia della stima della fedeltà in tempo reale.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "setup-imports",
"metadata": {},
"outputs": [],
"source": [
"# Standard library imports\n",
"import random\n",
"import time\n",
"\n",
"# External libraries\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"from tqdm import tqdm\n",
"\n",
"# Qiskit\n",
"from qiskit import QuantumCircuit\n",
"from qiskit.quantum_info import Clifford, Pauli, PauliLindbladMap, PauliList\n",
"from qiskit.result import sampled_expectation_value\n",
"from qiskit.transpiler import generate_preset_pass_manager\n",
"from qiskit.visualization import plot_coupling_map\n",
"\n",
"# Qiskit Aer\n",
"from qiskit_aer import AerSimulator\n",
"from qiskit_aer.noise import NoiseModel as AerNoiseModel\n",
"from qiskit_aer.noise import ReadoutError, depolarizing_error\n",
"\n",
"# Qiskit IBM Runtime\n",
"from qiskit_ibm_runtime import NoiseLearner, QiskitRuntimeService\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"# Qiskit Paulice\n",
"from qiskit_paulice import add_pauli_checks\n",
"from qiskit_paulice.layout import get_check_qubits\n",
"from qiskit_paulice.noise_models import NoiseModel"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "setup-helpers",
"metadata": {},
"outputs": [],
"source": [
"def random_clifford_circuit(\n",
" num_qubits: int, depth: int, rng: np.random.Generator\n",
") -> QuantumCircuit:\n",
" \"\"\"Brickwork random Clifford on `num_qubits`, with `depth` CZ layers.\"\"\"\n",
" qc = QuantumCircuit(num_qubits)\n",
" qc.h(range(num_qubits))\n",
" for d in range(depth):\n",
" for i in range(d % 2, num_qubits - 1, 2):\n",
" qc.cz(i, i + 1)\n",
" for q in range(num_qubits):\n",
" if rng.integers(0, 2):\n",
" qc.sx(q)\n",
" if rng.integers(0, 2):\n",
" qc.s(q)\n",
" if rng.integers(0, 2):\n",
" qc.sx(q)\n",
" return qc\n",
"\n",
"\n",
"def find_check_layout(\n",
" backend,\n",
" num_qubits: int,\n",
" rng: np.random.Generator,\n",
" num_trials: int = 200,\n",
" max_gate_error: float = 0.03,\n",
" max_readout_error: float = 0.2,\n",
") -> list[int]:\n",
" \"\"\"Find a low-error path of `num_qubits` qubits with many available ancillas.\n",
"\n",
" Builds random self-avoiding walks on the coupling map, excluding the qubits\n",
" and two-qubit gates whose reported errors exceed the thresholds, and keeps\n",
" the path that offers the most target and ancilla pairs. Ties are broken by\n",
" the lower average two-qubit gate error along the path.\n",
" \"\"\"\n",
" target = backend.target\n",
" gate_2q = next(\n",
" name for name in (\"cz\", \"ecr\", \"cx\") if name in target.operation_names\n",
" )\n",
"\n",
" # Collect per-edge gate errors and per-qubit readout errors\n",
" edge_error = {}\n",
" for qubits, props in target[gate_2q].items():\n",
" edge = tuple(sorted(qubits))\n",
" if props is not None and props.error is not None:\n",
" edge_error[edge] = min(edge_error.get(edge, 1.0), props.error)\n",
" readout_error = {\n",
" qubit: target[\"measure\"][(qubit,)].error\n",
" for (qubit,) in target[\"measure\"]\n",
" }\n",
"\n",
" # Keep only the edges whose gate and readout errors are acceptable\n",
" adjacency = {}\n",
" for (q1, q2), error in edge_error.items():\n",
" if (\n",
" error <= max_gate_error\n",
" and readout_error.get(q1, 1.0) <= max_readout_error\n",
" and readout_error.get(q2, 1.0) <= max_readout_error\n",
" ):\n",
" adjacency.setdefault(q1, set()).add(q2)\n",
" adjacency.setdefault(q2, set()).add(q1)\n",
"\n",
" # Random self-avoiding walks; keep the path with the most check pairs\n",
" starts = sorted(adjacency)\n",
" best_path = None\n",
" best_score = (-1, float(\"inf\"))\n",
" for _ in range(num_trials):\n",
" path = [starts[rng.integers(len(starts))]]\n",
" while len(path) < num_qubits:\n",
" options = sorted(adjacency[path[-1]] - set(path))\n",
" if not options:\n",
" break\n",
" path.append(options[rng.integers(len(options))])\n",
" if len(path) < num_qubits:\n",
" continue\n",
" num_pairs = len(get_check_qubits(backend.coupling_map, path)[0])\n",
" mean_error = float(\n",
" np.mean(\n",
" [edge_error[tuple(sorted(e))] for e in zip(path, path[1:])]\n",
" )\n",
" )\n",
" if num_pairs > best_score[0] or (\n",
" num_pairs == best_score[0] and mean_error < best_score[1]\n",
" ):\n",
" best_path, best_score = path, (num_pairs, mean_error)\n",
"\n",
" if best_path is None:\n",
" raise RuntimeError(\n",
" \"No connected low-error path found. Relax the error thresholds.\"\n",
" )\n",
" return best_path\n",
"\n",
"\n",
"def learned_noise_model(layer_errors, layout: list[int]) -> NoiseModel:\n",
" \"\"\"Build a `NoiseModel` from `NoiseLearner` results.\n",
"\n",
" `NoiseLearner` reports one `PauliLindbladError` per entangling layer, whose\n",
" generators are indexed against that layer's own physical qubits, while\n",
" `NoiseModel.from_pauli_lindblad_maps` expects `PauliLindbladMap`s indexed the\n",
" way `NoiseModel.from_backend` indexes them: by position in `layout`. This\n",
" translates between the two and drops generators that fall outside `layout`.\n",
" \"\"\"\n",
" phys_to_virt = {phys: virt for virt, phys in enumerate(layout)}\n",
" maps = []\n",
" for layer in layer_errors:\n",
" if layer.error is None:\n",
" continue\n",
" terms = []\n",
" for pauli, rate in zip(\n",
" layer.error.generators, layer.error.rates, strict=True\n",
" ):\n",
" label, indices = [], []\n",
" for local, phys in enumerate(layer.qubits):\n",
" x, z = bool(pauli.x[local]), bool(pauli.z[local])\n",
" if not (x or z):\n",
" continue\n",
" if phys not in phys_to_virt:\n",
" break # generator reaches outside the layout, so skip it\n",
" label.append(\"Y\" if x and z else \"X\" if x else \"Z\")\n",
" indices.append(phys_to_virt[phys])\n",
" else:\n",
" if label:\n",
" terms.append(\n",
" (\"\".join(label), tuple(indices), float(rate))\n",
" )\n",
" # Each map needs a 2-qubit generator to define an entangling layer\n",
" if any(len(t[1]) == 2 for t in terms):\n",
" maps.append(\n",
" PauliLindbladMap.from_sparse_list(\n",
" terms, num_qubits=len(layout)\n",
" )\n",
" )\n",
" if not maps:\n",
" raise RuntimeError(\n",
" \"No usable layer errors. Check that the learner ran on this layout.\"\n",
" )\n",
" return NoiseModel.from_pauli_lindblad_maps(maps)\n",
"\n",
"\n",
"def append_basis_rotation(\n",
" circuit: QuantumCircuit, pauli: Pauli\n",
") -> QuantumCircuit:\n",
" \"\"\"Strip measurements, append basis rotations for `pauli`, and re-measure.\"\"\"\n",
" out = circuit.remove_final_measurements(inplace=False)\n",
" for q in range(pauli.num_qubits):\n",
" if pauli.x[q]:\n",
" if pauli.z[q]:\n",
" out.sdg(q)\n",
" out.h(q)\n",
" out.measure_all()\n",
" return out\n",
"\n",
"\n",
"def expectation(counts: dict, pauli: Pauli) -> float:\n",
" \"\"\"Expectation value of `pauli` from counts measured in the Z basis.\n",
"\n",
" Pads with identity on any qubits beyond the support of `pauli`, such as the\n",
" check ancillas that appear in the postselected counts.\n",
" \"\"\"\n",
" if not counts:\n",
" return float(\"nan\")\n",
" n = pauli.num_qubits\n",
" sign = -1 if int(pauli.phase) % 4 == 2 else 1\n",
" total = len(next(iter(counts)))\n",
" label = \"\".join(\n",
" \"Z\" if q < n and (pauli.x[q] or pauli.z[q]) else \"I\"\n",
" for q in range(total - 1, -1, -1)\n",
" )\n",
" return sign * sampled_expectation_value(counts, label)\n",
"\n",
"\n",
"def cum_mean_sem(values: np.ndarray):\n",
" \"\"\"Cumulative mean and standard error of the mean, ignoring NaNs.\"\"\"\n",
" valid = ~np.isnan(values)\n",
" total = np.cumsum(np.where(valid, values, 0.0))\n",
" total_sq = np.cumsum(np.where(valid, values**2, 0.0))\n",
" count = np.maximum(np.cumsum(valid).astype(float), 1)\n",
" mean = total / count\n",
" sem = np.sqrt(np.maximum(total_sq / count - mean**2, 0) / count)\n",
" return np.where(np.cumsum(valid) > 0, mean, np.nan), sem"
]
},
{
"cell_type": "markdown",
"id": "small-scale-header",
"metadata": {},
"source": [
"\n",
"\n",
"## Esempio di simulatore su piccola scala\n",
"\n",
"Questa sezione illustra il flusso di lavoro completo su un simulatore con rumore. Utilizza i dati dei benchmark del backend per scegliere una configurazione dei qubit e un modello di rumore, individua automaticamente i controlli e ricorre alla post-selezione sulla distribuzione campionata per dimostrare il miglioramento della fedeltà.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "step1-header",
"metadata": {},
"source": [
"\n",
"\n",
"### Fase 1: Mappare gli input classici su un problema quantistico\n",
"\n",
"Il circuito di carico utile è un circuito di Clifford casuale unidimensionale a struttura a mattoni poco profonda. Poiché il circuito è di tipo Clifford, genera uno stato stabilizzatore la cui fedeltà può essere stimata direttamente dai valori attesi campionati dello stabilizzatore. Inizia con un circuito poco complesso, in modo che i controlli siano facili da visualizzare nella fase successiva.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "step1-code",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"num_qubits = 12\n",
"depth = 4\n",
"seed = 1764\n",
"rng = np.random.default_rng(seed)\n",
"np.random.seed(seed)\n",
"\n",
"circuit = random_clifford_circuit(num_qubits, depth, rng)\n",
"circuit.measure_all()\n",
"circuit.draw(\"mpl\", fold=-1, scale=0.6)"
]
},
{
"cell_type": "markdown",
"id": "step2-header",
"metadata": {},
"source": [
"\n",
"\n",
"### Fase 2: Ottimizzazione per l'esecuzione su hardware quantistico\n",
"\n",
"La mappatura del circuito sull'hardware definisce la disposizione fisica dei qubit, il modello di rumore utilizzato per valutare i controlli candidati e i controlli stessi.\n",
"\n",
"Per prima cosa, seleziona un backend e cerca nella sua mappa di accoppiamento una disposizione unidimensionale dei qubit con l’helper `find_check_layout` definito nella sezione “Setup”. L'helper genera percorsi casuali che evitano i gate e i readout con il maggior errore, e mantiene il percorso che offre il maggior numero di coppie di target e ancilla. Poiché la ricerca legge i dati relativi alla connettività e agli errori direttamente dal backend, lo stesso codice funziona su qualsiasi QPU IBM Quantum. La funzione `get_check_qubits` restituisce quindi le coppie di target e ancilla, dove la verifica su utilizza `target_qubits[i]` `ancilla_qubits[i]`.\n",
"\n",
"Nel grafico di accoppiamento riportato di seguito, i qubit verdi sono i qubit di carico utile, mentre quelli arancioni sono gli ancilla che eseguono i controlli. I qubit con un ancilla adiacente vengono utilizzati come qubit di riferimento per i controlli.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "step2-layout",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Backend: ibm_boston\n",
"Target qubits: [105, 107, 108, 123, 125, 141, 143]\n",
"Ancilla qubits: [104, 97, 109, 122, 126, 140, 144]\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(operational=True, simulator=False)\n",
"\n",
"print(f\"Backend: {backend.name}\")\n",
"\n",
"# Search for a low-error path, then pair each target qubit with a neighboring ancilla\n",
"layout = find_check_layout(backend, num_qubits, rng)\n",
"target_qubits, ancilla_qubits = get_check_qubits(backend, layout)\n",
"num_checks = len(target_qubits)\n",
"\n",
"print(f\"Target qubits: {target_qubits}\")\n",
"print(f\"Ancilla qubits: {ancilla_qubits}\")\n",
"plot_coupling_map(\n",
" num_qubits=backend.num_qubits,\n",
" qubit_coordinates=getattr(\n",
" backend.configuration(), \"qubit_coordinates\", None\n",
" ),\n",
" coupling_map=backend.configuration().coupling_map,\n",
" figsize=(12, 12),\n",
" qubit_color=[\n",
" \"#4CAF50\"\n",
" if i in set(layout)\n",
" else \"#FF9800\"\n",
" if i in set(ancilla_qubits)\n",
" else \"#DDDDDD\"\n",
" for i in backend.coupling_map.graph.node_indices()\n",
" ],\n",
" qubit_size=220,\n",
" line_width=2,\n",
" font_size=90,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "step2-transpile-md",
"metadata": {},
"source": [
"Una volta scelti il backend e il layout, traspilare il payload in un circuito con architettura a set di istruzioni (ISA). È sufficiente impostare il layout e convertire i gate nel set di gate nativo del backend.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "step2-transpile",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pm = generate_preset_pass_manager(\n",
" optimization_level=0, backend=backend, initial_layout=layout\n",
")\n",
"circuit_isa = pm.run(circuit)\n",
"circuit_isa.draw(\"mpl\", fold=-1, scale=0.6)"
]
},
{
"cell_type": "markdown",
"id": "step2-noise-md",
"metadata": {},
"source": [
"Successivamente, illustra in che modo il rumore di gate e di lettura nel backend influisce sull'esecuzione. Il modello di rumore determina in quale punto del circuito un controllo rileva il maggior numero di errori. Un modello più accurato migliora il rilevamento, ma di solito non è necessario addestrarne uno tramite campionamento della QPU. Il modello che segue deduce, sulla base dei dati di riferimento `qiskit-ibm-runtime` , un canale di depolarizzazione uniforme per il rumore di gate e di lettura.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "step2-noise",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NoiseModel(gate_noise=0.001079865281450939, readout_noise=0.006001790364583333, idling_noise=None)\n"
]
}
],
"source": [
"noise_model = NoiseModel.from_backend(\n",
" backend, layout, uniform_gate_noise=True\n",
")\n",
"print(noise_model)"
]
},
{
"cell_type": "markdown",
"id": "step2-checks-md",
"metadata": {},
"source": [
"Ora aggiungi i controlli al circuito. La funzione `add_pauli_checks` accetta come parametri il payload di Clifford, l'elenco dei qubit di destinazione e il modello di rumore. L'argomento `ancilla_qubits` indica alla funzione quale ancilla fisica deve essere accoppiata a ciascun bersaglio. I controlli vengono aggiunti nell'ordine in cui compaiono i qubit di destinazione, quindi la disposizione finale del circuito controllato è `layout + ancilla_qubits`. Per realizzare un circuito di uscita con un numero inferiore di (`i`) controlli, il layout finale è il seguente `layout + ancilla_qubits[:i]`.\n",
"\n",
"L'output di è `add_pauli_checks` una sequenza di circuiti con un numero crescente di controlli, che va da nessun controllo fino a un controllo per ogni qubit di destinazione. La visualizzazione conferma che i controlli utilizzano le coppie di target e ancilla specificate. Per ulteriori dettagli su come individuare controlli efficaci, si vedano le sezioni da II a IV delle informazioni supplementari contenute nel riferimento [\\[1\\]](#references).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "step2-checks",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Physical layout of payload and ancillas: [108, 107, 106, 105, 117, 125, 124, 123, 136, 143, 142, 141, 104, 97, 109, 122, 126, 140, 144]\n",
"Checked circuit:\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"checked = add_pauli_checks(\n",
" circuit_isa,\n",
" target_qubits,\n",
" noise_model,\n",
" ancilla_qubits=ancilla_qubits,\n",
" cost=\"gamma\",\n",
" method=\"windowed\",\n",
" seed=seed,\n",
")\n",
"\n",
"print(f\"Physical layout of payload and ancillas: {layout + ancilla_qubits}\")\n",
"print(\"Checked circuit:\")\n",
"checked[-1].circuit.draw(\"mpl\", fold=-1, idle_wires=False)"
]
},
{
"cell_type": "markdown",
"id": "step3-header",
"metadata": {},
"source": [
"\n",
"\n",
"### Passaggio 3: Eseguire il comando utilizzando Qiskit primitives\n",
"\n",
"Per rendere visibile l'effetto del rumore di gate, aumentare la profondità del payload e campionare un sottoinsieme dei suoi stabilizzatori. In genere, ogni stabilizzatore non commuta con gli altri a livello di qubit, pertanto una singola serie di verifiche non è valida per due stabilizzatori diversi. Anziché raggruppare gli stabilizzatori in insiemi di pendolari, individua una serie adeguata di controlli per ciascuno stabilizzatore in modo indipendente. Il campionamento casuale e uniforme degli stabilizzatori fornisce una stima non distorta della fedeltà.\n",
"\n",
"Costruisci il circuito più complesso e estrai un campione casuale dei suoi stabilizzatori.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "step3-stabilizers",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sampled 20 stabilizers of a 12-qubit circuit with two-qubit depth 24: {ZXIIXZYYXIZZ, XXXYIIZYXIII, ...}\n"
]
}
],
"source": [
"depth = 24\n",
"num_stabilizers = 20\n",
"num_shots = 1_000\n",
"\n",
"circuit = random_clifford_circuit(num_qubits, depth, rng)\n",
"\n",
"# Build the full stabilizer group, then sample from it uniformly at random\n",
"circ_no_meas = circuit.remove_final_measurements(inplace=False)\n",
"stabilizer_group = PauliList([Pauli(\"I\" * num_qubits)])\n",
"for generator in (\n",
" Pauli(label) for label in Clifford(circ_no_meas).to_labels(mode=\"S\")\n",
"):\n",
" stabilizer_group = stabilizer_group + stabilizer_group.compose(generator)\n",
"\n",
"keep = np.where(\n",
" stabilizer_group.x.any(axis=1) | stabilizer_group.z.any(axis=1)\n",
")[0]\n",
"chosen = np.random.default_rng(seed).choice(\n",
" keep, size=min(num_stabilizers, len(keep)), replace=False\n",
")\n",
"stabilizers = [stabilizer_group[int(i)] for i in chosen]\n",
"\n",
"two_qubit_depth = circuit.depth(lambda x: x.operation.num_qubits == 2)\n",
"print(\n",
" f\"Sampled {len(stabilizers)} stabilizers of a {circuit.num_qubits}-qubit \"\n",
" f\"circuit with two-qubit depth {two_qubit_depth}: \"\n",
" f\"{{{stabilizers[0]}, {stabilizers[1]}, ...}}\"\n",
")"
]
},
{
"cell_type": "markdown",
"id": "step3-findchecks-md",
"metadata": {},
"source": [
"Per ogni stabilizzatore campionato, ruotare il circuito in modo che lo stabilizzatore venga misurato nella base computazionale, trasporlo sul backend e individuare una serie adeguata di controlli. Per ogni stabilizzatore, le coppie di target e ancilla vengono mescolate in modo che ogni target mantenga la propria ancilla. Ricorda che i controlli vengono confermati in ordine sequenziale, secondo l'ordine in cui vengono specificati i qubit di destinazione, e che un controllo già confermato non viene modificato anche se vengono aggiunti altri controlli.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "step3-findchecks",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 20/20 [00:15<00:00, 1.29it/s]"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Added 7 checks to 20 circuits in 15s.\n",
"On average, two-qubit depth increased from 24 to 33 when adding 7 checks.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"noisy_circuits = []\n",
"checked_circuits = []\n",
"depths_2q = []\n",
"t0 = time.time()\n",
"for i, pauli in enumerate(tqdm(stabilizers)):\n",
" noisy_circuits.append(pm.run(append_basis_rotation(circuit, pauli)))\n",
" # Shuffle target and ancilla pairs together so each target keeps its ancilla\n",
" targets, ancillas = zip(\n",
" *random.sample(\n",
" list(zip(target_qubits, ancilla_qubits, strict=True)),\n",
" k=len(target_qubits),\n",
" ),\n",
" strict=True,\n",
" )\n",
" checked_circuits.append(\n",
" add_pauli_checks(\n",
" noisy_circuits[-1],\n",
" list(targets),\n",
" noise_model,\n",
" ancilla_qubits=list(ancillas),\n",
" cost=\"gamma\",\n",
" method=\"windowed\",\n",
" seed=seed + 1 + i,\n",
" )\n",
" )\n",
" depths_2q.append(\n",
" checked_circuits[-1][-1].circuit.depth(lambda x: len(x.qubits) == 2)\n",
" )\n",
"\n",
"print(\n",
" f\"Added {num_checks} checks to {len(stabilizers)} circuits \"\n",
" f\"in {(time.time() - t0):.0f}s.\"\n",
")\n",
"print(\n",
" f\"On average, two-qubit depth increased from \"\n",
" f\"{circuit.depth(lambda x: len(x.qubits) == 2)} to {int(np.mean(depths_2q))} \"\n",
" f\"when adding {num_checks} checks.\"\n",
")"
]
},
{
"cell_type": "markdown",
"id": "step3-sample-md",
"metadata": {},
"source": [
"Prova il payload non protetto e i circuiti verificati con Qiskit Aer. Il simulatore utilizza lo stesso modello di depolarizzazione utilizzato per la valutazione dei test, pertanto il rumore su cui si concentrano i test è lo stesso che il simulatore applica.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "step3-sample",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 20/20 [00:17<00:00, 1.13it/s]\n"
]
}
],
"source": [
"aer_nm = AerNoiseModel()\n",
"aer_nm.add_all_qubit_quantum_error(\n",
" depolarizing_error(noise_model.gate_noise, 2), [\"cz\"]\n",
")\n",
"p = noise_model.readout_noise\n",
"aer_nm.add_all_qubit_readout_error(ReadoutError([[1 - p, p], [p, 1 - p]]))\n",
"noisy_sim = AerSimulator(method=\"stabilizer\", noise_model=aer_nm)\n",
"\n",
"counts = []\n",
"for i, checked_circ_result in enumerate(tqdm(checked_circuits)):\n",
" noisy_counts = (\n",
" noisy_sim.run(\n",
" noisy_circuits[i], shots=num_shots, seed_simulator=seed * i + 1\n",
" )\n",
" .result()\n",
" .get_counts()\n",
" )\n",
" checked_counts_per_variant = []\n",
" for k, ck in enumerate(checked_circ_result):\n",
" variant_counts = (\n",
" noisy_sim.run(\n",
" ck.circuit, shots=num_shots, seed_simulator=seed * i + 2 + k\n",
" )\n",
" .result()\n",
" .get_counts()\n",
" )\n",
" checked_counts_per_variant.append(variant_counts)\n",
" counts.append((noisy_counts, checked_counts_per_variant))"
]
},
{
"cell_type": "markdown",
"id": "step4-header",
"metadata": {},
"source": [
"\n",
"\n",
"### Fase 4: Elaborazione successiva e restituzione del risultato nel formato classico desiderato\n",
"\n",
"Ogni verifica utilizza porte di entanglement tra un ancilla e un bersaglio. L'ancilla parte da $|0\\rangle$, quindi $Z_\\text{anc}$ ne stabilizza l'input. La propagazione di un’ $Z_\\text{anc}$ e in avanti attraverso il circuito di controllo produce un operatore di Pauli in uscita, i cui termini non identitari definiscono il supporto del controllo. Un controllo è valido quando i bit che lo compongono hanno parità pari. Un campione viene conservato solo se supera tutti i controlli.\n",
"\n",
"La funzione di `get_postselection_method` ciascun restituisce `CheckedCircuit` una funzione che mappa una stringa di bit misurata su un vettore di sindrome. Conserva i campioni il cui indice di sindrome è pari a zero in ogni controllo e scarta gli altri. Il grafico che segue mostra che l'aggiunta di ulteriori controlli riduce il tasso di post-selezione. Un tasso di post-selezione più basso richiede un numero maggiore di scatti per raggiungere una determinata precisione, pertanto esiste un compromesso tra capacità di rilevamento e costo di campionamento. Il tasso sembra convergere, il che indica che ulteriori controlli contribuiscono in misura minore alla capacità di rilevamento.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "step4-psr",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"rate_per_variant = []\n",
"kept_per_stab = []\n",
"for i, (_, checked_counts_per_variant) in enumerate(counts):\n",
" rates = []\n",
" kept_at_num_checks = None\n",
" for k, variant_counts in enumerate(checked_counts_per_variant):\n",
" ps_fn = checked_circuits[i][k].get_postselection_method()\n",
" kept = {\n",
" bs: n for bs, n in variant_counts.items() if not ps_fn(bs).any()\n",
" }\n",
" rates.append(sum(kept.values()) / num_shots)\n",
" if k == num_checks:\n",
" kept_at_num_checks = kept\n",
" rate_per_variant.append(rates)\n",
" kept_per_stab.append(kept_at_num_checks)\n",
"\n",
"max_len = max(len(s) for s in rate_per_variant)\n",
"rates_arr = np.full((len(rate_per_variant), max_len), np.nan)\n",
"for i, s in enumerate(rate_per_variant):\n",
" rates_arr[i, : len(s)] = s\n",
"ks = np.arange(max_len)\n",
"\n",
"fig, ax = plt.subplots(figsize=(8, 4))\n",
"ax.plot(ks, rates_arr.T, color=\"#ff8c00\", alpha=0.15, linewidth=1)\n",
"ax.plot(\n",
" ks,\n",
" np.nanmedian(rates_arr, axis=0),\n",
" color=\"black\",\n",
" linewidth=1,\n",
" linestyle=\"--\",\n",
" label=\"median\",\n",
")\n",
"ax.set_xlabel(\"Checks committed\")\n",
"ax.set_ylabel(\"Postselection rate\")\n",
"ax.set_ylim((0, 1.05))\n",
"ax.set_title(\n",
" f\"Per-stabilizer postselection rate ({len(rates_arr)} stabilizers)\"\n",
")\n",
"ax.legend()\n",
"ax.grid(True, alpha=0.3)\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "step4-fidelity-md",
"metadata": {},
"source": [
"Ora confrontiamo la fedeltà dello stato \"nudo\" e rumoroso con quella dello stato post-selezionato. La selezione a posteriori dei soli campioni in cui non è stato rilevato alcun errore aumenta il valore atteso di ogni stabilizzatore e, di conseguenza, la fedeltà stimata. I valori post-selezionati utilizzano un numero inferiore di campioni rispetto ai valori grezzi, ma i valori attesi sono più precisi e la varianza campionaria è inferiore. Si noti inoltre che il tasso medio di post-selezione è prossimo alla fedeltà soggetta a rumore. Questo è ciò che ci si aspetta quando i controlli rilevano quasi tutti i campioni errati: la frazione di campioni che superano ogni controllo si avvicina alla frazione di campioni privi di errori, che corrisponde alla fedeltà dello stato rumoroso.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "step4-fidelity",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ideal fidelity: 1.0\n",
"noisy fidelity: 0.7899\n",
"postselected fidelity: 0.9679\n",
"mean postselection rate: 0.780\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"results = []\n",
"for i, ((noisy_counts, _), kept) in enumerate(\n",
" zip(counts, kept_per_stab, strict=True)\n",
"):\n",
" results.append(\n",
" (\n",
" expectation(noisy_counts, stabilizers[i]),\n",
" expectation(kept, stabilizers[i]),\n",
" sum(kept.values()) / num_shots,\n",
" )\n",
" )\n",
"\n",
"fidelity_noisy = float(np.nanmean([r[0] for r in results]))\n",
"fidelity_postsel = float(np.nanmean([r[1] for r in results]))\n",
"psr = float(np.mean([r[2] for r in results]))\n",
"print(\n",
" f\"ideal fidelity: 1.0\\n\"\n",
" f\"noisy fidelity: {fidelity_noisy:.4f}\\n\"\n",
" f\"postselected fidelity: {fidelity_postsel:.4f}\\n\"\n",
" f\"mean postselection rate: {psr:.3f}\"\n",
")\n",
"\n",
"evs_ideal = np.ones(len(results))\n",
"evs_noisy = np.array([r[0] for r in results])\n",
"evs_post = np.array([r[1] for r in results])\n",
"idx = np.arange(len(results))\n",
"\n",
"\n",
"def strip(ax, ys, color, label):\n",
" m, s = np.nanmean(ys), np.nanstd(ys)\n",
" ax.axhspan(\n",
" m - s, m + s, color=color, alpha=0.15, label=f\"{label} mean and std\"\n",
" )\n",
" ax.axhline(\n",
" m, color=color, linewidth=1, linestyle=\"--\", label=f\"{label} fidelity\"\n",
" )\n",
"\n",
"\n",
"fig, ax = plt.subplots(figsize=(8, 4))\n",
"ax.axhline(np.nanmean(evs_ideal), color=\"black\", linewidth=1.5, label=\"ideal\")\n",
"strip(ax, evs_noisy, \"red\", \"noisy\")\n",
"strip(ax, evs_post, \"green\", \"postselected\")\n",
"ax.scatter(idx, evs_noisy, color=\"red\", s=22, alpha=0.7, label=\"noisy EVs\")\n",
"ax.scatter(\n",
" idx,\n",
" evs_post,\n",
" color=\"green\",\n",
" s=22,\n",
" alpha=0.7,\n",
" label=\"postselected EVs\",\n",
")\n",
"ax.set_xlabel(\"stabilizer index\")\n",
"ax.set_ylabel(r\"$\\langle G \\rangle$\")\n",
"ax.set_ylim((-0.1, 1.1))\n",
"ax.set_title(\"Per-stabilizer expectation values\")\n",
"ax.legend(loc=\"lower left\")\n",
"ax.grid(True, alpha=0.3)\n",
"plt.tight_layout()\n",
"plt.show()\n",
"\n",
"M = np.arange(1, len(results) + 1)\n",
"fig, ax = plt.subplots(figsize=(8, 4))\n",
"for ys, color, label in [\n",
" (evs_ideal, \"black\", \"ideal\"),\n",
" (evs_noisy, \"red\", \"noisy\"),\n",
" (evs_post, \"green\", \"postselected\"),\n",
"]:\n",
" cm, sem = cum_mean_sem(ys)\n",
" ax.plot(M, cm, color=color, linewidth=1.5, label=label)\n",
" ax.fill_between(M, cm - sem, cm + sem, color=color, alpha=0.15)\n",
"ax.set_xlabel(\"number of stabilizers averaged\")\n",
"ax.set_ylabel(\"running fidelity estimate\")\n",
"ax.set_title(\"Fidelity convergence versus number of stabilizers\")\n",
"ax.legend()\n",
"ax.grid(True, alpha=0.3)\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "step4-gamma-md",
"metadata": {},
"source": [
"Il punteggio gamma indica quale percentuale del canale di rumore modellato non viene rilevata dai controlli. Il grafico che mette in relazione il punteggio gamma con il numero di controlli effettuati mostra come la capacità di rilevamento migliori man mano che viene aggiunto ogni controllo. Un valore pari a indica `1.0` che i controlli rilevano tutto il rumore modellato. Le curve tendono verso `1.0` man mano che vengono eseguiti ulteriori controlli, il che dimostra che ogni controllo aggiuntivo individua una parte dell’errore residuo non ancora rilevato.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "step4-gamma",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stab_scores = [\n",
" [variant.cost for variant in checked_circ_result]\n",
" for checked_circ_result in checked_circuits\n",
"]\n",
"max_len = max(len(s) for s in stab_scores)\n",
"scores = np.full((len(stab_scores), max_len), np.nan)\n",
"for i, s in enumerate(stab_scores):\n",
" scores[i, : len(s)] = s\n",
"ks = np.arange(max_len)\n",
"\n",
"fig, ax = plt.subplots(figsize=(8, 4))\n",
"ax.plot(ks, scores.T, color=\"#4682b4\", alpha=0.15, linewidth=1)\n",
"ax.plot(\n",
" ks,\n",
" np.nanmedian(scores, axis=0),\n",
" color=\"black\",\n",
" linewidth=1,\n",
" linestyle=\"--\",\n",
" label=\"median\",\n",
")\n",
"ax.set_xlabel(\"Checks committed\")\n",
"ax.set_ylabel(\"Gamma\")\n",
"ax.set_yscale(\"log\")\n",
"ax.set_title(f\"Per-stabilizer gamma curves ({len(scores)} stabilizers)\")\n",
"ax.legend()\n",
"ax.grid(True, alpha=0.3, which=\"both\")\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "hardware-header",
"metadata": {},
"source": [
"\n",
"\n",
"## Esempio di hardware su larga scala\n",
"\n",
"Lo stesso flusso di lavoro viene eseguito su hardware dotato di una capacità di carico maggiore e più profonda. Questa sezione riutilizza il backend dell'esempio del simulatore, ma crea un nuovo layout da 20 qubit con le proprie coppie di target e ancilla e il proprio gestore di passaggi, per poi inviare i circuiti alla QPU in un unico lavoro. A queste dimensioni, la maggior parte degli scatti attiva almeno un controllo, quindi il tasso di post-selezione è basso e ogni circuito richiede un budget di scatti elevato per ottenere un numero sufficiente di campioni. L'esempio concentra quindi il proprio budget su un numero limitato di stabilizzatori campionati; si tratta comunque di una stima della fedeltà non distorta, ma meno dettagliata rispetto alla media calcolata dall'esempio del simulatore su un ampio numero di stabilizzatori.\n",
"\n",
"Rispetto all’esempio del simulatore, c’è una differenza: invece di dedurre un canale depolarizzante uniforme dai dati di calibrazione, in questa sezione **si apprende** il modello di rumore con `NoiseLearner` e si costruisce il modello `qiskit-paulice` partendo dal risultato ottenuto con `NoiseModel.from_pauli_lindblad_maps`. Un modello Pauli-Lindblad addestrato riproduce la struttura spaziale del rumore su questa specifica configurazione, anziché ipotizzare che ogni bordo presenti lo stesso livello di rumore; pertanto, il posizionamento dei simboli viene valutato in base a un rumore più simile a quello che interessa la QPU. L'apprendimento del rumore richiede il campionamento della QPU e deve essere preso in considerazione nel bilancio complessivo di campionamento della QPU.\n",
"\n",
"I parametri riportati di seguito definiscono il numero di qubit, la profondità, il numero di stabilizzatori e il numero di shot. La scala `hw_num_shots` dipende dall'inverso del tasso di post-selezione: con un tasso del 3%, 40.000 misurazioni producono circa 1.200 campioni post-selezionati per circuito. Aumentare `hw_num_stabilizers` per ottenere una stima più precisa della fedeltà, a costo di un maggior numero di circuiti per ogni lavoro, ciascuno dei quali richiede lo stesso budget di shot.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "hardware-steps-header",
"metadata": {},
"source": [
"\n",
"\n",
"### Passaggi da 1 a 4 (raggruppati in un unico blocco di codice)\n",
"\n",
"La cella seguente esegue gli stessi quattro passaggi dell'esempio del simulatore. Crea il payload più grande e campiona alcuni stabilizzatori (fase 1); sceglie un layout, apprende il modello di rumore su di esso e individua il circuito completamente verificato per ciascuno stabilizzatore (fase 2); invia un’attività Sampler contenente sia i circuiti grezzi che quelli verificati (fase 3); ed effettua una post-selezione dei conteggi verificati per confrontare le stime di fedeltà con rumore e quelle post-selezionate, per singolo stabilizzatore e in media (fase 4). A queste dimensioni, enumerare l’intero gruppo degli stabilizzatori come nell’esempio del simulatore è impossibile, quindi la cella campiona in modo casuale un sottoinsieme degli stabilizzatori per calcolare una stima della fedeltà.\n",
"\n",
"Si noti che il passaggio 2 in questo caso svolge un ruolo più ampio rispetto all'esempio del simulatore: il processo di apprendimento del modello di rumore invia il proprio lavoro `NoiseLearner` prima di quello del campionatore, quindi la cella esegue in totale **due** lavori. Sono provvisti delle etichette e `TUT_ASPC_LEARN` `TUT_ASPC` in modo da poterli ritrovare in seguito. Per ulteriori informazioni sull'assegnazione di tag alle offerte di lavoro, consulta la sezione \" [Organizza e cerca in base ai tag delle offerte di lavoro](/docs/guides/add-job-tags)\".\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "hardware-submit",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Layout with 11 check pairs: [153, 152, 151, 138, 131, 130, 129, 118, 109, 110, 111, 98, 91, 90, 89, 78, 69, 70, 71, 58]\n",
"Submitted noise-learner job d9f4mncjeosc73fjfmkg\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Learned 4 layers; readout noise 0.00470\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"100%|██████████| 10/10 [01:01<00:00, 6.18s/it]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Submitted job d9f4s04jeosc73fjftkg with 20 circuits\n",
"noisy fidelity estimate: 0.3685\n",
"postselected fidelity estimate: 0.6869\n",
"mean postselection rate: 0.2851 (~11404 kept shots per circuit)\n",
"\n",
"per-stabilizer results:\n",
"idx noisy postsel psr kept shots\n",
" 0 0.3769 0.6918 0.3247 12987\n",
" 1 0.3745 0.6760 0.2999 11995\n",
" 2 0.3659 0.6389 0.3549 14196\n",
" 3 0.3821 0.7060 0.2660 10641\n",
" 4 0.3653 0.7475 0.2531 10124\n",
" 5 0.3752 0.7022 0.2698 10791\n",
" 6 0.3508 0.7144 0.2711 10842\n",
" 7 0.3485 0.7087 0.2381 9523\n",
" 8 0.3825 0.6289 0.2928 11711\n",
" 9 0.3630 0.6549 0.2808 11232\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# -------------------------Step 1: build a larger payload and sample stabilizers-------------------------\n",
"hw_num_qubits = 20\n",
"hw_depth = 36\n",
"hw_num_stabilizers = 10\n",
"hw_num_shots = 40_000\n",
"\n",
"hw_circuit = random_clifford_circuit(hw_num_qubits, hw_depth, rng)\n",
"hw_no_meas = hw_circuit.remove_final_measurements(inplace=False)\n",
"\n",
"# Enumerating all 2^n stabilizers is infeasible at this size, so draw each\n",
"# stabilizer by composing a random subset of the group generators\n",
"hw_generators = [\n",
" Pauli(label) for label in Clifford(hw_no_meas).to_labels(mode=\"S\")\n",
"]\n",
"sample_rng = np.random.default_rng(seed)\n",
"hw_stabilizers = []\n",
"while len(hw_stabilizers) < hw_num_stabilizers:\n",
" mask = sample_rng.integers(0, 2, hw_num_qubits).astype(bool)\n",
" if not mask.any():\n",
" continue # skip the identity\n",
" stabilizer = Pauli(\"I\" * hw_num_qubits)\n",
" for generator, chosen in zip(hw_generators, mask, strict=True):\n",
" if chosen:\n",
" stabilizer = stabilizer.compose(generator)\n",
" hw_stabilizers.append(stabilizer)\n",
"\n",
"# -------------------------Step 2: find a 20-qubit layout, learn its noise, and add checks-------------------------\n",
"# A single bad coupler or bad-readout qubit on the path drags every\n",
"# stabilizer down, so search harder and with tighter error thresholds\n",
"hw_layout = find_check_layout(\n",
" backend,\n",
" hw_num_qubits,\n",
" rng,\n",
" num_trials=500,\n",
" max_gate_error=0.015,\n",
" max_readout_error=0.05,\n",
")\n",
"hw_target_qubits, hw_ancilla_qubits = get_check_qubits(backend, hw_layout)\n",
"hw_pm = generate_preset_pass_manager(\n",
" optimization_level=0, backend=backend, initial_layout=hw_layout\n",
")\n",
"print(f\"Layout with {len(hw_target_qubits)} check pairs: {hw_layout}\")\n",
"\n",
"# ----- learn a Pauli-Lindblad noise model on this layout -----\n",
"# The simulator example scored checks against a uniform depolarizing channel\n",
"# inferred from calibration data. Here, learn the noise instead: NoiseLearner\n",
"# runs its own job on the QPU and returns a Pauli-Lindblad channel per unique\n",
"# entangling layer, so the checks are placed against the noise this layout\n",
"# actually has, including its spatial structure. All the sampled stabilizers\n",
"# share the same entangling layers and differ only in their final basis\n",
"# rotation, so learning on the bare payload covers all of them.\n",
"learner = NoiseLearner(\n",
" mode=backend,\n",
" options={\n",
" \"max_layers_to_learn\": 4,\n",
" \"num_randomizations\": 32,\n",
" \"shots_per_randomization\": 128,\n",
" \"environment\": {\"job_tags\": [\"TUT_ASPC_LEARN\"]},\n",
" },\n",
")\n",
"learner_job = learner.run([hw_pm.run(hw_circuit)])\n",
"print(f\"Submitted noise-learner job {learner_job.job_id()}\")\n",
"hw_layer_errors = learner_job.result().data\n",
"\n",
"# To see how much the learned model helps, swap the next line for the\n",
"# simulator example's uniform model - a one-line change:\n",
"# hw_noise_model = NoiseModel.from_backend(backend, hw_layout, uniform_gate_noise=True)\n",
"hw_noise_model = learned_noise_model(hw_layer_errors, hw_layout)\n",
"# NoiseLearner characterizes gate noise only, so keep the readout estimate\n",
"# from calibration data rather than leaving it unset\n",
"hw_noise_model.readout_noise = NoiseModel.from_backend(\n",
" backend, hw_layout, uniform_gate_noise=True\n",
").readout_noise\n",
"print(\n",
" f\"Learned {len(hw_layer_errors)} layers; \"\n",
" f\"readout noise {hw_noise_model.readout_noise:.5f}\"\n",
")\n",
"\n",
"# ----- add the fully checked circuit per stabilizer -----\n",
"hw_noisy_circuits = []\n",
"hw_checked_circuits = []\n",
"for i, pauli in enumerate(tqdm(hw_stabilizers)):\n",
" bare = hw_pm.run(append_basis_rotation(hw_circuit, pauli))\n",
" hw_noisy_circuits.append(bare)\n",
" variants = add_pauli_checks(\n",
" bare,\n",
" hw_target_qubits,\n",
" hw_noise_model,\n",
" ancilla_qubits=hw_ancilla_qubits,\n",
" cost=\"gamma\",\n",
" method=\"windowed\",\n",
" seed=seed + 1 + i,\n",
" )\n",
" hw_checked_circuits.append(variants[-1]) # keep the fully checked circuit\n",
"\n",
"# -------------------------Step 3: submit one Sampler job with the bare and checked circuits-------------------------\n",
"sampler = Sampler(mode=backend)\n",
"sampler.options.default_shots = hw_num_shots\n",
"sampler.options.environment.job_tags = [\"TUT_ASPC\"]\n",
"\n",
"pubs = hw_noisy_circuits + [cc.circuit for cc in hw_checked_circuits]\n",
"job = sampler.run(pubs)\n",
"print(f\"Submitted job {job.job_id()} with {len(pubs)} circuits\")\n",
"\n",
"# -------------------------Step 4: postselect and compare fidelity-------------------------\n",
"result = job.result()\n",
"n_stab = len(hw_stabilizers)\n",
"\n",
"hw_results = []\n",
"for i in range(n_stab):\n",
" noisy_counts = result[i].join_data().get_counts()\n",
" checked_counts = result[n_stab + i].join_data().get_counts()\n",
" ps_fn = hw_checked_circuits[i].get_postselection_method()\n",
" kept = {bs: c for bs, c in checked_counts.items() if not ps_fn(bs).any()}\n",
" hw_results.append(\n",
" (\n",
" expectation(noisy_counts, hw_stabilizers[i]),\n",
" expectation(kept, hw_stabilizers[i]),\n",
" sum(kept.values()) / sum(checked_counts.values()),\n",
" )\n",
" )\n",
"\n",
"hw_fidelity_noisy = float(np.nanmean([r[0] for r in hw_results]))\n",
"hw_fidelity_postsel = float(np.nanmean([r[1] for r in hw_results]))\n",
"hw_psr = float(np.mean([r[2] for r in hw_results]))\n",
"print(\n",
" f\"noisy fidelity estimate: {hw_fidelity_noisy:.4f}\\n\"\n",
" f\"postselected fidelity estimate: {hw_fidelity_postsel:.4f}\\n\"\n",
" f\"mean postselection rate: {hw_psr:.4f} \"\n",
" f\"(~{int(round(hw_psr * hw_num_shots))} kept shots per circuit)\"\n",
")\n",
"\n",
"# Per-stabilizer breakdown. The postselection rate varies from stabilizer to\n",
"# stabilizer, so a stabilizer whose postselected value barely moves is usually\n",
"# one whose checks rejected little; the kept-shot count says how much of the\n",
"# gap is statistics rather than signal.\n",
"print(\"\\nper-stabilizer results:\")\n",
"print(\n",
" f\"{'idx':>3} {'noisy':>8} {'postsel':>8} {'psr':>7} {'kept shots':>10}\"\n",
")\n",
"for i, (noisy, post, psr_i) in enumerate(hw_results):\n",
" print(\n",
" f\"{i:>3} {noisy:>8.4f} {post:>8.4f} {psr_i:>7.4f} \"\n",
" f\"{int(round(psr_i * hw_num_shots)):>10}\"\n",
" )\n",
"\n",
"hw_noisy = np.array([r[0] for r in hw_results])\n",
"hw_post = np.array([r[1] for r in hw_results])\n",
"idx = np.arange(n_stab)\n",
"\n",
"fig, ax = plt.subplots(figsize=(9, 4))\n",
"ax.axhline(1.0, color=\"black\", linewidth=1.5, label=\"ideal\")\n",
"strip(ax, hw_noisy, \"red\", \"noisy\")\n",
"strip(ax, hw_post, \"green\", \"postselected\")\n",
"ax.scatter(idx, hw_noisy, color=\"red\", s=22, alpha=0.7, label=\"noisy EVs\")\n",
"ax.scatter(\n",
" idx,\n",
" hw_post,\n",
" color=\"green\",\n",
" s=22,\n",
" alpha=0.7,\n",
" label=\"postselected EVs\",\n",
")\n",
"ax.set_xlabel(\"stabilizer index\")\n",
"ax.set_ylabel(r\"$\\langle G \\rangle$\")\n",
"ax.set_ylim((-0.1, 1.1))\n",
"ax.set_xticks(idx)\n",
"ax.set_title(\"Per-stabilizer expectation values on hardware\")\n",
"# Outside the axes so it cannot hide a data point\n",
"ax.legend(loc=\"center left\", bbox_to_anchor=(1.02, 0.5), frameon=False)\n",
"ax.grid(True, alpha=0.3)\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "hardware-results-md",
"metadata": {},
"source": [
"Per circuiti di queste dimensioni, la maggior parte dei campioni contiene almeno un errore rilevato, quindi il tasso di post-selezione è basso e la post-selezione scarta la maggior parte degli scatti. I campioni che superano tutti i controlli forniscono un valore atteso di gran lunga migliore rispetto al circuito nudo, e i valori relativi a ciascuno stabilizzatore si distinguono nettamente dalla linea di base rumorosa. Per ottenere una stima più accurata della fedeltà, campionare un numero maggiore di stabilizzatori utilizzando lo stesso budget di misurazioni per circuito. Per aumentare il tasso di post-selezione, ridurre la profondità del circuito o eseguire un numero minore di controlli; per ottenere carichi utili maggiori, scalare il budget di shot in base all’inverso del tasso di post-selezione.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "next-steps",
"metadata": {},
"source": [
"\n",
"\n",
"## Passi successivi\n",
"\n",
"\n",
" Se questo lavoro ti è sembrato interessante, potrebbero interessarti anche i seguenti contenuti:\n",
"\n",
" * Il tutorial sui [codici di ripetizione](/docs/tutorials/repetition-codes) : un'introduzione alla correzione degli errori quantistici.\n",
" * La [documentazione `qiskit-paulice`](/docs/addons/qiskit-addon-paulice) relativa all'API completa per la ricerca di assegni e il [repository GitHub](https://github.com/Qiskit/qiskit-paulice) del pacchetto, contenente il codice sorgente.\n",
" * L'articolo \" [Rilevamento degli errori a basso overhead con codici spazio-temporali](https://arxiv.org/abs/2504.15725)\" illustra i fondamenti teorici alla base dei controlli.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "references",
"metadata": {},
"source": [
"\n",
"\n",
"## Riferimenti\n",
"\n",
"* \\[1] Martiel, S., & Javadi-Abhari, A. (2025). Rilevamento degli errori a basso overhead con codici spazio-temporali. *arXiv preprint* [arXiv:2504.15725](https://arxiv.org/abs/2504.15725).\n",
"* \\[2] van den Berg, E., Bravyi, S., Gambetta, J. M., Jurcevic, P., Maslov, D., & Temme, K. (2023). Mitigazione degli errori su singoli shot tramite controlli di Pauli coerenti. *Physical Review Research*, 5(3), 033193.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
},
"hours": 2.5,
"qpuSeconds": 10
},
"nbformat": 4,
"nbformat_minor": 5
}