{
"cells": [
{
"cell_type": "markdown",
"id": "d2c31ae8",
"metadata": {},
"source": [
"---\n",
"title: \"Corte de fios para estimativa de valores esperados\"\n",
"description: \"Use o corte de fios para dividir os circuitos em vários subcircuitos menores.\"\n",
"---\n",
"\n",
"{/* cspell:ignore edgecolor Cutqc forall fontsize */}\n",
"\n",
"\n",
"\n",
"# Corte de fios para estimativa de valores esperados\n",
"\n",
"*Estimativa de tempo de execução: 22 segundos em um processador Heron (NOTA: Trata-se apenas de uma estimativa. (O tempo de execução pode variar.)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8bf80006",
"metadata": {},
"source": [
"\n",
"\n",
"## Resultados do aprendizado\n",
"\n",
"Após concluir este tutorial, os usuários deverão compreender:\n",
"\n",
"* Como usar [`qiskit-addon-cutting`](https://github.com/Qiskit/qiskit-addon-cutting) para dividir um circuito grande em subcircuitos menores, reduzindo assim o efeito do ruído\n",
"\n",
"\n",
"\n",
"## Pré-requisitos\n",
"\n",
"Recomendamos que os usuários estejam familiarizados com o seguinte tópico antes de seguir com este tutorial:\n",
"\n",
"* Utilizando a primitiva [Sampler](/docs/api/qiskit-ibm-runtime/sampler-v2), que é usada neste fluxo de trabalho\n",
"\n",
"\n",
"\n",
"## Segundo plano\n",
"\n",
"A “tricotagem de circuitos” é um termo genérico que abrange vários métodos de divisão de um circuito em vários subcircuitos menores, envolvendo menos portas lógicas ou qubits. Cada um dos subcircuitos pode ser executado de forma independente, e o resultado final é obtido por meio de um pós-processamento clássico aplicado aos resultados de cada subcircuito. Essa técnica está disponível no [complemento](https://qiskit.github.io/qiskit-addon-cutting/index.html) Circuit cutting do Qiskit; consulte a [documentação](https://qiskit.github.io/qiskit-addon-cutting/explanation/index.html) e outros [materiais introdutórios](https://qiskit.github.io/qiskit-addon-cutting/tutorials/index.html) para obter uma explicação detalhada sobre a técnica.\n",
"\n",
"Este tutorial aborda um método chamado “**corte por fio** ”, no qual o circuito é dividido ao longo do fio [\\[1\\], \\[2\\]](#references). Observe que a divisão em partes é simples nos circuitos clássicos, uma vez que o resultado no ponto de divisão pode ser determinado de forma determinística e é 0 ou 1. No entanto, o estado do qubit no momento do corte é, em geral, um estado misto. Portanto, cada subcircuito precisa ser medido várias vezes em diferentes bases (geralmente uma base tomograficamente completa, como a base de Pauli [\\[3\\], \\[4\\]](#references) ) e, consequentemente, preparado em seu estado próprio. A figura abaixo (fonte: [\\[7\\]](#references) ) mostra um exemplo de divisão de um estado GHZ de quatro qubits em três subcircuitos. Aqui, $M_j$ denota um conjunto de bases (geralmente Pauli X, Y e Z), e $P_i$ denota um conjunto de estados próprios (geralmente $|0\\rangle$, $|1\\rangle$, $|+\\rangle$ e $|+i\\rangle$ ).\n",
"\n",
"\n",
"\n",
"\n",
"Como cada subcircuito possui menos qubits e portas lógicas, espera-se que sejam menos suscetíveis ao ruído. Este tutorial mostra um exemplo em que esse método pode ser usado para suprimir eficazmente o ruído no sistema.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "55b94021",
"metadata": {},
"source": [
"\n",
"\n",
"## Requisitos\n",
"\n",
"Antes de iniciar este tutorial, verifique se você tem os seguintes itens instalados:\n",
"\n",
"* Qiskit SDK v2.0 ou posterior, com suporte [para visualização](/docs/api/qiskit/visualization)\n",
"* Qiskit Runtime v0.22 ou mais tarde ( `pip install qiskit-ibm-runtime` )\n",
"* Complemento Qiskit para criação de circuitos v0.10.0 ou versão posterior (`pip install qiskit-addon-cutting`)\n",
"* Complemento Qiskit utils 0.3 ou posterior (`pip install qiskit-addon-utils`)\n",
"* Qiskit Aer (`pip install qiskit-aer` )\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "7db2e559",
"metadata": {},
"source": [
"\n",
"\n",
"## Instalação\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "bc380c46",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit\n",
"from qiskit.quantum_info import PauliList, SparsePauliOp\n",
"from qiskit.transpiler import generate_preset_pass_manager\n",
"from qiskit_aer import AerSimulator\n",
"from qiskit.result import sampled_expectation_value\n",
"\n",
"from qiskit_addon_cutting.instructions import CutWire\n",
"from qiskit_addon_cutting import (\n",
" cut_wires,\n",
" expand_observables,\n",
" partition_problem,\n",
" generate_cutting_experiments,\n",
" reconstruct_expectation_values,\n",
")\n",
"\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"from qiskit_ibm_runtime import SamplerV2, Batch"
]
},
{
"cell_type": "markdown",
"id": "431a5bd2-e6ed-471b-ad9e-c4edd27784a8",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplo de simulador em pequena escala\n",
"\n",
"Este tutorial implementa um [padrão do Qiskit](/docs/guides/intro-to-patterns) para simular um circuito de localização de muitos corpos (MBL) unidimensional ( 1D ). O circuito MBL é um circuito eficiente em termos de hardware e é parametrizado por dois parâmetros: $\\theta$ e $\\vec{\\phi}$. Quando $\\theta$ é definido como $0$ e o estado inicial é preparado em $|0\\rangle$ para todos os qubits, o valor esperado ideal de $\\langle Z_i \\rangle$ é $+1$ para cada local de qubit $i$, independentemente dos valores de $\\vec{\\phi}$. Mais detalhes sobre este circuito estão disponíveis neste [artigo](https://www.nature.com/articles/s41467-025-57623-x).\n",
"\n",
"Observe que, em um simulador sem ruído, o valor esperado obtido com e sem o corte do circuito será o mesmo.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "988ee237",
"metadata": {},
"source": [
"\n",
"\n",
"### Passo 1: Mapear entradas clássicas para um problema quântico\n",
"\n",
"\n",
"\n",
"#### Construa o circuito MBL “ 1D ”\n",
"\n",
"Primeiro, apresentamos uma função para a construção do circuito MBL de \" 1D \".\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "d2aa988a",
"metadata": {},
"outputs": [],
"source": [
"class MBLChainCircuit(QuantumCircuit):\n",
" def __init__(\n",
" self, num_qubits: int, depth: int, use_cut: bool = False\n",
" ) -> None:\n",
" super().__init__(\n",
" num_qubits, name=f\"MBLChainCircuit<{num_qubits}, {depth}>\"\n",
" )\n",
" evolution = MBLChainEvolution(num_qubits, depth, use_cut)\n",
" self.compose(evolution, inplace=True)\n",
"\n",
"\n",
"class MBLChainEvolution(QuantumCircuit):\n",
" def __init__(self, num_qubits: int, depth: int, use_cut) -> None:\n",
" super().__init__(\n",
" num_qubits, name=f\"MBLChainEvolution<{num_qubits}, {depth}>\"\n",
" )\n",
"\n",
" theta = Parameter(\"θ\")\n",
" phis = ParameterVector(\"φ\", num_qubits)\n",
"\n",
" for layer in range(depth):\n",
" layer_parity = layer % 2\n",
" # print(\"layer parity\", layer_parity)\n",
" for qubit in range(layer_parity, num_qubits - 1, 2):\n",
" # print(qubit)\n",
" self.cz(qubit, qubit + 1)\n",
" self.u(theta, 0, np.pi, qubit)\n",
" self.u(theta, 0, np.pi, qubit + 1)\n",
" if (\n",
" use_cut\n",
" and layer_parity == 0\n",
" and (\n",
" qubit == num_qubits // 2 - 1\n",
" or qubit == num_qubits // 2\n",
" )\n",
" ):\n",
" self.append(CutWire(), [num_qubits // 2])\n",
" if use_cut and layer < depth - 1 and layer_parity == 1:\n",
" if qubit == num_qubits // 2:\n",
" self.append(CutWire(), [qubit])\n",
" for qubit in range(num_qubits):\n",
" self.p(phis[qubit], qubit)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "a3debf65-06df-4277-933e-14b6f6170756",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"num_qubits = 10\n",
"depth = 2\n",
"mbl = MBLChainCircuit(num_qubits, depth)\n",
"mbl.draw(\"mpl\", fold=-1)"
]
},
{
"cell_type": "markdown",
"id": "ef13f367",
"metadata": {},
"source": [
"Calculamos o valor médio esperado $O = \\frac{1}{n} \\sum_i Z_i$ para todos os qubits em $\\theta = 0$. Como o valor esperado ideal de $\\langle Z_i \\rangle = 1$ $\\forall$ $i$, o valor esperado ideal de $O$ também é $1$. Os parâmetros $\\phi$ são selecionados aleatoriamente.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "b0f1e5fd",
"metadata": {},
"outputs": [],
"source": [
"np.random.seed(42)\n",
"phis = list(np.random.rand(mbl.num_parameters - 1))\n",
"theta = [0]\n",
"params = theta + phis"
]
},
{
"cell_type": "markdown",
"id": "a81f0346",
"metadata": {},
"source": [
"É necessário anotar o circuito inserindo \" **CutWire** \" nos locais desejados para dividi-lo. Para este tutorial, optamos por uma divisão igualitária. O circuito MBL foi projetado de forma que a configuração `use_cut=True` na função insira a anotação corretamente após $\\frac{n}{2}$ qubits, sendo $n$ o número de qubits no circuito original. Também atribuímos os parâmetros gerados aleatoriamente ao circuito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "5208e0a8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mbl_cut = MBLChainCircuit(num_qubits, depth, use_cut=True)\n",
"mbl_cut.assign_parameters(params, inplace=True)\n",
"mbl_cut.draw(\"mpl\", fold=-1)"
]
},
{
"cell_type": "markdown",
"id": "ac6f36e3",
"metadata": {},
"source": [
"\n",
"\n",
"### Etapa 2: Otimizar o problema para execução em hardware quântico\n",
"\n",
"\n",
"\n",
"#### Divida o circuito em subcircuitos menores\n",
"\n",
"Agora dividimos o circuito em dois subcircuitos menores usando [`qiskit-addon-cutting`](https://qiskit.github.io/qiskit-addon-cutting/). `qiskit-addon-cutting` insere uma porta virtual `Move` para dividir o ponto de corte do fio, ajustando adequadamente o número de qubits. Agora vamos criar o circuito com essa porta virtual. Como há um fio cortado, o número de qubits associados aumentará em 1.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "1834cb22",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mbl_move = cut_wires(mbl_cut)\n",
"mbl_move.draw(\"mpl\", fold=-1)"
]
},
{
"cell_type": "markdown",
"id": "1df16e6b",
"metadata": {},
"source": [
"\n",
"\n",
"#### Construir e expandir o observável\n",
"\n",
"A observável, conforme definido anteriormente, será a média de $Z$ em cada qubit. No entanto, ao inserir a porta virtual `Move` , o número efetivo de qubits no circuito aumenta. O observável também deve ser expandido de forma adequada para levar em conta essa mudança no número de qubits. Observe que o observável sempre age de forma trivial (como em $I$ ) sobre o qubit adicional adicionado para a porta virtual `Move` .\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "3074b173",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"PauliList(['ZIIIIIIIII', 'IZIIIIIIII', 'IIZIIIIIII', 'IIIZIIIIII',\n",
" 'IIIIZIIIII', 'IIIIIZIIII', 'IIIIIIZIII', 'IIIIIIIZII',\n",
" 'IIIIIIIIZI', 'IIIIIIIIIZ'])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"observable = PauliList(\n",
" [\"I\" * i + \"Z\" + \"I\" * (num_qubits - i - 1) for i in range(num_qubits)]\n",
")\n",
"observable"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "32b7081b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"PauliList(['ZIIIIIIIIII', 'IZIIIIIIIII', 'IIZIIIIIIII', 'IIIZIIIIIII',\n",
" 'IIIIZIIIIII', 'IIIIIIZIIII', 'IIIIIIIZIII', 'IIIIIIIIZII',\n",
" 'IIIIIIIIIZI', 'IIIIIIIIIIZ'])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"new_obs = expand_observables(observable, mbl, mbl_move)\n",
"new_obs"
]
},
{
"cell_type": "markdown",
"id": "0ad0886b",
"metadata": {},
"source": [
"Agora, o circuito pode ser dividido ao longo da `Move` porta, obtendo-se assim os subcircuitos, bem como o subobservável, que é a parte do observável original associada a cada subcircuito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "c8894a06",
"metadata": {},
"outputs": [],
"source": [
"partitioned_problem = partition_problem(circuit=mbl_move, observables=new_obs)\n",
"subcircuits = partitioned_problem.subcircuits\n",
"subobservables = partitioned_problem.subobservables"
]
},
{
"cell_type": "markdown",
"id": "8f47ab33",
"metadata": {},
"source": [
"Aqui, visualizamos os dois subcircuitos:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "1b0e779f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"subcircuits[0].draw(\"mpl\", fold=-1)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "3c802f28",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"subcircuits[1].draw(\"mpl\", fold=-1)"
]
},
{
"cell_type": "markdown",
"id": "0e4c03fb",
"metadata": {},
"source": [
"Para expandir o observável utilizando a `Move` operação, é necessária uma `PauliList` estrutura de dados. Para reconstruir o valor esperado do circuito original, precisamos da observável no `SparsePauliOp` formato.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "7dc51220",
"metadata": {},
"outputs": [],
"source": [
"M_z = SparsePauliOp(\n",
" [\"I\" * i + \"Z\" + \"I\" * (num_qubits - i - 1) for i in range(num_qubits)],\n",
" coeffs=[1 / num_qubits] * num_qubits,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "2b5a5746",
"metadata": {},
"source": [
"Conforme discutido anteriormente, para cada corte, o circuito a montante deve ser medido em uma base de Pauli, e o circuito a jusante deve ser preparado no estado próprio dessa base. A função `generate_cutting_experiments` cria todos esses circuitos necessários e os coeficientes associados a cada circuito, essenciais para a reconstrução. Veja mais detalhes [neste artigo](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "648519f0",
"metadata": {},
"outputs": [],
"source": [
"subexperiments, coefficients = generate_cutting_experiments(\n",
" circuits=subcircuits,\n",
" observables=subobservables,\n",
" num_samples=np.inf,\n",
")"
]
},
{
"cell_type": "markdown",
"id": "43f58cfb",
"metadata": {},
"source": [
"\n",
"\n",
"#### Compilar os circuitos no backend\n",
"\n",
"Para o primeiro exemplo, que envolve apenas simulação, compilamos o circuito para o conjunto de portas de base do backend:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "29d71cd3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(\n",
" operational=True, simulator=False, min_num_qubits=133\n",
")\n",
"\n",
"print(backend)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "b4d480b3",
"metadata": {},
"source": [
"\n",
"\n",
"### Passo 3: Execute usando Qiskit primitives\n",
"\n",
"Agora, execute cada subexperimento:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "05fabb27",
"metadata": {},
"outputs": [],
"source": [
"pm_basis = generate_preset_pass_manager(\n",
" optimization_level=2, basis_gates=backend.configuration().basis_gates\n",
")\n",
"basis_subexperiments = {\n",
" label: pm_basis.run(partition_subexpts)\n",
" for label, partition_subexpts in subexperiments.items()\n",
"}"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "b22a1b00",
"metadata": {},
"outputs": [],
"source": [
"sampler = SamplerV2(mode=AerSimulator())\n",
"jobs = {\n",
" label: sampler.run(subsystem_subexpts, shots=2**12)\n",
" for label, subsystem_subexpts in basis_subexperiments.items()\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "50b94af2",
"metadata": {},
"source": [
"\n",
"\n",
"### Etapa 4: Pós-processamento e retorno do resultado no formato clássico desejado\n",
"\n",
"Agora, recuperamos o resultado de cada execução do sub-experimento e reconstruímos o valor esperado do circuito não cortado:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "31dc35ea-6554-4ca7-9c3b-0b5394c46e4e",
"metadata": {},
"outputs": [],
"source": [
"# Retrieve results\n",
"results = {label: job.result() for label, job in jobs.items()}"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "4972e4e4",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"np.float64(0.9953821063041687)"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"reconstructed_expval_terms = reconstruct_expectation_values(\n",
" results,\n",
" coefficients,\n",
" subobservables,\n",
")\n",
"reconstructed_expval = np.dot(reconstructed_expval_terms, M_z.coeffs).real\n",
"reconstructed_expval"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "fb5f955a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0, 0.5, '$M_Z$')"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"methods = [\n",
" \"Uncut\",\n",
" \"Wire cut\",\n",
"]\n",
"values = [\n",
" 1,\n",
" reconstructed_expval,\n",
"] # since the ideal expectation value in noiseless simulation is +1\n",
"\n",
"ax = plt.gca()\n",
"plt.bar(methods, values, color=\"#a56eff\", width=0.4, edgecolor=\"#8a3ffc\")\n",
"ax.set_ylabel(r\"$M_Z$\", fontsize=12)"
]
},
{
"cell_type": "markdown",
"id": "0d6db390-e7a8-4efe-902c-8d9a312170c6",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplo de hardware em grande escala\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ae69c5e0-32b1-4f03-ab13-7b95a9acfd25",
"metadata": {},
"source": [
"Agora, demonstraremos o corte de fios para um circuito MBL de 60 qubits. Tanto os circuitos não cortados quanto os cortados serão executados em um hardware d IBM Quantum® :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "37834c72",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"num_qubits = 60\n",
"depth = 2\n",
"\n",
"# construct the circuit\n",
"mbl = MBLChainCircuit(num_qubits, depth)\n",
"\n",
"# create parameters\n",
"phis = list(np.random.rand(mbl.num_parameters - 1))\n",
"theta = [0]\n",
"params = theta + phis\n",
"\n",
"# construct the cut circuit\n",
"mbl_cut = MBLChainCircuit(num_qubits, depth, use_cut=True)\n",
"mbl_cut.assign_parameters(params, inplace=True)\n",
"mbl_move = cut_wires(mbl_cut)\n",
"\n",
"# Define observable and expand to account for the wire cut\n",
"observable = PauliList(\n",
" [\"I\" * i + \"Z\" + \"I\" * (num_qubits - i - 1) for i in range(num_qubits)]\n",
")\n",
"new_obs = expand_observables(observable, mbl, mbl_move)\n",
"\n",
"# Construct a SparsePauliOp version of the observable for later use in reconstruction\n",
"M_z = SparsePauliOp(\n",
" [\"I\" * i + \"Z\" + \"I\" * (num_qubits - i - 1) for i in range(num_qubits)],\n",
" coeffs=[1 / num_qubits] * num_qubits,\n",
")\n",
"\n",
"# Partition the circuit and get subcircuits and subobservables\n",
"partitioned_problem = partition_problem(circuit=mbl_move, observables=new_obs)\n",
"subcircuits = partitioned_problem.subcircuits\n",
"subobservables = partitioned_problem.subobservables\n",
"\n",
"# Obtain subexperiments and coefficients\n",
"subexperiments, coefficients = generate_cutting_experiments(\n",
" circuits=subcircuits,\n",
" observables=subobservables,\n",
" num_samples=np.inf,\n",
")\n",
"\n",
"# Transpile the subexperiments to the backend\n",
"pm = generate_preset_pass_manager(optimization_level=2, backend=backend)\n",
"isa_subexperiments = {\n",
" label: pm.run(partition_subexpts)\n",
" for label, partition_subexpts in subexperiments.items()\n",
"}\n",
"\n",
"# Execute the subexperiments and retrieve results\n",
"with Batch(backend=backend) as batch:\n",
" sampler = SamplerV2(mode=batch)\n",
" sampler.options.environment.job_tags = [\"TUT_WC\"]\n",
" jobs = {\n",
" label: sampler.run(subsystem_subexpts, shots=2**12)\n",
" for label, subsystem_subexpts in isa_subexperiments.items()\n",
" }\n",
"results = {label: job.result() for label, job in jobs.items()}\n",
"\n",
"# Reconstruct the expectation value of the original observable\n",
"reconstructed_expval_terms = reconstruct_expectation_values(\n",
" results,\n",
" coefficients,\n",
" subobservables,\n",
")\n",
"reconstructed_expval = np.dot(reconstructed_expval_terms, M_z.coeffs).real\n",
"\n",
"# Compute the uncut circuit to obtain the noisy expectation value for comparison\n",
"sampler = SamplerV2(mode=backend)\n",
"sampler.options.environment.job_tags = [\"TUT_WC\"]\n",
"\n",
"if mbl.num_clbits == 0:\n",
" mbl.measure_all()\n",
"isa_mbl = pm.run(mbl)\n",
"\n",
"pub = (isa_mbl, params)\n",
"uncut_job = sampler.run([pub])\n",
"\n",
"uncut_counts = uncut_job.result()[0].data.meas.get_counts()\n",
"uncut_expval = sampled_expectation_value(uncut_counts, M_z)\n",
"\n",
"# visualize the results\n",
"ax = plt.gca()\n",
"methods = [\"uncut\", \"cut\"]\n",
"values = [uncut_expval, reconstructed_expval]\n",
"\n",
"plt.bar(methods, values, color=\"#a56eff\", width=0.4, edgecolor=\"#8a3ffc\")\n",
"plt.axhline(y=1, color=\"k\", linestyle=\"--\")\n",
"plt.text(0.3, 0.95, \"Exact result\")\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "1445d099",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.9202473958333336"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"uncut_expval"
]
},
{
"cell_type": "markdown",
"id": "75f48e6a-c7e4-46f3-9d39-a7a877427a04",
"metadata": {},
"source": [
"\n",
"\n",
"## Próximas etapas\n",
"\n",
"\n",
" Se você achou este trabalho interessante, talvez se interesse pelo seguinte material:\n",
"\n",
" * [Condições de contorno periódicas com corte de circuito](/docs/tutorials/periodic-boundary-conditions-with-circuit-cutting)\n",
" * [Corte em circuito para redução da profundidade](/docs/tutorials/depth-reduction-with-circuit-cutting)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "23cd3042",
"metadata": {},
"source": [
"\n",
"\n",
"## Referências\n",
"\n",
"\\[1] Peng, T., Harrow, A. W., Ozols, M., & Wu, X. (2020). Simulação de grandes circuitos quânticos em um pequeno computador quântico. Physical Review Letters, 125(15), 150504.\n",
"\n",
"\\[2] Tang, W., Tomesh, T., Suchara, M., Larson, J., & Martonosi, M. (2021, abril). Cutqc: uso de computadores quânticos pequenos para avaliações de circuitos quânticos grandes. Em Proceedings of the 26th ACM International conference on architectural support for programming languages and operating systems (pp. 473-486).\n",
"\n",
"\\[3] Perlin, M. A., Saleem, Z. H., Suchara, M., & Osborn, J. C. (2021). Corte de circuito quântico com tomografia de máxima verossimilhança. npj Quantum Information, 7(1), 64.\n",
"\n",
"\\[4] Majumdar, R., & Wood, C. J. (2022). Corte de circuito quântico com atenuação de erros. arXiv pré-impressão arXiv:2211.13431.\n",
"\n",
"\\[5] Khare, T., Majumdar, R., Sangle, R., Ray, A., Seshadri, P. V., & Simmhan, Y. (2023). Paralelização de cargas de trabalho clássicas-quânticas: Perfilando o impacto das técnicas de divisão. Em 2023, Conferência Internacional do IEEE sobre Engenharia e Computação Quântica (QCE) (Vol. 1, pp. 990-1000). IEEE.\n",
"\n",
"\\[6] Bhoumik, D., Majumdar, R., Saha, A., & Sur-Kolay, S. (2023). Distributed Scheduling of Quantum Circuits with Noise and Time Optimization (Programação distribuída de circuitos quânticos com ruído e otimização de tempo). arXiv pré-impressão arXiv:2309.06005.\n",
"\n",
"\\[7] Majumdar, R. (2024). Redução eficiente de recursos e ruído em circuitos de computação quântica discreta (Tese de doutorado, Instituto Indiano de Estatística - Calcutá). [https://www.proquest.com/openview/b481def90b1cc80e6b58a77c99e8385c/1?pq-origsite=gscholar\\&cbl=2026366\\&diss=y](https://www.proquest.com/openview/b481def90b1cc80e6b58a77c99e8385c/1?pq-origsite=gscholar\\&cbl=2026366\\&diss=y)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
},
"hours": 1.5,
"qpuSeconds": 22
},
"nbformat": 4,
"nbformat_minor": 5
}