{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "58b0ed8c-a233-4d70-9127-b740c757955f",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Transpilar con gestores de pasos\"\n",
        "description: \"Cómo transpilear circuitos cuánticos utilizando gestores de pases en Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"transpile-with-pass-managers\" />\n",
        "\n",
        "# Transpilar con gestores de pasos\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=\"Versiones del paquete\">\n",
        "    El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos.\n",
        "    Recomendamos utilizar estas versiones o versiones más recientes.\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": [
        "La forma recomendada de transpilar un circuito es crear un gestor de pasadas por etapas y luego ejecutar su método `run` con el circuito como entrada. Esta página explica cómo transpilar circuitos cuánticos de esta forma.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47730af4-67a2-44b4-a304-224296926799",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-staged-pass-manager\" />\n",
        "\n",
        "## ¿Qué es un gestor de pases (por etapas)?\n",
        "\n",
        "En el contexto del SDK de Qiskit, la transpilación se refiere al proceso de transformar un circuito de entrada en una forma que sea adecuada para su ejecución en un dispositivo cuántico. La transpilación suele producirse en una secuencia de pasos denominados pases de transpilador. El circuito es procesado por cada paso del transpilador en secuencia, y la salida de un paso se convierte en la entrada del siguiente. Por ejemplo, una pasada podría recorrer el circuito y fusionar todas las secuencias consecutivas de puertas de un solo qubit y, a continuación, la siguiente pasada podría sintetizar estas puertas en el conjunto de bases del dispositivo objetivo. Los pases del transpilador incluidos con Qiskit se encuentran en el módulo [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) módulo.\n",
        "\n",
        "Un gestor de pases es un objeto que almacena una lista de pases del transpilador y puede ejecutarlos en un circuito. Crea un gestor de pases inicializando un [`PassManager`](/docs/api/qiskit/qiskit.transpiler.PassManager) con una lista de pases de transpilador. Para ejecutar la transpilación en un circuito, llame al método [`run`](/docs/api/qiskit/qiskit.transpiler.PassManager#run) con un circuito como entrada.\n",
        "\n",
        "Un gestor de pases por etapas es un tipo especial de gestor de pases que representa un nivel de abstracción superior al de un gestor de pases normal. Mientras que un gestor de pases normal se compone de varios pases de transpilador, un gestor de pases por etapas se compone de varios *gestores de pases*. Se trata de una abstracción útil porque la transpilación suele producirse en etapas discretas, como se describe en [Etapas del transpilador](transpiler-stages), y cada etapa está representada por un gestor de pases. Los gestores de pases por etapas están representados por la clase [`StagedPassManager`](/docs/api/qiskit/qiskit.transpiler.StagedPassManager) clase. El resto de esta página describe cómo crear y personalizar gestores de pases (por etapas).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9d1aaab0-e9e9-4066-9a9a-f551fdc410b9",
      "metadata": {},
      "source": [
        "<span id=\"generate-a-preset-staged-pass-manager\" />\n",
        "\n",
        "## Generar un gestor de pases por etapas preestablecido\n",
        "\n",
        "Para crear un gestor de pasadas por etapas preconfigurado con valores predeterminados razonables, utiliza la [`generate_preset_pass_manager`](/docs/api/qiskit/qiskit.transpiler.generate_preset_pass_manager#qiskit.transpiler.generate_preset_pass_manager) función.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  En estos ejemplos se utiliza el backend `FakeSherbrooke``qiskit_ibm_runtime` simulado de, pero puedes probarlo con cualquier backend real o simulado compatible con Qiskit.  Tus resultados pueden 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 un circuito o una lista de circuitos con un gestor de pases, pase el circuito o la lista de circuitos al método `run` . Hagámoslo en un circuito de dos qubits consistente en un Hadamard seguido de dos puertas CX adyacentes:\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 [Valores predeterminados de transpilación y opciones de configuración](defaults-and-configuration-options) para obtener una descripción de los posibles argumentos de la función `generate_preset_pass_manager` . Los argumentos de `generate_preset_pass_manager` coinciden con los argumentos de la función [`transpile`](/docs/api/qiskit/compiler#qiskit.compiler.transpile) función.\n",
        "\n",
        "Si los gestores de pases predefinidos no satisfacen sus necesidades, personalice la transpilación creando gestores de pases (por etapas) o incluso pases de transpilación. El resto de esta página describe cómo crear gestores de acceso. Para obtener instrucciones sobre cómo crear pases de transpilación, consulte [Escriba su propio pase de transpilación](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",
        "## Crea tu propio gestor de pases\n",
        "\n",
        "El módulo [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) incluye muchos pases de transpilador que pueden utilizarse para crear gestores de pases. Para crear un gestor de pases, inicialice un `PassManager` con una lista de pases. Por ejemplo, el siguiente código crea un pase de transpilador que fusiona puertas adyacentes de dos qubits y luego las sintetiza en una base de [$R_y$](/docs/api/qiskit/qiskit.circuit.library.RYGate), [$R_z$](/docs/api/qiskit/qiskit.circuit.library.RZGate) y [$R_{xx}$](/docs/api/qiskit/qiskit.circuit.library.RXXGate).\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 demostrar este gestor de pases en acción, pruébalo en un circuito de dos qubits formado por un Hadamard seguido de dos puertas CX adyacentes:\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 ejecutar el gestor de pases en el circuito, llame al 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 obtener un ejemplo más avanzado que muestra cómo crear un administrador de pases para implementar la técnica de supresión de errores conocida como desacoplamiento dinámico, consulte [Crear un administrador de pases para desacoplamiento 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",
        "## Crear un gestor de pases por etapas\n",
        "\n",
        "Un `StagedPassManager` es un gestor de pases que se compone de etapas individuales, donde cada etapa está definida por una instancia `PassManager` . Puede crear una `StagedPassManager` especificando las etapas deseadas. Por ejemplo, el siguiente código crea un gestor de pases por etapas con dos etapas, `init` y `translation`. La etapa `translation` está definida por el gestor de pases creado 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": [
        "No hay límite en el número de etapas que puedes poner en un gestor de pases por etapas.\n",
        "\n",
        "Otra forma útil de crear un gestor de pases por etapas es comenzar con un gestor de pases por etapas preestablecido y luego intercambiar algunas de las etapas. Por ejemplo, el siguiente código genera un gestor de pases preestablecido con un nivel de optimización 3 y, a continuación, especifica una etapa personalizada `pre_layout` .\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": [
        "Las [funciones del generador de etapas](/docs/api/qiskit/transpiler_preset#stage-generator-functions) pueden ser útiles para construir gestores de pases personalizados.\n",
        "Generan etapas que proporcionan funcionalidades comunes utilizadas en muchos gestores de pases.\n",
        "Por ejemplo, [`generate_embed_passmanager`](/docs/api/qiskit/transpiler_preset#qiskit.transpiler.preset_passmanagers.generate_embed_passmanager) puede utilizarse para generar una etapa para \"incrustar\" un `Layout` inicial seleccionado de un pase de diseño en el dispositivo de destino especificado.\n",
        "\n",
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Próximos pasos\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recomendación\">\n",
        "  * [Escribir un pase de transpilador personalizado](custom-transpiler-pass).\n",
        "  * [Crear un gestor de pases para el desacoplamiento dinámico](dynamical-decoupling-pass-manager).\n",
        "  * Para obtener más información sobre la función `generate_preset_passmanager` , consulte el tema [Ajustes por defecto y opciones de configuración de la transpilación](defaults-and-configuration-options).\n",
        "  * Prueba la guía [de configuración del transpilador Compare](/docs/guides/circuit-transpilation-settings).\n",
        "  * Revisa la [documentación de la API del transpilador](/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
}