{
"cells": [
{
"cell_type": "markdown",
"id": "e6e50bd6-8ac4-40b1-ac0f-6e22b6af1377",
"metadata": {},
"source": [
"---\n",
"title: \"Simular un modelo de Ising con la función TEM\"\n",
"description: \"Introducción a TEM, una función Qiskit de Algorithmiq, para calcular estimaciones con mitigación de errores de posprocesamiento de software utilizando redes tensoriales.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Simular un modelo de Ising con la función TEM\n",
"\n",
"{/* cspell:ignore Floquet, linestyles */}\n",
"\n",
"El método de mitigación de errores de red tensorial (TEM) de Algorithmiq es un algoritmo híbrido cuántico-clásico diseñado para realizar la mitigación del ruido íntegramente en la etapa de posprocesamiento clásico. Con TEM, el usuario puede calcular los valores esperados de los observables, mitigando los inevitables errores inducidos por el ruido que se producen en el hardware cuántico con mayor precisión y rentabilidad, lo que lo convierte en una opción muy atractiva tanto para los investigadores cuánticos como para los profesionales del sector.\n",
"\n",
"Este tutorial muestra cómo TEM puede obtener resultados significativos para la dinámica de un sistema cuántico, lo cual sería inaccesible sin la mitigación de errores y requeriría muchos más recursos cuánticos si se utilizaran otros métodos de mitigación de errores, como PEC y ZNE.\n",
"\n",
"*Estimación de uso: este cuaderno utiliza aproximadamente 10 minutos de QPU en dispositivos Heron r3. El tiempo de ejecución puede depender en gran medida del dispositivo elegido. A continuación se pueden encontrar estimaciones de uso por sección.*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "1f5e328d-fe93-4ee2-995b-2e70b36ea0de",
"metadata": {},
"source": [
"\n",
"\n",
"## Realice experimentos de física de muchos cuerpos con mitigación de errores con la función TEM\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b63a662c-a4e9-4b5f-92fd-46352a2bd0bd",
"metadata": {},
"source": [
"Este tutorial se basa en la siguiente referencia: [L. E. Fischer et al., Nat. Fís. (2026)](https://www.nature.com/articles/s41567-025-03144-9). Esta referencia analiza una simulación real en hardware cuántico de hasta 91 qubits. En este tutorial, recreamos una simulación similar en un circuito de menor tamaño.\n",
"\n",
"El modelo de Ising modificado corresponde al modelo de Ising habitual:\n",
"\n",
"$\\hat{H}_{\\text{I}} = J \\sum_{n=0}^{N-2} \\hat{Z}_n \\hat{Z}_{n+1} + h \\sum_{n=0}^{N-1} \\hat{Z}_n$\n",
"\n",
"al que se le aplica una patada transversal:\n",
"\n",
"$\\hat{H}_{K} = b \\sum_{n=0}^{N-1} \\hat{X}_n$\n",
"\n",
"El objetivo es simular la dinámica de un estado bajo el hamiltoniano de Ising transversal, cuya evolución temporal puede implementarse mediante un operador unitario de Floquet $\\hat{U}_{\\text{KI}} = e^{-i \\hat{H}_K} e^{-i \\hat{H}_I} $. El estado inicial que se va a desarrollar es aquel en el que el primer qubit se encuentra en el estado $|+\\rangle$, mientras que los demás se emparejan y se establecen en el estado de Bell $(|00\\rangle + |11\\rangle)/\\sqrt{2}$.\n",
"\n",
"La cantidad que queremos observar es la función de correlación. [El artículo de](https://www.nature.com/articles/s41567-025-03144-9) referencia analiza cómo esta cantidad puede reescribirse como un operador de Pauli e $\\hat{X}$ e en el qubit e $n^{th}$.\n",
"Tras una serie de pasos de tiempo físicos $t$, calculamos el valor del operador de Pauli $\\hat{X}_{n=t}$.\n",
"Dependiendo de los parámetros del sistema, el valor de esta observable es igual a un valor que puede calcularse con exactitud o solo simularse mediante métodos aproximados. Concretamente, para $|J|=|b|=\\pi/4$ es igual a $[\\cos(2h)]^t$, que es el valor que utilizaremos para comparar los resultados de este tutorial. Además, en un intervalo de tiempo dado $t$, $\\langle\\hat{X}_{n\\neq t}\\rangle$ es cero. Para obtener más detalles sobre cómo obtener estos valores y para compararlos con los resultados aproximados de la simulación clásica fuera de estos parámetros, véase [L. E. Fischer et al., Nat. Fís. (2026)](https://www.nature.com/articles/s41567-025-03144-9).\n",
"\n",
"TEM funciona caracterizando primero el ruido para cada capa única de puertas de dos qubits en el circuito, así como caracterizando el error de lectura. A continuación, el circuito se ejecuta en la máquina cuántica. Por último, la mitigación del error de la red tensorial se realiza en los recursos clásicos de IBM Cloud® y se devuelve el valor mitigado. En este ejemplo, el circuito tiene dos capas únicas que caracterizar.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "4b30f191-9759-49de-ba8f-7cc616b61ec6",
"metadata": {},
"source": [
"\n",
"\n",
"## Configuración\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9cf6d15e-324b-474a-886c-c3dca5a24141",
"metadata": {},
"source": [
"Como requisito previo, asegúrese de que las dependencias necesarias estén instaladas.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1eeec332-29ca-4882-8129-d1c93ed82b2b",
"metadata": {},
"outputs": [],
"source": [
"%pip install numpy matplotlib qiskit qiskit-ibm-catalog qiskit-ibm-runtime pylatexenc qiskit_qasm3_import"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "ad0002b7-dbff-4699-af52-ba0df72ed200",
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"from matplotlib import pyplot as plt\n",
"import numpy as np\n",
"\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"from qiskit.qasm3 import load\n",
"\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog"
]
},
{
"cell_type": "markdown",
"id": "b95b9e75-37fe-4f86-a923-0a833c7960f8",
"metadata": {},
"source": [
"\n",
"\n",
"## Mitigación de errores con TEM\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "651a3f04-c8ba-4a39-8415-52d7e313ba2a",
"metadata": {},
"source": [
"Aquí proporcionamos un circuito que implementa el modelo de Ising con efecto de retroceso descrito anteriormente. El circuito se prepara de la siguiente manera. En primer lugar, hay una fase de preparación del estado, en la que el primer qubit se encuentra en el estado $|+\\rangle$, mientras que los demás se encuentran en pares de Bell $(|00\\rangle + |11\\rangle)/\\sqrt{2}$. A continuación, se aplica la estructura de ladrillo que implementa la evolución unitaria $\\hat{U}_{\\text{KI}}$. El número de pasos de tiempo físicos corresponde a $t/2$ capas del circuito.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "11e42656-76ba-452c-af22-8f4cd22ff174",
"metadata": {},
"source": [
"El siguiente código descarga los dos archivos QASM necesarios para este tutorial.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "39bf7188-3771-4994-a6c6-e9cfcae3484f",
"metadata": {},
"outputs": [],
"source": [
"# Download required QASM files\n",
"import urllib\n",
"\n",
"urllib.request.urlretrieve(\n",
" \"https://ibm.box.com/shared/static/swy5jtq309b0xpzluzlmsmj908yphes8.qasm\",\n",
" \"ki_30q.qasm\",\n",
")\n",
"urllib.request.urlretrieve(\n",
" \"https://ibm.box.com/shared/static/et3gkodonw6gsp2trs43lzaozrdtiu7s.qasm\",\n",
" \"ki_12q.qasm\",\n",
")"
]
},
{
"cell_type": "markdown",
"id": "1f6f9970-63fb-40f4-9586-261cba23cb88",
"metadata": {},
"source": [
"Podemos visualizar una versión reducida del circuito, con 12 qubits y seis pasos temporales:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "381a4e25-bc9c-47d0-b9f1-172eb5516484",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Parameters of the kicked Ising model\n",
"h = 0.0\n",
"num_qubits = 12\n",
"t_steps = 6\n",
"\n",
"# Load the circuit for the kicked Ising model\n",
"small_circuit = load(\"ki_12q.qasm\")\n",
"\n",
"# Draw the circuit\n",
"small_circuit.draw(\"mpl\", scale=0.25, fold=-1)"
]
},
{
"cell_type": "markdown",
"id": "a674e407-504d-4812-82bf-98e91ec9a4b4",
"metadata": {},
"source": [
"A continuación, construya el observable, $\\hat{X}_{n=t}$. Se construye como una cadena de Pauli simple con el orden que coincide con el utilizado por Qiskit:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "a9a87f6c-176d-4c85-85e5-6751aea0c90b",
"metadata": {},
"outputs": [],
"source": [
"def xt_observable(n_qubits, t_steps):\n",
" pauli_str = \"\".join([\"I\" * t_steps, \"X\", \"I\" * (n_qubits - t_steps - 1)])\n",
" pauli_str = pauli_str[::-1] # Reverse the string to match qiskit order\n",
" return SparsePauliOp(data=pauli_str, coeffs=1.0)"
]
},
{
"cell_type": "markdown",
"id": "ba5f7042-4abd-4ae7-a091-591678377e8f",
"metadata": {},
"source": [
"En nuestro pequeño ejemplo de 12 qubits, el observable tiene este aspecto:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "b2608df1-b4e4-4143-bea5-a65ab8045fd4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"SparsePauliOp(['IIIIIXIIIIII'],\n",
" coeffs=[1.+0.j])\n"
]
}
],
"source": [
"# Build the observable for the kicked Ising model\n",
"small_observable = xt_observable(n_qubits=12, t_steps=6)\n",
"print(small_observable)"
]
},
{
"cell_type": "markdown",
"id": "e588fafe-8db8-4445-8893-a78190b27b64",
"metadata": {},
"source": [
"Qiskit Functions utilizar los PUB como medio para recopilar las aportaciones. En nuestro caso, consideremos un único circuito y un observador como nuestro PUB :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fc48eb54-148b-4b0d-8424-a135cb92039e",
"metadata": {},
"outputs": [],
"source": [
"# Collect the input PUBs, in this case composed of a\n",
"# single circuit and observable\n",
"pubs = [(small_circuit, [small_observable])]"
]
},
{
"cell_type": "markdown",
"id": "9a4bcd8d-ae21-40ab-b0e2-510236ba92de",
"metadata": {},
"source": [
"A continuación, accedemos a la función TEM. Primero configuramos la autenticación necesaria en IBM Cloud y seleccionamos un backend de entre los dispositivos disponibles. El token, los backends disponibles y los nombres de recursos en la nube (CRN) correspondientes se pueden obtener iniciando sesión en su cuenta en el [panel de control](/) de IBM Quantum Platform.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "6c9f80a8-4a65-4daa-94bb-a98edd6a1989",
"metadata": {},
"outputs": [],
"source": [
"# Set IBM Quantum credentials and backend configuration\n",
"personal_token = os.environ.get(\n",
" \"QISKIT_IBM_TOKEN\", \"\"\n",
") # Replace with your personal token or set the environment variable\n",
"channel = \"ibm_quantum_platform\"\n",
"crn = \"your_crn\" # Replace with the Cloud Resource Name (CRN)\n",
"\n",
"# Select the QPU backend\n",
"backend_name = \"ibm_qpu_name\" # Replace with your desired backend's name"
]
},
{
"cell_type": "markdown",
"id": "10df1803-5245-42b2-8eea-c0773cd655b6",
"metadata": {},
"source": [
"Cargue la función TEM desde [Qiskit Functions Catalog](/functions) :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "2473b284-108f-45fe-a8d8-3aed584137f6",
"metadata": {},
"outputs": [],
"source": [
"# Load the TEM function from the Qiskit Functions Catalog\n",
"catalog = QiskitFunctionsCatalog(\n",
" channel=channel,\n",
" token=personal_token,\n",
" instance=crn,\n",
")\n",
"tem = catalog.load(\"algorithmiq/tem\")"
]
},
{
"cell_type": "markdown",
"id": "3c732819-4dca-421c-bc2b-45ff5a5912db",
"metadata": {},
"source": [
"Ahora podemos realizar un experimento en el circuito Ising activado con la mitigación de errores proporcionada por TEM. Con la configuración predeterminada, TEM se puede ejecutar de forma sencilla con un tiempo de ejecución de QPU previsto de entre 2.5 minutos, dependiendo de la QPU:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "b826e025-f36b-4fb5-90bd-e1ef36f5c1b2",
"metadata": {},
"outputs": [],
"source": [
"tem_job = tem.run(pubs=pubs, backend_name=backend_name)"
]
},
{
"cell_type": "markdown",
"id": "4b692a80-5a10-4131-9d7f-785fedbe4221",
"metadata": {},
"source": [
"Con las opciones predeterminadas, la función TEM ejecuta tres tareas en el ordenador cuántico: aprendizaje del ruido, mitigación de la lectura y muestreo del circuito. El número de disparos utilizados por cada uno de ellos se puede cambiar en las opciones pasadas a la función. Por defecto, estos parámetros se establecen para lograr una precisión de 0.05 en los valores esperados mitigados.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "25b6f313-a928-493e-837f-45e6e7836aef",
"metadata": {},
"source": [
"Puede comprobar el estado de su trabajo en el [panel de control](/) de IBM Quantum Platform o con:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "05e202ff-5b86-4a93-a693-86fbb1cf3e02",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QUEUED\n"
]
}
],
"source": [
"print(tem_job.status())"
]
},
{
"cell_type": "markdown",
"id": "8e427c75-72fb-4a97-b723-97d695a692d3",
"metadata": {},
"source": [
"Cuando el estado es `DONE`, podemos comprobar los resultados sin procesar y mitigados. Los `tem_evs` definidos a continuación son los valores esperados de los observables solicitados, en este caso solo un observable, $\\langle \\hat X_{n=t}\\rangle$, y `tem_std` son las desviaciones estándar correspondientes.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "3ca34069-1363-4e37-9718-91639d817a82",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TEM Result: 1.031 ± 0.046\n"
]
}
],
"source": [
"# Get the results of the TEM job\n",
"tem_results = tem_job.result()[\n",
" 0\n",
"] # Get the first and only result from the job\n",
"tem_evs = tem_results.data.evs[0]\n",
"tem_std = tem_results.data.stds[0]\n",
"\n",
"print(f\"TEM Result: {tem_evs:.3f} ± {tem_std:.3f}\")"
]
},
{
"cell_type": "markdown",
"id": "f90f503e-ab80-4550-a7cf-dfeea12babb0",
"metadata": {},
"source": [
"También podemos comprobar cuánto tiempo de ejecución cuántico se utilizó para cada llamada en [IBM Quantum Platform](), o inspeccionando los metadatos del resultado del código Python.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "b05818d6-b680-483e-9084-f3fd2de067ab",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TEM Runtime: 155.0 seconds\n"
]
}
],
"source": [
"# Get the TEM job runtime\n",
"tem_runtime = tem_job.result().metadata[\"resource_usage\"][\n",
" \"RUNNING: EXECUTING_QPU\"\n",
"][\"QPU_TIME\"]\n",
"\n",
"print(f\"TEM Runtime: {tem_runtime} seconds\")"
]
},
{
"cell_type": "markdown",
"id": "6be333a8-41c9-4ba9-b07d-a0ac50149add",
"metadata": {},
"source": [
"\n",
"\n",
"## Personalizar los parámetros TEM y las opciones avanzadas\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "abee6fc2-90d6-4608-ad21-c606c936dd94",
"metadata": {},
"source": [
"La función TEM ofrece varias opciones avanzadas para personalizar el flujo de trabajo de mitigación de errores. Estas opciones le permiten controlar la precisión, el número de disparos, las estrategias de aprendizaje del ruido y otros parámetros para adaptarse mejor a los requisitos de su experimento y a los recursos cuánticos disponibles.\n",
"\n",
"Las opciones avanzadas comunes son:\n",
"\n",
"* **`precision`**: Especifique la precisión objetivo para los valores esperados mitigados.\n",
"* **`default_shots`**: En lugar de `precision`, puede especificar el número de disparos utilizados por el trabajo de medición.\n",
"* **`tem_max_bond_dimension`**: La dimensión máxima del enlace utilizada en la red tensorial.\n",
"* **`tem_compression_cutoff`**: El valor de corte que se utilizará para la red tensorial.\n",
"* **Opciones de aprendizaje del ruido** : Configure cómo se caracteriza el ruido, como el número de repeticiones o circuitos de calibración específicos.\n",
"* \\*\\*`private`\\*\\*Asegúrese de que los circuitos y los resultados de los experimentos sean privados y desactive las descargas múltiples de los resultados de los trabajos.\n",
"\n",
"Consulte la [documentación](/docs/guides/algorithmiq-tem) de TEM o el sitio web [Qiskit Functions Catalog](/functions) para obtener una lista completa de las opciones compatibles y sus descripciones. Puede ajustar estos parámetros para equilibrar el tiempo de ejecución, el uso de recursos y la precisión de los resultados.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "24db681c-b306-41e0-8507-626ef279b076",
"metadata": {},
"source": [
"Puede pasar estas opciones como un diccionario al `options` argumento al ejecutar la función TEM:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a2e9a032-91cb-4a18-9a00-00a149e60459",
"metadata": {},
"outputs": [],
"source": [
"options = {\n",
" \"default_shots\": 10_000,\n",
" \"tem_max_bond_dimension\": 512,\n",
" \"tem_compression_cutoff\": 1e-16,\n",
" # This option helps optimizing the measurement\n",
" # stage since the observable is strongly biased\n",
" # toward the X operator for all the qubits.\n",
" \"compute_shadows_bias_from_observable\": True,\n",
" # set to True to keep experiment results private,\n",
" # recommended for confidential circuits\n",
" \"private\": False,\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "db700868-4dae-48c8-be1a-668ef2e63177",
"metadata": {},
"source": [
"También se pueden pasar opciones personalizadas para el aprendedor de ruido. Siguen las definiciones utilizadas en el Diccionario de terminología de la UE ( Qiskit Runtime ) [`NoiseLearnerOptions`](/docs/api/qiskit-ibm-runtime/options-noise-learner-options):\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "30591014-3bc6-4548-ba0d-dc5cc22e9dcc",
"metadata": {},
"outputs": [],
"source": [
"nl_options = {\n",
" \"num_randomizations\": 32,\n",
" \"max_layers_to_learn\": 2,\n",
" \"shots_per_randomization\": 128,\n",
" \"layer_pair_depths\": [0, 1, 2, 4, 16, 32],\n",
"}\n",
"\n",
"# add noise learning options to the overall options\n",
"options |= nl_options"
]
},
{
"cell_type": "markdown",
"id": "216ad12c-8c70-4073-8515-b07fd57f74d4",
"metadata": {},
"source": [
"Vuelva a realizar el experimento con estas opciones personalizadas ajustadas a nuestro circuito. El tiempo de ejecución previsto es de aproximadamente cuatro minutos QPU.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "ebce8e14-433f-4858-96c6-9d90ff0353af",
"metadata": {},
"outputs": [],
"source": [
"tem_job_custom = tem.run(\n",
" pubs=pubs, backend_name=backend_name, options=options\n",
")"
]
},
{
"cell_type": "markdown",
"id": "bd8d2c12-c9da-4ac3-97c0-d53be1455091",
"metadata": {},
"source": [
"Si el trabajo no está configurado como privado, podemos recuperar el resultado más adelante. Para ello, guarde el ID del trabajo que aparece aquí y utilice `tem_job_custom = catalog.get_job_by_id(\"your-job-id\")`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "0f99101b-9e72-45c8-8b00-9f3a257b8b3b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job ID: 1ba10094-a541-457a-9287-dbd49306d12d\n"
]
}
],
"source": [
"job_id = tem_job_custom.job_id\n",
"print(f\"Job ID: {job_id}\")"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "0c751dac-e856-4371-aaed-f67aca31061f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TEM Result: 0.956 ± 0.018\n"
]
}
],
"source": [
"results_custom = tem_job_custom.result()\n",
"tem_evs = results_custom[0].data.evs[0]\n",
"tem_std = results_custom[0].data.stds[0]\n",
"\n",
"print(f\"TEM Result: {tem_evs:.3f} ± {tem_std:.3f}\")"
]
},
{
"cell_type": "markdown",
"id": "edfef6f9-6bac-42bb-8bd2-95f977f7b31b",
"metadata": {},
"source": [
"Ahora podemos inspeccionar los resultados y los metadatos para obtener información sobre el experimento:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "dd189b2d-860b-4b9a-88c2-7e5c62b1f160",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Unmitigated Result: 0.894 ± 0.015\n",
"Exact Result: 1.0\n"
]
}
],
"source": [
"metadata_custom = results_custom[0].metadata\n",
"\n",
"unmitigated_evs = metadata_custom[\"evs_non_mitigated\"][0]\n",
"unmitigated_stds = metadata_custom[\"stds_non_mitigated\"][0]\n",
"print(f\"Unmitigated Result: {unmitigated_evs:.3f} ± {unmitigated_stds:.3f}\")\n",
"\n",
"# Exact result for the kicked Ising model from the reference paper\n",
"exact_evs = np.cos(2 * h) ** t_steps\n",
"print(\"Exact Result:\", exact_evs)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "c3a2168d-98df-491e-a1f8-05de5684ab96",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Plot comparing the different expectation values\n",
"plt.bar(\n",
" [\"Unmitigated\", \"TEM\"],\n",
" [unmitigated_evs, tem_evs],\n",
" yerr=[unmitigated_stds, tem_std],\n",
" color=[\"grey\", \"c\"],\n",
")\n",
"plt.hlines(y=exact_evs, xmin=-0.5, xmax=1.5, colors=\"r\", linestyles=\"dashed\")\n",
"plt.ylabel(\"Expectation Value\")\n",
"plt.ylim(0, 1.1)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "d643bdb4-22e0-4f55-b3a8-d5ef39f6e696",
"metadata": {},
"source": [
"Por último, podemos comprobar el impacto de las opciones personalizadas en el tiempo de ejecución de la QPU y el tiempo de ejecución clásico:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "09cf2226-c48c-483b-aa49-80186229ae95",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QPU Runtime: 342.0 seconds\n",
"Classical Runtime: 107.632604 seconds\n"
]
}
],
"source": [
"# Get the metadata of the TEM job\n",
"job_metadata = results_custom.metadata\n",
"\n",
"# Get the runtime of the TEM job\n",
"qpu_runtime = job_metadata[\"resource_usage\"][\"RUNNING: EXECUTING_QPU\"][\n",
" \"QPU_TIME\"\n",
"]\n",
"classical_runtime = (\n",
" job_metadata[\"resource_usage\"][\"RUNNING: OPTIMIZING_FOR_HARDWARE\"][\n",
" \"CPU_TIME\"\n",
" ]\n",
" + job_metadata[\"resource_usage\"][\"RUNNING: POST_PROCESSING\"][\"CPU_TIME\"]\n",
")\n",
"\n",
"print(f\"QPU Runtime: {qpu_runtime} seconds\")\n",
"print(f\"Classical Runtime: {classical_runtime} seconds\")"
]
},
{
"cell_type": "markdown",
"id": "7cea6cf1-5530-4bf6-83da-ad2e9ff96806",
"metadata": {},
"source": [
"\n",
"\n",
"## Escalar TEM a circuitos grandes\n",
"\n",
"En principio, los circuitos grandes pueden ejecutarse con la función TEM. Sin embargo, es importante ser consciente de las limitaciones de los recursos clásicos, ya que TEM se ejecuta en ejecutores de IBM Cloud, con tiempos de ejecución potencialmente muy largos. Para circuitos extremadamente grandes, póngase en contacto con el equipo de asistencia de TEM en [qiskit\\ \\_ibm@algorithmiq.fi](mailto:qiskit_ibm@algorithmiq.fi).\n",
"\n",
"Aquí ejecutamos un ejemplo con un circuito más grande, del tamaño de una planta de servicios públicos, de 30 qubits, optimizando los parámetros TEM para la velocidad en lugar de la precisión.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f7ea1d3c-d745-48cc-8922-b070b2b5fd44",
"metadata": {},
"outputs": [],
"source": [
"# Kicked Ising model parameters\n",
"n_qubits = 30\n",
"t_steps = 15\n",
"h = 0.0\n",
"\n",
"# Load the circuit for the kicked Ising model\n",
"circuit = load(\"ki_30q.qasm\")\n",
"\n",
"\n",
"# Build the observable for the kicked Ising model\n",
"observable = xt_observable(n_qubits=n_qubits, t_steps=t_steps)\n",
"\n",
"# Collect the input PUBs, in this case composed of a\n",
"# single circuit and observable\n",
"pubs = [(circuit, [observable])]"
]
},
{
"cell_type": "markdown",
"id": "854c3208-8c0f-4f7d-b260-0abba2bc71a0",
"metadata": {},
"source": [
"Definamos algunas opciones orientadas al rendimiento:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"id": "64882a71-3027-4e25-b714-9e9d6b13cd49",
"metadata": {},
"outputs": [],
"source": [
"options = {\n",
" \"num_randomizations\": 32,\n",
" \"max_layers_to_learn\": 2,\n",
" \"shots_per_randomization\": 128,\n",
" \"layer_pair_depths\": [0, 1, 2, 4, 16, 32, 64],\n",
" \"default_shots\": 5_000,\n",
" \"tem_max_bond_dimension\": 128,\n",
" \"tem_compression_cutoff\": 1e-10,\n",
" \"compute_shadows_bias_from_observable\": True,\n",
" \"private\": False,\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "4ba36257-1974-4274-b04c-6daf3afe9d72",
"metadata": {},
"source": [
"Por último, realice el experimento, obtenga el resultado y visualícelo. Esto llevará aproximadamente 3.5 minutos de QPU.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"id": "6faf7f80-dec9-49d2-80e7-d4e6fdea5100",
"metadata": {},
"outputs": [],
"source": [
"tem_job_large = tem.run(pubs=pubs, backend_name=backend_name, options=options)"
]
},
{
"cell_type": "code",
"execution_count": 51,
"id": "333b2335-b480-4bf9-854c-5155eedee900",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job ID: 9f3f190f-f4b0-4dcb-bb83-5f71f37d0d77\n"
]
}
],
"source": [
"job_id = tem_job_large.job_id\n",
"print(f\"Job ID: {job_id}\")"
]
},
{
"cell_type": "code",
"execution_count": 53,
"id": "a04dd421-a212-473c-a8a9-4c8edcfc3667",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TEM Result: 0.794 ± 0.026\n",
"QPU Runtime: 203.0 seconds\n",
"Classical Runtime: 251.71805499999996 seconds\n"
]
}
],
"source": [
"results_large = tem_job_large.result()\n",
"tem_evs = results_large[0].data.evs[0]\n",
"tem_std = results_large[0].data.stds[0]\n",
"\n",
"print(f\"TEM Result: {tem_evs:.3f} ± {tem_std:.3f}\")\n",
"\n",
"\n",
"# Get the metadata of the TEM job\n",
"job_metadata = tem_job_large.result().metadata\n",
"\n",
"# Get the runtime of the TEM job\n",
"qpu_runtime = job_metadata[\"resource_usage\"][\"RUNNING: EXECUTING_QPU\"][\n",
" \"QPU_TIME\"\n",
"]\n",
"classical_runtime = (\n",
" job_metadata[\"resource_usage\"][\"RUNNING: OPTIMIZING_FOR_HARDWARE\"][\n",
" \"CPU_TIME\"\n",
" ]\n",
" + job_metadata[\"resource_usage\"][\"RUNNING: POST_PROCESSING\"][\"CPU_TIME\"]\n",
")\n",
"\n",
"print(f\"QPU Runtime: {qpu_runtime} seconds\")\n",
"print(f\"Classical Runtime: {classical_runtime} seconds\")"
]
},
{
"cell_type": "code",
"execution_count": 54,
"id": "24894c44-e399-4b9d-a3ff-38a28ff32ece",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Plot comparing the different expectation values\n",
"metadata_large = results_large[0].metadata\n",
"unmitigated_evs = metadata_large[\"evs_non_mitigated\"][0]\n",
"unmitigated_stds = metadata_large[\"stds_non_mitigated\"][0]\n",
"\n",
"exact_evs = np.cos(2 * h) ** t_steps\n",
"\n",
"plt.bar(\n",
" [\"Unmitigated\", \"TEM\"],\n",
" [unmitigated_evs, tem_evs],\n",
" yerr=[unmitigated_stds, tem_std],\n",
" color=[\"grey\", \"c\"],\n",
")\n",
"plt.hlines(y=exact_evs, xmin=-0.5, xmax=1.5, colors=\"r\", linestyles=\"dashed\")\n",
"plt.ylabel(\"Expectation Value\")\n",
"plt.ylim(0, 1.1)\n",
"plt.show()"
]
},
{
"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.5,
"qpuSeconds": 600
},
"nbformat": 4,
"nbformat_minor": 4
}