Teletransportación cuántica

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 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ó 14 segundos de tiempo de QPU. Esto es solo una estimación. Tu uso real puede variar.

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

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

---

Introducción y antecedentes

La teletransportación cuántica es una técnica de la física cuántica que permite transferir información cuántica de un lugar a otro sin mover físicamente las partículas. A diferencia del concepto de teletransportación de la ciencia ficción, este proceso no implica transportar materia. En cambio, se basa en el principio del entrelazamiento cuántico, por el cual dos partículas quedan vinculadas sin importar la distancia que las separe. Mediante una serie de mediciones precisas y comunicación clásica, el estado cuántico de una partícula puede recrearse en otra partícula en un lugar distante, "teletransportando" efectivamente la información cuántica. En este módulo veremos cómo funciona esto matemáticamente y luego implementaremos la teletransportación cuántica en una computadora cuántica real. La introducción aquí será breve; para más antecedentes sobre información cuántica y una explicación más detallada sobre la teletransportación, recomendamos el curso de John Watrous sobre los Fundamentos de la información cuántica, y en particular la sección sobre Teletransportación.

Los bits clásicos pueden estar en los estados 0 o 1. Los bits cuánticos (qubits) pueden estar en estados cuánticos denotados $|0\rangle$ y $|1\rangle$ y también en combinaciones lineales de estos estados, llamadas "superposiciones", como $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, con $\alpha_0,\alpha_1 \in \mathbb{C},$ y $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Aunque los estados pueden existir en esta superposición, una medición del estado lo "colapsará" al estado $|0\rangle$ o al $|1\rangle$. Los parámetros $a$ y $b$ están relacionados con la probabilidad de cada resultado de medición según

$$P_0 = |\alpha_0|^2$$ $$P_1 = |\alpha_1|^2$$

De ahí la restricción de que $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Otra característica clave es que los bits cuánticos pueden estar "entrelazados", lo que significa que la medición de un qubit puede afectar el resultado de la medición de otro qubit entrelazado con él. Entender en qué se diferencia el entrelazamiento de las simples correlaciones clásicas es algo complicado. Primero expliquemos nuestra notación. Llamemos a dos qubits pertenecientes a la amiga 0 (Alice) y al amigo 1 (Bob), cada uno en el estado $|0\rangle$

$$|0\rangle_B|0\rangle_A$$

o

$$|0\rangle_1|0\rangle_0$$

a veces abreviado simplemente como

$$|00\rangle$$

Nota que el qubit con el número (o letra) más bajo está más a la derecha. Esta es una convención llamada notación "little-endian", utilizada en todo Qiskit. Si el estado de dos qubits de los amigos es $|00\rangle$ y miden el estado de sus respectivos qubits, cada uno encontrará un 0. De manera similar, si los qubits estuvieran en el estado $|11\rangle,$ cada una de sus mediciones daría un 1. Eso no es diferente del caso clásico. Sin embargo, en computación cuántica podemos combinar esto con la superposición para obtener estados como

$$\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$

En un estado como este, si los qubits de Alice y Bob están en el estado 0 o 1 aún no se sabe —ni siquiera la naturaleza lo ha determinado aún—, pero sabemos que medirán el mismo estado para su qubit. Por ejemplo, si Bob mide que su qubit está en el estado $|0\rangle,$ la única forma en que eso puede ocurrir es que la medición haya colapsado el estado de dos qubits a uno de los dos estados posibles, concretamente a $|00\rangle.$ Eso deja el qubit de Alice también en el estado $|0\rangle$.

El entrelazamiento de qubits de esta manera no requiere que los qubits permanezcan físicamente cerca uno del otro. En otras palabras, podríamos entrelazar qubits, separarlos a una gran distancia y usar su entrelazamiento para enviar información. Un estado entrelazado como el anterior es una unidad básica de entrelazamiento, y a veces se denomina "e-bit", un solo bit de entrelazamiento. Estos e-bits pueden considerarse recursos en la comunicación cuántica, ya que cada e-bit compartido entre socios distantes puede usarse, como se describe aquí, para mover información de un lugar a otro.

El primer pensamiento de muchas personas que aprenden esto por primera vez es sobre la violación de la relatividad: ¿podemos usar esto para enviar información más rápido que la luz? Por supuesto, sigue cuestionando y poniendo a prueba las reglas científicas, pero desafortunadamente esto no nos permitirá enviar información más rápido que la luz, por razones que quedarán claras a lo largo de este módulo. Spoiler: sorprendentemente, NO se debe a la velocidad a la que se propaga este colapso, que sí parece ocurrir más rápido que la luz [1]. Comenzamos con dos colaboradores, Alice y Bob, que inicialmente están en el mismo lugar y pueden trabajar juntos con los mismos qubits. Estos colaboradores entrelazarán sus qubits. Luego se separarán a dos ubicaciones geográficas distintas, llevando consigo sus respectivos qubits. Alice entonces obtendrá información cuántica en un nuevo qubit Q. No hacemos ninguna suposición sobre la información en Q. El estado de Q podría ser un secreto desconocido para Alice; podría ser desconocido para todas las personas. Pero Alice tiene la tarea de transferir la información en Q a Bob. Lo hará usando la teletransportación cuántica.

Para lograrlo, necesitaremos conocer algunas operaciones cuánticas o "Gates".

Operadores cuánticos (Gates)

Siéntete libre de omitir esta sección si ya estás familiarizado con los Gates cuánticos. Si quieres entender mejor estos Gates, consulta Fundamentos de la información cuántica, especialmente las dos primeras lecciones, en IBM Quantum Learning.

Para este protocolo de teletransportación utilizaremos principalmente dos tipos de Gates cuánticos: el Gate Hadamard y el Gate CNOT. Algunos otros tendrán un papel menor: el Gate $X$, el Gate $Z$ y el Gate SWAP.

Este módulo puede completarse con conocimientos muy limitados de álgebra lineal, pero a veces visualizar los Gates mecánico-cuánticos mediante matrices y vectores puede ser útil. Por eso presentamos aquí también las formas matricial/vectorial de los Gates y estados cuánticos.

Los estados que ya hemos presentado se eligen (en parte por convención y en parte por restricciones) para tener formas vectoriales:

$$|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$$ $$|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$$

De esta forma, un estado arbitrario $|\psi\rangle = a|0\rangle+b|1\rangle$ puede escribirse como

$$|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$$

Hay cierta libertad en cómo extender la notación a estados de múltiples qubits, pero la elección siguiente es bastante estándar:

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

Con esta notación vectorial en mente, podemos introducir los Gates cuánticos que necesitamos, sus efectos sobre los estados cuánticos y sus formas matriciales.

Gate H Hadamard: Crea un estado de superposición. Gate de un solo qubit.

$$H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right),$$ $$H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$$ $$H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Un Circuit con un Gate Hadamard se construye de la siguiente manera:

from qiskit import QuantumCircuit

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

Gate CNOT (NOT controlado): Este Gate utiliza dos qubits: un control y un objetivo. Verifica el estado del qubit de control, que no cambia. Pero si el qubit de control está en el estado $|1\rangle$, el Gate cambia el estado del qubit objetivo; si el estado del qubit de control es $|0\rangle$, no se realiza ningún cambio. En la notación siguiente, se asume que el qubit $A$ (el 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 usada es $CNOT(q_{control},q_{objetivo})|BA\rangle.$

$$CNOT(A,B)|00\rangle = |00\rangle, \\ CNOT(A,B)|01\rangle = |11\rangle, \\ CNOT(A,B)|10\rangle = |10\rangle, \\ CNOT(A,B)|11\rangle = |01\rangle$$

A veces verás el CNOT escrito con el orden del control y el objetivo simplemente implícito. Pero no existe tal ambigüedad en el código ni en los diagramas de circuito.

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

Un Gate CNOT se ve algo diferente en un Circuit, ya que requiere dos qubits. Así se implementa:

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

Comprueba tu comprensión

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

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

Respuesta:

$CNOT|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} = |11\rangle$

Gate $X$: Equivalente a una operación NOT. Gate de un solo qubit.

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

En Qiskit, crear un Circuit con un Gate $X$ se hace así:

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

Gate $Z$: Agrega una "fase" a un estado (un prefactor que, en el caso de los autoestados $|0\rangle$ y $|1\rangle$ del Gate Z, es 1 o -1, respectivamente). Gate de un solo qubit.

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

En Qiskit, crear un Circuit con un Gate $Z$ se hace así:

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

Teoría

Vamos a exponer el protocolo de teletransportación cuántica usando matemáticas. Luego, en la siguiente sección, implementaremos esta configuración en una computadora cuántica.

Alice y Bob entrelazan sus qubits: Inicialmente, el qubit de Alice y el de Bob están cada uno, por separado, en el estado $|0\rangle$ (una suposición válida y también la inicialización correcta para las computadoras cuánticas de IBM®). Podemos escribir esto como $|0\rangle_B|0\rangle_A$ o simplemente como $|00\rangle$. Calculemos qué sucede cuando Alice y Bob aplican el Gate Hadamard al qubit de Alice y luego un Gate CNOT con el qubit de Alice como control y el de Bob como objetivo:

$$\begin{aligned} CNOT(A,B)H_A |0\rangle_B|0\rangle_A &= CNOT(A,B)|0\rangle_B\frac{1}{\sqrt{2}}\left(|0\rangle_A+|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(CNOT(A,B)|0\rangle_B|0\rangle_A+CNOT(A,B)|0\rangle_B|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right) \end{aligned}$$

Nota que ahora los qubits de Alice y Bob están entrelazados. Aunque la naturaleza aún no ha determinado si ambos qubits están en el estado $|0\rangle$ o $|1\rangle$, sí se sabe que sus qubits están en el mismo estado. Alice y Bob se separan: Los dos amigos llevan sus qubits a nuevas ubicaciones, posiblemente muy distantes entre sí. Esto conlleva muchas advertencias: no es trivial mover información cuántica sin perturbarlo. Pero puede moverse y, de hecho, tú lo harás en este módulo. Ten en cuenta, sin embargo, que es de esperar que encontremos algunos errores cuando movemos información cuántica con frecuencia.

Se introduce Q: El estado secreto se prepara en el qubit Q:

$$|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q$$

En este punto, Q simplemente está adyacente al qubit de Alice (A). No ha habido entrelazamiento, por lo que el estado cuántico de los tres qubits juntos puede escribirse como:

$$|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).$$

El objetivo es mover la información en Q desde la ubicación de Alice hasta la ubicación de Bob. En este punto, no hacemos ninguna afirmación ni requisito sobre el secreto o la velocidad de la transferencia de información. Simplemente exploramos cómo puede moverse la información de Alice a Bob. Dado que la información comienza en Q, asumiremos que Q tiene el número más bajo entre los números de qubit, de modo que la notación little-endian hace que Q sea el qubit más a la derecha en las matemáticas siguientes.

Alice entrelaza los qubits A y Q: Alice opera ahora con un Gate CNOT con su propio qubit como control y Q como objetivo, y luego aplica un Gate Hadamard a Q. Calculemos el estado de tres qubits tras esa operación:

$$\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}$$

Dado que A y Q están en el mismo lugar, agrupemos los términos anteriores según los resultados de las mediciones sobre los qubits A y Q:

$$\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}$$

Comprueba tu comprensión

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

Dada la expresión anterior para los estados de los tres qubits, ¿cuál es la probabilidad de que una medición de los qubits A y Q dé $|0\rangle_A|0\rangle_Q?$

Respuesta:

25%. Para ver esto, recuerda que el estado de Bob debe estar normalizado, por lo que $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Ahora Alice puede medir los qubits A y Q. No puede controlar el resultado de esa medición, ya que las mediciones cuánticas son probabilísticas. Por eso cuando mide, hay 4 resultados posibles y los 4 son igualmente probables: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q$ y $|1\rangle_A|1\rangle_Q.$ Nota que cada resultado tiene implicaciones diferentes para el qubit de Bob. Por ejemplo, si Alice encuentra que sus qubits están en $|0\rangle_A|0\rangle_Q,$ eso colapsa todo el estado cuántico de 3 qubits a $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Los otros resultados de medición de Alice dan lugar a diferentes estados para Bob. Estos se recogen en la tabla siguiente.

Resultado de Alice	Estado de Bob	Instrucción para Bob	Resultado
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Ninguna	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ luego $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Para todos los posibles resultados de medición sobre los qubits de Alice, el qubit de Bob queda en un estado vagamente parecido al estado secreto que originalmente estaba en Q. En el caso en que Alice mide $	0\rangle_C	0\rangle_A$(la primera fila de la tabla), ¡el qubit de Bob queda en exactamente el estado secreto! En los otros casos, hay algo incorrecto en el estado. Los coeficientes ($\alpha$s) están intercambiados, o hay un signo "-" donde debería haber un "+", o ambos. Para modificar el qubit de Bob y que sea exactamente igual al estado secreto, Alice debe llamar a Bob (usar algún medio de comunicación clásica) y decirle que realice operaciones adicionales sobre su qubit, tal como se indica en la tabla. Por ejemplo, en la tercera fila los coeficientes están intercambiados. Si Alice llama a Bob y le dice que aplique un Gate$X$a su qubit, cambia un$	0\rangle$por un$

Ahora debería quedar claro por qué no podemos usar esta configuración para enviar información más rápido que la luz. Podríamos tener suerte y medir $|0\rangle_A|0\rangle_Q,$ lo que significa que Bob tiene exactamente el estado secreto, de forma instantánea. Pero Bob no lo sabe hasta que lo llamamos y le decimos "Medimos $|0\rangle_A|0\rangle_Q$, así que no tienes que hacer nada."

En el experimento mental, los qubits suelen estar físicamente separados y llevados a un nuevo lugar. Las computadoras cuánticas de IBM® usan qubits de estado sólido en un chip que no pueden separarse. Por eso, en lugar de mover a Alice y Bob a ubicaciones diferentes, separaremos la información en el propio chip usando los llamados "swap gates" para mover la información de un qubit a otro.

Experimento 1: Teleportación básica

IBM Quantum recomienda abordar los problemas de computación cuántica usando un marco de trabajo que llamamos "Qiskit patterns" (patrones de Qiskit). Consiste en los siguientes pasos.

• Paso 1: Transforma tu problema en un Circuit cuántico
• Paso 2: Optimiza tu Circuit para ejecutarlo en hardware cuántico real
• Paso 3: Ejecuta tu trabajo en computadoras cuánticas de IBM usando Runtime Primitives
• Paso 4: Post-procesa los resultados

Paso 1: Transforma tu problema en un Circuit cuántico

Toda la matemática que hicimos arriba fue describiendo el paso 1. Ahora lo implementaremos, ¡construyendo nuestro Circuit cuántico con Qiskit! Comenzamos creando un Circuit cuántico con tres Qubits y entrelazando los dos Qubits de Alice y Bob. Tomaremos estos como los Qubits 1 y 2, y reservaremos el Qubit 0 para el estado secreto.

# Step 1: Map your problem to a quantum circuit

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np

# Define registers
secret = QuantumRegister(1, "Q")
Alice = QuantumRegister(1, "A")
Bob = QuantumRegister(1, "B")

cr = ClassicalRegister(3, "c")

qc = QuantumCircuit(secret, Alice, Bob, cr)

# We entangle Alice's and Bob's qubits as in our work above. We apply a Hadamard gate and then a CNOT gate.
# Note that the second argument in the CNOT gate is the target.
qc.h(Alice)
qc.cx(Alice, Bob)

# Inserting a barrier changes nothing about the logic. It just allows us to force gates to be positioned in "layers".
qc.barrier()

# Now we will use random variables to create the secret state. Don't worry about the "u" gate and the details.
np.random.seed(42)  # fixing seed for repeatability
theta = np.random.uniform(0.0, 1.0) * np.pi  # from 0 to pi
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q
qc.u(theta, varphi, 0.0, secret)
qc.barrier()

# Now entangle Q and Alice's qubits as in the discussion above.
qc.cx(secret, Alice)
qc.h(secret)
qc.barrier()

# Now Alice measures her qubits, and stores the outcomes in the "classical registers" cr[]
qc.measure(Alice, cr[1])
qc.measure(secret, cr[0])

# Now we insert some conditional logic. If Alice measures Q in a "1" we need a Z gate, and if Alice measures A in a "1" we need an X gate (see the table).
with qc.if_test((cr[1], 1)):
    qc.x(Bob)
with qc.if_test((cr[0], 1)):
    qc.z(Bob)

qc.draw(output="mpl")

Eso es todo lo que tenemos que hacer para teleportar el estado de Alice a Bob. Sin embargo, recuerda que cuando medimos un estado cuántico $\alpha_0 |0\rangle+\alpha_1|1\rangle$ obtenemos $|0\rangle$ o $|1\rangle.$ Así que al final de todo esto, Bob definitivamente tiene el estado secreto de Alice, pero no podemos verificarlo fácilmente con una medición. Para que una medición nos confirme que lo hicimos correctamente, tenemos que aplicar un truco. Teníamos un operador etiquetado "U" de "unitario" que usamos para preparar el estado secreto de Alice. Podemos aplicar la inversa de U al final de nuestro Circuit. Si U transformó el estado $|0\rangle$ de Alice en $\alpha_0 |0\rangle+\alpha_1|1\rangle$, entonces la inversa de U transformará el $\alpha_0 |0\rangle+\alpha_1|1\rangle$ de Bob de vuelta a $|0\rangle.$ Así que esta última parte no sería necesaria si el objetivo fuera simplemente mover información cuántica. Solo la hacemos para verificar nuestros resultados.

# Add the inverse of U and measure Bob's qubit.
qc.barrier()

qc.u(theta, varphi, 0.0, Bob).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(Bob, cr[2])  # add measurement gate

qc.draw(output="mpl")

Si lo hemos hecho correctamente, nuestra medición en el Qubit de Bob debería dar un estado $|0\rangle.$ Por supuesto, estas mediciones son probabilísticas. Así que si hay aunque sea una pequeña probabilidad de medir el Qubit de Bob en el estado $|1\rangle$, una sola medición podría dar $|1\rangle.$ En realidad querríamos hacer muchas mediciones para asegurarnos de que la probabilidad de $|0\rangle$ es bastante alta.

Paso 2: Optimiza el problema para la ejecución cuántica

Este paso toma las operaciones que queremos realizar y las expresa en términos de la funcionalidad de una computadora cuántica específica. También mapea nuestro problema sobre la disposición de la computadora cuántica.

Comenzaremos cargando varios paquetes necesarios para comunicarnos con las computadoras cuánticas de IBM. También debemos seleccionar un Backend sobre el que ejecutar. Podemos elegir el Backend menos ocupado o seleccionar uno específico cuyas propiedades conocemos.

El código de abajo permite 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

# 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_sherbrooke

Habilitamos explícitamente la lógica sobre las mediciones.

from qiskit.circuit import IfElseOp

backend.target.add_instruction(IfElseOp, name="if_else")

Ahora debemos "transpilar" el Circuit cuántico. Esto implica muchos subpasos y es un tema fascinante. Solo para dar un ejemplo de un subpaso: no todas las computadoras cuánticas pueden implementar directamente todos los Gates lógicos de Qiskit. Debemos reescribir los Gates de nuestro Circuit en términos de Gates que la computadora cuántica pueda implementar. Podemos llevar a cabo ese proceso, y otros, usando un gestor de pases preconfigurado. Establecer optimization = 3 (el nivel más alto de optimización) garantiza que el mapeo de nuestro Circuit cuántico abstracto a las instrucciones dadas a la computadora cuántica sea tan eficiente como puede hacerlo nuestro pre-procesamiento.

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

Un "Sampler" es una primitiva diseñada para muestrear los posibles estados resultantes de un Circuit 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)

No todos los cómputos en una computadora cuántica pueden simularse razonablemente en computadoras clásicas. Esta teleportación simple definitivamente sí puede, pero no es nada sorprendente que clásicamente podamos guardar información de un lugar a otro. Recomendamos firmemente realizar estos cálculos usando una computadora cuántica real de IBM. Pero en caso de que hayas agotado tu uso mensual gratuito, o si algo debe completarse en clase y no puede esperar en la cola, este módulo puede completarse usando un simulador. Para ello, simplemente ejecuta la celda de abajo y descomenta las líneas asociadas en los pasos de "Ejecución".

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

Paso 3: Ejecución

Usa el Sampler para ejecutar tu trabajo, con el Circuit como argumento.

job = sampler.run([qc_isa])
# job = sampler_sim.run([qc_isa])
res = job.result()
counts = res[0].data.c.get_counts()

Paso 4: Post-procesamiento y análisis

Grafiquemos los resultados e interpretémoslos.

# This required 5 s to run on a Heron r2 processor on 10-28-24
from qiskit.visualization import plot_histogram

plot_histogram(counts)

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.

¿Cuáles de los estados anteriores indican una teleportación exitosa y cómo puedes saberlo?

Respuesta:

Los estados $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ son todos consistentes con una teleportación exitosa. Esto se debe a que agregamos un Gate para deshacer la preparación inicial del estado secreto. Si el estado secreto fue teleportado correctamente al Qubit de Bob, ese Gate adicional debería devolver el Qubit de Bob al estado $|0\rangle.$ Así que cualquier estado anterior con el Qubit de Bob (Qubit 0, también medido en el componente 0 del registro clásico, y por lo tanto el más alto/más a la derecha) en el estado $|0\rangle$ indica éxito.

Este gráfico muestra todos los resultados de medición para los tres Qubits, a lo largo de 5.000 pruebas o "shots". Señalamos antes que Alice mediría todos los estados posibles para los Qubits A y Q con igual probabilidad. Asignamos los Qubits 0-2 en el Circuit a Q, A y B, en ese orden. En notación little-endian, el Qubit de Bob es el más a la izquierda/inferior. Así que las cuatro barras de la izquierda corresponden al Qubit de Bob en $|0\rangle$, y los otros dos Qubits están en todas las combinaciones posibles con probabilidades aproximadamente iguales. Nota que casi todas (generalmente ~95%) las mediciones dan el Qubit de Bob en el estado $|0\rangle$, ¡lo que significa que nuestra configuración fue exitosa! Hay un puñado de shots (~5%) que dieron el Qubit de Bob en el estado $|1\rangle.$ Eso no debería ser lógicamente posible. Sin embargo, todas las computadoras cuánticas modernas sufren de ruido y errores en una medida mucho mayor que las computadoras clásicas. Y la corrección de errores cuánticos es todavía un campo emergente.

Experimento 2: Teleportación a través de un procesador

Sin duda, la parte más interesante de la teleportación cuántica es que un estado cuántico puede teleportarse a grandes distancias de forma instantánea (aunque la comunicación clásica de los Gates adicionales no es instantánea). Como ya se dijo, no podemos romper los Qubits del procesador y moverlos. Pero sí podemos mover la información de un Qubit a otro, hasta que los Qubits involucrados en la teleportación estén en lados opuestos del procesador. Repitamos los pasos que dimos arriba, pero ahora haremos un Circuit más grande con suficientes Qubits para abarcar el procesador.

Paso 1: Transforma tu problema en un Circuit cuántico

Esta vez, los Qubits correspondientes a Alice y Bob cambiarán. Por eso no nombraremos un único Qubit "A" y otro "B". En cambio, numeraremos los Qubits y usaremos variables para representar la posición actual de la información en los Qubits de Alice y Bob. Todos los demás pasos, excepto los swap gates, son como se describió anteriormente.

# Step 1: Map

# Define registers
qr = QuantumRegister(13, "q")

qc = QuantumCircuit(qr, cr)

# Define registers
secret = QuantumRegister(1, "Q")
ebitsa = QuantumRegister(6, "A")
ebitsb = QuantumRegister(6, "B")
# q = ClassicalRegister(1, "q meas")
# a = ClassicalRegister(1, "a")
# b = ClassicalRegister(1, "b")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)

# We'll start Alice in the middle of the circuit, then move information outward in both directions.
Alice = 5
Bob = 0
qc.h(ebitsa[Alice])
qc.cx(ebitsa[Alice], ebitsb[Bob])

# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits, until the information is on distant qubits.

for n in range(Alice):
    qc.swap(ebitsb[Bob], ebitsb[Bob + 1])
    qc.swap(ebitsa[Alice], ebitsa[Alice - 1])
    Alice = Alice - 1
    Bob = Bob + 1

qc.barrier()

# Create a random state for Alice (qubit zero)
np.random.seed(42)  # fixing seed for repeatability
# theta = np.random.uniform(0.0, 1.0) * np.pi    #from 0 to pi
theta = 0.3
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

qc.u(theta, varphi, 0.0, secret)

# Entangle Alice's two qubits
qc.cx(secret, ebitsa[Alice])
qc.h(secret)

qc.barrier()

# Make measurements of Alice's qubits and store the results in the classical register.
qc.measure(ebitsa[Alice], cr[1])
qc.measure(secret, cr[0])

# Send instructions to Bob's qubits based on the outcome of Alice's measurements.
with qc.if_test((cr[1], 1)):
    qc.x(ebitsb[Bob])
with qc.if_test((cr[0], 1)):
    qc.z(ebitsb[Bob])

qc.barrier()

# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.
qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(ebitsb[Bob], cr[2])  # add measurement gate

qc.draw("mpl")

Puedes ver en el diagrama del Circuit que los pasos lógicos son los mismos. La única diferencia es que usamos los swap gates para llevar el estado del Qubit de Alice desde el Qubit 6 ($A_5$) hasta el Qubit 1 ($A_0$), justo al lado de Q. Y usamos swap gates para llevar el estado inicial de Bob desde el Qubit 7 ($B_0$) hasta el Qubit 12 ($B_5$). Nota que el estado en el Qubit 12 ni siquiera está relacionado con el estado secreto de Q hasta que se realizan las mediciones en los lejanos Qubits 0 y 1, y el estado en el Qubit 12 no es igual al estado secreto hasta que se aplican los Gates condicionales $X$ y $Z$.

Paso 2: Optimiza tu Circuit

Normalmente, cuando usamos el gestor de pases para transpilar y optimizar nuestros Circuits, tiene sentido establecer optimization_level = 3, porque queremos que nuestros Circuits sean lo más eficientes posible. En este caso, no hay razón computacional para que transfiramos estados de los Qubits 6 y 7 a los Qubits 1 y 12. Eso es solo algo que hicimos para demostrar la teleportación a distancia. Si le pedimos al gestor de pases que optimice nuestro Circuit, se dará cuenta de que no hay razón lógica para estos swap gates, y los eliminará y realizará las operaciones de los Gates en Qubits adyacentes. Así que para este caso especial, usamos optimization_level = 0.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pmzero = generate_preset_pass_manager(target=target, optimization_level=0)

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Podemos visualizar dónde se encuentran estos Qubits en el procesador cuántico usando la función plot_circuit_layout.

Paso 3: Ejecución

Como antes, recomendamos ejecutar en computadoras cuánticas reales de IBM. Si has alcanzado tu uso mensual gratuito, no dudes en descomentar las celdas del simulador para ejecutar en uno.

# This required 5 s to run on a Heron r2 processor on 10-28-24
job = sampler.run([qc_isa_zero])
# job = sampler_sim.run([qc_isa_zero])
counts = job.result()[0].data.c.get_counts()

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Paso 4: Post-procesamiento clásico

De nuevo vemos que las probabilidades de los posibles resultados para los Qubits de Alice son bastante uniformes. Hay una fuerte preferencia por encontrar el Qubit de Bob en $|0\rangle$ después de invertir el código secreto, lo que significa que hay una alta probabilidad de haber teleportado correctamente el estado secreto a través del procesador, de Q a Bob (Qubits 0 a 12). Sin embargo, notamos que ahora hay una probabilidad mayor de no medir $|0\rangle$ para Bob. Esta es una lección importante en computación cuántica: cuantos más Gates tengas en secuencia, especialmente Gates de múltiples Qubits como los swap gates, más ruido y errores encontrarás.

Preguntas

Los instructores pueden solicitar versiones de estos notebooks con claves de respuestas y orientación sobre su ubicación en planes de estudios comunes completando esta encuesta rápida sobre cómo se están usando los notebooks.

Conceptos clave

• Los Qubits pueden entrelazarse, lo que significa que la medición de un Qubit afecta o incluso determina el estado de otro Qubit.
• El entrelazamiento difiere de las correlaciones clásicas; por ejemplo, los Qubits A y B podrían estar en una superposición de estados como $\alpha_0|00\rangle+\alpha_1|11\rangle.$ El estado de A o B podría ser indeterminado por la naturaleza, y sin embargo A y B podrían estar garantizados de estar en el mismo estado.
• A través de una combinación de entrelazamientos y mediciones, podemos transferir un estado (que puede almacenar información) de un Qubit a otro. Esta transferencia puede hacerse incluso a grandes distancias, y esto se llama teleportación cuántica.
• La teleportación cuántica depende de mediciones cuánticas, que son probabilísticas. Por lo tanto, puede ser necesaria comunicación clásica para ajustar los estados teleportados. Esto impide que la teleportación cuántica mueva información más rápido que la luz. La teleportación cuántica no viola la relatividad ni la causalidad.
• Las computadoras cuánticas modernas son más susceptibles al ruido y los errores que las computadoras clásicas. Espera unos pocos por ciento de error.
• Cuantos más Gates añadas en secuencia (especialmente Gates de 2 Qubits), más errores y ruido puedes esperar.

Preguntas de verdadero/falso

1. V/F La teleportación cuántica puede usarse para enviar información más rápido que la luz.
2. V/F La evidencia moderna sugiere que el colapso de un estado cuántico se propaga más rápido que la luz.
3. V/F En Qiskit, los Qubits se ordenan en estados con el Qubit de menor número a la derecha, como en $|q_3,q_2,q_1, q_0\rangle$

Preguntas de opción múltiple

1. Los Qubits A y B están entrelazados y luego separados por una gran distancia $d$. Se mide el Qubit A. ¿Cuál afirmación es correcta sobre la velocidad a la que se ve afectado el estado del Qubit B?

• a. El Qubit B se ve afectado instantáneamente, dentro de la tolerancia experimental, en los experimentos realizados hasta ahora.
• b. El Qubit B se ve afectado después de un tiempo $d/c$, lo que significa que el estado cuántico "colapsa" aproximadamente a la velocidad de la luz, dentro de la tolerancia experimental.
• c. El Qubit B se ve afectado solo después de que se haya producido comunicación clásica, lo que significa que ocurre en un tiempo mayor que $d/c$.
• d. Ninguna de las anteriores

2. Recuerda que la probabilidad de medición está relacionada con las amplitudes en los estados cuánticos. Por ejemplo, si un Qubit está inicialmente en el estado $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ la probabilidad de medir el estado $|0\rangle$ es $|\alpha_0|^2.$ No todos los conjuntos de mediciones coincidirán exactamente con estas probabilidades, debido al muestreo finito (igual que lanzar una moneda podría dar cara dos veces seguidas). El histograma de medición de abajo podría corresponder a cuál de los siguientes estados cuánticos. Selecciona la mejor opción.

• a. $|0\rangle$
• b. $\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$
• d. $\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle$
• e. $\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle$

3. ¿Cuál(es) de los siguientes estados muestra(n) los Qubits A y B entrelazados? Selecciona todos los que apliquen.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)$
• e. $|0\rangle_B|0\rangle_A$

4. En este módulo, preparamos un estado entrelazado: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Pero hay muchos otros estados entrelazados que podrían usarse para un protocolo similar. ¿Cuál de los estados de abajo podría producir un histograma de medición de 2 Qubits como el siguiente? Selecciona la mejor respuesta.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A$
• e. $|0\rangle_B|0\rangle_A$

Preguntas de discusión

1. Describe el protocolo de teleportación cuántica, de principio a fin, a tu compañero/grupo. Comprueba si tienen algo que agregar o si tienen preguntas.