{ "cells": [ { "cell_type": "markdown", "id": "72a56be1-db57-4364-acf3-57814453b64e", "metadata": {}, "source": [ "---\n", "title: \"Feedforward clássico e fluxo de controle (circuitos dinâmicos)\"\n", "description: \"Use o Qiskit para feedforward clássico e fluxo de controle, também conhecido como circuitos dinâmicos\"\n", "---\n", "\n", "\n", "\n", "# Feedforward clássico e fluxo de controle (circuitos dinâmicos)\n", "\n" ] }, { "cell_type": "markdown", "id": "7f636096-9a03-4f72-823b-4b9219d496f0", "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 usando os seguintes requisitos.\n", " Recomendamos o uso dessas versões ou de versões mais recentes.\n", "\n", " ```\n", " qiskit[all]~=2.5.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "ea7e102f-6e41-4bdd-95be-5dd13225952b", "metadata": {}, "source": [ "Os circuitos dinâmicos são ferramentas poderosas com as quais você pode medir qubits no meio da execução de um circuito quântico e, em seguida, realizar operações lógicas clássicas dentro do circuito, com base no resultado dessas medições no meio do circuito. Esse processo também é conhecido como *feedforward clássico*. Embora ainda seja cedo para entender a melhor forma de aproveitar os circuitos dinâmicos, a comunidade de pesquisa quântica já identificou vários casos de uso, como os seguintes:\n", "\n", "* Preparação eficiente de estados quânticos, como [o estado GHZ](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339), [o estado W](https://arxiv.org/abs/2403.07604) (para mais informações sobre o estado W, consulte também [“Preparação de estados por circuitos rasos usando feed forward”](https://arxiv.org/abs/2307.14840) ) e uma ampla classe de [estados de produto matricial](https://arxiv.org/abs/2404.16083)\n", "* [Emaranhamento eficiente de longo alcance](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.5.030339) entre qubits no mesmo chip usando circuitos rasos\n", "* [Amostragem eficiente de circuitos do tipo IQP](https://arxiv.org/pdf/2505.04705)\n", "\n" ] }, { "cell_type": "markdown", "id": "b2953dd4-218e-4daa-a753-0d2aa5e0a0bb", "metadata": {}, "source": [ "O Qiskit oferece suporte a quatro construções de fluxo de controle para redes clássicas de alimentação direta, cada uma implementada como um método em [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit). As construções e seus métodos correspondentes são:\n", "\n", "* Instrução if - [`QuantumCircuit.if_test`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#if_test)\n", "* Instrução switch - [`QuantumCircuit.switch`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#switch)\n", "* Loop “for” - [`QuantumCircuit.for_loop`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#for_loop)\n", "* Enquanto o loop - [`QuantumCircuit.while_loop`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#while_loop)\n", "\n", "Cada um desses métodos retorna um [gerenciador de contexto](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers) e é normalmente usado em uma `with` instrução. O restante deste guia explica cada uma dessas estruturas e como utilizá-las.\n", "\n", "\n", " Existem algumas limitações nas operações clássicas de feedforward e de fluxo de controle em hardware quântico que podem afetar seu programa. Para obter mais informações, consulte “[Executar circuitos dinâmicos](/docs/guides/execute-dynamic-circuits) ”.\n", "\n", "\n", "\n", "\n", "## `if` declaração\n", "\n", "A instrução `if` é usada para executar operações condicionalmente com base no valor de um bit ou registro clássico.\n", "\n", "No exemplo abaixo, aplicamos uma porta Hadamard a um qubit e o medimos. Se o resultado for 1, então aplicamos uma porta X no qubit, o que tem o efeito de virá-lo de volta para o estado 0. Em seguida, medimos o qubit novamente. O resultado da medição resultante deve ser 0 com 100% de probabilidade.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "f0f191a7-d59d-415f-a11b-9f39e431269b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "\n", "qubits = QuantumRegister(1)\n", "clbits = ClassicalRegister(1)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "(q0,) = qubits\n", "(c0,) = clbits\n", "\n", "circuit.h(q0)\n", "circuit.measure(q0, c0)\n", "with circuit.if_test((c0, 1)):\n", " circuit.x(q0)\n", "circuit.measure(q0, c0)\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'0': 1024}" ] }, { "cell_type": "markdown", "id": "867d8f76-9cba-47fd-a341-ac40db6ee073", "metadata": {}, "source": [ "A instrução `with` pode receber um destino de atribuição que, por sua vez, é um gerenciador de contexto que pode ser armazenado e, posteriormente, usado para criar um bloco else, que é executado sempre que o conteúdo do bloco `if` *não* for executado.\n", "\n", "No exemplo abaixo, inicializamos os registros com dois qubits e dois bits clássicos. Aplicamos uma porta Hadamard ao primeiro qubit e o medimos. Se o resultado for 1, aplicaremos uma porta Hadamard no segundo qubit; caso contrário, aplicaremos uma porta X no segundo qubit. Por fim, também medimos o segundo qubit.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "d40249f1-d951-49e4-9ee9-662d3568f32f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubits = QuantumRegister(2)\n", "clbits = ClassicalRegister(2)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "(q0, q1) = qubits\n", "(c0, c1) = clbits\n", "\n", "circuit.h(q0)\n", "circuit.measure(q0, c0)\n", "with circuit.if_test((c0, 1)) as else_:\n", " circuit.h(q1)\n", "with else_:\n", " circuit.x(q1)\n", "circuit.measure(q1, c1)\n", "\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'01': 260, '11': 272, '10': 492}" ] }, { "cell_type": "markdown", "id": "ba7b688a-e961-4361-9edf-47b387704f9d", "metadata": {}, "source": [ "Além de condicionar um único bit clássico, também é possível condicionar o valor de um registro clássico composto de vários bits.\n", "\n", "No exemplo abaixo, aplicamos portas Hadamard a dois qubits e os medimos. Se o resultado for `01`, ou seja, o primeiro qubit é 1 e o segundo qubit é 0, então aplicamos um portão X a um terceiro qubit. Por fim, medimos o terceiro qubit. Observe que, para maior clareza, optamos por especificar o estado do terceiro bit clássico, que é 0, na `if` condição. No desenho do circuito, a condição é indicada pelos círculos nos bits clássicos que estão sendo condicionados. Um círculo sólido indica condicionamento em 1, enquanto um círculo contornado indica condicionamento em 0.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "6ccfd81b-0bda-409e-bd9a-116848df631b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubits = QuantumRegister(3)\n", "clbits = ClassicalRegister(3)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "(q0, q1, q2) = qubits\n", "(c0, c1, c2) = clbits\n", "\n", "circuit.h([q0, q1])\n", "circuit.measure(q0, c0)\n", "circuit.measure(q1, c1)\n", "with circuit.if_test((clbits, 0b001)):\n", " circuit.x(q2)\n", "circuit.measure(q2, c2)\n", "\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'101': 269, '011': 260, '000': 252, '010': 243}" ] }, { "cell_type": "markdown", "id": "f85c34ed-bca6-40b9-9db2-e534f8c79010", "metadata": {}, "source": [ "\n", "\n", "## Instrução SWITCH\n", "\n", "A instrução `switch` é usada para selecionar ações com base no valor de um bit ou registro clássico. É semelhante a uma instrução “if”, mas permite especificar mais casos para a lógica de ramificação. O exemplo a seguir aplica uma porta de Hadamard a um qubit e o mede. Se o resultado for 0, aplique uma porta X no qubit; se o resultado for 1, aplique uma porta Z. O resultado da medição deve ser 1 com 100% de probabilidade.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "04b82e33-7c95-4042-a5e9-d00ff075ca02", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubits = QuantumRegister(1)\n", "clbits = ClassicalRegister(1)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "(q0,) = qubits\n", "(c0,) = clbits\n", "\n", "circuit.h(q0)\n", "circuit.measure(q0, c0)\n", "with circuit.switch(c0) as case:\n", " with case(0):\n", " circuit.x(q0)\n", " with case(1):\n", " circuit.z(q0)\n", "circuit.measure(q0, c0)\n", "\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'1': 1024}" ] }, { "cell_type": "markdown", "id": "e0da6aa3-736e-4eb5-ad36-8626236f7604", "metadata": {}, "source": [ "Como o exemplo acima utilizou um único bit clássico, havia apenas dois casos possíveis; portanto, você poderia ter obtido o mesmo resultado usando uma instrução if-else. A instrução switch case é útil principalmente para realizar ramificações com base no valor de um registro clássico composto por vários bits. O exemplo a seguir mostra como criar um caso padrão, que é executado caso nenhum dos casos anteriores seja executado. Observe que, em uma instrução `switch`, apenas um dos blocos é executado. Não há execução automática.\n", "\n", "O exemplo a seguir aplica portas de Hadamard a dois qubits e os mede. Se o resultado for 00 ou 11, aplique um portão Z ao terceiro qubit. Se o resultado for 01, aplique uma porta Y. Se nenhum dos casos anteriores corresponder, aplique uma porta X. Por fim, meça o terceiro qubit.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "6aaba57e-7841-47d3-8f31-f922cb2b81f7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubits = QuantumRegister(3)\n", "clbits = ClassicalRegister(3)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "(q0, q1, q2) = qubits\n", "(c0, c1, c2) = clbits\n", "\n", "circuit.h([q0, q1])\n", "circuit.measure(q0, c0)\n", "circuit.measure(q1, c1)\n", "with circuit.switch(clbits) as case:\n", " with case(0b000, 0b011):\n", " circuit.z(q2)\n", " with case(0b001):\n", " circuit.y(q2)\n", " with case(case.DEFAULT):\n", " circuit.x(q2)\n", "circuit.measure(q2, c2)\n", "\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'101': 267, '110': 249, '011': 265, '000': 243}" ] }, { "cell_type": "markdown", "id": "e5f1da75-abcc-42de-8aa6-6f2a6d450ddd", "metadata": {}, "source": [ "\n", "\n", "## Para loop\n", "\n", "Um loop “for” é usado para percorrer uma sequência de valores clássicos e realizar algumas operações a cada iteração.\n", "\n", "O exemplo a seguir usa um loop for para aplicar 5 portas X a um qubit e, em seguida, mede-o. Como ele executa um número ímpar de portas X, o efeito geral é fazer com que o qubit mude do estado 0 para o estado 1.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "c6c91715-7a98-46a8-885e-92d3d1f99557", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubits = QuantumRegister(1)\n", "clbits = ClassicalRegister(1)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "(q0,) = qubits\n", "(c0,) = clbits\n", "\n", "with circuit.for_loop(range(5)) as _:\n", " circuit.x(q0)\n", "circuit.measure(q0, c0)\n", "\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'1': 1024}" ] }, { "cell_type": "markdown", "id": "98e7b4f3-e73e-4caf-9326-11b45bd6cfcf", "metadata": {}, "source": [ "\n", "\n", "## Loop while\n", "\n", "Um loop while é usado para repetir instruções enquanto uma determinada condição for satisfeita.\n", "\n", "O exemplo a seguir aplica portas de Hadamard a dois qubits e os mede. Em seguida, ele cria um loop while que repete esse procedimento enquanto o resultado da medição for 11. Consequentemente, o resultado final nunca deve ser 11, e as demais possibilidades devem ocorrer com frequência aproximadamente igual.\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "c26465ff-5d3e-4799-8c68-c327abff5694", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qubits = QuantumRegister(2)\n", "clbits = ClassicalRegister(2)\n", "circuit = QuantumCircuit(qubits, clbits)\n", "\n", "q0, q1 = qubits\n", "c0, c1 = clbits\n", "\n", "circuit.h([q0, q1])\n", "circuit.measure(q0, c0)\n", "circuit.measure(q1, c1)\n", "with circuit.while_loop((clbits, 0b11)):\n", " circuit.h([q0, q1])\n", " circuit.measure(q0, c0)\n", " circuit.measure(q1, c1)\n", "\n", "circuit.draw(\"mpl\")\n", "\n", "# example output counts: {'01': 334, '10': 368, '00': 322}" ] }, { "cell_type": "markdown", "id": "672080db-913d-4511-ab63-48ca48b60fa5", "metadata": {}, "source": [ "\n", "\n", "## Expressões clássicas\n", "\n", "O módulo [`qiskit.circuit.classical`](/docs/api/qiskit/circuit_classical) de expressões clássicas do Qiskit contém uma representação exploratória das operações em tempo de execução realizadas sobre valores clássicos durante a execução do circuito.\n", "\n", "O exemplo a seguir mostra que você pode usar o cálculo da paridade para criar um estado GHZ de n-qubit usando circuitos dinâmicos. Primeiro, gere $n/2$ pares de Bell em qubits adjacentes. Em seguida, cole esses pares usando uma camada de portas CNOT entre os pares. Em seguida, você mede o qubit de destino de todas as portas CNOT anteriores e redefine cada qubit medido para o estado $\\vert 0 \\rangle$. Você aplica o $X$ a cada local não medido para o qual a paridade de todos os bits anteriores é ímpar. Por fim, as portas CNOT são aplicadas aos qubits medidos para restabelecer o emaranhamento perdido na medição.\n", "\n", "No cálculo da paridade, o primeiro elemento da expressão construída envolve elevar o objeto Python`mr[0]` a um [`Value`](/docs/api/qiskit/circuit_classical#value) nó (`lift` é usado para transformar objetos arbitrários em expressões clássicas). Isso não é necessário para `mr[1]` e o possível registro clássico seguinte, pois eles são entradas para `expr.bit_xor`, e qualquer levantamento necessário é feito automaticamente nesses casos. Essas expressões podem ser criadas em loops e outras construções.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "8c8ad702-1097-411f-983d-b5654f75059f", "metadata": {}, "outputs": [], "source": [ "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "from qiskit.circuit.classical import expr\n", "\n", "num_qubits = 8\n", "if num_qubits % 2 or num_qubits < 4:\n", " raise ValueError(\"num_qubits must be an even integer ≥ 4\")\n", "meas_qubits = list(range(2, num_qubits, 2)) # qubits to measure and reset\n", "\n", "qr = QuantumRegister(num_qubits, \"qr\")\n", "mr = ClassicalRegister(len(meas_qubits), \"m\")\n", "qc = QuantumCircuit(qr, mr)\n", "\n", "# Create local Bell pairs\n", "qc.reset(qr)\n", "qc.h(qr[::2])\n", "for ctrl in range(0, num_qubits, 2):\n", " qc.cx(qr[ctrl], qr[ctrl + 1])\n", "\n", "# Glue neighboring pairs\n", "for ctrl in range(1, num_qubits - 1, 2):\n", " qc.cx(qr[ctrl], qr[ctrl + 1])\n", "\n", "# Measure boundary qubits between pairs,reset to 0\n", "for k, q in enumerate(meas_qubits):\n", " qc.measure(qr[q], mr[k])\n", " qc.reset(qr[q])\n", "\n", "# Parity-conditioned X corrections\n", "# Each non-measured qubit gets flipped iff the parity (XOR) of all\n", "# preceding measurement bits is 1\n", "for tgt in range(num_qubits):\n", " if tgt in meas_qubits: # skip measured qubits\n", " continue\n", " # all measurement registers whose physical qubit index < tgt\n", " left_bits = [k for k, q in enumerate(meas_qubits) if q < tgt]\n", " if not left_bits: # skip if list empty\n", " continue\n", "\n", " # build XOR-parity expression\n", " parity = expr.lift(\n", " mr[left_bits[0]]\n", " ) # lift the first bit to Value so it will be treated like a boolean.\n", " for k in left_bits[1:]:\n", " parity = expr.bit_xor(\n", " mr[k], parity\n", " ) # calculate parity with all other bits\n", " with qc.if_test(parity): # Add X if parity is 1\n", " qc.x(qr[tgt])\n", "\n", "# Re-entangle measured qubits\n", "for ctrl in range(1, num_qubits - 1, 2):\n", " qc.cx(qr[ctrl], qr[ctrl + 1])" ] }, { "cell_type": "code", "execution_count": 9, "id": "a5d808f5-d424-4133-a557-89d2f2a2c853", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc.draw(output=\"mpl\", style=\"iqp\", idle_wires=False, fold=-1)" ] }, { "cell_type": "markdown", "id": "62134a85-608f-4ad2-a76e-b0736bec9362", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "### `Store`\n", "\n", "Você pode usar a [`store`](/docs/api/qiskit/circuit#store) instrução para salvar o resultado de uma expressão clássica, caso essa expressão venha a ser usada repetidamente. As operações são paralelizadas automaticamente, tornando seu código significativamente mais eficiente em tempo de execução.\n", "\n", "Por exemplo, é mais natural e mais eficiente em tempo de execução escrever $B[0] \\oplus B[1] \\oplus B[2] \\ldots$, onde $B = \\neg A$, do que $(\\neg A[0]) \\oplus (\\neg A[1]) \\oplus (\\neg A[2]) \\ldots$. A primeira opção calcula a negação em uma única etapa paralela antes da cadeia XOR, em vez de avaliar cada negação sequencialmente dentro da expressão.\n", "\n", "Exemplo completo:\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "953fa3ca-f542-47ea-9cf2-36a616ecb7f7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "from qiskit.circuit.classical import expr\n", "\n", "qregs = QuantumRegister(4, \"q\")\n", "creg = ClassicalRegister(3, \"c\")\n", "# temp is a plain ClassicalRegister used as the store target\n", "temp = ClassicalRegister(3, \"temp\")\n", "qc = QuantumCircuit(qregs, creg, temp)\n", "\n", "qc.h([0, 1, 2])\n", "qc.measure([0, 1, 2], creg)\n", "\n", "# Store bit-NOT of the full 3-bit register into temp\n", "qc.store(temp, expr.bit_not(creg))\n", "\n", "# Compute parity of temp using bit-indexed XOR\n", "parity = expr.bit_xor(\n", " expr.bit_xor(expr.index(temp, 0), expr.index(temp, 1)),\n", " expr.index(temp, 2),\n", ")\n", "\n", "# Flip q3 if parity of ~creg is 1\n", "with qc.if_test(parity):\n", " qc.x(3)\n", "\n", "qc.measure([0, 1, 2], creg)\n", "\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "f1b55508-04e8-4f53-9b13-33302102711d", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Aprenda a implementar um desacoplamento dinâmico preciso usando [o stretch](/docs/guides/stretch).\n", " * Use [a visualização do cronograma do circuito](/docs/guides/qiskit-runtime-circuit-timing) para depurar e otimizar seus circuitos dinâmicos.\n", " * [Executar circuitos dinâmicos](/docs/guides/execute-dynamic-circuits).\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 }