Primeros pasos con Qiskit en el aula

Para este módulo de Qiskit en el Aula, los estudiantes deben tener un entorno de Python funcional con los siguientes paquetes instalados:

• qiskit v2.1.0 o posterior
• qiskit-ibm-runtime v0.40.1 o posterior
• qiskit-aer v0.17.0 o posterior
• qiskit.visualization
• numpy
• pylatexenc

Para configurar e instalar los paquetes anteriores, consulta la guía Instalar Qiskit. Para ejecutar trabajos en computadoras cuánticas reales, los estudiantes deberán crear una cuenta en IBM Quantum® siguiendo los pasos de la guía Configura tu cuenta de IBM Cloud®.

Este módulo fue probado y utilizó 2 segundos de tiempo de QPU en un procesador Heron v2. Este es solo un estimado. Tu uso real puede variar.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Introducción

En los módulos de Qiskit en el Aula, tendrás la oportunidad de usar una computadora cuántica para explorar distintos conceptos en campos relacionados con la computación cuántica, como mecánica cuántica, ciencias de la computación, química y más. Este módulo es un prerrequisito para los demás: introduce los fundamentos de la computación cuántica y cómo usar Qiskit para ejecutar circuitos cuánticos.

Primero te daremos una breve descripción de cómo funciona una computadora clásica; luego te mostraremos cómo esos conceptos se adaptan al paradigma de la computación cuántica. Finalmente, veremos cómo combinar todo esto para construir y ejecutar tu primer circuito cuántico.

Computadoras clásicas

Probablemente ya estés familiarizado con los fundamentos de cómo funcionan las computadoras clásicas, pero aquí destacaremos algunas de sus características clave para luego establecer una comparación con las computadoras cuánticas.

Las unidades básicas de información: los bits

Las computadoras clásicas procesan información clásica, y la unidad fundamental de esa información es el bit. Un solo bit puede almacenar la respuesta a una pregunta de "sí/no". Solemos representar los dos estados binarios de un bit como "0" y "1".

Repaso de números binarios

Combinar bits te permite almacenar más información. Por ejemplo, si quieres guardar un número del 0 al 15, puedes hacerlo con cuatro bits de la siguiente manera:

0 = 0000	4 = 0100	8 = 1000	12 = 1100
1 = 0001	5 = 0101	9 = 1001	13 = 1101
2 = 0010	6 = 0110	10 = 1010	14 = 1110
3 = 0011	7 = 0111	11 = 1011	15 = 1111

En general, para convertir un número binario de $N$ bits a un número familiar en base 10, multiplicas el bit menos significativo (el de la derecha) por $2^0 = 1$, el siguiente bit a la izquierda por $2^1 = 2$, luego el siguiente por $2^2 = 4$, y así sucesivamente hasta llegar al bit más significativo (el de la izquierda), que multiplicas por $2^{N-1}$.

Esto significa que $N$ bits pueden estar en uno de $2^N$ estados posibles diferentes.

Comprueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

¿Cuántos bits necesitarías para representar el número 86? Escribe la cadena de bits que codifica ese número en binario.

Respuesta:

Recuerda que $N$ bits te permiten representar los números $0$ hasta $2^N - 1$, así que con seis bits llegarías hasta $2^6 - 1 = 63$. Eso no es suficiente. Agrega un bit más para llegar hasta $2^7 - 1 = 127$. Ahora descompongamos el 86 en potencias de 2:

$$\begin{aligned} 86 &= 64 + 16 + 4 + 2 \\ &= 2^6 \times 1 + 2^5 \times 0 + 2^4 \times 1 + 2^3 \times 0 + 2^2 \times 1 + 2^1 \times 1 + 2^0 \times 0 \\ &= 1010110 \end{aligned}$$

Operaciones fundamentales: compuertas

Para poder hacer algo con los bits, una computadora necesita operaciones. Las compuertas binarias son las operaciones que forman los bloques de construcción fundamentales de todos los algoritmos y códigos más complejos.

Compuerta de un solo bit:

NOT

Cuando tienes un solo bit, solo hay una manera de transformar su estado: invertirlo de 0 a 1 o de 1 a 0. A esto lo llamamos la compuerta "NOT". El efecto de esta compuerta —y el resto de las que veremos a continuación— puede representarse en una llamada "tabla de verdad", con columnas para los estados de entrada y salida de los qubits. La tabla de verdad de la compuerta NOT es:

Entrada	Salida
0	1
1	0

Compuertas de múltiples bits:

AND

AND es una compuerta de dos bits que toma dos bits de entrada y produce un solo bit de salida. Da 1 si ambos bits de entrada son 1, y 0 en cualquier otro caso:

Entrada	Salida
00	0
01	0
10	0
11	1

OR

OR es otra compuerta de dos bits con un único bit de salida. Da 1 si alguno de los bits es 1:

Entrada	Salida
00	0
01	1
10	1
11	1

XOR

XOR significa "OR exclusivo" y es similar a la compuerta OR, pero da 1 solo si únicamente uno de los bits de entrada es 1. Da 0 si ambos son 1 o ambos son 0:

Entrada	Salida
00	0
01	1
10	1
11	0

Mediciones:

Típicamente, al aprender sobre computación clásica, no se presta mucha atención al proceso de leer el estado de los bits. Esto se debe a que conceptualmente no es muy complejo. Puedes medir los bits en cualquier momento, antes, durante o después de un cómputo, sin que eso afecte el resultado. En computación cuántica esto no es así, como veremos más adelante.

Circuitos:

Al combinar las compuertas anteriores, puedes realizar cualquier tipo de operación en una computadora. Veamos un ejemplo sencillo: usando las compuertas AND y XOR, puedes construir el circuito semisumador, que calcula la suma de dos bits. Esto se representa en un diagrama de circuito lógico, donde los cables representan los bits y las compuertas que operan sobre ellos aparecen como símbolos en los cables correspondientes:

Los dos bits se copian y se pasan por una compuerta AND y una compuerta XOR. El resultado de la compuerta XOR es el "bit de suma" (S), que permanece en el lugar de las unidades del número binario, y el resultado de la compuerta AND es el "bit de acarreo" (C), que es el valor del siguiente dígito más significativo en el número binario. Aquí está la tabla de verdad:

$A$	$B$	Suma ($A \oplus B$)	Acarreo ($A \wedge B$)
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

Comprueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

Verifica que la tabla de verdad anterior produce el resultado correcto para un circuito sumador. Es decir, para cada una de las cuatro combinaciones de A y B, verifica que $A+B=S+2 \times C$.

Respuesta:

$$\begin{aligned} 0+0 &= 0+0 = 0 ~\checkmark \\ 0+1 &= 1+0 = 1 ~\checkmark \\ 1+0 &= 1+0 = 1 ~\checkmark \\ 1+1 &= 0+2 = 2 ~\checkmark \\ \end{aligned}$$

Computadoras cuánticas

Bits $\rightarrow$ qubits

Así como los bits son las unidades fundamentales de la información clásica, los bits cuánticos, o "qubits", son las unidades fundamentales de la información cuántica. Al igual que el bit clásico, el estado de un qubit puede ser 0 o 1, lo que generalmente denotamos como $\vert 0\rangle$ y $\vert 1\rangle$. Pero a diferencia del bit clásico, un bit cuántico también puede estar en una superposición de ambos estados $\vert 0\rangle$ y $\vert 1\rangle$ al mismo tiempo. En general, un qubit puede estar en cualquier estado $\vert \psi\rangle$ de la forma:

$$\vert \psi\rangle = c_0 \vert 0\rangle + c_1 \vert 1\rangle$$

donde $c_0$ y $c_1$ son amplitudes complejas con $\vert c_0 \vert ^2+\vert c_1\vert ^2=1$.

La fase cuántica

Dado que $c_0$ y $c_1$ son complejos, cada uno puede escribirse como $c_i = \vert c_i\vert e^{i\phi_i}$ donde $\phi_i$ se llama la fase. Si multiplicamos todo el estado por el mismo factor de fase global, nada cambia físicamente — esto se llama fase global, y no tiene consecuencias observables.

Por esa razón, es convencional "factorizar" $e^{i\phi_0}$, lo que da:

$\vert \psi\rangle = \vert c_0\vert \vert 0\rangle + \vert c_1\vert e^{i\phi}\vert 1\rangle$

donde $\phi = \phi_1-\phi_0$ es la fase relativa del estado cuántico, que sí tiene consecuencias observables.

Esta fase juega un papel muy importante en la computación cuántica, y explorarás sus diversas consecuencias en los módulos posteriores de Qiskit en el Aula.

Múltiples qubits

Mientras que el estado de múltiples bits podría expresarse simplemente como una cadena de 0s y 1s, el estado de múltiples qubits se complica un poco más debido a los principios de superposición y entrelazamiento.

Recuerda que $N$ bits podían estar en uno de $2^N$ estados posibles, que van desde el número binario 000...000 hasta 111...111. Pero ahora, gracias al principio de superposición, $N$ qubits pueden estar en una superposición de todos esos estados al mismo tiempo.

Esto puede expresarse como

$$\psi_N = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$$

donde, como en el caso clásico, el estado $\vert i\rangle$ corresponde al estado en que cada qubit está en la combinación correcta de 0s y 1s para producir el número binario $i$. Estos se conocen como los "estados de la base computacional" del sistema cuántico. Por ejemplo, un estado de tres qubits puede escribirse como superposición de sus ocho estados de la base computacional:

$$\psi_3 = c_0 \vert 000\rangle + c_1 \vert 001\rangle + c_2 \vert 010\rangle + c_3 \vert 011\rangle + c_4 \vert 100\rangle + c_5 \vert 101\rangle + c_6 \vert 110\rangle + c_7 \vert 111\rangle$$

Cada qubit del sistema se denota con un índice de $0$ a $N-1$. La convención es leer los estados de los qubits de derecha a izquierda, de modo que el estado del qubit $0$ es el más a la derecha y el del qubit $N-1$ es el más a la izquierda. Esto se conoce como notación "little-endian" y puede parecer contraintuitivo al principio, ya que estamos acostumbrados a leer de izquierda a derecha.

Comprueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

A primera vista, puede parecer contraintuitivo ordenar los qubits de derecha a izquierda como en la notación little-endian, ¡pero en realidad es muy lógico! Explica por qué. (Recuerda la discusión anterior sobre la conversión de binario a base 10.)

Respuesta:

Si ordenamos los qubits de derecha a izquierda, de modo que el qubit 0 esté en el extremo derecho y el qubit N-1 en el extremo izquierdo, es lógico asociar el qubit $0$ con el bit menos significativo, que se multiplica por $2^0$, y el qubit $N-1$ con el bit más significativo, que se multiplica por $2^{N-1}$.

Entrelazamiento

Como mencionamos antes, otra característica clave de los qubits es que pueden estar entrelazados entre sí. Tomemos un ejemplo de un estado de dos qubits, donde $c_0 = c_3 = \frac{1}{\sqrt{2}}$ y $c_1 = c_2 = 0$:

$\vert \psi\rangle = \frac{1}{\sqrt{2}}(\vert 00\rangle + \vert 11\rangle)$

El estado del qubit 0 puede ser $\vert 0\rangle$ o $\vert 1\rangle$ con igual probabilidad, y lo mismo ocurre con el qubit 1. Pero estas probabilidades ya no son independientes entre sí. Si encontramos que el qubit 0 está en el estado $\vert 0\rangle$, entonces sabemos que el qubit 1 también estará en $\vert 0\rangle$. Esto es cierto sin importar la distancia entre ambos, razón por la que el acto de medir un estado entrelazado se denomina a veces "acción fantasmal a distancia".

El entrelazamiento también puede tomar otras formas. Por ejemplo, el estado

$\vert \psi\rangle = \frac{1}{\sqrt{2}}(\vert 01\rangle + \vert 10\rangle)$

produce resultados opuestos cada vez: si un qubit se mide como $\vert 0\rangle$, el otro tiene garantizado estar en el estado $\vert 1\rangle$.

Comprueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

¿Está entrelazado el estado $\vert \psi\rangle = \vert 11\rangle$? ¿Por qué o por qué no?

Respuesta:

No está entrelazado. Aunque los resultados son siempre los mismos al medir ambos qubits, esto se debe únicamente a que cada qubit siempre está fijo en el estado $\vert 1\rangle$. El resultado de medir un qubit no depende realmente del otro — ambos son simplemente siempre $\vert 1\rangle$.

En general, si puedes describir el estado de cada qubit por separado y luego multiplicarlos así:

$\vert \psi\rangle = \vert \psi_1\rangle \vert \psi_0\rangle$

entonces se conoce como un "estado producto" y no está entrelazado.

Notación vectorial

Suele ser útil usar vectores y matrices para ver cómo el estado cuántico se transforma bajo diferentes operaciones. En esta representación, los estados cuánticos serán vectores, y las compuertas cuánticas (que veremos en la siguiente sección) serán matrices que transforman esos vectores.

Para un solo qubit, las formas vectoriales de los estados se eligen como: $\vert 0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$ $\vert 1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$ De esta manera, un estado arbitrario $\vert \psi\rangle = a\vert 0\rangle+b\vert 1\rangle$ puede escribirse como $\vert \psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$

Para un estado general de $n$ qubits, necesitaremos un vector de dimensión $2^n$, con los estados base ordenados en orden binario ascendente, como cabría esperar:

$$\vert 0 \dots 000\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ \vdots \\ 0\end{pmatrix}, \vert 0 \dots 001 \rangle = \vert 1 \dots 110\rangle = \begin{pmatrix}0 \\ \vdots \\ 0 \\ 1 \\ 0\end{pmatrix}, \vert 1 \dots 111 \rangle = \begin{pmatrix}0 \\ \vdots \\ 0 \\ 0\\ 1\end{pmatrix}$$

Con esta elección de notación vectorial en mente, podemos introducir las compuertas cuánticas necesarias, sus efectos sobre los estados cuánticos y sus formas matriciales.

Comprueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

Hay cuatro estados de la base computacional para un sistema de dos qubits. Escribe cada uno en notación ket y en notación vectorial.

Respuesta:

$$\vert 00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix}, \vert 01 \rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, \dots, \vert 10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\ 0\end{pmatrix}, \vert 11 \rangle = \begin{pmatrix}0 \\ 0 \\ 0\\ 1\end{pmatrix}$$

Compuertas $\rightarrow$ compuertas cuánticas

Así como las compuertas clásicas — NOT, AND, OR y XOR — pueden combinarse para construir circuitos clásicos arbitrarios, las compuertas cuánticas desempeñan el mismo papel en la computación cuántica. Debido a que los qubits poseen características adicionales de la mecánica cuántica, las compuertas cuánticas son correspondientemente más ricas. Si bien aún podemos describir su acción sobre los estados de la base $|0\rangle$ y $|1\rangle$ con una tabla de verdad, esto no captura el panorama completo. Para las compuertas cuánticas, suele ser más natural utilizar una representación matricial, ya que también actúan sobre superposiciones de estados de la base.

A continuación, presentaremos las compuertas cuánticas más comunes y cómo transforman los qubits con los que interactúan. Cuando corresponda, las conectaremos con compuertas clásicas conocidas.

Compuertas de un solo qubit

Compuerta $X$: Es el equivalente cuántico de la operación NOT. Su tabla de verdad es exactamente igual a la de la compuerta NOT clásica:

Entrada	Salida
$\vert 0\rangle$	$\vert 1\rangle$
$\vert 1\rangle$	$\vert 0\rangle$

Y la representación matricial:

$X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$

En Qiskit, crear un circuito con una compuerta $X$ se ve así:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.x(0)
qc.draw("mpl")

En este diagrama de circuito muy sencillo, el qubit está representado por un cable — la línea horizontal negra — y la compuerta aparece como un cuadro sobre ese cable.

Compuerta de Hadamard: Crea un estado de superposición. Tabla de verdad:

Entrada	Salida
$\vert 0\rangle$	$\frac{1}{\sqrt{2}}\left(\vert 0\rangle+\vert 1\rangle\right)$
$\vert 1\rangle$	$\frac{1}{\sqrt{2}}\left(\vert 0\rangle-\vert 1\rangle\right)$

Representación matricial: $H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$

Un circuito con una compuerta de Hadamard se construye así:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.h(0)
qc.draw("mpl")

Compuerta $Z$: Agrega un desfase de fase de $\Delta \phi = \pi$ al estado $|1\rangle$:

Entrada	Salida
$\vert 0\rangle$	$\vert 0\rangle$
$\vert 1\rangle$	$-\vert 1\rangle$

$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$

En Qiskit, crear un circuito con una compuerta $Z$ se ve así:

qc = QuantumCircuit(1)
qc.z(0)
qc.draw("mpl")

Compuerta $T$: Agrega un desfase de fase de $\Delta \phi = \pi/4$ al estado $|1\rangle$:

Entrada	Salida
$\vert 0\rangle$	$\vert 0\rangle$
$\vert 1\rangle$	$e^{i\pi/4}\vert 1\rangle$

$T=\begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$

En Qiskit, crear un circuito con una compuerta $T$ se ve así:

qc = QuantumCircuit(1)
qc.t(0)
qc.draw("mpl")

Puertas de múltiples qubits

Las puertas de dos qubits pueden parecerse a las puertas clásicas de dos bits, pero con una advertencia importante: todas las puertas cuánticas deben ser reversibles. En términos de álgebra lineal, esto significa que están representadas por matrices unitarias. Por lo tanto, dos qubits de entrada siempre se asignan a dos qubits de salida, y la operación puede, en principio, deshacerse. Esto contrasta con las puertas clásicas que vimos anteriormente, como AND u OR, que pierden información y son irreversibles — dado un resultado, no puedes determinar de forma única la entrada.

Puerta CNOT (NOT controlado): Los dos qubits de entrada se denominan qubits "control" y "objetivo". El qubit de control permanece sin cambios, pero su estado dicta lo que le ocurre al qubit objetivo. Si el qubit de control está en el estado $\vert 1\rangle$, entonces se aplica una puerta $X$ al objetivo; si el estado del qubit de control es $\vert 0\rangle$, no se realiza ningún cambio. En la notación siguiente, asume que el qubit $A$ (el qubit más a la derecha) es el control, y el qubit $B$ (el más a la izquierda) es el objetivo. A continuación, la notación utilizada es $CNOT(q_{control},q_{target})\vert BA\rangle.$

$CNOT(A,B)\vert BA\rangle_{input} = \vert BA\rangle_{output}$

Entrada	Salida
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 11\rangle$
$\vert 10\rangle$	$\vert 10\rangle$
$\vert 11\rangle$	$\vert 01\rangle$

Entonces, la matriz que representa esta acción es:

$CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}$

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")

Este es el primer diagrama de circuito que vemos con dos qubits, representados por los dos cables. La puerta CNOT se implementa entre los dos qubits, con $q_0$ como control y $q_1$ como objetivo.

Pon a prueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

La mayoría de las puertas tienen la misma forma matricial en Qiskit que en cualquier otro lugar. Pero la puerta CNOT actúa sobre dos qubits, por lo que de repente las convenciones de orden de los qubits se convierten en un problema. Los textos que ordenan los qubits como $\vert q_0,q_1,...\rangle$ mostrarán una forma matricial diferente para sus puertas CNOT. Verifica mediante multiplicación matricial explícita que la matriz CNOT anterior tiene la acción correcta sobre el estado $\vert 01\rangle.$

Respuesta:

$CNOT\vert 01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = \vert 11\rangle$

Puerta SWAP: Esta puerta intercambia los estados de dos qubits. Tabla de verdad:

Entrada	Salida
$\vert 00\rangle$	$\vert 00\rangle$
$\vert 01\rangle$	$\vert 10\rangle$
$\vert 10\rangle$	$\vert 01\rangle$
$\vert 11\rangle$	$\vert 11\rangle$

Entonces, la matriz que representa esta acción es:

$SWAP=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1\end{pmatrix}$

qc = QuantumCircuit(2)
qc.swap(0, 1)
qc.draw("mpl")

La puerta SWAP puede construirse a partir de tres CNOTs. Para ver cómo, podemos decompose() la puerta con Qiskit:

qc = QuantumCircuit(2)
qc.swap(0, 1)
qc.decompose().draw("mpl")

Aquí vemos por primera vez cómo se muestran varias puertas en un diagrama de circuito. Lo leemos de izquierda a derecha, por lo que la puerta más a la izquierda se aplica primero.

Pon a prueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

Verifica que la combinación de CNOTs anterior resulta en una puerta SWAP. Puedes hacerlo con multiplicación matricial o cualquier otro método.

Respuesta:

Con multiplicación matricial:

$\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0\end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1\end{pmatrix} = SWAP ~\checkmark$

Usando una tabla de verdad para ver cómo cambian los estados con cada CNOT. En la última columna, los estados deben ser equivalentes a la columna "salida" de la tabla de verdad de SWAP:

Entrada	CNOT(A,B)	CNOT(B,A)	CNOT(A,B)
$\vert 00\rangle$	$\vert 00\rangle$	$\vert 00\rangle$	$\vert 00\rangle \checkmark$
$\vert 01\rangle$	$\vert 11\rangle$	$\vert 10\rangle$	$\vert 10\rangle \checkmark$
$\vert 10\rangle$	$\vert 10\rangle$	$\vert 11\rangle$	$\vert 01\rangle \checkmark$
$\vert 11\rangle$	$\vert 01\rangle$	$\vert 01\rangle$	$\vert 11\rangle \checkmark$

Puerta Toffoli (o "NOT controlado-controlado" (CCNOT)): Esta es una puerta de tres qubits. El nombre "NOT controlado-controlado" ya te indica cómo funciona: hay dos qubits de control y un qubit objetivo, y el estado del qubit objetivo solo se invierte si ambos qubits de control están en el estado $\vert 1\rangle$. Mantenemos la convención de orden que usamos con el CNOT:

$$CCNOT(Control A, Control B, Target C)\vert CBA\rangle$$

Entonces la tabla de verdad es:

Entrada	Salida
$\vert 000\rangle$	$\vert 000\rangle$
$\vert 001\rangle$	$\vert 001\rangle$
$\vert 010\rangle$	$\vert 010\rangle$
$\vert 011\rangle$	$\vert 111\rangle$
$\vert 100\rangle$	$\vert 100\rangle$
$\vert 101\rangle$	$\vert 101\rangle$
$\vert 110\rangle$	$\vert 110\rangle$
$\vert 111\rangle$	$\vert 011\rangle$

Y la matriz que representa esta acción es:

$$CCNOT=\begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\end{pmatrix}$$

qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
qc.draw("mpl")

La puerta Toffoli también puede descomponerse en CNOTs junto con otras puertas. Sin embargo, es significativamente más compleja que la descomposición de la puerta SWAP, por lo que se dejará como ejercicio opcional al final del módulo explorar y verificar dicha descomposición.

Mediciones

Las mediciones desempeñan un papel especial en la computación cuántica — uno que no tiene análogo en la computación clásica. Mientras que en la computación clásica puedes revisar tus bits en cualquier momento durante un algoritmo, en la computación cuántica debes ser muy selectivo sobre cuándo observas tus qubits, porque la medición colapsa su estado y destruye la superposición que les otorga su complejidad computacional.

En particular, dado un estado cuántico de $N$ bits $\vert \psi\rangle = \sum_{i=0}^{2^N-1} c_i \vert i\rangle$, una medición colapsará el estado a una de las funciones de base $\vert i\rangle$ con una probabilidad igual a $\vert c_i\vert ^2$.

Pero este efecto destructivo de la medición no siempre es un obstáculo. De hecho, es un recurso clave en ciertos algoritmos y protocolos, como la teleportación cuántica y la distribución cuántica de claves.

En Qiskit, cuando se realiza una medición, se envía a un registro clásico donde se almacena como un bit clásico. Crear un circuito con una medición se ve así:

qc = QuantumCircuit(
    1, 1
)  # the second number is the number of classical bits in the circuit
qc.measure(0, 0)
qc.draw("mpl")

Circuitos

Ahora que sabemos cómo funcionan los qubits, las puertas y las mediciones, ¡construyamos y ejecutemos nuestro propio circuito cuántico! Para esto, necesitamos presentarte un flujo de trabajo muy útil llamado patrones de Qiskit.

Marco de patrones de Qiskit

El marco de patrones de Qiskit es un procedimiento general para abordar y resolver problemas con una computadora cuántica. Consta de cuatro pasos:

1. Mapeo de nuestro problema a circuitos cuánticos y operadores
2. Optimización del circuito para el hardware objetivo
3. Ejecución en el hardware objetivo
4. Posprocesamiento de nuestros resultados

Para ilustrar estos pasos, implementaremos una versión cuántica del circuito semisumador visto anteriormente.

1. Mapeo

El circuito sumador clásico usa una puerta XOR y una puerta AND para calcular los bits de suma y acarreo, respectivamente. Podemos adaptar estas puertas al contexto cuántico para construir el semisumador cuántico. Primero, recordando que las puertas cuánticas son reversibles, no podemos simplemente sobreescribir las entradas. En cambio, introducimos dos qubits auxiliares inicializados en $\vert 0\rangle$ para almacenar las salidas de suma y acarreo. Así, nuestro estado cuántico completo consistirá en los qubits $A$ y $B$, y los qubits de suma y acarreo, que etiquetaremos como $S$ y $C$:

$\vert \psi\rangle = \vert C S B A\rangle$

Ahora necesitamos puertas cuánticas que realicen lo que las puertas XOR y AND hacían en el circuito clásico.

Suma:

Para el XOR, aplicamos dos CNOTs, cada uno con los qubits de control $A$ y $B$ y el qubit objetivo $S$ para ambos. Si $A$ y $B$ son diferentes, una de las puertas CNOT invertirá $S$ al estado $\vert 1\rangle$. Si $A$ y $B$ son ambos $\vert 0\rangle$, entonces no ocurre nada con $S$ y permanece en el estado $\vert 0\rangle$. Si $A$ y $B$ son ambos $\vert 1\rangle$, entonces el estado de $S$ se invertirá dos veces, volviendo al estado $\vert 0\rangle$.

Acarreo:

Para el bit de acarreo, necesitamos algo que funcione como la puerta AND clásica.

Pon a prueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

Revisa las puertas que hemos discutido para ver si puedes adivinar cuál puerta cuántica usaremos en lugar de la puerta AND clásica:

Respuesta:

¡Es la puerta Toffoli! Recuerda que la puerta Toffoli, o NOT controlado-controlado, invierte el estado objetivo si y solo si el qubit de control 0 Y el qubit de control 1 están ambos en $\vert 1\rangle$. Por lo tanto, si el qubit objetivo comienza en el estado $\vert 0\rangle$, tiene la misma acción que la puerta AND.

Entonces, ahora tenemos todos los ingredientes necesarios para construir el circuito cuántico:

# qubits: a, b, sum, carry
qc = QuantumCircuit(4)

# Choose values for A and B:
a = 0
b = 0

# Prepare A and B qubits according to selected values:
if a:
    qc.x(0)
if b:
    qc.x(1)

# XOR (sum) into qubit 2
qc.cx(0, 2)
qc.cx(1, 2)

# AND (carry) into qubit 3
qc.ccx(0, 1, 3)  # a AND b

# measure
qc.measure_all()

qc.draw("mpl")

Arriba se muestra el diagrama del circuito cuántico semisumador. Como se menciónó anteriormente, los cables representan los qubits $0$ a $3$ ordenados de arriba a abajo, y el registro de bits clásicos es el cable doble en la parte inferior. Luego, leyendo de izquierda a derecha, vemos cómo se aplican las puertas a cada qubit observando dónde aparecen los cuadros en los cables correspondientes. Finalmente, las mediciones se muestran al final. Las mediciones colapsan los estados de los qubits a valores definidos de $0$ o $1$, y los resultados se envían a un registro clásico.

Una sutileza: aunque el diagrama del circuito se dibuja de izquierda a derecha, al escribir la expresión matricial correspondiente debemos leerlo de derecha a izquierda. Esto se debe a que en la multiplicación de matrices, el operador más cercano al vector de estado (el más a la derecha) actúa primero. Así, por ejemplo, el circuito anterior (ignorando las mediciones) se escribiría como:

$$CCNOT(q_0,q_1,q_3)CNOT(q_1, q_2)CNOT(q_0,q_2)\vert q_3 q_2 q_1 q_0\rangle$$

2. Optimización:

A continuación, necesitamos optimizar el circuito para ejecutarlo en el hardware cuántico. Esta optimización se realiza a través del transpilador, que traduce el circuito abstracto mostrado arriba en instrucciones que la computadora cuántica entenderá. Asigna los qubits lógicos anteriores a qubits físicos reales del procesador y reescribe las puertas en términos del conjunto nativo de puertas del sistema, optimizado para ejecutarse en la computadora cuántica. Finalmente, el transpilador también implementa algo llamado "supresión y mitigación de errores" para intentar minimizar el efecto de los errores en el resultado. Esto no es tan importante para nuestro circuito tan sencillo, pero si continúas tu camino en la computación cuántica y ejecutas circuitos más complicados, pronto verás el valor de la supresión y mitigación de errores. Si quieres aprender más sobre esto, consulta el curso de Olivia Lane, Computación Cuántica en la Práctica.

Primero, cargamos los paquetes necesarios para comunicarnos con las computadoras cuánticas de IBM® y seleccionamos un backend sobre el que ejecutar. Podemos elegir el backend menos ocupado o seleccionar un backend específico cuyas propiedades conocemos.

A continuación hay código para guardar tus credenciales en el primer uso. Asegúrate de eliminar esta información del notebook después de guardarla en tu entorno, para que tus credenciales no se compartan accidentalmente al compartir el notebook. Consulta Configura tu cuenta de IBM Cloud e Inicializa el servicio en un entorno no confiable para obtener más orientación.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_fez

Ahora usamos el transpilador para optimizar el circuito. Podemos elegir el nivel de optimización de 0 (sin optimización) a 3 (optimización máxima). Para ver qué implica cada nivel, visita la guía Establece el nivel de optimización del transpilador. El circuito resultante tendrá un aspecto significativamente diferente al circuito lógico que hicimos en nuestro paso de mapeo.

# Transpile the circuit and optimize for running on the quantum computer selected
# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

qc_isa.draw("mpl")

Un "Sampler" es una primitiva diseñada para muestrear los posibles estados resultantes de un circuito cuántico y recopilar estadísticas sobre qué estados podrían medirse y con qué probabilidad. Aquí importamos el Sampler de Qiskit Runtime:

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Si has agotado tu tiempo asignado en computadoras cuánticas reales o si no tienes conexión a internet, puede que prefieras usar un simulador. Para hacerlo, ejecuta la celda a continuación y descomenta la línea correspondiente en el paso "Ejecutar".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

3. Ejecución

Después de preparar el circuito, ¡ya podemos ejecutarlo en la computadora cuántica!

job = sampler.run([qc_isa], shots=100)
# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator
res = job.result()
counts = res[0].data.meas.get_counts()

4. Posprocesamiento

¡Ahora estamos listos para ver nuestros resultados! Mostraremos un histograma de las 100 muestras del circuito.

from qiskit.visualization import plot_histogram

print("counts = ", counts)
plot_histogram(counts)

counts =  {'0000': 90, '0100': 4, '1100': 3, '0010': 3}

El histograma anterior muestra los resultados de medición de los cuatro qubits al final del circuito. Una computadora cuántica ideal con cero ruido habría medido los qubits con los mismos valores cada vez, pero en la realidad, el ruido provocará que algunas de las ejecuciones produzcan errores.

Pon a prueba tu comprensión

Lee la(s) pregunta(s) a continuación, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

Usando el bitstring con más conteos como tus valores de $A$, $B$, $S$ y $C$, verifica que el circuito sumador cuántico funciónó.

Respuesta:

Necesitamos verificar que $A+B = S+2 \times C$. Recuerda que el orden del bitstring sigue la notación little-endian, por lo que se lee como CSBA.

Del histograma anterior, vemos que el bitstring 0000 es el dominante.

$0 + 0 = 0 + 0 \times 2 = 0 ~\checkmark$

Regresa y cambia los valores de $A$ y $B$ a $A=1$ y $B=1$, y vuelve a seguir los pasos de los patrones de Qiskit para ejecutar el circuito de nuevo. Verifica que el circuito sumador funciónó de nuevo.

Respuesta:

Deberías obtener un histograma con el bitstring dominante siendo 1011:

$1 + 1 = 0 + 1 \times 2 = 2 ~\checkmark$

Una de las ventajas adicionales del semisumador cuántico sobre el semisumador clásico es que puede ejecutarse con entradas cuánticas. Es decir, puede "sumar" los qubits $A$ y $B$ incluso si están en estados de superposición. En la sección de Preguntas de Desafío a continuación, se te pedirá que prepares los qubits en superposiciones y veas qué ocurre.

Conclusión

Este módulo fue diseñado para darte una comprensión sólida de los principios básicos de la computación cuántica comparándola con la computación clásica. Observamos el circuito semisumador clásico y luego te mostramos cómo adaptar el circuito para ejecutarlo con qubits en una computadora cuántica. ¡Ahora estás listo para explorar los demás módulos de Qiskit en el Aula!

Conceptos clave:

• A diferencia de los bits clásicos, que solo pueden tomar los valores 0 y 1, los qubits también pueden estar en estados de superposición de 0 y 1.
• Múltiples qubits pueden estar en una superposición sobre los bitstrings permitidos clásicamente, llamados estados de la base computacional.
• Múltiples qubits pueden estar entrelazados de modo que el estado de uno depende del estado del otro.
• La convención de Qiskit es usar la notación little-endian, que coloca el qubit menos significativo, $q_0$, en la posición más a la derecha y el qubit más significativo, $q_N$, a la izquierda.
• Las puertas cuánticas son operaciones reversibles representadas por matrices unitarias que actúan sobre los vectores de estado cuántico. En esta notación, la matriz más cercana al vector (la más a la derecha) actúa primero.
• Las mediciones colapsan un estado de superposición cuántica a uno de sus estados clásicamente permitidos, con una probabilidad igual al cuadrado de la amplitud del estado de la base computacional correspondiente en la superposición.
• Los circuitos cuánticos se representan frecuentemente mediante diagramas de circuito cuántico, donde los qubits se representan como cables horizontales y las puertas cuánticas aparecen a lo largo de estos cables de izquierda a derecha.
• Para ejecutar un circuito cuántico, usamos los cuatro pasos del flujo de trabajo de patrones de Qiskit: Mapear, Optimizar, Ejecutar, Posprocesar.

Preguntas

Preguntas de verdadero/falso

1. Un solo bit en una computadora clásica solo puede contener el valor 0 o 1.

2. El entrelazamiento significa que el estado de un qubit es independiente del estado de otro.

3. Las puertas cuánticas son operaciones generalmente irreversibles.

4. La convención de Qiskit coloca el qubit menos significativo, $q_0$, en la posición más a la izquierda.

5. Medir un estado cuántico siempre da el mismo resultado si se repite muchas veces.

6. La puerta Hadamard crea superposición en un solo qubit.

7. Los circuitos cuánticos pueden incluir operaciones de medición que colapsan el estado de superposición a uno de los estados clásicamente permitidos.

8. El número de estados clásicos posibles para $N$ bits es $2N$.

9. Las probabilidades de los resultados de las mediciones cuánticas están dadas por los cuadrados de las amplitudes de los estados de la base medibles clásicamente.

Preguntas de respuesta corta

1. ¿Cuáles son algunas de las diferencias principales entre un bit y un qubit?

2. ¿Qué le ocurre a un estado cuántico cuando se mide?

3. ¿Por qué usamos la notación little-endian en Qiskit?

4. ¿Cuáles son los cuatro pasos del flujo de trabajo de patrones de Qiskit?

Preguntas de desafío:

1. En el módulo, solo usamos el sumador para sumar estados clásicamente permitidos de $A$ y $B$. ¡Pero también podemos preparar $A$ y $B$ en superposiciones! Cambia el código para preparar cada qubit en una superposición igual de 0 y 1, luego ejecuta el nuevo circuito y obtén un nuevo histograma. ¿Qué observas? Explica qué está ocurriendo.