Monedas cuánticas — un módulo sobre superposición e interferencia

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 más reciente
• qiskit-ibm-runtime v0.40.1 o más reciente
• qiskit-aer v0.17.0 o más reciente
• 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 necesitará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ó 47 segundos de tiempo de QPU. Es solo una estimación; tu uso real puede variar.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit 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'

Mira el recorrido del módulo con la Dra. Katie McCormick a continuación, o haz clic aquí para verlo en YouTube.

---

Introducción

En este módulo exploraremos uno de los principios fundamentales de la teoría cuántica: la superposición. En nuestra experiencia cotidiana, los objetos siempre tienen características definidas. Su ubicación, tamaño, forma, color — todo sobre ellos — está determinado y es cierto, incluso si nosotros como observadores aún no los hemos medido. En el mundo cuántico, esto no es necesariamente así. Un objeto cuántico puede estar en algo llamado "superposición" de múltiples estados clásicamente permitidos. Cuando se mide la superposición, esta "colapsa" aleatoriamente a uno de esos estados.

En cierto modo, medir un estado de superposición es como lanzar una moneda al aire: no hay forma de saber de antemano de qué lado caerá. Este indeterminismo fundamental es un aspecto incómodo de la mecánica cuántica con el que incluso Einstein tuvo dificultades. Él dijo célebremente "Dios no juega a los dados" sobre esta aleatoriedad. Pero, como veremos, Dios efectivamente juega a los dados — y lanza monedas.

Vamos a pensar en el lanzamiento de una moneda clásica como analogía para la medición de un estado de superposición. Y — al jugar con una "moneda cuántica" usando Qiskit y un qubit en un procesador cuántico de IBM® — descubriremos rápidamente los límites de esa analogía.

Moneda clásica

Empecemos con una moneda clásica. Lanza una moneda y caerá cara arriba o cara abajo, con un 50$~$% de probabilidad de cada resultado. Si bien en principio se podría calcular de qué lado caerá la moneda conociendo las condiciones iniciales precisas y la fuerza/torsión del lanzamiento, en la práctica no hay forma de saber a priori de qué lado caerá. Por eso usamos el lanzamiento de moneda como ejemplo canónico de un estado probabilístico clásico, donde el resultado es esencialmente aleatorio. Podemos escribir el estado de la moneda antes de que aterrice para reflejar esta probabilidad 50/50:

$$S(coin) = \frac{1}{2}|up\rangle + \frac{1}{2}|down\rangle$$

Aquí, los dos términos representan los dos resultados posibles del lanzamiento y sus coeficientes representan las probabilidades de cada resultado. Observa que normalmente el "$|\rangle$" (conocido como "ket") se usa para representar un estado cuántico, pero aquí hablamos de un estado probabilístico clásico. Consulta la Lección 1: Sistemas únicos del curso Fundamentos de la información cuántica para aprender más sobre cómo representamos la información clásica y cuántica.

Si lanzáramos una moneda 1000 veces y registráramos el número de veces que cae cara arriba o abajo, obtendríamos algo como esto:

# import necessary packages:
import numpy as np
import matplotlib.pyplot as plt
import random

nflips = 1000
fliplist = [random.randint(0, 1) for f in range(nflips)]

# bar plots using get_gaussian_probs function
plt.hist(fliplist)
plt.show()

Moneda cuántica

Podemos crear un estado probabilístico similar usando un qubit en nuestra computadora cuántica. Al igual que el lanzamiento de moneda, un qubit también puede medirse en dos estados posibles: $|0\rangle$ y $|1\rangle$. Creamos el estado probabilístico de "superposición" partiendo del estado $|0\rangle$ y luego aplicando lo que se llama una Hadamard gate al qubit. Esto lo coloca en una superposición equitativa de $|0\rangle$ y $|1\rangle$. Ten en cuenta que aunque este estado de superposición puede parecer y comportarse como la moneda a primera vista, pronto veremos que hay mucho más en él que eso. El objetivo de este módulo es mostrarte que una superposición no es lo mismo que un lanzamiento de moneda clásico.

Entonces, dado que el qubit está en una superposición equitativa de 0 y 1, cuando midamos el qubit habrá un 50% de probabilidad de medir $|0\rangle$ y un 50% de probabilidad de medir $|1\rangle$. Escribimos este estado de forma un poco diferente al caso probabilístico clásico, por razones que quedarán claras más adelante:

$$|\psi\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle$$

Aquí, las probabilidades de medir cada uno de los dos estados ya no son iguales a los coeficientes, como era el caso en el estado probabilístico clásico anterior. En cambio, es el cuadrado de los coeficientes lo que nos da las probabilidades, y cada uno de estos coeficientes puede ser ahora complejo, lo que significa que pueden tener partes real e imaginaria.

A pesar de estas diferencias, el resultado de medir este estado es esencialmente el mismo que lanzar una moneda.

from qiskit import QuantumCircuit

qcoin = QuantumCircuit(1)
qcoin.h(0)
qcoin.measure_all()

qcoin.draw("mpl")

En efecto, aplicar la Hadamard gate es el análogo de lanzar una moneda. Y, así como lanzamos la moneda 1000 veces para observar las estadísticas de cara arriba o abajo, podemos hacer algo similar en Qiskit con nuestra "moneda cuántica". Podemos usar una primitiva de Qiskit llamada Sampler, que repetirá un Circuit varias veces para muestrear las estadísticas del estado resultante.

Primero, cargamos el servicio y las primitivas de Qiskit Runtime y luego seleccionamos un Backend en el que ejecutar el Circuit.

El código de abajo incluye instrucciones 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 más orientación.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# 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()

# Load the Runtime primitive and session
from qiskit_ibm_runtime import (
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

# Use the least busy backend
backend = service.least_busy()
print(backend.name)

ibm_kingston

Si ya no tienes tiempo disponible en tu cuenta, también puedes ejecutarlo en un simulador. Solo descomenta el código y ejecuta la celda de abajo:

## Use a local simulator

# from qiskit_aer import AerSimulator

## Generate a simulator that mimics the real quantum system

# backend_sim = AerSimulator.from_backend(backend)

## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)

# from qiskit.primitives import BackendSamplerV2
# sampler_sim = BackendSamplerV2(backend = backend_sim)
# from qiskit.primitives import BackendEstimatorV2
# estimator_sim = BackendEstimatorV2(backend = backend_sim)

## 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(qcoin)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analysis
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Con 1000 muestras del Circuit anterior, obtenemos algo prácticamente idéntico al histograma de la moneda clásica, salvo alguna fluctuación estadística.

Además de muestrear las estadísticas de la moneda cuántica, también podemos usar otra primitiva de Qiskit llamada Estimator para medir el llamado valor de expectativa de un observable del estado. Para ilustrar qué es este valor de expectativa, usemos la moneda clásica como ejemplo. Imagina que usas la moneda para apostar: cada vez que la lanzas y cae "cara arriba", ganas un dólar. Pero cada vez que cae "cara abajo", pierdes un dólar. Si quieres saber cuánto dinero esperas ganar por lanzamiento (el valor de expectativa del observable "dinero"), calcularías:

$$E(money) = \frac{1}{2} (+ \text{1 dollar}) + \frac{1}{2} (- \text{1 dollar}) = \text{0 dollars}$$

Como tienes la misma probabilidad de ganar un dólar que de perder uno, el valor de expectativa es $0.

De manera similar, con un estado cuántico podemos calcular el valor de expectativa del observable "Z", donde Z es la matriz de Pauli con valores +1 y -1 asociados a los estados $|0\rangle$ y $|1\rangle$, respectivamente.

$$\langle \psi|Z|\psi \rangle = \frac{1}{2} \langle 0 | Z | 0 \rangle + \frac{1}{2} \langle 1 | Z | 1 \rangle = \frac{1}{2} (+1) + \frac{1}{2}(-1) = 0$$

from qiskit.quantum_info import Pauli

qcoin = QuantumCircuit(1)
qcoin.h(0)

# for Estimator, we do not apply the measurement to the circuit

<qiskit.circuit.instructionset.InstructionSet at 0x136df1ba0>

## Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

obs = Pauli("Z")

qc_isa = pm.run(qcoin)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

## Execute

# On real hardware:
estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# On a simulator:
# job = estimator_sim.run([[qc_isa, obs_isa]])
# res=job.result()

print(res[0].data.evs)

-0.014799284701239441

Obtenemos un valor de expectativa de 0, tal como se esperaba (ja). Esta es otra forma de confirmar que efectivamente hay una probabilidad igual de medir 0 y 1, y que el comportamiento parece ser el de un lanzamiento de moneda.

En este punto, la "moneda cuántica" parece exactamente igual que la moneda clásica. Pero en la siguiente sección haremos algunos experimentos que revelarán las diferencias fundamentales entre ambas.

Lo cuántico al descubierto: un experimento en tres dimensiones

Hagamos un experimento mental: imagina que lanzas una moneda al aire y, en lugar de dejarla caer al suelo, tienes la coordinación para aplaudir mientras pasa entre tus manos y atraparla entre tus palmas. Ahora, en lugar de que la moneda quede cara arriba o abajo, queda cara a la izquierda o a la derecha.

Comprueba tu comprensión

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

¿Cuál es la probabilidad de cada uno de estos resultados, cara a la izquierda o cara a la derecha?

Respuesta:

La probabilidad seguirá siendo 50-50. No debería importar en qué dimensión elijamos medir el resultado del lanzamiento de moneda.

Con suerte respondiste que la probabilidad de encontrar cara a la izquierda o a la derecha sigue siendo 50-50. La dimensión a lo largo de la cual se mide el lanzamiento no debería afectar la probabilidad de los resultados.

Pero, ¿cómo se vería esto de forma diferente en nuestra moneda cuántica? Vamos a comprobarlo.

Podemos crear nuestra superposición cuántica de la misma manera que la vez anterior, con una Hadamard gate. Para medir "cara a la izquierda o a la derecha" en nuestra moneda cuántica, podemos hacer lo que hicimos con la moneda clásica: medir a lo largo de un eje diferente. Nuestras mediciones estándar en la computadora cuántica son a lo largo del eje vertical, como la medición habitual de "cara arriba o abajo" de la moneda clásica. Pero también podemos preguntarle a nuestra moneda cuántica si está cara a la izquierda o a la derecha, o de manera equivalente, si está en los estados $|+\rangle$ o $|-\rangle$, que apuntan a lo largo del eje $x$. Sampler solo muestrea en la base de medición Z, pero podemos usar Estimator para obtener el valor de expectativa de X. Los valores de X son +1 y -1 para los estados $|+\rangle$ o $|-\rangle$, respectivamente.

Comprueba tu comprensión

Lee la pregunta de abajo, piensa en tu respuesta y luego haz clic en el triángulo para ver la solución.

Si la moneda cuántica se comportara como la moneda clásica en este caso, tendríamos una probabilidad 50-50 de medir el estado en $|+\rangle$ y $|-\rangle$. ¿Qué valor de expectativa de X esperaríamos que devuelva Estimator en ese caso?

Respuesta:

Cuando aplicamos X al estado $|+\rangle$, obtenemos el valor +1 y al estado $|-\rangle$ obtenemos -1, por lo que si tuviéramos una distribución 50-50, obtendríamos un valor de expectativa de 0.

# Step 1: map problem

qcoin_lr = QuantumCircuit(1)
qcoin_lr.h(0)

obs = Pauli("X")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_lr)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = estimator_sim.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

0.9985207100591716

El valor de expectativa de X para este estado es 1. Por lo tanto, no hay una probabilidad 50-50 de medir $|+\rangle$ y $|-\rangle$.

Comprueba tu comprensión

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

¿Qué nos dice este valor de expectativa sobre el estado $|\psi\rangle$? ¿Cuáles son las probabilidades de medir $|+\rangle$ y $|-\rangle$ en esta base X?

Respuesta:

Como el valor de expectativa es igual al valor de X para el estado $|+\rangle$, eso significa que tenemos 100% de probabilidad de medir el estado $|+\rangle$ cuando medimos a lo largo de X.

¿Qué está pasando aquí? Parece que nuestra moneda cuántica puede tener resultados aleatorios y probabilísticos a lo largo de una dimensión, pero resultados perfectamente predecibles a lo largo de otra. Sería como lanzar una moneda y garantizar que cada vez que se atrapa apretando las manos, siempre quedara con la cara mirando a la derecha.

La fase cuántica

La diferencia clave de la moneda cuántica es que tiene otra cualidad que la moneda clásica no tiene. Recuerda que en un estado probabilístico clásico,

$$S(coin) = c_1|up\rangle + c_2|down\rangle$$

cada coeficiente es simplemente un número real y positivo que representa la probabilidad de medir un estado particular. En un estado cuántico,

$$|\psi\rangle = c_1 |0\rangle + c_2 |1\rangle$$

los coeficientes son complejos, por lo que contienen una parte real y una parte imaginaria. Cada coeficiente $c_i$ puede expresarse como un vector bidimensional en el plano complejo, con magnitud $|c_i|$ y ángulo $\phi_i$ que forma con el eje real:

$$c_i = |c_i| e^{i \phi_i}.$$

Llamamos $\phi_i$ la fase. La fase nos indica cómo dos términos en un estado cuántico van a interferir, es decir, cómo se sumarán o cancelarán como ondas. Si dos ondas están en fase, de modo que sus crestas y valles se alinean, se combinarán para formar una onda el doble de alta. A esto lo llamamos interferencia constructiva. Si están desfasadas, es decir, si la cresta de una se alinea con el valle de la otra y viceversa, se interfieren de forma destructiva y se cancelan por completo.

Al igual que las ondas, los estados cuánticos también pueden sumarse constructiva o destructivamente. Puede ser más difícil de ver porque a menudo no estamos hablando de una onda real en el espacio físico. En el caso de nuestros qubits, la interferencia ocurre en el espacio de información abstracto de los qubits. Observa también que, como solo importa la fase relativa entre las dos ondas para determinar cómo interferirán — es decir, la diferencia de fases $\Delta \phi = \phi_2 - \phi_1$ de los dos coeficientes — normalmente aplicamos una fase global de $-\phi_1$ a todo el estado para que $c_1$ sea puramente real y la fase relativa quede completamente capturada en $c_2$.

Para ver cómo la fase puede causar interferencia en nuestra moneda cuántica, intentemos aplicar la Hadamard dos veces en lugar de una sola. Clásicamente, esto no tendría ningún sentido — si aplicar la Hadamard equivale a lanzar una moneda, no se puede lanzar una moneda que ya está girando. Pero veamos qué le sucede a la moneda cuántica:

qcoin_0 = QuantumCircuit(1)
qcoin_0.h(0)
qcoin_0.h(0)
qcoin_0.measure_all()

qcoin_0.draw("mpl")

Ahora, antes de usar Sampler para medir el estado resultante, pensemos en cómo este qubit será transformado por cada gate. Comienza, como siempre, en $|0\rangle$. Luego, la primera Hadamard transforma el estado a la superposición, tal como ya hemos visto:

$$H|0\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle.$$

En este caso, ambos coeficientes son completamente reales y positivos, lo que significa que la fase es $\phi=0$.

A continuación se aplica la segunda Hadamard a cada parte del estado de superposición por separado. Ya sabemos cómo la Hadamard transforma el estado $|0\rangle$. ¿Pero qué ocurre con $|1\rangle$?

$$H|1\rangle = \frac{1}{\sqrt{2}} |0\rangle - \frac{1}{\sqrt{2}} |1\rangle$$

Esto es, de nuevo, una superposición equitativa de 0 y 1, similar a lanzar una moneda al aire, pero el coeficiente de este estado frente a $|1\rangle$ tiene una fase de $\phi = \pi$ que le da el signo negativo.

Comprueba tu comprensión

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

Calcula el estado resultante después de aplicar la segunda Hadamard. Es decir, calcula: $H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle)$. Ten en cuenta que $H$ es distributiva, así que podemos aplicarla a cada uno de los términos individualmente.

Respuesta:

$$H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle) = \frac{1}{\sqrt{2}} H|0\rangle + \frac{1}{\sqrt{2}} H|1\rangle = \frac{1}{2} [(|0\rangle + |1\rangle) + (|0\rangle - |1\rangle)] = |0\rangle$$

Ahora vamos a comprobar nuestra predicción con Sampler.

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_0)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

La segunda Hadamard ha cancelado a la primera y hemos vuelto al estado 0 con el que empezamos. Esto se debe a que la Hadamard transforma tanto el estado $|0\rangle$ como el $|1\rangle$ a estados similares, pero con fases opuestas. Tras la segunda Hadamard, vemos que los términos $|0\rangle$ interfieren de forma constructiva, pero los términos $|1\rangle$ interfieren destructivamente y se cancelan entre sí.

Exploremos más: podemos cambiar la fase usando una Gate "PHASE". Así que ahora apliquemos una Hadamard para crear la superposición, apliquemos un desfase de $\pi$ radianes y luego apliquemos la segunda Hadamard:

qcoin_pi = QuantumCircuit(1)
qcoin_pi.h(0)
qcoin_pi.p(np.pi, 0)
qcoin_pi.h(0)
qcoin_pi.measure_all()

qcoin_pi.draw("mpl")

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_pi)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Y ahora el Qubit se mide en el estado 1 en lugar de en el 0.

Entonces, incluso a partir de estos pocos y sencillos experimentos, ya puedes apreciar la drástica diferencia que esta fase puede marcar en un Circuit cuántico. Puede ser sutil y difícil de ver al principio. En nuestro primer experimento, donde simplemente lanzamos nuestra moneda cuántica con una Gate Hadamard y medimos el resultado del lanzamiento, nada revelaba el efecto de la fase. Fue solo al profundizar más cuando descubrimos la diferencia que puede suponer una fase. Puede hacer que la misma Gate cuántica tenga literalmente el efecto contrario sobre un Qubit.

Pruébalo tú mismo:

Edita la celda de código de abajo para cambiar la fase de manera que la segunda Hadamard cree un estado de superposición con probabilidades del 25% y el 75% de encontrar el estado en $|0\rangle$ y $|1\rangle$, respectivamente. Verifica tu respuesta con matemáticas.

qcoin_phase = QuantumCircuit(1)
qcoin_phase.h(0)
# replace "x" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)
# qcoin_phase.rz(x, 0)
qcoin_phase.h(0)
qcoin_phase.measure_all()

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_phase)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Otra analogía con la moneda (mejor) usando la Gate $\sqrt{\text{NOT}}$

A estas alturas ya hemos aprendido que el acto de lanzar una moneda es bastante diferente a crear un estado de superposición. ¿Existe una mejor analogía con una moneda que capture más fenómenos propios de la superposición? Sí. Claro que sí.

Vamos a hacer otro experimento mental con una moneda. Imagina la moneda sobre la mesa, con la cara hacia arriba. Para ponerla con la cara hacia abajo, basta con darle la vuelta. Esto es el equivalente computacional de una Gate "NOT".

Supongamos que queremos construir una operación que, si se aplica dos veces, sea equivalente a la Gate NOT. Es decir, queremos una "raíz cuadrada de NOT," o $\sqrt{\text{NOT}}$. Podemos conseguirlo pensando en cómo se implementa físicamente la Gate NOT sobre la moneda: es simplemente una rotación de 180 grados alrededor del eje x, por ejemplo. Así, si rotáramos la moneda solo 90 grados alrededor del eje x, sería equivalente a una Gate $\sqrt{\text{NOT}}$.

Imagina que, tras aplicar la Gate $\sqrt{\text{NOT}}$, queremos saber si la moneda está con la cara hacia arriba o hacia abajo. No está en ninguna de las dos posiciones: está de canto respecto al eje vertical. Pero ahora redefinamos nuestra "medición" de la moneda como: primero, colapsar la moneda a lo largo del eje de medición (aplastándola con la mano para que quede plana), y segundo, comprobar si está cara arriba o cara abajo.

Si realizamos esta "medición" sobre la moneda que está de canto, entonces la moneda "colapsará" a cara arriba o cara abajo con igual probabilidad. Al igual que en el lanzamiento de una moneda, en principio la dirección en que cae la moneda puede predecirse a partir de las condiciones iniciales y de cómo exactamente la fuerza de nuestra mano la "colapsa". Pero en la práctica debería ser difícil predecir qué cara quedará hacia arriba, así que es esencialmente aleatorio.

En realidad podemos medir esta moneda a lo largo de tres ejes distintos: $x$, $y$ y $z$. Vemos que el canto de la moneda apunta a lo largo de $x$ y $z$, de modo que la medición en esas direcciones requiere "colapsar" la moneda; por tanto, a lo largo de esos ejes habrá aleatoriedad con probabilidad 50:50 de medir cara arriba o cara abajo. Pero a lo largo del eje $y$, ya está plana, con la cara orientada hacia la dirección $-y$. Podemos llamar a eso "cara adelante."

Así, mientras que las mediciones en x y z arrojaron resultados aleatorios, ¡la medición en y siempre dará el mismo resultado! Si recuerdas el experimento de la "moneda cuántica" de la sección anterior, esto recuerda al comportamiento de la moneda cuántica. Se midió como 0 o 1 con probabilidad 50/50 en la dirección z, pero siempre como $|+\rangle$ y nunca como $|-\rangle$ a lo largo de X. Esto sugiere que quizás una moneda quieta, de canto, es una mejor forma de visualizar un estado de superposición de un Qubit que una moneda girando descontroladamente por el aire.

Usemos Qiskit para ver si nuestra "moneda cuántica" se comporta igual que la clásica cuando se aplica una Gate $\sqrt{\text{NOT}}$. Aplicaremos $\sqrt{\text{NOT}}$ a un Qubit que comienza en $|0\rangle$ y usaremos Estimator para comprobar el valor esperado de los tres observables X, Y y Z.

qcoin_sx = QuantumCircuit(1)
qcoin_sx.sx(0)

qcoin_sx.draw("mpl")

obs1 = Pauli("X")
obs2 = Pauli("Y")
obs3 = Pauli("Z")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_sx)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
job = estimator.run(pubs)
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
# job = estimator_sim.run(pubs)
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

[[-0.01234492]
 [-1.00388865]
 [ 0.00740695]]

Los valores esperados son 0, -1 y 0 para X, Y y Z, respectivamente.

Comprueba tu comprensión

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

Dados los valores esperados, ¿cuáles son las probabilidades de medir la moneda cuántica como cara arriba/abajo (o izquierda/derecha o adelante/atrás) para cada uno de los 3 ejes de medición?

Respuesta:

Hay una probabilidad del 50/50 de medir cualquiera de los dos estados a lo largo de X y Z, y el estado siempre se mide en la dirección $-y$ a lo largo de Y.

Este es el mismo resultado que obtuvimos con nuestro experimento mental aplicando una rotación de 90 grados "$\sqrt{\text{NOT}}$" a la moneda clásica. De hecho, ahora existe una analogía precisa entre la moneda y el estado del Qubit. Podemos visualizar el estado del Qubit como un vector que apunta en la dirección de la cara de una moneda, normal a la superficie de la moneda. Así, cara arriba, o el estado $|0\rangle$ en una moneda cuántica, es equivalente a un vector apuntando recto hacia arriba; cara abajo, o $|1\rangle$, apunta recto hacia abajo. Cualquier superposición equitativa de $|0\rangle$ y $|1\rangle$ apunta horizontalmente. La fase del estado determina la dirección horizontal exacta: la dirección a lo largo del ecuador es igual a la dirección a la que apunta el coeficiente $c_2$ en el plano complejo.

Ahora bien, todas las Gates que hemos visto en este notebook pueden visualizarse como una rotación (o serie de rotaciones) de la moneda/vector.

• NOT: 180 grados alrededor del eje x

• $\sqrt{\text{NOT}}$: 90 grados alrededor del eje x

• PHASE: rotación de $\phi$ alrededor del eje z

• Hadamard: Esta es un poco más complicada. Inicialmente la comparamos con lanzar una moneda al aire y que girara sin control. Pero la Hadamard es en realidad una rotación controlada y determinista de la moneda, como las demás Gates. La Hadamard se realiza rotando 90 grados alrededor del eje y y luego 180 grados alrededor del eje x.

Así que no hay nada aleatorio en un estado de superposición cuántica ni en ninguna de las operaciones estándar que realizamos sobre el Qubit. Cada operación es determinista y reversible. El único momento en que entra en juego la aleatoriedad es cuando decidimos medir el estado cuántico.

El estado del Qubit como vector de Bloch

Este vector que apunta en la dirección de la "cara" de la moneda se conoce como "vector de Bloch." Formalmente, un estado arbitrario de un Qubit (aislado) puede representarse mediante un vector que se encuentra en la superficie de una esfera de radio 1 con coordenadas $(r, \theta, \phi)$. Escrito en términos de estas coordenadas, el estado del Qubit es:

$|\psi\rangle = \cos{\frac{\theta}{2}} |0\rangle + e^{i \phi} \sin{\frac{\theta}{2}} |1\rangle$

Ahora vamos a comprobar con Qiskit cómo cambia el vector de Bloch cuando aplicamos varias Gates a nuestro Qubit partiendo del estado $|0\rangle$.

NOT

from qiskit.visualization import plot_bloch_multivector

qnot = QuantumCircuit(1)
qnot.x(0)

plot_bloch_multivector(qnot)

$\sqrt{\text{NOT}}$

qsqrtnot = QuantumCircuit(1)
qsqrtnot.sx(0)

plot_bloch_multivector(qsqrtnot)

PHASE ($\phi = \pi$)

qphase = QuantumCircuit(1)
qphase.p(np.pi, 0)

plot_bloch_multivector(qphase)

Hadamard

qhadamard = QuantumCircuit(1)
qhadamard.h(0)

plot_bloch_multivector(qhadamard)

Conclusión: ¿qué es realmente un estado de superposición?

Comenzamos este módulo comparando la aleatoriedad de medir un estado de superposición cuántica con el lanzamiento de una moneda. Comparamos la "Gate Hadamard" que produce una superposición cuántica con el acto de lanzar una moneda al aire. Sin embargo, a través de una serie de experimentos, aprendimos que existen diferencias fundamentales entre el lanzamiento de una moneda clásica y una superposición cuántica.

Aprendimos que en realidad no hay nada "aleatorio" en un Qubit en estado de superposición. Es como una moneda quieta en el espacio tridimensional. De hecho, una moneda libre de rotar en 3 dimensiones es una analogía muy cercana a una forma particular de visualizar el estado cuántico de un Qubit, llamada vector de Bloch. Las Gates cuánticas rotan esta moneda/vector de Bloch de forma determinista y reversible. Es solo cuando medimos el Qubit que se introduce cualquier aleatoriedad. Comparamos este proceso de medición con aplastar la moneda para que quede plana en la dirección del eje de medición.

Si un estado cuántico está o no en superposición depende realmente del ojo que lo mire. Como probablemente hayas encontrado antes, somos libres de elegir nuestro sistema de coordenadas: $x$, $y$ y $z$ pueden apuntar a lo largo de tres direcciones ortogonales cualesquiera. Así, si tenemos una superposición de 0 y 1 en un sistema de coordenadas, podemos definir un nuevo sistema de coordenadas —o equivalentemente, una nueva "base de medición"— en el que el estado apunta puramente en la dirección $+z$ y, por tanto, no está en un estado de superposición. Entonces, cuando decimos que un Qubit está en superposición, también debemos responder a la pregunta: "¿superposición de qué?"

Puede que termines este módulo con la impresión de que acabamos de eliminar todo el misterio de la mecánica cuántica. Al fin y al cabo, uno de los aspectos supuestamente "más extraños", el estado de superposición de un Qubit, es en realidad tan sencillo como un vector tridimensional. Pero ten en cuenta que la moneda sigue siendo solo una analogía, y que incluso el vector de Bloch es únicamente una herramienta de visualización para calcular las probabilidades de los resultados de una medición. No podemos decir lo que un estado cuántico está realmente haciendo antes de ser medido. ¡Porque comprobarlo requiere una medición!

Discutiremos este dilema sobre cuál es la naturaleza "verdadera" de un estado cuántico y cómo el fenómeno cuántico del entrelazamiento puede ayudarnos a esclarecerlo en el módulo de la Desigualdad de Bell.

Preguntas

Los instructores pueden solicitar versiones de estos notebooks con las claves de respuesta y orientación sobre su ubicación en planes de estudio habituales rellenando esta breve encuesta sobre cómo se están utilizando los notebooks.

Conceptos clave:

• Aunque la medición de un Qubit en superposición es probabilística, como el lanzamiento de una moneda, el estado de superposición en sí se comporta de manera diferente a una moneda en el aire.
• Una diferencia principal entre una distribución de probabilidad clásica y una superposición es que la superposición tiene coherencia de fase, lo que le permite interferir de forma constructiva o destructiva.
• El estado de un Qubit único y aislado puede visualizarse como un punto en la llamada "esfera de Bloch," donde las amplitudes relativas de los componentes $|0\rangle$ y $|1\rangle$ determinan el ángulo polar $\theta$ y las fases relativas entre los dos componentes determinan el ángulo azimutal $\phi$.
• Todas las Gates cuánticas de un solo Qubit pueden verse como rotaciones del vector sobre esta esfera.

Preguntas V/F:

1. V/F Una superposición cuántica es básicamente lo mismo que un evento probabilístico en la física clásica, como lanzar una moneda al aire.

2. V/F La longitud del vector de Bloch que describe el estado de un Qubit aislado único es siempre 1.

3. V/F Las Gates cuánticas de un solo Qubit no cambian la longitud del vector de Bloch.

Preguntas de opción múltiple:

1. Selecciona el vector de Bloch correcto que representa el estado $|\Psi\rangle = \sqrt{\frac{1}{3}}|0\rangle + e^{i \pi / 4} \sqrt{\frac{2}{3}}|1\rangle$:

2. La esfera de Bloch describe lo siguiente de un Qubit: (selecciona todas las que apliquen)

   a. amplitud

   b. entrelazamiento con otros Qubits

   c. fase

   d. color

   e. probabilidad de los resultados de medición

Preguntas de discusión:

1. ¿Por qué el estado de un Qubit puede visualizarse en la esfera de Bloch, pero la distribución de probabilidad del lanzamiento de una moneda no?

2. ¿Por qué una moneda girando en el aire no es la mejor analogía para un estado de superposición cuántica? ¿Qué aspecto de las superposiciones no queda capturado en esta analogía?

Problemas de desafío:

1. Usa Qiskit para crear un Circuit que transforme el estado $|0\rangle$ al estado $\frac{\sqrt{3}}{2}|0\rangle + \frac{1}{2}e^{i \frac{5\pi}{6}}|1\rangle$