Distribuição quântica de chaves

Para este módulo do Qiskit in Classrooms, os estudantes precisam ter um ambiente Python funcional 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 tarefas em computadores quânticos reais, os estudantes precisarão criar uma conta no IBM Quantum® seguindo os passos do guia Configurar sua conta IBM Cloud.

Este módulo foi testado e utilizou 5 segundos de tempo de QPU. Isso é apenas uma estimativa. O uso real pode variar.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Assista ao guia do módulo pela Dra. Katie McCormick abaixo, ou clique aqui para assistir no YouTube.

Introdução e motivação

Há infinitas formas de criptografar e descriptografar informações, e literalmente milhares delas já foram estudadas em profundidade. Aqui, vamos nos restringir a um método de criptografia muito antigo e muito simples, chamado de "substituição simples", para poder focar na parte quântica deste protocolo. A parte quântica pode ser adaptada a muitos outros protocolos com relativamente poucas mudanças.

Substituição simples

Uma criptografia por substituição simples é aquela em que uma letra ou número é substituído por outro, de forma que haja um mapeamento 1:1 entre as letras e os números de uma mensagem e as letras e números usados na sequência criptografada. Um exemplo popular desse tipo é o puzzle de criptograma, em que uma citação ou frase é criptografada por substituição simples, e o jogador tem a tarefa de descriptografá-la. Esses puzzles 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 puzzles à mão geralmente usam truques que envolvem familiaridade com a estrutura da língua 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 certos valores. Há coisas mais sutis que dão pistas, como o fato de que a palavra mais comum com o padrão de "GSZG" é "that". Quem usa código para resolver esses puzzles tem muito mais opções, incluindo simplesmente varrer as possibilidades até que uma palavra em inglês seja encontrada e atualizar preservando essa palavra. Um método simples, mas poderoso, é usar a frequência de letras, especialmente quando a mensagem é longa o suficiente para constituir uma amostra representativa do inglês.

Questão de verificação

Tente descriptografar o texto acima, se quiser, embora isso não seja necessário para o restante do módulo. Clique na seta abaixo para ver a mensagem.

Resposta:

I decided that I'd better make this pretty long. That way, people will have an easier time solving it. I hope I made it simple enough.

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

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

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

Note que esses puzzles são muito difíceis se forem curtos. Na verdade, se forem muito curtos, são indetermináveis. Considere:

URYYP

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

Mas se você enviar muitas mensagens assim, eventualmente a criptografia será quebrada. Portanto, você não deveria usar a mesma "chave" com muita frequência. Na verdade, o ideal é usar uma certa substituição apenas uma vez. Não em apenas uma mensagem, mas somente para um único caractere! Com isso, queremos dizer que você terá um esquema de criptografia ou chave para cada caractere usado na mensagem, em ordem. Se você quiser enviar uma mensagem a um amigo usando esse método, você e seu amigo precisariam de um bloco de papel (nos velhos tempos) no qual essa chave em constante mudança estivesse escrita. Você vai usá-lo apenas uma vez. Isso é chamado de "bloco de uso único" (one-time pad).

O bloco de uso único

Vamos ver como isso funciona com um exemplo. Poderíamos fazer isso inteiramente com letras, mas é comum converter de letras para números, digamos, atribuindo A=0, B=1, C=2…. Suponha que somos amigos envolvidos em atividades clandestinas e compartilhamos um bloco. O ideal seria compartilhar muitos blocos, mas o de hoje é:

EDGRPOJNCUWQZVMK…

Ou, convertendo para números pela posição no alfabeto:

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

Suponha que eu queira compartilhar com você a mensagem:

"I love quantum!"

Ou, equivalentemente:

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

Não queremos enviar o código acima; isso seria uma substituição simples, que não é nada segura. Queremos combinar isso com nossa chave de alguma forma. Uma maneira comum é a adição módulo 26. Somamos o valor da mensagem ao valor da chave, mod 26, até chegar ao final da mensagem. Então, 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

Note que se alguém interceptar isso e NÃO tiver a chave, descriptografá-la é completamente 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 módulo 26 que você sabe que eu realizei:

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 forma que a mensagem x1, x2, x3, x4… deve ser

8, 11, 14, 21…

Por fim, convertendo isso para texto, temos

"I love quantum".

Isso é um bloco de uso único.

Note que se a chave for mais curta que a mensagem, começamos a repetir nossa codificação. Isso ainda seria um problema de descriptografia difícil de resolver, mas não impossível se for repetido com frequência suficiente. Portanto, você precisa de uma chave (ou "bloco") longa.

nota

Em muitos contextos, os estudantes já estarão familiarizados com essa criptografia, de forma que essa atividade pode ser pulada. Mas é uma recapitulação relativamente rápida e simples.

Passo 1: Encontre um parceiro e compartilhem uma sequência de 4 letras para usar como chave. Qualquer sequência de 4 letras apropriada para o ambiente de aula serve.
Passo 2: Escolha uma palavra secreta de 4 letras que você quer enviar ao seu parceiro (ambos os parceiros fazem isso, para que vocês se enviem palavras secretas diferentes).
Passo 3: Converta a chave/bloco de 4 letras e cada uma das palavras secretas de 4 letras para números usando A = 1, B = 2, e assim por diante.
Passo 4: Combine sua palavra de 4 letras com o bloco de uso único usando adição módulo 26.
Passo 5: Entregue ao seu parceiro a sequência de números que codifica sua palavra secreta, e seu parceiro entregará a dele a você.
Passo 6: Decodifique as palavras um do outro usando subtração módulo 26.
Passo 7: Verifique. Funcionou?

Questão de acompanhamento

Troque palavras criptografadas com um grupo diferente que não tenha acesso ao seu bloco de uso único. Você consegue descriptografá-las? Explique por quê ou por quê não.

Esperamos que a atividade acima deixe claro que um bloco de uso único é uma forma inquebrável de criptografia, dadas algumas suposições, como:

A chave tem o mesmo comprimento da mensagem a ser enviada, ou é mais longa
A chave é verdadeiramente aleatória
A chave é usada apenas uma vez e então descartada

Ótimo. Temos criptografia inquebrável... a menos que alguém obtenha nossa chave. Se alguém obtiver nossa chave, tudo é descriptografado. Essa diferença entre criptografia inquebrável e ter todos os nossos segredos expostos torna o compartilhamento de uma chave segura extremamente importante. O objetivo da distribuição quântica de chaves é aproveitar as restrições que a natureza impôs à informação quântica para proteger uma chave/bloco de uso único compartilhado.

Usando estados quânticos como chave

Vamos supor que estamos trabalhando com qubits (enfatizando que os qubits têm dois autoestados). Poderíamos usar sistemas quânticos com um número maior de estados quânticos, mas os computadores quânticos de ponta da IBM® usam qubits. Não há problema em codificar nossos A, B, C em sequências de 0s e 1s. Portanto, é suficiente para nós compartilharmos uma chave de 0s e 1s e fazer adição módulo 2 em cada bit que armazena uma letra.

Verifique sua compreensão

Leia a pergunta abaixo, pense na sua resposta e clique no triângulo para revelar a solução.

Se nos preocuparmos apenas com letras do inglês, 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 tal forma que ninguém mais possa interceptá-la (pelo menos não sem que eles saibam). Eles precisam ter uma maneira de enviar estados quânticos um ao outro. Fazer isso com alta fidelidade e sem ruído/erros NÃO é trivial. Mas há duas abordagens que devemos ser capazes de entender neste ponto:

Um cabo de fibra óptica permite enviar luz… que é muito quântico-mecânica. Fótons individuais podem ser detectados com alta fidelidade por muitos quilômetros de cabo de fibra óptica. Esse não é um canal quântico perfeito e sem erros, mas pode ser muito bom.
Poderíamos usar o teletransporte quântico, conforme descrito em um módulo anterior. Ou seja, Alice e Bob poderiam compartilhar qubits entrelaçados, 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 significa que esse seja o mais realista para o compartilhamento de chaves quânticas a longas distâncias.

Vamos explorar agora um protocolo proposto inicialmente 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 construir 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 nome "distribuição quântica de chaves" (QKD).

QKD passo 1: 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 na qual preparar um estado quântico, com base em cada bit aleatório, usando a tabela abaixo (uma tabela que Bob também tem):

Base	bit = 0	bit = 1
Z	$\vert 0\rangle$	$\vert 1\rangle$
X	$\vert +\rangle$	$\vert -\rangle$

Por exemplo, suponha que Alice gerou aleatoriamente um 0 e selecionou aleatoriamente a base X. Então 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 aleatória de base. Por ora, vamos simplesmente supor que um conjunto aleatório foi gerado, como a seguir:

Bits de Alice	0	1	0	0	1	1	0	1	0	...
Bases de Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Estados de Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...

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

QKD passo 2: bases aleatórias de Bob

Bob também faz uma escolha aleatória de bases. No entanto, enquanto Alice usava a escolha de base para preparar seu estado, Bob fará medições nessas bases. Se Bob fizer uma medição na mesma base em que Alice preparou o estado, então podemos 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.

Bits de Alice	0	1	0	0	1	1	0	1	0	...
Bases de Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Estados de Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Bases de Bob	X	Z	X	Z	X	X	Z	X	X	...
Estados de Bob (a priori)	$\vert +\rangle$	?	?	$\vert 0\rangle$	?	$\vert -\rangle$	$\vert 0\rangle$	?	$\vert +\rangle$	...
Estados de Bob (medidos)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...

Na tabela abaixo, considere a primeira coluna. Alice preparou o estado $\vert +\rangle,$ que é um autoestado 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, porém, eles escolheram bases diferentes. O estado que Alice enviou é $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$ Esse estado 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 mostrando o que sabemos, a priori, sobre as medições de Bob não pode ser preenchida para a coluna 2. Mas Bob fará uma medição e obterá um autoestado de (naquela coluna) Z. Na linha inferior, preenchemos o que essas medições aconteceram de produzir.

QKD passo 3: discussão pública das bases

Alice e Bob podem agora compartilhar entre si qual base escolheram em cada caso. Para todas as colunas em que coincidiram na mesma base, cada um sabe com certeza qual estado o outro tinha. Bob pode converter o estado e a base em um 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:

Bits de Alice	0	0	1	0	0	...
Bases de Alice	X	Z	X	Z	X	...
Estados de Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Bases de Bob	X	Z	X	Z	X	X
Estados de Bob (a priori)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Estados de Bob (medidos)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Bits de Bob	0	0	1	0	0	...

Alice transmitiu com sucesso a sequência de bits 00100... para Bob. Se os amigos concordaram com antecedência em usar sequências de 5 bits como números em seu bloco de uso único, esses primeiros cinco bits dariam o número $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

QKD passo 4: verificar e enviar o segredo

Antes de Alice e Bob irem mais longe, eles devem escolher um subconjunto de seus bits clássicos para comparar. Como mantiveram apenas medições de qubits que foram preparados e medidos usando a mesma base, todos os valores medidos devem concordar. Se houvesse uma porcentagem muito pequena que não concordasse, isso poderia ser atribuído a ruído ou erros quânticos. 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 ora, assumiremos que essa verificação corre bem; voltaremos a isso na seção abaixo sobre espionagem.

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

Alice e Bob comunicaram sua escolha de base por canais clássicos — isso não poderia ser interceptado? Sim! Mas saber a base que eles usaram para medição não revela qual bit foi enviado ou obtido. Isso só seria possível se você também soubesse os bits iniciais de Alice. Mas então você estaria no computador de Alice, onde os segredos estão armazenados, e a comunicação secreta dos segredos se tornaria inútil. Portanto, a interceptação da comunicação clássica não quebra a criptografia. Mas e a interceptação de informações no canal quântico?

Resistência do QKD à espionagem

Alice e Bob têm uma amiga, Eve, notória por bisbilhotar. Eve deseja interceptar a chave quântica de Alice e Bob para poder 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 espionagem teria que ocorrer antes de qualquer compartilhamento ou comparação de bases.

Eve precisa adivinhar qual base foi usada na codificação de cada bit. Novamente, se ela não conseguir acessar o computador de Alice, não tem nada em que basear esse palpite, e ele será aleatório. Vamos assumir que o ponto de partida de Alice é o mesmo de antes, e vamos assumir também que a escolha aleatória de base de medição de Bob é a mesma de antes. Vamos preencher o que Eve obtém se fizer medições do canal quântico. Como antes, se Eve escolher a mesma base que Alice, sabemos o que ela obterá. Se não, ela poderia obter qualquer um dos dois resultados, cada um com probabilidade de 50%.

Bits de Alice	0	1	0	0	1	1	0	1	0	...
Bases de Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Estados de Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Bases adivinhadas por Eve	Z	X	X	Z	X	Z	Z	X	X	...
Estados de Eve (a priori)	?	$\vert -\rangle$	?	$\vert 0\rangle$	?	?	$\vert 0\rangle$	?	$\vert +\rangle$	...
Estados de Eve (medidos)	$\vert 1\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Bases de Bob	X	Z	X	Z	X	X	Z	X	X	...

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 que ela sabe com certeza é que Alice não preparou o estado $|1\rangle$ para aquele qubit. Mas Alice poderia ter preparado $|0\rangle,$ $|+\rangle,$ ou $|-\rangle.$ Todos seriam consistentes com a medição de Eve. Então Eve precisa fazer uma escolha. Ela pode transmitir exatamente o estado que mediu, ou pode tentar adivinhar as instâncias em que sua medição não era o autoestado enviado por Alice. Incluiremos uma mistura em nossa tabela:

Bits de Alice	0	1	0	0	1	1	0	1	0	...
Bases de Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Estados de Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Bases adivinhadas por Eve	Z	X	X	Z	X	Z	Z	X	X	...
Estados de Eve (a priori)	?	$\vert -\rangle$	?	$\vert 0\rangle$	?	?	$\vert 0\rangle$	?	$\vert +\rangle$	...
Estados de Eve (medidos)	$\vert 1\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Estados de Eve (transmitidos)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	...
Bases de Bob	X	Z	X	Z	X	X	Z	X	X	...
Estados de Bob (a priori)	?	$\vert 0\rangle$	?	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Estados de Bob (medidos)	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Bits de Bob	1	0	0	0	1	0	0	1	0	...

Neste ponto, é razoável perguntar: "Por que Eve não simplesmente faz uma cópia do estado quântico de Alice, fica com uma para medir e transmite a outra para Bob?" A resposta é o teorema da não-clonagem. De forma informal, ele diz que não existe nenhuma operação unitária (quântico-mecânica) capaz de fazer uma segunda cópia de um estado quântico arbitrário preservando a primeira cópia. A prova é relativamente simples e é deixada como exercício guiado. Mas por ora, entenda que o fato de Eve fazer cópias do estado quântico é proibido pelas leis fundamentais da natureza, e esse é um ponto central de força do QKD.

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

Bits de Alice	0	0	1	0	0	...
Bases de Alice	X	Z	X	Z	X	...
Estados de Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Bases adivinhadas por Eve	Z	Z	Z	Z	X	...
Estados de Eve (a priori)	?	$\vert 0\rangle$	?	$\vert 0\rangle$	$\vert +\rangle$	...
Estados de Eve (medidos)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Estados de Eve (transmitidos)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	...
Bases de Bob	X	Z	X	Z	X	...
Estados de Bob (a priori)	?	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Estados de Bob (medidos)	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Bits de Bob	1	0	0	0	0	...

Alice e Bob comunicaram mais uma vez uma sequência de bits... mas as sequências não coincidem. O bit mais à esquerda e o bit do meio estão invertidos. Observando a tabela anterior, você pode rastrear essa divergência até a interferência de Eve. Crucialmente, note que podemos fazer estatísticas sobre a correspondência entre nossas sequências de bits agora, enquanto configuramos a chave, muito antes de compartilharmos nosso segredo criptografado. Alice e Bob são livres para usar quantos bits do bloco de uso único quiserem para verificar a segurança de seu canal. Se um único bit, ou uma porcentagem muito pequena de bits, não coincidir, isso pode ser atribuído a ruído ou erros. Mas uma fração substancial de divergências indica espionagem. O significado de "substancial" aqui depende um pouco do ruído na configuração usada; o que isso significa para os computadores quânticos da IBM® é discutido abaixo quando implementamos esse protocolo. Se forem detectados erros em excesso, Alice e Bob não compartilham o segredo e podem começar a procurar o espião.

Ressalvas

Provar a segurança é extremamente difícil. Na verdade, o protocolo descrito aqui de forma simplificada foi proposto em 1984, e só foi provado seguro 16 anos depois Shor & Preskill, 2000. Há muitas sutilezas que estão além do escopo desta introdução. Mas listamos brevemente algumas para demonstrar que o tema é mais complexo do que ilustrado aqui.

Canais seguros: Quando Alice envia seus qubits por alguma configuração quântica (um canal), e em particular quando recebe respostas clássicas de alguém, assumimos que esse alguém é realmente Bob. Se Eve infiltrasse essa configuração de tal forma que toda a comunicação de Alice estivesse realmente acontecendo com Eve, e toda a comunicação de Bob estivesse realmente sendo feita com Eve, então Eve teria efetivamente obtido uma chave e poderia conhecer os segredos. É preciso primeiro garantir "canais seguros", um processo com um conjunto diferente de protocolos que não abordamos aqui.
Suposições sobre Eve: Para provar a segurança de forma completa, não podemos fazer suposições sobre o comportamento de Eve; ela sempre poderia surpreender nossas expectativas. Aqui, para fornecer exemplos concretos, estamos fazendo suposições. Por exemplo, podemos supor que os estados que Eve transmite para Bob são sempre exatamente aqueles que ela obteve na medição. Ou podemos supor que ela escolhe aleatoriamente um estado experimentalmente consistente com sua medição. Mais fundamentalmente, a linguagem aqui assume 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 adequadas para entender o protocolo, mas significam que não estamos provando nada em plena generalidade.
Amplificação de privacidade: Alice e Bob não são obrigados a usar a chave quântica exatamente como transmitida. Eles podem, por exemplo, aplicar uma função hash à chave compartilhada. Isso aproveitaria 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 espião

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

Primeiro, uma observação sobre simuladores quânticos: a maioria dos problemas quânticos que envolve mais de ~30 qubits não pode ser simulada pela maioria dos computadores. Nenhum computador clássico, supercomputador ou GPU consegue simular toda a gama de comportamentos de um computador quântico de 127 qubits. Normalmente, a motivação para usar computadores quânticos reais é que os muitos qubits entrelaçados não podem ser simulados. Neste caso, não há entrelaçamento de qubits, a menos que usemos o esquema de teleportação para mover informações. Aqui, a motivação para usar computadores quânticos reais é diferente: é o teorema da não-clonagem. Um computador clássico simulando 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 Eve poderia manter uma cópia perfeita enquanto enviava outra para Bob. Isso não é possível com estados quânticos reais.

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

Etapa 1: Mapeie seu problema para um circuito quântico
Etapa 2: Otimize seu circuito para execução em hardware quântico real
Etapa 3: Execute seu job em computadores quânticos da IBM usando primitivas do Runtime
Etapa 4: Pós-processe os resultados

Padrões Qiskit — etapa 1: Mapear o problema para um circuito quântico

Neste caso, o mapeamento do nosso problema para circuitos quânticos se reduz simplesmente a preparar os estados de Alice e, em seguida, incluir as medições de Bob. Começamos com a seleção aleatória de bits e bases.

# 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. Note 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")

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

Saída da célula de código anterior

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

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

Começaremos carregando vários pacotes necessários para se comunicar com os computadores quânticos da IBM. Também precisamos selecionar um backend no qual executar. Podemos escolher o backend menos ocupado ou selecionar um backend específico cujas propriedades conhecemos. Embora usemos um simulador por ora, é 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 depois em computadores quânticos reais.

O código abaixo permite salvar suas credenciais no primeiro uso. Certifique-se de apagar essas informações do notebook depois de salvá-las em seu ambiente, para que suas credenciais não sejam acidentalmente compartilhadas ao compartilhar o notebook. Consulte Configurar sua conta IBM Cloud e Inicializar o serviço em um ambiente não confiável para 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)

ibm_brisbane

Abaixo 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 job, passando 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 do nosso sampler, mas o usamos de uma forma não convencional. Em vez de fazer muitas medições do nosso circuito e desenvolver estatísticas sobre os estados, fizemos apenas uma medição (a de Bob). Qualquer qubit com um estado que foi preparado e medido na mesma base deve ter um resultado determinístico, de modo que apenas uma medição é necessária. Aqueles qubits com estados preparados e medidos em bases diferentes (que teriam resultados probabilísticos e precisariam de muitas medições para serem interpretados) não serão usados para construir nosso bloco de uso único/chave.

Vamos extrair uma lista de resultados de medição dessa cadeia de bits. Preste atenção para inverter a ordem ao comparar com o array de bits de 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)

[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 do nosso protocolo QKD (discussão pública das bases). Sempre que eles escolheram 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 concordam, ou se houve perdas 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))

[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 cada um uma lista de bits, e eles coincidem com 100% de fidelidade. Eles podem usá-los para gerar números em um bloco de uso único. Então podem usá-lo na etapa 4 do QKD: enviar e descriptografar um segredo. O array de bits atual é muito curto para descriptografar qualquer coisa de valor. Voltaremos a isso após incluir a espionagem.

Verifique sua compreensão

Leia a pergunta abaixo, pense na sua resposta e depois clique no triângulo para revelar a solução.

Suponha que você precise de dígitos grandes o suficiente para facilitar o deslocamento de letras no alfabeto inglês pelo comprimento completo desse alfabeto, ou mais, embora certamente existam outros esquemas de codificação. (a) Quantas letras de comprimento poderia ter uma mensagem a ser descriptografada usando os bits da chave acima? (b) Sua resposta precisa coincidir com a dos seus colegas? Por que sim ou por que não?

Resposta:

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

Experimento 2: QKD com um espião

Vamos implementar exatamente o mesmo protocolo de antes. Desta vez, vamos inserir outro conjunto de medições, 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()

O pós-processamento dos padrões Qiskit (etapa 4) é simples neste caso. Não há necessidade de visualizar a distribuição das medições, já que 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)

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

Agora Eve precisa reconstruir os estados para enviar a Bob. Como descrito na introdução, ela não tem como saber se adivinhou corretamente as bases de codificação, portanto não consegue preparar exatamente os mesmos estados que foram enviados. Ela poderia assumir que cada escolha de base estava correta e codificar exatamente o que mediu, ou poderia assumir que escolheu a base incorretamente e escolher qualquer autoestado da base oposta. Aqui, por simplicidade, assumimos a primeira opção. Fazemos isso construindo um circuito quântico completamente 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)

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

[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 nas chaves de Alice e Bob. Agora, devido à interferência de Eve, vemos que os bits de Alice e Bob diferem em 14% dos casos que deveriam coincidir, pois Alice e Bob selecionaram as mesmas bases. Isso deve ser fácil de detectar por Alice e Bob. No entanto, depender de uma porcentagem de erros assim 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, computadores quânticos reais têm ruído e taxas de erro mais altas do que computadores clássicos. Então, vamos comparar a perda de fidelidade dos bits da 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 espionagem:

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

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 espionagem, obtivemos 100% de fidelidade nesse conjunto de 127 bits de teste, resultando em 55 bases coincidentes e bits de chave utilizáveis. Agora vamos repetir esse experimento com Eve escutando:

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

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 nos bits compartilhados devido à espionagem! Isso é muito detectável! Note que transferir informação quântica por longas distâncias ainda pode introduzir ruído e erros adicionais. Garantir que a espionagem possa ser detectada, mesmo na presença de ruído e mesmo quando Eve usa todos os truques disponíveis, é um campo complexo que vai além desta introdução.

Questões

Instrutores podem solicitar versões destes notebooks com gabaritos e orientações sobre como inseri-los em currículos comuns preenchendo esta pesquisa rápida sobre como os notebooks estão sendo utilizados.

Conceitos fundamentais

Informação quântica não pode ser copiada ou "clonada".
Você pode repetir o mesmo processo de preparação para criar um conjunto de estados quânticos que sejam todos iguais, ou quase iguais.
Uma chave de cifragem/decifragem (um bloco de uso único) pode ser compartilhada entre dois amigos usando estados quânticos.
Dois amigos que escolhem aleatoriamente uma base de medição farão escolhas diferentes metade das vezes e terão que descartar a informação nesses qubits.
A escolha aleatória da base de medição também garante que uma pessoa que está espionando não possa conhecer o estado inicial preparado e, portanto, não possa recriar o estado enviado. Isso assegura que a espionagem será detectada.

Questões V/F

V/F Na distribuição quântica de chaves, os dois parceiros de comunicação medem cada qubit na mesma base.
V/F Uma pessoa que intercepta informação quântica em QKD é impedida pelas leis da natureza de copiar o estado quântico que intercepta.
V/F Um bloco de uso único é uma chave para cifrar/decifrar mensagens seguras na qual um esquema de codificação específico é usado apenas uma vez, para uma única informação (como uma única letra do alfabeto).

Questões de múltipla escolha

Selecione a opção que completa melhor a afirmação. Conforme descrito neste módulo, um bloco de uso único é um conjunto de chaves de cifragem/decifragem 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 para um período de tempo definido, como um dia.
d. Até que haja evidência de espionagem.

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

a. 100%
b. 50%
c. 25%
d. 12,5%
e. 0%

Após Alice e Bob selecionarem os casos em que usaram as mesmas bases de medição, qual porcentagem desses bits de informação deve coincidir, se o ruído e os erros quânticos fossem desprezíveis?

a. 100%
b. 50%
c. 25%
d. 12,5%
e. 0%

Suponha que Alice tenha escolhido suas bases de medição aleatoriamente. Eve também escolhe suas bases aleatoriamente e escuta (mede). Ela envia a Bob estados consistentes com suas medições. Alice e Bob comparam as escolhas de base e mantêm apenas os qubits medidos/preparados por eles nas mesmas bases. Desconsiderando flutuações aleatórias, aproximadamente qual porcentagem dessas medições de qubits mantidas irá coincidir, segundo Alice e Bob?

a. 100%
b. 75%
c. 50%
d. 25%
e. 12,5%
f. 0%

Questões para discussão

Suponha que todas as escolhas de base sejam aleatórias para todos os participantes: Alice, Bob e Eve. Suponha que, após Eve escutar, ela envie a Bob um estado preparado na mesma base em que ela mediu e consistente com essa medição. Convença seus colegas de que 12,5% de todos os qubits inicializados por Alice gerarão discordâncias de medição entre Alice e Bob, indicando espionagem (ignorando erros e ruído quânticos). Dica 1: Como não há base preferencial, se você considerar apenas uma escolha inicial de Alice, a proporção para essa escolha deve ser a mesma que a proporção para a soma de todas as escolhas. Dica 2: Pode não ser suficiente contar o número de maneiras pelas quais algo pode acontecer, pois alguns resultados podem ocorrer com probabilidades diferentes.
Suponha novamente que todas as escolhas de base sejam aleatórias para todos os participantes: Alice, Bob e Eve. Mas agora, considere que Eve é livre para enviar qualquer estado que quiser após sua medição. Ela poderia até tentar enviar estados inconsistentes com suas próprias medições. Discuta com seus colegas se você acha que existe alguma escolha de base que poderia reduzir a porcentagem média de qubits que indicam espionagem para Alice e Bob.

Introdução e motivação​

Substituição simples​

Questão de verificação​

O bloco de uso único​

Questão de acompanhamento​

Usando estados quânticos como chave​

Verifique sua compreensão​

QKD passo 1: bits aleatórios e bases aleatórias de Alice​

QKD passo 2: bases aleatórias de Bob​

QKD passo 3: discussão pública das bases​

QKD passo 4: verificar e enviar o segredo​

Resistência do QKD à espionagem​

Ressalvas​

Experimento 1: QKD sem espião​

Padrões Qiskit — etapa 1: Mapear o problema para um circuito quântico​

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

Padrões Qiskit — etapa 3: Executar​

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

Verifique sua compreensão​

Experimento 2: QKD com um espião​

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

Questões​

Conceitos fundamentais​

Questões V/F​

Questões de múltipla escolha​

Questões para discussão​

Introdução e motivação

Substituição simples

Questão de verificação

O bloco de uso único

Questão de acompanhamento

Usando estados quânticos como chave

Verifique sua compreensão

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

QKD passo 2: bases aleatórias de Bob

QKD passo 3: discussão pública das bases

QKD passo 4: verificar e enviar o segredo

Resistência do QKD à espionagem

Ressalvas

Experimento 1: QKD sem espião

Padrões Qiskit — etapa 1: Mapear o problema para um circuito quântico

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

Padrões Qiskit — etapa 3: Executar

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

Verifique sua compreensão

Experimento 2: QKD com um espião

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

Questões

Conceitos fundamentais

Questões V/F

Questões de múltipla escolha

Questões para discussão