{
"cells": [
{
"cell_type": "markdown",
"id": "b3e994de-6477-421d-8a9a-6b20d45260ae",
"metadata": {},
"source": [
"---\n",
"title: \"Crear una plantilla de función Qiskit para la simulación hamiltoniana\"\n",
"description: \"Cómo crear un programa de transpilación paralelo e implementarlo en IBM Quantum Platform para utilizarlo como un servicio remoto reutilizable.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Crear una plantilla de función Qiskit para la simulación hamiltoniana\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "31aee42c-1834-4fae-a05f-f78d8e5db7c0",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"id": "b51e81bf-0bbf-4f64-af1e-87fcb443d997",
"metadata": {},
"source": [
"Esta plantilla encapsula un flujo de trabajo para simular la evolución temporal de un estado inicial frente a un hamiltoniano basado en espín definido por el usuario y devuelve un conjunto de valores esperados especificados utilizando el complemento [AQC-Tensor](https://qiskit.github.io/qiskit-addon-aqc-tensor/) Qiskit.\n",
"\n",
"Esta plantilla está estructurada como un patrón Qiskit con los siguientes pasos:\n",
"\n",
"\n",
"\n",
"#### 1. Recopilar información y analizar el problema\n",
"\n",
"Esta sección toma como entrada el Hamiltoniano a simular, un estado inicial en forma de `QuantumCircuit`, un conjunto de observables para estimar valores de expectativa, y una especificación de opciones para el addon AQC. Este paso valida que todos los datos de entrada requeridos están presentes y que están en el formato correcto.\n",
"\n",
"A continuación, los argumentos de entrada se utilizan para construir los circuitos cuánticos y operadores pertinentes para el flujo de trabajo. Se crea un circuito de destino y se encuentra una representación de estado de producto matricial de este circuito utilizando el complemento AQC. A continuación, se genera un circuito ansatz y se optimiza utilizando métodos de redes tensoriales, produciendo un circuito final que ejecuta el resto de la evolución temporal.\n",
"\n",
"\n",
"\n",
"#### 2. Preparar los circuitos generados para su ejecución\n",
"\n",
"Los circuitos generados a partir del addon AQC se transpilan para ejecutarse en el backend elegido. Se crea una instancia de [`EstimatorV2`](../api/qiskit-ibm-runtime/estimator-v2) instancia se crea con un conjunto predeterminado de opciones de mitigación de errores para gestionar la ejecución del circuito.\n",
"\n",
"\n",
"\n",
"#### 3. Ejecución\n",
"\n",
"Por último, el circuito ansatz se transpila y ejecuta en una QPU y recopila estimaciones para todos los valores de expectativa especificados, que se devuelven en un formato serializable para que el usuario pueda acceder a ellas.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e451f954-1d8f-4687-a7e9-e4b0dfa170f3",
"metadata": {},
"source": [
"\n",
"\n",
"## Escribir la plantilla de función\n",
"\n",
"En primer lugar, escriba una plantilla de función para la simulación hamiltoniana que utilice el [complemento AQC-Tensor Qiskit](https://qiskit.github.io/qiskit-addon-aqc-tensor/) para asignar la descripción del problema a un circuito de profundidad reducida para su ejecución en hardware.\n",
"\n",
"Si descargas esta página y la abres en un editor de código, verás que algunas de las celdas de código contienen el [comando mágico ](https://ipython.readthedocs.io/en/stable/interactive/magics.html#cellmagic-writefile)`%%writefile`. Este comando mágico guarda el código en `./source_files/template_hamiltonian_simulation.py`, que es la plantilla de función que puedes subir a y ejecutar de forma remota con Qiskit Serverless.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "115c14aa-5028-46f9-ab19-b49d47519636",
"metadata": {},
"source": [
"\n",
"\n",
"### Recopilar y validar las entradas\n",
"\n",
"Empiece por obtener las entradas para la plantilla. Este ejemplo tiene entradas específicas de dominio relevantes para la simulación hamiltoniana (como el hamiltoniano y el observable) y opciones específicas de capacidad (como cuánto desea comprimir las capas iniciales del circuito Trotter utilizando AQC-Tensor, u opciones avanzadas para ajustar con precisión la supresión y mitigación de errores más allá de los valores predeterminados que forman parte de este ejemplo).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5e1e974b-feaa-47ce-abd1-65d442e8176e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Writing ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"from qiskit import QuantumCircuit\n",
"from qiskit_serverless import get_arguments, save_result\n",
"\n",
"\n",
"# Extract parameters from arguments\n",
"#\n",
"# Do this at the top of the program so it fails early if any required arguments\n",
"# are missing or invalid.\n",
"\n",
"arguments = get_arguments()\n",
"\n",
"dry_run = arguments.get(\"dry_run\", False)\n",
"backend_name = arguments[\"backend_name\"]\n",
"\n",
"aqc_evolution_time = arguments[\"aqc_evolution_time\"]\n",
"aqc_ansatz_num_trotter_steps = arguments[\"aqc_ansatz_num_trotter_steps\"]\n",
"aqc_target_num_trotter_steps = arguments[\"aqc_target_num_trotter_steps\"]\n",
"\n",
"remainder_evolution_time = arguments[\"remainder_evolution_time\"]\n",
"remainder_num_trotter_steps = arguments[\"remainder_num_trotter_steps\"]\n",
"\n",
"# Stop if this fidelity is achieved\n",
"aqc_stopping_fidelity = arguments.get(\"aqc_stopping_fidelity\", 1.0)\n",
"# Stop after this number of iterations, even if stopping fidelity is not achieved\n",
"aqc_max_iterations = arguments.get(\"aqc_max_iterations\", 500)\n",
"\n",
"hamiltonian = arguments[\"hamiltonian\"]\n",
"observable = arguments[\"observable\"]\n",
"initial_state = arguments.get(\"initial_state\",\n",
" QuantumCircuit(hamiltonian.num_qubits))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3f2629d5-5183-432a-8802-115a3b2f6ff7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"import numpy as np\n",
"import json\n",
"from mergedeep import merge\n",
"\n",
"\n",
"# Configure `EstimatorOptions`, to control the parameters\n",
"# of the hardware experiment\n",
"#\n",
"# Set default options\n",
"estimator_default_options = {\n",
" \"resilience\": {\n",
" \"measure_mitigation\": True,\n",
" \"zne_mitigation\": True,\n",
" \"zne\": {\n",
" \"amplifier\": \"gate_folding\",\n",
" \"noise_factors\": [1, 2, 3],\n",
" \"extrapolated_noise_factors\": list(np.linspace(0, 3, 31)),\n",
" \"extrapolator\": [\"exponential\", \"linear\", \"fallback\"],\n",
" },\n",
" \"measure_noise_learning\": {\n",
" \"num_randomizations\": 512,\n",
" \"shots_per_randomization\": 512,\n",
" },\n",
" },\n",
" \"twirling\": {\n",
" \"enable_gates\": True,\n",
" \"enable_measure\": True,\n",
" \"num_randomizations\": 300,\n",
" \"shots_per_randomization\": 100,\n",
" \"strategy\": \"active\",\n",
" },\n",
"}\n",
"# Merge with user-provided options\n",
"estimator_options = merge(\n",
" arguments.get(\"estimator_options\", {}), estimator_default_options\n",
")"
]
},
{
"cell_type": "markdown",
"id": "ac4e21bf-ccec-459e-984b-dc6a13ea56c8",
"metadata": {},
"source": [
"Cuando la plantilla de funciones se está ejecutando, es útil devolver información en los registros mediante sentencias print, para poder evaluar mejor el progreso de la carga de trabajo. A continuación se muestra un sencillo ejemplo de impresión de `estimator_options` para que quede constancia de las opciones reales del Estimador utilizadas. Hay muchos más ejemplos similares a lo largo del programa para informar del progreso durante la ejecución, incluyendo el valor de la función objetivo durante el componente iterativo de AQC-Tensor, y la profundidad de dos qubits del circuito final de arquitectura de conjunto de instrucciones (ISA) destinado a la ejecución en hardware.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "be933b77-fb13-4875-9734-4226067bc8d2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"print(\"estimator_options =\", json.dumps(estimator_options, indent=4))"
]
},
{
"cell_type": "markdown",
"id": "fb65718c-8837-4610-87b7-59e6dc7abb80",
"metadata": {},
"source": [
"\n",
"\n",
"#### Validar las entradas\n",
"\n",
"Un aspecto importante para garantizar que la plantilla pueda reutilizarse en toda una serie de entradas es la validación de las mismas. El siguiente código es un ejemplo de verificación de que la fidelidad de parada durante AQC-Tensor se ha especificado correctamente y, si no es así, devuelve un mensaje de error informativo sobre cómo solucionar el error.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0af1aee2-5771-4ae1-82dc-3ec08943de54",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"# Perform parameter validation\n",
"\n",
"if not 0.0 < aqc_stopping_fidelity <= 1.0:\n",
" raise ValueError(\n",
" f\"Invalid stopping fidelity: {aqc_stopping_fidelity}. \"\n",
" f\"It must be a positive float no greater than 1.\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "0e5495ee-82e2-43dc-bca7-f8e81f8b6302",
"metadata": {},
"source": [
"\n",
"\n",
"#### Prepare las salidas de la función\n",
"\n",
"En primer lugar, prepare un diccionario que contenga todas las salidas de las plantillas de funciones. Las claves se irán añadiendo a este diccionario a lo largo del flujo de trabajo, y se devuelve al final del programa.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "1677fa7c-3b4a-4a24-b1e4-e03d9b3c49da",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"output = {}"
]
},
{
"cell_type": "markdown",
"id": "3acd5522-a880-4de7-9251-2d68efc261ad",
"metadata": {},
"source": [
"\n",
"\n",
"### Mapea el problema y preprocesa el circuito con AQC\n",
"\n",
"La optimización AQC-Tensor se produce en el paso 1 de un patrón Qiskit. En primer lugar, se construye un estado objetivo. En este ejemplo, se construye a partir de un circuito objetivo que evoluciona el mismo Hamiltoniano durante el mismo periodo de tiempo que la parte AQC. A continuación, se genera un ansatz a partir de un circuito equivalente pero con menos pasos de Trotter. En la parte principal del algoritmo AQC, ese ansatz se acerca iterativamente al estado objetivo. Por último, el resultado se combina con el resto de pasos Trotter necesarios para alcanzar el tiempo de evolución deseado.\n",
"\n",
"Observe los ejemplos adicionales de registro incorporados en el siguiente código.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "92b59882-2844-4312-a09b-3da02c63f60b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"import os\n",
"os.environ[\"NUMBA_CACHE_DIR\"] = \"/data\"\n",
"\n",
"import datetime\n",
"import quimb.tensor\n",
"from scipy.optimize import OptimizeResult, minimize\n",
"from qiskit.synthesis import SuzukiTrotter\n",
"from qiskit_addon_utils.problem_generators import generate_time_evolution_circuit\n",
"from qiskit_addon_aqc_tensor.ansatz_generation import (\n",
" generate_ansatz_from_circuit,\n",
" AnsatzBlock,\n",
")\n",
"from qiskit_addon_aqc_tensor.simulation import (\n",
" tensornetwork_from_circuit,\n",
" compute_overlap,\n",
")\n",
"from qiskit_addon_aqc_tensor.simulation.quimb import QuimbSimulator\n",
"from qiskit_addon_aqc_tensor.objective import OneMinusFidelity\n",
"\n",
"print(\"Hamiltonian:\", hamiltonian)\n",
"print(\"Observable:\", observable)\n",
"simulator_settings = QuimbSimulator(quimb.tensor.CircuitMPS, autodiff_backend=\"jax\")\n",
"\n",
"# Construct the AQC target circuit\n",
"aqc_target_circuit = initial_state.copy()\n",
"if aqc_evolution_time:\n",
" aqc_target_circuit.compose(\n",
" generate_time_evolution_circuit(\n",
" hamiltonian,\n",
" synthesis=SuzukiTrotter(reps=aqc_target_num_trotter_steps),\n",
" time=aqc_evolution_time,\n",
" ),\n",
" inplace=True,\n",
" )\n",
"\n",
"# Construct matrix-product state representation of the AQC target state\n",
"aqc_target_mps = tensornetwork_from_circuit(aqc_target_circuit, simulator_settings)\n",
"print(\"Target MPS maximum bond dimension:\", aqc_target_mps.psi.max_bond())\n",
"output[\"target_bond_dimension\"] = aqc_target_mps.psi.max_bond()\n",
"\n",
"# Generate an ansatz and initial parameters from a Trotter circuit with fewer steps\n",
"aqc_good_circuit = initial_state.copy()\n",
"if aqc_evolution_time:\n",
" aqc_good_circuit.compose(\n",
" generate_time_evolution_circuit(\n",
" hamiltonian,\n",
" synthesis=SuzukiTrotter(reps=aqc_ansatz_num_trotter_steps),\n",
" time=aqc_evolution_time,\n",
" ),\n",
" inplace=True,\n",
" )\n",
"aqc_ansatz, aqc_initial_parameters = generate_ansatz_from_circuit(aqc_good_circuit)\n",
"print(\"Number of AQC parameters:\", len(aqc_initial_parameters))\n",
"output[\"num_aqc_parameters\"] = len(aqc_initial_parameters)\n",
"\n",
"# Calculate the fidelity of ansatz circuit vs. the target state, before optimization\n",
"good_mps = tensornetwork_from_circuit(aqc_good_circuit, simulator_settings)\n",
"starting_fidelity = abs(compute_overlap(good_mps, aqc_target_mps)) ** 2\n",
"print(\"Starting fidelity of AQC portion:\", starting_fidelity)\n",
"output[\"aqc_starting_fidelity\"] = starting_fidelity\n",
"\n",
"# Optimize the ansatz parameters by using MPS calculations\n",
"def callback(intermediate_result: OptimizeResult):\n",
" fidelity = 1 - intermediate_result.fun\n",
" print(f\"{datetime.datetime.now()} Intermediate result: Fidelity {fidelity:.8f}\")\n",
" if intermediate_result.fun < stopping_point:\n",
" raise StopIteration\n",
"\n",
"\n",
"objective = OneMinusFidelity(aqc_target_mps, aqc_ansatz, simulator_settings)\n",
"stopping_point = 1.0 - aqc_stopping_fidelity\n",
"\n",
"result = minimize(\n",
" objective,\n",
" aqc_initial_parameters,\n",
" method=\"L-BFGS-B\",\n",
" jac=True,\n",
" options={\"maxiter\": aqc_max_iterations},\n",
" callback=callback,\n",
")\n",
"if result.status not in (\n",
" 0,\n",
" 1,\n",
" 99,\n",
"): # 0 => success; 1 => max iterations reached;\n",
" # 99 => early termination via StopIteration\n",
" raise RuntimeError(\n",
" f\"Optimization failed: {result.message} (status={result.status})\"\n",
" )\n",
"print(f\"Done after {result.nit} iterations.\")\n",
"output[\"num_iterations\"] = result.nit\n",
"aqc_final_parameters = result.x\n",
"output[\"aqc_final_parameters\"] = list(aqc_final_parameters)\n",
"\n",
"# Construct an optimized circuit for initial portion of time evolution\n",
"aqc_final_circuit = aqc_ansatz.assign_parameters(aqc_final_parameters)\n",
"\n",
"# Calculate fidelity after optimization\n",
"aqc_final_mps = tensornetwork_from_circuit(aqc_final_circuit, simulator_settings)\n",
"aqc_fidelity = abs(compute_overlap(aqc_final_mps, aqc_target_mps)) ** 2\n",
"print(\"Fidelity of AQC portion:\", aqc_fidelity)\n",
"output[\"aqc_fidelity\"] = aqc_fidelity\n",
"\n",
"# Construct final circuit, with remainder of time evolution\n",
"final_circuit = aqc_final_circuit.copy()\n",
"if remainder_evolution_time:\n",
" remainder_circuit = generate_time_evolution_circuit(\n",
" hamiltonian,\n",
" synthesis=SuzukiTrotter(reps=remainder_num_trotter_steps),\n",
" time=remainder_evolution_time,\n",
" )\n",
" final_circuit.compose(remainder_circuit, inplace=True)"
]
},
{
"cell_type": "markdown",
"id": "ae8e53a6-2106-4753-ad1a-ebc146cd44ab",
"metadata": {},
"source": [
"\n",
"\n",
"### Optimizar el circuito final para la ejecución\n",
"\n",
"Después de la parte AQC del flujo de trabajo, el `final_circuit` se [transpila para el hardware](/docs/guides/transpile#instruction-set-architecture) como de costumbre.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1db2749f-1285-48c6-8ec3-bc9f422686e2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"from qiskit.transpiler import generate_preset_pass_manager\n",
"\n",
"service = QiskitRuntimeService()\n",
"backend = service.backend(backend_name)\n",
"\n",
"# Transpile PUBs (circuits and observables) to match ISA\n",
"pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=3)\n",
"isa_circuit = pass_manager.run(final_circuit)\n",
"isa_observable = observable.apply_layout(isa_circuit.layout)\n",
"\n",
"isa_2qubit_depth = isa_circuit.depth(lambda x: x.operation.num_qubits == 2)\n",
"print(\"ISA circuit two-qubit depth:\", isa_2qubit_depth)\n",
"output[\"twoqubit_depth\"] = isa_2qubit_depth"
]
},
{
"cell_type": "markdown",
"id": "c41b9c0e-1f00-454c-acff-c194cc16e03e",
"metadata": {},
"source": [
"\n",
"\n",
"#### Salga antes de tiempo si utiliza el modo de simulación\n",
"\n",
"Si se ha seleccionado el modo de funcionamiento en seco, el programa se detiene antes de ejecutarse en el hardware. Esto puede ser útil si, por ejemplo, desea inspeccionar primero la profundidad de dos qubits del circuito ISA antes de decidir ejecutarlo en hardware.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "e7c6c770-0453-4ad7-9a3e-20a47208768a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"# Exit now if dry run; don't execute on hardware\n",
"if dry_run:\n",
" import sys\n",
"\n",
" print(\"Exiting before hardware execution since `dry_run` is True.\")\n",
" save_result(output)\n",
" sys.exit(0)"
]
},
{
"cell_type": "markdown",
"id": "3a603817-abaf-4403-beea-cca838a59577",
"metadata": {},
"source": [
"\n",
"\n",
"#### Ejecutar el circuito en hardware\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b7525014-a473-4d9d-b7cb-9c590f2364ae",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"# ## Step 3: Execute quantum experiments on backend\n",
"from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
"\n",
"\n",
"estimator = Estimator(backend, options=estimator_options)\n",
"\n",
"# Submit the underlying Estimator job. Note that this is not the\n",
"# actual function job.\n",
"job = estimator.run([(isa_circuit, isa_observable)])\n",
"print(\"Job ID:\", job.job_id())\n",
"output[\"job_id\"] = job.job_id()\n",
"\n",
"# Wait until job is complete\n",
"hw_results = job.result()\n",
"hw_results_dicts = [pub_result.data.__dict__ for pub_result in hw_results]\n",
"\n",
"# Save hardware results to serverless output dictionary\n",
"output[\"hw_results\"] = hw_results_dicts\n",
"\n",
"# Reorganize expectation values\n",
"hw_expvals = [pub_result_data[\"evs\"].tolist()\n",
" for pub_result_data in hw_results_dicts]\n",
"\n",
"# Save expectation values to Qiskit Serverless\n",
"print(\"Hardware expectation values\", hw_expvals)\n",
"output[\"hw_expvals\"] = hw_expvals[0]"
]
},
{
"cell_type": "markdown",
"id": "12df35c4-4f1c-48cb-a323-d0cf33422fab",
"metadata": {},
"source": [
"\n",
"\n",
"#### Guardar la salida\n",
"\n",
"Esta plantilla de función devuelve la salida relevante a nivel de dominio para este flujo de trabajo de simulación Hamiltoniana (valores de expectativa) además de metadatos importantes generados a lo largo del camino.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "bfb8ab87-c42d-4993-92bd-8b38364dc443",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Appending to ./source_files/template_hamiltonian_simulation.py\n"
]
}
],
"source": [
"%%writefile --append ./source_files/template_hamiltonian_simulation.py\n",
"\n",
"save_result(output)"
]
},
{
"cell_type": "markdown",
"id": "220f8bc8-4f04-41d3-86f1-15e9c2f45a56",
"metadata": {},
"source": [
"\n",
"\n",
"## Implementa la función en IBM Quantum Platform\n",
"\n",
"En el apartado anterior se ha creado un programa que se ejecutará de forma remota. El código de esta sección sube ese programa a Qiskit Serverless.\n",
"\n",
"Utilice `qiskit-ibm-catalog` para autenticarse en `QiskitServerless` con su clave API, que encontrará en el panel de control de [la plataforma Quantum IBM](), y cargue el programa.\n",
"\n",
"Opcionalmente, puede utilizar `save_account()` para guardar sus credenciales (consulte la guía [Configurar su cuenta de IBM Cloud](/docs/guides/cloud-setup#cloud-save) ). Tenga en cuenta que esto escribe sus credenciales en el mismo archivo que [`QiskitRuntimeService.save_account()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#save_account).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "313bd03b-bf9b-4e6c-aa05-1fe8def3868d",
"metadata": {},
"outputs": [],
"source": [
"from qiskit_ibm_catalog import QiskitServerless, QiskitFunction\n",
"\n",
"# Authenticate to the remote cluster and submit the pattern\n",
"# for remote execution\n",
"serverless = QiskitServerless()"
]
},
{
"cell_type": "markdown",
"id": "e9c495d4-cdab-4329-b65d-d111029aee64",
"metadata": {},
"source": [
"Este programa tiene dependencias personalizadas de `pip` . Añádalos a una matriz `dependencies` cuando construya la instancia `QiskitFunction` :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ca386323-d92d-4c41-908b-1670324e1264",
"metadata": {},
"outputs": [],
"source": [
"template = QiskitFunction(\n",
" title=\"template_hamiltonian_simulation\",\n",
" entrypoint=\"template_hamiltonian_simulation.py\",\n",
" working_dir=\"./source_files/\",\n",
" dependencies=[\n",
" \"qiskit-addon-utils~=0.1.0\",\n",
" \"qiskit-addon-aqc-tensor[quimb-jax]~=0.1.2\",\n",
" \"mergedeep==1.3.4\",\n",
" ],\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "80a2c6b5-1f1e-4e90-9b1f-75907caf1df3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"QiskitFunction(template_hamiltonian_simulation)"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"serverless.upload(template)"
]
},
{
"cell_type": "markdown",
"id": "06677105-627a-4948-aac7-071f44327a0b",
"metadata": {},
"source": [
"Por último, compruebe si el programa se ha cargado correctamente, utilice `serverless.list()`:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "11f14088-8eca-4a99-a291-3f37a61b0d26",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" QiskitFunction(template_hamiltonian_simulation),\n"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"serverless.list()"
]
},
{
"cell_type": "markdown",
"id": "385bda3e-73de-413c-8e45-cf7047303219",
"metadata": {},
"source": [
"\n",
"\n",
"## Ejecutar la plantilla de función de forma remota\n",
"\n",
"La plantilla de la función se ha cargado, por lo que se puede ejecutar de forma remota con Qiskit Serverless. En primer lugar, cargue la plantilla por su nombre:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "d4ff8dea-95ab-4cc9-92b9-e28e277e76f2",
"metadata": {},
"outputs": [],
"source": [
"template = serverless.load(\"template_hamiltonian_simulation\")"
]
},
{
"cell_type": "markdown",
"id": "57964962-87e9-4c0b-a717-cb620019960e",
"metadata": {},
"source": [
"A continuación, ejecute la plantilla con las entradas a nivel de dominio para la simulación hamiltoniana. Este ejemplo especifica un modelo XXZ de 50 qubits con acoplamientos aleatorios, y un estado inicial y observable.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "e5d1555c-9abb-4fef-b8a2-f8d1b723df01",
"metadata": {},
"outputs": [],
"source": [
"from itertools import chain\n",
"import numpy as np\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"\n",
"L = 50\n",
"\n",
"# Generate the edge list for this spin-chain\n",
"edges = [(i, i + 1) for i in range(L - 1)]\n",
"# Generate an edge-coloring so we can make hw-efficient circuits\n",
"edges = edges[::2] + edges[1::2]\n",
"\n",
"# Generate random coefficients for our XXZ Hamiltonian\n",
"np.random.seed(0)\n",
"Js = np.random.rand(L - 1) + 0.5 * np.ones(L - 1)\n",
"\n",
"hamiltonian = SparsePauliOp.from_sparse_list(\n",
" chain.from_iterable(\n",
" [\n",
" [\n",
" (\"XX\", (i, j), Js[i] / 2),\n",
" (\"YY\", (i, j), Js[i] / 2),\n",
" (\"ZZ\", (i, j), Js[i]),\n",
" ]\n",
" for i, j in edges\n",
" ]\n",
" ),\n",
" num_qubits=L,\n",
")\n",
"observable = SparsePauliOp.from_sparse_list(\n",
" [(\"ZZ\", (L // 2 - 1, L // 2), 1.0)], num_qubits=L\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "7ec5ab02-280c-4c04-8e63-e5354eb8ebb9",
"metadata": {},
"outputs": [],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"initial_state = QuantumCircuit(L)\n",
"for i in range(L):\n",
" if i % 2:\n",
" initial_state.x(i)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "ac8d8fec-0290-4d6b-a18c-afd02acfa850",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"853b0edb-d63f-4629-be71-398b6dcf33cb\n"
]
}
],
"source": [
"job = template.run(\n",
" dry_run=True,\n",
" initial_state=initial_state,\n",
" hamiltonian=hamiltonian,\n",
" observable=observable,\n",
" backend_name=\"ibm_fez\",\n",
" estimator_options={},\n",
" aqc_evolution_time=0.2,\n",
" aqc_ansatz_num_trotter_steps=1,\n",
" aqc_target_num_trotter_steps=32,\n",
" remainder_evolution_time=0.2,\n",
" remainder_num_trotter_steps=4,\n",
" aqc_max_iterations=300,\n",
")\n",
"print(job.job_id)"
]
},
{
"cell_type": "markdown",
"id": "2249cabc-6821-4d84-b4d8-e519c2d94a5c",
"metadata": {},
"source": [
"Comprueba el estado del trabajo:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "ed3b744d-cb00-43e0-907c-34dfebe2fa9b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'QUEUED'"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"job.status()"
]
},
{
"cell_type": "markdown",
"id": "83751f45-ab37-4037-bc77-d1aef91ed46c",
"metadata": {},
"source": [
"Una vez ejecutada la tarea, puede recuperar los registros creados a partir de las salidas de `print()` . Éstas pueden proporcionar información procesable sobre el progreso del flujo de trabajo de la simulación hamiltoniana. Por ejemplo, el valor de la función objetivo durante el componente iterativo de AQC, o la profundidad de dos qubits del circuito ISA final destinado a la ejecución en hardware.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "3be62464-18b0-4598-b386-0ac0cc9cccb6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"No logs yet.\n"
]
}
],
"source": [
"print(job.logs())"
]
},
{
"cell_type": "markdown",
"id": "a8384509-2a9d-44e6-a729-40464ff52bea",
"metadata": {},
"source": [
"Bloquea el resto del programa hasta que el resultado esté disponible. Una vez realizado el trabajo, puedes recuperar los resultados. Entre ellos se incluye el resultado a nivel de dominio de la simulación hamiltoniana (valor de expectativa) y metadatos útiles.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "fc678bcd-539d-4970-86e0-9a69f0a367ef",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'target_bond_dimension': 5,\n",
" 'num_aqc_parameters': 816,\n",
" 'aqc_starting_fidelity': 0.9914382555614002,\n",
" 'num_iterations': 72,\n",
" 'aqc_fidelity': 0.9998108844412502,\n",
" 'twoqubit_depth': 33}"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"result = job.result()\n",
"\n",
"del result[\n",
" \"aqc_final_parameters\"\n",
"] # the list is too long to conveniently display here\n",
"result"
]
},
{
"cell_type": "markdown",
"id": "12b0ccfe-325a-4939-81e7-58d94557990d",
"metadata": {},
"source": [
"Una vez finalizada la tarea, estará disponible toda la salida de registro.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "cb722373-cbfb-45a7-a2b5-d7a97e18ee6c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2024-12-17 14:50:15,580\tINFO job_manager.py:531 -- Runtime env is setting up.\n",
"estimator_options = {\n",
" \"resilience\": {\n",
" \"measure_mitigation\": true,\n",
" \"zne_mitigation\": true,\n",
" \"zne\": {\n",
" \"amplifier\": \"gate_folding\",\n",
" \"noise_factors\": [\n",
" 1,\n",
" 2,\n",
" 3\n",
" ],\n",
" \"extrapolated_noise_factors\": [\n",
" 0.0,\n",
" 0.1,\n",
" 0.2,\n",
" 0.30000000000000004,\n",
" 0.4,\n",
" 0.5,\n",
" 0.6000000000000001,\n",
" 0.7000000000000001,\n",
" 0.8,\n",
" 0.9,\n",
" 1.0,\n",
" 1.1,\n",
" 1.2000000000000002,\n",
" 1.3,\n",
" 1.4000000000000001,\n",
" 1.5,\n",
" 1.6,\n",
" 1.7000000000000002,\n",
" 1.8,\n",
" 1.9000000000000001,\n",
" 2.0,\n",
" 2.1,\n",
" 2.2,\n",
" 2.3000000000000003,\n",
" 2.4000000000000004,\n",
" 2.5,\n",
" 2.6,\n",
" 2.7,\n",
" 2.8000000000000003,\n",
" 2.9000000000000004,\n",
" 3.0\n",
" ],\n",
" \"extrapolator\": [\n",
" \"exponential\",\n",
" \"linear\",\n",
" \"fallback\"\n",
" ]\n",
" },\n",
" \"measure_noise_learning\": {\n",
" \"num_randomizations\": 512,\n",
" \"shots_per_randomization\": 512\n",
" }\n",
" },\n",
" \"twirling\": {\n",
" \"enable_gates\": true,\n",
" \"enable_measure\": true,\n",
" \"num_randomizations\": 300,\n",
" \"shots_per_randomization\": 100,\n",
" \"strategy\": \"active\"\n",
" }\n",
"}\n",
"Hamiltonian: SparsePauliOp(['IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXX', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYY', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZ', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'XXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'YYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZI', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IIIZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IXXIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IYYIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'IZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'],\n",
" coeffs=[0.52440675+0.j, 0.52440675+0.j, 1.0488135 +0.j, 0.55138169+0.j,\n",
" 0.55138169+0.j, 1.10276338+0.j, 0.4618274 +0.j, 0.4618274 +0.j,\n",
" 0.9236548 +0.j, 0.46879361+0.j, 0.46879361+0.j, 0.93758721+0.j,\n",
" 0.73183138+0.j, 0.73183138+0.j, 1.46366276+0.j, 0.64586252+0.j,\n",
" 0.64586252+0.j, 1.29172504+0.j, 0.53402228+0.j, 0.53402228+0.j,\n",
" 1.06804456+0.j, 0.28551803+0.j, 0.28551803+0.j, 0.57103606+0.j,\n",
" 0.2601092 +0.j, 0.2601092 +0.j, 0.5202184 +0.j, 0.63907838+0.j,\n",
" 0.63907838+0.j, 1.27815675+0.j, 0.73930917+0.j, 0.73930917+0.j,\n",
" 1.47861834+0.j, 0.48073968+0.j, 0.48073968+0.j, 0.96147936+0.j,\n",
" 0.30913721+0.j, 0.30913721+0.j, 0.61827443+0.j, 0.32167664+0.j,\n",
" 0.32167664+0.j, 0.64335329+0.j, 0.51092416+0.j, 0.51092416+0.j,\n",
" 1.02184832+0.j, 0.38227781+0.j, 0.38227781+0.j, 0.76455561+0.j,\n",
" 0.47807517+0.j, 0.47807517+0.j, 0.95615033+0.j, 0.2593949 +0.j,\n",
" 0.2593949 +0.j, 0.5187898 +0.j, 0.55604786+0.j, 0.55604786+0.j,\n",
" 1.11209572+0.j, 0.72187404+0.j, 0.72187404+0.j, 1.44374808+0.j,\n",
" 0.42975395+0.j, 0.42975395+0.j, 0.8595079 +0.j, 0.5988156 +0.j,\n",
" 0.5988156 +0.j, 1.1976312 +0.j, 0.58338336+0.j, 0.58338336+0.j,\n",
" 1.16676672+0.j, 0.35519128+0.j, 0.35519128+0.j, 0.71038256+0.j,\n",
" 0.40771418+0.j, 0.40771418+0.j, 0.81542835+0.j, 0.60759468+0.j,\n",
" 0.60759468+0.j, 1.21518937+0.j, 0.52244159+0.j, 0.52244159+0.j,\n",
" 1.04488318+0.j, 0.57294706+0.j, 0.57294706+0.j, 1.14589411+0.j,\n",
" 0.6958865 +0.j, 0.6958865 +0.j, 1.391773 +0.j, 0.44172076+0.j,\n",
" 0.44172076+0.j, 0.88344152+0.j, 0.51444746+0.j, 0.51444746+0.j,\n",
" 1.02889492+0.j, 0.71279832+0.j, 0.71279832+0.j, 1.42559664+0.j,\n",
" 0.29356465+0.j, 0.29356465+0.j, 0.5871293 +0.j, 0.66630992+0.j,\n",
" 0.66630992+0.j, 1.33261985+0.j, 0.68500607+0.j, 0.68500607+0.j,\n",
" 1.37001215+0.j, 0.64957928+0.j, 0.64957928+0.j, 1.29915856+0.j,\n",
" 0.64026459+0.j, 0.64026459+0.j, 1.28052918+0.j, 0.56996051+0.j,\n",
" 0.56996051+0.j, 1.13992102+0.j, 0.72233446+0.j, 0.72233446+0.j,\n",
" 1.44466892+0.j, 0.45733097+0.j, 0.45733097+0.j, 0.91466194+0.j,\n",
" 0.63711684+0.j, 0.63711684+0.j, 1.27423369+0.j, 0.53421697+0.j,\n",
" 0.53421697+0.j, 1.06843395+0.j, 0.55881775+0.j, 0.55881775+0.j,\n",
" 1.1176355 +0.j, 0.558467 +0.j, 0.558467 +0.j, 1.116934 +0.j,\n",
" 0.59091015+0.j, 0.59091015+0.j, 1.1818203 +0.j, 0.46851598+0.j,\n",
" 0.46851598+0.j, 0.93703195+0.j, 0.28011274+0.j, 0.28011274+0.j,\n",
" 0.56022547+0.j, 0.58531893+0.j, 0.58531893+0.j, 1.17063787+0.j,\n",
" 0.31446315+0.j, 0.31446315+0.j, 0.6289263 +0.j])\n",
"Observable: SparsePauliOp(['IIIIIIIIIIIIIIIIIIIIIIIIZZIIIIIIIIIIIIIIIIIIIIIIII'],\n",
" coeffs=[1.+0.j])\n",
"Target MPS maximum bond dimension: 5\n",
"Number of AQC parameters: 816\n",
"Starting fidelity of AQC portion: 0.9914382555614002\n",
"2024-12-17 14:52:23.400028 Intermediate result: Fidelity 0.99764093\n",
"2024-12-17 14:52:23.429669 Intermediate result: Fidelity 0.99788003\n",
"2024-12-17 14:52:23.459674 Intermediate result: Fidelity 0.99795970\n",
"2024-12-17 14:52:23.489666 Intermediate result: Fidelity 0.99799067\n",
"2024-12-17 14:52:23.518545 Intermediate result: Fidelity 0.99803401\n",
"2024-12-17 14:52:23.546952 Intermediate result: Fidelity 0.99809821\n",
"2024-12-17 14:52:23.575271 Intermediate result: Fidelity 0.99824660\n",
"2024-12-17 14:52:23.604049 Intermediate result: Fidelity 0.99845326\n",
"2024-12-17 14:52:23.632709 Intermediate result: Fidelity 0.99870497\n",
"2024-12-17 14:52:23.660527 Intermediate result: Fidelity 0.99891442\n",
"2024-12-17 14:52:23.688273 Intermediate result: Fidelity 0.99904488\n",
"2024-12-17 14:52:23.716105 Intermediate result: Fidelity 0.99914438\n",
"2024-12-17 14:52:23.744336 Intermediate result: Fidelity 0.99922827\n",
"2024-12-17 14:52:23.773399 Intermediate result: Fidelity 0.99929071\n",
"2024-12-17 14:52:23.801482 Intermediate result: Fidelity 0.99932432\n",
"2024-12-17 14:52:23.830466 Intermediate result: Fidelity 0.99936460\n",
"2024-12-17 14:52:23.860738 Intermediate result: Fidelity 0.99938891\n",
"2024-12-17 14:52:23.889958 Intermediate result: Fidelity 0.99940607\n",
"2024-12-17 14:52:23.918703 Intermediate result: Fidelity 0.99941965\n",
"2024-12-17 14:52:23.949744 Intermediate result: Fidelity 0.99944337\n",
"2024-12-17 14:52:23.980871 Intermediate result: Fidelity 0.99946875\n",
"2024-12-17 14:52:24.012124 Intermediate result: Fidelity 0.99949009\n",
"2024-12-17 14:52:24.044359 Intermediate result: Fidelity 0.99952191\n",
"2024-12-17 14:52:24.075840 Intermediate result: Fidelity 0.99953669\n",
"2024-12-17 14:52:24.106303 Intermediate result: Fidelity 0.99955242\n",
"2024-12-17 14:52:24.139329 Intermediate result: Fidelity 0.99958412\n",
"2024-12-17 14:52:24.169725 Intermediate result: Fidelity 0.99960176\n",
"2024-12-17 14:52:24.198749 Intermediate result: Fidelity 0.99961606\n",
"2024-12-17 14:52:24.227874 Intermediate result: Fidelity 0.99963811\n",
"2024-12-17 14:52:24.256818 Intermediate result: Fidelity 0.99964383\n",
"2024-12-17 14:52:24.285889 Intermediate result: Fidelity 0.99964717\n",
"2024-12-17 14:52:24.315228 Intermediate result: Fidelity 0.99966064\n",
"2024-12-17 14:52:24.345322 Intermediate result: Fidelity 0.99966517\n",
"2024-12-17 14:52:24.374921 Intermediate result: Fidelity 0.99967089\n",
"2024-12-17 14:52:24.404309 Intermediate result: Fidelity 0.99968305\n",
"2024-12-17 14:52:24.432664 Intermediate result: Fidelity 0.99968889\n",
"2024-12-17 14:52:24.461639 Intermediate result: Fidelity 0.99969997\n",
"2024-12-17 14:52:24.491244 Intermediate result: Fidelity 0.99971666\n",
"2024-12-17 14:52:24.520354 Intermediate result: Fidelity 0.99972441\n",
"2024-12-17 14:52:24.549965 Intermediate result: Fidelity 0.99973561\n",
"2024-12-17 14:52:24.583464 Intermediate result: Fidelity 0.99973811\n",
"2024-12-17 14:52:24.617537 Intermediate result: Fidelity 0.99974074\n",
"2024-12-17 14:52:24.652247 Intermediate result: Fidelity 0.99974467\n",
"2024-12-17 14:52:24.686831 Intermediate result: Fidelity 0.99974991\n",
"2024-12-17 14:52:24.725476 Intermediate result: Fidelity 0.99975230\n",
"2024-12-17 14:52:24.764637 Intermediate result: Fidelity 0.99975373\n",
"2024-12-17 14:52:24.802499 Intermediate result: Fidelity 0.99975552\n",
"2024-12-17 14:52:24.839960 Intermediate result: Fidelity 0.99975885\n",
"2024-12-17 14:52:24.877472 Intermediate result: Fidelity 0.99976469\n",
"2024-12-17 14:52:24.916233 Intermediate result: Fidelity 0.99976517\n",
"2024-12-17 14:52:24.993750 Intermediate result: Fidelity 0.99976875\n",
"2024-12-17 14:52:25.034953 Intermediate result: Fidelity 0.99976887\n",
"2024-12-17 14:52:25.076197 Intermediate result: Fidelity 0.99977244\n",
"2024-12-17 14:52:25.112340 Intermediate result: Fidelity 0.99977638\n",
"2024-12-17 14:52:25.149947 Intermediate result: Fidelity 0.99977828\n",
"2024-12-17 14:52:25.190049 Intermediate result: Fidelity 0.99978174\n",
"2024-12-17 14:52:25.310903 Intermediate result: Fidelity 0.99978222\n",
"2024-12-17 14:52:25.347512 Intermediate result: Fidelity 0.99978508\n",
"2024-12-17 14:52:25.385201 Intermediate result: Fidelity 0.99978543\n",
"2024-12-17 14:52:25.457436 Intermediate result: Fidelity 0.99978770\n",
"2024-12-17 14:52:25.497133 Intermediate result: Fidelity 0.99978818\n",
"2024-12-17 14:52:25.541179 Intermediate result: Fidelity 0.99978913\n",
"2024-12-17 14:52:25.584791 Intermediate result: Fidelity 0.99978937\n",
"2024-12-17 14:52:25.621484 Intermediate result: Fidelity 0.99979068\n",
"2024-12-17 14:52:25.655847 Intermediate result: Fidelity 0.99979211\n",
"2024-12-17 14:52:25.691710 Intermediate result: Fidelity 0.99979700\n",
"2024-12-17 14:52:25.767711 Intermediate result: Fidelity 0.99979759\n",
"2024-12-17 14:52:25.804517 Intermediate result: Fidelity 0.99979807\n",
"2024-12-17 14:52:25.839394 Intermediate result: Fidelity 0.99980236\n",
"2024-12-17 14:52:25.874438 Intermediate result: Fidelity 0.99980296\n",
"2024-12-17 14:52:25.909900 Intermediate result: Fidelity 0.99980320\n",
"2024-12-17 14:52:26.713044 Intermediate result: Fidelity 0.99980320\n",
"Done after 72 iterations.\n",
"Fidelity of AQC portion: 0.9998108844412502\n",
"ISA circuit two-qubit depth: 33\n",
"Exiting before hardware execution since `dry_run` is True.\n",
"\n"
]
}
],
"source": [
"print(job.logs())"
]
},
{
"cell_type": "markdown",
"id": "196d6261-e26b-4057-ae55-19f003fdc10a",
"metadata": {},
"source": [
"\n",
"\n",
"## Próximos pasos\n",
"\n",
"\n",
" Para una inmersión más profunda en el addon Qiskit AQC-Tensor, echa un vistazo al tutorial [Improved Trotterized Time Evolution with Approximate Quantum Compilation](/docs/tutorials/approximate-quantum-compilation-for-time-evolution) o al [repositorio qiskit-addon-aqc-tensor](https://github.com/Qiskit/qiskit-addon-aqc-tensor).\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "20502fe4-7940-40fa-a978-64cc3ff6c1b1",
"metadata": {
"tags": [
"id-full-source"
]
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting ./source_files/template_hamiltonian_simulation_full.py\n"
]
}
],
"source": [
"%%writefile ./source_files/template_hamiltonian_simulation_full.py\n",
"\n",
"from qiskit import QuantumCircuit\n",
"from qiskit_serverless import get_arguments, save_result\n",
"\n",
"\n",
"# Extract parameters from arguments\n",
"#\n",
"# Do this at the top of the program so it fails early\n",
"# if any required arguments are missing or invalid.\n",
"\n",
"arguments = get_arguments()\n",
"\n",
"dry_run = arguments.get(\"dry_run\", False)\n",
"backend_name = arguments[\"backend_name\"]\n",
"\n",
"aqc_evolution_time = arguments[\"aqc_evolution_time\"]\n",
"aqc_ansatz_num_trotter_steps = arguments[\"aqc_ansatz_num_trotter_steps\"]\n",
"aqc_target_num_trotter_steps = arguments[\"aqc_target_num_trotter_steps\"]\n",
"\n",
"remainder_evolution_time = arguments[\"remainder_evolution_time\"]\n",
"remainder_num_trotter_steps = arguments[\"remainder_num_trotter_steps\"]\n",
"\n",
"# Stop if this fidelity is achieved\n",
"aqc_stopping_fidelity = arguments.get(\"aqc_stopping_fidelity\", 1.0)\n",
"# Stop after this number of iterations, even if stopping fidelity is not achieved\n",
"aqc_max_iterations = arguments.get(\"aqc_max_iterations\", 500)\n",
"\n",
"hamiltonian = arguments[\"hamiltonian\"]\n",
"observable = arguments[\"observable\"]\n",
"initial_state = arguments.get(\"initial_state\", QuantumCircuit(hamiltonian.num_qubits))\n",
"\n",
"import numpy as np\n",
"import json\n",
"from mergedeep import merge\n",
"\n",
"\n",
"# Configure `EstimatorOptions` to control the hardware experiment's parameters\n",
"#\n",
"# Set default options\n",
"estimator_default_options = {\n",
" \"resilience\": {\n",
" \"measure_mitigation\": True,\n",
" \"zne_mitigation\": True,\n",
" \"zne\": {\n",
" \"amplifier\": \"gate_folding\",\n",
" \"noise_factors\": [1, 2, 3],\n",
" \"extrapolated_noise_factors\": list(np.linspace(0, 3, 31)),\n",
" \"extrapolator\": [\"exponential\", \"linear\", \"fallback\"],\n",
" },\n",
" \"measure_noise_learning\": {\n",
" \"num_randomizations\": 512,\n",
" \"shots_per_randomization\": 512,\n",
" },\n",
" },\n",
" \"twirling\": {\n",
" \"enable_gates\": True,\n",
" \"enable_measure\": True,\n",
" \"num_randomizations\": 300,\n",
" \"shots_per_randomization\": 100,\n",
" \"strategy\": \"active\",\n",
" },\n",
"}\n",
"# Merge with user-provided options\n",
"estimator_options = merge(\n",
" arguments.get(\"estimator_options\", {}), estimator_default_options\n",
")\n",
"\n",
"print(\"estimator_options =\", json.dumps(estimator_options, indent=4))\n",
"\n",
"# Perform parameter validation\n",
"\n",
"if not 0.0 < aqc_stopping_fidelity <= 1.0:\n",
" raise ValueError(\n",
" f\"Invalid stopping fidelity: {aqc_stopping_fidelity}. \"\n",
" It must be a positive float no greater than 1.\"\n",
" )\n",
"\n",
"output = {}\n",
"\n",
"import os\n",
"os.environ[\"NUMBA_CACHE_DIR\"] = \"/data\"\n",
"\n",
"import datetime\n",
"import quimb.tensor\n",
"from scipy.optimize import OptimizeResult, minimize\n",
"from qiskit.synthesis import SuzukiTrotter\n",
"from qiskit_addon_utils.problem_generators import generate_time_evolution_circuit\n",
"from qiskit_addon_aqc_tensor.ansatz_generation import (\n",
" generate_ansatz_from_circuit,\n",
" AnsatzBlock,\n",
")\n",
"from qiskit_addon_aqc_tensor.simulation import (\n",
" tensornetwork_from_circuit,\n",
" compute_overlap,\n",
")\n",
"from qiskit_addon_aqc_tensor.simulation.quimb import QuimbSimulator\n",
"from qiskit_addon_aqc_tensor.objective import OneMinusFidelity\n",
"\n",
"print(\"Hamiltonian:\", hamiltonian)\n",
"print(\"Observable:\", observable)\n",
"simulator_settings = QuimbSimulator(quimb.tensor.CircuitMPS, autodiff_backend=\"jax\")\n",
"\n",
"# Construct the AQC target circuit\n",
"aqc_target_circuit = initial_state.copy()\n",
"if aqc_evolution_time:\n",
" aqc_target_circuit.compose(\n",
" generate_time_evolution_circuit(\n",
" hamiltonian,\n",
" synthesis=SuzukiTrotter(reps=aqc_target_num_trotter_steps),\n",
" time=aqc_evolution_time,\n",
" ),\n",
" inplace=True,\n",
" )\n",
"\n",
"# Construct matrix-product state representation of the AQC target state\n",
"aqc_target_mps = tensornetwork_from_circuit(aqc_target_circuit, simulator_settings)\n",
"print(\"Target MPS maximum bond dimension:\", aqc_target_mps.psi.max_bond())\n",
"output[\"target_bond_dimension\"] = aqc_target_mps.psi.max_bond()\n",
"\n",
"# Generate an ansatz and initial parameters from a Trotter circuit with fewer steps\n",
"aqc_good_circuit = initial_state.copy()\n",
"if aqc_evolution_time:\n",
" aqc_good_circuit.compose(\n",
" generate_time_evolution_circuit(\n",
" hamiltonian,\n",
" synthesis=SuzukiTrotter(reps=aqc_ansatz_num_trotter_steps),\n",
" time=aqc_evolution_time,\n",
" ),\n",
" inplace=True,\n",
" )\n",
"aqc_ansatz, aqc_initial_parameters = generate_ansatz_from_circuit(aqc_good_circuit)\n",
"print(\"Number of AQC parameters:\", len(aqc_initial_parameters))\n",
"output[\"num_aqc_parameters\"] = len(aqc_initial_parameters)\n",
"\n",
"# Calculate the fidelity of ansatz circuit vs. the target state, before optimization\n",
"good_mps = tensornetwork_from_circuit(aqc_good_circuit, simulator_settings)\n",
"starting_fidelity = abs(compute_overlap(good_mps, aqc_target_mps)) ** 2\n",
"print(\"Starting fidelity of AQC portion:\", starting_fidelity)\n",
"output[\"aqc_starting_fidelity\"] = starting_fidelity\n",
"\n",
"# Optimize the ansatz parameters by using MPS calculations\n",
"def callback(intermediate_result: OptimizeResult):\n",
" fidelity = 1 - intermediate_result.fun\n",
" print(f\"{datetime.datetime.now()} Intermediate result: Fidelity {fidelity:.8f}\")\n",
" if intermediate_result.fun < stopping_point:\n",
" raise StopIteration\n",
"\n",
"\n",
"objective = OneMinusFidelity(aqc_target_mps, aqc_ansatz, simulator_settings)\n",
"stopping_point = 1.0 - aqc_stopping_fidelity\n",
"\n",
"result = minimize(\n",
" objective,\n",
" aqc_initial_parameters,\n",
" method=\"L-BFGS-B\",\n",
" jac=True,\n",
" options={\"maxiter\": aqc_max_iterations},\n",
" callback=callback,\n",
")\n",
"if result.status not in (\n",
" 0,\n",
" 1,\n",
" 99,\n",
"): # 0 => success; 1 => max iterations reached; 99 => early termination via StopIteration\n",
" raise RuntimeError(\n",
" f\"Optimization failed: {result.message} (status={result.status})\"\n",
" )\n",
"print(f\"Done after {result.nit} iterations.\")\n",
"output[\"num_iterations\"] = result.nit\n",
"aqc_final_parameters = result.x\n",
"output[\"aqc_final_parameters\"] = list(aqc_final_parameters)\n",
"\n",
"# Construct an optimized circuit for initial portion of time evolution\n",
"aqc_final_circuit = aqc_ansatz.assign_parameters(aqc_final_parameters)\n",
"\n",
"# Calculate fidelity after optimization\n",
"aqc_final_mps = tensornetwork_from_circuit(aqc_final_circuit, simulator_settings)\n",
"aqc_fidelity = abs(compute_overlap(aqc_final_mps, aqc_target_mps)) ** 2\n",
"print(\"Fidelity of AQC portion:\", aqc_fidelity)\n",
"output[\"aqc_fidelity\"] = aqc_fidelity\n",
"\n",
"# Construct final circuit, with remainder of time evolution\n",
"final_circuit = aqc_final_circuit.copy()\n",
"if remainder_evolution_time:\n",
" remainder_circuit = generate_time_evolution_circuit(\n",
" hamiltonian,\n",
" synthesis=SuzukiTrotter(reps=remainder_num_trotter_steps),\n",
" time=remainder_evolution_time,\n",
" )\n",
" final_circuit.compose(remainder_circuit, inplace=True)\n",
"\n",
"from qiskit.transpiler import generate_preset_pass_manager\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"service = QiskitRuntimeService()\n",
"backend = service.backend(backend_name)\n",
"\n",
"# Transpile PUBs (circuits and observables) to match ISA\n",
"pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=3)\n",
"isa_circuit = pass_manager.run(final_circuit)\n",
"isa_observable = observable.apply_layout(isa_circuit.layout)\n",
"\n",
"isa_2qubit_depth = isa_circuit.depth(lambda x: x.operation.num_qubits == 2)\n",
"print(\"ISA circuit two-qubit depth:\", isa_2qubit_depth)\n",
"output[\"twoqubit_depth\"] = isa_2qubit_depth\n",
"\n",
"# Exit now if dry run; don't execute on hardware\n",
"if dry_run:\n",
" import sys\n",
"\n",
" print(\"Exiting before hardware execution since `dry_run` is True.\")\n",
" save_result(output)\n",
" sys.exit(0)\n",
"\n",
"# ## Step 3: Execute quantum experiments on backend\n",
"from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
"\n",
"\n",
"estimator = Estimator(backend, options=estimator_options)\n",
"\n",
"# Submit the underlying Estimator job. Note that this is not the\n",
"# actual function job.\n",
"job = estimator.run([(isa_circuit, isa_observable)])\n",
"print(\"Job ID:\", job.job_id())\n",
"output[\"job_id\"] = job.job_id()\n",
"\n",
"# Wait until job is complete\n",
"hw_results = job.result()\n",
"hw_results_dicts = [pub_result.data.__dict__ for pub_result in hw_results]\n",
"\n",
"# Save hardware results to serverless output dictionary\n",
"output[\"hw_results\"] = hw_results_dicts\n",
"\n",
"# Reorganize expectation values\n",
"hw_expvals = [pub_result_data[\"evs\"].tolist()\n",
" for pub_result_data in hw_results_dicts]\n",
"\n",
"# Save expectation values to Qiskit Serverless\n",
"output[\"hw_expvals\"] = hw_expvals[0]\n",
"\n",
"save_result(output)"
]
},
{
"cell_type": "markdown",
"id": "d7f1776a-a8f6-43a3-85b7-33975c4eeec0",
"metadata": {},
"source": [
"\n",
" \n",
" Aquí está toda la fuente de `./source_files/template_hamiltonian_simulation.py` como un bloque de código.\n",
"\n",
" \n",
" \n",
"\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"
}
},
"nbformat": 4,
"nbformat_minor": 4
}