single-qubit-gates.ipynb

Kernel: Python 3

Compuertas de un Solo Qubit

En la sección anterior, analizamos todos los estados posibles en los que podría estar un qubit. Vimos que los qubits pueden representarse mediante vectores 2D y que sus estados se limitan a la forma:

$$|q\rangle = \cos{(\tfrac{\theta}{2})}|0\rangle + e^{i\phi}\sin{\tfrac{\theta}{2}}|1\rangle$$

Donde $\theta$ y $\phi$ son números reales. En esta sección, cubriremos las compuertas, las operaciones que cambian un qubit entre estos estados. Debido a la cantidad de compuertas y las similitudes entre ellas, este capítulo corre el riesgo de convertirse en una lista. Para contrarrestar esto, hemos incluido algunas digresiones para introducir ideas importantes en lugares apropiados a lo largo del capítulo.

En Los Átomos de la Computación nos encontramos con algunas compuertas y las usamos para realizar un cálculo clásico. Una característica importante de los circuitos cuánticos es que, entre inicializar los qubits y medirlos, ¡las operaciones (compuertas) son siempre reversibles! Estas compuertas reversibles se pueden representar como matrices, y como rotaciones alrededor de la esfera de Bloch.

from qiskit import QuantumCircuit, assemble, Aer
from math import pi, sqrt
from qiskit.visualization import plot_bloch_multivector, plot_histogram
sim = Aer.get_backend('aer_simulator')

1. Las Compuertas de Pauli

Debes estar familiarizado con las matrices de Pauli de la sección de álgebra lineal. Si alguna de las matemáticas aquí es nueva para ti, debes usar la sección de álgebra lineal para ponerte al día. Veremos aquí que las matrices de Pauli pueden representar algunas compuertas cuánticas de uso muy común.

1.1 La Compuerta X

La compuerta X está representada por la matriz de Pauli X:

$$X = \begin{bmatrix} 0 & 1 \ 1 & 0 \end{bmatrix} = |0\rangle\langle1| + |1\rangle\langle0|$$

Para ver el efecto que tiene una compuerta en un qubit, simplemente multiplicamos el vector de estado del qubit por la compuerta. Podemos ver que la compuerta X intercambia las amplitudes de los estados $|0\rangle$ y $|1\rangle$:

$$X|0\rangle = \begin{bmatrix} 0 & 1 \ 1 & 0 \end{bmatrix}\begin{bmatrix} 1 \ 0 \end{bmatrix} = \begin{bmatrix} 0 \ 1 \end{bmatrix} = |1\rangle$$

Recordatorios

Multiplicación de Vectores por Matrices La multiplicación de matrices es una generalización del producto interno que vimos en el último capítulo. En el caso específico de multiplicar un vector por una matriz (como se ve arriba), siempre obtenemos un vector como resultado:

$$M|v\rangle = \begin{bmatrix}a & b \ c & d \end{bmatrix}\begin{bmatrix}v_0 \ v_1 \end{bmatrix} = \begin{bmatrix}a\cdot v_0 + b \cdot v_1 \ c \cdot v_0 + d \cdot v_1 \end{bmatrix}$$

En computación cuántica, podemos escribir nuestras matrices en términos de vectores base:

$$X = |0\rangle\langle1| + |1\rangle\langle0|$$

A veces, esto puede ser más claro que usar una matriz como caja, ya que podemos ver los resultados de las diferentes multiplicaciones:

$$\begin{aligned} X|1\rangle & = (|0\rangle\langle1| + |1\rangle\langle0|)|1\rangle \ & = |0\rangle\langle1|1\rangle + |1\rangle\langle0|1\rangle \ & = |0\rangle \times 1 + |1\rangle \times 0 \ & = |0\rangle \end{aligned}$$

De hecho, cuando vemos un ket y un bra multiplicados como esto:

$$|a\rangle\langle b|$$

esto se llama el producto externo, que sigue la regla:

$$|a\rangle\langle b| = \begin{bmatrix} a_0 b_0 & a_0 b_1 & \dots & a_0 b_n\ a_1 b_0 & \ddots & & \vdots \ \vdots & & \ddots & \vdots \ a_n b_0 & \dots & \dots & a_n b_n \ \end{bmatrix}$$

Podemos ver que esto da como resultado la matriz X como se ve arriba:

$$|0\rangle\langle1| + |1\rangle\langle0| = \begin{bmatrix}0 & 1 \ 0 & 0 \end{bmatrix} + \begin{bmatrix}0 & 0 \ 1 & 0 \end{bmatrix} = \begin{bmatrix}0 & 1 \ 1 & 0 \end{bmatrix} = X$$

En Qiskit, podemos crear un cortocircuito para verificar esto:

# Hagamos una compuerta X en un qubit |0>
qc = QuantumCircuit(1)
qc.x(0)
qc.draw()

Veamos el resultado del circuito anterior. Nota: Aquí usamos plot_bloch_multivector(), que toma el vector de estado de un qubit en lugar del vector de Bloch.

# Veamos el resultado
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)

De hecho, podemos ver que el estado del qubit es $|1\rangle$ como se esperaba. Podemos pensar en esto como una rotación de $\pi$ radianes alrededor del eje x de la esfera de Bloch. La compuerta X también se denomina a menudo compuerta NOT, en referencia a su análogo clásico.

1.2 Las compuertas Y y Z

De manera similar a la compuerta X, las matrices Y y Z de Pauli también actúan como compuertas Y y Z en nuestros circuitos cuánticos:

$$Y = \begin{bmatrix} 0 & -i \ i & 0 \end{bmatrix} \quad\quad\quad\quad Z = \begin{bmatrix} 1 & 0 \ 0 & -1 \end{bmatrix}$$$$Y = -i|0\rangle\langle1| + i|1\rangle\langle0| \quad\quad Z = |0\rangle\langle0| - |1\rangle\langle1|$$

Y, como era de esperar, también realizan respectivamente rotaciones de [[$\pi$|$2\pi$|$\frac{\pi}{2}$]] alrededor de los ejes y y z de la esfera de Bloch.

A continuación hay un widget que muestra el estado de un qubit en la esfera de Bloch, al presionar uno de los botones se realizará la compuerta en el qubit:

# Ejecutar el código en esta celda para ver el widget
from qiskit_textbook.widgets import gate_demo
gate_demo(gates='pauli')

En Qiskit, podemos aplicar las compuertas Y y Z a nuestro circuito usando:

qc.y(0) # Aplicar la compuerta Y en el qubit 0
qc.z(0) # Aplicar la compuerta Z en el qubit 0
qc.draw()

2. Digresión: Las Bases X, Y y Z

Recordatorios

Vectores Propios de las Matrices Hemos visto que multiplicar un vector por una matriz da como resultado un vector:

$$M|v\rangle = |v'\rangle \leftarrow \text{nuevo vector}$$$$M|v\rangle = \lambda|v\rangle$$$$\begin{aligned} Z|0\rangle & = |0\rangle \ Z|1\rangle & = -|1\rangle \end{aligned}$$

También puedes notar que la compuerta Z parece no tener efecto en nuestro qubit cuando está en cualquiera de estos dos estados. Esto se debe a que los estados $|0\rangle$ y $|1\rangle$ son los dos estados propios de la compuerta Z. De hecho, la base computacional (la base formada por los estados $|0\rangle$ y $|1\rangle$) suele denominarse base Z. Esta no es la única base que podemos usar, una base popular es la base X, formada por los estados propios de la compuerta X. Llamamos a estos dos vectores $|+\rangle$ y $|-\rangle$:

$$|+\rangle = \tfrac{1}{\sqrt{2}}(|0\rangle + |1\rangle) = \tfrac{1}{\sqrt{2}}\begin{bmatrix} 1 \ 1 \end{bmatrix}$$$$|-\rangle = \tfrac{1}{\sqrt{2}}(|0\rangle - |1\rangle) = \tfrac{1}{\sqrt{2}}\begin{bmatrix} 1 \ -1 \end{bmatrix}$$

Otra base menos utilizada es la formada por los estados propios de la compuerta Y. Estos se llaman:

$$|\circlearrowleft\rangle, \quad |\circlearrowright\rangle$$

Dejamos como ejercicio el cálculo de estos. De hecho, hay un número infinito de bases; para formar una, simplemente necesitamos dos vectores ortogonales. Los vectores propios de las matrices unitarias y Hermitianas forman una base para el espacio vectorial. Debido a esta propiedad, podemos estar seguros de que los estados propios de la compuerta X y la compuerta Y forman una base para los estados de 1 qubit (lee más sobre esto en la página de álgebra lineal en el apéndice)

Ejercicios Rápidos

1. Verifica que $|+\rangle$ y $|-\rangle$ sean de hecho estados propios de la compuerta X.

2. ¿Qué valores propios tienen?

3. Encuentra los estados propios de la compuerta Y y sus coordenadas en la esfera de Bloch.

Usando solo las compuertas de Pauli, es imposible mover nuestro qubit inicializado a cualquier estado que no sea $|0\rangle$ o $|1\rangle$, es decir, no podemos lograr la superposición. Esto significa que no podemos ver un comportamiento diferente al de un bit clásico. ¡Para crear estados más interesantes, necesitaremos más compuertas!

3. La Compuerta Hadamard

La compuerta de Hadamard (compuerta H) es una compuerta cuántica fundamental. Nos permite alejarnos de los polos de la esfera de Bloch y crear una superposición de $|0\rangle$ y $|1\rangle$. Tiene la matriz:

$$H = \tfrac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \ 1 & -1 \end{bmatrix}$$

Podemos ver que esto realiza las siguientes transformaciones:

$$H|0\rangle = |+\rangle$$$$H|1\rangle = |-\rangle$$

Esto se puede considerar como una rotación alrededor del vector de Bloch [1,0,1] (la línea entre los ejes x y z), o como una transformación del estado del qubit entre las bases X y Z.

Puedes jugar con estas compuertas usando el siguiente widget:

# Ejecutar el código en esta celda para ver el widget
from qiskit_textbook.widgets import gate_demo
gate_demo(gates='pauli+h')

Ejercicio Rápido

1. Escribe la compuerta H como los productos externos de los vectores $|0\rangle$, $|1\rangle$, $|+\rangle$ y $|-\rangle$.

2. Muestra que aplicar la secuencia de compuertas: HZH, a cualquier estado de qubit es equivalente a aplicar una compuerta X.

3. Encuentra una combinación de compuertas X, Z y H que sea equivalente a una compuerta Y (ignorando la fase global).

4. Digresión: Medir en Diferentes Bases

Hemos visto que el eje Z no es intrínsecamente especial y que hay infinitas otras bases. De manera similar, con la medición, no siempre tenemos que medir en la base computacional (la base Z), podemos medir nuestros qubits en cualquier base.

Como ejemplo, intentemos medir en la base X. Podemos calcular la probabilidad de medir $|+\rangle$ o $|-\rangle$:

$$p(|+\rangle) = |\langle+|q\rangle|^2, \quad p(|-\rangle) = |\langle-|q\rangle|^2$$

Y después de la medición, la superposición se destruye. Dado que Qiskit solo permite medir en la base Z, debemos crear la nuestra usando compuertas Hadamard:

# Crear la función de medición X:
def x_measurement(qc, qubit, cbit):
    """Medir el 'qubit' en la base X y almacenar el resultado en 'cbit'"""
    qc.h(qubit)
    qc.measure(qubit, cbit)
    return qc

initial_state = [1/sqrt(2), -1/sqrt(2)]
# Inicializar nuestro qubit y medirlo
qc = QuantumCircuit(1,1)
qc.initialize(initial_state, 0)
x_measurement(qc, 0, 0)  # medir el qubit 0 al bit clásico 0
qc.draw()

En los ejercicios rápidos anteriores, vimos que podías crear una compuerta X intercalando nuestra compuerta Z entre dos compuertas H:

$$X = HZH$$

Comenzando en la base Z, la compuerta H cambia nuestro qubit a la base X, la compuerta Z realiza un NOT en la base X y la compuerta H final devuelve nuestro qubit a la base Z. Podemos verificar que esto siempre se comporta como una compuerta X multiplicando las matrices:

$$ HZH = \tfrac{1}{\sqrt{2}}$$\begin{bmatrix} 1 & 1 \ 1 & -1 \end{bmatrix}$$ $$\begin{bmatrix} 1 & 0 \ 0 & -1 \end{bmatrix}$$ \tfrac{1}{\sqrt{2}}$$\begin{bmatrix} 1 & 1 \ 1 & -1 \end{bmatrix}$$

$$\begin{bmatrix} 0 & 1 \ 1 & 0 \end{bmatrix}$$

Siguiendo la misma lógica, hemos creado una medición en X al transformar la base X a la base Z antes de nuestra medición. Dado que el proceso de medición puede tener diferentes efectos según el sistema (por ejemplo, algunos sistemas siempre devuelven el qubit a $|0\rangle$ después de la medición, mientras que otros pueden dejarlo como el estado medido), el estado del qubit posterior a la medición no está definido y debemos restablecerlo si queremos usarlo nuevamente.

Hay otra forma de ver por qué la compuerta Hadamard nos lleva de la base Z a la base X. Supongamos que el qubit que queremos medir en la base X está en el estado (normalizado) $a |0\rangle + b |1\rangle$. Para medirlo en la base X, primero expresamos el estado como una combinación lineal de $|+\rangle$ y $|-\rangle$. Usando las relaciones $|0\rangle = \frac{|+\rangle + |-\rangle}{\sqrt{2}}$ y $|1\rangle = \frac{|+\rangle - |-\rangle} {\sqrt{2}}$, el estado se convierte en $\frac{a + b}{\sqrt{2}}|+\rangle + \frac{a - b}{\sqrt{2}}|-\rangle$. Observa que las amplitudes de probabilidad en la base X se pueden obtener aplicando una matriz Hadamard sobre el vector de estado expresado en la base Z.

Veamos ahora los resultados:

qobj = assemble(qc)  # Ensamblar el circuito en un Qobj que se pueda ejecutar
counts = sim.run(qobj).result().get_counts()  # Hacer la simulación, devolviendo el vector de estado
plot_histogram(counts)  # Mostrar la salida en la medición del vector de estado

Inicializamos nuestro qubit en el estado $|-\rangle$, pero podemos ver que, después de la medición, colapsamos nuestro qubit en el estado $|1\rangle$. Si vuelves a ejecutar la celda, verás el mismo resultado, ya que a lo largo de la base X, el estado $|-\rangle$ es un estado base y medirlo a lo largo de X siempre arrojará el mismo resultado.

Ejercicios Rápidos

1. Si inicializamos nuestro qubit en el estado $|+\rangle$, ¿cuál es la probabilidad de medirlo en el estado $|-\rangle$?

2. Usa Qiskit para mostrar la probabilidad de medir un qubit $|0\rangle$ en los estados $|+\rangle$ y $|-\rangle$ (Sugerencia: es posible que desees usar .get_counts() y plot_histogram()).

3. Intenta crear una función que mida en la base Y.

Medir en diferentes bases nos permite ver el famoso principio de incertidumbre de Heisenberg en acción. Tener la certeza de medir un estado en la base Z elimina toda certeza de medir un estado específico en la base X, y viceversa. Un error común es que la incertidumbre se debe a los límites de nuestro equipo, pero aquí podemos ver que la incertidumbre es en realidad parte de la naturaleza del qubit.

Por ejemplo, si ponemos nuestro qubit en el estado $|0\rangle$, nuestra medición en la base Z seguramente será $|0\rangle$, ¡pero nuestra medición en la base X es completamente aleatoria! De manera similar, si ponemos nuestro qubit en el estado $|-\rangle$, nuestra medición en la base X seguramente será $|-\rangle$, pero ahora cualquier medición en la base Z será completamente aleatoria.

En términos más generales: Cualquiera que sea el estado en el que se encuentre nuestro sistema cuántico, siempre hay una medición que tiene un resultado determinista.

La introducción de la compuerta H nos ha permitido explorar algunos fenómenos interesantes, pero todavía estamos muy limitados en nuestras operaciones cuánticas. Introduzcamos ahora un nuevo tipo de compuerta:

5. La compuerta P

La compuerta P (compuerta de fase) está parametrizada, es decir, necesita un número ($\phi$) para decirle exactamente qué hacer. La compuerta P realiza una rotación de $\phi$ alrededor de la dirección del eje Z. Tiene la forma matricial:

$$P(\phi) = \begin{bmatrix} 1 & 0 \ 0 & e^{i\phi} \end{bmatrix}$$

Donde $\phi$ es un número real.

Puedes usar el widget a continuación para jugar con la compuerta P, especifica $\phi$ usando el control deslizante:

# Ejecutar el código en esta celda para ver el widget
from qiskit_textbook.widgets import gate_demo
gate_demo(gates='pauli+h+p')

VBox(children=(HBox(children=(Button(description='X', layout=Layout(height='3em', width='3em'), style=ButtonSt…

Image(value=b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x01 \x00\x00\x01 \x08\x06\x00\x00\x00\x14\x83\xae\x8…

En Qiskit, especificamos una compuerta P usando p(phi, qubit):

qc = QuantumCircuit(1)
qc.p(pi/4, 0)
qc.draw()

Puedes notar que la compuerta Z es un caso especial de la compuerta P, con $\phi = \pi$. De hecho, hay tres compuertas a las que se hace referencia más comúnmente que mencionaremos en este capítulo, todas las cuales son casos especiales de la compuerta P:

6. Las compuertas I, S y T

6.1 La compuerta I

Primero viene la compuerta I (también conocida como ‘Id-gate’ o ‘compuerta identidad’). Esta es simplemente una compuerta que no hace nada. Su matriz es la matriz identidad:

$$I = \begin{bmatrix} 1 & 0 \ 0 & 1\end{bmatrix}$$

La aplicación de la compuerta identidad en cualquier lugar de tu circuito no debería tener ningún efecto en el estado del qubit, por lo que es interesante que incluso se considere una compuerta. Hay dos razones principales detrás de esto, una es que a menudo se usa en cálculos, por ejemplo: probar que la compuerta X es su propio inverso:

$$I = XX$$

La segunda, es que a menudo es útil cuando se considera hardware real para especificar una operación de ‘hacer nada’ o ‘ninguno’.

Ejercicio Rápido

1. ¿Cuáles son los estados propios de la compuerta I?

6.2 Las compuertas S

La siguiente compuerta a mencionar es la compuerta S (a veces conocida como compuerta $\sqrt{Z}$), esta es una compuerta P con $\phi = \pi/2$. Da un cuarto de vuelta alrededor de la esfera de Bloch. Es importante tener en cuenta que, a diferencia de todas las compuertas presentadas en este capítulo hasta ahora, ¡la compuerta S no es su propio inverso! Como resultado, a menudo verás la compuerta S^† (también compuerta “S-dagger”, “Sdg” o $\sqrt{Z}^\dagger$). La compuerta S^† es claramente una compuerta P con $\phi = -\pi/2$:

$$S = \begin{bmatrix} 1 & 0 \ 0 & e^{\frac{i\pi}{2}} \end{bmatrix}, \quad S^\dagger = \begin{bmatrix} 1 & 0 \ 0 & e^{-\frac{i\pi}{2}} \end{bmatrix}$$

El nombre "compuerta $\sqrt{Z}$" se debe al hecho de que dos compuertas S aplicadas sucesivamente tienen el mismo efecto que una compuerta Z:

$$SS|q\rangle = Z|q\rangle$$

Esta notación es común en toda la computación cuántica.

Para agregar una compuerta S en Qiskit:

qc = QuantumCircuit(1)
qc.s(0)   # Aplicar la compuerta S al qubit 0
qc.sdg(0) # Aplicar la compuerta Sdg al qubit 0
qc.draw()

6.3 La compuerta T

La compuerta T es muy utilizada, es una compuerta P con $\phi = \pi/4$:

$$T = \begin{bmatrix} 1 & 0 \ 0 & e^{\frac{i\pi}{4}} \end{bmatrix}, \quad T^\dagger = \begin{bmatrix} 1 & 0 \ 0 & e^{-\frac{i\pi}{4}} \end{bmatrix}$$

Al igual que con la compuerta S, la compuerta T a veces también se conoce como la compuerta $\sqrt[4]{Z}$.

En Qiskit:

qc = QuantumCircuit(1)
qc.t(0)   # Aplicar la compuerta T al qubit 0
qc.tdg(0) # Aplicar la compuerta Tdg al qubit 0
qc.draw()

Puedes usar el widget a continuación para jugar con todas las compuertas presentadas en este capítulo hasta ahora:

# Ejecutar el código en esta celda para ver el widget
from qiskit_textbook.widgets import gate_demo
gate_demo()

7. La compuerta U

Como vimos anteriormente, las compuertas I, Z, S y T eran todas casos especiales de la compuerta P más general. De la misma manera, la compuerta U es la más general de todas las compuertas cuánticas de un solo qubit. Es una compuerta parametrizada de la forma:

$$U(\theta, \phi, \lambda) = \begin{bmatrix} \cos(\frac{\theta}{2}) & -e^{i\lambda}\sin(\frac{\theta}{2}) \ e^{i\phi}\sin(\frac{\theta}{2}) & e^{i(\phi+\lambda)}\cos(\frac{\theta}{2}) \end{bmatrix}$$

Cada compuerta en este capítulo podría especificarse como $U(\theta,\phi,\lambda)$, pero es inusual ver esto en un diagrama de circuito, posiblemente debido a la dificultad para leerlo.

Como ejemplo, vemos algunos casos específicos de la compuerta U en los que es equivalente a la compuerta H y la compuerta P respectivamente.

$$\begin{aligned} U(\tfrac{\pi}{2}, 0, \pi) = \tfrac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \ 1 & -1 \end{bmatrix} = H & \quad & U(0, 0, \lambda) = \begin{bmatrix} 1 & 0 \ 0 & e^{i\lambda}\ \end{bmatrix} = P \end{aligned}$$

# Hagamos que la compuerta U transforme un estado |0> a |+>
qc = QuantumCircuit(1)
qc.u(pi/2, 0, pi, 0)
qc.draw()

# Veamos el resultado
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)

Debería ser obvio a partir de esto que hay un número infinito de compuertas posibles, y que esto también incluye las compuertas R_x y R_y, aunque no se mencionan aquí. También se debe tener en cuenta que no hay nada especial en la base Z, excepto que se ha seleccionado como la base de cálculo estándar. Qiskit también proporciona el equivalente X de las compuertas S y Sdg, es decir, las compuertas SX y SXdg respectivamente. Estas compuertas dan un cuarto de vuelta con respecto al eje X alrededor de la esfera del Bloch y son un caso especial de la compuerta R_x.

Antes de ejecutar en hardware cuántico real de IBM, todas las operaciones de un solo qubit se compilan en $I$, $X$, $SX$ y $R_{z}$. Por este motivo, a veces se denominan compuertas físicas.

8. Recursos adicionales

Puedes encontrar una hoja de trucos creada por la comunidad con algunas de las compuertas cuánticas comunes y sus propiedades aquí.

import qiskit.tools.jupyter
%qiskit_version_table