Circuitos Cuánticos
En este tutorial, cubriremos los fundamentos de los circuitos cuánticos, que son los bloques de construcción fundamentales de la computación cuántica. También mostraremos cómo usar QiliSDK para construir y simular un circuito cuántico simple.
¿Qué es un Circuito Cuántico?
En la computación clásica, tenemos puertas lógicas que operan sobre bits para realizar cálculos. Podríamos empezar con todos nuestros bits en el estado 0, y luego aplicamos una serie de puertas lógicas (p. ej. AND, OR, NOT) para manipular esos bits y realizar algún cálculo. En la computación cuántica, en cambio tenemos puertas cuánticas que operan sobre qubits para realizar cálculos.
La mayoría de los circuitos cuánticos tienen un aspecto similar al siguiente:
En este caso particular, tenemos un circuito cuántico con 2 qubits: \(q_0\) y \(q_1\). Las líneas horizontales representan los qubits, y las cajas y otros símbolos representan las puertas cuánticas que operan sobre esos qubits.
La primera puerta que aplicamos es una puerta Hadamard (H) sobre \(q_0\), que la coloca en una superposición de estados. Luego aplicamos una puerta CNOT, que entrelaza \(q_0\) y \(q_1\). Finalmente, medimos ambos qubits.
¿Qué Son las Puertas Cuánticas?
Entonces, ¿qué hacen exactamente estas puertas? Una forma de representar tales operaciones cuánticas es a través de su representación matricial. Al convertir el estado de nuestros qubits en un vector, podemos representar las puertas cuánticas como matrices que actúan sobre esos vectores para producir nuevos estados. Para convertir nuestro estado en un vector, podemos usar la base computacional, donde \(|0⟩\) se representa como el vector \(\begin{pmatrix} 1 \\ 0 \end{pmatrix}\) y \(|1⟩\) se representa como el vector \(\begin{pmatrix} 0 \\ 1 \end{pmatrix}\).
Cuando tenemos múltiples qubits, podemos usar el producto tensorial como se mencionó en el tutorial anterior para representar el estado del sistema como un vector en un espacio de mayor dimensión. Por lo tanto, si tenemos dos qubits, podemos representar el estado inicial \(|00⟩\) como el vector:
Nuestra puerta Hadamard (H) puede representarse como la matriz:
Ahora queremos realizar la operación \(H|00⟩\), pero notemos que nuestra puerta Hadamard es una matriz 2x2, mientras que nuestro estado es un vector de 4 dimensiones. Para aplicar la puerta Hadamard a nuestro estado de dos qubits, primero necesitamos tomar el producto tensorial de la puerta Hadamard con la matriz identidad para crear una matriz 4x4 que pueda operar sobre nuestro vector de estado de 4 dimensiones. La matriz identidad es:
Por tanto, podemos representar la operación de aplicar la puerta Hadamard al primer qubit como:
Si finalmente realizamos la operación \((H \otimes I)|00⟩\), obtenemos:
Esto es exactamente lo que esperaríamos, ya que la puerta Hadamard coloca el primer qubit en una superposición de estados, mientras deja el segundo qubit sin cambios.
Se puede realizar un proceso similar para todas las diferentes puertas y combinaciones de puertas, y así es como podemos entender y simular lo que cada puerta hará a nuestro estado cuántico.
Nótese que con un único qubit teníamos un vector de dimensión 2, mientras que con dos qubits tenemos un vector de dimensión 4. En general, el tamaño de nuestro vector de estado crece exponencialmente con el número de qubits, de modo que si tuviéramos 20 qubits necesitaríamos vectores de tamaño 1.048.576, por lo que debería quedar claro por qué simular circuitos cuánticos en ordenadores clásicos puede volverse difícil rápidamente.
¿Qué Hace Cada Puerta Cuántica?
Acabamos de ver cómo se comporta la puerta Hadamard, pero ¿qué otras puertas podemos usar en circuitos cuánticos? Aquí enumeramos todas las puertas cuánticas más comunes, su comportamiento y sus representaciones matriciales.
Nota
No te preocupes por memorizar nada aquí, pero es bueno tener una idea vaga de algunos de los nombres y comportamientos.
Nombre/s de la Puerta |
Descripción |
Representación Matricial |
|---|---|---|
X |
Invierte el estado de un qubit: \(|0⟩\) a \(|1⟩\) y \(|1⟩\) a \(|0⟩\) |
\(\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\) |
Y |
Invierte el estado de un qubit y aplica un desplazamiento de fase: \(|0⟩\) a \(i|1⟩\) y \(|1⟩\) a \(-i|0⟩\) |
\(\begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}\) |
Z |
Aplica un desplazamiento de fase de -1 al estado \(|1⟩\), dejando el estado \(|0⟩\) sin cambios |
\(\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}\) |
H, Hadamard |
Crea superposiciones: \(|0⟩\) a \(\frac{1}{\sqrt{2}}(|0⟩ + |1⟩)\) y \(|1⟩\) a \(\frac{1}{\sqrt{2}}(|0⟩ - |1⟩)\) |
\(\frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}\) |
S |
Aplica un desplazamiento de fase de \(i\) al estado \(|1⟩\), dejando el estado \(|0⟩\) sin cambios |
\(\begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}\) |
T |
Aplica un desplazamiento de fase de \(e^{i\pi/4}\) al estado \(|1⟩\), dejando el estado \(|0⟩\) sin cambios |
\(\begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}\) |
RX |
Una rotación de un solo qubit alrededor del eje X de la esfera de Bloch por un ángulo \(θ\) |
\(\begin{pmatrix} \cos(\frac{θ}{2}) & -i\sin(\frac{θ}{2}) \\ -i\sin(\frac{θ}{2}) & \cos(\frac{θ}{2}) \end{pmatrix}\) |
RY |
Una rotación de un solo qubit alrededor del eje Y de la esfera de Bloch por un ángulo \(θ\) |
\(\begin{pmatrix} \cos(\frac{θ}{2}) & -\sin(\frac{θ}{2}) \\ \sin(\frac{θ}{2}) & \cos(\frac{θ}{2}) \end{pmatrix}\) |
RZ |
Una rotación de un solo qubit alrededor del eje Z de la esfera de Bloch por un ángulo \(θ\) |
\(\begin{pmatrix} e^{-i\frac{θ}{2}} & 0 \\ 0 & e^{i\frac{θ}{2}} \end{pmatrix}\) |
CNOT, CX |
Una puerta de dos qubits que invierte el segundo qubit si el primer qubit es \(|1⟩\) |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}\) |
CZ |
Una puerta de dos qubits que aplica un desplazamiento de fase de -1 al estado \(|11⟩\), dejando los demás estados sin cambios |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & -1 \end{pmatrix}\) |
SWAP |
Una puerta de dos qubits que intercambia los estados de los dos qubits |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix}\) |
Puertas Controladas Genéricas |
Una versión controlada de una puerta genérica U, de modo que U actúa sobre el segundo qubit solo si el primer qubit es \(|1⟩\) |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & U_{00} & U_{01} \\ 0 & 0 & U_{10} & U_{11} \end{pmatrix}\) |
Toffoli |
Una puerta de tres qubits que invierte el tercer qubit si los dos primeros qubits son ambos \(|1⟩\) |
\(\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 & 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 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \end{pmatrix}\) |
¿Cómo Podemos Simular Estos Circuitos?
Nota
Si no tiene QiliSDK instalado y desea ejecutar los siguientes ejemplos usted mismo, puede seguir las instrucciones en la guía de instalación.
Ahora que entendemos qué son los circuitos cuánticos y qué hacen las puertas cuánticas, podemos usar QiliSDK para construir y simular nuestros propios circuitos cuánticos. Para crear un circuito cuántico en QiliSDK, podemos usar la clase Circuit:
from qilisdk.digital import Circuit
circuit = Circuit(2)
Esto crea un circuito cuántico con 2 qubits. Luego podemos añadir puertas a nuestro circuito:
from qilisdk.digital import H, CNOT
circuit.add(H(0))
circuit.add(CNOT(0, 1))
Y finalmente también deberíamos añadir algunas mediciones:
from qilisdk.digital import M
circuit.add(M(0))
circuit.add(M(1))
Esto da como resultado el circuito que mostramos al comienzo de este tutorial, que crea una superposición en el primer qubit, lo entrelaza con el segundo qubit y luego mide ambos qubits.
If we want to simulate this circuit, we can use the QiliSim backend. To tell the simulator that we want to simulate a circuit we use the the DigitalPropagation class and then use the Readout class to specify how we want to read out our results:
from qilisdk.backends import QiliSim
from qilisdk.functionals import DigitalPropagation
from qilisdk.readout import Readout
backend = QiliSim()
result = backend.execute(DigitalPropagation(circuit), Readout().with_sampling(nshots=100))
print(result.get_samples())
Esto ejecutará nuestro circuito en el simulador QiliSim, como si hubiéramos ejecutado nuestro circuito cuántico 100 veces y registrado todas nuestras mediciones. La salida será un diccionario de muestras, donde cada clave es una cadena que representa los resultados de medición para cada qubit, y cada valor es el número de veces que se observó ese resultado:
{
'00': 49,
'11': 51
}
Como puede verse, obtenemos números aproximadamente iguales de resultados “00” y “11”, que es lo que esperaríamos de nuestro circuito. Nótese que no es exactamente 50/50 ya que estamos muestreando de una distribución aleatoria, pero a medida que aumentamos el número de muestras deberíamos verlo acercarse cada vez más a 50/50.
Aquí solo hemos usado un simulador para ejecutar nuestro circuito, pero también podríamos ejecutarlo en un ordenador cuántico real. Para ello, puede usar SpeQtrum, el sistema para acceder al hardware cuántico de Qilimanjaro, que está disponible a través de QiliSDK. Puede encontrar más información sobre cómo hacer esto en la guía del módulo SpeQtrum.