{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "58b0ed8c-a233-4d70-9127-b740c757955f",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Transpile com gerenciadores de etapas\"\n",
        "description: \"Como transpilá-los usando gerenciadores de passagem no Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"transpile-with-pass-managers\" />\n",
        "\n",
        "# Transpile com gerenciadores de etapas\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a6414f1d-e0c5-4022-b297-719ea5958842",
      "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.5.0\n",
        "    qiskit-ibm-runtime~=0.47.0\n",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d93f555a-6238-4660-91b5-181ae0da4a53",
      "metadata": {},
      "source": [
        "A maneira recomendada de transpilar um circuito é criar um gerenciador de passagens em etapas e, em seguida, executar seu método `run` com o circuito como entrada. Esta página explica como transpilar circuitos quânticos dessa forma.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47730af4-67a2-44b4-a304-224296926799",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-staged-pass-manager\" />\n",
        "\n",
        "## O que é um gerenciador de senhas (em etapas)?\n",
        "\n",
        "No contexto do Qiskit SDK, a transpilação refere-se ao processo de transformação de um circuito de entrada em um formato adequado para execução em um dispositivo quântico. Normalmente, a transpilação ocorre em uma sequência de etapas denominadas passagens do transpilador. O circuito é processado por cada passagem do transpilador em sequência, com a saída de uma passagem se tornando a entrada para a próxima. Por exemplo, uma passagem poderia percorrer o circuito e mesclar todas as sequências consecutivas de portas de um único qubit e, em seguida, a próxima passagem poderia sintetizar essas portas no conjunto de base do dispositivo de destino. As passagens do transpilador incluídas no Qiskit estão localizadas no módulo [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) módulo.\n",
        "\n",
        "Um gerenciador de passes é um objeto que armazena uma lista de passes do transpilador e pode executá-los em um circuito. Crie um gerenciador de passes inicializando um [`PassManager`](/docs/api/qiskit/qiskit.transpiler.PassManager) com uma lista de passagens do transpilador. Para executar a transpilação em um circuito, chame o método [`run`](/docs/api/qiskit/qiskit.transpiler.PassManager#run) com um circuito como entrada.\n",
        "\n",
        "Um gerenciador de passagens em estágios é um tipo especial de gerenciador de passagens que representa um nível de abstração superior ao de um gerenciador de passagens normal. Enquanto um gerenciador de passes normal é composto de vários passes de transpiladores, um gerenciador de passes em estágios é composto de vários *gerenciadores de passes*. Essa é uma abstração útil porque a transpilação normalmente ocorre em estágios discretos, conforme descrito em [Estágios do transpilador](transpiler-stages), com cada estágio sendo representado por um gerenciador de passagem. Os gerenciadores de passagens em estágios são representados pela classe [`StagedPassManager`](/docs/api/qiskit/qiskit.transpiler.StagedPassManager) classe. O restante desta página descreve como criar e personalizar gerenciadores de passes (em etapas).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9d1aaab0-e9e9-4066-9a9a-f551fdc410b9",
      "metadata": {},
      "source": [
        "<span id=\"generate-a-preset-staged-pass-manager\" />\n",
        "\n",
        "## Gerar um gerenciador de passes pré-definido\n",
        "\n",
        "Para criar um gerenciador de passagens pré-configurado com valores padrão adequados, use a [`generate_preset_pass_manager`](/docs/api/qiskit/qiskit.transpiler.generate_preset_pass_manager#qiskit.transpiler.generate_preset_pass_manager) função.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  Nestes exemplos, é utilizado o backend `FakeSherbrooke``qiskit_ibm_runtime` simulado do, mas você pode testá-lo em qualquer backend real ou simulado compatível com o Qiskit.  Seus resultados podem ser diferentes.\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "293c1f9f-f9da-4c60-b456-80fea88b1194",
      "metadata": {},
      "outputs": [],
      "source": [
        "from qiskit.transpiler import generate_preset_pass_manager\n",
        "from qiskit_ibm_runtime.fake_provider import FakeSherbrooke\n",
        "\n",
        "backend = FakeSherbrooke()\n",
        "pass_manager = generate_preset_pass_manager(\n",
        "    optimization_level=3, backend=backend\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7796dd8b-5f42-4712-bcd8-ebff5096c5f1",
      "metadata": {},
      "source": [
        "Para transpilar um circuito ou uma lista de circuitos com um gerenciador de passagem, passe o circuito ou a lista de circuitos para o método `run` . Vamos fazer isso em um circuito de dois qubits que consiste em um Hadamard seguido por duas portas CX adjacentes:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "c1426e6c-f506-4938-8c0a-05198bae9746",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/transpile-with-pass-managers/extracted-outputs/c1426e6c-f506-4938-8c0a-05198bae9746-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit import QuantumRegister, QuantumCircuit\n",
        "\n",
        "# Create a circuit\n",
        "qubits = QuantumRegister(2, name=\"q\")\n",
        "circuit = QuantumCircuit(qubits)\n",
        "a, b = qubits\n",
        "circuit.h(a)\n",
        "circuit.cx(a, b)\n",
        "circuit.cx(b, a)\n",
        "\n",
        "# Transpile it by calling the run method of the pass manager\n",
        "transpiled = pass_manager.run(circuit)\n",
        "\n",
        "# Draw it, excluding idle qubits from the diagram\n",
        "transpiled.draw(\"mpl\", idle_wires=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9568b846-12b9-4de0-88a7-594d14312db4",
      "metadata": {},
      "source": [
        "Consulte [Padrões de transpilação e opções de configuração](defaults-and-configuration-options) para obter uma descrição dos possíveis argumentos da função `generate_preset_pass_manager` . Os argumentos para `generate_preset_pass_manager` correspondem aos argumentos para a função [`transpile`](/docs/api/qiskit/compiler#qiskit.compiler.transpile) função.\n",
        "\n",
        "Se os gerenciadores de passagem predefinidos não atenderem às suas necessidades, personalize a transpilação criando gerenciadores de passagem (em etapas) ou até mesmo passagens de transpilação. O restante desta página descreve como criar gerenciadores de passes. Para obter instruções sobre como criar passagens de transpilação, consulte [Escreva sua própria passagem de transpilação](custom-transpiler-pass).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2a6d45c6-1d88-4566-92f2-0ae149c606fa",
      "metadata": {},
      "source": [
        "<span id=\"create-your-own-pass-manager\" />\n",
        "\n",
        "## Crie seu próprio gerenciador de passes\n",
        "\n",
        "O módulo [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) inclui muitas passagens do transpilador que podem ser usadas para criar gerenciadores de passagens. Para criar um gerenciador de passes, inicialize um `PassManager` com uma lista de passes. Por exemplo, o código a seguir cria uma passagem de transpilador que mescla portas de dois qubits adjacentes e, em seguida, as sintetiza em uma base de [$R_y$](/docs/api/qiskit/qiskit.circuit.library.RYGate), [$R_z$](/docs/api/qiskit/qiskit.circuit.library.RZGate), e [$R_{xx}$](/docs/api/qiskit/qiskit.circuit.library.RXXGate) portas.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "054a634f-958a-49e3-81d5-c53257e25b65",
      "metadata": {},
      "outputs": [],
      "source": [
        "from qiskit.transpiler import PassManager\n",
        "from qiskit.transpiler.passes import (\n",
        "    Collect2qBlocks,\n",
        "    ConsolidateBlocks,\n",
        "    UnitarySynthesis,\n",
        ")\n",
        "\n",
        "basis_gates = [\"rx\", \"ry\", \"rxx\"]\n",
        "translate = PassManager(\n",
        "    [\n",
        "        Collect2qBlocks(),\n",
        "        ConsolidateBlocks(basis_gates=basis_gates),\n",
        "        UnitarySynthesis(basis_gates),\n",
        "    ]\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a93ff400-d04e-4aa1-9a70-4f583425cc3c",
      "metadata": {},
      "source": [
        "Para demonstrar esse gerenciador de passagem em ação, teste-o em um circuito de dois qubits que consiste em um Hadamard seguido por duas portas CX adjacentes:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "01317c54-68b5-4e41-893f-82ee223e22f0",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/transpile-with-pass-managers/extracted-outputs/01317c54-68b5-4e41-893f-82ee223e22f0-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit import QuantumRegister, QuantumCircuit\n",
        "\n",
        "qubits = QuantumRegister(2, name=\"q\")\n",
        "circuit = QuantumCircuit(qubits)\n",
        "\n",
        "a, b = qubits\n",
        "circuit.h(a)\n",
        "circuit.cx(a, b)\n",
        "circuit.cx(b, a)\n",
        "\n",
        "circuit.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1a852fa1-6fe0-42b7-b6ad-26c29e844a3a",
      "metadata": {},
      "source": [
        "Para executar o gerenciador de passes no circuito, chame o método `run` .\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "019ad99b-bd38-4217-90ee-da43959dc8ad",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<Image src=\"/docs/images/guides/transpile-with-pass-managers/extracted-outputs/019ad99b-bd38-4217-90ee-da43959dc8ad-0.svg\" alt=\"Output of the previous code cell\" />"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "translated = translate.run(circuit)\n",
        "translated.draw(\"mpl\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bc0944c9-b25f-4efe-a6ab-9ae4b5b27976",
      "metadata": {},
      "source": [
        "Para obter um exemplo mais avançado que mostre como criar um gerenciador de passes para implementar a técnica de supressão de erros conhecida como desacoplamento dinâmico, consulte [Criar um gerenciador de passes para desacoplamento dinâmico](dynamical-decoupling-pass-manager).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0abb7cb1-3a5e-42c1-9817-f2838ad98b98",
      "metadata": {},
      "source": [
        "<span id=\"create-a-staged-pass-manager\" />\n",
        "\n",
        "## Criar um gerenciador de passes em etapas\n",
        "\n",
        "O `StagedPassManager` é um gerenciador de passes composto de estágios individuais, em que cada estágio é definido por uma instância do `PassManager` . Você pode criar um `StagedPassManager` especificando os estágios desejados. Por exemplo, o código a seguir cria um gerenciador de passes em estágios com dois estágios, `init` e `translation`. O estágio `translation` é definido pelo gerenciador de passes que foi criado anteriormente.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "8f1c1a26-b6bc-470c-9b8a-7f9d53db8b01",
      "metadata": {},
      "outputs": [],
      "source": [
        "from qiskit.transpiler import PassManager, StagedPassManager\n",
        "from qiskit.transpiler.passes import UnitarySynthesis, Unroll3qOrMore\n",
        "\n",
        "basis_gates = [\"rx\", \"ry\", \"rxx\"]\n",
        "init = PassManager(\n",
        "    [UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()]\n",
        ")\n",
        "staged_pm = StagedPassManager(\n",
        "    stages=[\"init\", \"translation\"], init=init, translation=translate\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "45d3105f-e852-4571-b221-70bf517ff519",
      "metadata": {},
      "source": [
        "Não há limite para o número de etapas que você pode colocar em um gerenciador de passes por etapas.\n",
        "\n",
        "Outra maneira útil de criar um gerenciador de passes em etapas é começar com um gerenciador de passes em etapas predefinido e, em seguida, trocar algumas das etapas. Por exemplo, o código a seguir gera um gerenciador de passagens predefinido com nível de otimização 3 e, em seguida, especifica um estágio `pre_layout` personalizado.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "2a2b86b9-f46a-460b-b2d6-5962cffeec01",
      "metadata": {},
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from qiskit.circuit.library import HGate, PhaseGate, RXGate, TdgGate, TGate\n",
        "from qiskit.transpiler.passes import InverseCancellation\n",
        "\n",
        "pass_manager = generate_preset_pass_manager(3, backend)\n",
        "inverse_gate_list = [\n",
        "    HGate(),\n",
        "    (RXGate(np.pi / 4), RXGate(-np.pi / 4)),\n",
        "    (PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4)),\n",
        "    (TGate(), TdgGate()),\n",
        "]\n",
        "logical_opt = PassManager(\n",
        "    [\n",
        "        InverseCancellation(inverse_gate_list),\n",
        "    ]\n",
        ")\n",
        "\n",
        "# Add pre-layout stage to run extra logical optimization\n",
        "pass_manager.pre_layout = logical_opt"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9d49e4a5-2868-4f09-85f8-a0b89f35338c",
      "metadata": {},
      "source": [
        "As [funções do gerador de estágios](/docs/api/qiskit/transpiler_preset#stage-generator-functions) podem ser úteis para a construção de gerenciadores de passagens personalizados.\n",
        "Eles geram estágios que fornecem funcionalidade comum usada em muitos gerenciadores de passes.\n",
        "Por exemplo, [`generate_embed_passmanager`](/docs/api/qiskit/transpiler_preset#qiskit.transpiler.preset_passmanagers.generate_embed_passmanager) pode ser usado para gerar um estágio para \"incorporar\" uma inicial selecionada `Layout` de uma passagem de layout para o dispositivo de destino especificado.\n",
        "\n",
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Próximas etapas\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recomendação\">\n",
        "  * [Escreva uma passagem de transpilador personalizada](custom-transpiler-pass).\n",
        "  * [Criar um gerenciador de passes para desacoplamento dinâmico](dynamical-decoupling-pass-manager).\n",
        "  * Para saber mais sobre a função `generate_preset_passmanager` , consulte o tópico [Definições padrão de transpilação e opções de configuração](defaults-and-configuration-options).\n",
        "  * Experimente o guia [Comparar configurações do transpiler](/docs/guides/circuit-transpilation-settings).\n",
        "  * Consulte a [documentação da API do transpiler](/docs/api/qiskit/transpiler).\n",
        "</Admonition>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "id": "a1b8767d",
      "source": "© IBM Corp., 2017-2026"
    }
  ],
  "metadata": {
    "celltoolbar": "Raw Cell Format",
    "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
}