{ "cells": [ { "cell_type": "markdown", "id": "a1b2c3d4", "metadata": {}, "source": [ "---\n", "title: \"Métodos de compilación para circuitos de simulación hamiltonianos\"\n", "description: \"Compara los métodos de compilación de SABRE, el transpiler basado en IA y Rustiq en circuitos de simulación hamiltonianos de Hamlib.\"\n", "---\n", "\n", "\n", "\n", "# Métodos de compilación para circuitos de simulación hamiltonianos\n", "\n", "*Estimación de tiempo de ejecución: menos de 1 minuto en un procesador Heron de IBM (NOTA: Se trata únicamente de una estimación. (El tiempo de ejecución puede variar.)*\n", "\n", "{/* cspell:ignore Rustiq, nshuffles, edgecolors, edgecolor, Hamlib, Benchpress, Brugiere, Goubault, Martiel, Dubal, Lishman, Ivrii, fontweight, fontsize, textprops, wedgeprops, startangle, autopct, Hellinger, iloc, ylabel, frameon, ylims, CMHSC */}\n", "\n" ] }, { "cell_type": "markdown", "id": "b1c2d3e4", "metadata": {}, "source": [ "\n", "\n", "## Resultados del aprendizaje\n", "\n", "Una vez que hayas completado este tutorial, comprenderás:\n", "\n", "* Cómo utilizar el transpilador de Qiskit con SABRE para la optimización del diseño y el enrutamiento\n", "* Cómo sacar partido al transpilador basado en IA para la optimización avanzada de circuitos\n", "* Cómo utilizar el complemento Rustiq para sintetizar `PauliEvolutionGate` operaciones en circuitos de simulación hamiltonianos\n", "* Cómo evaluar y comparar métodos de compilación utilizando la profundidad de dos qubits, el número total de puertas y el tiempo de ejecución\n", "\n", "\n", "\n", "## Requisitos previos\n", "\n", "Te recomendamos que te familiarices con los siguientes temas antes de seguir este tutorial:\n", "\n", "* [Conceptos de transpilación](/docs/guides/transpile)\n", "* [Etapas del transpilador](/docs/guides/transpiler-stages)\n", "* [Transpilar con gestores de pasos](/docs/guides/transpile-with-pass-managers)\n", "\n" ] }, { "cell_type": "markdown", "id": "c1d2e3f4", "metadata": {}, "source": [ "\n", "\n", "## En segundo plano\n", "\n", "La compilación de circuitos cuánticos transforma un algoritmo cuántico de alto nivel en un circuito físico que respeta las restricciones del hardware de destino. Una compilación eficaz puede reducir significativamente la profundidad del circuito y el número de puertas lógicas, dos factores que influyen directamente en la calidad de los resultados de los dispositivos cuánticos a corto plazo.\n", "\n", "En este tutorial se comparan tres métodos de compilación en circuitos de simulación hamiltoniana creados con `PauliEvolutionGate`. Estos circuitos modelan las interacciones entre pares de qubits (como los términos « $ZZ$ », « $XX$ » y « $YY$ ») y son habituales en la química cuántica, la física de la materia condensada y la ciencia de los materiales.\n", "\n", "Los circuitos de referencia proceden de la colección [Hamlib](https://github.com/SRI-International/QC-App-Oriented-Benchmarks/tree/master/qedcbench/hamlib#hamlib-simulation---benchmark-program), a la que se accede a través del repositorio [Benchpress](https://github.com/Qiskit/benchpress). Hamlib ofrece un conjunto estandarizado de hamiltonianos representativos, lo que permite comparar estrategias de compilación en cargas de trabajo de simulación realistas.\n", "\n", "\n", "\n", "### Resumen de los métodos de compilación\n", "\n", "\n", "\n", "#### Transpilador de Qiskit con SABRE\n", "\n", "El transpilador de Qiskit utiliza el algoritmo SABRE (búsqueda heurística « BidiREctional » basada en SWAP) para optimizar el diseño y el enrutamiento de los circuitos. SABRE se centra en minimizar las puertas SWAP y su impacto en la profundidad del circuito, respetando al mismo tiempo las restricciones de conectividad del hardware. Se trata de un método de uso general que ofrece un buen equilibrio entre rendimiento y tiempo de compilación. Para más información, véase [\\[1\\]](https://arxiv.org/abs/2409.08368). Las ventajas y el análisis de los parámetros de SABRE se tratan en profundidad en un [tutorial](/docs/tutorials/transpilation-optimizations-with-sabre) aparte.\n", "\n", "\n", "\n", "#### Transpilador basado en IA\n", "\n", "El transpilador basado en inteligencia artificial utiliza el aprendizaje automático para predecir estrategias óptimas de transpilación mediante el análisis de patrones en la estructura de los circuitos y las restricciones de hardware. También puede aplicar el `AIPauliNetworkSynthesis` «pass», que se centra en los circuitos de la red de Pauli mediante un enfoque de síntesis basado en el aprendizaje por refuerzo. Para más información, véanse [\\[2\\]](https://arxiv.org/abs/2405.13196) y [\\[3\\]](https://arxiv.org/abs/2503.14448).\n", "\n", "\n", "\n", "#### Complemento Rustiq\n", "\n", "El complemento Rustiq ofrece técnicas avanzadas de síntesis específicas para `PauliEvolutionGate` operaciones que representan las rotaciones de Pauli, habitualmente utilizadas en la dinámica de Trotter. Está diseñado para generar descomposiciones de circuitos de poca profundidad para cargas de trabajo de simulación hamiltoniana. Para más información, véase [\\[4\\]](https://arxiv.org/abs/2404.03280).\n", "\n", "\n", "\n", "### Métricas clave\n", "\n", "Comparamos los tres métodos en función de los siguientes indicadores:\n", "\n", "* **Profundidad de dos qubits** : La profundidad del circuito que tiene en cuenta únicamente las puertas de dos qubits. Esto suele ser el cuello de botella que limita la fidelidad en el hardware real.\n", "* **Tamaño del circuito (número total de puertas)** : El número total de puertas del circuito transpilado.\n", "* **Tiempo de ejecución** : El tiempo real transcurrido durante la transpilación.\n", "\n" ] }, { "cell_type": "markdown", "id": "d1e2f3a4", "metadata": {}, "source": [ "\n", "\n", "## Requisitos\n", "\n", "Antes de empezar este tutorial, asegúrate de tener instalado lo siguiente:\n", "\n", "* Qiskit SDK v2.0 o posterior, con soporte [para visualización](/docs/api/qiskit/visualization)\n", "* Qiskit Runtime v0.22 o posterior (`pip install qiskit-ibm-runtime`)\n", "* Qiskit Aer (`pip install qiskit-aer`)\n", "* Qiskit IBM Transpiler (`pip install qiskit-ibm-transpiler`)\n", "* Qiskit AI Transpiler modo local (`pip install qiskit_ibm_ai_local_transpiler`)\n", "* Networkx (`pip install networkx`)\n", "\n" ] }, { "cell_type": "markdown", "id": "e1f2a3b4", "metadata": {}, "source": [ "\n", "\n", "## Configuración\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "f1a2b3c4", "metadata": {}, "outputs": [], "source": [ "from qiskit.circuit import QuantumCircuit\n", "from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2\n", "from qiskit.circuit.library import PauliEvolutionGate\n", "from qiskit_ibm_transpiler import generate_ai_pass_manager\n", "from qiskit.quantum_info import SparsePauliOp\n", "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", "from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig\n", "from qiskit_aer import AerSimulator\n", "from qiskit_aer.noise import NoiseModel, depolarizing_error\n", "from collections import Counter\n", "from statistics import mean, stdev\n", "from scipy.sparse import SparseEfficiencyWarning\n", "import time\n", "import warnings\n", "import matplotlib.pyplot as plt\n", "import matplotlib.ticker as ticker\n", "import numpy as np\n", "import json\n", "import requests\n", "import logging\n", "\n", "# Suppress noisy loggers and warnings\n", "logging.getLogger(\n", " \"qiskit_ibm_transpiler.wrappers.ai_local_synthesis\"\n", ").setLevel(logging.ERROR)\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", "warnings.filterwarnings(\"ignore\", category=SparseEfficiencyWarning)\n", "\n", "seed = 42 # Seed for reproducibility" ] }, { "cell_type": "markdown", "id": "a2b3c4d5", "metadata": {}, "source": [ "\n", "\n", "### Conectarse a un servidor backend\n", "\n", "Selecciona un backend que se vaya a utilizar tanto para los ejemplos a pequeña escala como para los de gran escala. El backend determina el mapa de acoplamiento y las puertas de base a las que se dirige el transpilador.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "b2c3d4e5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using backend: ibm_pittsburgh\n" ] } ], "source": [ "# QiskitRuntimeService.save_account(channel=\"ibm_quantum_platform\",\n", "# token=\"\", overwrite=True, set_as_default=True)\n", "service = QiskitRuntimeService(channel=\"ibm_quantum_platform\")\n", "backend = service.least_busy(operational=True, simulator=False)\n", "print(f\"Using backend: {backend.name}\")" ] }, { "cell_type": "markdown", "id": "c2d3e4f5", "metadata": {}, "source": [ "\n", "\n", "### Definir gestores de pases\n", "\n", "Configura los tres métodos de compilación.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "d2e3f4a5", "metadata": {}, "outputs": [], "source": [ "# SABRE pass manager (Qiskit default at optimization level 3)\n", "pm_sabre = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend, seed_transpiler=seed\n", ")" ] }, { "cell_type": "code", "execution_count": 4, "id": "e2f3a4b5", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e14d6bb64d3e4a399a645a5437a4a1cb", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Fetching 127 files: 0%| | 0/127 [00:00\n", "\n", "### Definir funciones auxiliares\n", "\n", "La siguiente función compila una lista de circuitos utilizando un gestor de pasadas determinado y registra las métricas clave (profundidad de dos qubits, tamaño del circuito y tiempo de ejecución) de cada circuito.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "b3c4d5e6", "metadata": {}, "outputs": [], "source": [ "def capture_transpilation_metrics(\n", " results, pass_manager, circuits, method_name\n", "):\n", " \"\"\"\n", " Transpile circuits and append one metrics record per circuit to\n", " ``results``.\n", "\n", " Args:\n", " results (list): List of dicts to append the metrics records to.\n", " pass_manager: Pass manager used for transpilation.\n", " circuits (list): List of quantum circuits to transpile.\n", " method_name (str): Name of the transpilation method.\n", "\n", " Returns:\n", " list: List of transpiled circuits.\n", " \"\"\"\n", " transpiled_circuits = []\n", "\n", " for i, qc in enumerate(circuits):\n", " start_time = time.time()\n", " transpiled_qc = pass_manager.run(qc)\n", " end_time = time.time()\n", "\n", " # Decompose swaps for consistency across methods\n", " transpiled_qc = transpiled_qc.decompose(gates_to_decompose=[\"swap\"])\n", "\n", " transpilation_time = end_time - start_time\n", " two_qubit_depth = transpiled_qc.depth(\n", " lambda x: x.operation.num_qubits == 2\n", " )\n", " circuit_size = transpiled_qc.size()\n", "\n", " results.append(\n", " {\n", " \"method\": method_name,\n", " \"qc_name\": qc.name,\n", " \"qc_index\": i,\n", " \"num_qubits\": qc.num_qubits,\n", " \"two_qubit_depth\": two_qubit_depth,\n", " \"size\": circuit_size,\n", " \"runtime\": transpilation_time,\n", " }\n", " )\n", " transpiled_circuits.append(transpiled_qc)\n", " print(\n", " f\"[{method_name}] Circuit {i} ({qc.name}): \"\n", " f\"2Q depth={two_qubit_depth}, size={circuit_size}, \"\n", " f\"time={transpilation_time:.2f}s\"\n", " )\n", "\n", " return transpiled_circuits" ] }, { "cell_type": "code", "execution_count": 7, "id": "summary_table_fn", "metadata": {}, "outputs": [], "source": [ "def _method_order(results):\n", " \"\"\"Return the distinct method names in their first-seen order.\"\"\"\n", " order = []\n", " for r in results:\n", " if r[\"method\"] not in order:\n", " order.append(r[\"method\"])\n", " return order\n", "\n", "\n", "def print_summary_table(results):\n", " \"\"\"\n", " Print the mean and standard deviation of each metric per compilation\n", " method, followed by the mean percent improvement relative to SABRE.\n", " \"\"\"\n", " metrics = [\n", " (\"two_qubit_depth\", \"2Q Depth\"),\n", " (\"size\", \"Gate Count\"),\n", " (\"runtime\", \"Runtime (s)\"),\n", " ]\n", " methods = _method_order(results)\n", " by_method = {m: [r for r in results if r[\"method\"] == m] for m in methods}\n", " sabre_by_index = {r[\"qc_index\"]: r for r in by_method.get(\"SABRE\", [])}\n", "\n", " col_w = 22\n", " name_w = max(len(m) for m in methods)\n", " header = f\"{'Method':<{name_w}}\" + \"\".join(\n", " f\" {label:>{col_w}}\" for _, label in metrics\n", " )\n", "\n", " print(\"Mean +/- std per compilation method\")\n", " print(header)\n", " print(\"-\" * len(header))\n", " for method in methods:\n", " cells = []\n", " for key, _ in metrics:\n", " values = [r[key] for r in by_method[method]]\n", " std = stdev(values) if len(values) > 1 else 0.0\n", " cells.append(f\"{mean(values):,.1f} +/- {std:,.1f}\")\n", " print(\n", " f\"{method:<{name_w}}\" + \"\".join(f\" {c:>{col_w}}\" for c in cells)\n", " )\n", "\n", " others = [m for m in methods if m != \"SABRE\"]\n", " if others and sabre_by_index:\n", " print()\n", " print(\"Mean % improvement vs SABRE (positive = better than SABRE)\")\n", " print(header)\n", " print(\"-\" * len(header))\n", " for method in others:\n", " cells = []\n", " for key, _ in metrics:\n", " pct = [\n", " (sabre_by_index[r[\"qc_index\"]][key] - r[key])\n", " / sabre_by_index[r[\"qc_index\"]][key]\n", " * 100\n", " for r in by_method[method]\n", " if sabre_by_index.get(r[\"qc_index\"])\n", " and sabre_by_index[r[\"qc_index\"]][key]\n", " ]\n", " if pct:\n", " std = stdev(pct) if len(pct) > 1 else 0.0\n", " cells.append(f\"{mean(pct):+.1f}% +/- {std:.1f}%\")\n", " else:\n", " cells.append(\"n/a\")\n", " print(\n", " f\"{method:<{name_w}}\"\n", " + \"\".join(f\" {c:>{col_w}}\" for c in cells)\n", " )" ] }, { "cell_type": "code", "execution_count": 8, "id": "per_circuit_table_fn", "metadata": {}, "outputs": [], "source": [ "def print_per_circuit_comparison(results, num_rows=5):\n", " \"\"\"\n", " Print a per-metric comparison of the compilation methods for the\n", " first ``num_rows`` circuits (sorted by qubit count). The best\n", " (lowest) value for each metric is marked with an asterisk.\n", " \"\"\"\n", " metrics = [\n", " (\"two_qubit_depth\", \"2Q Depth\"),\n", " (\"size\", \"Gate Count\"),\n", " (\"runtime\", \"Runtime (s)\"),\n", " ]\n", " methods = _method_order(results)\n", "\n", " by_index = {}\n", " for r in results:\n", " by_index.setdefault(r[\"qc_index\"], {})[r[\"method\"]] = r\n", " ordered = sorted(\n", " by_index.items(),\n", " key=lambda kv: (next(iter(kv[1].values()))[\"num_qubits\"], kv[0]),\n", " )[:num_rows]\n", "\n", " for key, label in metrics:\n", " print(f\"{label} (first {num_rows} circuits by qubit count); * = best\")\n", " header = f\"{'Idx':>3} {'Circuit':<16} {'Q':>3}\" + \"\".join(\n", " f\"{m:>9}\" for m in methods\n", " )\n", " print(header)\n", " print(\"-\" * len(header))\n", " for idx, method_map in ordered:\n", " any_record = next(iter(method_map.values()))\n", " present = {\n", " m: method_map[m][key] for m in methods if m in method_map\n", " }\n", " best = min(present.values())\n", " line = (\n", " f\"{idx:>3} {any_record['qc_name'][:16]:<16} \"\n", " f\"{any_record['num_qubits']:>3}\"\n", " )\n", " for m in methods:\n", " value = method_map[m][key]\n", " text = f\"{value:.2f}\" if key == \"runtime\" else f\"{int(value)}\"\n", " if value == best:\n", " text += \"*\"\n", " line += f\"{text:>9}\"\n", " print(line)\n", " print()" ] }, { "cell_type": "markdown", "id": "c3d4e5f6", "metadata": {}, "source": [ "\n", "\n", "### Cargar circuitos hamiltonianos desde Hamlib\n", "\n", "Cargamos un conjunto representativo de hamiltonianos del repositorio Benchpress y construimos `PauliEvolutionGate` circuitos. Se eliminan los circuitos que superan el número de qubits del backend, así como aquellos cuyo tamaño tras la descomposición supera las 1.500 puertas (para que los tiempos de transpilación sean razonables).\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "d3e4f5a6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Total Hamiltonian circuits loaded: 42\n", "Qubit range: 2 to 112\n" ] } ], "source": [ "# Obtain the Hamiltonian JSON from the benchpress repository\n", "url = (\n", " \"https://raw.githubusercontent.com/Qiskit/benchpress/\"\n", " \"e7b29ef7be4cc0d70237b8fdc03edbd698908eff/\"\n", " \"benchpress/hamiltonian/hamlib/100_representative.json\"\n", ")\n", "response = requests.get(url)\n", "response.raise_for_status()\n", "ham_records = json.loads(response.text)\n", "\n", "# Remove circuits that are too large for the backend\n", "ham_records = [\n", " h for h in ham_records if h[\"ham_qubits\"] <= backend.num_qubits\n", "]\n", "\n", "# Build PauliEvolutionGate circuits\n", "qc_ham_list = []\n", "for h in ham_records:\n", " terms = h[\"ham_hamlib_hamiltonian_terms\"]\n", " coeff = h[\"ham_hamlib_hamiltonian_coefficients\"]\n", " num_qubits = h[\"ham_qubits\"]\n", " name = h[\"ham_problem\"]\n", "\n", " evo_gate = PauliEvolutionGate(SparsePauliOp(terms, coeff))\n", " qc = QuantumCircuit(num_qubits)\n", " qc.name = name\n", " qc.append(evo_gate, range(num_qubits))\n", " qc_ham_list.append(qc)\n", "\n", "# Remove circuits whose decomposed size exceeds 1500 gates so that\n", "# transpilation completes in a reasonable time frame\n", "qc_ham_list = [qc for qc in qc_ham_list if qc.decompose().size() <= 1500]\n", "\n", "print(f\"Total Hamiltonian circuits loaded: {len(qc_ham_list)}\")\n", "min_qubits = min(qc.num_qubits for qc in qc_ham_list)\n", "max_qubits = max(qc.num_qubits for qc in qc_ham_list)\n", "print(f\"Qubit range: {min_qubits} to {max_qubits}\")" ] }, { "cell_type": "markdown", "id": "e3f4a5b6", "metadata": {}, "source": [ "Dividir los circuitos en grupos de pequeña escala (menos de 20 qubits) y de gran escala (20 o más qubits).\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "f3a4b5c6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Small-scale circuits (<20 qubits): 20\n", "Large-scale circuits (>=20 qubits): 22\n" ] } ], "source": [ "qc_small = [qc for qc in qc_ham_list if qc.num_qubits < 20]\n", "qc_large = [qc for qc in qc_ham_list if qc.num_qubits >= 20]\n", "\n", "print(f\"Small-scale circuits (<20 qubits): {len(qc_small)}\")\n", "print(f\"Large-scale circuits (>=20 qubits): {len(qc_large)}\")" ] }, { "cell_type": "markdown", "id": "a4b5c6d7", "metadata": {}, "source": [ "Echa un vistazo a uno de los circuitos hamiltonianos a pequeña escala antes de la transpilación.\n", "\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "b4c5d6e7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# We decompose the circuit here, otherwise it would just be a PauliEvolutionGate box,\n", "# which isn't very informative to look at!\n", "qc_small[0].decompose().draw(\"mpl\", fold=-1)" ] }, { "cell_type": "markdown", "id": "sec-small-scale", "metadata": {}, "source": [ "\n", "\n", "## Ejemplo a pequeña escala\n", "\n", "En esta sección, comparamos los tres métodos de compilación en circuitos hamiltonianos con menos de 20 qubits. Estos circuitos se transpilan rápidamente y ofrecen una visión clara de cómo cada método gestiona circuitos de complejidad moderada.\n", "\n" ] }, { "cell_type": "markdown", "id": "c4d5e6f7", "metadata": {}, "source": [ "\n", "\n", "### Paso 1: Asignar entradas clásicas a un problema cuántico\n", "\n", "Cada hamiltoniano se codifica como un `PauliEvolutionGate` circuito. Los circuitos ya se habían construido en la sección de configuración a partir de los datos de las pruebas de rendimiento de Hamlib.\n", "\n" ] }, { "cell_type": "markdown", "id": "d4e5f6a7", "metadata": {}, "source": [ "\n", "\n", "### Paso 2: Optimizar el problema para la ejecución en hardware cuántico\n", "\n", "Transpilamos todos los circuitos a pequeña escala utilizando cada uno de los tres gestores de pasadas y, a continuación, recopilamos las métricas.\n", "\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "e4f5a6b7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[SABRE] Circuit 0 (all-vib-bh): 2Q depth=3, size=30, time=2.09s\n", "[SABRE] Circuit 1 (all-vib-c2h): 2Q depth=18, size=111, time=0.01s\n", "[SABRE] Circuit 2 (all-vib-o3): 2Q depth=6, size=58, time=0.00s\n", "[SABRE] Circuit 3 (all-vib-c2h): 2Q depth=2, size=37, time=0.01s\n", "[SABRE] Circuit 4 (graph-gnp_k-2): 2Q depth=24, size=126, time=0.01s\n", "[SABRE] Circuit 5 (LiH): 2Q depth=66, size=285, time=0.01s\n", "[SABRE] Circuit 6 (all-vib-fccf): 2Q depth=66, size=339, time=0.01s\n", "[SABRE] Circuit 7 (all-vib-ch2): 2Q depth=88, size=413, time=0.01s\n", "[SABRE] Circuit 8 (all-vib-f2): 2Q depth=180, size=1000, time=0.02s\n", "[SABRE] Circuit 9 (all-vib-bhf2): 2Q depth=18, size=223, time=0.03s\n", "[SABRE] Circuit 10 (graph-gnp_k-4): 2Q depth=122, size=675, time=0.02s\n", "[SABRE] Circuit 11 (Be2): 2Q depth=343, size=1628, time=0.03s\n", "[SABRE] Circuit 12 (all-vib-fccf): 2Q depth=14, size=134, time=0.00s\n", "[SABRE] Circuit 13 (uf20-ham): 2Q depth=50, size=341, time=0.01s\n", "[SABRE] Circuit 14 (TSP_Ncity-4): 2Q depth=118, size=615, time=0.01s\n", "[SABRE] Circuit 15 (graph-complete_bipart): 2Q depth=232, size=1420, time=0.03s\n", "[SABRE] Circuit 16 (all-vib-cyclo_propene): 2Q depth=18, size=354, time=0.93s\n", "[SABRE] Circuit 17 (all-vib-hno): 2Q depth=6, size=174, time=0.14s\n", "[SABRE] Circuit 18 (all-vib-fccf): 2Q depth=30, size=286, time=0.01s\n", "[SABRE] Circuit 19 (tfim): 2Q depth=31, size=232, time=0.03s\n", "[AI] Circuit 0 (all-vib-bh): 2Q depth=3, size=30, time=0.01s\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cf50b939bf4141bcbc610275a514d6fd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Fetching 4 files: 0%| | 0/4 [00:00\n", "\n", "#### Visualizar resultados\n", "\n", "Los gráficos que se muestran a continuación comparan los tres métodos en función de cada indicador, circuito por circuito. Los circuitos se ordenan según el número de qubits y se identifican mediante un índice en el eje x, ya que varios circuitos pueden compartir el mismo número de qubits.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "c5d6e7f8", "metadata": {}, "outputs": [], "source": [ "def plot_transpilation_comparison(results, title_prefix):\n", " \"\"\"\n", " Create a three-panel figure comparing compilation methods on\n", " two-qubit depth, circuit size, and runtime.\n", "\n", " Circuits are sorted by qubit count and plotted by circuit index.\n", " \"\"\"\n", " methods = _method_order(results)\n", " palette = {\"SABRE\": \"#1f77b4\", \"AI\": \"#ff7f0e\", \"Rustiq\": \"#2ca02c\"}\n", " markers = {\"SABRE\": \"o\", \"AI\": \"^\", \"Rustiq\": \"s\"}\n", "\n", " # Order circuits by qubit count (then index) and map to plot positions\n", " ref = sorted(\n", " [r for r in results if r[\"method\"] == methods[0]],\n", " key=lambda r: (r[\"num_qubits\"], r[\"qc_index\"]),\n", " )\n", " pos_map = {r[\"qc_index\"]: pos for pos, r in enumerate(ref)}\n", " tick_positions = [pos_map[r[\"qc_index\"]] for r in ref]\n", " tick_labels = [\n", " f\"{pos_map[r['qc_index']]} ({r['num_qubits']}q)\" for r in ref\n", " ]\n", "\n", " metrics = [\n", " (\"two_qubit_depth\", \"Two-Qubit Depth\"),\n", " (\"size\", \"Total Gate Count (Circuit Size)\"),\n", " (\"runtime\", \"Transpilation Runtime (s)\"),\n", " ]\n", "\n", " fig, axes = plt.subplots(1, 3, figsize=(20, 5.5))\n", " fig.suptitle(title_prefix, fontsize=15, fontweight=\"bold\", y=1.02)\n", "\n", " for ax, (metric, ylabel) in zip(axes, metrics):\n", " for method in methods:\n", " subset = sorted(\n", " [r for r in results if r[\"method\"] == method],\n", " key=lambda r: pos_map[r[\"qc_index\"]],\n", " )\n", " ax.plot(\n", " [pos_map[r[\"qc_index\"]] for r in subset],\n", " [r[metric] for r in subset],\n", " marker=markers.get(method, \"o\"),\n", " label=method,\n", " color=palette.get(method, None),\n", " linewidth=1.5,\n", " markersize=6,\n", " alpha=0.85,\n", " )\n", " ax.set_xlabel(\"Circuit Index (num qubits)\", fontsize=11)\n", " ax.set_ylabel(ylabel, fontsize=11)\n", " ax.legend(frameon=True, fontsize=9)\n", " ax.grid(True, linestyle=\"--\", alpha=0.4)\n", " step = max(1, len(tick_positions) // 15)\n", " ax.set_xticks(tick_positions[::step])\n", " ax.set_xticklabels(\n", " [tick_labels[i] for i in range(0, len(tick_labels), step)],\n", " fontsize=7,\n", " rotation=45,\n", " ha=\"right\",\n", " )\n", "\n", " plt.tight_layout()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 16, "id": "pct_improvement_plot_fn", "metadata": {}, "outputs": [], "source": [ "def plot_pct_improvement_vs_sabre(results, title_prefix):\n", " \"\"\"\n", " Plot the per-circuit percent improvement of each non-SABRE method\n", " relative to SABRE, for each metric. A positive value means the\n", " method improved on SABRE; negative means SABRE was better.\n", " \"\"\"\n", " metrics = [\n", " (\"two_qubit_depth\", \"2Q Depth\"),\n", " (\"size\", \"Gate Count\"),\n", " (\"runtime\", \"Runtime\"),\n", " ]\n", " palette = {\"AI\": \"#ff7f0e\", \"Rustiq\": \"#2ca02c\"}\n", " markers = {\"AI\": \"^\", \"Rustiq\": \"s\"}\n", "\n", " methods = _method_order(results)\n", " sabre = sorted(\n", " [r for r in results if r[\"method\"] == \"SABRE\"],\n", " key=lambda r: (r[\"num_qubits\"], r[\"qc_index\"]),\n", " )\n", " other_methods = [m for m in methods if m != \"SABRE\"]\n", "\n", " tick_positions = list(range(len(sabre)))\n", " tick_labels = [\n", " f\"{i} ({sabre[i]['num_qubits']}q)\" for i in range(len(sabre))\n", " ]\n", "\n", " fig, axes = plt.subplots(1, 3, figsize=(20, 5.5))\n", " fig.suptitle(\n", " f\"{title_prefix}: % Improvement over SABRE\",\n", " fontsize=15,\n", " fontweight=\"bold\",\n", " y=1.02,\n", " )\n", "\n", " for ax, (metric, label) in zip(axes, metrics):\n", " ax.axhline(0, color=\"#1f77b4\", linewidth=2, label=\"SABRE (baseline)\")\n", " for method in other_methods:\n", " data = sorted(\n", " [r for r in results if r[\"method\"] == method],\n", " key=lambda r: (r[\"num_qubits\"], r[\"qc_index\"]),\n", " )\n", " pct = [\n", " (sabre[i][metric] - data[i][metric]) / sabre[i][metric] * 100\n", " for i in range(len(sabre))\n", " ]\n", " ax.plot(\n", " tick_positions,\n", " pct,\n", " marker=markers.get(method, \"o\"),\n", " label=method,\n", " color=palette.get(method, None),\n", " linewidth=1.5,\n", " markersize=6,\n", " alpha=0.85,\n", " )\n", " ax.set_xlabel(\"Circuit Index (num qubits)\", fontsize=11)\n", " ax.set_ylabel(f\"% Improvement ({label})\", fontsize=11)\n", " ax.legend(frameon=True, fontsize=9)\n", " ax.grid(True, linestyle=\"--\", alpha=0.4)\n", " step = max(1, len(tick_positions) // 15)\n", " ax.set_xticks(tick_positions[::step])\n", " ax.set_xticklabels(\n", " [tick_labels[i] for i in range(0, len(tick_labels), step)],\n", " fontsize=7,\n", " rotation=45,\n", " ha=\"right\",\n", " )\n", " ylims = ax.get_ylim()\n", " ax.axhspan(0, max(ylims[1], 1), alpha=0.04, color=\"green\")\n", " ax.axhspan(min(ylims[0], -1), 0, alpha=0.04, color=\"red\")\n", "\n", " plt.tight_layout()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 17, "id": "d5e6f7a8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_transpilation_comparison(\n", " results_small,\n", " \"Small-Scale Hamiltonian Circuits: Compilation Comparison\",\n", ")" ] }, { "cell_type": "code", "execution_count": 18, "id": "pct_improvement_small", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_pct_improvement_vs_sabre(\n", " results_small,\n", " \"Small-Scale Hamiltonian Circuits\",\n", ")" ] }, { "cell_type": "markdown", "id": "d2a29d04", "metadata": {}, "source": [ "A esta escala, los tres gestores de pases obtienen buenos resultados, y sus resultados medios son muy similares entre sí. Esto se debe, en gran medida, a que los circuitos pequeños ofrecen un margen limitado para una mayor optimización, por lo que los métodos tienden a converger en soluciones similares.\n", "\n", "En este ejemplo, Rustiq ofrece los resultados más variables, con los valores atípicos más destacados tanto en la profundidad de dos qubits como en el número de puertas. Aunque esta variabilidad hace que a veces se quede rezagado, también significa que, en ocasiones, Rustiq encuentra soluciones mejores que los otros dos métodos. El transpilador de IA ofrece resultados más estables que SABRE y Rustiq, ya que se mantiene muy cerca de ellos en la mayoría de los circuitos sin presentar muchos valores atípicos.\n", "\n", "En cuanto a la velocidad de ejecución, tanto SABRE como Rustiq son rápidos, mientras que el transpilador basado en IA es notablemente más lento en determinados circuitos.\n", "\n" ] }, { "cell_type": "markdown", "id": "e5f6a7b8", "metadata": {}, "source": [ "\n", "\n", "#### Método con mejor rendimiento según el indicador\n", "\n", "El gráfico siguiente muestra la frecuencia con la que cada método ha alcanzado el mejor valor (el más bajo) para cada indicador. Es posible que haya empates: en circuitos más sencillos, varios métodos pueden alcanzar la misma profundidad óptima de dos qubits o el mismo número de puertas. Cuando hay un empate, se tienen en cuenta todos los métodos empatados, por lo que la suma de los porcentajes de una métrica determinada puede superar el 100 %.\n", "\n" ] }, { "cell_type": "code", "execution_count": 19, "id": "f5a6b7c8", "metadata": {}, "outputs": [], "source": [ "def plot_best_method_bars(results, metrics_list=None):\n", " \"\"\"\n", " Plot a grouped bar chart showing the percentage of circuits\n", " where each method achieved the best (lowest) value for each metric.\n", "\n", " Ties are counted for all tied methods, so percentages per metric\n", " can sum to more than 100%.\n", " \"\"\"\n", " if metrics_list is None:\n", " metrics_list = [\"two_qubit_depth\", \"size\", \"runtime\"]\n", "\n", " labels = {\n", " \"two_qubit_depth\": \"2Q Depth\",\n", " \"size\": \"Gate Count\",\n", " \"runtime\": \"Runtime\",\n", " }\n", " methods = _method_order(results)\n", " palette = {\"SABRE\": \"#1f77b4\", \"AI\": \"#ff7f0e\", \"Rustiq\": \"#2ca02c\"}\n", "\n", " by_index = {}\n", " for r in results:\n", " by_index.setdefault(r[\"qc_index\"], []).append(r)\n", " n_circuits = len(by_index)\n", "\n", " win_data = {m: [] for m in methods}\n", " tie_counts = []\n", " metric_labels = []\n", "\n", " for metric in metrics_list:\n", " metric_labels.append(\n", " labels.get(metric, metric.replace(\"_\", \" \").title())\n", " )\n", " counts = Counter()\n", " ties = 0\n", " for group in by_index.values():\n", " min_val = min(r[metric] for r in group)\n", " best = [r[\"method\"] for r in group if r[metric] == min_val]\n", " if len(best) > 1:\n", " ties += 1\n", " counts.update(best)\n", " tie_counts.append(ties)\n", " for m in methods:\n", " win_data[m].append(counts.get(m, 0) / n_circuits * 100)\n", "\n", " x = np.arange(len(metric_labels))\n", " width = 0.22\n", " fig, ax = plt.subplots(figsize=(8, 5))\n", "\n", " for i, method in enumerate(methods):\n", " bars = ax.bar(\n", " x + i * width,\n", " win_data[method],\n", " width,\n", " label=method,\n", " color=palette.get(method, None),\n", " edgecolor=\"black\",\n", " linewidth=0.5,\n", " )\n", " for bar in bars:\n", " height = bar.get_height()\n", " if height > 0:\n", " ax.text(\n", " bar.get_x() + bar.get_width() / 2,\n", " height + 1.5,\n", " f\"{height:.0f}%\",\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=9,\n", " )\n", "\n", " # Annotate tie counts below each metric label\n", " for j, ties in enumerate(tie_counts):\n", " if ties > 0:\n", " ax.text(\n", " x[j] + width,\n", " -8,\n", " f\"({ties} tie{'s' if ties != 1 else ''})\",\n", " ha=\"center\",\n", " va=\"top\",\n", " fontsize=8,\n", " color=\"gray\",\n", " )\n", "\n", " ax.set_xticks(x + width)\n", " ax.set_xticklabels(metric_labels, fontsize=11)\n", " ax.set_ylabel(\"Circuits with best value (%)\", fontsize=11)\n", " ax.set_title(\n", " \"Best-Performing Method by Metric (ties counted for all tied methods)\",\n", " fontsize=12,\n", " fontweight=\"bold\",\n", " )\n", " ax.legend(frameon=True, fontsize=10)\n", " ax.set_ylim(-12, 120)\n", " ax.yaxis.set_major_formatter(ticker.PercentFormatter())\n", " ax.grid(axis=\"y\", linestyle=\"--\", alpha=0.4)\n", "\n", " plt.tight_layout()\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 20, "id": "a6b7c8d9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_best_method_bars(results_small)" ] }, { "cell_type": "markdown", "id": "30687d7b", "metadata": {}, "source": [ "En este ejemplo, los tres métodos ofrecen un rendimiento muy similar en los circuitos a pequeña escala. En cuanto a la profundidad de dos qubits y al número de puertas, la proporción de circuitos en los que cada método es el mejor es muy similar (aproximadamente entre el 35 % y el 55 %), y muchos circuitos terminan en empate, ya que los circuitos más sencillos suelen tener una única solución óptima que varios métodos logran encontrar. La diferencia más evidente es el tiempo de ejecución: SABRE y Rustiq son los más rápidos en aproximadamente la mitad de los circuitos cada uno, mientras que el transpilador basado en IA rara vez es el más rápido. Si se tienen en cuenta los tres indicadores en su conjunto, Rustiq presenta una ligera ventaja general: es el que obtiene mejores resultados en la profundidad de dos qubits y se mantiene competitivo en cuanto al número de puertas y el tiempo de ejecución.\n", "\n" ] }, { "cell_type": "markdown", "id": "b6c7d8e9", "metadata": {}, "source": [ "\n", "\n", "### Paso 3: Ejecutar utilizando Qiskit primitives\n", "\n", "Para evaluar cómo afecta la calidad de la transpilación a la ejecución en presencia de ruido, utilizamos una técnica **de circuitos espejo**. Para cada circuito transpilado $U$, le añadimos su inverso $U^\\dagger$, de modo que el circuito combinado $U^\\dagger U$ es, en teoría, el circuito de identidad. Partiendo del estado « $|0\\rangle$ », una ejecución perfecta (sin ruido) devolvería la cadena de bits compuesta íntegramente por ceros con probabilidad 1.\n", "\n", "En la práctica, los errores de las puertas lógicas se acumulan a lo largo de todo el circuito, por lo que disminuye la probabilidad de recuperar un $|0\\rangle^{\\otimes n}$. Un método de compilación que genere un circuito menos complejo y con menos puertas lógicas acumulará menos ruido.\n", "\n", "El enfoque del circuito espejo resulta atractivamente sencillo y se adapta a circuitos de cualquier tamaño, ya que la salida esperada es siempre « $|0\\rangle^{\\otimes n}$ » y no se requiere ninguna simulación clásica del estado ideal. Sin embargo, hay que tener en cuenta las siguientes salvedades: el circuito espejo es un sustituto del circuito real (no el circuito en sí mismo), duplica el número de puertas (lo que exagera el efecto del ruido) y puede subestimar ciertos errores cuando el ruido se cancela simétricamente a través del límite del espejo.\n", "\n", "Seleccionamos el índice de circuito 6 del conjunto de pequeña escala y ejecutamos los circuitos de espejo en un simulador Aer con un modelo sencillo de ruido despolarizador.\n", "\n" ] }, { "cell_type": "code", "execution_count": 21, "id": "c6d7e8f9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test circuit: all-vib-fccf, 4 qubits\n", "\n", "Transpilation metrics for circuit index 6:\n", " SABRE 2Q depth= 66 size= 339\n", " AI 2Q depth= 65 size= 300\n", " Rustiq 2Q depth= 34 size= 193\n" ] } ], "source": [ "# Select circuit index 6 from the small-scale transpiled circuits\n", "test_idx = 6\n", "test_circuit = qc_small[test_idx]\n", "print(f\"Test circuit: {test_circuit.name}, {test_circuit.num_qubits} qubits\")\n", "\n", "# Get the transpiled versions\n", "tqc_methods_small = {\n", " \"SABRE\": tqc_sabre_small[test_idx],\n", " \"AI\": tqc_ai_small[test_idx],\n", " \"Rustiq\": tqc_rustiq_small[test_idx],\n", "}\n", "\n", "# Show transpilation metrics for this circuit\n", "print(f\"\\nTranspilation metrics for circuit index {test_idx}:\")\n", "for method, tqc in tqc_methods_small.items():\n", " depth_2q = tqc.depth(lambda x: x.operation.num_qubits == 2)\n", " size = tqc.size()\n", " print(f\" {method:8s} 2Q depth={depth_2q:5d} size={size:6d}\")" ] }, { "cell_type": "markdown", "id": "d6e7f8a9", "metadata": {}, "source": [ "Crea los circuitos de espejo (añade « $U^\\dagger$ »), reasigna los índices de los qubits para que sean contiguos, de modo que el simulador solo gestione los qubits activos, y ejecútalos en un simulador Aer con ruido.\n", "\n" ] }, { "cell_type": "code", "execution_count": 22, "id": "e6f7a8b9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SABRE P(|00...0>) = 0.7796 (7796/10000)\n", "AI P(|00...0>) = 0.8073 (8073/10000)\n", "Rustiq P(|00...0>) = 0.8923 (8923/10000)\n" ] } ], "source": [ "def remap_to_contiguous(tqc):\n", " \"\"\"Remap a transpiled circuit to use contiguous qubit indices.\n", "\n", " Transpiled circuits target specific physical qubits (e.g., qubit 45, 67)\n", " on a large backend. This remaps them to 0, 1, 2, ... so Aer only\n", " simulates the active qubits.\n", " \"\"\"\n", " active = sorted(\n", " {tqc.find_bit(q).index for inst in tqc.data for q in inst.qubits}\n", " )\n", " qubit_map = {old: new for new, old in enumerate(active)}\n", " new_qc = QuantumCircuit(len(active))\n", " for inst in tqc.data:\n", " old_indices = [tqc.find_bit(q).index for q in inst.qubits]\n", " new_qc.append(inst.operation, [qubit_map[i] for i in old_indices])\n", " return new_qc\n", "\n", "\n", "def build_mirror_circuit(tqc):\n", " \"\"\"Build a mirror circuit: U followed by U-dagger, with measurements.\n", "\n", " The combined circuit U-dagger @ U should be the identity, so measuring\n", " all zeros indicates a noise-free execution.\n", " \"\"\"\n", " tqc_compact = remap_to_contiguous(tqc)\n", " mirror = tqc_compact.compose(tqc_compact.inverse())\n", " mirror.measure_all()\n", " return mirror\n", "\n", "\n", "# Build a simple depolarizing noise model\n", "noise_model = NoiseModel()\n", "noise_model.add_all_qubit_quantum_error(\n", " depolarizing_error(0.001, 1),\n", " [\"sx\", \"x\", \"rz\"], # ~0.1% per 1Q gate\n", ")\n", "noise_model.add_all_qubit_quantum_error(\n", " depolarizing_error(0.01, 2),\n", " [\"cx\", \"ecr\"], # ~1% per 2Q gate\n", ")\n", "\n", "aer_sim = AerSimulator(noise_model=noise_model)\n", "\n", "shots = 10000\n", "fidelities = {}\n", "\n", "for method, tqc in tqc_methods_small.items():\n", " mirror = build_mirror_circuit(tqc)\n", "\n", " sampler = SamplerV2(mode=aer_sim)\n", " job = sampler.run([mirror], shots=shots)\n", " result = job.result()\n", " counts = result[0].data.meas.get_counts()\n", "\n", " # Fidelity = fraction of all-zeros (error-free) outcomes\n", " n_qubits = mirror.num_qubits - mirror.num_clbits # active qubits\n", " all_zeros = \"0\" * mirror.num_qubits\n", " fidelity = counts.get(all_zeros, 0) / shots\n", " fidelities[method] = fidelity\n", " print(\n", " f\"{method:8s} P(|00...0>) = {fidelity:.4f} \"\n", " f\"({counts.get(all_zeros, 0)}/{shots})\"\n", " )" ] }, { "cell_type": "code", "execution_count": 23, "id": "small_step4_plot", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def plot_mirror_results(tqc_methods, fidelities, circuit_name):\n", " \"\"\"\n", " Plot a three-panel comparison: fidelity, 2Q depth,\n", " and gate count for each compilation method.\n", " \"\"\"\n", " methods = list(tqc_methods.keys())\n", " palette = {\"SABRE\": \"#1f77b4\", \"AI\": \"#ff7f0e\", \"Rustiq\": \"#2ca02c\"}\n", " colors = [palette.get(m, \"gray\") for m in methods]\n", "\n", " fidelity_vals = [fidelities[m] for m in methods]\n", " depth_vals = [\n", " tqc_methods[m].depth(lambda x: x.operation.num_qubits == 2)\n", " for m in methods\n", " ]\n", " size_vals = [tqc_methods[m].size() for m in methods]\n", "\n", " fig, axes = plt.subplots(1, 3, figsize=(16, 5))\n", " fig.suptitle(\n", " f\"Mirror Circuit Results: {circuit_name}\",\n", " fontsize=14,\n", " fontweight=\"bold\",\n", " y=1.02,\n", " )\n", "\n", " def _annotate_bars(ax, bars, values, fmt=\"{}\"):\n", " ymax = ax.get_ylim()[1]\n", " for bar, val in zip(bars, values):\n", " label = fmt.format(val)\n", " y = val + ymax * 0.03\n", " ax.text(\n", " bar.get_x() + bar.get_width() / 2,\n", " y,\n", " label,\n", " ha=\"center\",\n", " va=\"bottom\",\n", " fontsize=10,\n", " fontweight=\"bold\",\n", " )\n", "\n", " # Panel 1: Survival Probability\n", " bars = axes[0].bar(\n", " methods, fidelity_vals, color=colors, edgecolor=\"black\", linewidth=0.5\n", " )\n", " axes[0].set_ylabel(\"Fidelity P(|00...0>)\", fontsize=11)\n", " axes[0].set_title(\"Fidelity (higher is better)\", fontsize=12)\n", " axes[0].set_ylim(\n", " 0, max(fidelity_vals) * 1.18 if max(fidelity_vals) > 0 else 1.0\n", " )\n", " axes[0].grid(axis=\"y\", linestyle=\"--\", alpha=0.4)\n", " _annotate_bars(axes[0], bars, fidelity_vals, fmt=\"{:.4f}\")\n", "\n", " # Panel 2: Two-Qubit Depth\n", " bars = axes[1].bar(\n", " methods, depth_vals, color=colors, edgecolor=\"black\", linewidth=0.5\n", " )\n", " axes[1].set_ylabel(\"Two-Qubit Depth\", fontsize=11)\n", " axes[1].set_title(\"2Q Depth (lower is better)\", fontsize=12)\n", " axes[1].set_ylim(0, max(depth_vals) * 1.18)\n", " axes[1].grid(axis=\"y\", linestyle=\"--\", alpha=0.4)\n", " _annotate_bars(axes[1], bars, depth_vals)\n", "\n", " # Panel 3: Gate Count\n", " bars = axes[2].bar(\n", " methods, size_vals, color=colors, edgecolor=\"black\", linewidth=0.5\n", " )\n", " axes[2].set_ylabel(\"Total Gate Count\", fontsize=11)\n", " axes[2].set_title(\"Gate Count (lower is better)\", fontsize=12)\n", " axes[2].set_ylim(0, max(size_vals) * 1.18)\n", " axes[2].grid(axis=\"y\", linestyle=\"--\", alpha=0.4)\n", " _annotate_bars(axes[2], bars, size_vals)\n", "\n", " plt.tight_layout()\n", " plt.show()\n", "\n", "\n", "plot_mirror_results(tqc_methods_small, fidelities, test_circuit.name)" ] }, { "cell_type": "markdown", "id": "small_mirror_commentary", "metadata": {}, "source": [ "\n", "\n", "#### Observaciones\n", "\n", "El método con menor profundidad de dos qubits y menor número de puertas alcanza la mayor fidelidad, lo que concuerda con la hipótesis de que los circuitos más cortos acumulan menos ruido. Incluso las diferencias más pequeñas en la profundidad y el número de puertas se traducen en diferencias cuantificables en la fidelidad según el modelo de ruido despolarizante.\n", "\n", "Ten en cuenta que estos resultados corresponden a un solo circuito. La clasificación relativa de los métodos puede variar de un circuito a otro, dependiendo de la estructura del hamiltoniano.\n", "\n" ] }, { "cell_type": "markdown", "id": "sec-large-scale", "metadata": {}, "source": [ "\n", "\n", "## Ejemplo de hardware a gran escala\n", "\n", "En esta sección, comparamos los mismos tres métodos de compilación en circuitos hamiltonianos con 20 o más qubits. Estos circuitos son más representativos de las cargas de trabajo prácticas de simulación hamiltoniana y permiten comprobar cómo se adapta cada método en cuanto a la calidad del circuito y el tiempo de compilación.\n", "\n" ] }, { "cell_type": "markdown", "id": "f6a7b8c9", "metadata": {}, "source": [ "\n", "\n", "### Pasos 1 a 4 combinados\n", "\n", "El flujo de trabajo sigue la misma estructura que el ejemplo a pequeña escala. Compilamos todos los circuitos a gran escala con cada método, recopilamos métricas y enviamos un circuito espejo a un hardware cuántico real.\n", "\n" ] }, { "cell_type": "code", "execution_count": 24, "id": "a7b8c9d0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[SABRE] Circuit 0 (all-vib-hc3h2cn): 2Q depth=2, size=258, time=0.16s\n", "[SABRE] Circuit 1 (ham-graph-gnp_k-5): 2Q depth=345, size=4036, time=0.08s\n", "[SABRE] Circuit 2 (TSP_Ncity-5): 2Q depth=187, size=2045, time=0.04s\n", "[SABRE] Circuit 3 (tfim): 2Q depth=100, size=489, time=0.21s\n", "[SABRE] Circuit 4 (all-vib-h2co): 2Q depth=30, size=570, time=0.18s\n", "[SABRE] Circuit 5 (uuf100-ham): 2Q depth=414, size=4779, time=0.09s\n", "[SABRE] Circuit 6 (uuf100-ham): 2Q depth=523, size=5667, time=0.11s\n", "[SABRE] Circuit 7 (graph-gnp_k-4): 2Q depth=3028, size=24885, time=0.39s\n", "[SABRE] Circuit 8 (uf100-ham): 2Q depth=700, size=8271, time=0.15s\n", "[SABRE] Circuit 9 (uf100-ham): 2Q depth=698, size=8957, time=0.15s\n", "[SABRE] Circuit 10 (TSP_Ncity-7): 2Q depth=432, size=6353, time=0.12s\n", "[SABRE] Circuit 11 (all-vib-cyclo_propene): 2Q depth=30, size=1144, time=0.20s\n", "[SABRE] Circuit 12 (TSP_Ncity-8): 2Q depth=704, size=10287, time=0.18s\n", "[SABRE] Circuit 13 (uf100-ham): 2Q depth=2454, size=30195, time=0.46s\n", "[SABRE] Circuit 14 (tfim): 2Q depth=245, size=3670, time=0.08s\n", "[SABRE] Circuit 15 (flat100-ham): 2Q depth=154, size=3836, time=0.12s\n", "[SABRE] Circuit 16 (graph-regular_reg-4): 2Q depth=863, size=14063, time=0.22s\n", "[SABRE] Circuit 17 (tfim): 2Q depth=581, size=8810, time=0.15s\n", "[SABRE] Circuit 18 (FH_D-1): 2Q depth=1704, size=9528, time=0.35s\n", "[SABRE] Circuit 19 (TSP_Ncity-10): 2Q depth=1091, size=22041, time=0.38s\n", "[SABRE] Circuit 20 (TSP_Ncity-10): 2Q depth=1091, size=22005, time=0.38s\n", "[SABRE] Circuit 21 (ham-unary-color02-queen13_13_k-4): 2Q depth=224, size=8321, time=0.17s\n", "[AI] Circuit 0 (all-vib-hc3h2cn): 2Q depth=2, size=258, time=0.17s\n", "[AI] Circuit 1 (ham-graph-gnp_k-5): 2Q depth=323, size=4418, time=3.13s\n", "[AI] Circuit 2 (TSP_Ncity-5): 2Q depth=161, size=2229, time=1.47s\n", "[AI] Circuit 3 (tfim): 2Q depth=20, size=402, time=0.34s\n", "[AI] Circuit 4 (all-vib-h2co): 2Q depth=38, size=661, time=0.19s\n", "[AI] Circuit 5 (uuf100-ham): 2Q depth=391, size=5130, time=3.27s\n", "[AI] Circuit 6 (uuf100-ham): 2Q depth=463, size=6095, time=4.23s\n", "[AI] Circuit 7 (graph-gnp_k-4): 2Q depth=3207, size=25641, time=15.15s\n", "[AI] Circuit 8 (uf100-ham): 2Q depth=637, size=8267, time=5.87s\n", "[AI] Circuit 9 (uf100-ham): 2Q depth=632, size=9330, time=7.29s\n", "[AI] Circuit 10 (TSP_Ncity-7): 2Q depth=452, size=7418, time=6.02s\n", "[AI] Circuit 11 (all-vib-cyclo_propene): 2Q depth=38, size=1323, time=0.27s\n", "[AI] Circuit 12 (TSP_Ncity-8): 2Q depth=609, size=11131, time=10.07s\n", "[AI] Circuit 13 (uf100-ham): 2Q depth=2251, size=31128, time=38.77s\n", "[AI] Circuit 14 (tfim): 2Q depth=165, size=3460, time=1.64s\n", "[AI] Circuit 15 (flat100-ham): 2Q depth=91, size=3497, time=2.49s\n", "[AI] Circuit 16 (graph-regular_reg-4): 2Q depth=664, size=15256, time=12.35s\n", "[AI] Circuit 17 (tfim): 2Q depth=583, size=9157, time=6.28s\n", "[AI] Circuit 18 (FH_D-1): 2Q depth=1193, size=7754, time=4.54s\n", "[AI] Circuit 19 (TSP_Ncity-10): 2Q depth=1134, size=22577, time=25.64s\n", "[AI] Circuit 20 (TSP_Ncity-10): 2Q depth=1172, size=23851, time=28.97s\n", "[AI] Circuit 21 (ham-unary-color02-queen13_13_k-4): 2Q depth=219, size=8600, time=8.85s\n", "[Rustiq] Circuit 0 (all-vib-hc3h2cn): 2Q depth=2, size=257, time=0.16s\n", "[Rustiq] Circuit 1 (ham-graph-gnp_k-5): 2Q depth=640, size=5831, time=0.13s\n", "[Rustiq] Circuit 2 (TSP_Ncity-5): 2Q depth=408, size=3985, time=0.08s\n", "[Rustiq] Circuit 3 (tfim): 2Q depth=31, size=688, time=0.07s\n", "[Rustiq] Circuit 4 (all-vib-h2co): 2Q depth=65, size=1058, time=2.91s\n", "[Rustiq] Circuit 5 (uuf100-ham): 2Q depth=633, size=6757, time=0.14s\n", "[Rustiq] Circuit 6 (uuf100-ham): 2Q depth=795, size=8495, time=0.17s\n", "[Rustiq] Circuit 7 (graph-gnp_k-4): 2Q depth=13768, size=139793, time=2.92s\n", "[Rustiq] Circuit 8 (uf100-ham): 2Q depth=1099, size=11878, time=0.25s\n", "[Rustiq] Circuit 9 (uf100-ham): 2Q depth=911, size=11111, time=0.22s\n", "[Rustiq] Circuit 10 (TSP_Ncity-7): 2Q depth=1183, size=13197, time=0.27s\n", "[Rustiq] Circuit 11 (all-vib-cyclo_propene): 2Q depth=67, size=2491, time=13.56s\n", "[Rustiq] Circuit 12 (TSP_Ncity-8): 2Q depth=1615, size=21358, time=0.48s\n", "[Rustiq] Circuit 13 (uf100-ham): 2Q depth=2920, size=40465, time=0.91s\n", "[Rustiq] Circuit 14 (tfim): 2Q depth=489, size=6552, time=0.15s\n", "[Rustiq] Circuit 15 (flat100-ham): 2Q depth=378, size=5906, time=0.14s\n", "[Rustiq] Circuit 16 (graph-regular_reg-4): 2Q depth=12163, size=168679, time=2.94s\n", "[Rustiq] Circuit 17 (tfim): 2Q depth=1208, size=17042, time=0.36s\n", "[Rustiq] Circuit 18 (FH_D-1): 2Q depth=1061, size=24000, time=0.47s\n", "[Rustiq] Circuit 19 (TSP_Ncity-10): 2Q depth=2565, size=41340, time=1.38s\n", "[Rustiq] Circuit 20 (TSP_Ncity-10): 2Q depth=2565, size=41275, time=1.38s\n", "[Rustiq] Circuit 21 (ham-unary-color02-queen13_13_k-4): 2Q depth=808, size=17548, time=0.42s\n" ] } ], "source": [ "results_large = []\n", "\n", "tqc_sabre_large = capture_transpilation_metrics(\n", " results_large, pm_sabre, qc_large, \"SABRE\"\n", ")\n", "tqc_ai_large = capture_transpilation_metrics(\n", " results_large, pm_ai, qc_large, \"AI\"\n", ")\n", "tqc_rustiq_large = capture_transpilation_metrics(\n", " results_large, pm_rustiq, qc_large, \"Rustiq\"\n", ")" ] }, { "cell_type": "code", "execution_count": 25, "id": "b7c8d9e0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mean +/- std per compilation method\n", "Method 2Q Depth Gate Count Runtime (s)\n", "------------------------------------------------------------------------------\n", "SABRE 709.1 +/- 783.8 9,100.5 +/- 8,493.1 0.2 +/- 0.1\n", "AI 656.6 +/- 777.5 9,435.6 +/- 8,853.0 8.5 +/- 10.2\n", "Rustiq 2,062.5 +/- 3,631.1 26,804.8 +/- 43,403.1 1.3 +/- 2.9\n", "\n", "Mean % improvement vs SABRE (positive = better than SABRE)\n", "Method 2Q Depth Gate Count Runtime (s)\n", "------------------------------------------------------------------------------\n", "AI +9.6% +/- 22.8% -3.4% +/- 9.4% -3620.0% +/- 2405.5%\n", "Rustiq -154.5% +/- 273.9% -137.1% +/- 233.2% -527.0% +/- 1405.5%\n" ] } ], "source": [ "print_summary_table(results_large)" ] }, { "cell_type": "code", "execution_count": 26, "id": "per_circuit_large_code", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2Q Depth (first 8 circuits by qubit count); * = best\n", "Idx Circuit Q SABRE AI Rustiq\n", "----------------------------------------------------\n", " 0 all-vib-hc3h2cn 24 2* 2* 2*\n", " 1 ham-graph-gnp_k- 24 345 323* 640\n", " 2 TSP_Ncity-5 25 187 161* 408\n", " 3 tfim 26 100 20* 31\n", " 4 all-vib-h2co 32 30* 38 65\n", " 5 uuf100-ham 40 414 391* 633\n", " 6 uuf100-ham 40 523 463* 795\n", " 7 graph-gnp_k-4 40 3028* 3207 13768\n", "\n", "Gate Count (first 8 circuits by qubit count); * = best\n", "Idx Circuit Q SABRE AI Rustiq\n", "----------------------------------------------------\n", " 0 all-vib-hc3h2cn 24 258 258 257*\n", " 1 ham-graph-gnp_k- 24 4036* 4418 5831\n", " 2 TSP_Ncity-5 25 2045* 2229 3985\n", " 3 tfim 26 489 402* 688\n", " 4 all-vib-h2co 32 570* 661 1058\n", " 5 uuf100-ham 40 4779* 5130 6757\n", " 6 uuf100-ham 40 5667* 6095 8495\n", " 7 graph-gnp_k-4 40 24885* 25641 139793\n", "\n", "Runtime (s) (first 8 circuits by qubit count); * = best\n", "Idx Circuit Q SABRE AI Rustiq\n", "----------------------------------------------------\n", " 0 all-vib-hc3h2cn 24 0.16 0.17 0.16*\n", " 1 ham-graph-gnp_k- 24 0.08* 3.13 0.13\n", " 2 TSP_Ncity-5 25 0.04* 1.47 0.08\n", " 3 tfim 26 0.21 0.34 0.07*\n", " 4 all-vib-h2co 32 0.18* 0.19 2.91\n", " 5 uuf100-ham 40 0.09* 3.27 0.14\n", " 6 uuf100-ham 40 0.11* 4.23 0.17\n", " 7 graph-gnp_k-4 40 0.39* 15.15 2.92\n", "\n" ] } ], "source": [ "print_per_circuit_comparison(results_large, num_rows=8)" ] }, { "cell_type": "code", "execution_count": 27, "id": "c7d8e9f0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_transpilation_comparison(\n", " results_large,\n", " \"Large-Scale Hamiltonian Circuits: Compilation Comparison\",\n", ")" ] }, { "cell_type": "code", "execution_count": 28, "id": "pct_improvement_large", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_pct_improvement_vs_sabre(\n", " results_large,\n", " \"Large-Scale Hamiltonian Circuits\",\n", ")" ] }, { "cell_type": "code", "execution_count": 29, "id": "d7e8f9a0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_best_method_bars(results_large)" ] }, { "cell_type": "code", "execution_count": 30, "id": "f7a8b9c0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test circuit: tfim, 26 qubits\n", "\n", "Transpilation metrics for circuit index 3:\n", " SABRE 2Q depth= 100 size= 489\n", " AI 2Q depth= 20 size= 402\n", " Rustiq 2Q depth= 31 size= 688\n" ] } ], "source": [ "# Select circuit index 3 from the large-scale transpiled circuits\n", "test_idx_large = 3\n", "test_circuit_large = qc_large[test_idx_large]\n", "print(\n", " f\"Test circuit: {test_circuit_large.name}, {test_circuit_large.num_qubits} qubits\"\n", ")\n", "\n", "tqc_methods_large = {\n", " \"SABRE\": tqc_sabre_large[test_idx_large],\n", " \"AI\": tqc_ai_large[test_idx_large],\n", " \"Rustiq\": tqc_rustiq_large[test_idx_large],\n", "}\n", "\n", "print(f\"\\nTranspilation metrics for circuit index {test_idx_large}:\")\n", "for method, tqc in tqc_methods_large.items():\n", " depth_2q = tqc.depth(lambda x: x.operation.num_qubits == 2)\n", " size = tqc.size()\n", " print(f\" {method:8s} 2Q depth={depth_2q:5d} size={size:6d}\")" ] }, { "cell_type": "code", "execution_count": 31, "id": "3cd3afa2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "SABRE transpiled circuit:\n", "OrderedDict({'sx': 211, 'rz': 163, 'cz': 104, 'x': 11})\n", "SABRE mirror circuit count ops:\n", "OrderedDict({'rz': 1170, 'sx': 422, 'cz': 208, 'measure': 156, 'x': 22, 'barrier': 1})\n", "\n", "AI transpiled circuit:\n", "OrderedDict({'sx': 165, 'rz': 162, 'cz': 68, 'x': 7})\n", "AI mirror circuit count ops:\n", "OrderedDict({'rz': 984, 'sx': 330, 'measure': 156, 'cz': 136, 'x': 14, 'barrier': 1})\n", "\n", "Rustiq transpiled circuit:\n", "OrderedDict({'sx': 316, 'rz': 225, 'cz': 140, 'x': 7})\n", "Rustiq mirror circuit count ops:\n", "OrderedDict({'rz': 1714, 'sx': 632, 'cz': 280, 'measure': 156, 'x': 14, 'barrier': 1})\n" ] } ], "source": [ "pm_mirror = generate_preset_pass_manager(\n", " optimization_level=0, backend=backend\n", ")\n", "\n", "for method, tqc in tqc_methods_large.items():\n", " # print the count ops for each circuit\n", " mirror = tqc.copy()\n", " mirror.compose(tqc.inverse(), inplace=True)\n", " mirror.measure_all()\n", " mirror = pm_mirror.run(mirror)\n", " print(f\"\\n{method} transpiled circuit:\")\n", " print(tqc.count_ops())\n", " print(f\"{method} mirror circuit count ops:\")\n", " print(mirror.count_ops())" ] }, { "cell_type": "code", "execution_count": 32, "id": "large_hw_submit", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SABRE: submitted job d8gvgq66983c73dqe5og\n", "AI: submitted job d8gvgqe6983c73dqe5pg\n", "Rustiq: submitted job d8gvgqm6983c73dqe5q0\n" ] } ], "source": [ "# Build mirror circuits and submit to real hardware\n", "# The inverse may introduce gates (e.g., sxdg) not in the backend's\n", "# basis gate set, so we re-transpile the mirror circuit.\n", "pm_mirror = generate_preset_pass_manager(\n", " optimization_level=0, backend=backend\n", ")\n", "\n", "shots_hw = 10000\n", "hw_jobs = {}\n", "\n", "for method, tqc in tqc_methods_large.items():\n", " mirror = tqc.copy()\n", " mirror.compose(tqc.inverse(), inplace=True)\n", " mirror.measure_all()\n", "\n", " # Re-transpile at opt level 0 to decompose into basis gates\n", " # without changing the layout or routing\n", " mirror = pm_mirror.run(mirror)\n", "\n", " sampler = SamplerV2(mode=backend)\n", " sampler.options.environment.job_tags = [\"TUT_CMHSC\"]\n", " job = sampler.run([mirror], shots=shots_hw)\n", " hw_jobs[method] = job\n", " print(f\"{method}: submitted job {job.job_id()}\")" ] }, { "cell_type": "code", "execution_count": 33, "id": "large_hw_results", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SABRE P(|00...0>) = 0.0005 (5/10000)\n", "AI P(|00...0>) = 0.3267 (3267/10000)\n", "Rustiq P(|00...0>) = 0.1845 (1845/10000)\n" ] } ], "source": [ "# Retrieve results and compute fidelities\n", "fidelities_large = {}\n", "\n", "for method, job in hw_jobs.items():\n", " result = job.result()\n", " counts = result[0].data.meas.get_counts()\n", "\n", " n_qubits = backend.num_qubits\n", " all_zeros = \"0\" * n_qubits\n", " fidelity = counts.get(all_zeros, 0) / shots_hw\n", " fidelities_large[method] = fidelity\n", " print(\n", " f\"{method:8s} P(|00...0>) = {fidelity:.4f} \"\n", " f\"({counts.get(all_zeros, 0)}/{shots_hw})\"\n", " )" ] }, { "cell_type": "code", "execution_count": 34, "id": "large_hw_plot", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_mirror_results(\n", " tqc_methods_large, fidelities_large, test_circuit_large.name\n", ")" ] }, { "cell_type": "markdown", "id": "sec-analysis", "metadata": {}, "source": [ "\n", "\n", "## Análisis de los resultados de la recopilación\n", "\n", "Las pruebas de rendimiento anteriores comparan SABRE, el transpilador basado en IA, y Rustiq en circuitos de simulación hamiltonianos de la colección Hamlib, tanto a pequeña como a gran escala.\n", "\n", "\n", "\n", "### Profundidad de dos qubits y número de puertas\n", "\n", "A gran escala, SABRE y el transpilador basado en IA son los dos que obtienen mejores resultados, y cada uno destaca en un indicador diferente. Tal y como muestra el gráfico *de métricas*, que presenta el método con mejor rendimiento, SABRE genera el menor número de puertas en la gran mayoría de los circuitos y es el método más rápido en casi todos ellos, lo que concuerda con una heurística diseñada para minimizar las puertas SWAP insertadas y con las recientes optimizaciones de su diseño y enrutamiento. El transpilador basado en IA genera la menor profundidad de dos qubits en la mayoría de los circuitos, lo que concuerda con la parte de su objetivo de aprendizaje por refuerzo que se centra en la profundidad de los circuitos. La tabla resumen refleja la misma distribución: SABRE presenta el menor número medio de puertas, mientras que el transpilador de IA presenta la menor profundidad media de dos qubits. Ambos métodos son coherentes y fiables en toda la gama de circuitos.\n", "\n", "Rustiq, diseñado específicamente para `PauliEvolutionGate` la síntesis, ofrece el mejor resultado en solo una pequeña parte de los circuitos a gran escala. Sus métricas medias se ven muy sesgadas por un puñado de valores atípicos significativos, visibles como grandes picos en el gráfico comparativo de compilación, en el que Rustiq genera una profundidad y un número de puertas considerablemente superiores a los de los demás métodos. Sin estos valores atípicos, su rendimiento medio estaría mucho más cerca del de SABRE y del transpilador basado en IA.\n", "\n", "La conclusión principal es que ningún método destaca por sí solo en todos los circuitos. Cada método ofrece mejores resultados que los demás en casos concretos, por lo que merece la pena probar todas las herramientas disponibles y seleccionar la que ofrezca el mejor resultado para cada circuito.\n", "\n", "\n", "\n", "### Tiempo de ejecución\n", "\n", "SABRE es, sin lugar a dudas, el método más rápido. Rustiq suele funcionar a una velocidad similar, pero puede dar lugar a casos atípicos en los que la compilación tarda mucho más. Esto se aprecia especialmente en los resultados a gran escala, donde unos pocos circuitos provocan picos en el tiempo de ejecución de Rustiq. Estos valores atípicos influyen considerablemente en el tiempo de ejecución medio, por lo que la mediana podría ser un indicador más representativo para Rustiq. El transpilador basado en IA es el más lento de los tres, y su tiempo de ejecución aumenta notablemente a medida que los circuitos son más grandes y complejos.\n", "\n", "\n", "\n", "### Resultados del circuito de espejos\n", "\n", "Los experimentos con circuitos espejo confirman la tendencia esperada: los métodos que producen una menor profundidad de dos qubits y un menor número de puertas logran una mayor fidelidad en presencia de ruido. Esto es válido tanto para el simulador con ruido (a pequeña escala) como para el hardware real (a gran escala).\n", "\n", "Ten en cuenta que cada gráfico de circuitos espejo refleja un único circuito, no el conjunto. El ejemplo de hardware anterior utiliza un circuito de 26 qubits `tfim` , que resulta ser un caso en el que SABRE produce una profundidad de dos qubits mucho mayor que el transpilador basado en IA y Rustiq, por lo que su fidelidad es, en consecuencia, mucho menor. Esto no es representativo de los resultados generales: en el conjunto completo de circuitos a gran escala, la profundidad de dos qubits de SABRE suele estar cerca de la del transpilador basado en IA, y cada uno de los dos métodos destaca en diferentes métricas (el transpilador basado en IA en profundidad de dos qubits, y SABRE en número de puertas y tiempo de ejecución). Un único resultado de «mirror» evalúa una versión duplicada de un circuito, en lugar de la carga de trabajo completa, por lo que no debe interpretarse como un veredicto sobre la calidad general del método.\n", "\n", "\n", "\n", "### Recomendaciones\n", "\n", "No existe una única estrategia de transpilación que sea la mejor para todos los circuitos. La mejor opción depende de la estructura del circuito, del objetivo de optimización y del tiempo disponible para la compilación:\n", "\n", "* **SABRE** es la opción predeterminada recomendada. Es rápido y fiable, y ofrece excelentes resultados en una amplia variedad de circuitos. Para un ajuste más detallado, los usuarios pueden aumentar el número de pruebas de diseño y enrutamiento (véase el [tutorial de optimización de SABRE](/docs/tutorials/transpilation-optimizations-with-sabre) ).\n", "* Merece la pena probar **el transpilador basado en IA** cuando el tiempo de compilación no supone una limitación, sobre todo cuando la prioridad es minimizar la profundidad de dos qubits: en la mayoría de los circuitos a gran escala de esta prueba comparativa, ha generado la profundidad de dos qubits más baja.\n", "* **Rustiq** está diseñado específicamente para `PauliEvolutionGate` circuitos y es capaz de encontrar soluciones con una profundidad muy reducida y un número reducido de puertas lógicas, sobre todo en circuitos más pequeños. En circuitos más grandes, en ocasiones puede dar lugar a resultados mucho mayores, por lo que es mejor utilizarlo como uno de los varios métodos que se pueden probar, en lugar de como opción predeterminada.\n", "\n", "En la práctica, lo mejor es aplicar todos los métodos disponibles y elegir el mejor resultado para cada circuito. La sobrecarga de compilación que supone probar varios métodos es mínima en comparación con la posible mejora en la calidad de ejecución en hardware real.\n", "\n" ] }, { "cell_type": "markdown", "id": "sec-next-steps", "metadata": {}, "source": [ "\n", "\n", "## Próximos pasos\n", "\n", "Si este tutorial te ha resultado útil, quizá te interesen los siguientes:\n", "\n", "\n", " * [Optimizaciones de transpilación con SABRE](/docs/tutorials/transpilation-optimizations-with-sabre)\n", " * [El transpilador basado en IA supera la prueba](/docs/guides/ai-transpiler-passes)\n", " * [Crear un complemento de transpilador](/docs/guides/create-transpiler-plugin)\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "sec-references", "metadata": {}, "source": [ "\n", "\n", "## Referencias\n", "\n", "\\[1] \"\"LightSABRE: Un algoritmo SABRE ligero y mejorado\". H. Zou, M. Treinish, K. Hartman, A. Ivrii, J. Lishman et al. [https://arxiv.org/abs/2409.08368](https://arxiv.org/abs/2409.08368)\n", "\n", "\\[2] \"Síntesis y transpilación prácticas y eficientes de circuitos cuánticos con aprendizaje por refuerzo\". D. Kremer, V. Villar, H. Paik, I. Duran, I. Faro, J. Cruz-Benito et al. [https://arxiv.org/abs/2405.13196](https://arxiv.org/abs/2405.13196)\n", "\n", "\\[3] «Síntesis de circuitos de redes de Pauli mediante aprendizaje por refuerzo». A Dubal, D. Kremer, S. Martiel, V. Villar, D. Wang, J. Cruz-Benito y otros. [https://arxiv.org/abs/2503.14448](https://arxiv.org/abs/2503.14448)\n", "\n", "\\[4] «Síntesis más rápida y breve de circuitos de simulación hamiltonianos». T. Goubault de Brugiere, S. Martiel y otros [ https://arxiv.org/abs/2404.03280](https://arxiv.org/abs/2404.03280)\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": 1, "qpuSeconds": 60 }, "nbformat": 4, "nbformat_minor": 5 }