Distribución cuántica de claves

Para este módulo de Qiskit en las aulas, los estudiantes deben tener un entorno Python en funcionamiento 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 ordenadores cuánticos reales, los estudiantes deberán crear una cuenta en IBM Quantum® siguiendo los pasos de la guía Configure su cuenta IBM Cloud.

Este módulo fue probado y utilizó 5 segundos de tiempo QPU. Esto es sólo una estimación. Su uso real puede variar.

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

Vea el tutorial del módulo de la Dra. Katie McCormick a continuación, o haga clic aquí para verlo en YouTube.

Introducción y motivación

Existen infinitas formas de cifrar y descifrar información, y se han estudiado literalmente miles de ellas. Aquí nos limitaremos a un método de cifrado muy antiguo y muy sencillo, denominado "sustitución simple", para centrarnos en la parte cuántica de este protocolo. La parte cuántica podría adaptarse a muchos otros protocolos con relativamente pocos cambios.

Sustitución sencilla

Un cifrado por sustitución simple es aquel en el que una letra o un número se sustituye por otro, de modo que existe una correspondencia 1:1 entre las letras y números de un mensaje y las letras y números utilizados en una secuencia cifrada. Un ejemplo de la cultura popular son las criptocitas o criptogramas, en los que una cita o frase se cifra mediante una simple sustitución y el jugador debe descifrarla. Estos son fáciles de resolver si son lo suficientemente largos. Veamos un ejemplo:

R WVXRWVW GSZG R'W YVGGVI NZPV GSRH KIVGGB OLMT. GSZG DZB, KVLKOV DROO SZEV ZM VZHRVI GRNV HLOERMT RG. R SLKV R NZWV RG HRNKOV VMLFTS.

Las personas que los resuelven a mano suelen utilizar trucos que implican familiaridad con la estructura del lenguaje del mensaje original. Por ejemplo, en inglés, las únicas palabras de una letra como la "R" cifrada son "a" e "I". Las letras dobles cifradas en, por ejemplo, "KIVGGB" sólo pueden tomar determinados valores. Hay cosas más sutiles que dan pistas, como que la palabra más común que encaja en el patrón "GSZG" es "eso". Las personas que utilizan código para resolver esto tienen muchas más opciones, incluida la simple exploración de posibilidades hasta recuperar una palabra en inglés, y la actualización conservando esa palabra. Un método sencillo pero eficaz es utilizar la frecuencia de las letras, especialmente cuando el mensaje es lo suficientemente largo como para constituir una muestra representativa del inglés.

Pregunta de registro

Si quieres, intenta descifrarlo, aunque no es necesario para el resto del módulo. Haz clic en «Responder» a continuación para ver el mensaje.

• Respuesta

  Decidí que sería mejor hacer esto bastante largo. Así, la gente lo tendrá más fácil para resolverlo. Espero haberlo simplificado lo suficiente.

El ejemplo anterior está asociado a una "clave", una correspondencia entre las letras cifradas y las descifradas. En este caso, la clave es:

• A (no se utiliza, llamémosla Z)
• B->Y
• C (no se utiliza, llamémoslo X)
• D->W
• E->V
• F->U
• ...

Y así sucesivamente. Por decirlo suavemente, no es una buena llave. Las claves en las que las letras cifradas y descifradas son simplemente versiones desplazadas del alfabeto (como A->B y B->C) se denominan cifrados de "desplazamiento César".

Tenga en cuenta que estos son muy difíciles si son cortos. De hecho, si son muy cortas, son indeterminadas. Ten en cuenta los datos siguientes:

URYYP

Hay muchas desencriptaciones posibles, usando diferentes claves: HELLO, PETTY, HAPPY, JIGGY, STOOL. ¿Se le ocurren otros?

Pero si envías muchos mensajes como éste, con el tiempo, el cifrado será descifrado. Por lo tanto, no debes utilizar la misma "llave" con demasiada frecuencia. De hecho, lo mejor es que utilice una determinada sustitución una sola vez. No en un solo mensaje, ¡sino para un solo personaje! Con esto queremos decir que tendrás un esquema o clave de cifrado para cada carácter utilizado en el mensaje, en orden. Si quieres enviar un mensaje a un amigo utilizando este mensaje, tú y tu amigo necesitaríais un bloc de papel (en los viejos tiempos) en el que estuviera escrita esta clave siempre cambiante. Sólo se utilizará una vez. Esto se denomina "one-time pad".

El bloque de cifrado de uso único

Veamos cómo funciona con un ejemplo. Podría hacerse enteramente con letras, pero es habitual convertir de letras a números, por ejemplo, asignando A=0, B=1, C=2…. Supongamos que somos amigos implicados en actividades clandestinas y hemos compartido un bloc. Lo ideal sería compartir muchas almohadillas, pero la de hoy lo es:

EDGRPOJNCUWQZVMK.

O la conversión a números por su ubicación en el alfabeto:

4,3,6,17,15, 14, 9, 13, 2, 20, 22, 16, 25, 21, 12, 10.

Supongamos, quiero compartir con ustedes, el mensaje:

"¡Me encanta el quantum!"

O, lo que es lo mismo:

8, 11, 14, 21, 4, 16, 20, 0, 13, 19, 20, 12

No queremos enviar el código anterior; es una simple sustitución, que no es nada segura. Queremos combinar esto con nuestra llave de alguna manera. Una forma común es la suma módulo 26. Sumamos el valor del mensaje al valor de la clave, mod 26, hasta llegar al final del mensaje. Por lo tanto, enviaríamos

8+4 (mod 26) = 12, 11+3 (mod 26) = 14, 14+6 (mod 26) = 20, 21+17 (mod 26) = 12.

= 12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

Ten en cuenta que si alguien intercepta esto y NO tiene la clave, ¡desencriptarlo es totalmente imposible! Ni siquiera las dos "u" de "quantum" están codificadas con el mismo número El primero es un 3, y el segundo un 16... ¡en la misma palabra!

Así que te envío esto, y tienes la misma llave que yo. Deshaces la suma módulo 26 que sabes que he realizado:

12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

=( 4+x1 ) (mod 26), ( 3+x2 ) (mod 26), ( 6+x3 ) (mod 26), ( 17+x4 ) (mod 26),.

Tal que el mensaje x1, x2, x3, x4… debe ser

8, 11, 14, 21.

Finalmente, convirtiendo esto a texto, tenemos

"Me encanta la cuántica".

Se trata de una almohadilla de un solo uso.

Tenga en cuenta que si la clave es más corta que el mensaje, empezamos a repetir nuestra codificación. Seguiría siendo un problema de descifrado difícil de resolver, pero no imposible si se repite suficientes veces. Por tanto, necesitas una tecla larga (o "almohadilla").

Esperemos que la actividad anterior deje claro que una almohadilla de un solo uso es una forma irrompible de cifrado, dadas algunas suposiciones, como:

• La clave tiene la misma longitud que el mensaje que se envía, o más
• La clave es realmente aleatoria
• La clave sólo se utiliza una vez y luego se descarta

Así que esto es genial. Tenemos encriptación irrompible... a menos que alguien consiga nuestra llave. Si alguien consigue nuestra clave, todo se descifra. Esta diferencia entre un cifrado indescifrable y que todos nuestros secretos queden al descubierto hace que compartir una clave segura sea extremadamente importante. El objetivo de la distribución cuántica de claves es aprovechar las restricciones que la naturaleza ha impuesto a la información cuántica para asegurar una clave compartida/una almohadilla de un solo uso.

Usando estados cuánticos como clave

Supongamos que trabajamos con qubits (haciendo hincapié en que los qubits tienen dos estados propios). Se podrían utilizar sistemas cuánticos con mayor número de estados cuánticos, pero los ordenadores cuánticos de última generación de IBM® utilizan qubits. No es ningún problema codificar nuestro A, B, C, en secuencias de 0’s y 1’s. Así pues, nos basta con compartir una clave de 0’s y 1’s y hacer la suma módulo 2 en cada bit que almacena una letra.

Comprueba tu comprensión

Si realmente sólo nos importan las letras inglesas, ¿cuántos bits necesitamos?

• Respuesta
  $$2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}$$

A nuestros amigos Alice y Bob les gustaría compartir una clave cuántica de forma que nadie más pueda interceptarla (al menos no sin que ellos lo sepan). Necesitan tener una forma de enviarse estados cuánticos entre sí. Hacer esto con alta fidelidad y sin ruidos/errores NO es trivial. Pero hay dos enfoques que deberíamos ser capaces de entender en este punto:

1. Un cable de fibra óptica permite enviar luz... que es muy mecánica cuántica. Los fotones individuales pueden detectarse con gran fidelidad a lo largo de muchos kilómetros de cable de fibra óptica. No se trata de un canal cuántico perfecto y sin errores, pero podría ser muy bueno.
2. Podríamos utilizar el teletransporte cuántico, como se describe en un módulo anterior. Es decir, Alice y Bob podrían compartir qubits entrelazados y se podría enviar un estado de Alice a Bob utilizando el protocolo de teletransporte.

Para este módulo, no queremos requerir que tengas configuraciones ópticas de alta fidelidad para compartir fotones, así que usaremos el segundo método para compartir estados cuánticos. Pero esto no quiere decir que sea el más realista para compartir claves cuánticas a larga distancia.

Ahora exploraremos un protocolo establecido por primera vez por Charles Bennett y Gilles Brassard en 1984 para compartir estados medidos en diferentes bases de Alice a Bob. Utilizaremos un régimen de medición inteligente para construir una clave que utilizaremos en el cifrado posterior. En otras palabras, estamos distribuyendo una clave cuántica entre dos partes que desean comunicarse, de ahí lo de "distribución de clave cuántica" (QKD).

Paso 1 de QKD: bits aleatorios y bases aleatorias de Alice

Alice empezará generando una secuencia aleatoria de 0 y 1. A continuación, seleccionará aleatoriamente una base en la que preparar un estado cuántico, basándose en cada bit aleatorio, utilizando la siguiente tabla (una tabla que también tiene Bob):

Por ejemplo, supongamos que Alicia genera aleatoriamente un 0 y selecciona al azar la base X. Entonces prepararía un estado cuántico $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Ciertamente, se puede aprovechar la aleatoriedad cuántica para generar un conjunto aleatorio de 0 y 1, y una elección de base aleatoria. Por ahora, vamos a suponer simplemente que se ha generado un conjunto aleatorio, como se indica a continuación:

Este conjunto de bits aleatorios, bases y estados resultantes continuaría en una larga secuencia, para dar una clave de longitud suficiente.

Paso 2 de QKD: bases aleatorias de Bob

Bob también elige las bases al azar. Sin embargo, mientras que Alice estaba utilizando la elección de bases para preparar su estado, Bob realmente hará mediciones en estas bases. Si Bob hace una medición en la misma base en la que Alice preparó el estado, entonces podemos predecir el resultado de la medición de Bob. Si Bob elige una base distinta de la que utilizó Alice para prepararse, no podemos conocer el resultado de la medición de Bob.

En la tabla siguiente, considere la primera columna. Alice ha preparado el estado $\vert +\rangle,$ que es un estado propio de X. Como Bob también ha elegido aleatoriamente medir en la base X, sólo hay un resultado posible para el estado medido de Bob: $\vert +\rangle.$ En la segunda columna, sin embargo, han elegido bases diferentes. El estado que Alice envió es $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$. Este tiene un 50% de posibilidades de ser medido por Bob en el estado $\vert 0\rangle$, y un 50% de posibilidades de ser medido en $\vert 1\rangle.$. Así que la fila que muestra lo que sabemos, a priori, sobre las mediciones de Bob no puede ser rellenada para la columna 2. Pero Bob hará una medición y obtendrá un estado propio de (en esa columna) Z. En la fila inferior, rellenamos lo que arrojaron estas mediciones.

QKD paso 3: Debate público sobre las bases

Alice y Bob pueden ahora compartir entre ellos qué base eligieron en cada caso. Para todas las columnas en las que casualmente eligieron la misma base, cada uno sabe con certeza qué estado tenía el otro. Bob puede convertir el estado y la base en un 0 o 1 según la convención compartida por ambas partes. Podemos reescribir la tabla anterior para mostrar sólo los casos en los que las bases de Alice y Bob coinciden:

Alice ha transmitido con éxito la cadena de bits 00100... a Bob. Si los amigos acordaron de antemano utilizar cadenas de 5 bits como números en su almohadilla de un solo uso, estos cinco primeros bits les darían el número $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

Paso 4 de QKD: Verificar y enviar el secreto

Antes de seguir adelante, Alice y Bob deben elegir un subconjunto de sus bits clásicos para compararlos. Dado que sólo han conservado las mediciones de los qubits que se prepararon y midieron utilizando la misma base, todos los valores medidos deberían coincidir. Si hubiera un porcentaje muy pequeño que no coincidiera, podría atribuirse a ruido cuántico o a errores. Pero si muchos no están de acuerdo, ¡algo ha ido mal!

Aquí no abordaremos qué fracción de la clave debe utilizarse para la verificación. Por ahora, supondremos que esta comprobación va bien; volveremos sobre ello en la sección siguiente sobre escuchas.

A continuación, los amigos se enviarían un mensaje cifrado utilizando los canales clásicos. A continuación, utilizarían los números de su almohadilla de un solo uso para cifrar/descifrar mensajes secretos, sin transmitir nunca la almohadilla de un solo uso de un lugar a otro. Para la siguiente sección sobre escuchas, ten en cuenta que todo este intercambio de claves se produce antes de la revelación del secreto cifrado a través de los canales clásicos.

Alice y Bob comunicaron su base de elección a través de canales clásicos, así que ¿no podría ser interceptado? ¡Sí! Pero conocer la base que utilizaron para la medición no te dice qué bit enviaron u obtuvieron. Eso sólo es posible si también conoces los bits iniciales de Alice. Pero entonces estarías en el ordenador de Alice, donde se almacenan los secretos, y la comunicación secreta de los secretos se vuelve discutible. Por tanto, la interceptación de la comunicación clásica no rompe el cifrado. Pero, ¿qué pasa con la interceptación de información en el canal cuántico?

Resistencia del QKD al espionaje

Alice y Bob tienen una amiga, Eve, que es famosa por escuchar a escondidas. Eve desea interceptar la clave cuántica de Alice y Bob, de modo que pueda utilizarla para descifrar los mensajes enviados entre ambos. Esto ocurriría necesariamente entre la preparación de los estados por parte de Alice y la medición de los estados por parte de Bob, ya que la medición colapsa el estado cuántico. En concreto, esto significa que las escuchas tendrían que producirse antes de que se hayan compartido o comparado las bases.

Eve debe adivinar qué base se utilizó para codificar cada bit. Una vez más, si no puede acceder al ordenador de Alice, no tiene nada en lo que basar esta suposición, y será aleatoria. Supongamos que el inicio de Alice es el mismo que antes, y supongamos además que la elección aleatoria de la base de medida de Bob es la misma que antes. Completemos lo que obtiene Eva si realiza mediciones del canal cuántico. Como antes, si Eva elige la misma base que Alicia, sabemos lo que obtendrá. Si no, podría obtener cualquiera de los dos resultados, cada uno con una probabilidad del 50%.

Ahora, como Eve no tiene ni idea de si ha coincidido con la base de Alice o no, no sabe qué transmitir a Bob para que coincida con los estados originales de Alice. Cuando Eva mide, por ejemplo, $|0\rangle,$ todo lo que sabe con certeza es que Alicia no preparó el estado $|1\rangle$ para ese qubit. Pero Alice podría haber preparado $|0\rangle,$ $|+\rangle,$ o $|-\rangle.$ Todo podría ser consistente con la medida de Eve. Así que Eva debe tomar una decisión. Podría enviar exactamente el estado que midió, o podría intentar adivinar los casos en los que su medición no era el estado propio enviado por Alice. Incluiremos una mezcla en nuestra mesa:

Llegados a este punto, es razonable preguntarse: "¿Por qué Eva no hace simplemente una copia del estado cuántico de Alicia, guarda una para medirla y transmite la otra a Bob?" La respuesta es el teorema de la "no clonación". Informalmente, dice que no existe ninguna operación unitaria (mecánica cuántica) que pueda hacer una segunda copia de un estado cuántico arbitrario, conservando la primera copia. La prueba es relativamente sencilla y se deja como ejercicio guiado. Pero por ahora, entienda que Eve haciendo copias del estado cuántico está prohibido por las leyes fundamentales de la naturaleza, y este es un punto fuerte del principio de QKD.

Como antes, Alice y Bob se llamarían y compararían las bases. Reducirán esta tabla a los casos en que los dos amigos hayan seleccionado las mismas bases:

Alice y Bob han vuelto a comunicar una cadena de bits... pero las cadenas no coinciden. Los bits del extremo izquierdo y del medio están invertidos. Mirando la tabla anterior, se puede rastrear este desajuste a la interferencia de Eva. Cabe destacar que podemos realizar estadísticas sobre la coincidencia entre nuestras cadenas de bits ahora, mientras configuramos la clave, mucho antes de compartir nuestro secreto cifrado. Alice y Bob son libres de utilizar tantos bits de su almohadilla de un solo uso como deseen para comprobar la seguridad de su canal. Si un solo bit o un porcentaje muy pequeño de bits no coinciden, puede deberse a ruido o a errores. Pero una fracción sustancial de desajustes indica escuchas. El significado de "sustancial" aquí depende un poco del ruido en la configuración que se utilice; lo que significa para los ordenadores cuánticos IBM® se discute más adelante, cuando implementemos este protocolo. Si se detecta un exceso de errores, Alice y Bob no comparten el secreto y pueden empezar a cazar al fisgón.

Advertencias

Demostrar la seguridad es extremadamente difícil. De hecho, el protocolo aquí descrito se propuso en 1984 y no se demostró su seguridad hasta 16 años después (Shor & Preskill, 2000 ). Hay muchas sutilezas que quedan fuera del alcance de esta introducción. Pero enumeraremos brevemente algunas para demostrar que el tema es más complejo de lo que aquí se ilustra.

• Canales seguros: Cuando Alice envía sus qubits a través de una configuración cuántica (un canal) y, en particular, cuando recibe respuestas clásicas de alguien, hemos asumido que ese alguien es Bob. Si Eve se infiltró en esta configuración de tal manera que toda la comunicación de Alice se realizaba en realidad con Eve, y toda la comunicación de Bob se realizaba en realidad con Eve, entonces Eve ha obtenido efectivamente una clave, y puede aprender secretos. Primero hay que garantizar "canales seguros", un proceso con un conjunto diferente de protocolos que no hemos abordado aquí.
• Suposiciones sobre Eve: Para probar realmente la seguridad, no podemos hacer suposiciones sobre el comportamiento de Eva; siempre podría confundir nuestras expectativas. Aquí, por poner ejemplos concretos, estamos haciendo suposiciones. Por ejemplo, podríamos suponer que los estados que Eva envía a Bob son siempre exactamente los que obtuvo en la medición. O podríamos suponer que elige al azar un estado experimentalmente coherente con su medición. Más fundamentalmente, el lenguaje aquí asume que Eva realmente hace una medición, en lugar de almacenar el estado en otro sistema cuántico y enviar un qubit aleatorio a Bob. Estas suposiciones están bien para entender el protocolo, pero significan que no estamos demostrando nada con total generalidad.
• Amplificación de la privacidad: Alice y Bob no están obligados a utilizar la clave cuántica exactamente como se transmite. Pueden, por ejemplo, aplicar una función hash a la clave compartida. Esto aprovecharía el hecho de que el fisgón tiene un conocimiento incompleto de la clave para producir una clave compartida más corta, pero segura.

Experimento 1: QKD sin espías

Implementemos el protocolo anterior en ausencia de un espía. Primero lo haremos utilizando un simulador, simplemente para entender el flujo de trabajo.

En primer lugar, una nota sobre los simuladores cuánticos: La mayoría de los problemas cuánticos que implican más de ~30 qubits no pueden ser simulados por la mayoría de los ordenadores. Ningún ordenador clásico, superordenador o GPU puede simular toda la gama de comportamientos de un ordenador cuántico de 127 qubits. Normalmente, la motivación para utilizar ordenadores cuánticos reales es que los numerosos qubits entrelazados no pueden simularse. En este caso, no hay entrelazamiento de qubits, a menos que utilicemos el esquema de teletransporte para mover la información. En este caso, la motivación para utilizar ordenadores cuánticos reales es diferente: se trata del teorema de no clonación. Un ordenador clásico que simule un qubit podría enviar información sobre un estado cuántico de Alice a Bob, pero si esta información clásica fuera interceptada, podría duplicarse fácilmente, y Eve podría quedarse con una copia perfecta, mientras envía otra a Bob. Esto no es posible con los estados cuánticos reales.

IBM Quantum recomienda abordar los problemas de computación cuántica utilizando un marco que denominamos "patrones Qiskit". Consta de los siguientes pasos.

• Paso 1: Representar el problema en un circuito cuántico
• Paso 2: Optimiza tu circuito para que funcione en hardware cuántico real
• Paso 3: Ejecute su trabajo en los ordenadores cuánticos de IBM utilizando las primitivas Runtime
• Paso 4: Postprocesamiento de los resultados

Patrones Qiskit, paso 1: asigna tu problema a un circuito cuántico

En este caso, el mapeo de nuestro problema a circuitos cuánticos se reduce a simplemente preparar los estados de Alice, y luego incluir las mediciones de Bob. Comenzamos con la selección de bits aleatorios y bases aleatorias.

# Qiskit patterns step 1: Map your problem to quantum circuit
# Import some generic packages

import numpy as np
from qiskit import QuantumCircuit

# Set up a random number generator and a quantum circuit. We choose to start with 20 bits, though
# any number <30 should be fine.

rng = np.random.default_rng()
bit_num = 20
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Random bits and bases for Alice
# generate Alice's random bits

abits = np.round(rng.random(bit_num))

# generate Alice's random measurement bases. Here we will associate a "0" with the Z basis, and a
# "1" with the X basis.

abase = np.round(rng.random(bit_num))

# Alice's state preparation. Check that this creates states according to table 1

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob
# generate Bob's random measurement bases.

bbase = np.round(rng.random(bit_num))

# Note that if Bob measures in Z no gates are necessary, since IBM Quantum computers
# measure in Z by default.
# If Bob measures in the X basis, we implement a hadamard gate qc.h to facilitate the measurement.

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

Visualicemos los bits, las bases y el circuito. Tenga en cuenta que a veces las bases coinciden y a veces no.

print("Alice's bits are ", abits)
print("Alice's bases are ", abase)
print("Bob's bases are ", bbase)
qc.draw("mpl")

Output:

Alice's bits are  [1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0.]
Alice's bases are  [0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0.]
Bob's bases are  [0. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0.]

Patrones Qiskit, paso 2: Optimizar 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 un ordenador cuántico específico. También mapea nuestro problema en el diseño del ordenador cuántico.

Empezaremos cargando varios paquetes necesarios para comunicarnos con los ordenadores cuánticos de IBM. También debemos seleccionar un backend en el que ejecutarlo. Podemos elegir el backend menos ocupado o seleccionar un backend específico cuyas propiedades conozcamos. Aunque momentáneamente utilizaremos un simulador, es importante utilizar un modelo de ruido razonable en la simulación, y es bueno mantener el flujo de trabajo lo más parecido posible al que utilizaremos más adelante para los ordenadores cuánticos reales.

A continuación encontrará un código para guardar sus credenciales la primera vez que las utilice. Asegúrate de borrar esta información del cuaderno después de guardarlo en tu entorno, para que tus credenciales no se compartan accidentalmente cuando compartas el cuaderno. Consulte Configurar su cuenta IBM Cloud e Inicializar el servicio en un entorno no fiable para obtener 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)

Output:

ibm_brisbane

A continuación seleccionamos un simulador y un modelo de ruido.

# 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

# Load the qiskit runtime sampler
from qiskit_ibm_runtime import SamplerV2 as Sampler


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)

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

Patrones Qiskit, paso 3: Ejecutar

Utilice el muestreador para ejecutar su trabajo, con el circuito como argumento.

# This required 5 s to run on a Heron r2 processor on 10-28-24
sampler = Sampler(mode=backend)
job = sampler.run([qc_isa], shots=1)
# job = sampler_sim.run([qc], shots = 1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Patrones Qiskit, paso 4: Posprocesamiento

Aquí interpretamos nuestros resultados y extraemos información útil. Podríamos intentar visualizar la salida de nuestro muestreador, pero hemos utilizado el muestreador de una forma poco convencional. En lugar de hacer muchas mediciones de nuestro circuito y elaborar estadísticas sobre los estados, hemos hecho una sola medición (la de Bob). Cualquier qubit con un estado que se haya preparado y medido en la misma base debería tener un resultado determinista, de forma que sólo sea necesaria una medición. Esos qubits con estados preparados y medidos en bases diferentes (que tendrían resultados probabilísticos y requerirían muchas mediciones para interpretarlos) no se utilizarán para construir nuestro pad/clave de un solo uso.

Extraigamos de esta cadena de bits una lista de resultados de medición. Ten cuidado de invertir el orden si lo comparas con la matriz de bits de Alice que utilizamos para generar el circuito.

# Get an array of bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))

# Reverse the order to match our input. See "little endian" notation.

bbits = bmeas_ints[::-1]

print(bbits)

Output:

[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0]

Comparemos las bases de medida elegidas al azar por Alice y Bob. Este fue el paso 3 de nuestro protocolo QKD (discusión pública de las bases). Cada vez que eligen la misma base para un qubit, añadimos los bits asociados a ese qubit a una lista de bits para generar números en un one-time pad. Cuando las bases no coinciden, los resultados se descartan. Comprobemos también si las dos listas de bits coinciden o si ha habido pérdidas debidas al ruido u otros factores.

# QKD step 3: Public discussion of bases

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    # Check whether bases matched.
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        # If bits match when bases matched, increase count of matching bits
        if int(abits[n]) == bbits[n]:
            match_count += 1

print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 0, 1, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 1, 0]
fidelity =  1.0
loss =  0.0

Alice y Bob tienen cada uno una lista de bits, y coinciden con un 100% de fidelidad. Pueden utilizarlos para generar números en un pad de un solo uso. A continuación, pueden utilizarlo en el paso 4 de QKD: enviar y descifrar un secreto. El conjunto actual de bits es demasiado corto para descifrar casi nada. Volveremos sobre ello después de incluir las escuchas.

Comprueba tu comprensión

Supongamos que necesita dígitos lo suficientemente grandes como para facilitar el desplazamiento de las letras del alfabeto inglés en toda su longitud, o más, aunque sin duda existen otros esquemas de codificación. (a) ¿Cuántas letras podría tener un mensaje para que se pudiera descifrar utilizando los bits de la clave anterior? (b) ¿Debe coincidir tu respuesta con la de tus compañeros? ¿Por qué sí o por qué no?

• Respuesta

  (a) La respuesta depende del número de bases elegidas al azar que coincidan entre Alice y Bob. Dado que hay aproximadamente un 50 % de probabilidades de que las bases coincidan para cualquier qubit dado, esperamos que cerca de 10 de nuestros bits sean útiles. El 9 o el 11 serán muy habituales. Ni siquiera un 4 o un 15 están fuera de lo posible. Se necesitan 5 bits para desplazar una cantidad igual o superior a la longitud del alfabeto inglés, lo que significa que se puede aplicar el desplazamiento a una letra por cada 5 bits disponibles. Si dispones de al menos 5 bits compartidos por Alice y Bob, puedes codificar una sola letra. Si tienes al menos 10, puedes codificar 2 letras, y así sucesivamente.

  b) No tiene por qué estar de acuerdo, por las razones expuestas en el apartado a).

Experimento 2: QKD con un intruso

Aplicaremos exactamente el mismo protocolo que antes. Esta vez, insertaremos otro conjunto de mediciones, realizadas por Eve, entre Alice y Bob.

from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Qiskit patterns step 1: Mapping your problem to a quantum circuit
# QKD step 1: Random bits and bases for Alice

bit_num = 20
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Alice's random bits and bases, as before

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation, as before

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

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

# Qiskit patterns step 3: Execute
job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

El paso 4 de los patrones Qiskit (posprocesamiento) es sencillo en este caso. No es necesario visualizar la distribución de las mediciones, ya que sólo realizamos una medición. Eve tiene los siguientes bits:

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

print(ebits)

Output:

[0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]

Ahora Eve debe reconstruir los estados para enviárselos a Bob. Como se describe en la introducción, no tiene forma de saber si adivinó correctamente las bases de codificación, por lo que no puede preparar exactamente los mismos estados que se enviaron. Podría suponer que cada elección de base era correcta y codificar exactamente lo que midió, o podría suponer que eligió la base incorrectamente y elegir cualquier estado propio de la base opuesta. Aquí supondremos lo primero, por simplicidad. Para ello, construimos un circuito cuántico completamente nuevo, repitiendo los pasos de los patrones Qiskit como antes.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit patterns step 1: Mapping your problem onto a quantum circuit
# QKD step 1: Eve uses her measurements to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)


# Qiskit patterns step 3: Execute

job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

print(bbits)

Output:

[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]

Comparemos ahora los bits de Alice y Bob:

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1
print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 1]
fidelity =  0.8571428571428571
loss =  0.1428571428571429

Anteriormente, había una coincidencia perfecta entre los bits de las claves de Alice y Bob. Ahora, a partir de la interferencia de Eve, vemos que los bits de Alice y Bob son diferentes en el 14% de los casos que deberían coincidir debido a que Alice y Bob seleccionaron las mismas bases. Esto debería ser fácil de detectar para Alice y Bob. Sin embargo, confiar en un porcentaje de errores como éste significa que hay un límite en cuanto a la cantidad de ruido que podemos tolerar en el canal cuántico.

Experimento 3: Comparar QKD con y sin espionaje en un ordenador cuántico real

Corramos esto en un ordenador cuántico real. Así podemos aprovechar el teorema de no clonación. Al mismo tiempo, los ordenadores cuánticos reales tienen ruido y presentan mayores tasas de error que los ordenadores clásicos. Así que comparemos la pérdida de fidelidad de nuestros bits clave con y sin escucha, para asegurarnos de que la diferencia es detectable al utilizar un ordenador cuántico real. Empezaremos en ausencia de escuchas:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 3 sec to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)


# Qiskit patterns step 2: Transpilation

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Load the Runtime primitive and session
sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's measurement bases and collect usable bits

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
Bob's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
fidelity =  0.9682539682539683
loss =  0.031746031746031744

Sin escuchas, obtuvimos una fidelidad del 100% sobre este conjunto de 127 bits de prueba, lo que dio como resultado 55 bases coincidentes y bits de clave utilizables. Ahora repitamos este experimento con Eve escuchando:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 2 s to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)


# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Eve's bits

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

# print(ebits)

# Restart process
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

# QKD step 1: Eve uses her measurements above to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)


# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit Patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's bases, when they are the same, keep the bits.

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1]
Bob's bits =  [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
fidelity =  0.7619047619047619
loss =  0.23809523809523814

Aquí encontramos casi un 23% de pérdida de fidelidad en los bits compartidos debido a las escuchas ¡Esto es muy detectable! Hay que tener en cuenta que la transferencia de información cuántica a grandes distancias podría introducir ruido y errores adicionales. Garantizar que las escuchas puedan detectarse, incluso en presencia de ruido, y aunque Eva utilice todos los trucos a su disposición es un campo complejo que va más allá de esta introducción.

Preguntas

Los profesores pueden solicitar versiones de estos cuadernos con claves de respuestas y orientaciones sobre su colocación en planes de estudios comunes rellenando esta rápida encuesta sobre cómo se están utilizando los cuadernos.

Conceptos fundamentales

• La información cuántica no puede copiarse ni "clonarse".
• Se puede repetir el mismo proceso de preparación para crear un conjunto de estados cuánticos que sean todos iguales, o casi iguales.
• Dos amigos pueden compartir una clave de cifrado/descifrado (una almohadilla de un solo uso) utilizando estados cuánticos.
• Que dos amigos elijan al azar una base de medida significa que la mitad de las veces elegirán de forma diferente, y tendrán que desechar la información de esos qubits.
• La elección aleatoria de la base de medición también garantiza que un fisgón no pueda conocer el estado inicial preparado y, por tanto, no pueda recrear el estado enviado. Esto garantiza que se detecten las escuchas.

Preguntas de verdadero o falso

1. T/F En la distribución cuántica de claves, los dos interlocutores que se comunican miden cada qubit en la misma base.
2. T/F Las leyes de la naturaleza impiden que un fisgón que intercepta información cuántica en QKD copie el estado cuántico que intercepta.
3. T/F Un one-time pad es una clave para cifrar/descifrar mensajes seguros en la que un esquema de codificación particular se utiliza una sola vez, para una sola pieza de información (como una letra del alfabeto).

Preguntas del maestro de ceremonias

1. Seleccione la opción que mejor complete el enunciado. Como se describe en este módulo, una almohadilla de un solo uso es un conjunto de claves de cifrado/descifrado que se utiliza...

• a. Sólo una vez para un único dato, como una sola letra.
• b. Sólo una vez para un único mensaje.
• c. Sólo una vez durante un periodo de tiempo determinado, como un día.
• d. Hasta que haya pruebas de escuchas.

2. Supongamos que Alice y Bob eligen sus bases de medida al azar. Miden. A continuación, comparten sus bases de medición y sólo conservan los fragmentos de información de los casos en los que utilizaron la misma base. Hasta cierta fluctuación aleatoria, ¿aproximadamente qué porcentaje de sus qubits deberían producir bits de información utilizables?

• a. 100 %
• b. 50 %
• c. 25 %
• d. 12.5%
• decir, 0 %

3. Después de que Alice y Bob seleccionen los casos en los que utilizaron las mismas bases de medida, ¿qué porcentaje de esos bits de información deberían coincidir, si el ruido y los errores cuánticos fueran despreciables?

• a. 100 %
• b. 50 %
• c. 25 %
• d. 12.5%
• decir, 0 %

4. Supongamos que Alicia ha elegido sus bases de medida al azar. Eve también elige sus bases al azar, y escucha en (medidas). Ella envía estados a Bob que son consistentes con sus medidas. Alice y Bob comparan las bases elegidas y mantienen sólo los qubits medidos/preparados por ellos en las mismas bases. Hasta cierta fluctuación aleatoria, ¿aproximadamente qué porcentaje de esas medidas de qubits guardadas coincidirán, según Alice y Bob?

• a. 100 %
• b. 75%
• c. 50 %
• d. 25 %
• decir, 12.5%
• f. 0 %

Preguntas para el debate

1. Supongamos que todas las elecciones de base son aleatorias para todos los participantes, Alice, Bob y Eve. Supongamos que después de que Eva escuche, envía un estado a Bob que está preparado en la misma base en la que ella midió, y que es consistente con esa medición. Convence a tus socios de que 12.5 % de todos los qubits inicializados por Alice darán lugar a desajustes de medición entre Alice y Bob, lo que indica que hay escuchas (ignorando los errores cuánticos y el ruido). Pista 1: Puesto que no existe una base preferida, si se considera sólo una opción inicial para Alicia, la proporción para esa única opción debería ser la misma que la proporción para la suma de todas las opciones. Pista 2: Puede que no baste con contar el número de formas en que puede ocurrir algo, ya que algunos resultados pueden darse con distintas probabilidades.

2. Supongamos de nuevo que todas las elecciones de base son aleatorias para todos los participantes, Alice, Bob y Eve. Pero ahora, considere que Eva es libre de enviar a lo largo de cualquier estado que le gusta después de su medición. Incluso podría intentar enviar estados que no concuerden con sus propias medidas. Discute con tus compañeros/vecinos si crees que hay alguna elección de bases que pueda reducir el porcentaje medio de qubits que indican escuchas a Alice y Bob.