Distribuição de Chaves Quânticas (QKD)

Para este módulo do Qiskit in Classrooms, os alunos devem ter um ambiente de trabalho Python com os seguintes pacotes instalados:

• qiskit v2.1.0 ou mais recente
• qiskit-ibm-runtime v0.40.1 ou mais recente
• qiskit-aer v0.17.0 ou mais recente
• qiskit.visualization
• numpy
• pylatexenc

Para configurar e instalar os pacotes acima, consulte o guia Instalar o Qiskit. Para executar trabalhos em computadores quânticos reais, os alunos precisarão configurar uma conta no IBM Quantum® seguindo as etapas do guia Configurar sua conta IBM Cloud.

Esse módulo foi testado e usou 5 segundos de tempo de QPU. Essa é apenas uma estimativa. Seu uso real pode 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'

Assista ao passo a passo do módulo pela Dra. Katie McCormick abaixo, ou clique aqui para assisti-lo em YouTube.

Introdução e motivação

Há um número infinito de maneiras de criptografar e descriptografar informações e, literalmente, milhares de maneiras foram bem estudadas. Aqui, vamos nos restringir a um método muito antigo e muito simples de criptografia, chamado de "substituição simples", para nos concentrarmos na parte quântica desse protocolo. A parte quântica pode ser adaptada a muitos outros protocolos com relativamente poucas alterações.

Substituição simples

Uma criptografia de substituição simples é aquela em que uma letra ou um número é substituído por outro, de modo que haja um mapeamento 1:1 das letras e dos números em uma mensagem para as letras e os números que estão sendo usados em uma sequência criptografada. Um exemplo da cultura pop é o quebra-cabeça criptoquote ou criptograma, no qual uma citação ou frase é criptografada usando uma substituição simples, e o jogador é encarregado de descriptografá-la. Esses problemas são fáceis de resolver se forem longos o suficiente. Considere o exemplo:

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.

As pessoas que resolvem esses problemas manualmente usam principalmente truques que envolvem familiaridade com a estrutura da linguagem da mensagem original. Por exemplo, em inglês, as únicas palavras de uma letra como o "R" criptografado são "a" e "I". As letras duplas criptografadas em, por exemplo, "KIVGGB" só podem assumir determinados valores. Há coisas mais sutis que dão pistas, como a palavra mais comum que se encaixa no padrão "GSZG": "that". As pessoas que usam código para resolver esse problema têm muito mais opções, incluindo a simples varredura das possibilidades até que uma palavra em inglês seja recuperada e a atualização preservando essa palavra. Um método simples, mas eficaz, é usar a frequência das letras, especialmente quando a mensagem é longa o suficiente para constituir uma amostra representativa do inglês.

Pergunta de check-in

Tente decifrar isso, se quiser, embora não seja necessário para o restante do módulo. Clique em “Responder” abaixo para ver a mensagem.

• Resposta

  Decidi que seria melhor fazer isso bem longo. Dessa forma, as pessoas terão mais facilidade para resolver o problema. Espero ter simplificado o suficiente.

O exemplo acima está associado a uma "chave", um mapeamento das letras criptografadas para as descriptografadas. Nesse caso, a chave é:

• A (não utilizado, vamos chamá-lo de Z)
• B->Y
• C (não utilizado, vamos chamá-lo de X)
• D->W
• E->V
• F->U
• ...

E assim por diante. Para dizer o mínimo, essa não é uma boa chave. As chaves nas quais as letras criptografadas e descriptografadas são simplesmente versões deslocadas do alfabeto (como A->B e B->C) são chamadas de cifras "Caesar shift".

Observe que esses itens são muito difíceis se forem curtos. De fato, se forem muito curtos, são indeterminados. Considere:

URYYP

Há muitas descriptografias possíveis, usando chaves diferentes: HELLO, PETTY, HAPPY, JIGGY, STOOL. Você consegue pensar em outros?

Mas se você enviar muitas mensagens como essa, eventualmente a criptografia será quebrada. Portanto, você não deve usar a mesma "chave" com muita frequência. Na verdade, o melhor é usar uma determinada substituição apenas uma vez. Não em apenas uma mensagem, mas apenas para um único caractere! Com isso, queremos dizer que você terá um esquema de criptografia ou uma chave para cada caractere usado na mensagem, em ordem. Se quiser enviar uma mensagem a um amigo usando essa mensagem, você e seu amigo precisarão de um bloco de papel (nos tempos antigos) no qual essa chave em constante mudança esteja escrita. Você usará isso apenas uma vez. Isso é chamado de "one-time pad".

O bloco de uso único

Vamos ver como isso funciona com um exemplo. Isso poderia ser feito inteiramente com letras, mas é comum converter de letras para números, por exemplo, atribuindo A=0, B=1, C=2…. Suponha que sejamos amigos envolvidos em atividades clandestinas e tenhamos compartilhado um bloco. Idealmente, compartilharíamos muitos pads, mas o de hoje é:

EDGRPOJNCUWQZVMK.

Ou, convertendo em números por posição no alfabeto:

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

Suponhamos que eu queira compartilhar com vocês a mensagem:

"Eu adoro quantum!"

Ou, de forma equivalente:

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

Não queremos enviar o código acima; essa é uma substituição simples, que não é nada segura. Queremos combinar isso com nossa chave de alguma forma. Uma forma comum é a adição módulo 26. Adicionamos o valor da mensagem ao valor da chave, mod 26, até chegarmos ao final da mensagem. Então, nós enviamos

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

Observe que, se alguém interceptar isso e NÃO tiver a chave, a descriptografia será totalmente impossível! Nem mesmo os dois "u "s em "quantum" são codificados com o mesmo número! O primeiro é um 3, e o segundo é um 16... na mesma palavra!

Então, eu envio isso para você, e você tem a mesma chave que eu. Você desfaz a adição do módulo 26, que você sabe que eu fiz:

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),.

De modo que a mensagem x1, x2, x3, x4… deve ser

8, 11, 14, 21.

Por fim, convertendo isso em texto, temos

"Eu amo a quântica".

Esse é um bloco único.

Observe que, se a chave for mais curta do que a mensagem, começaremos a repetir nossa codificação. Esse ainda seria um problema de descriptografia difícil de resolver, mas não impossível se for repetido várias vezes. Portanto, você precisa de uma tecla longa (ou "pad").

Esperamos que a atividade acima deixe claro que o one-time pad é uma forma inviolável de criptografia, considerando algumas suposições, como:

• A chave tem o mesmo comprimento da mensagem que está sendo enviada, ou mais
• A chave é realmente aleatória
• A chave é usada apenas uma vez e depois descartada

Portanto, isso é ótimo. Temos criptografia inquebrável... a menos que alguém pegue nossa chave. Se alguém obtiver nossa chave, tudo será descriptografado. Essa diferença entre a criptografia inviolável e a exposição de todos os nossos segredos torna o compartilhamento de uma chave segura extremamente importante. O objetivo da distribuição de chaves quânticas é aproveitar as restrições que a natureza impôs às informações quânticas para proteger uma chave compartilhada/um bloco de tempo único.

Usando estados quânticos como chave

Vamos supor que estejamos trabalhando com qubits (enfatizando que os qubits têm dois estados próprios). É possível usar sistemas quânticos com um número maior de estados quânticos, mas os computadores quânticos de última geração em IBM® usam qubits. Não há problema em codificar nosso A, B, C em sequências de 0’s e 1’s. Portanto, basta que compartilhemos uma chave de 0’s e 1’s e façamos a adição do módulo 2 em cada bit que armazena uma letra.

Verifique sua compreensão

Se realmente nos importarmos apenas com as letras em inglês, de quantos bits precisamos?

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

Nossos amigos, Alice e Bob, gostariam de compartilhar uma chave quântica de forma que ninguém mais pudesse interceptá-la (pelo menos não sem que eles soubessem). Eles precisam ter uma maneira de enviar estados quânticos uns para os outros. Fazer isso com alta fidelidade e sem ruídos/erros NÃO é algo trivial. Mas há duas abordagens que devemos entender neste momento:

1. Um cabo de fibra óptica permite que você envie luz... o que é muito quântico-mecânico. Fótons únicos podem ser detectados com alta fidelidade ao longo de muitos quilômetros de cabo de fibra óptica. Esse não é um canal quântico perfeito e livre de erros, mas pode ser muito bom.
2. Poderíamos usar o teletransporte quântico, conforme descrito em um módulo anterior. Ou seja, Alice e Bob poderiam compartilhar qubits emaranhados e um estado poderia ser enviado de Alice para Bob usando o protocolo de teletransporte.

Para este módulo, não queremos exigir que você tenha configurações ópticas de alta fidelidade para compartilhar fótons, portanto, usaremos o segundo método para compartilhar estados quânticos. Mas isso não quer dizer que seja o mais realista para o compartilhamento de longa distância de chaves quânticas.

Agora, exploraremos um protocolo estabelecido pela primeira vez por Charles Bennett e Gilles Brassard em 1984 para compartilhar estados medidos em bases diferentes de Alice para Bob. Usaremos um regime de medição inteligente para criar uma chave para uso em criptografia posterior. Em outras palavras, estamos distribuindo uma chave quântica entre duas partes que desejam se comunicar, daí o termo "distribuição de chave quântica" (QKD).

Etapa 1 do QKD: bits aleatórios e bases aleatórias de Alice

Alice começará gerando uma sequência aleatória de 0s e 1s. Em seguida, ela selecionará aleatoriamente uma base para preparar um estado quântico, com base em cada bit aleatório, usando a tabela abaixo (uma tabela que Bob também tem):

Por exemplo, vamos supor que Alice tenha gerado aleatoriamente um 0 e selecionado aleatoriamente a base X. Em seguida, ela prepararia um estado quântico $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Certamente é possível aproveitar a aleatoriedade quântica para gerar um conjunto aleatório de 0s e 1s e uma escolha de base aleatória. Por enquanto, vamos simplesmente supor que um conjunto aleatório tenha sido gerado, como segue:

Esse conjunto de bits aleatórios, bases e estados resultantes continuaria em uma longa sequência para fornecer uma chave de tamanho suficiente.

QKD etapa 2: bases aleatórias de Bob

Bob também faz uma escolha aleatória de bases. No entanto, enquanto Alice estava usando a escolha da base para preparar seu estado, Bob realmente fará medições nessas bases. Se Bob fizer uma medição na mesma base em que Alice preparou o estado, poderemos prever o resultado da medição de Bob. Quando Bob escolhe uma base diferente da base que Alice usou na preparação, não podemos saber o resultado da medição de Bob.

Na tabela abaixo, considere a primeira coluna. Alice preparou o estado $\vert +\rangle,$, que é um estado próprio de X. Como Bob também escolheu aleatoriamente medir na base X, há apenas um resultado possível para o estado medido de Bob: $\vert +\rangle.$ Na segunda coluna, entretanto, eles escolheram bases diferentes. O estado que Alice enviou é $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$. Isso tem 50% de chance de ser medido por Bob no estado $\vert 0\rangle$ e 50% de chance de ser medido em $\vert 1\rangle.$. Portanto, a linha que mostra o que sabemos, a priori, sobre as medições de Bob não pode ser preenchida na coluna 2. Mas Bob fará uma medição e obterá um estado próprio de (nessa coluna) Z. Na linha inferior, preenchemos o que essas medições produziram.

Etapa 3 do QKD: Discussão pública das bases

Alice e Bob podem agora compartilhar entre si a base que escolheram em cada caso. Para todas as colunas em que eles escolheram a mesma base, cada um sabe com certeza qual estado o outro tinha. Bob pode converter o estado e a base em 0 ou 1, de acordo com a convenção compartilhada por ambas as partes. Podemos reescrever a tabela acima para mostrar apenas as instâncias em que as bases de Alice e Bob coincidiram:

Alice transmitiu com sucesso a cadeia de bits 00100... para Bob. Se os amigos concordassem antecipadamente em usar sequências de 5 bits como números em seu one-time pad, esses primeiros cinco bits dariam a eles o número $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

Etapa 4 do QKD: Verificar e enviar segredo

Antes de Alice e Bob prosseguirem, eles devem escolher um subconjunto de seus bits clássicos para comparar. Como eles mantiveram apenas medições de qubits que foram preparados e medidos usando a mesma base, todos os valores medidos devem estar de acordo. Se houvesse uma porcentagem muito pequena que não concordasse, isso poderia ser atribuído a erros ou ruído quântico. Mas se muitos não concordarem, algo deu errado!

Aqui não abordaremos qual fração da chave deve ser usada para verificação. Por enquanto, presumiremos que essa verificação foi bem-sucedida; revisaremos isso na seção abaixo sobre espionagem.

Os amigos então enviariam uma mensagem criptografada um para o outro usando canais clássicos. Em seguida, eles usariam os números em seu bloco de tempo único para criptografar/descriptografar mensagens secretas, sem nunca transmitir o bloco de tempo único de um local para outro. Para a próxima seção sobre espionagem, lembre-se de que todo esse compartilhamento da chave acontece antes da revelação do segredo criptografado por meio de canais clássicos.

Alice e Bob comunicaram sua base de escolha por meio de canais clássicos, então isso não poderia ser interceptado? Sim! Mas saber a base que eles usaram para a medição não diz a você qual bit eles enviaram ou obtiveram. Isso só é possível se você também souber os bits iniciais de Alice. Mas, nesse caso, você estaria no computador de Alice, onde os segredos estão armazenados, e a comunicação secreta dos segredos se torna discutível. Portanto, a interceptação da comunicação clássica não quebra a criptografia. Mas e quanto à interceptação de informações no canal quântico?

Resistência do QKD à interceptação

Alice e Bob têm uma amiga, Eve, que é conhecida por espionar. Eve deseja interceptar a chave quântica de Alice e Bob, para que possa usá-la para descriptografar as mensagens enviadas entre os dois. Isso necessariamente aconteceria entre a preparação dos estados por Alice e a medição dos estados por Bob, já que a medição colapsa o estado quântico. Em particular, isso significa que a escuta teria que ocorrer antes de haver qualquer compartilhamento ou comparação de bases.

Eve deve adivinhar qual base foi usada na codificação de cada bit. Novamente, se ela não puder acessar o computador de Alice, não terá nada em que se basear para fazer essa suposição, e ela será aleatória. Vamos supor que o início de Alice seja o mesmo de antes, e vamos supor também que a escolha aleatória da base de medição de Bob seja a mesma de antes. Vamos preencher o que Eve obtém se ela fizer medições do canal quântico. Como antes, se Eva escolher a mesma base que Alice, saberemos o que ela obterá. Caso contrário, ela poderia obter um dos dois resultados, cada um com 50% de probabilidade.

Agora, como Eve não tem ideia se ela correspondeu à base de Alice ou não, ela não sabe o que transmitir a Bob para corresponder aos estados originais de Alice. Quando Eve mede, por exemplo, $|0\rangle,$, tudo o que ela sabe com certeza é que Alice não preparou o estado $|1\rangle$ para esse qubit. Mas Alice poderia ter preparado $|0\rangle,$ $|+\rangle,$ ou $|-\rangle.$. Tudo poderia ser consistente com a medição de Eva. Portanto, Eva precisa fazer uma escolha. Ela pode enviar exatamente o estado que mediu ou pode tentar adivinhar as instâncias em que sua medição não foi o estado próprio enviado por Alice. Incluiremos uma mistura em nossa mesa:

Nesse ponto, é razoável perguntar: "Por que Eve não faz uma cópia do estado quântico de Alice, mantém uma para medir e transmite a outra para Bob?" A resposta é o teorema da "não clonagem". Informalmente, ela diz que não há nenhuma operação unitária (mecânica quântica) que possa fazer uma segunda cópia de um estado quântico arbitrário, preservando a primeira cópia. A prova é relativamente simples e é deixada como um exercício guiado. Mas, por enquanto, entenda que o fato de Eve fazer cópias do estado quântico é proibido pelas leis fundamentais da natureza, e esse é um dos principais pontos fortes da QKD.

Como antes, Alice e Bob ligariam um para o outro e comparariam as bases. Eles reduzirão essa tabela aos casos em que os dois amigos selecionaram as mesmas bases:

Alice e Bob comunicaram mais uma vez uma cadeia de bits... mas as cadeias de caracteres não coincidem. Os bits da extrema esquerda e do meio estão invertidos. Observando a tabela anterior, você pode rastrear essa incompatibilidade até a interferência de Eve. De forma crítica, observe que podemos fazer estatísticas sobre a correspondência entre nossas cadeias de bits agora, enquanto configuramos a chave, muito antes de compartilhar nosso segredo criptografado. Alice e Bob podem usar quantos bits de seus blocos de tempo único quiserem para verificar a segurança de seu canal. Se um único bit ou uma porcentagem muito pequena de bits não corresponder, isso pode ser atribuído a ruído ou erros. Mas uma fração substancial de incompatibilidades indica espionagem. O significado de "substancial" aqui depende um pouco do ruído na configuração que está sendo usada; o que isso significa para os computadores quânticos IBM® será discutido abaixo quando implementarmos esse protocolo. Se forem detectados erros em excesso, Alice e Bob não compartilham o segredo e podem começar a caçar o espião.

Ressalvas

É extremamente difícil comprovar a segurança. De fato, o protocolo descrito aqui foi proposto em 1984 e só foi comprovado como seguro 16 anos depois, em Shor & Preskill, 2000. Há muitas sutilezas que estão além do escopo desta introdução. Mas listaremos brevemente alguns deles para demonstrar que o tópico é mais complexo do que o ilustrado aqui.

• Canais seguros: Quando Alice envia seus qubits por meio de alguma configuração quântica (um canal) e, em particular, quando ela recebe respostas clássicas de alguém, presumimos que esse alguém seja realmente Bob. Se Eve se infiltrou nessa configuração de tal forma que toda a comunicação de Alice estava de fato acontecendo com Eve, e toda a comunicação de Bob estava de fato sendo feita com Eve, então Eve obteve efetivamente uma chave e pode aprender segredos. Primeiro, é preciso garantir "canais seguros", um processo com um conjunto diferente de protocolos que não abordamos aqui.
• Suposições sobre a Eve: Para realmente provar a segurança, não podemos fazer suposições sobre o comportamento de Eve; ela sempre pode confundir nossas expectativas. Aqui, para dar exemplos concretos, estamos fazendo suposições. Por exemplo, podemos presumir que os estados que Eve envia para Bob são sempre exatamente aqueles que ela obteve na medição. Ou podemos supor que ela escolha aleatoriamente um estado experimentalmente consistente com sua medição. Mais fundamentalmente, a linguagem aqui pressupõe que Eve realmente faz uma medição, em vez de armazenar o estado em outro sistema quântico e enviar um qubit aleatório para Bob. Essas suposições são boas para entender o protocolo, mas significam que não estamos provando nada em toda a sua generalidade.
• Amplificação da privacidade: Alice e Bob não são obrigados a usar a chave quântica exatamente como foi transmitida. Eles podem, por exemplo, aplicar uma função de hash à chave compartilhada. Isso exploraria o fato de que o espião tem conhecimento incompleto da chave para produzir uma chave compartilhada mais curta, mas segura.

Experimento 1: QKD sem bisbilhoteiros

Vamos implementar o protocolo acima na ausência de um espião. Faremos isso primeiro usando um simulador, simplesmente para entender o fluxo de trabalho.

Primeiro, uma observação sobre simuladores quânticos: A maioria dos problemas quânticos que envolvem mais de ~30 qubits não pode ser simulada pela maioria dos computadores. Nenhum computador clássico, supercomputador ou GPU pode simular toda a gama de comportamento de um computador quântico de 127 qubits. Normalmente, a motivação para usar computadores quânticos reais é que os muitos qubits emaranhados não podem ser simulados. Nesse caso, não há emaranhamento de qubits, a menos que usemos o esquema de teletransporte para mover informações. Nesse caso, a motivação para usar computadores quânticos reais é diferente: é o teorema da não clonagem. Um computador clássico que simula um qubit poderia enviar informações sobre um estado quântico de Alice para Bob, mas se essas informações clássicas fossem interceptadas, elas poderiam ser facilmente duplicadas, e Eva poderia manter uma cópia perfeita e enviar outra para Bob. Isso não é possível com estados quânticos reais.

IBM A Quantum recomenda a abordagem de problemas de computação quântica usando uma estrutura que chamamos de "padrões Qiskit". Ele consiste nas seguintes etapas.

• Etapa 1: Mapeie seu problema em um circuito quântico
• Etapa 2: otimize seu circuito para execução em hardware quântico real
• Etapa 3: Execute seu trabalho em computadores quânticos IBM usando primitivas de tempo de execução
• Etapa 4: Pós-processar os resultados

Padrões Qiskit etapa 1: Mapeie seu problema para um circuito quântico

Nesse caso, o mapeamento do nosso problema para circuitos quânticos se reduz à simples preparação dos estados de Alice e, em seguida, à inclusão das medições de Bob. Começamos com o bit aleatório e a seleção de base aleatória.

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

Vamos visualizar os bits, as bases e o circuito. Observe que, às vezes, as bases coincidem e, às vezes, não.

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.]

Padrões Qiskit etapa 2: Otimizar o problema para execução quântica

Essa etapa pega as operações que queremos realizar e as expressa em termos da funcionalidade de um computador quântico específico. Ele também mapeia nosso problema no layout do computador quântico.

Começaremos carregando vários pacotes que são necessários para a comunicação com os computadores quânticos do IBM. Também devemos selecionar um backend para execução. Podemos escolher o backend menos ocupado ou selecionar um backend específico cujas propriedades conhecemos. Embora, momentaneamente, usaremos um simulador, é importante usar um modelo de ruído razoável na simulação, e é bom manter o fluxo de trabalho o mais próximo possível do que usaremos posteriormente para computadores quânticos reais.

Há um código abaixo para salvar suas credenciais na primeira utilização. Certifique-se de excluir essas informações do notebook depois de salvá-lo em seu ambiente, para que suas credenciais não sejam compartilhadas acidentalmente quando você compartilhar o notebook. Consulte Configurar sua conta IBM Cloud e Inicializar o serviço em um ambiente não confiável para obter mais orientações.

# 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 seguir, selecionamos um simulador e um modelo de ruído.

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

Padrões Qiskit etapa 3: Executar

Use o sampler para executar seu trabalho, com o 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()

Padrões Qiskit, etapa 4: Pós-processamento

Aqui, interpretamos nossos resultados e extraímos informações úteis. Poderíamos tentar visualizar a saída de nosso amostrador, mas usamos o amostrador de uma forma não convencional. Em vez de fazer muitas medições de nosso circuito e desenvolver estatísticas sobre os estados, fizemos apenas uma medição (a de Bob). Qualquer qubit com um estado que tenha sido preparado e medido na mesma base deve ter um resultado determinístico, de modo que apenas uma medição seja necessária. Esses qubits com estados preparados e medidos em bases diferentes (que teriam resultados probabilísticos e exigiriam muitas medições para serem interpretados) não serão usados para criar nosso teclado/chave de uso único.

Vamos extrair uma lista de resultados de medição dessa cadeia de bits. Tome cuidado para inverter a ordem se estiver comparando com a matriz de bits da Alice que usamos para gerar o 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]

Vamos comparar as bases de medição escolhidas aleatoriamente por Alice e Bob. Essa foi a etapa 3 de nosso protocolo QKD (discussão pública das bases). Sempre que eles escolhem a mesma base para um qubit, adicionamos os bits associados a esse qubit a uma lista de bits para gerar números em um bloco de uso único. Quando as bases não coincidem, os resultados são descartados. Vamos também verificar se as duas listas de bits estão de acordo ou se houve alguma perda devido a ruído ou outros fatores.

# 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 e Bob têm uma lista de bits, e eles combinam com 100% de fidelidade. Eles podem usá-los para gerar números em um teclado de uso único. Eles podem então usar isso na etapa 4 do QKD: enviar e descriptografar um segredo. O conjunto atual de bits é muito curto para descriptografar qualquer coisa. Voltaremos a esse assunto depois de incluir a espionagem.

Verifique sua compreensão

Suponha que você precise de dígitos grandes o suficiente para facilitar o deslocamento das letras do alfabeto inglês por todo o comprimento do alfabeto, ou mais, embora certamente existam outros esquemas de codificação. (a) Quantas letras uma mensagem pode ter para ser descriptografada usando os bits da chave acima? (b) Sua resposta deve concordar com a de seus colegas de classe? Por que ou por que não?

• Resposta

  (a) A resposta depende de quantas bases escolhidas aleatoriamente coincidiram entre Alice e Bob. Como há aproximadamente 50% de chance de as bases coincidirem para qualquer qubit, esperamos que cerca de 10 dos nossos bits sejam úteis. 9 ou 11 serão perfeitamente comuns. Mesmo que sejam 4 ou 15, isso não está fora do reino das possibilidades. São necessários 5 bits para deslocar um número maior ou igual ao comprimento do alfabeto inglês, o que significa que você pode aplicar o deslocamento a uma letra a cada 5 bits disponíveis. Se você tiver pelo menos 5 bits compartilhados por Alice e Bob, poderá codificar uma única letra. Se você tiver pelo menos 10, poderá codificar 2 letras, e assim por diante.

  (b) Não precisa concordar, pelas razões expostas na alínea (a).

Experimento 2: QKD com um bisbilhoteiro

Implementaremos exatamente o mesmo protocolo de antes. Desta vez, inseriremos outro conjunto de medições, feitas por Eve, entre Alice e 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()

A etapa 4 (pós-processamento) dos padrões Qiskit é simples nesse caso. Não há necessidade de visualizar a distribuição das medições, pois fizemos apenas uma medição. Eve tem os seguintes 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]

Agora Eve deve reconstruir os estados para enviar a Bob. Conforme descrito na introdução, ela não tem como saber se adivinhou as bases de codificação corretamente, portanto, não é capaz de preparar exatamente os mesmos estados que foram enviados. Ela poderia presumir que cada escolha de base estava correta e codificar exatamente o que mediu, ou poderia presumir que escolheu a base incorretamente e escolher um dos estados próprios da base oposta. Aqui, assumimos a primeira opção, por simplicidade. Para isso, construímos um circuito quântico totalmente novo, repetindo as etapas dos padrões 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]

Vamos agora comparar os bits de Alice e 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, havia uma correspondência perfeita entre os bits das chaves de Alice e Bob. Agora, com a interferência de Eve, vemos que os bits de Alice e Bob são diferentes em 14% dos casos que deveriam coincidir devido ao fato de Alice e Bob terem selecionado as mesmas bases. Isso deve ser fácil de ser detectado por Alice e Bob. No entanto, confiar em uma porcentagem de erros como essa significa que há um limite para a quantidade de ruído que podemos tolerar no canal quântico.

Experimento 3: Comparar QKD com e sem espionagem em um computador quântico real

Vamos executar isso em um computador quântico real. Dessa forma, podemos aproveitar o teorema da não clonagem. Ao mesmo tempo, os computadores quânticos reais têm ruído e taxas de erro mais altas do que os computadores clássicos. Portanto, vamos comparar a perda de fidelidade de nossos bits-chave com e sem espionagem, para garantir que a diferença seja detectável ao usar um computador quântico real. Começaremos na ausência de escutas:

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

Sem interceptação, obtivemos 100% de fidelidade nesse conjunto de 127 bits de teste, resultando em 55 bases correspondentes e bits de chave utilizáveis. Agora vamos repetir esse experimento com Eve ouvindo:

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

Aqui encontramos quase 23% de perda de fidelidade em bits compartilhados devido à espionagem! Isso é muito detectável! Observe que a transferência de informações quânticas por longas distâncias ainda pode introduzir ruídos e erros adicionais. Garantir que a escuta possa ser detectada, mesmo na presença de ruído e mesmo quando Eve usa todos os truques à sua disposição, é um campo complexo que vai além desta introdução.

Perguntas

Os instrutores podem solicitar versões desses cadernos com chaves de resposta e orientação sobre a colocação em currículos comuns preenchendo esta pesquisa rápida sobre como os cadernos estão sendo usados.

Conceitos críticos

• As informações quânticas não podem ser copiadas ou "clonadas".
• Você pode repetir o mesmo processo de preparação para criar um conjunto de estados quânticos que são todos iguais ou quase iguais.
• Uma chave de criptografia/descriptografia (um one-time pad) pode ser compartilhada entre dois amigos usando estados quânticos.
• Dois amigos escolhendo aleatoriamente uma base de medição significa que, na metade das vezes, eles escolherão de forma diferente e terão que descartar as informações sobre esses qubits.
• A escolha aleatória da base de medição também garante que um espião não possa conhecer o estado inicial preparado e, portanto, não possa recriar o estado enviado. Isso garante que a espionagem seja detectada.

Questões de verdadeiro ou falso

1. T/F Na distribuição de chaves quânticas, os dois parceiros de comunicação medem cada qubit na mesma base.
2. T/F Um espião que intercepta informações quânticas em QKD é impedido pelas leis da natureza de copiar o estado quântico que intercepta.
3. T/F Um one-time pad é uma chave para criptografar/descriptografar mensagens seguras em que um determinado esquema de codificação é usado apenas uma vez, para uma única informação (como uma letra do alfabeto).

Perguntas do MC

1. Selecione a opção que melhor completa a afirmação. Conforme descrito neste módulo, um one-time pad é um conjunto de chaves de criptografia/descriptografia que é usado...

• a. Apenas uma vez para uma única informação, como uma única letra.
• b. Apenas uma vez para uma única mensagem.
• c. Apenas uma vez por um determinado período de tempo, como um dia.
• d. Até que haja evidência de espionagem.

2. Suponha que Alice e Bob escolham suas bases de medição aleatoriamente. Eles medem. Em seguida, eles compartilham suas bases de medição e mantêm apenas os bits de informação dos casos em que usaram a mesma base. Até alguma flutuação aleatória, aproximadamente qual porcentagem de seus qubits deve produzir bits de informação utilizáveis?

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

3. Depois que Alice e Bob selecionarem os casos em que usaram as mesmas bases de medição, que porcentagem desses bits de informação deve corresponder, se o ruído e os erros quânticos forem desprezíveis?

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

4. Suponha que Alice tenha escolhido suas bases de medição aleatoriamente. Eve também escolhe suas bases aleatoriamente e ouve (medidas). Ela envia estados para Bob que são consistentes com suas medidas. Alice e Bob comparam as escolhas de base e mantêm apenas os qubits medidos/preparados por eles nas mesmas bases. Até alguma flutuação aleatória, aproximadamente qual porcentagem dessas medições de qubit mantidas será igual, de acordo com Alice e Bob?

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

QUESTÕES PARA DISCUSSÃO

1. Suponha que todas as escolhas de base sejam aleatórias para todos os participantes, Alice, Bob e Eve. Suponha que, depois que Eve escute, ela envie um estado para Bob que seja preparado na mesma base em que ela mediu e que seja consistente com essa medição. Convença seus parceiros de que 12.5 % de todos os qubits inicializados por Alice produzirão incompatibilidades de medição entre Alice e Bob, indicando espionagem (ignorando erros quânticos e ruído). Dica 1: Como não há uma base preferencial, se você considerar apenas uma escolha inicial para Alice, a proporção para essa escolha deve ser a mesma que a proporção para a soma de todas as escolhas. Dica 2: Talvez não seja suficiente contar o número de maneiras pelas quais algo pode acontecer, pois alguns resultados podem ocorrer com probabilidades diferentes.

2. Suponha novamente que todas as escolhas de base sejam aleatórias para todos os participantes, Alice, Bob e Eve. Mas agora, considere que Eva é livre para enviar qualquer estado que desejar após sua medição. Ela pode até tentar enviar estados que sejam inconsistentes com suas próprias medidas. Discuta com seus parceiros/vizinhos se você acha que há alguma escolha de bases que poderia reduzir a porcentagem média de qubits que indicam espionagem para Alice e Bob.