{ "cells": [ { "cell_type": "markdown", "id": "aea62c4c-1e42-4472-9f1d-e52783e81fc6", "metadata": {}, "source": [ "---\n", "title: \"Biblioteca de circuitos\"\n", "description: \"Más información sobre los circuitos listos para usar que ofrece la biblioteca de circuitos Qiskit, incluidos los circuitos N-local, de evolución temporal y de codificación de datos\"\n", "---\n", "\n", "{/* cspell:ignore cout */}\n", "\n", "\n", "\n", "# Biblioteca de circuitos\n", "\n" ] }, { "cell_type": "markdown", "id": "14baab34-71a4-4d3c-bdc1-083bb2c32065", "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", "\n", " \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", " \n", "\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6f257ff9-15c4-48d8-9503-7f0ab16a91b2", "metadata": {}, "source": [ "El SDK de Qiskit incluye una biblioteca de circuitos populares para utilizarlos como bloques de construcción en tus propios programas. El uso de circuitos predefinidos ahorra tiempo de investigación, escritura de código y depuración. La biblioteca incluye circuitos populares en computación cuántica, circuitos difíciles de simular clásicamente y circuitos útiles para la evaluación comparativa del hardware cuántico.\n", "\n", "Esta página enumera las diferentes categorías de circuitos que ofrece la biblioteca. Para obtener una lista completa de circuitos, consulte la [documentación de la API de la biblioteca de circuitos](/docs/api/qiskit/circuit_library).\n", "\n" ] }, { "cell_type": "markdown", "id": "0b473350", "metadata": {}, "source": [ "\n", "\n", "## Puertas estándar\n", "\n", "La biblioteca de circuitos también incluye puertas cuánticas estándar. Algunas son puertas más fundamentales (como la `UGate`), y otras son puertas multi-qubit que normalmente necesitan construirse a partir de puertas de uno y dos qubits. Para añadir puertas importadas a tu circuito, utiliza el método `append` ; el primer argumento es la puerta, y el siguiente es una lista de qubits a los que aplicar la puerta.\n", "\n", "Por ejemplo, la siguiente celda de código crea un circuito con una puerta Hadamard y una puerta X multicontrolada.\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "a846a845-7ac5-4c92-b124-d2b90a773ba2", "metadata": { "tags": [ "ignore-warnings" ] }, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.circuit.library import HGate, MCXGate\n", "\n", "mcx_gate = MCXGate(3)\n", "hadamard_gate = HGate()\n", "\n", "qc = QuantumCircuit(4)\n", "qc.append(hadamard_gate, [0])\n", "qc.append(mcx_gate, [0, 1, 2, 3])\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e5066595", "metadata": {}, "source": [ "Consulte [Puertas estándar](/docs/api/qiskit/circuit_library#standard-gates) en la documentación de la API de la biblioteca de circuitos.\n", "\n" ] }, { "cell_type": "markdown", "id": "f1d7c8c9-1b4d-45e1-9cd5-c5d76c2e25ab", "metadata": {}, "source": [ "\n", "\n", "## Circuitos N-locales\n", "\n", "Estos circuitos alternan capas de puertas de rotación de un solo qubit con capas de puertas de enredo de varios qubits.\n", "\n", "Esta familia de circuitos es popular en los algoritmos cuánticos variacionales porque pueden producir una amplia gama de estados cuánticos. Los algoritmos variacionales ajustan los parámetros de la puerta para encontrar estados que tengan ciertas propiedades (como los estados que representan una buena solución a un problema de optimización). Para ello, muchos circuitos de la biblioteca están **parametrizados**, lo que significa que puede definirlos sin valores fijos.\n", "\n", "La siguiente celda de código importa un circuito `n_local` , en el que las puertas de enredo son puertas de dos qubits. Este circuito intercala bloques de puertas parametrizadas de un solo qubit, seguidos de bloques entrelazados de puertas de dos qubits. El siguiente código crea un circuito de tres qubits, con puertas RX de un qubit y puertas CZ de dos qubits.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "3ccaeb1b-03c6-4dfa-9000-e48db2516303", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import n_local\n", "\n", "two_local = n_local(3, \"rx\", \"cz\")\n", "two_local.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e32e031b-3218-4c1c-af7c-b40ad6c82100", "metadata": {}, "source": [ "El atributo `parameters` permite obtener una lista de los parámetros del circuito.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "d503e1c8-0ccd-4868-a5dc-4806d00ab54b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "two_local.parameters" ] }, { "cell_type": "markdown", "id": "555aca2a-a754-4372-8846-22ee4773ece1", "metadata": {}, "source": [ "También puede utilizarlo para asignar estos parámetros a valores reales utilizando un diccionario de la forma `{ Parameter: number }`. Para demostrarlo, la siguiente celda de código asigna cada parámetro del circuito a `0`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "89227b48-12b2-4b1b-9680-55a7fce88a2b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bound_circuit = two_local.assign_parameters(\n", " {p: 0 for p in two_local.parameters}\n", ")\n", "bound_circuit.decompose().draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "78772993-d0da-4651-9211-706e86a59432", "metadata": {}, "source": [ "Para obtener más información, consulte [Puertas N-locales](/docs/api/qiskit/circuit_library#n-local-circuits) en la documentación de la API de la biblioteca de circuitos o realice el [curso de diseño de algoritmos variacionales](/learning/courses/variational-algorithm-design) en IBM Quantum Learning.\n", "\n" ] }, { "cell_type": "markdown", "id": "3e463081-bce9-4ee2-9046-97659e9ac847", "metadata": {}, "source": [ "\n", "\n", "## Circuitos de codificación de datos\n", "\n", "Estos circuitos parametrizados codifican datos en estados cuánticos para su procesamiento mediante algoritmos de aprendizaje de máquinas cuánticas. Algunos circuitos compatibles con Qiskit son:\n", "\n", "* Codificación de amplitud, que codifica cada número en la amplitud de un estado base. Esto puede almacenar $2^n$ números en un solo estado, pero puede ser costoso de implementar.\n", "* Codificación de base, que codifica un entero $k$ preparando el estado de base correspondiente $|k\\rangle$.\n", "* Codificación angular, que establece cada número de los datos como un ángulo de rotación en un circuito parametrizado.\n", "\n", "El mejor enfoque depende de las características específicas de su aplicación. En los ordenadores cuánticos actuales, sin embargo, solemos utilizar circuitos de codificación angular como el `zz_feature_map`.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "cf8b1efc-57b3-4681-8e6a-d5b8406d092d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import zz_feature_map\n", "\n", "features = [0.2, 0.4, 0.8]\n", "feature_map = zz_feature_map(feature_dimension=len(features))\n", "\n", "encoded = feature_map.assign_parameters(features)\n", "encoded.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "031bf004-ca80-4cc0-b153-2cd5cd778386", "metadata": {}, "source": [ "Consulte [Circuitos de codificación de datos](/docs/api/qiskit/circuit_library#data-encoding-circuits) en la documentación de la API de la biblioteca de circuitos.\n", "\n" ] }, { "cell_type": "markdown", "id": "5c5d2735-ef6a-48db-8382-9dc03c9af20a", "metadata": {}, "source": [ "\n", "\n", "## Circuitos de evolución temporal\n", "\n", "Estos circuitos simulan un estado cuántico que evoluciona en el tiempo. Utilizar circuitos de evolución temporal para investigar efectos físicos como la transferencia de calor o las transiciones de fase en un sistema. Los circuitos de evolución temporal también son un componente fundamental de las funciones de onda de la química (como los estados de prueba unitarios de clústeres acoplados) y del algoritmo QAOA que utilizamos para los problemas de optimización.\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "834794df-86e9-4bea-8efa-5380499e359b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import PauliEvolutionGate\n", "from qiskit.circuit import QuantumCircuit\n", "from qiskit.quantum_info import SparsePauliOp\n", "\n", "\n", "# Prepare an initial state with a Hadamard on the middle qubit\n", "state = QuantumCircuit(3)\n", "state.h(1)\n", "\n", "hamiltonian = SparsePauliOp([\"ZZI\", \"IZZ\"])\n", "evolution = PauliEvolutionGate(hamiltonian, time=1)\n", "\n", "# Evolve state by appending the evolution gate\n", "state.compose(evolution, inplace=True)\n", "\n", "state.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e2dad12f-535a-4f42-8ac4-dbfcfb5533cc", "metadata": {}, "source": [ "Lea la [documentación de la API `PauliEvolutionGate` ](/docs/api/qiskit/qiskit.circuit.library.PauliEvolutionGate).\n", "\n" ] }, { "cell_type": "markdown", "id": "0cf7122d-c3fe-41a6-936c-b3770b33f0f1", "metadata": {}, "source": [ "\n", "\n", "## Circuitos de benchmarking y teoría de la complejidad\n", "\n", "Los circuitos de evaluación comparativa nos dan una idea de lo bien que funciona realmente nuestro hardware, y los circuitos de teoría de la complejidad nos ayudan a entender lo difíciles que son los problemas que queremos resolver.\n", "\n", "Por ejemplo, la referencia \"volumen cuántico\" mide la precisión con la que un ordenador cuántico ejecuta un tipo de circuito cuántico aleatorio. La puntuación del ordenador cuántico aumenta con el tamaño del circuito que puede ejecutar de forma fiable. Esto tiene en cuenta todos los aspectos del ordenador, incluido el recuento de qubits, la fidelidad de las instrucciones, la conectividad de los qubits y la pila de software que transpila y postprocesa los resultados. Lea más sobre el volumen cuántico en el [artículo original sobre el volumen cuántico](https://arxiv.org/abs/1811.12926).\n", "\n", "El siguiente código muestra un ejemplo de un circuito de volumen cuántico construido en Qiskit que funciona con cuatro qubits (los bloques `unitary` son puertas aleatorias de dos qubits).\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "9629a507-8191-409e-b895-fd0833c8fcd7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import quantum_volume\n", "\n", "quantum_volume(4).draw(\"mpl\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "908e4b4a-5edf-4390-82a0-e755050c2a37", "metadata": {}, "source": [ "La biblioteca de circuitos también incluye circuitos considerados difíciles de simular clásicamente, como los circuitos polinómicos cuánticos instantáneos (iqp). Estos circuitos intercalan ciertas puertas diagonales (en la base computacional) entre bloques de puertas Hadamard.\n", "\n", "Otros circuitos son `grover_operator` para el algoritmo de Grover y el circuito `fourier_checking` para el problema de comprobación de Fourier. Consulte estos circuitos en [Circuitos cuánticos particulares](/docs/api/qiskit/circuit_library#particular-quantum-circuits) en la documentación de la API de la biblioteca de circuitos.\n", "\n" ] }, { "cell_type": "markdown", "id": "58b1a7b8-c173-4de8-957a-ca5d58332073", "metadata": {}, "source": [ "\n", "\n", "## Circuitos aritméticos\n", "\n", "Las operaciones aritméticas son funciones clásicas, como la suma de enteros y las operaciones con bits. Pueden ser útiles con algoritmos como la estimación de amplitud para aplicaciones financieras, y en algoritmos como el algoritmo HHL, que resuelve sistemas lineales de ecuaciones.\n", "\n", "Como ejemplo, intentemos sumar dos números de tres bits utilizando un circuito \"ripple-carry\" para realizar la suma en el lugar (`FullAdderGate`). Este sumador suma dos números (los llamaremos \"A\" y \"B\") y escribe el resultado en el registro que contenía B. En el siguiente ejemplo, A=2 y B=3.\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "77555a5a-a81c-47b8-a9ae-3015d84adcf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.circuit.library import FullAdderGate\n", "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", "\n", "adder = FullAdderGate(3) # Adder of 3-bit numbers\n", "\n", "# Create the number A=2\n", "reg_a = QuantumRegister(3, \"a\")\n", "number_a = QuantumCircuit(reg_a)\n", "number_a.initialize(2) # Number 2; |010>\n", "\n", "# Create the number B=3\n", "reg_b = QuantumRegister(3, \"b\")\n", "number_b = QuantumCircuit(reg_b)\n", "number_b.initialize(3) # Number 3; |011>\n", "\n", "# Create a circuit to hold everything, including a classical register for\n", "# the result\n", "qregs = [\n", " QuantumRegister(1, \"cin\"),\n", " QuantumRegister(3, \"a\"),\n", " QuantumRegister(3, \"b\"),\n", " QuantumRegister(1, \"cout\"),\n", "]\n", "reg_result = ClassicalRegister(3)\n", "circuit = QuantumCircuit(*qregs, reg_result)\n", "\n", "# Compose number initializers with the adder. Adder stores the result to\n", "# register B, so we'll measure those qubits.\n", "circuit = (\n", " circuit.compose(number_a, qubits=reg_a)\n", " .compose(number_b, qubits=reg_b)\n", " .compose(adder)\n", ")\n", "circuit.measure(reg_b, reg_result)\n", "circuit.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "e8a8deee-ad46-42cd-844e-51d5541c3f65", "metadata": {}, "source": [ "La simulación del circuito muestra que éste emite `5` para todos los disparos de `1024` (es decir, se mide con probabilidad `1.0`).\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "ede21ca4-0358-4c83-9af5-63a1c67ae3cb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Count data:\n", " {5: 1024}\n" ] } ], "source": [ "from qiskit.primitives import StatevectorSampler\n", "\n", "result = StatevectorSampler().run([circuit]).result()\n", "\n", "print(f\"Count data:\\n {result[0].data.c0.get_int_counts()}\")" ] }, { "cell_type": "markdown", "id": "cbd99d49-eb5c-4cd5-bac2-528497b8405e", "metadata": {}, "source": [ "Consulte [Aritmética](/docs/api/qiskit/circuit_library#arithmetic) en la documentación de la API de la biblioteca de circuitos.\n", "\n" ] }, { "cell_type": "markdown", "id": "9a900a84-c52f-4a03-b3e9-87c71fa93e88", "metadata": {}, "source": [ "\n", "\n", "## Próximos pasos\n", "\n", "\n", " * Aprende métodos avanzados para crear circuitos en el tema [«Circuitos» de Construct](/docs/guides/construct-circuits).\n", " * Vea un ejemplo de circuitos utilizados en el tutorial [del Algoritmo de Grover](/docs/tutorials/grovers-algorithm).\n", " * Revise la referencia [API de la biblioteca de circuitos](/docs/api/qiskit/circuit_library).\n", "\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 }