{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "58b0ed8c-a233-4d70-9127-b740c757955f",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Transpiler avec gestionnaires de passes\"\n",
        "description: \"Comment transcompiler des circuits quantiques à l'aide de gestionnaires de passes dans Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"transpile-with-pass-managers\" />\n",
        "\n",
        "# Transpiler avec gestionnaires de passes\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=\"Versions de package\">\n",
        "    Le code de cette page a été développé en tenant compte des exigences suivantes.\n",
        "    Nous recommandons d'utiliser ces versions ou des versions plus récentes.\n",
        "\n",
        "    ```\n",
        "    qiskit[all]~=2.5.1\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 méthode recommandée pour transpiler un circuit consiste à créer un gestionnaire de passes par étapes, puis à exécuter sa méthode `run` avec le circuit en entrée. Cette page explique comment transposer les circuits quantiques de cette manière.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47730af4-67a2-44b4-a304-224296926799",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-staged-pass-manager\" />\n",
        "\n",
        "## Qu'est-ce qu'un gestionnaire de passe (étagé)?\n",
        "\n",
        "Dans le contexte du SDK Qiskit, la transpilation fait référence au processus de transformation d'un circuit d'entrée en une forme adaptée à l'exécution sur un dispositif quantique. La transpilation s'effectue généralement en une série d'étapes appelées \"passes de transpilation\". Le circuit est traité par chaque passage du transpondeur en séquence, la sortie d'un passage devenant l'entrée du suivant. Par exemple, une passe pourrait parcourir le circuit et fusionner toutes les séquences consécutives de portes à qubit unique, puis la passe suivante pourrait synthétiser ces portes dans l'ensemble de base du dispositif cible. Les passes de transpilation incluses avec Qiskit sont situées dans le module [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) module.\n",
        "\n",
        "Un gestionnaire de passes est un objet qui stocke une liste de passes de transpondeur et peut les exécuter sur un circuit. Créer un gestionnaire de passes en initialisant un [`PassManager`](/docs/api/qiskit/qiskit.transpiler.PassManager) avec une liste de passes de transpilateur. Pour exécuter la transpilation sur un circuit, appelez la méthode [`run`](/docs/api/qiskit/qiskit.transpiler.PassManager#run) avec un circuit en entrée.\n",
        "\n",
        "Un gestionnaire de passe par étapes est un type spécial de gestionnaire de passe qui représente un niveau d'abstraction supérieur à celui d'un gestionnaire de passe normal. Alors qu'un gestionnaire de laissez-passer normal est composé de plusieurs laissez-passer de transpondeur, un gestionnaire de laissez-passer par étapes est composé de plusieurs *gestionnaires de laissez-passer*. Il s'agit d'une abstraction utile car la transpilation s'effectue généralement par étapes discrètes, comme décrit dans les [étapes du transpilateur](transpiler-stages), chaque étape étant représentée par un gestionnaire de passes. Les gestionnaires de passages échelonnés sont représentés par la classe [`StagedPassManager`](/docs/api/qiskit/qiskit.transpiler.StagedPassManager) classe. Le reste de cette page décrit comment créer et personnaliser les gestionnaires de passe (par étapes).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9d1aaab0-e9e9-4066-9a9a-f551fdc410b9",
      "metadata": {},
      "source": [
        "<span id=\"generate-a-preset-staged-pass-manager\" />\n",
        "\n",
        "## Générer un gestionnaire de passes prédéfini\n",
        "\n",
        "Pour créer un gestionnaire de passes par étapes prédéfini avec des valeurs par défaut raisonnables, utilisez la [`generate_preset_pass_manager`](/docs/api/qiskit/qiskit.transpiler.generate_preset_pass_manager#qiskit.transpiler.generate_preset_pass_manager) fonction.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  Le backend `FakeSherbrooke` fictif de `qiskit_ibm_runtime` est utilisé dans ces exemples, mais vous pouvez l'essayer sur n'importe quel backend réel ou fictif compatible avec Qiskit.  Vos résultats peuvent varier.\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": [
        "Pour transpiler un circuit ou une liste de circuits avec un gestionnaire de passage, passez le circuit ou la liste de circuits à la méthode `run` . Nous allons le faire sur un circuit à deux qubits composé d'un Hadamard suivi de deux portes 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": [
        "Voir les [options de configuration et les valeurs par défaut de la transpilation](defaults-and-configuration-options) pour une description des arguments possibles de la fonction `generate_preset_pass_manager` . Les arguments de `generate_preset_pass_manager` correspondent aux arguments de la fonction [`transpile`](/docs/api/qiskit/compiler#qiskit.compiler.transpile) de la fonction.\n",
        "\n",
        "Si les gestionnaires de passe prédéfinis ne répondent pas à vos besoins, personnalisez la transpilation en créant des gestionnaires de passe (échelonnés) ou même des passes de transpilation. Le reste de cette page décrit comment créer des gestionnaires de passe. Pour savoir comment créer des passes de transpilation, voir [Rédiger votre propre passe de transpilation](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",
        "## Créez votre propre gestionnaire de passes\n",
        "\n",
        "Le module [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) comprend de nombreuses passes de transpilation qui peuvent être utilisées pour créer des gestionnaires de passes. Pour créer un gestionnaire de laissez-passer, initialisez un site `PassManager` avec une liste de laissez-passer. Par exemple, le code suivant crée une passe de transpilation qui fusionne des portes adjacentes à deux qubits, puis les synthétise dans une base de [$R_y$](/docs/api/qiskit/qiskit.circuit.library.RYGate), [$R_z$](/docs/api/qiskit/qiskit.circuit.library.RZGate), et [$R_{xx}$](/docs/api/qiskit/qiskit.circuit.library.RXXGate) et de portes,.\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": [
        "Pour démontrer l'efficacité de ce gestionnaire de passage, nous le testons sur un circuit à deux qubits composé d'un Hadamard suivi de deux portes 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": [
        "Pour exécuter le gestionnaire de passe sur le circuit, appelez la méthode `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": [
        "Pour un exemple plus avancé qui montre comment créer un gestionnaire de passe pour mettre en œuvre la technique de suppression des erreurs connue sous le nom de découplage dynamique, voir [Créer un gestionnaire de passe pour le découplage dynamique.](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",
        "## Créer un gestionnaire de passes par étapes\n",
        "\n",
        "Un site `StagedPassManager` est un gestionnaire de passage composé d'étapes individuelles, chaque étape étant définie par une instance `PassManager` . Vous pouvez créer un site `StagedPassManager` en spécifiant les étapes souhaitées. Par exemple, le code suivant crée un gestionnaire de passes par étapes avec deux étapes, `init` et `translation`. L'étape `translation` est définie par le gestionnaire de passe créé précédemment.\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": [
        "Il n'y a pas de limite au nombre d'étapes que vous pouvez mettre dans un gestionnaire de passes par étapes.\n",
        "\n",
        "Une autre façon utile de créer un gestionnaire de laissez-passer par étapes consiste à commencer par un gestionnaire de laissez-passer par étapes prédéfini, puis à intervertir certaines des étapes. Par exemple, le code suivant génère un gestionnaire de passe prédéfini avec un niveau d'optimisation 3, puis spécifie une étape personnalisée `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": [
        "Les [fonctions du générateur d'étapes](/docs/api/qiskit/transpiler_preset#stage-generator-functions) peuvent être utiles pour construire des gestionnaires de passe personnalisés.\n",
        "Ils génèrent des étapes qui fournissent des fonctionnalités communes utilisées dans de nombreux gestionnaires de passe.\n",
        "Par exemple, [`generate_embed_passmanager`](/docs/api/qiskit/transpiler_preset#qiskit.transpiler.preset_passmanagers.generate_embed_passmanager) peut être utilisé pour générer une étape pour \"incorporer\" un site initial sélectionné `Layout` à partir d'un passage de mise en page vers le dispositif cible spécifié.\n",
        "\n",
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Etapes suivantes\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recommandation\">\n",
        "  * [Écrire une passe de transposition personnalisée](custom-transpiler-pass).\n",
        "  * [Créer un gestionnaire de passes pour le découplage dynamique](dynamical-decoupling-pass-manager).\n",
        "  * Pour en savoir plus sur la fonction `generate_preset_passmanager` , voir la rubrique [Paramètres par défaut et options de configuration de la transpilation](defaults-and-configuration-options).\n",
        "  * Consultez le guide [Comparer les paramètres du transpiler](/docs/guides/circuit-transpilation-settings).\n",
        "  * Consultez [la documentation relative à l'API du transcompilateur](/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
}