Teletransporte quântico

Para este módulo do Qiskit in Classrooms, os alunos 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 jobs em computadores quânticos reais, os alunos precisarão criar uma conta no IBM Quantum® seguindo os passos do guia Configure sua conta IBM Cloud.

Este módulo foi testado e utilizou 14 segundos de tempo de QPU. Isso é apenas uma estimativa. O seu 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 walkthrough do módulo com a Dra. Katie McCormick abaixo, ou clique aqui para assistir no YouTube.

---

Introdução e contexto

O teletransporte quântico é uma técnica da física quântica que permite a transferência de informação quântica de um local para outro sem mover fisicamente as partículas. Ao contrário do conceito de teletransporte da ficção científica, esse processo não envolve o transporte de matéria. Em vez disso, ele se baseia no princípio do emaranhamento quântico, em que duas partículas ficam ligadas independentemente da distância. Por meio de uma série de medições precisas e de comunicação clássica, o estado quântico de uma partícula pode ser recriado em outra partícula em um local distante, efetivamente "teletransportando" a informação quântica. Neste módulo, veremos como isso funciona matematicamente e, em seguida, implementaremos o teletransporte quântico em um computador quântico real. A introdução aqui será breve; para mais contexto sobre informação quântica e mais explicações sobre o teletransporte, recomendamos o curso de John Watrous sobre os Fundamentos da informação quântica, em especial a seção sobre Teletransporte.

Bits clássicos podem estar nos estados 0 ou 1. Bits quânticos (qubits) podem estar em estados quânticos denotados por $|0\rangle$ e $|1\rangle$ e também em combinações lineares desses estados, chamadas de "superposições", como $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, com $\alpha_0,\alpha_1 \in \mathbb{C},$ e $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Embora os estados possam existir nessa superposição, uma medição do estado vai "colapsá-lo" para o estado $|0\rangle$ ou $|1\rangle$. Os parâmetros $a$ e $b$ estão relacionados à probabilidade de cada resultado de medição de acordo com

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

Daí a restrição de que $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Outra característica fundamental é que os bits quânticos podem ser "emaranhados", o que significa que a medição de um qubit pode afetar o resultado da medição de outro qubit emaranhado. Entender como o emaranhamento difere das correlações clássicas simples é um pouco complicado. Vamos primeiro explicar nossa notação. Chame de dois qubits pertencentes à amiga 0 (Alice) e ao amigo 1 (Bob), cada um no estado $|0\rangle$

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

ou

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

às vezes abreviado simplesmente para

$$|00\rangle$$

Observe que o qubit com número (ou letra) mais baixo está mais à direita. Essa é uma convenção chamada de notação "little-endian", usada em todo o Qiskit. Se o estado de dois qubits dos amigos for $|00\rangle$ e eles medirem o estado de seus respectivos qubits, cada um encontrará 0. Da mesma forma, se os qubits estivessem no estado $|11\rangle,$ cada uma de suas medições resultaria em 1. Isso não é diferente do caso clássico. No entanto, na computação quântica, podemos combinar isso com a superposição para obter estados como

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

Em um estado como esse, se os qubits de Alice e Bob estão no estado 0 ou 1 ainda não é conhecido, nem mesmo determinado pela natureza, e ainda assim sabemos que eles medirão o mesmo estado para seus qubits. Por exemplo, se Bob medir seu qubit no estado $|0\rangle,$ a única forma de isso acontecer é se a medição tiver colapsado o estado de dois qubits para um dos dois estados possíveis, especificamente para $|00\rangle.$ Isso deixa o qubit de Alice também no estado $|0\rangle$.

O emaranhamento de qubits dessa forma não exige que os qubits permaneçam fisicamente próximos uns dos outros. Em outras palavras, poderíamos emaranhar qubits, depois separá-los por uma grande distância e usar seu emaranhamento para enviar informações. Um estado emaranhado como o acima é uma unidade básica de emaranhamento e às vezes é chamado de "e-bit", um único bit de emaranhamento. Esses e-bits podem ser vistos como recursos na comunicação quântica, pois cada e-bit compartilhado entre parceiros distantes pode ser usado, como descrevemos aqui, para mover informações de um local para outro.

O primeiro pensamento de muitas pessoas que aprendem sobre isso pela primeira vez é sobre a violação da relatividade: podemos usar isso para enviar informações mais rápido do que a luz? Por favor, continue questionando e sondando as regras científicas, mas infelizmente isso não nos permitirá enviar informações mais rápido do que a luz, por razões que ficarão claras ao longo deste módulo. Spoiler: surpreendentemente, NÃO é devido à velocidade com que esse colapso se propaga, que parece acontecer mais rápido do que a luz [1]. Começamos com dois colaboradores, Alice e Bob, que inicialmente estão no mesmo local e podem trabalhar juntos nos mesmos qubits. Esses colaboradores vão emaranhar seus qubits. Em seguida, eles se separarão e irão para dois locais geográficos diferentes, levando cada um seus respectivos qubits. Alice então obterá informações quânticas em um novo qubit Q. Não fazemos suposições sobre as informações contidas em Q. O estado de Q pode ser um segredo desconhecido para Alice; pode ser desconhecido para todas as pessoas. Mas Alice recebe a tarefa de transferir as informações de Q para Bob. Ela fará isso usando o teletransporte quântico.

Para isso, precisaremos conhecer algumas operações quânticas ou "portas".

Operadores quânticos (portas)

Fique à vontade para pular esta seção se você já estiver familiarizado com portas quânticas. Se você quiser entender melhor essas portas, consulte Fundamentos da informação quântica, especialmente as duas primeiras lições, no IBM Quantum Learning.

Para este protocolo de teletransporte, usaremos principalmente dois tipos de portas quânticas: a porta Hadamard e a porta CNOT. Algumas outras terão um papel menor: a porta $X$, a porta $Z$ e a porta SWAP.

Este módulo pode ser concluído com um conhecimento muito limitado de álgebra linear, mas às vezes visualizar as portas da mecânica quântica usando matrizes e vetores pode ser útil. Por isso, apresentamos aqui as formas matriciais/vetoriais das portas/estados quânticos também.

Os estados que já apresentamos são escolhidos (em parte por convenção e em parte por restrições) para ter as seguintes formas vetoriais:

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

Dessa forma, um estado arbitrário $|\psi\rangle = a|0\rangle+b|1\rangle$ pode ser escrito como

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

Há alguma escolha na forma de estender a notação para estados de múltiplos qubits, mas a opção abaixo é bastante padrão:

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

Com essa escolha de notação vetorial em mente, podemos apresentar as portas quânticas necessárias, seus efeitos sobre os estados quânticos e suas formas matriciais.

Porta H de Hadamard: Cria um estado de superposição. Porta de um único qubit.

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

Um circuito com uma porta Hadamard é criado da seguinte forma:

from qiskit import QuantumCircuit

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

Porta CNOT (NOT Controlado): Essa porta usa dois qubits: um de controle e um alvo. Verifica o estado de um qubit de controle, que não é alterado. Mas se o qubit de controle estiver no estado $|1\rangle$, a porta altera o estado do qubit alvo; se o estado do qubit de controle for $|0\rangle$, nenhuma alteração é feita. Na notação abaixo, considere que o qubit $A$ (o qubit mais à direita) é o controle, e o qubit $B$ (o mais à esquerda) é o alvo. Abaixo, a notação usada é $CNOT(q_{control},q_{target})|BA\rangle.$

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

Você pode às vezes ver CNOT escrito com a ordem do controle e do alvo simplesmente implícita. Mas não há essa ambiguidade em código ou em diagramas de circuito.

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

Uma porta CNOT parece um pouco diferente em um circuito, pois requer dois qubits. Veja como ela é implementada:

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

Verifique sua compreensão

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

A maioria das portas tem a mesma forma matricial no Qiskit que em qualquer outro lugar. Mas a porta CNOT age sobre dois qubits, e de repente a convenção de ordenação dos qubits se torna um problema. Textos que ordenam qubits como $|q_0,q_1,...\rangle$ mostrarão uma forma matricial diferente para suas portas CNOT. Verifique por multiplicação matricial explícita que a matriz CNOT acima tem a ação correta sobre o estado $|01\rangle.$

Resposta:

$CNOT|01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = |11\rangle$

Porta $X$: Equivalente a uma operação NOT. Porta de um único qubit.

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

No Qiskit, criar um circuito com uma porta $X$ é assim:

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

Porta $Z$: Adiciona uma "fase" a um estado (um pré-fator que, no caso dos autoestados Z $|0\rangle$ e $|1\rangle$, é 1 ou -1, respectivamente). Porta de um único qubit.

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

No Qiskit, criar um circuito com uma porta $Z$ é assim:

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

Teoria

Vamos descrever o protocolo para o teletransporte quântico usando matemática. Em seguida, na próxima seção, realizaremos essa configuração usando um computador quântico.

Alice e Bob emaranlham seus qubits: Inicialmente, o qubit de Alice e o qubit de Bob estão, cada um separadamente, no estado $|0\rangle$ (uma suposição razoável e também a inicialização correta para os computadores quânticos IBM®). Podemos escrever isso como $|0\rangle_B|0\rangle_A$ ou simplesmente como $|00\rangle$. Vamos calcular o que acontece quando Alice e Bob aplicam a porta Hadamard ao qubit de Alice e, em seguida, uma porta CNOT com o qubit de Alice como controle e o de Bob como alvo:

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

Observe que agora os qubits de Alice e Bob estão emaranhados. Embora ainda não seja determinado pela natureza se ambos os qubits deles estão no estado $|0\rangle$ ou $|1\rangle$, sabe-se que seus qubits estão no mesmo estado. Alice e Bob se separam: Os dois amigos levam seus qubits para novos locais, possivelmente muito distantes um do outro. Isso vem com muitos alertas: não é trivial mover informações quânticas sem perturbá-las. Mas elas podem ser movidas e, de fato, você as moverá neste módulo. Mas tenha em mente, como um alerta, que esperamos encontrar alguns erros quando movemos informações quânticas por muitos lugares.

Q é introduzido: O estado secreto é preparado no qubit Q:

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

Neste ponto, Q está simplesmente adjacente ao qubit de Alice (A). Não houve emaranhamento, portanto o estado quântico dos três qubits juntos pode ser escrito como:

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

O objetivo é mover as informações em Q do local de Alice para o local de Bob. Neste ponto, não estamos fazendo nenhuma afirmação ou exigência sobre sigilo ou velocidade de transferência de informações. Estamos simplesmente explorando como as informações podem se mover de Alice para Bob. Como a informação começa em Q, assumiremos que Q recebe o menor número nos números de qubits, de modo que a notação little-endian faça Q ser o qubit mais à direita na matemática abaixo.

Alice emaranla os qubits A e Q: Alice agora opera com uma porta CNOT com seu próprio qubit como controle e Q como alvo, depois aplica uma porta Hadamard a Q. Vamos calcular o estado de três qubits após essa operação:

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

Como A e Q estão no mesmo local, vamos agrupar os termos acima de acordo com os resultados das medições nos qubits A e Q:

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

Verifique sua compreensão

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

Dada a expressão acima para os estados dos três qubits, qual é a probabilidade de que uma medição dos qubits A e Q resulte em $|0\rangle_A|0\rangle_Q?$

Resposta:

25%. Para ver isso, lembre-se de que o estado de Bob deve ser normalizado, portanto $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Agora, Alice pode medir os qubits A e Q. Ela não pode controlar o resultado dessa medição, pois as medições quânticas são probabilísticas. Portanto, quando ela mede, há 4 resultados possíveis e todos os 4 são igualmente prováveis: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q,$ e $|1\rangle_A|1\rangle_Q.$ Observe que cada resultado tem implicações diferentes para o qubit de Bob. Por exemplo, se Alice encontrar seus qubits em $|0\rangle_A|0\rangle_Q,$ isso colapsou todo o estado quântico de 3 qubits para $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Outros resultados de medição para Alice deixam estados diferentes para Bob. Estes são reunidos na tabela abaixo.

Resultado de Alice	Estado de Bob	Instrução para Bob	Resultado
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Nenhuma	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ e depois $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Para todos os possíveis resultados de medição nos qubits de Alice, o qubit de Bob fica em um estado vagamente semelhante ao estado secreto originalmente em Q. No caso em que Alice mede $	0\rangle_C	0\rangle_A$(a primeira linha da tabela), o qubit de Bob fica exatamente no estado secreto! Nos outros casos, há algo errado no estado. Os coeficientes ($\alpha$'s) estão trocados, ou há um sinal "-" onde deveria haver um "+" , ou ambos. Para modificar o qubit de Bob e torná-lo exatamente igual ao estado secreto, Alice precisa ligar para Bob (usar algum meio de comunicação clássica) e dizer a Bob para realizar operações adicionais em seu qubit, conforme descrito na tabela. Por exemplo, na terceira linha os coeficientes estão trocados. Se Alice ligar para Bob e dizer a ele para aplicar uma porta$X$ao seu qubit, ela transforma um$	0\rangle$em$

Agora deve estar claro por que não podemos usar essa configuração para enviar informações mais rápido do que a luz. Podemos ter sorte e medir $|0\rangle_A|0\rangle_Q,$ o que significa que Bob tem exatamente o estado secreto, instantaneamente. Mas Bob não sabe disso até que nós o liguemos e digamos "Medimos $|0\rangle_A|0\rangle_Q$, então você não precisa fazer nada."

No experimento mental, os qubits são frequentemente fisicamente separados e levados a um novo local. Os computadores quânticos IBM® usam qubits de estado sólido em um chip que não podem ser separados. Portanto, em vez de mover Alice e Bob para locais diferentes, separaremos as informações no próprio chip usando as chamadas "portas swap" para mover as informações de um qubit para outro.

Experimento 1: Teleportação básica

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 de Runtime
• Etapa 4: Pós-processe os resultados

Etapa 1: Mapeie seu problema para um circuito quântico

Toda a matemática que fizemos acima foi o esboço da Etapa 1. Vamos implementá-la agora, construindo nosso circuito quântico usando o Qiskit! Começamos criando um circuito quântico com três qubits e entrelaçando os dois qubits de Alice e Bob. Vamos considerar esses como qubits 1 e 2, e reservar o qubit 0 para o estado secreto.

# Step 1: Map your problem to a quantum circuit

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

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

cr = ClassicalRegister(3, "c")

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

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

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

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

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

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

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

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

qc.draw(output="mpl")

Isso é tudo que precisamos fazer para teleportar o estado de Alice para Bob. No entanto, lembre-se de que ao medirmos um estado quântico $\alpha_0 |0\rangle+\alpha_1|1\rangle$ encontramos ou $|0\rangle$ ou $|1\rangle.$ Portanto, ao final de tudo isso, Bob definitivamente tem o estado secreto de Alice, mas não conseguimos verificar isso facilmente com uma medição. Para que uma medição nos diga que fizemos isso corretamente, precisamos usar um truque. Tínhamos um operador chamado "U" de "unitário", que usamos para preparar o estado secreto de Alice. Podemos aplicar o inverso de U ao final do nosso circuito. Se U mapeou o estado $|0\rangle$ de Alice em $\alpha_0 |0\rangle+\alpha_1|1\rangle$, então o inverso de U vai mapear o $\alpha_0 |0\rangle+\alpha_1|1\rangle$ de Bob de volta para $|0\rangle.$ Portanto, essa última parte não precisaria necessariamente ser feita se o objetivo fosse apenas mover informação quântica. Isso é feito somente para nós verificarmos nosso trabalho.

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

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

qc.draw(output="mpl")

Portanto, se fizemos isso corretamente, nossa medição no qubit de Bob deve produzir um estado $|0\rangle$. Claro, essas medições são probabilísticas. Então, se houver mesmo uma pequena chance de medir o qubit de Bob no estado $|1\rangle$, uma única medição poderia resultar em $|1\rangle.$ Gostaríamos realmente de fazer muitas medições para ter a certeza de que a probabilidade de $|0\rangle$ é bastante alta.

Etapa 2: Otimize o problema para execução quântica

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

Começaremos carregando vários pacotes necessários para comunicação 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 já conhecemos.

Há código abaixo para salvar suas credenciais no primeiro uso. Certifique-se de excluir essas informações do notebook após salvá-las em seu ambiente, para que suas credenciais não sejam compartilhadas acidentalmente quando você compartilhar o notebook. Consulte Configure sua conta IBM Cloud e Inicialize 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_sherbrooke

Habilitamos explicitamente a lógica sobre medições.

from qiskit.circuit import IfElseOp

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

Agora precisamos "transpilar" o circuito quântico. Isso envolve muitas sub-etapas e é um tema fascinante. Só para dar um exemplo de sub-etapa: nem todos os computadores quânticos conseguem implementar diretamente todas as portas lógicas do Qiskit. Precisamos escrever as portas do nosso circuito em termos das portas que o computador quântico consegue implementar. Podemos realizar esse processo, e outros, usando um gerenciador de passagens predefinido. Definir optimization = 3 (o nível mais alto de otimização) garante que o mapeamento do nosso circuito quântico abstrato para as instruções enviadas ao computador quântico seja o mais eficiente possível no nosso pré-processamento.

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

Um "Sampler" é uma primitiva projetada para amostrar possíveis estados resultantes de um circuito quântico e coletar estatísticas sobre quais estados podem ser medidos e com qual probabilidade. Importamos aqui o Sampler do Qiskit Runtime:

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Nem todos os cálculos em um computador quântico podem ser simulados de forma razoável em computadores clássicos. Essa teleportação simples definitivamente pode ser simulada, mas não é nada surpreendente que possamos salvar informação classicamente de um lugar para outro. Recomendamos fortemente realizar esses cálculos usando um computador quântico IBM real. Mas, caso você tenha esgotado seu uso mensal gratuito, ou se algo precisar ser concluído em aula e não puder aguardar na fila, este módulo pode ser completado usando um simulador. Para isso, basta executar a célula abaixo e descomentar as linhas associadas nas etapas de "Execução".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

Etapa 3: Executar

Use o sampler para executar seu job, com o circuito como argumento.

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

Etapa 4: Pós-processamento e análise

Vamos plotar os resultados e interpretá-los.

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

plot_histogram(counts)

Verifique sua compreensão

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

Quais dos estados acima indicam uma teleportação bem-sucedida e como você pode identificar isso?

Resposta:

Os estados $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ são todos consistentes com uma teleportação bem-sucedida. Isso porque adicionamos uma porta para desfazer a preparação inicial do estado secreto. Se o estado secreto foi teleportado com sucesso para o qubit de Bob, essa porta adicional deve retornar o qubit de Bob ao estado $|0\rangle$. Portanto, qualquer estado acima com o qubit de Bob (qubit 0, também medido no 0º componente do registrador clássico e, portanto, o mais alto/mais à direita) no estado $|0\rangle$ indica sucesso.

Este gráfico mostra todos os resultados de medição para os três qubits, ao longo de 5.000 tentativas ou "shots". Apontamos anteriormente que Alice mediria todos os estados possíveis para os qubits A e Q com probabilidade igual. Atribuímos os qubits 0 a 2 no circuito a Q, A e B, nessa ordem. Na notação little-endian, o qubit de Bob é o mais à esquerda/mais baixo. Portanto, as quatro barras à esquerda correspondem ao qubit de Bob sendo $|0\rangle$, e os outros dois qubits estando em todas as combinações possíveis com probabilidade aproximadamente igual. Note que quase todas (geralmente ~95%) as medições produzem o qubit de Bob no estado $|0\rangle$, o que significa que nossa configuração foi bem-sucedida! Há alguns shots (~5%) que produziram o qubit de Bob no estado $|1\rangle$. Isso não deveria ser logicamente possível. No entanto, todos os computadores quânticos modernos sofrem com ruído e erros em uma extensão muito maior do que os computadores clássicos. E a correção de erros quânticos ainda é um campo emergente.

Experimento 2: Teleportando por um processador

Sem dúvida, a parte mais interessante da teleportação quântica é que um estado quântico pode ser teleportado a longas distâncias instantaneamente (embora a comunicação clássica de portas extras não seja instantânea). Como já afirmamos, não podemos destacar qubits do processador e movê-los. Mas podemos mover a informação de um qubit para outro, até que os qubits envolvidos na teleportação estejam em lados opostos do processador. Vamos repetir as etapas que seguimos acima, mas agora criaremos um circuito maior com qubits suficientes para abranger o processador.

Etapa 1: Mapeie seu problema para um circuito quântico

Desta vez, os qubits correspondentes a Alice e Bob vão mudar. Portanto, não daremos o nome "A" a um único qubit e "B" a outro. Em vez disso, vamos numerar os qubits e usar variáveis para representar a posição atual da informação nos qubits pertencentes a Alice e Bob. Todas as outras etapas, exceto as portas swap, são como descritas anteriormente.

# Step 1: Map

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

qc = QuantumCircuit(qr, cr)

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

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

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

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

qc.barrier()

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

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

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

qc.barrier()

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

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

qc.barrier()

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

qc.draw("mpl")

Você pode ver no diagrama do circuito que as etapas lógicas são as mesmas. A única diferença é que usamos as portas swap para trazer o estado do qubit de Alice do qubit 6 ($A_5$) até o qubit 1 ($A_0$), bem próximo de Q. E usamos portas swap para trazer o estado inicial de Bob do qubit 7 ($B_0$) até o qubit 12 ($B_5$). Note que o estado no qubit 12 não está sequer relacionado ao estado secreto de Q até que as medições sejam feitas nos qubits distantes 0 e 1, e o estado no qubit 12 não é igual ao estado secreto até que as portas condicionais $X$ e $Z$ sejam aplicadas.

Etapa 2: Otimize seu circuito

Normalmente, quando usamos o gerenciador de passagens para transpilar e otimizar nossos circuitos, faz sentido definir optimization_level = 3, porque queremos que nossos circuitos sejam tão eficientes quanto possível. Neste caso, não há nenhuma razão computacional para transferirmos os estados dos qubits 6 e 7 para os qubits 1 e 12. Isso foi algo que fizemos apenas para demonstrar a teleportação à distância. Se pedirmos ao gerenciador de passagens para otimizar nosso circuito, ele perceberá que não há razão lógica para essas portas swap e as removerá, realizando as operações de porta em qubits adjacentes. Portanto, para este caso especial, usamos optimization_level = 0.

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

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

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Podemos visualizar onde no processador quântico esses qubits estão usando a função plot_circuit_layout.

Etapa 3: Executar

Como antes, recomendamos executar em computadores quânticos IBM reais. Se seu uso mensal gratuito tiver sido atingido, sinta-se à vontade para descomentar as células do simulador e executar em um simulador.

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

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Etapa 4: Pós-processamento clássico

Novamente vemos que as probabilidades para os possíveis resultados dos qubits de Alice são bastante uniformes. Há uma forte preferência por encontrar o qubit de Bob em $|0\rangle$ após inverter o código secreto, o que significa que há uma alta probabilidade de termos teleportado corretamente o estado secreto pelo processador de Q para Bob (qubits 0 a 12). No entanto, notamos que agora há uma chance maior de não medir $|0\rangle$ para Bob. Esta é uma lição importante em computação quântica: quanto mais portas você tiver em sequência, especialmente portas de múltiplos qubits como as portas swap, mais ruído e erros você vai encontrar.

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

• Qubits podem ser entrelaçados, o que significa que a medição de um qubit afeta ou até determina o estado de outro qubit.
• O entrelaçamento difere das correlações clássicas; por exemplo, os qubits A e B podem estar em uma superposição de estados como $\alpha_0|00\rangle+\alpha_1|11\rangle.$ O estado de A ou B pode ser indeterminado pela natureza, e ainda assim A e B podem ter garantia de estar no mesmo estado.
• Por meio de uma combinação de entrelaçamentos e medições, podemos transferir um estado (que pode armazenar informação) de um qubit para outro. Essa transferência pode ser feita mesmo a longas distâncias, e isso é chamado de teleportação quântica.
• A teleportação quântica depende de medições quânticas, que são probabilísticas. Portanto, a comunicação clássica pode ser necessária para ajustar os estados teleportados. Isso impede que a teleportação quântica mova informação mais rápido do que a luz. A teleportação quântica não viola a relatividade nem a causalidade.
• Os computadores quânticos modernos são mais suscetíveis a ruído e erros do que os computadores clássicos. Espere alguns por cento de erro.
• Quanto mais portas você adicionar em sequência (especialmente portas de 2 qubits), mais erros e ruído você pode esperar.

Questões de verdadeiro/falso

1. V/F A teleportação quântica pode ser usada para enviar informação mais rápido do que a luz.
2. V/F Evidências modernas sugerem que o colapso de um estado quântico se propaga mais rápido do que a luz.
3. V/F No Qiskit, os qubits são ordenados nos estados com o qubit de número mais baixo à direita, como em $|q_3,q_2,q_1, q_0\rangle$

Questões de múltipla escolha

1. Os qubits A e B estão entrelaçados e, em seguida, separados por uma grande distância $d$. O qubit A é medido. Qual afirmação está correta sobre a velocidade com que o estado do qubit B é afetado?

• a. O qubit B é afetado instantaneamente, dentro da tolerância experimental, nos experimentos realizados até agora.
• b. O qubit B é afetado após um tempo $d/c$, o que significa que o estado quântico "colapsa" aproximadamente à velocidade da luz, dentro da tolerância experimental.
• c. O qubit B é afetado somente após a ocorrência da comunicação clássica, o que significa que acontece em um tempo maior do que $d/c$.
• d. Nenhuma das anteriores

2. Lembre-se de que a probabilidade de medição está relacionada às amplitudes nos estados quânticos. Por exemplo, se um qubit está inicialmente no estado $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ a probabilidade de medir o estado $|0\rangle$ é $|\alpha_0|^2.$ Nem todos os conjuntos de medições vão corresponder exatamente a essas probabilidades, devido à amostragem finita (assim como lançar uma moeda pode resultar em cara duas vezes seguidas). O histograma de medição abaixo poderia corresponder a qual dos seguintes estados quânticos? Selecione a melhor opção.

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

3. Quais dos seguintes estados mostram os qubits A e B entrelaçados? Selecione todos que se aplicam.

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

4. Neste módulo, preparamos um estado entrelaçado: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Mas há muitos outros estados entrelaçados que poderiam ser usados para um protocolo semelhante. Qual dos estados abaixo poderia produzir um histograma de medição de 2 qubits como o seguinte? Selecione a melhor resposta.

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

Questões para discussão

1. Descreva o protocolo de teleportação quântica, do início ao fim, para seu parceiro/grupo. Veja se eles têm algo a acrescentar ou se têm dúvidas.

2. Há algo único no estado entrelaçado inicial entre Alice e Bob: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Se sim, o que é único nele? Se não, quais outros estados entrelaçados poderíamos ter usado?