{
"cells": [
{
"cell_type": "markdown",
"id": "0d58aa59",
"metadata": {},
"source": [
"---\n",
"title: \"QESEM - Uma função Qiskit da Qedma\"\n",
"description: \"Execute circuitos quânticos em QPUs ruidosas para obter resultados altamente precisos e sem erros, com sobrecargas de tempo de QPU altamente eficientes, próximas dos limites fundamentais.\"\n",
"---\n",
"\n",
"{/* cspell:ignore DESY Multibase, Quasicrystal, Downfolding, Aharonov, Goldack, wavefunctions, Sakuma */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# QESEM: Uma função Qiskit da Qedma\n",
"\n",
"*Consulte a [referência da API](/docs/api/functions/qedma-qesem)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "6256578e",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"{/*\n",
" DO NOT EDIT THIS CELL!!!\n",
" This cell's content is generated automatically by a script. Anything you add\n",
" here will be removed next time the notebook is run. To add new content, create\n",
" a new cell before or after this one.\n",
" */}\n",
"\n",
"\n",
" \n",
" O código desta página foi desenvolvido com base nos seguintes requisitos.\n",
" Recomendamos o uso dessas versões ou versões mais recentes.\n",
"\n",
" ```\n",
" qiskit[all]~=2.5.0\n",
" qiskit-ibm-runtime~=0.47.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "13528739",
"metadata": {},
"source": [
"\n",
" As funções do Qiskit são um recurso experimental disponível apenas para usuários dos planos IBM Quantum® Premium Plan, Flex Plan e On-Prem (via IBM Quantum Platform API). Eles estão no status de versão prévia e estão sujeitos a alterações.\n",
"\n",
"\n",
"\n",
"\n",
"## Visão geral\n",
"\n",
"Embora as unidades de processamento quântico tenham melhorado significativamente nos últimos anos, os erros causados por ruído e imperfeições no hardware existente continuam sendo um grande desafio para os desenvolvedores de algoritmos quânticos. À medida que o campo se aproxima de cálculos quânticos em escala utilitária que não podem ser verificados classicamente, soluções para cancelar ruídos com precisão garantida estão se tornando cada vez mais importantes. Para superar esse desafio, a Qedma desenvolveu o Quantum Error Mitigation (QESEM), perfeitamente integrado ao IBM Quantum Platform como uma [função Qiskit](/docs/guides/functions).\n",
"\n",
"Com o QESEM, os usuários podem executar seus circuitos quânticos em QPUs sujeitas a ruído para obter resultados altamente precisos e livres de erros, com sobrecargas de tempo de QPU altamente eficientes, próximas aos limites fundamentais. Para isso, o QESEM utiliza um conjunto de métodos proprietários desenvolvidos pela Qedma, destinados à caracterização e à redução de erros. As técnicas de redução de erros incluem otimização de portas, transpilagem sensível ao ruído, supressão de erros (ES) e mitigação imparcial de erros (EM). Com essa combinação de métodos baseados em caracterização, os usuários podem obter resultados confiáveis e sem erros para circuitos quânticos genéricos de grande volume, possibilitando aplicações que não poderiam ser realizadas de outra forma.\n",
"\n",
"Para uma descrição completa dos componentes subjacentes, bem como uma demonstração em escala utilitária, consulte o artigo [Mitigação de erros confiável e de alta precisão para circuitos quânticos em escala utilitária](https://arxiv.org/abs/2508.10997).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5f761442",
"metadata": {},
"source": [
"\n",
"\n",
"## Descrição\n",
"\n",
"Você pode usar a função QESEM da Qedma para estimar e executar facilmente seus circuitos com supressão e atenuação de erros, obtendo maiores volumes de circuitos e maior precisão. Para usar o QESEM, você fornece um circuito quântico, um conjunto de observáveis a serem medidos, uma precisão estatística alvo para cada observável e uma QPU escolhida. Antes de executar o circuito com a precisão desejada, você pode estimar o tempo de QPU necessário com base em um cálculo analítico que não requer a execução do circuito. Quando estiver satisfeito com a estimativa de tempo da QPU, você poderá executar o circuito com o QESEM.\n",
"\n",
"Quando você executa um circuito, o QESEM executa um protocolo de caracterização de dispositivo adaptado ao seu circuito, produzindo um modelo de ruído confiável para os erros que ocorrem no circuito. Com base na caracterização, o QESEM primeiro implementa a transpilagem sensível ao ruído para mapear o circuito de entrada em um conjunto de qubits e portas físicos, o que minimiza o ruído que afeta o observável alvo. Isso inclui os portões disponíveis nativamente (CX/CZ em dispositivos IBM® ), bem como portões adicionais otimizados pela QESEM, formando o conjunto de portões estendido da QESEM. O QESEM então executa um conjunto de circuitos ES e EM baseados em caracterização na QPU e coleta os resultados das medições. Em seguida, eles são processados posteriormente de maneira clássica para fornecer um valor esperado imparcial e uma barra de erro para cada observável, correspondendo à precisão solicitada.\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "74823696",
"metadata": {},
"source": [
"Foi demonstrado que o QESEM fornece resultados de alta precisão para uma variedade de aplicações quânticas e nos maiores volumes de circuitos que podem ser obtidos atualmente. O QESEM oferece os seguintes recursos voltados para o usuário, demonstrados na seção de benchmarks abaixo:\n",
"\n",
"* **Precisão garantida:** o QESEM produz estimativas imparciais para valores esperados de observáveis. Seu método EM é equipado com garantias teóricas que, juntamente com a caracterização de ponta da Qedma, asseguram que a mitigação converge para a saída do circuito sem ruído até a precisão especificada pelo usuário. Em contraste com muitos métodos EM heurísticos que são propensos a erros sistemáticos ou vieses, a precisão garantida do QESEM é essencial para garantir resultados confiáveis em circuitos quânticos genéricos e observáveis.\n",
"* **Escalabilidade para QPUs grandes:** o tempo de QPU do QESEM depende dos volumes dos circuitos, mas é independente do número de qubits. A Qedma demonstrou o QESEM nos maiores dispositivos quânticos disponíveis atualmente, incluindo os dispositivos Eagle de 127 qubits e Heron de 133 qubits da IBM Quantum.\n",
"* **Independente do aplicativo:** O QESEM foi demonstrado em uma variedade de aplicações, incluindo simulação Hamiltoniana, VQE, QAOA e estimativa de amplitude. Os usuários podem inserir qualquer circuito quântico e observável a ser medido e obter resultados precisos e sem erros. As únicas limitações são ditadas pelas especificações de hardware e pelo tempo alocado da QPU, que determinam os volumes de circuito acessíveis e as precisões de saída. Por outro lado, muitas soluções de redução de erros são específicas do aplicativo ou envolvem heurísticas não controladas, o que as torna inaplicáveis a circuitos e aplicativos quânticos genéricos.\n",
"* **Conjunto de portas estendido:** o QESEM suporta portas de ângulo fracionário e fornece portas de ângulo fracionário otimizadas para Qedma ( $Rzz(\\theta)$ ) nos dispositivos IBM Quantum Heron e Eagle. Este conjunto de portas estendido permite uma compilação mais eficiente e desbloqueia volumes de circuito maiores em até 2 vezes em comparação com a compilação CX/CZ padrão.\n",
"* **Observáveis multibase:** O QESEM é compatível com observáveis de entrada compostos por muitas cadeias de Pauli não comutáveis, como Hamiltonianos genéricos. A escolha das bases de medição e a otimização da alocação de recursos da QPU (disparos e circuitos) são então executadas automaticamente pelo QESEM para minimizar o tempo necessário da QPU para a precisão solicitada. Essa otimização, que leva em conta as fidelidades do hardware e as taxas de execução, permite que você execute circuitos mais profundos e obtenha maior precisão.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "57b41ab0",
"metadata": {},
"source": [
"\n",
"\n",
"## Referências\n",
"\n",
"O QESEM foi testado em uma ampla variedade de casos de uso e aplicativos. Os exemplos a seguir podem ajudá-lo a avaliar os tipos de cargas de trabalho que podem ser executados com o QESEM.\n",
"\n",
"Uma figura-chave de mérito para quantificar a dificuldade da mitigação de erros e da simulação clássica para um determinado circuito e observável é o **volume ativo** : o número de portas CNOT que afetam o observável no circuito. O volume ativo depende da profundidade e da largura do circuito, do peso do observável e da estrutura do circuito, que determina o cone de luz do observável. Para obter mais detalhes, consulte a palestra do [2024 IBM Quantum Summit](https://www.youtube.com/watch?v=Hd-IGvuARfE\\&t=1730s). O QESEM oferece um valor particularmente grande no regime de alto volume, fornecendo resultados confiáveis para circuitos e observáveis genéricos.\n",
"\n",
"\n",
"\n",
"| Aplicativo | Número de qubits | Dispositivo | Descrição do circuito | Precisão | Tempo total | Uso de tempo de execução |\n",
"| -------------------------------------- | ---------------- | ------------ | ------------------------------------------------------------------ | -------- | ----------- | ------------------------ |\n",
"| Circuito VQE | 8 | Eagle ( r3 ) | 21 camadas totais, 9 bases de medição, 1D chain | 98% | 35 min | 14 min |\n",
"| Chutou Ising | 28 | Eagle ( r3 ) | 3 camadas exclusivas x 3 etapas, 2D topologia heavy-hex | 97% | 22 min | 4 minutos |\n",
"| Chutou Ising | 28 | Eagle ( r3 ) | 3 camadas exclusivas x 8 etapas, 2D topologia heavy-hex | 97% | 116 min | 23 min |\n",
"| Simulação de Hamiltoniano Trotterizado | 40 | Eagle ( r3 ) | 2 camadas únicas x 10 degraus de Trotter, 1D chain | 97% | 3 horas | 25 min |\n",
"| Simulação de Hamiltoniano Trotterizado | 119 | Eagle ( r3 ) | 3 camadas exclusivas x 9 etapas de Trotter, 2D topologia heavy-hex | 95% | 6.5 horas | 45 min |\n",
"| Chutou Ising | 136 | Garça ( r2 ) | 3 camadas exclusivas x 15 etapas, 2D topologia heavy-hex | em 90% | 52 min | 9 min. |\n",
"\n",
"A precisão é medida aqui em relação ao valor ideal do observável: $\\frac{\\langle O \\rangle_{ideal} - \\epsilon}{\\langle O \\rangle_{ideal}}$, em que ' $\\epsilon$ ' é a precisão absoluta da atenuação (definida pela entrada do usuário), e $\\langle O \\rangle_{ideal}$ é o observável no circuito sem ruído.\n",
"o \"uso do tempo de execução\" mede o uso do parâmetro de comparação no modo de lote (soma do uso de trabalhos individuais), enquanto o \"tempo total\" mede o uso no modo de sessão (tempo de parede do experimento), que inclui tempos clássicos e de comunicação adicionais. O QESEM está disponível para execução em ambos os modos, para que os usuários possam fazer o melhor uso de seus recursos disponíveis.\n",
"\n",
"Os circuitos Kicked Ising de 28 qubits simulam o Discrete Time Quasicrystal estudado por Shinjo et al [arXiv 2403.16718](https://arxiv.org/abs/2403.16718) e [Q2B24 Tokyo](https://www.youtube.com/watch?v=tQW6FdLc6zo) ) em três circuitos conectados de ibm\\_kawasaki. Os parâmetros do circuito adotados aqui são $(\\theta_x, \\theta_z) = (0.9 \\pi, 0)$, com um estado inicial ferromagnético $| \\psi_0 \\rangle = | 0 \\rangle ^{\\otimes n}$. O observável medido é o valor absoluto da magnetização $M = |\\frac{1}{28} \\sum_{i=0}^{27} \\langle Z_i \\rangle|$. O experimento Kicked Ising em escala de utilidade foi executado nos 136 melhores qubits do ibm\\_fez; esse benchmark específico foi executado no ângulo de Clifford $(\\theta_x, \\theta_z) = (\\pi, 0)$, no qual o volume ativo cresce lentamente com a profundidade do circuito, o que - juntamente com as altas fidelidades do dispositivo - permite alta precisão em um curto tempo de execução.\n",
"\n",
"Os circuitos de simulação de hamiltoniano troterizado são para um modelo Ising de campo transversal em ângulos fracionários: $(\\theta_{zz}, \\theta_x) = (\\pi / 4, \\pi /8)$ e $(\\theta_{zz}, \\theta_x) = (\\pi / 6, \\pi / 8)$, respectivamente (consulte [Q2B24 em Tóquio](https://www.youtube.com/watch?v=tQW6FdLc6zo) ). O circuito em escala de utilidade foi executado nos 119 melhores qubits de ibm\\_brisbane, enquanto o experimento de 40 qubits foi executado na melhor cadeia disponível. A precisão é relatada para a magnetização; resultados de alta precisão também foram obtidos para observáveis de maior peso.\n",
"\n",
"O circuito VQE foi desenvolvido em conjunto com pesquisadores do Center for Quantum Technology and Applications do Deutsches Elektronen-Synchrotron (DESY). O observável alvo aqui era um Hamiltoniano que consistia em um grande número de cadeias de Pauli não comutáveis, enfatizando o desempenho otimizado do QESEM para observáveis de várias bases. A atenuação foi aplicada a um ansatz otimizado classicamente; embora esses resultados ainda não tenham sido publicados, resultados da mesma qualidade serão obtidos para diferentes circuitos com propriedades estruturais semelhantes.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d6fb65de",
"metadata": {},
"source": [
"\n",
"\n",
"## Introdução\n",
"\n",
"Autentique-se usando sua [chave de API IBM Quantum Platform](http://quantum.cloud.ibm.com/) e selecione a função QESEM Qiskit da seguinte forma. (Este trecho pressupõe que você já tenha [salvo sua conta](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) no seu ambiente local.)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95a715d2",
"metadata": {},
"outputs": [],
"source": [
"import qiskit\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# verify that you have access to the function\n",
"catalog.list()"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "2d78b033",
"metadata": {},
"outputs": [],
"source": [
"# load the function\n",
"qesem_function = catalog.load(\"qedma/qesem\")"
]
},
{
"cell_type": "markdown",
"id": "5f0120d8",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplos\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7d102971",
"metadata": {},
"source": [
"\n",
"\n",
"### Exemplo de trabalho de estimativa de tempo\n",
"\n",
"A tarefa de estimativa de tempo é útil para estimar o tempo de QPU necessário para um determinado `pub` e `backend_name`. `backend_name` também pode ser configurado para qualquer backend de simulador; por exemplo, `fake_fez`.\n",
"\n",
"O QESEM utiliza um método EM quase-probabilístico, baseado em caracterização. Esse método apresenta uma sobrecarga de tempo da QPU que varia aproximadamente da seguinte forma:\n",
"\n",
"$T_{QPU} = a \\frac{e^{\\alpha IF\\cdot V_a}}{\\epsilon^2} + b$\n",
"\n",
"Onde $V_a$ é o volume ativo do circuito, $\\epsilon$ é a precisão alvo e $IF$ é a infidelidade das portas nativas.\n",
"\n",
"Observe que `\"estimate_time_only\": \"empirical\"` o programa utiliza alguns minutos de tempo de QPU para estimar o tempo necessário para a tarefa (se o backend for um dispositivo real; se for um simulador, não é utilizado tempo de QPU). Isso geralmente leva cerca de 5 minutos, mas não mais do que 10 minutos. Se a infidelidade mudar drasticamente entre a tarefa de estimativa empírica de tempo e a tarefa de mitigação, o tempo de QPU também mudará drasticamente.\n",
"\n",
"Para começar, experimente este exemplo básico de estimativa do tempo de QPU necessário para executar o QESEM para um determinado `pub`:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d56e1440",
"metadata": {},
"outputs": [],
"source": [
"backend_name = \"fake_fez\"\n",
"\n",
"circ = qiskit.QuantumCircuit(5)\n",
"circ.cx(0, 1)\n",
"circ.cx(2, 3)\n",
"circ.cx(1, 2)\n",
"circ.cx(3, 4)\n",
"\n",
"avg_magnetization = qiskit.quantum_info.SparsePauliOp.from_sparse_list(\n",
" [(\"Z\", [q], 1 / 5) for q in range(5)], num_qubits=5\n",
")\n",
"other_observable = qiskit.quantum_info.SparsePauliOp.from_sparse_list(\n",
" [(\"ZZ\", [0, 1], 1.0), (\"XZ\", [1, 4], 0.5)], num_qubits=5\n",
")\n",
"\n",
"time_estimation_job = qesem_function.run(\n",
" pubs=[(circ, [avg_magnetization, other_observable])],\n",
" options={\n",
" \"estimate_time_only\": \"empirical\",\n",
" },\n",
" backend_name=backend_name, # example: \"fake_fez\", \"ibm_fez\"\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "a6eb4bda04796ac5",
"metadata": {
"ExecuteTime": {
"end_time": "2026-05-03T12:04:42.901739Z",
"start_time": "2026-05-03T12:02:20.288020Z"
}
},
"outputs": [],
"source": [
"time_estimate_result = (\n",
" time_estimation_job.result()\n",
") # a list of results per pub (circuit)"
]
},
{
"cell_type": "markdown",
"id": "5ec8053b",
"metadata": {},
"source": [
"O trecho de código a seguir descreve como recuperar diferentes métricas de execução da tarefa de estimativa de tempo (`estimate_time_only` que está definida):\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 106,
"id": "77a9dca8efb1a37b",
"metadata": {
"ExecuteTime": {
"end_time": "2026-05-12T11:22:06.848571Z",
"start_time": "2026-05-12T11:22:06.838844Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The estimated QPU time for mitigation for this PUB is: 300\n",
"The QPU time that this time estimation job took is (here it is 0 because we used fake_fez): 0\n",
"Gates fidelity measured during the experiment: {'CZ': 0.9951354916722668, 'ID1Q': 0.9991246627329172}\n",
"Total shots: 220000\n",
"Resource usage breakdown: {'RUNNING: MAPPING': {'CPU_TIME': 33.6066133165732, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 184.53575124032795, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: EXECUTING_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}}\n"
]
}
],
"source": [
"pub_result = time_estimate_result[0]\n",
"\n",
"print(\n",
" f\"The estimated QPU time for mitigation for this PUB is: {pub_result.metadata['time_estimation_sec']}\"\n",
")\n",
"print(\n",
" f\"The QPU time that this time estimation job took is (here it is 0 because we used fake_fez): {pub_result.metadata['total_qpu_time']}\"\n",
")\n",
"print(\n",
" f\"Gates fidelity measured during the experiment: {pub_result.metadata['gate_fidelities']}\"\n",
")\n",
"print(f\"Total shots: {pub_result.metadata['total_shots']}\")\n",
"print(f\"Resource usage breakdown: {pub_result.metadata['resource_usage']}\")"
]
},
{
"cell_type": "markdown",
"id": "5f68f983189f00a1",
"metadata": {},
"source": [
"Quando a estimativa empírica de tempo está ativada, o QESEM executa um pequeno número de circuitos para fornecer uma estimativa mais precisa do tempo de execução na QPU. Os resultados da mitigação desses circuitos estão disponíveis no `empirical_estimation_mitigation_results` campo do trabalho.\n",
"\n",
"Como esses resultados foram obtidos a partir de uma amostra limitada de circuitos, eles são significativamente menos precisos do que os resultados finais obtidos a partir do trabalho completo de mitigação do QESEM. No entanto, quando o circuito é pequeno ou a precisão alvo é baixa, a mitigação realizada durante a estimativa empírica do tempo pode ser suficiente para atingir a precisão desejada, e talvez não seja necessário realizar todo o processo de mitigação.\n",
"\n",
"O `empirical_estimation_mitigation_results` campo é uma lista de `PrimitiveResult` objetos por parâmetro de entrada. Se o circuito não estiver parametrizado, a lista terá comprimento 1.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "7acca648911dacd5",
"metadata": {
"ExecuteTime": {
"end_time": "2026-05-05T13:41:38.131003Z",
"start_time": "2026-05-05T13:41:38.127666Z"
}
},
"outputs": [],
"source": [
"empirical_estimation_mitigation_results = time_estimate_result[0].metadata[\n",
" \"empirical_estimation_mitigation_results\"\n",
"][0] # a list per parameter"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "60b482803339ce27",
"metadata": {
"ExecuteTime": {
"end_time": "2026-05-05T15:23:58.817671Z",
"start_time": "2026-05-05T15:23:58.811680Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Partial results for the observables:\n",
" Mitigated expectation values: [1.00347302 1.00693905]\n",
" Mitigated error bars: [0.00304061 0.00714276]\n",
" Number of shots used for mitigation: 180000\n",
" Qubit mapping: [[[0, 136], [1, 143], [2, 142], [3, 141], [4, 140]]]\n",
" Number of measurement bases: 2\n",
"\n",
"Results for each observable:\n",
"Observable 1: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" QESEM mitigated value: 1.003473015776871 ± 0.0030406128032204015\n",
"Observable 2: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" QESEM mitigated value: 1.0069390542613554 ± 0.0071427606736885925\n"
]
}
],
"source": [
"print(\"Partial results for the observables:\")\n",
"\n",
"print(\n",
" f\" Mitigated expectation values: {empirical_estimation_mitigation_results.data.evs}\"\n",
")\n",
"print(\n",
" f\" Mitigated error bars: {empirical_estimation_mitigation_results.data.stds}\"\n",
")\n",
"print(\n",
" f\" Number of shots used for mitigation: {empirical_estimation_mitigation_results.metadata['mitigation_shots']}\"\n",
")\n",
"transpiled_circ = empirical_estimation_mitigation_results.metadata[\n",
" \"transpiled_circ\"\n",
"]\n",
"print(f\" Qubit mapping: {transpiled_circ['qubit_maps']}\")\n",
"print(\n",
" f\" Number of measurement bases: {transpiled_circ['num_measurement_bases']}\\n\"\n",
")\n",
"\n",
"# results per obs\n",
"emp_obs_results = empirical_estimation_mitigation_results.metadata[\"results\"][\n",
" 0\n",
"]\n",
"# print(f\"Results for each observable: {results}\")\n",
"print(\"Results for each observable:\")\n",
"\n",
"for i, (obs_array, result_dict) in enumerate(emp_obs_results):\n",
" # obs_array, result_dict = results\n",
" print(f\"Observable {i+1}: {obs_array}\")\n",
" print(\n",
" f\" QESEM mitigated value: {result_dict['qesem']['value']} \\u00b1 {result_dict['qesem']['error_bar']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "ae10a4c8",
"metadata": {},
"source": [
"\n",
"\n",
"### Exemplo de tarefa de mitigação no QESEM\n",
"\n",
"O exemplo a seguir executa um trabalho do QESEM:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e7351d6b",
"metadata": {
"ExecuteTime": {
"end_time": "2026-05-05T13:42:11.391952Z",
"start_time": "2026-05-05T13:42:01.266109Z"
}
},
"outputs": [],
"source": [
"sample_job = qesem_function.run(\n",
" pubs=[(circ, [avg_magnetization, other_observable])],\n",
" backend_name=backend_name, # example: \"ibm_fez\"\n",
" # options = {\n",
" # \"estimate_time_only\": \"empirical\",\n",
" # \"default_precision\": 0.2, # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details\n",
" # \"max_execution_time\": 3600, # You can specify a maximum QPU time in seconds, see API reference for more details\n",
" # \"transpilation_level\": \"standard\", # \"minimal_with_layout_opt\" for minimal transpilation, see API reference for more details\n",
" # \"parallel_execution\": True, # True for parallel execution, see API reference for more details\n",
" # },\n",
")"
]
},
{
"cell_type": "markdown",
"id": "f7f7fe68",
"metadata": {},
"source": [
"Para obter uma descrição detalhada de cada campo de entrada e opção, consulte a [referência da API do QESEM](/docs/api/functions/qedma-qesem).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dfe99043",
"metadata": {},
"source": [
"Você pode usar as APIs conhecidas do Qiskit Serverless para verificar o status da carga de trabalho do Qiskit Function ou retornar resultados:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "856fe992",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3ac6b2df-15b0-4dc0-8f48-cf14bd20a1c8\n",
"DONE\n"
]
}
],
"source": [
"# Print the ID so you can use it later, if necessary\n",
"print(sample_job.job_id)\n",
"print(sample_job.status())\n",
"sample_result = sample_job.result()"
]
},
{
"cell_type": "markdown",
"id": "a9e51542",
"metadata": {},
"source": [
"O trecho de código a seguir demonstra como recuperar os resultados da mitigação e as métricas de execução. Esses dados contêm informações essenciais que permitem uma compreensão mais profunda de como os diferentes parâmetros afetam a execução do QESEM. Isso também pode ser relevante ao redigir um artigo com base em sua pesquisa.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"id": "117c2e4aa624ed51",
"metadata": {
"ExecuteTime": {
"end_time": "2026-05-12T11:23:45.739919Z",
"start_time": "2026-05-12T11:23:45.737884Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"PUB 0:\n",
" The QPU time that this job took is (here it is 0 because we used fake_fez): 0.0\n",
" Gates fidelity measured during the experiment: {'CZ': 0.9953704216147041, 'ID1Q': 0.9991834123567518}\n",
" Total shots: 446000\n",
" Number of shots used for mitigation: 194000\n",
" Resource usage breakdown: {'RUNNING: MAPPING': {'CPU_TIME': 32.52745003718883, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 257.850521848537, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: EXECUTING_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}}\n"
]
}
],
"source": [
"for pub_idx, pub_result in enumerate(\n",
" sample_result\n",
"): # each element in the list is a result for a different pub, here we sent only one pub\n",
" print(f\"\\nPUB {pub_idx}:\")\n",
" print(\n",
" f\" The QPU time that this job took is (here it is 0 because we used fake_fez): {pub_result.metadata['total_qpu_time']}\"\n",
" )\n",
" print(\n",
" f\" Gates fidelity measured during the experiment: {pub_result.metadata['gate_fidelities']}\"\n",
" )\n",
" print(f\" Total shots: {pub_result.metadata['total_shots']}\")\n",
" print(\n",
" f\" Number of shots used for mitigation: {pub_result.metadata['mitigation_shots']}\"\n",
" )\n",
" print(\n",
" f\" Resource usage breakdown: {pub_result.metadata['resource_usage']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "3f71cc3a",
"metadata": {},
"source": [
"`metadata[\"results\"]`Nesse caso, os resultados são agrupados primeiro por instância do circuito e, em seguida, por observável.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 99,
"id": "a5899795",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Full QESEM mitigation results:\n",
"\n",
"PUB 0:\n",
" Mitigated expectation values: [1.00648343 1.00636289]\n",
" Mitigated error bars: [0.00253812 0.00693586]\n",
" Unmitigated expectation values: [0.98031429 0.96357143]\n",
" Unmitigated error bars: [0.00124128 0.00578812]\n",
" Transpiled circuits:\n",
" Circuit 0:\n",
" Qubit mapping: [[[0, 140], [1, 141], [2, 142], [3, 143], [4, 136]]]\n",
" Measurement bases: 2\n",
" Results for each observable:\n",
" Circuit 0:\n",
" Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" QESEM mitigated value: 1.0064834305181962 ± 0.002538119914534849\n",
" Unmitigated value: 0.9803142857142859 ± 0.0012412835813609938\n",
" Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" QESEM mitigated value: 1.0063628870614818 ± 0.006935859820870656\n",
" Unmitigated value: 0.9635714285714285 ± 0.005788121870526659\n"
]
}
],
"source": [
"print(\"Full QESEM mitigation results:\")\n",
"\n",
"for pub_idx, pub_result in enumerate(sample_result):\n",
" print(f\"\\nPUB {pub_idx}:\")\n",
"\n",
" print(f\" Mitigated expectation values: {pub_result.data.evs}\")\n",
" print(f\" Mitigated error bars: {pub_result.data.stds}\")\n",
" noisy_results = pub_result.metadata.get(\"noisy_results\")\n",
" print(f\" Unmitigated expectation values: {noisy_results.evs}\")\n",
" print(f\" Unmitigated error bars: {noisy_results.stds}\")\n",
"\n",
" print(\" Transpiled circuits:\")\n",
" for circ_idx, transpiled_circ in enumerate(\n",
" pub_result.metadata[\"transpiled_circs\"]\n",
" ):\n",
" print(f\" Circuit {circ_idx}:\")\n",
" # print(f\" Circuit: \\n {transpiled_circ['circuit']}\") # not printing it because it's long but you can see the transpiled circuit itself\n",
" print(f\" Qubit mapping: {transpiled_circ['qubit_maps']}\")\n",
" print(\n",
" f\" Measurement bases: {transpiled_circ['num_measurement_bases']}\"\n",
" )\n",
"\n",
" print(\" Results for each observable:\")\n",
" for circ_idx, circ_results in enumerate(pub_result.metadata[\"results\"]):\n",
" print(f\" Circuit {circ_idx}:\")\n",
" for obs_idx, (obs_array, result_dict) in enumerate(circ_results):\n",
" print(f\" Observable {obs_idx}: {obs_array}\")\n",
" print(\n",
" f\" QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}\"\n",
" )\n",
" print(\n",
" f\" Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "345524a3",
"metadata": {},
"source": [
"**Discriminação dos principais resultados:**\n",
"\n",
"* `mitigated`: o valor esperado do QESEM totalmente mitigado.\n",
"* `unmitigated`: o resultado bruto do ruído físico sem mitigação de erros.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "65a2e503",
"metadata": {},
"source": [
"\n",
"\n",
"#### Resultados da extrapolação heurística do QESEM\n",
"\n",
"Em uma execução padrão do QESEM com um único `precision` flutuador, os resultados também incluem pontos de escala de ruído disponíveis automaticamente, que são utilizados para a heurística do QESEM. Esses pontos são calculados sem recursos adicionais da QPU.\n",
"\n",
"A escala `1.0` representa o nível de ruído do dispositivo físico com mitigação de leitura (REM), enquanto a escala `2.0` corresponde ao ponto complementar com amplificação de ruído, também com REM. Esses pontos são utilizados para gerar o `qesem_heuristic` resultado.\n",
"\n",
"* `qesem_heuristic`: uma estimativa do tipo ZNE calculada a partir dos dados disponíveis, ajustados em função do ruído. Atualmente, isso utiliza extrapolação exponencial.\n",
"* `noise_scaling.results_with_REM`: valores esperados em diferentes escalas de ruído, todos com mitigação de leitura (REM).\n",
"\n",
"Um detalhe sutil, mas importante, é que o resultado da escala `1.0` não é o mesmo que o `unmitigated` resultado. Ambos correspondem ao nível de ruído do dispositivo físico, mas o ponto da escala `1.0` inclui a mitigação da leitura, enquanto `unmitigated` não inclui.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 101,
"id": "21afd3d2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QESEM heuristic results:\n",
"\n",
"PUB 0:\n",
" Circuit 0:\n",
" Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" QESEM heuristic:\n",
" Value: 1.0008161638888535 ± 0.0038859458884403964\n",
" Extrapolation: exponential\n",
" Scale factors: [1.0, 2.0]\n",
" Noise scaling results:\n",
" Scaling method: QESEM\n",
" Results with Readout mitigation (REM):\n",
" Scale factor 1.0: 0.9918395459270772 ± 0.0012565417579355634\n",
" Scale factor 2.0: 0.982943441922748 ± 0.0028919278067695018\n",
" Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" QESEM heuristic:\n",
" Value: 0.9960853148925298 ± 0.013811635038961175\n",
" Extrapolation: exponential\n",
" Scale factors: [1.0, 2.0]\n",
" Noise scaling results:\n",
" Scaling method: QESEM\n",
" Results with Readout mitigation (REM):\n",
" Scale factor 1.0: 0.9902860583785115 ± 0.005921236914723409\n",
" Scale factor 2.0: 0.984520565414274 ± 0.006909522262347639\n"
]
}
],
"source": [
"print(\"QESEM heuristic results:\")\n",
"\n",
"for pub_idx, pub_result in enumerate(sample_result):\n",
" print(f\"\\nPUB {pub_idx}:\")\n",
" for circ_idx, circ_results in enumerate(pub_result.metadata[\"results\"]):\n",
" print(f\" Circuit {circ_idx}:\")\n",
" for obs_idx, (obs_array, result_dict) in enumerate(circ_results):\n",
" print(f\" Observable {obs_idx}: {obs_array}\")\n",
" qesem_heuristic = result_dict[\"qesem_heuristic\"][0]\n",
" print(\" QESEM heuristic:\")\n",
" print(\n",
" f\" Value: {qesem_heuristic['value']} ± {qesem_heuristic['error_bar']}\"\n",
" )\n",
" print(\n",
" f\" Extrapolation: {qesem_heuristic['extrapolation']}\"\n",
" )\n",
" print(\n",
" f\" Scale factors: {qesem_heuristic['scale_factors']}\"\n",
" )\n",
" noise_scaling = result_dict[\"noise_scaling\"]\n",
" print(\" Noise scaling results:\")\n",
" print(\n",
" f\" Scaling method: {noise_scaling['scaling_method']}\"\n",
" )\n",
" print(\" Results with Readout mitigation (REM):\")\n",
" for rem_result in sorted(\n",
" (\n",
" item\n",
" for item in noise_scaling[\"results_with_REM\"]\n",
" if item[\"scale\"] != 0.0\n",
" ),\n",
" key=lambda item: item[\"scale\"],\n",
" ):\n",
" print(\n",
" f\" Scale factor {rem_result['scale']}: {rem_result['value']} ± {rem_result['error_bar']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "899d229a",
"metadata": {},
"source": [
"\n",
" Os exemplos a seguir se concentram em entradas e resultados específicos de cada recurso; portanto, não exibem todas as métricas de execução a cada vez. Os metadados de nível superior mostrados anteriormente, como total\\_qpu\\_time, gate\\_fidelities, total\\_chutes, medidas\\_de\\_mitigação e uso\\_de\\_recursos, também estão disponíveis para esses trabalhos.\n",
"\n",
" Algumas variáveis dos exemplos anteriores, incluindo o backend, os observáveis e os parâmetros do circuito base, são reutilizadas a seguir para maior concisão.\n",
"\n",
"\n",
"\n",
" Todos os exemplos a seguir também podem ser executados com estimativa empírica de tempo. Para ativá-lo, passe `\"estimate_time_only\": \"empírico\"` nas opções da função.\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "079cb5be",
"metadata": {},
"source": [
"\n",
"\n",
"### Exemplo de circuito parametrizado\n",
"\n",
"Muitos algoritmos avaliam o mesmo circuito com vários valores de parâmetros. O envio do circuito parametrizado como um único trabalho no QESEM permite que o QESEM compartilhe a caracterização e a calibração entre as instâncias do circuito, o que pode reduzir a sobrecarga de tempo de QPU em comparação com a execução de trabalhos separados.\n",
"\n",
"Para enviar um circuito parametrizado, é necessário utilizar o `\"minimal_with_layout_opt\"` nível de transpilação.\n",
"Os circuitos enviados neste nível já devem estar expressos utilizando as portas básicas do backend, dependendo do backend. Nesse nível, o QESEM mantém a estrutura enviada o mais próxima possível do circuito de entrada, respeita as barreiras durante a estratificação (agrupamento de operações em camadas de portas paralelas de dois qubits) e ainda lida automaticamente com o mapeamento de hardware para qubits de alta fidelidade e com a conectividade dos dispositivos.\n",
"\n",
"Na prática, isso significa que você deve transpilá-los para as portas básicas do backend de destino antes do envio. Segue abaixo um exemplo simples de transpilagem de porta de base.\n",
"\n",
"Atualmente, o QESEM suporta apenas uma variável observável por conjunto de parâmetros. As duas linhas de parâmetros abaixo estão associadas aos dois observáveis: a primeira linha é medida com `avg_magnetization`, e a segunda linha é medida com `other_observable`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "704f8aa5",
"metadata": {},
"outputs": [],
"source": [
"# Transpile to the backend basis gates only. With minimal_with_layout_opt, QESEM handles hardware mapping/connectivity and observable layout internally.\n",
"from qiskit_ibm_runtime.fake_provider import FakeFez\n",
"\n",
"backend = FakeFez()\n",
"basis = backend.operation_names\n",
"print(basis)\n",
"\n",
"param0 = qiskit.circuit.Parameter(\"param0\")\n",
"param1 = qiskit.circuit.Parameter(\"param1\")\n",
"parametrized_circ = qiskit.QuantumCircuit(5)\n",
"parametrized_circ.rx(param0, 0)\n",
"parametrized_circ.rx(param1, 1)\n",
"parametrized_circ.cx(0, 1)\n",
"parametrized_circ.cx(2, 3)\n",
"parametrized_circ.cx(1, 2)\n",
"parametrized_circ.cx(3, 4)\n",
"\n",
"parametrized_circ = qiskit.transpile(\n",
" parametrized_circ, basis_gates=basis, optimization_level=1\n",
")\n",
"parametrized_parameter_values = [[0.5, 0.1], [0.0, 0.6]]\n",
"parametrized_observables = [avg_magnetization, other_observable]\n",
"\n",
"parametrized_job = qesem_function.run(\n",
" pubs=[\n",
" (\n",
" parametrized_circ,\n",
" parametrized_observables,\n",
" parametrized_parameter_values,\n",
" 0.1,\n",
" )\n",
" ],\n",
" backend_name=backend_name,\n",
" options={\n",
" \"max_execution_time\": 300,\n",
" \"transpilation_level\": \"minimal_with_layout_opt\",\n",
" },\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 72,
"id": "85a452fc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"d1b0e29b-196c-4896-aec6-44a268ebd874\n",
"DONE\n"
]
}
],
"source": [
"print(parametrized_job.job_id)\n",
"print(parametrized_job.status())"
]
},
{
"cell_type": "code",
"execution_count": 73,
"id": "244cd3b2",
"metadata": {},
"outputs": [],
"source": [
"parametrized_result = parametrized_job.result()"
]
},
{
"cell_type": "code",
"execution_count": 77,
"id": "03399db5",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Parameterized circuit QESEM results:\n",
"\n",
"PUB 0:\n",
" Mitigated expectation values: [0.92392021 0.82517653]\n",
" Mitigated error bars: [0.00565281 0.00616016]\n",
" Unmitigated expectation values: [0.9028 0.78771429]\n",
" Unmitigated error bars: [0.00335142 0.00925413]\n",
" Results for each parameter value:\n",
" Parameter set 0: [0.5, 0.1]\n",
" Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" QESEM mitigated value: 0.923920210615709 ± 0.005652811570890183\n",
" Unmitigated value: 0.9028 ± 0.0033514176105045447\n",
" Parameter set 1: [0.0, 0.6]\n",
" Observable 0: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" QESEM mitigated value: 0.8251765289285893 ± 0.006160161743353999\n",
" Unmitigated value: 0.7877142857142858 ± 0.009254130564027902\n"
]
}
],
"source": [
"print(\"Parameterized circuit QESEM results:\")\n",
"\n",
"for pub_idx, pub_result in enumerate(parametrized_result):\n",
" print(f\"\\nPUB {pub_idx}:\")\n",
" print(f\" Mitigated expectation values: {pub_result.data.evs}\")\n",
" print(f\" Mitigated error bars: {pub_result.data.stds}\")\n",
" noisy_results = pub_result.metadata[\"noisy_results\"]\n",
" print(f\" Unmitigated expectation values: {noisy_results.evs}\")\n",
" print(f\" Unmitigated error bars: {noisy_results.stds}\")\n",
" print(\" Results for each parameter value:\")\n",
" for param_idx, param_results in enumerate(pub_result.metadata[\"results\"]):\n",
" print(\n",
" f\" Parameter set {param_idx}: {parametrized_parameter_values[param_idx]}\"\n",
" )\n",
" for obs_idx, (obs_array, result_dict) in enumerate(param_results):\n",
" print(f\" Observable {obs_idx}: {obs_array}\")\n",
" print(\n",
" f\" QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}\"\n",
" )\n",
" print(\n",
" f\" Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "d6d1b6c2",
"metadata": {},
"source": [
"\n",
"\n",
"### Exemplo de “multi-pub”\n",
"\n",
"A execução em múltiplos pubs é útil quando se deseja executar vários circuitos relacionados em um único trabalho do QESEM. Assim como a execução parametrizada, isso pode reduzir a sobrecarga, pois o QESEM pode compartilhar a caracterização e a calibração entre instâncias do circuito, em vez de repeti-las em tarefas separadas.\n",
"\n",
"Isso é especialmente útil para circuitos com uma estrutura de camadas compartilhadas, como cargas de trabalho **do tipo Trotter**, nas quais diferentes circuitos reutilizam as mesmas camadas únicas. Nesse caso, a execução conjunta dessas análises pode reduzir o custo da caracterização em comparação com trabalhos independentes de QESEM.\n",
"\n",
"Trabalhos com publicação em vários veículos exigem `\"transpilation_level\": \"minimal_with_layout_opt\"`. Assim como no exemplo parametrizado, os circuitos devem ser transpilados para as portas básicas do backend de destino antes do envio. O QESEM, então, lida internamente com a conectividade dos dispositivos, o layout e o mapeamento para qubits de alta fidelidade.\n",
"\n",
"Cada `PUB` abaixo contém um circuito e os mesmos dois observáveis usados anteriormente neste notebook; portanto, o resultado retornado `PrimitiveResult` contém um `PubResult` por circuito de entrada.\n",
"\n",
"O exemplo abaixo utiliza dois circuitos de Trotter simples com o mesmo padrão de camadas: `circ_a` possui uma camada de Trotter, e `circ_b` repete o mesmo padrão de camadas duas vezes. Isso torna a estrutura compartilhada explícita.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8cc663fc",
"metadata": {},
"outputs": [],
"source": [
"def make_trotter_circuit(num_qubits, num_layers, zz_angle=0.2, x_angle=0.1):\n",
" trotter_circ = qiskit.QuantumCircuit(num_qubits)\n",
" for _ in range(num_layers):\n",
" for q in range(num_qubits):\n",
" trotter_circ.rx(x_angle, q)\n",
" trotter_circ.barrier()\n",
" for q in range(0, num_qubits - 1, 2):\n",
" trotter_circ.rzz(zz_angle, q, q + 1)\n",
" trotter_circ.barrier()\n",
" for q in range(1, num_qubits - 1, 2):\n",
" trotter_circ.rzz(zz_angle, q, q + 1)\n",
" trotter_circ.barrier()\n",
" return trotter_circ\n",
"\n",
"\n",
"circ_a = make_trotter_circuit(num_qubits=5, num_layers=1)\n",
"circ_b = make_trotter_circuit(num_qubits=5, num_layers=2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "371c4893",
"metadata": {},
"outputs": [],
"source": [
"multi_pubs = [\n",
" (\n",
" qiskit.transpile(qci, basis_gates=basis, optimization_level=1),\n",
" [avg_magnetization, other_observable],\n",
" )\n",
" for qci in [circ_a, circ_b]\n",
"]\n",
"\n",
"multi_circ_job = qesem_function.run(\n",
" pubs=multi_pubs,\n",
" backend_name=backend_name,\n",
" options={\n",
" \"max_execution_time\": 300,\n",
" \"transpilation_level\": \"minimal_with_layout_opt\",\n",
" \"default_precision\": 0.1,\n",
" },\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 91,
"id": "92e45737",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"e34565b8-7262-4133-a120-de42ce624a99\n",
"DONE\n"
]
}
],
"source": [
"print(multi_circ_job.job_id)\n",
"print(multi_circ_job.status())"
]
},
{
"cell_type": "code",
"execution_count": 92,
"id": "23c61008",
"metadata": {},
"outputs": [],
"source": [
"multi_circ_result = multi_circ_job.result()"
]
},
{
"cell_type": "code",
"execution_count": 105,
"id": "1ae6f8c3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Multi-pub QESEM results:\n",
"\n",
"PUB 0:\n",
" Mitigated expectation values: [0.99502406 1.02209332]\n",
" Mitigated error bars: [0.00483819 0.00707488]\n",
" Unmitigated expectation values: [0.96934286 0.97271429]\n",
" Unmitigated error bars: [0.00124855 0.00617294]\n",
" Results for each observable:\n",
" Circuit 0:\n",
" Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" QESEM mitigated value: 0.9950240647925642 ± 0.004838188086259301\n",
" Unmitigated value: 0.9693428571428573 ± 0.0012485470362492692\n",
" Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" QESEM mitigated value: 1.0220933230604674 ± 0.007074884384355636\n",
" Unmitigated value: 0.9727142857142859 ± 0.006172939375512439\n",
"\n",
"PUB 1:\n",
" Mitigated expectation values: [0.98850017 1.02555188]\n",
" Mitigated error bars: [0.0077912 0.01672652]\n",
" Unmitigated expectation values: [0.93682857 0.95371429]\n",
" Unmitigated error bars: [0.00156245 0.00665735]\n",
" Results for each observable:\n",
" Circuit 0:\n",
" Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" QESEM mitigated value: 0.988500171577252 ± 0.007791203181151346\n",
" Unmitigated value: 0.9368285714285716 ± 0.001562451883089579\n",
" Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" QESEM mitigated value: 1.02555188098689 ± 0.016726524388086233\n",
" Unmitigated value: 0.9537142857142858 ± 0.006657345655544263\n"
]
}
],
"source": [
"print(\"Multi-pub QESEM results:\")\n",
"\n",
"for pub_idx, pub_result in enumerate(multi_circ_result):\n",
" print(f\"\\nPUB {pub_idx}:\")\n",
" print(f\" Mitigated expectation values: {pub_result.data.evs}\")\n",
" print(f\" Mitigated error bars: {pub_result.data.stds}\")\n",
" noisy_results = pub_result.metadata[\"noisy_results\"]\n",
" print(f\" Unmitigated expectation values: {noisy_results.evs}\")\n",
" print(f\" Unmitigated error bars: {noisy_results.stds}\")\n",
" print(\" Results for each observable:\")\n",
" for circ_idx, circ_results in enumerate(pub_result.metadata[\"results\"]):\n",
" print(f\" Circuit {circ_idx}:\")\n",
" for obs_idx, (obs_array, result_dict) in enumerate(circ_results):\n",
" print(f\" Observable {obs_idx}: {obs_array}\")\n",
" print(\n",
" f\" QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}\"\n",
" )\n",
" print(\n",
" f\" Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "8f28d826",
"metadata": {},
"source": [
"\n",
"\n",
"### Exemplo de Ajuste de Erro Quase-Probabilístico (QET)\n",
"\n",
"O Ajuste de Erro Quase-Probabilístico (QET) solicita valores esperados em fatores de escala de ruído selecionados. Isso é útil para estudos de escalonamento de ruído personalizados e fluxos de trabalho de extrapolação com ruído zero. A escala `1.0` representa o nível físico de ruído; valores entre `0.0` e `1.0` reduzem parcialmente o ruído, enquanto valores acima de `1.0` amplificam o ruído.\n",
"\n",
"Para usar o QET com a função Qiskit, passe um dicionário como a precisão do `PUB`. O dicionário mapeia cada escala de ruído solicitada para sua precisão alvo. Os resultados do fator de escala retornados são armazenados em `noise_scaling.results_with_REM` e incluem a mitigação da leitura. O ponto na escala `1.0` , portanto, não é idêntico ao valor não mitigado, pois `1.0` inclui a mitigação da leitura, enquanto `unmitigated` não inclui.\n",
"\n",
"Quando uma escala é solicitada, o QESEM também retorna a escala complementar em torno de `1.0` sem consumo adicional de QPU. Por exemplo, a solicitação `0.5` de também pode retornar `1.5`, e a solicitação `1.3` de também pode retornar `0.7`. A precisão na escala complementar não é garantida.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 88,
"id": "723cdf95",
"metadata": {},
"outputs": [],
"source": [
"noise_scale_precision = {0.5: 0.15, 1.3: 0.2}\n",
"\n",
"qet_job = qesem_function.run(\n",
" pubs=[\n",
" (\n",
" circ,\n",
" [avg_magnetization, other_observable],\n",
" None,\n",
" noise_scale_precision,\n",
" )\n",
" ],\n",
" backend_name=backend_name,\n",
" options={\"max_execution_time\": 300},\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 95,
"id": "d68a015c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8195fa58-f037-4651-8715-36ce1cdc5521\n",
"DONE\n"
]
}
],
"source": [
"print(qet_job.job_id)\n",
"print(qet_job.status())"
]
},
{
"cell_type": "code",
"execution_count": 96,
"id": "927d8543",
"metadata": {},
"outputs": [],
"source": [
"qet_result = qet_job.result()"
]
},
{
"cell_type": "code",
"execution_count": 104,
"id": "1c9ba079",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QET noise-scaling results:\n",
"\n",
"PUB 0:\n",
" Unmitigated expectation values: [0.97822857 0.96171429]\n",
" Unmitigated error bars: [0.00123812 0.00672958]\n",
" Results for each observable:\n",
" Circuit 0:\n",
" Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())\n",
" Scaling method: QESEM\n",
" Results with Readout mitigation (REM):\n",
" Scale factor 0.5: 0.9938730340199383 ± 0.0032116907357568275\n",
" Scale factor 0.7: 0.9963976191853445 ± 0.00036300258869586616\n",
" Scale factor 1.0: 0.9898115079506586 ± 0.0012525947426560995\n",
" Scale factor 1.3: 0.9864667065580341 ± 0.002633221613518526\n",
" Scale factor 1.5: 0.9838755527197551 ± 0.002948417797996015\n",
" Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())\n",
" Scaling method: QESEM\n",
" Results with Readout mitigation (REM):\n",
" Scale factor 0.5: 1.0006538544450332 ± 0.002121742014777343\n",
" Scale factor 0.7: 1.0004159801523036 ± 0.0021671375357823794\n",
" Scale factor 1.0: 0.9898058846339917 ± 0.00690183710903159\n",
" Scale factor 1.3: 0.9948946719997267 ± 0.002146532859610311\n",
" Scale factor 1.5: 0.9927220368192772 ± 0.0020875057190323882\n"
]
}
],
"source": [
"print(\"QET noise-scaling results:\")\n",
"\n",
"for pub_idx, pub_result in enumerate(qet_result):\n",
" print(f\"\\nPUB {pub_idx}:\")\n",
" noisy_results = pub_result.metadata[\"noisy_results\"]\n",
" print(f\" Unmitigated expectation values: {noisy_results.evs}\")\n",
" print(f\" Unmitigated error bars: {noisy_results.stds}\")\n",
" print(\" Results for each observable:\")\n",
" for circ_idx, circ_results in enumerate(pub_result.metadata[\"results\"]):\n",
" print(f\" Circuit {circ_idx}:\")\n",
" for obs_idx, (obs_array, result_dict) in enumerate(circ_results):\n",
" print(f\" Observable {obs_idx}: {obs_array}\")\n",
" noise_scaling = result_dict[\"noise_scaling\"]\n",
" print(\n",
" f\" Scaling method: {noise_scaling['scaling_method']}\"\n",
" )\n",
" print(\" Results with Readout mitigation (REM):\")\n",
" for rem_result in sorted(\n",
" (\n",
" item\n",
" for item in noise_scaling[\"results_with_REM\"]\n",
" if item[\"scale\"] != 0.0\n",
" ),\n",
" key=lambda item: item[\"scale\"],\n",
" ):\n",
" print(\n",
" f\" Scale factor {rem_result['scale']}: {rem_result['value']} ± {rem_result['error_bar']}\"\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "35aed54a",
"metadata": {},
"source": [
"\n",
"\n",
"## Buscar mensagens de erro\n",
"\n",
"Se o status da sua carga de trabalho for ERROR, use `job.result()` para obter a mensagem de erro da seguinte maneira:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d95a3f30",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(), stds=np.ndarray(), shape=(2,)), metadata={'gate_fidelities': {'CZ': 0.9979444718552628, 'ID1Q': 0.9991994239814883}, 'total_shots': 498600, 'mitigation_shots': 223400, 'transpiled_circs': [{'circuit': 'OPENQASM 3.0;\\ninclude \"stdgates.inc\";\\nbit[76] c0;\\nqubit[76] q0;\\nrx(0) q0[54];\\nrx(0) q0[59];\\nrx(0) q0[75];\\nrz(pi/2) q0[54];\\nrz(pi/2) q0[59];\\nrz(pi/2) q0[75];\\nrx(pi/2) q0[54];\\nr... (truncated 3771 characters)\n"
]
}
],
"source": [
"# Get the result and truncate for readability\n",
"result = sample_job.result()\n",
"result_str = str(result)\n",
"max_length = 500 # Adjust this value as necessary\n",
"\n",
"if len(result_str) > max_length:\n",
" truncated = (\n",
" result_str[:max_length]\n",
" + f\"... (truncated {len(result_str) - max_length} characters)\"\n",
" )\n",
"else:\n",
" truncated = result_str\n",
"\n",
"print(truncated)"
]
},
{
"cell_type": "markdown",
"id": "e9ec2e67",
"metadata": {},
"source": [
"\n",
"\n",
"## Obtenha suporte\n",
"\n",
"A equipe de suporte da Qedma está aqui para ajudar! Se você encontrar algum problema ou tiver dúvidas sobre o uso da função Qiskit da QESEM, não hesite em entrar em contato. Nossa equipe de suporte experiente e amigável está pronta para ajudá-lo com qualquer dúvida técnica ou questionamento que você possa ter.\n",
"\n",
"Você pode nos enviar um e-mail para [support@qedma.com](mailto:support@qedma.com) para obter assistência. Inclua o máximo de detalhes possível sobre o problema que está enfrentando para nos ajudar a fornecer uma resposta rápida e precisa. Você também pode entrar em contato com seu representante POC dedicado da Qedma por e-mail ou telefone.\n",
"\n",
"Para nos ajudar a ajudá-lo de forma mais eficiente, forneça as seguintes informações ao entrar em contato conosco:\n",
"\n",
"* Uma descrição detalhada do problema\n",
"* O ID da tarefa\n",
"* Quaisquer mensagens ou códigos de erro relevantes\n",
"\n",
"Temos o compromisso de fornecer suporte imediato e eficaz para garantir que você tenha a melhor experiência possível com a nossa função Qiskit.\n",
"\n",
"Estamos sempre buscando melhorar nosso produto e agradecemos suas sugestões! Se você tiver ideias sobre como podemos melhorar nossos serviços ou recursos que gostaria de ver, envie-nos suas sugestões para [support@qedma.com](mailto:support@qedma.com).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5a6a25c8",
"metadata": {},
"source": [
"\n",
"\n",
"## Próximas etapas\n",
"\n",
"\n",
" * [Solicite acesso ao Qedma QESEM](/functions?id=qedma-qesem).\n",
" * Consulte a [referência da API](/docs/api/functions/qedma-qesem) para esta função do Qiskit.\n",
" * Experimente o tutorial [“Simulação de um modelo de Ising de campo inclinado com 2D ” utilizando a função QESEM](/docs/tutorials/qedma-2d-ising-with-qesem).\n",
" * Revisão [Aharonov, D., et al. (2025). Mitigação de erros confiável e de alta precisão para circuitos quânticos em escala utilitária. arXiv pré-impressão arXiv:2508.10997](https://arxiv.org/pdf/2508.10997).\n",
" * Resenha [Aharonov, D., et al. (2025). Mitigação de erros lógicos com reconhecimento da síndrome. arXiv pré-impressão arXiv:2508.10997](https://arxiv.org/pdf/2508.10997).\n",
" * Resenha [Aharonov, D., et al. (2025). Sobre a importância da mitigação de erros na computação quântica. arXiv pré-impressão arXiv:2512.23810](https://arxiv.org/abs/2512.23810).\n",
" * Revisão [Bauman, N. P., et al. (2025). Teoria do Downfolding de Clusters Acoplados em Simulações de Sistemas Químicos em Hardware Quântico. arXiv pré-impressão arXiv:2507.01199](https://arxiv.org/pdf/2507.01199).\n",
" * Resenha [Goldack, M., et al. (2026). Cálculo de propriedades estatísticas de campos de velocidade em hardware quântico atual. arXiv pré-impressão arXiv:2601.10166](https://arxiv.org/pdf/2601.10166).\n",
" * Resenha [Sakuma, R., et al. (2026). Análise da simetria de grupos pontuais de funções de onda com muitos elétrons em um computador quântico arXiv pré-impressão arXiv:2605.24824](https://arxiv.org/abs/2605.24824).\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": 5
}