{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "58b0ed8c-a233-4d70-9127-b740c757955f",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Transpilare con gestori di passaggi\"\n",
        "description: \"Come transpilare circuiti quantistici utilizzando i gestori di passaggi in Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"transpile-with-pass-managers\" />\n",
        "\n",
        "# Transpilare con gestori di passaggi\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=\"Versioni del pacchetto\">\n",
        "    Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti.\n",
        "    Si consiglia di utilizzare queste versioni o versioni più recenti.\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": [
        "Il modo consigliato per transpilare un circuito è quello di creare uno staged pass manager e poi eseguire il suo metodo `run` con il circuito come input. Questa pagina spiega come trasporre i circuiti quantistici in questo modo.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47730af4-67a2-44b4-a304-224296926799",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-staged-pass-manager\" />\n",
        "\n",
        "## Che cos'è un gestore di pass (a più livelli)?\n",
        "\n",
        "Nel contesto del Qiskit SDK, la transpilazione si riferisce al processo di trasformazione di un circuito di input in una forma adatta all'esecuzione su un dispositivo quantistico. La trasposizione avviene tipicamente in una sequenza di passaggi chiamati passaggi di trasposizione. Il circuito viene elaborato da ciascun passaggio del transpiler in sequenza, con l'uscita di un passaggio che diventa l'ingresso del successivo. Ad esempio, un passaggio potrebbe passare attraverso il circuito e unire tutte le sequenze consecutive di porte a singolo qubit, e poi il passaggio successivo potrebbe sintetizzare queste porte nell'insieme di basi del dispositivo di destinazione. I passaggi del transpiler inclusi in Qiskit si trovano nel modulo [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) modulo.\n",
        "\n",
        "Un gestore di passaggi è un oggetto che memorizza un elenco di passaggi del transpiler e può eseguirli su un circuito. Crea un gestore di passaggi inizializzando un file [`PassManager`](/docs/api/qiskit/qiskit.transpiler.PassManager) con un elenco di passaggi del transpiler. Per eseguire la transpilazione su un circuito, richiamare il metodo [`run`](/docs/api/qiskit/qiskit.transpiler.PassManager#run) con un circuito in ingresso.\n",
        "\n",
        "Un gestore di passaggi staged è un tipo speciale di gestore di passaggi che rappresenta un livello di astrazione superiore a quello di un normale gestore di passaggi. Mentre un normale pass manager è composto da diversi pass transpiler, uno staged pass manager è composto da diversi *pass manager*. Si tratta di un'astrazione utile perché la transpilazione avviene tipicamente in stadi discreti, come descritto in [Stadi del transpiler](transpiler-stages), e ogni stadio è rappresentato da un gestore di passaggi. I gestori di passaggi a tappe sono rappresentati dalla classe [`StagedPassManager`](/docs/api/qiskit/qiskit.transpiler.StagedPassManager) classe. Il resto di questa pagina descrive come creare e personalizzare i gestori di passaggi (staged).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9d1aaab0-e9e9-4066-9a9a-f551fdc410b9",
      "metadata": {},
      "source": [
        "<span id=\"generate-a-preset-staged-pass-manager\" />\n",
        "\n",
        "## Genera un gestore di passaggi preimpostato\n",
        "\n",
        "Per creare un gestore di passaggi predefinito con impostazioni predefinite adeguate, utilizzare la [`generate_preset_pass_manager`](/docs/api/qiskit/qiskit.transpiler.generate_preset_pass_manager#qiskit.transpiler.generate_preset_pass_manager) funzione.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  In questi esempi viene utilizzato il backend `FakeSherbrooke``qiskit_ibm_runtime` fittizio di, ma è possibile provarlo su qualsiasi backend reale o fittizio compatibile con Qiskit.  I tuoi risultati potrebbero essere diversi.\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": [
        "Per transpilare un circuito o un elenco di circuiti con un pass manager, passare il circuito o l'elenco di circuiti al metodo `run` . Eseguiamo questa operazione su un circuito a due equbit costituito da un Hadamard seguito da due porte CX adiacenti:\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": [
        "Per una descrizione dei possibili argomenti della funzione `generate_preset_pass_manager` , vedere [Valori predefiniti e opzioni di configurazione della transpilazione](defaults-and-configuration-options). Gli argomenti di `generate_preset_pass_manager` corrispondono agli argomenti della funzione [`transpile`](/docs/api/qiskit/compiler#qiskit.compiler.transpile) funzione.\n",
        "\n",
        "Se i gestori di passaggi preimpostati non soddisfano le vostre esigenze, potete personalizzare la transpilazione creando gestori di passaggi (a stadi) o addirittura passaggi di transpilazione. Il resto di questa pagina descrive come creare i gestori di pass. Per istruzioni su come creare passaggi di transpilazione, vedere [Scrivere il proprio passaggio di transpiler](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 il tuo gestore di pass\n",
        "\n",
        "Il modulo [qiskit.transpiler.passes](/docs/api/qiskit/transpiler_passes) include molti passaggi di transpiler che possono essere usati per creare gestori di passaggi. Per creare un gestore di pass, inizializzare un `PassManager` con un elenco di pass. Ad esempio, il codice seguente crea un passaggio di transpiler che unisce porte adiacenti a due qubit e poi le sintetizza in una base di [$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), porte.\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": [
        "Per dimostrare l'azione di questo pass manager, testatelo su un circuito a due equbit costituito da un Hadamard seguito da due porte CX adiacenti:\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": [
        "Per eseguire il pass manager sul circuito, chiamare il metodo `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": [
        "Per un esempio più avanzato che mostra come creare un gestore di passaggi per implementare la tecnica di soppressione degli errori nota come disaccoppiamento dinamico, vedere [Creare un gestore di passaggi per il disaccoppiamento dinamico](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",
        "## Creare un gestore di passaggi graduali\n",
        "\n",
        "Un `StagedPassManager` è un gestore di passaggi composto da singoli stadi, dove ogni stadio è definito da un'istanza `PassManager` . È possibile creare un sito `StagedPassManager` specificando le fasi desiderate. Ad esempio, il codice seguente crea uno staged pass manager con due stadi, `init` e `translation`. Lo stadio `translation` è definito dal gestore dei passaggi creato in precedenza.\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": [
        "Non c'è limite al numero di tappe che si possono inserire in un gestore di staged pass.\n",
        "\n",
        "Un altro modo utile per creare uno staged pass manager è quello di iniziare con uno staged pass manager preimpostato e poi scambiare alcuni degli stadi. Ad esempio, il codice seguente genera un gestore di passaggi preimpostato con livello di ottimizzazione 3 e specifica uno stadio `pre_layout` personalizzato.\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": [
        "Le [funzioni del generatore di fasi](/docs/api/qiskit/transpiler_preset#stage-generator-functions) potrebbero essere utili per creare gestori di passaggi personalizzati.\n",
        "Generano stadi che forniscono funzionalità comuni utilizzate in molti gestori di passaggi.\n",
        "Ad esempio, [`generate_embed_passmanager`](/docs/api/qiskit/transpiler_preset#qiskit.transpiler.preset_passmanagers.generate_embed_passmanager) può essere usato per generare uno stage per \"incorporare\" un `Layout` iniziale selezionato da un passaggio di layout nel dispositivo di destinazione specificato.\n",
        "\n",
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Passi successivi\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Suggerimento\">\n",
        "  * [Scrivere un passaggio di transpiler personalizzato](custom-transpiler-pass).\n",
        "  * [Creare un gestore di passaggi per il disaccoppiamento dinamico](dynamical-decoupling-pass-manager).\n",
        "  * Per saperne di più su `generate_preset_passmanager` funzione, vedere l'argomento [Impostazioni predefinite e opzioni di configurazione della traduzione](defaults-and-configuration-options).\n",
        "  * Prova la guida [Confronta le impostazioni del transpiler](/docs/guides/circuit-transpilation-settings).\n",
        "  * Consulta [la documentazione dell'API del 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
}