{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "bc54d7bc-b2d8-4b30-9b0b-05689e07a463",
      "metadata": {},
      "source": [
        "---\n",
        "title: \"Crear circuitos\"\n",
        "description: \"Cómo construir y visualizar circuitos cuánticos en Qiskit.\"\n",
        "---\n",
        "\n",
        "<span id=\"construct-circuits\" />\n",
        "\n",
        "# Crear circuitos\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=\"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",
        "    ```\n",
        "  </AccordionItem>\n",
        "</Accordion>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d",
      "metadata": {},
      "source": [
        "Esta página echa un vistazo más de cerca a la clase [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) en el SDK de Qiskit, incluyendo algunos métodos más avanzados que puedes utilizar para crear circuitos cuánticos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2664d407-aa95-43a3-9101-d3ad58c2df58",
      "metadata": {},
      "source": [
        "<span id=\"what-is-a-quantum-circuit\" />\n",
        "\n",
        "## ¿Qué es un circuito cuántico?\n",
        "\n",
        "Un circuito cuántico simple es una colección de qubits y una lista de instrucciones que actúan sobre esos qubits. Para demostrarlo, la siguiente celda crea un nuevo circuito con dos nuevos qubits y, a continuación, muestra el atributo [`qubits`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qubits) del circuito, que es una lista de [`Qubits`](/docs/api/qiskit/circuit#qiskit.circuit.Qubit) en orden desde el bit menos significativo $q_0$ hasta el bit más significativo $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": [
        "Se pueden combinar varios objetos `QuantumRegister` y `ClassicalRegister` para crear un circuito. Cada [`QuantumRegister`](/docs/api/qiskit/circuit#qiskit.circuit.QuantumRegister) y [`ClassicalRegister`](/docs/api/qiskit/circuit#qiskit.circuit.ClassicalRegister) también pueden nombrarse.\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": [
        "Puedes encontrar el índice y el registro de un qubit utilizando el método del circuito [`find_bit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.find_bit) y sus atributos.\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": [
        "Al añadir una instrucción al circuito, ésta se añade al atributo [`data`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#data) del circuito. La siguiente salida de celda muestra que `data` es una lista de [`CircuitInstruction`](/docs/api/qiskit/qiskit.circuit.CircuitInstruction) objetos, cada uno de los cuales tiene un atributo `operation` , y un atributo `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 forma más sencilla de ver esta información es mediante el [`draw`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#draw) método, que devuelve una visualización del circuito. Consulte [«Visualizar circuitos»](/docs/guides/visualize-circuits) para ver diferentes formas de representar circuitos cuánticos.\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": [
        "Los objetos de instrucción de circuito pueden contener circuitos de \"definición\" que describen la instrucción en términos de instrucciones más fundamentales. Por ejemplo, la [puerta X](/docs/api/qiskit/qiskit.circuit.library.XGate) se define como un caso específico de la puerta [U3-gate](/docs/api/qiskit/qiskit.circuit.library.U3Gate) una puerta más general de un solo qubit.\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": [
        "Las instrucciones y los circuitos se parecen en que ambos describen operaciones con bits y qubits, pero tienen propósitos diferentes:\n",
        "\n",
        "* Las instrucciones se tratan como fijas, y sus métodos suelen devolver nuevas instrucciones (sin mutar el objeto original).\n",
        "* Los circuitos están diseñados para ser construidos sobre muchas líneas de código, y [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) los métodos a menudo mutan el objeto existente.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2e451022",
      "metadata": {},
      "source": [
        "<span id=\"what-is-circuit-depth\" />\n",
        "\n",
        "### ¿Qué es la profundidad del circuito?\n",
        "\n",
        "La [profundidad()](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.depth) de un circuito cuántico es una medida del número de \"capas\" de puertas cuánticas, ejecutadas en paralelo, que se necesitan para completar el cálculo definido por el circuito. Dado que las puertas cuánticas tardan tiempo en implementarse, la profundidad de un circuito corresponde aproximadamente a la cantidad de tiempo que tarda el ordenador cuántico en ejecutar el circuito. Así, la profundidad de un circuito es una magnitud importante para medir si un circuito cuántico puede funcionar en un dispositivo.\n",
        "\n",
        "El resto de esta página ilustra cómo manipular circuitos cuánticos.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ff4f08f3-48eb-454c-9647-2af505bf79bc",
      "metadata": {},
      "source": [
        "<span id=\"build-circuits\" />\n",
        "\n",
        "## Construir circuitos\n",
        "\n",
        "Métodos como [`QuantumCircuit.h`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#h) y [`QuantumCircuit.cx`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#cx) añaden instrucciones específicas a los circuitos. Para añadir instrucciones a un circuito de forma más general, utilice el método [`append`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#append) método. Toma una instrucción y una lista de qubits a los que aplicar la instrucción. Consulte [la documentación de la API Circuit Library](/docs/api/qiskit/circuit_library) para obtener una lista de las instrucciones compatibles.\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": [
        "Para combinar dos circuitos, utilice el método [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) método. Este acepta otro [`QuantumCircuit`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit) y una lista opcional de asignaciones de qubits.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  El método [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) devuelve un circuito nuevo y **no** muta ninguno de los circuitos sobre los que actúa. Para mutar el circuito sobre el que se llama al método [`compose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#compose) utilice el argumento `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": [
        "También puedes compilar los circuitos en instrucciones para mantenerlos organizados. Puede convertir un circuito en una instrucción utilizando el método [`to_instruction`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_instruction) y añadirla a otro circuito como lo haría con cualquier otra instrucción. El circuito dibujado en la celda siguiente es funcionalmente equivalente al circuito dibujado en la celda anterior.\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 tu circuito es unitario, puedes convertirlo en un [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) utilizando el método [`to_gate`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#to_gate) método. [`Gate`](/docs/api/qiskit/qiskit.circuit.Gate) son tipos específicos de instrucciones que tienen algunas características adicionales, como el [`control`](/docs/api/qiskit/qiskit.circuit.Gate#control) que añade un control cuántico.\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": [
        "Para ver lo que está pasando, puede utilizar el método [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) para expandir cada instrucción en su definición.\n",
        "\n",
        "<Admonition type=\"note\">\n",
        "  El método [`decompose`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#decompose) devuelve un nuevo circuito y **no** muta el circuito sobre el que actúa.\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",
        "## Medir qubits\n",
        "\n",
        "Las mediciones se utilizan para tomar muestras de los estados de los qubits individuales y transferir los resultados a un registro clásico. Ten en cuenta que, si envías circuitos a una primitiva [Sampler](/docs/guides/get-started-with-sampler), es obligatorio incluir las medidas. Sin embargo, los circuitos que se envían a una primitiva [Estimator](/docs/guides/get-started-with-estimator) no deben contener medidas.\n",
        "\n",
        "Los qubits se pueden medir mediante tres métodos: [`measure`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#qiskit.circuit.QuantumCircuit.measure), [`measure_all`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_all) y [`measure_active`](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#measure_active). Para saber cómo visualizar los resultados de las mediciones, consulta la página «[Visualizar resultados](/docs/guides/visualize-results) ».\n",
        "\n",
        "1. `QuantumCircuit.measure` mide cada qubit en el primer argumento sobre el bit clásico dado como segundo argumento. Este método permite controlar totalmente dónde se almacena el resultado de la medición.\n",
        "\n",
        "2. `QuantumCircuit.measure_all` no necesita argumento y puede utilizarse para circuitos cuánticos sin bits clásicos predefinidos. Crea hilos clásicos y almacena por orden los resultados de las mediciones. Por ejemplo, la medición del qubit $q_i$ se almacena en el cbit $meas_i$ ). También añade una barrera antes de la medición.\n",
        "\n",
        "3. `QuantumCircuit.measure_active` : similar a `measure_all`, pero sólo mide los qubits que tienen operaciones.\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",
        "## Circuitos parametrizados\n",
        "\n",
        "Muchos algoritmos cuánticos a corto plazo implican la ejecución de muchas variaciones de un circuito cuántico. Dado que la construcción y optimización de circuitos de gran tamaño puede resultar costosa desde el punto de vista informático, Qiskit admite circuitos **parametrizados**. Estos circuitos tienen parámetros indefinidos, y no es necesario definir sus valores hasta justo antes de ejecutar el circuito. Esto le permite mover la construcción del circuito y la optimización fuera del bucle principal del programa.  La siguiente celda crea y muestra un circuito parametrizado.\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 siguiente celda crea muchas variaciones de este circuito y muestra una de las variaciones.\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": [
        "Encontrará una lista de los parámetros no definidos de un circuito en su atributo `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",
        "### Cambiar el nombre de un parámetro\n",
        "\n",
        "Por defecto, los nombres de los parámetros de un circuito parametrizado llevan el prefijo `x`-, por ejemplo, `x[0]`. Puede cambiar los nombres después de haberlos definido, como se muestra en el siguiente ejemplo.\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",
        "## Próximos pasos\n",
        "\n",
        "<Admonition type=\"tip\" title=\"Recomendaciones\">\n",
        "  * Para aprender sobre algoritmos cuánticos a corto plazo, siga el curso [Diseño de algoritmos variacionales](/learning/courses/variational-algorithm-design).\n",
        "  * Vea un ejemplo de circuitos utilizados en el tutorial [del Algoritmo de Grover](/docs/tutorials/grovers-algorithm).\n",
        "  * Trabaje con circuitos sencillos utilizando [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
}