{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "bc54d7bc-b2d8-4b30-9b0b-05689e07a463",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Construire des circuits\"\n",
        "description: \"Comment construire et visualiser des circuits quantiques dans Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"construct-circuits\" />\n",
        "\n",
        "# Construire des circuits\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=\"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",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d",
      "metadata": {},
      "source": [
        "Cette page examine de plus près la classe [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) dans le SDK Qiskit, y compris certaines méthodes plus avancées que vous pouvez utiliser pour créer des circuits quantiques.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2664d407-aa95-43a3-9101-d3ad58c2df58",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-quantum-circuit\" />\n",
        "\n",
        "## Qu'est-ce qu'un circuit quantique?\n",
        "\n",
        "Un circuit quantique simple est une collection de qubits et une liste d'instructions qui agissent sur ces qubits. Pour le démontrer, la cellule suivante crée un nouveau circuit avec deux nouveaux qubits, puis affiche l'attribut [`qubits`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qubits) du circuit, qui est une liste de [`Qubits`](/docs/api/qiskit/circuit#qiskit.circuit.Qubit) dans l'ordre du bit le moins significatif $q_0$ au bit le plus significatif $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": [
        "Plusieurs objets `QuantumRegister` et `ClassicalRegister` peuvent être combinés pour créer un circuit. Chaque [`QuantumRegister`](/docs/api/qiskit/circuit#qiskit.circuit.QuantumRegister) et [`ClassicalRegister`](/docs/api/qiskit/circuit#qiskit.circuit.ClassicalRegister) peuvent également être nommés.\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": [
        "Vous pouvez trouver l'index et le registre d'un qubit en utilisant la méthode et les attributs du circuit [`find_bit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.find_bit) du circuit et de ses attributs.\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": [
        "L'ajout d'une instruction au circuit ajoute l'instruction à l'attribut du circuit [`data`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#data) du circuit. La sortie de cellule suivante montre que `data` est une liste d'objets qui ont chacun un attribut et un attribut [`CircuitInstruction`](/docs/api/qiskit/qiskit.circuit.CircuitInstruction) objets, dont chacun possède un attribut `operation` et un attribut `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": [
        "La manière la plus simple de consulter ces informations consiste à utiliser la [`draw`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#draw) méthode, qui renvoie une représentation graphique du circuit. Consultez [la section « Visualisation des circuits](/docs/guides/visualize-circuits) » pour découvrir différentes façons de représenter les circuits quantiques.\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": [
        "Les objets d'instruction de circuit peuvent contenir des circuits de \"définition\" qui décrivent l'instruction en termes d'instructions plus fondamentales. Par exemple, la [porte X](/docs/api/qiskit/qiskit.circuit.library.XGate) est définie comme un cas spécifique de la [U3-gate](/docs/api/qiskit/qiskit.circuit.library.U3Gate), une porte à qubit unique plus générale.\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": [
        "Les instructions et les circuits sont similaires en ce sens qu'ils décrivent tous deux des opérations sur des bits et des qubits, mais ils ont des objectifs différents :\n",
        "\n",
        "* Les instructions sont considérées comme fixes et leurs méthodes renvoient généralement de nouvelles instructions (sans modifier l'objet d'origine).\n",
        "* Les circuits sont conçus pour être construits sur plusieurs lignes de code, et les méthodes mutent souvent l'objet existant [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) mutent souvent l'objet existant.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2e451022",
      "metadata": {},
      "source": [
        "<span id=\"what-is-circuit-depth\" />\n",
        "\n",
        "### Qu'est-ce que la profondeur de circuit?\n",
        "\n",
        "La [profondeur()](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.depth) d'un circuit quantique est une mesure du nombre de \"couches\" de portes quantiques, exécutées en parallèle, nécessaires pour effectuer le calcul défini par le circuit. Comme la mise en œuvre des portes quantiques prend du temps, la profondeur d'un circuit correspond approximativement au temps qu'il faut à l'ordinateur quantique pour exécuter le circuit. Ainsi, la profondeur d'un circuit est une quantité importante utilisée pour mesurer si un circuit quantique peut être exécuté sur un appareil.\n",
        "\n",
        "Le reste de cette page illustre comment manipuler les circuits quantiques.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ff4f08f3-48eb-454c-9647-2af505bf79bc",
      "metadata": {},
      "source": [
        "<span id=\"build-circuits\" />\n",
        "\n",
        "## Construire des circuits\n",
        "\n",
        "Des méthodes telles que [`QuantumCircuit.h`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#h) et [`QuantumCircuit.cx`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#cx) ajoutent des instructions spécifiques aux circuits. Pour ajouter des instructions à un circuit de manière plus générale, utilisez la méthode [`append`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#append) méthode. Elle prend une instruction et une liste de qubits auxquels appliquer l'instruction. Voir la [documentation de l'API de la bibliothèque de circuits](/docs/api/qiskit/circuit_library) pour une liste des instructions prises en charge.\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": [
        "Pour combiner deux circuits, utilisez la méthode [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) méthode. Il accepte un autre [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) et une liste optionnelle de mappages de qubits.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  La méthode [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) renvoie un nouveau circuit et ne modifie **aucun** des circuits sur lesquels elle agit. Pour muter le circuit sur lequel vous appelez la méthode [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) utilisez l'argument `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": [
        "Vous pouvez également compiler les circuits en instructions afin de les organiser. Vous pouvez convertir un circuit en instruction en utilisant la méthode [`to_instruction`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_instruction) puis l'ajouter à un autre circuit comme n'importe quelle autre instruction. Le circuit dessiné dans la cellule suivante est fonctionnellement équivalent au circuit dessiné dans la cellule précédente.\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": [
        "Si votre circuit est unitaire, vous pouvez le convertir en un circuit [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) en utilisant la méthode [`to_gate`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_gate) méthode. [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) les objets sont des types d'instructions spécifiques qui présentent des caractéristiques supplémentaires, telles que la méthode, qui ajoute un contrôle quantique [`control`](/docs/api/qiskit/qiskit.circuit.Gate#control) qui ajoute un contrôle quantique.\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": [
        "Pour voir ce qui se passe, vous pouvez utiliser la méthode [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) pour développer chaque instruction dans sa définition.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  Le [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) la méthode renvoie un nouveau circuit et ne modifie **pas** le circuit sur lequel elle agit.\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",
        "## Mesurer les qubits\n",
        "\n",
        "Les mesures permettent de déterminer l'état de chaque qubit et de transférer les résultats vers un registre classique. Notez que si vous soumettez des circuits à une primitive [Sampler](/docs/guides/get-started-with-sampler), des mesures sont obligatoires. Cependant, les circuits transmis à une primitive [Estimator](/docs/guides/get-started-with-estimator) ne doivent pas contenir de mesures.\n",
        "\n",
        "Il existe trois méthodes pour mesurer les qubits : [`measure`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.measure), [`measure_all`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_all) et [`measure_active`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_active). Pour savoir comment visualiser les résultats mesurés, consultez la page «[ Visualiser les résultats](/docs/guides/visualize-results) ».\n",
        "\n",
        "1. `QuantumCircuit.measure` : mesure chaque qubit du premier argument sur le bit classique donné en second argument. Cette méthode permet de contrôler entièrement l'endroit où le résultat de la mesure est stocké.\n",
        "\n",
        "2. `QuantumCircuit.measure_all` : ne prend aucun argument et peut être utilisé pour les circuits quantiques sans bits classiques prédéfinis. Il crée des fils classiques et stocke les résultats des mesures dans l'ordre. Par exemple, la mesure du qubit $q_i$ est stockée dans le cbit $meas_i$ ). Il ajoute également une barrière avant la mesure.\n",
        "\n",
        "3. `QuantumCircuit.measure_active` : similaire à `measure_all`, mais ne mesure que les qubits qui ont des opérations.\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",
        "## Circuits paramétrés\n",
        "\n",
        "De nombreux algorithmes quantiques à court terme impliquent l'exécution de nombreuses variations d'un circuit quantique. Étant donné que la construction et l'optimisation de grands circuits peuvent être coûteuses en termes de calcul, Qiskit prend en charge les circuits **paramétrés**. Ces circuits ont des paramètres non définis et leurs valeurs ne doivent être définies que juste avant l'exécution du circuit. Cela vous permet de sortir la construction et l'optimisation du circuit de la boucle principale du programme.  La cellule suivante crée et affiche un circuit paramétré.\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": [
        "La cellule suivante crée plusieurs variantes de ce circuit et affiche l'une d'entre elles.\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": [
        "Vous trouverez la liste des paramètres non définis d'un circuit dans son attribut `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",
        "### Modifier le nom d'un paramètre\n",
        "\n",
        "Par défaut, les noms des paramètres d'un circuit paramétré sont préfixés par `x`un signe -, par exemple `x[0]`. Vous pouvez modifier les noms après les avoir définis, comme illustré dans l'exemple suivant.\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": "5af44bc3",
      "metadata": {},
      "source": [
        "<span id=\"next-steps\" />\n",
        "\n",
        "## Etapes suivantes\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recommandations\">\n",
        "  * Pour en savoir plus sur les algorithmes quantiques à court terme, suivez le cours sur la [conception d'algorithmes variationnels](/learning/courses/variational-algorithm-design).\n",
        "  * Voir un exemple d'utilisation des circuits dans le tutoriel sur l ['algorithme de Grover](/docs/tutorials/grovers-algorithm).\n",
        "  * Travaillez avec des circuits simples en utilisant [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
}