{
"cells": [
{
"cell_type": "markdown",
"id": "b3e994de-6477-421d-8a9a-6b20d45260ae",
"metadata": {},
"source": [
"---\n",
"title: \"Crie um modelo de função Qiskit para simulação hamiltoniana\"\n",
"description: \"Como criar um programa de transpilagem paralelo e implantá-lo em IBM Quantum Platform para usar como um serviço remoto reutilizável.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Crie um modelo de função Qiskit para simulação 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": [
"Este modelo encapsula um fluxo de trabalho para simular a evolução temporal de um estado inicial em relação a um Hamiltoniano baseado em spin definido pelo usuário e retorna um conjunto de valores esperados especificados usando o complemento [AQC-Tensor](https://qiskit.github.io/qiskit-addon-aqc-tensor/) Qiskit.\n",
"\n",
"Esse modelo é estruturado como um padrão Qiskit com as seguintes etapas:\n",
"\n",
"\n",
"\n",
"#### 1. Coleta de informações e mapeamento do problema\n",
"\n",
"Esta seção recebe como entrada o Hamiltoniano a ser simulado, um estado inicial na forma de um `QuantumCircuit`, um conjunto de observáveis para estimar os valores de expectativa e uma especificação de opções para o complemento AQC. Essa etapa valida se todos os dados de entrada necessários estão presentes e se estão no formato correto.\n",
"\n",
"Os argumentos de entrada são então usados para construir os circuitos e operadores quânticos relevantes para o fluxo de trabalho. Um circuito de destino é criado e uma representação do estado do produto da matriz desse circuito é encontrada usando o complemento AQC. Depois disso, um circuito ansatz é gerado e otimizado usando métodos de rede tensorial, produzindo um circuito final que executa o restante da evolução temporal.\n",
"\n",
"\n",
"\n",
"#### 2. Prepare os circuitos gerados para execução\n",
"\n",
"Os circuitos gerados pelo complemento AQC são então transpilados para execução em um backend escolhido. Uma instância [`EstimatorV2`](../api/qiskit-ibm-runtime/estimator-v2) é criada com um conjunto padrão de opções de atenuação de erros para gerenciar a execução do circuito.\n",
"\n",
"\n",
"\n",
"#### 3. Execução\n",
"\n",
"Por fim, o circuito ansatz é transpilado e executado em uma QPU e coleta estimativas para todos os valores de expectativa especificados, que são retornados em um formato serializável para acesso pelo usuário.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e451f954-1d8f-4687-a7e9-e4b0dfa170f3",
"metadata": {},
"source": [
"\n",
"\n",
"## Escreva o modelo da função\n",
"\n",
"Primeiro, escreva um modelo de função para simulação hamiltoniana que utilize o [complemento AQC-Tensor Qiskit](https://qiskit.github.io/qiskit-addon-aqc-tensor/) para mapear a descrição do problema para um circuito de profundidade reduzida para execução em hardware.\n",
"\n",
"Se você baixar esta página e a visualizar localmente em um editor de blocos de notas, verá que algumas das células de código contêm o [comando mágico ](https://ipython.readthedocs.io/en/stable/interactive/magics.html#cellmagic-writefile)`%%writefile`. Este comando mágico salva o código em `./source_files/template_hamiltonian_simulation.py`, que é o modelo de função que você pode enviar para o e executar remotamente usando Qiskit Serverless.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "115c14aa-5028-46f9-ab19-b49d47519636",
"metadata": {},
"source": [
"\n",
"\n",
"### Coletar e validar as entradas\n",
"\n",
"Comece obtendo as entradas para o modelo. Esse exemplo tem entradas específicas do domínio relevantes para a simulação hamiltoniana (como o hamiltoniano e o observável) e opções específicas do recurso (como o quanto você deseja comprimir as camadas iniciais do circuito de Trotter usando o AQC-Tensor ou opções avançadas para o ajuste fino da supressão e atenuação de erros além dos padrões que fazem parte deste exemplo).\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": [
"Quando o modelo de função está em execução, é útil retornar informações nos logs usando instruções de impressão, para que você possa avaliar melhor o progresso da carga de trabalho. A seguir, um exemplo simples de impressão do site `estimator_options` para que haja um registro das opções reais do Estimator usadas. Há muitos outros exemplos semelhantes em todo o programa para informar o progresso durante a execução, incluindo o valor da função objetiva durante o componente iterativo do AQC-Tensor e a profundidade de dois qubits do circuito final da arquitetura do conjunto de instruções (ISA) destinado à execução no 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",
"#### Valide as entradas\n",
"\n",
"Um aspecto importante para garantir que o modelo possa ser reutilizado em uma variedade de entradas é a validação de entrada. O código a seguir é um exemplo de verificação de que a fidelidade de parada durante o AQC-Tensor foi especificada adequadamente e, caso contrário, retorna uma mensagem de erro informativa sobre como corrigir o erro.\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 as saídas da função\n",
"\n",
"Primeiro, prepare um dicionário para armazenar todas as saídas do modelo de função. As chaves serão adicionadas a esse dicionário durante todo o fluxo de trabalho, e ele será retornado no final do 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",
"### Mapeie o problema e pré-processe o circuito com AQC\n",
"\n",
"A otimização do AQC-Tensor ocorre na etapa 1 de um padrão Qiskit. Primeiro, um estado-alvo é construído. Neste exemplo, ele é construído a partir de um circuito-alvo que evolui o mesmo Hamiltoniano para o mesmo período de tempo que a parte AQC. Em seguida, um ansatz é gerado a partir de um circuito equivalente, mas com menos etapas de Trotter. Na parte principal do algoritmo AQC, esse ansatz é iterativamente aproximado do estado-alvo. Por fim, o resultado é combinado com o restante das etapas de Trotter necessárias para atingir o tempo de evolução desejado.\n",
"\n",
"Observe os exemplos adicionais de registro incorporados no código a seguir.\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",
"### Otimize o circuito final para execução\n",
"\n",
"Após a parte AQC do fluxo de trabalho, o `final_circuit` é [transpilado para o hardware](/docs/guides/transpile#instruction-set-architecture) como de costume.\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",
"#### Saia antecipadamente se estiver usando o modo de execução em seco\n",
"\n",
"Se o modo de execução a seco tiver sido selecionado, o programa será interrompido antes de ser executado no hardware. Isso pode ser útil se, por exemplo, você quiser primeiro inspecionar a profundidade de dois qubits do circuito ISA antes de decidir executar no 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",
"#### Execute o circuito no 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",
"#### Salve a saída\n",
"\n",
"Esse modelo de função retorna o resultado relevante em nível de domínio para esse fluxo de trabalho de simulação hamiltoniana (valores de expectativa), além de metadados importantes gerados ao longo do caminho.\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",
"## Implemente a função em IBM Quantum Platform\n",
"\n",
"A seção anterior criou um programa para ser executado remotamente. O código nesta seção faz o upload desse programa para o Qiskit Serverless.\n",
"\n",
"Use `qiskit-ibm-catalog` para se autenticar em `QiskitServerless` com sua chave de API, que pode ser encontrada no painel da [IBM Quantum Platform](), e faça o upload do programa.\n",
"\n",
"Opcionalmente, você pode usar `save_account()` para salvar suas credenciais (consulte o guia [Configurar sua conta IBM Cloud](/docs/guides/cloud-setup#cloud-save) ). Observe que isso grava suas credenciais no mesmo arquivo 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": [
"Esse programa tem dependências personalizadas do site `pip` . Adicione-os a uma matriz `dependencies` ao criar a instância `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 fim, verifique se o upload do programa foi bem-sucedido, use `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",
"## Execute o modelo de função remotamente\n",
"\n",
"O modelo de função foi carregado, para que você possa executá-lo remotamente com o Qiskit Serverless. Primeiro, carregue o modelo pelo nome:\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": [
"Em seguida, execute o modelo com as entradas em nível de domínio para a simulação hamiltoniana. Esse exemplo especifica um modelo XXZ de 50 qubits com acoplamentos aleatórios e um estado inicial e observável.\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": [
"Verifique o status do trabalho:\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": [
"Depois que o trabalho estiver em execução, você poderá buscar os logs criados a partir das saídas do `print()` . Eles podem fornecer informações acionáveis sobre o progresso do fluxo de trabalho da simulação hamiltoniana. Por exemplo, o valor da função objetiva durante o componente iterativo do AQC ou a profundidade de dois qubits do circuito ISA final destinado à execução no 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": [
"Bloqueia o restante do programa até que um resultado esteja disponível. Depois que o trabalho for concluído, você poderá recuperar os resultados. Isso inclui o resultado em nível de domínio da simulação hamiltoniana (valor de expectativa) e metadados úteis.\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": [
"Depois que o trabalho for concluído, toda a saída de registro estará disponível.\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óximas etapas\n",
"\n",
"\n",
" Para se aprofundar no complemento AQC-Tensor do Qiskit, confira o tutorial [Improved Trotterized Time Evolution with Approximate Quantum Compilation](/docs/tutorials/approximate-quantum-compilation-for-time-evolution) ou o [repositório 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",
" Aqui está todo o código-fonte do `./source_files/template_hamiltonian_simulation.py` como um bloco 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
}