{ "cells": [ { "cell_type": "markdown", "id": "frontmatter", "metadata": {}, "source": [ "---\n", "title: \"Inicio rápido\"\n", "description: \"Guía de inicio rápido para la última versión de Qiskit Paulice\"\n", "---\n", "\n" ] }, { "cell_type": "markdown", "id": "intro", "metadata": {}, "source": [ "\n", "\n", "# Inicio rápido\n", "\n", "Esta guía muestra un ejemplo mínimo y funcional del paquete `qiskit-paulice` . Utilizamos [comprobaciones de Pauli en el espaciotiempo](https://arxiv.org/abs/2504.15725) 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](https://github.com/Qiskit/qiskit-paulice/blob/main/docs/guides/low_overhead_error_detection_using_spacetime_codes.ipynb).\n", "\n", "**Pasos de flujo de trabajo**\n", "\n", "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.\n", "2. Busca buenas comprobaciones de Pauli en el espaciotiempo y añádelas al circuito.\n", "3. Comprueba el circuito marcado.\n", "4. Selecciona únicamente las muestras en las que no se haya detectado ningún error.\n", "\n" ] }, { "cell_type": "markdown", "id": "build-circuit", "metadata": {}, "source": [ "\n", "\n", "## 1. Preparar los datos de entrada\n", "\n", "`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_boston`Aquí 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.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "make-circuit", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qiskit import QuantumCircuit\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "from qiskit_paulice.layout import get_check_qubits\n", "from qiskit_paulice.noise_models import NoiseModel\n", "\n", "# Backend and a 1D chain of physical qubits to run on\n", "backend = QiskitRuntimeService().backend(\"ibm_boston\")\n", "layout = [68, 69, 78, 89, 90, 91, 98, 111, 112, 113, 119, 133]\n", "\n", "# A shallow brickwork random Clifford payload circuit\n", "rng = np.random.default_rng(1764)\n", "circuit = QuantumCircuit(len(layout))\n", "circuit.h(range(circuit.num_qubits))\n", "for d in range(4):\n", " for i in range(d % 2, circuit.num_qubits - 1, 2):\n", " circuit.cz(i, i + 1)\n", " for q in range(circuit.num_qubits):\n", " if rng.integers(0, 2):\n", " circuit.sx(q)\n", " if rng.integers(0, 2):\n", " circuit.s(q)\n", "circuit.measure_all()\n", "\n", "# Pair each payload qubit with a neighboring ancilla to host a check (no SWAPs needed)\n", "target_qubits, ancilla_qubits = get_check_qubits(backend.coupling_map, layout)\n", "\n", "# A rough depolarizing noise model from backend benchmark data, used to score checks\n", "noise_model = NoiseModel.from_backend(\n", " backend, layout, uniform_gate_noise=True\n", ")\n", "\n", "circuit.draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "add-checks-md", "metadata": {}, "source": [ "\n", "\n", "## 2. Buscar e incorporar comprobaciones de Pauli en el espaciotiempo\n", "\n", "`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.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "add-checks", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit_paulice import add_pauli_checks\n", "\n", "# The circuit has virtual qubits, so we specify our target qubits with virtual indices\n", "target_qubits_v = [layout.index(q) for q in target_qubits]\n", "\n", "# Add spacetime Pauli checks\n", "checked_circuit = add_pauli_checks(circuit, target_qubits_v, noise_model)[-1]\n", "checked_circuit.circuit.draw(\"mpl\", fold=-1, scale=0.4, idle_wires=False)" ] }, { "cell_type": "markdown", "id": "postselect-md", "metadata": {}, "source": [ "\n", "\n", "## 3. Realizar una prueba del circuito comprobado\n", "\n", "`ibm_boston`Antes 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.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "sample", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sampled 1000 shots\n" ] } ], "source": [ "from qiskit import transpile\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", "# Transpile once: lay the checked circuit out on our qubits and into the native basis\n", "isa_circuit = transpile(\n", " checked_circuit.circuit,\n", " backend,\n", " initial_layout=layout + ancilla_qubits,\n", " optimization_level=0,\n", ")\n", "\n", "# Build an Aer noise model matching the depolarizing model used to pick checks\n", "aer_noise = AerNoiseModel()\n", "aer_noise.add_all_qubit_quantum_error(\n", " depolarizing_error(noise_model.gate_noise, 2), [\"cz\"]\n", ")\n", "p = noise_model.readout_noise\n", "aer_noise.add_all_qubit_readout_error(ReadoutError([[1 - p, p], [p, 1 - p]]))\n", "simulator = AerSimulator(method=\"stabilizer\", noise_model=aer_noise)\n", "\n", "counts = (\n", " simulator.run(isa_circuit, shots=1000, seed_simulator=1764)\n", " .result()\n", " .get_counts()\n", ")\n", "print(f\"sampled {sum(counts.values())} shots\")" ] }, { "cell_type": "markdown", "id": "postselect-step-md", "metadata": {}, "source": [ "\n", "\n", "## 4. Muestras seleccionadas a posteriori en las que no se ha detectado ningún error\n", "\n", "`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](https://github.com/Qiskit/qiskit-paulice/blob/main/docs/guides/low_overhead_error_detection_using_spacetime_codes.ipynb) para ver una comparación cuantitativa de la fidelidad.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "postselect", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "kept 927 of 1000 shots (93%)\n" ] } ], "source": [ "# Keep only the shots in which no check reported an error\n", "ps_fn = checked_circuit.get_postselection_method()\n", "counts_postselected = {\n", " bs: n for bs, n in counts.items() if not ps_fn(bs).any()\n", "}\n", "\n", "kept, total = sum(counts_postselected.values()), sum(counts.values())\n", "print(f\"kept {kept} of {total} shots ({kept / total:.0%})\")" ] }, { "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" } }, "nbformat": 4, "nbformat_minor": 5 }