{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "bc54d7bc-b2d8-4b30-9b0b-05689e07a463",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Construir circuitos\"\n",
        "description: \"Como construir e visualizar circuitos quânticos no Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"construct-circuits\" />\n",
        "\n",
        "# Construir circuitos\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e11dd8ad-7edc-4cf8-bc13-388fe04e84fa",
      "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",
        "<Accordion>\n",
        "  <AccordionItem title=\"Versões do pacote\">\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.3.1\n",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d",
      "metadata": {},
      "source": [
        "Esta página dá uma olhada mais de perto na classe [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) no Qiskit SDK, incluindo alguns métodos mais avançados que você pode usar para criar circuitos quânticos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2664d407-aa95-43a3-9101-d3ad58c2df58",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-quantum-circuit\" />\n",
        "\n",
        "## O que é um circuito quântico?\n",
        "\n",
        "Um circuito quântico simples é uma coleção de qubits e uma lista de instruções que atuam sobre esses qubits. Para demonstrar, a célula a seguir cria um novo circuito com dois novos qubits e, em seguida, exibe o atributo [`qubits`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qubits) do circuito, que é uma lista de [`Qubits`](/docs/api/qiskit/circuit#qiskit.circuit.Qubit) em ordem do bit menos significativo $q_0$ para o bit mais significativo $q_n$.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "b410d397-b67d-4f31-90cf-9c1c34c157c5",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<Qubit register=(2, \"q\"), index=0>, <Qubit register=(2, \"q\"), index=1>]"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit import QuantumCircuit\n",
        "\n",
        "qc = QuantumCircuit(2)\n",
        "qc.qubits"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "392e3d6c",
      "metadata": {},
      "source": [
        "Vários objetos `QuantumRegister` e `ClassicalRegister` podem ser combinados para criar um circuito. Todos os [`QuantumRegister`](/docs/api/qiskit/circuit#qiskit.circuit.QuantumRegister) e [`ClassicalRegister`](/docs/api/qiskit/circuit#qiskit.circuit.ClassicalRegister) também podem ser nomeados.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "6160e3f7",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<Qubit register=(2, \"qreg1\"), index=0>,\n",
              " <Qubit register=(2, \"qreg1\"), index=1>,\n",
              " <Qubit register=(1, \"qreg2\"), index=0>]"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit import QuantumRegister, ClassicalRegister\n",
        "\n",
        "qr1 = QuantumRegister(2, \"qreg1\")  # Create a QuantumRegister with 2 qubits\n",
        "qr2 = QuantumRegister(1, \"qreg2\")  # Create a QuantumRegister with 1 qubit\n",
        "cr1 = ClassicalRegister(3, \"creg1\")  # Create a ClassicalRegister with 3 cbits\n",
        "\n",
        "combined_circ = QuantumCircuit(\n",
        "    qr1, qr2, cr1\n",
        ")  # Create a quantum circuit with 2 QuantumRegisters and 1 ClassicalRegister\n",
        "combined_circ.qubits"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e7b212f",
      "metadata": {},
      "source": [
        "É possível encontrar o índice e o registro de um qubit usando o método [`find_bit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.find_bit) do circuito e seus atributos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "faeb3fbc",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Index: 2\n",
            "Register: [(QuantumRegister(1, 'qreg2'), 0)]\n"
          ]
        }
      ],
      "source": [
        "desired_qubit = qr2[0]  # Qubit 0 of register 'qreg2'\n",
        "\n",
        "print(\"Index:\", combined_circ.find_bit(desired_qubit).index)\n",
        "print(\"Register:\", combined_circ.find_bit(desired_qubit).registers)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f5c95cb2-a94f-48f3-b2a6-8ec6c25da5cd",
      "metadata": {},
      "source": [
        "A adição de uma instrução ao circuito anexa a instrução ao atributo [`data`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#data) do circuito. A saída da célula a seguir mostra que `data` é uma lista de [`CircuitInstruction`](/docs/api/qiskit/qiskit.circuit.CircuitInstruction) objetos, cada um dos quais tem um atributo `operation` e um atributo `qubits` .\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "f7b5573c-b2b2-4cbf-ba55-c53c9221ce71",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[CircuitInstruction(operation=Instruction(name='x', num_qubits=1, num_clbits=0, params=[]), qubits=(<Qubit register=(2, \"q\"), index=0>,), clbits=())]"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc.x(0)  # Add X-gate to qubit 0\n",
        "qc.data"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "17a82d8a-b717-44b8-b3f8-ce89e2588261",
      "metadata": {},
      "source": [
        "A maneira mais fácil de visualizar essas informações é por meio do método [`draw`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#draw) que retorna uma visualização de um circuito. Consulte [Visualizar circuitos](./visualize-circuits) para conhecer diferentes maneiras de exibir circuitos quânticos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "43a57258-3e33-4071-8a48-2bf127c8a5be",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/43a57258-3e33-4071-8a48-2bf127c8a5be-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ab5f4bc9-7d7c-4ee7-b1bc-70a313b4fe29",
      "metadata": {},
      "source": [
        "Os objetos de instrução de circuito podem conter circuitos de \"definição\" que descrevem a instrução em termos de instruções mais fundamentais. Por exemplo, o [X-gate](/docs/api/qiskit/qiskit.circuit.library.XGate) é definido como um caso específico do [U3-gate](/docs/api/qiskit/qiskit.circuit.library.U3Gate) um portão de um único qubit mais geral.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "653e2427-e301-4d2f-84de-1959185ace8e",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/653e2427-e301-4d2f-84de-1959185ace8e-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Draw definition circuit of 0th instruction in `qc`\n",
        "qc.data[0].operation.definition.draw(\"mpl\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "id": "ee893af1-db43-449f-bfc4-8f636bd98546",
      "metadata": {},
      "source": [
        "As instruções e os circuitos são semelhantes, pois ambos descrevem operações em bits e qubits, mas têm finalidades diferentes:\n",
        "\n",
        "* As instruções são tratadas como fixas, e seus métodos geralmente retornam novas instruções (sem alterar o objeto original).\n",
        "* Os circuitos são projetados para serem construídos com muitas linhas de código, e [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) e os métodos geralmente alteram o objeto existente.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2e451022",
      "metadata": {},
      "source": [
        "<span id=\"what-is-circuit-depth\" />\n",
        "\n",
        "### O que é profundidade de circuito?\n",
        "\n",
        "A [profundidade()](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.depth) de um circuito quântico é uma medida do número de \"camadas\" de portas quânticas, executadas em paralelo, necessárias para concluir o cálculo definido pelo circuito. Como as portas quânticas levam tempo para serem implementadas, a profundidade de um circuito corresponde aproximadamente à quantidade de tempo que o computador quântico leva para executar o circuito. Assim, a profundidade de um circuito é uma quantidade importante usada para medir se um circuito quântico pode ser executado em um dispositivo.\n",
        "\n",
        "O restante desta página ilustra como manipular circuitos quânticos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ff4f08f3-48eb-454c-9647-2af505bf79bc",
      "metadata": {},
      "source": [
        "<span id=\"build-circuits\" />\n",
        "\n",
        "## Construa circuitos\n",
        "\n",
        "Métodos como [`QuantumCircuit.h`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#h) e [`QuantumCircuit.cx`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#cx) adicionam instruções específicas aos circuitos. Para adicionar instruções a um circuito de forma mais geral, use o método [`append`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#append) método. Isso recebe uma instrução e uma lista de qubits aos quais aplicar a instrução. Consulte a [documentação da API da biblioteca de circuitos](/docs/api/qiskit/circuit_library) para obter uma lista das instruções compatíveis.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "66813cae-9841-47ea-96b7-8fd7b82e9759",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/66813cae-9841-47ea-96b7-8fd7b82e9759-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.circuit.library import HGate\n",
        "\n",
        "qc = QuantumCircuit(1)\n",
        "qc.append(\n",
        "    HGate(),  # New HGate instruction\n",
        "    [0],  # Apply to qubit 0\n",
        ")\n",
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bbdbef08-07c0-4fb0-ab3e-ed6efb7a3dc3",
      "metadata": {},
      "source": [
        "Para combinar dois circuitos, use o método [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) método. Isso aceita outro [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) e uma lista opcional de mapeamentos de qubit.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  O método [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) retorna um novo circuito e **não** altera nenhum dos circuitos em que atua. Para alterar o circuito no qual você está chamando o método [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) use o argumento `inplace=True`.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "29152dfa-2275-4bc4-aadb-82185b9e0e86",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/29152dfa-2275-4bc4-aadb-82185b9e0e86-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc_a = QuantumCircuit(4)\n",
        "qc_a.x(0)\n",
        "\n",
        "qc_b = QuantumCircuit(2, name=\"qc_b\")\n",
        "qc_b.y(0)\n",
        "qc_b.z(1)\n",
        "\n",
        "# compose qubits (0, 1) of qc_a to qubits (1, 3) of qc_b respectively\n",
        "combined = qc_a.compose(qc_b, qubits=[1, 3])\n",
        "combined.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d4529506-8397-4208-9cfd-31e1a1978741",
      "metadata": {},
      "source": [
        "Talvez você também queira compilar circuitos em instruções para manter seus circuitos organizados. Você pode converter um circuito em uma instrução usando o método [`to_instruction`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_instruction) e, em seguida, anexá-lo a outro circuito como faria com qualquer outra instrução. O circuito desenhado na célula seguinte é funcionalmente equivalente ao circuito desenhado na célula anterior.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "81b682dd-45cb-4492-809e-d9e8ebbf5600",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/81b682dd-45cb-4492-809e-d9e8ebbf5600-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "inst = qc_b.to_instruction()\n",
        "qc_a.append(inst, [1, 3])\n",
        "qc_a.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6e81c46b-a2d2-430e-9d3d-73e5030e3548",
      "metadata": {},
      "source": [
        "Se seu circuito for unitário, você poderá convertê-lo em um circuito [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) usando o método [`to_gate`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_gate) método. [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) os objetos são tipos específicos de instruções que têm alguns recursos extras, como o [`control`](/docs/api/qiskit/qiskit.circuit.Gate#control) que adiciona um controle quântico.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "id": "ed362e64-d6a4-4dfd-a5cf-5e6bdc7a81b5",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/ed362e64-d6a4-4dfd-a5cf-5e6bdc7a81b5-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "gate = qc_b.to_gate().control()\n",
        "qc_a.append(gate, [0, 1, 3])\n",
        "qc_a.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae850362-84eb-4998-a2cf-a93a1be4ac2a",
      "metadata": {},
      "source": [
        "Para ver o que está acontecendo, você pode usar o método [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) para expandir cada instrução em sua definição.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  O método [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) retorna um novo circuito e **não** altera o circuito no qual ele atua.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "3c0633db-929b-4428-a888-7a3d493bd6dd",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/3c0633db-929b-4428-a888-7a3d493bd6dd-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc_a.decompose().draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "87f1e053",
      "metadata": {},
      "source": [
        "<span id=\"measure-qubits\" />\n",
        "\n",
        "<span id=\"measure-qubits\" />\n",
        "\n",
        "## Medir qubits\n",
        "\n",
        "As medições são utilizadas para amostrar os estados de qubits individuais e transferir os resultados para um registro clássico. Observe que, se você estiver enviando circuitos para uma [primitiva](/docs/guides/primitives) Sampler, é necessário fornecer as medidas. No entanto, se os circuitos enviados a uma primitiva do Estimador contiverem medidas, essas medidas serão ignoradas.\n",
        "\n",
        "Os Qubits podem ser medidos usando três métodos: [`measure`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.measure), [`measure_all`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_all) e [`measure_active`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_active). Para saber como visualizar os resultados medidos, consulte a página [Visualizar resultados](./visualize-results).\n",
        "\n",
        "1. `QuantumCircuit.measure` mede cada qubit no primeiro argumento sobre o bit clássico fornecido como segundo argumento. Esse método permite controle total sobre onde o resultado da medição é armazenado.\n",
        "\n",
        "2. `QuantumCircuit.measure_all` o termo \"quantum\" não recebe nenhum argumento e pode ser usado para circuitos quânticos sem bits clássicos predefinidos. Ele cria fios clássicos e armazena os resultados das medições em ordem. Por exemplo, a medição do qubit $q_i$ é armazenada no cbit $meas_i$ ). Ele também adiciona uma barreira antes da medição.\n",
        "\n",
        "3. `QuantumCircuit.measure_active` : semelhante ao `measure_all`, mas mede apenas os qubits que têm operações.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "0cdb2273",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/0cdb2273-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc1 = QuantumCircuit(2, 2)\n",
        "qc1.measure(0, 1)\n",
        "qc1.draw(\"mpl\", cregbundle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "6f33698c",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/6f33698c-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc2 = QuantumCircuit(2)\n",
        "qc2.measure_all()\n",
        "qc2.draw(\"mpl\", cregbundle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "ca3f225f",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/ca3f225f-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc3 = QuantumCircuit(2)\n",
        "qc3.x(1)\n",
        "qc3.measure_active()\n",
        "qc3.draw(\"mpl\", cregbundle=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "649fc3fd-caf1-45f1-ad8e-3b5d26ca859b",
      "metadata": {},
      "source": [
        "<span id=\"parameterized-circuits\" />\n",
        "\n",
        "## Circuitos parametrizados\n",
        "\n",
        "Muitos algoritmos quânticos de curto prazo envolvem a execução de muitas variações de um circuito quântico. Como a construção e a otimização de circuitos grandes podem ser computacionalmente caras, o Qiskit oferece suporte a circuitos **parametrizados**. Esses circuitos têm parâmetros indefinidos, e seus valores não precisam ser definidos até pouco antes da execução do circuito. Isso permite que você mova a construção e a otimização do circuito para fora do loop do programa principal.  A célula a seguir cria e exibe um circuito parametrizado.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "a580552c-d585-4047-99f0-32aafd06e4f3",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/a580552c-d585-4047-99f0-32aafd06e4f3-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.transpiler import generate_preset_pass_manager\n",
        "from qiskit.circuit import Parameter\n",
        "\n",
        "angle = Parameter(\"angle\")  # undefined number\n",
        "\n",
        "# Create and optimize circuit once\n",
        "qc = QuantumCircuit(1)\n",
        "qc.rx(angle, 0)\n",
        "qc = generate_preset_pass_manager(\n",
        "    optimization_level=3, basis_gates=[\"u\", \"cx\"]\n",
        ").run(qc)\n",
        "\n",
        "qc.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a174600b-8f4a-47ca-aa4c-cd16dcbecb7c",
      "metadata": {},
      "source": [
        "A célula a seguir cria muitas variações desse circuito e exibe uma das variações.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "85af6231-921a-4130-99d3-f6998f761df8",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/construct-circuits/extracted-outputs/85af6231-921a-4130-99d3-f6998f761df8-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "circuits = []\n",
        "for value in range(100):\n",
        "    circuits.append(qc.assign_parameters({angle: value}))\n",
        "\n",
        "circuits[0].draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ede2ff7c-5e68-4458-87b3-887b5b027ee1",
      "metadata": {},
      "source": [
        "Você pode encontrar uma lista dos parâmetros indefinidos de um circuito em seu atributo `parameters` .\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "0990b840-f8c4-4416-b2b5-9861173a9471",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ParameterView([Parameter(angle)])"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "qc.parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8e415c37",
      "metadata": {},
      "source": [
        "<span id=\"change-a-parameters-name\" />\n",
        "\n",
        "### Alterar o nome de um parâmetro\n",
        "\n",
        "Por padrão, os nomes dos parâmetros de um circuito parametrizado são prefixados por `x`- por exemplo, `x[0]`. Você pode alterar os nomes após defini-los, conforme mostrado no exemplo a seguir.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "id": "1d3e6424",
      "metadata": {},
      "outputs": [],
      "source": [
        "from qiskit.circuit.library import z_feature_map\n",
        "from qiskit.circuit import ParameterVector\n",
        "\n",
        "# Define a parameterized circuit with default names\n",
        "# For example, x[0]\n",
        "circuit = z_feature_map(2)\n",
        "\n",
        "# Set new parameter names\n",
        "# They will now be prefixed by `hi` instead\n",
        "# For example, hi[0]\n",
        "training_params = ParameterVector(\"hi\", 2)\n",
        "\n",
        "# Assign parameter names to the quantum circuit\n",
        "circuit = circuit.assign_parameters(parameters=training_params)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae19e48d",
      "metadata": {},
      "source": [
        "<CodeAssistantAdmonition\n",
        "  tagLine=\"Forgotten the method name? Try asking Qiskit Code Assistant.\"\n",
        "  prompts={[\n",
        "\"# Assign all parameters in qc to 0\"\n",
        "]}\n",
        "/>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5af44bc3",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Próximas etapas\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recomendações\">\n",
        "  * Para saber mais sobre algoritmos quânticos de curto prazo, faça o curso [Variational algorithm design](/learning/courses/variational-algorithm-design).\n",
        "  * Veja um exemplo de circuitos sendo usados no tutorial [do Algoritmo de Grover](/docs/tutorials/grovers-algorithm).\n",
        "  * Trabalhe com circuitos simples usando o [IBM Quantum Composer](/docs/guides/composer).\n",
        "</Admonition>\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
}