Skip to content
Inicio/Blog/Teleportación cuántica en Qiskit: un tutorial práctico
AlgorithmsQiskitFundamentals

Teleportación cuántica en Qiskit: un tutorial práctico

Construye el protocolo de teleportación cuántica desde cero en Qiskit: par de Bell, medición en base de Bell y corrección controlada clásicamente, con código funcional y una mirada honesta a lo que el protocolo hace y no hace.

FreeQuantumComputing
·· 9 min read

La teleportación cuántica transfiere el estado exacto de un qubit de un lugar a otro sin transportar físicamente el qubit en sí. El protocolo necesita tres qubits, un par entrelazado compartido y dos bits clásicos, y puedes construir todo esto en menos de treinta líneas de Qiskit.

El nombre es la causa de la mayor parte de la confusión en torno a este protocolo, así que aclarémoslo antes de tocar código.

Lo que la teleportación no es

El protocolo no mueve materia. Nada de la partícula física del qubit se traslada a ningún sitio. Lo que se mueve es información: el qubit del receptor termina el protocolo exactamente en el mismo estado cuántico en el que empezó el qubit del emisor.

El protocolo no permite comunicación más rápida que la luz. El qubit del receptor es basura inservible hasta que llegan dos bits clásicos desde el emisor, y esta transmisión está limitada por la velocidad de la luz como cualquier otra señal clásica. La naturaleza es cuidadosa aquí: el entrelazamiento por sí solo correlaciona resultados, pero nunca transporta una señal controlable por sí mismo.

El protocolo tampoco copia el qubit. El teorema de no clonación prohíbe que exista jamás una copia perfecta de un estado cuántico desconocido junto al original, y la teleportación respeta esto estrictamente: el acto de transmitir el estado destruye la copia del emisor. Al final hay exactamente un qubit portando el estado, y el qubit del receptor no es el mismo con el que empezaste.

El protocolo en tres pasos

  1. Compartir entrelazamiento por adelantado. El emisor y el receptor tienen cada uno la mitad de un par de Bell, distribuido antes de que se sepa siquiera qué estado hay que teleportar.
  2. El emisor realiza una medición conjunta (en base de Bell) sobre su mitad del par junto con el qubit a teleportar. Esto produce uno de cuatro resultados aleatorios de dos bits y destruye el estado original del qubit como efecto secundario.
  3. El emisor envía esos dos bits clásicos al receptor, quien aplica una de cuatro puertas correspondientes (identidad, X, Z o XZ) a su mitad del par. Esta corrección reconstruye el estado original exacto, sin importar cuál de los cuatro resultados aleatorios salió en el paso 2.

La aleatoriedad del paso 2 es real e inevitable, y la corrección del paso 3 la cancela de forma determinista. Esta cancelación es todo el sentido del protocolo, y este paso es también la parte más fácil de hacer mal, más sobre esto a continuación.

Construyendo el circuito en Qiskit

Tres qubits: q0 contiene el estado a teleportar, q1 es la mitad del emisor del par entrelazado, q2 es la mitad del receptor.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit_aer import AerSimulator

theta = 0.9  # arbitrary angle, stands in for "an unknown state"

qr = QuantumRegister(3, "q")
cr = ClassicalRegister(2, "c")
result_reg = ClassicalRegister(1, "result")
qc = QuantumCircuit(qr, cr, result_reg)

# Step 0: prepare the state to teleport on q0. In a real protocol
# this state is unknown. Ry(theta) here only gives us something
# concrete to verify against later.
qc.ry(theta, 0)
qc.barrier()

Paso 1: Distribuir el par entrelazado

qc.h(1)
qc.cx(1, 2)
qc.barrier()

Construcción estándar de un estado de Bell: una puerta Hadamard seguida de una CNOT. q1 y q2 están ahora máximamente entrelazados, y en un despliegue real ya estarían separados: q1 con el emisor, q2 con el receptor, antes de que se ejecute el resto del protocolo.

Paso 2: Medición en base de Bell

qc.cx(0, 1)
qc.h(0)
qc.measure(0, cr[0])
qc.measure(1, cr[1])
qc.barrier()

La CNOT y la Hadamard rotan el estado conjunto de q0 y q1 a la base de Bell, de modo que una medición estándar en base computacional ahora indica en cuál de los cuatro estados de Bell colapsó el par. Este resultado es aleatorio de forma uniforme, aproximadamente un 25% para cada una de las cuatro combinaciones de cr[0] y cr[1], y corregir esta aleatoriedad es exactamente lo que hace el siguiente paso.

Paso 3: Corrección controlada clásicamente

with qc.if_test((cr[1], 1)):
    qc.x(2)
with qc.if_test((cr[0], 1)):
    qc.z(2)

Esta es una condición clásica genuina en medio del circuito, no un atajo: q2 solo recibe una puerta X cuando el bit clásico cr[1] midió 1, y solo recibe una puerta Z cuando cr[0] midió 1. El gestor de contexto if_test de Qiskit compila esto en un circuito dinámico real, el mismo mecanismo que un despliegue físico usaría para enviar dos bits clásicos por un canal ordinario y aplicar una corrección en el otro extremo.

Paso 4: Verificar que el protocolo funcionó

qc.ry(-theta, 2)
qc.measure(2, result_reg[0])

sim = AerSimulator()
tqc = transpile(qc, sim)
counts = sim.run(tqc, shots=4096).result().get_counts()
print(sorted(counts.items()))

El truco de verificación: aplicar la rotación inversa a la original sobre q2 y medir el qubit. Si q2 terminó en el estado exacto en que empezó q0, deshacer esta rotación devuelve el qubit a |0⟩, y el bit result lee 0. Los cuatro resultados de (cr[0], cr[1]) se mantienen aproximadamente repartidos por igual a lo largo de la ejecución, el resultado aleatorio de la medición de Bell comportándose como se espera, mientras que el bit result lee 0 sin importar cuál de los cuatro resultados ocurrió. Esta es la recompensa: el paso de corrección cancela cualquier resultado aleatorio que haya salido, absolutamente siempre, no solo en promedio.

El error: omitir la corrección "porque el circuito ya está bien"

Al mirar este circuito, es tentador asumir que el paso de corrección es un detalle menor, ya que tres de los cuatro resultados de Bell parecen cercanos al caso identidad. No lo son. Omite los bloques if_test y mide q2 directamente: el resultado vuelve correcto solo en el 25% aproximado de las ejecuciones donde la medición de Bell cayó por casualidad en |00⟩, y vuelve revuelto las otras tres cuartas partes del tiempo. Aquí no hay puntuación parcial. La corrección no es una optimización, la corrección es el mecanismo que hace determinista el protocolo en lugar de una moneda fiable solo una cuarta parte de las veces.

Para qué sirve la teleportación

El protocolo en sí no tiene una aplicación independiente como truco de fiesta autónomo. Su importancia es estructural: este es el mecanismo que las redes cuánticas y la computación cuántica distribuida usan para mover el estado de un qubit entre nodos conectados solo por entrelazamiento compartido de antemano y un enlace clásico, en lugar de por un cable cuántico directo. Toda propuesta para enlazar QPUs separadas en una máquina lógica más grande, o para repetidores cuánticos que extienden el entrelazamiento a lo largo de enlaces de fibra largos, se construye exactamente sobre esta primitiva. La codificación superdensa, que envía dos bits clásicos usando un solo qubit transmitido, es la misma idea aplicada al revés.

Ejecutar esto en hardware real

Una medición en medio del circuito seguida de una puerta condicionada clásicamente es un requisito de hardware genuinamente más exigente que un circuito estático. El sistema necesita electrónica de control clásica rápida y de baja latencia, que lea una medición y devuelva una corrección al mismo circuito antes de que los qubits pierdan coherencia, una capacidad a menudo llamada "circuitos dinámicos" y que no todos los backends en la nube soportan en todas las generaciones de dispositivos. Donde los circuitos dinámicos no están disponibles, algunas implementaciones sustituyen las correcciones clásicas por puertas de dos qubits condicionadas y posponen toda medición hasta el final, lo que verifica correctamente las matemáticas del protocolo en simulación pero evita el paso real de comunicación clásica que hace que la teleportación sea práctica para redes en primer lugar. Para ejecuciones en hardware real, comprueba si tu backend objetivo soporta explícitamente circuitos dinámicos antes de asumir que este código se ejecutará tal como está escrito.

Próximos pasos