Teleportação quântica

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

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

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

Esse módulo foi testado e usou 14 segundos de tempo de QPU. Essa é apenas uma estimativa. Seu uso real pode variar.

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

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

Introdução e antecedentes

O teletransporte quântico é uma técnica da física quântica que permite a transferência de informações quânticas de um local para outro sem mover fisicamente as partículas. Ao contrário do conceito de ficção científica de teletransporte, esse processo não envolve o transporte de matéria. Em vez disso, ele se baseia no princípio do entrelaçamento quântico, em que duas partículas ficam ligadas independentemente da distância. Por meio de uma série de medições precisas e 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" as informações quânticas. 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 obter mais informações sobre informações quânticas e mais explicações sobre teletransporte, recomendamos o curso de John Watrous sobre os fundamentos das informações quânticas e, em especial, a seção sobre teletransporte.

Os bits clássicos podem estar nos estados 0 ou 1. Os bits quânticos (qubits) podem estar em estados quânticos denotados $|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 o "colapsará" nos estados $|0\rangle$ ou $|1\rangle$. Os parâmetros $a$ e $b$ estão relacionados à probabilidade de cada resultado de medição de acordo com

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

Outro recurso importante é 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 entrelaçamento é diferente das correlações clássicas simples é um pouco complicado. Vamos primeiro explicar nossa notação. Chame dois qubits pertencentes ao amigo 0 (Alice) e ao amigo 1 (Bob), e cada um no estado $|0\rangle$

ou

às vezes abreviado para simplesmente

Observe que o qubit com o menor número (ou letra) está mais à direita. Essa é uma convenção chamada 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 deles encontrará um 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

Em um estado como esse, o fato de Alice e Bob terem qubits no estado 0 ou 1 ainda não é conhecido, nem mesmo determinado pela natureza, mas sabemos que eles medirão o mesmo estado para seus qubits. Por exemplo, se Bob medir que seu qubit está no estado $|0\rangle,$, a única maneira 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 entrelaçamento 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 considerados 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 ficam sabendo disso pela primeira vez é sobre a violação da relatividade: podemos usar isso para enviar informações mais rapidamente do que a luz? Por todos os meios, continue questionando e investigando as regras científicas, mas, infelizmente, isso não nos permitirá enviar informações mais rapidamente do que a luz, por motivos que ficarão claros no decorrer deste módulo. Spoiler: surpreendentemente, NÃO é devido à velocidade com que esse colapso se propaga, o que parece acontecer mais rápido que a luz [1].

Começamos com dois colaboradores, Alice e Bob, que estão inicialmente no mesmo local e podem trabalhar juntos nos mesmos qubits. Esses colaboradores emaranharão seus qubits. Em seguida, eles se afastarão para dois locais geográficos diferentes, levando seus respectivos qubits com eles. Alice então obterá informações quânticas em um novo qubit Q. Não fazemos suposições sobre as informações sobre Q. O estado de Q pode ser um segredo desconhecido por Alice; pode ser desconhecido por todas as pessoas. Mas Alice tem a tarefa de transferir as informações sobre 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 já estiver familiarizado com as portas quânticas. Se você quiser entender melhor essas portas, consulte Noções básicas de informação quântica, especialmente as duas primeiras lições, em IBM Quantum Learning.

Para esse protocolo de teletransporte, usaremos principalmente dois tipos de portas quânticas: a porta Hadamard e a porta CNOT. Algumas outras desempenharã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, a visualização de portas mecânicas quânticas usando matrizes e vetores pode ser útil. Portanto, também apresentamos aqui as formas de matriz/vetor de portas/estados quânticos.

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

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

Há algumas opções de como estender a notação para estados de múltiplos qubits, mas a opção abaixo é bastante padrão:

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

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

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

from qiskit import QuantumCircuit

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

Output:

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

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

Uma porta CNOT tem uma aparência um pouco diferente em um circuito, pois requer dois qubits. É assim que ele é implementado:

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

Output:

Verifique sua compreensão

A maioria das portas tem a mesma forma matricial no Qiskit, assim como em qualquer outro lugar. Mas a porta CNOT atua sobre dois qubits e, por isso, de repente, as convenções de ordenação dos qubits tornam-se um problema. Os textos que tratam de qubits $|q_0,q_1,...\rangle$ apresentam uma forma matricial diferente para suas portas CNOT. Verifique, por meio de multiplicação matricial explícita, se 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$

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

No Qiskit, a criação de um circuito com uma porta $X$ tem a seguinte aparência:

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

Output:

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

No Qiskit, a criação de um circuito com uma porta $Z$ tem a seguinte aparência:

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

Output:

teoria

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

Alice e Bob emaranham seus qubits: Inicialmente, o qubit de Alice e o qubit de Bob estão cada um, separadamente, no estado $|0\rangle$ (uma boa suposição 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 agem com a porta Hadamard no qubit de Alice e, em seguida, uma porta CNOT com o qubit de Alice como controle e o de Bob como alvo:

Observe que agora os qubits de Alice e Bob estão emaranhados. Embora ainda não esteja determinado pela natureza se ambos os qubits estão no estado $|0\rangle$ ou no estado $|1\rangle$, sabe-se que seus qubits estão no mesmo estado.

Alice e Bob se separam: Os dois amigos movem seus qubits para novos locais, possivelmente muito distantes um do outro. Isso vem com muitas ressalvas: não é trivial mover informações quânticas sem perturbá-las. Mas ela pode ser movida e, de fato, você a moverá neste módulo. Mas lembre-se de que esperamos encontrar alguns erros quando movimentamos muito as informações quânticas.

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

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

O objetivo é mover as informações sobre Q do local de Alice para o local de Bob. Neste momento, não estamos fazendo nenhuma reivindicação ou exigência sobre sigilo ou velocidade de transferência de informações. Estamos simplesmente explorando como as informações podem passar de Alice para Bob.

Como as informações começam em Q, assumiremos que Q é atribuído ao número mais baixo em números de qubit, de modo que a notação little endian faz com que Q seja o qubit mais à direita na matemática abaixo.

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

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:

Verifique sua compreensã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 descobrir que seus qubits estão 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 geram estados diferentes para Bob. Elas estão reunidas na tabela abaixo.

Para todos os resultados possíveis de medição nos qubits de Alice, o qubit de Bob é deixado em um estado vagamente parecido com o 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 é deixado exatamente no estado secreto! Em outros casos, há algo de errado com o estado. Os coeficientes ( $\alpha$ 's) estão trocados, ou há um sinal "-" onde deveria haver um sinal "+", ou ambos. Para modificar o qubit de Bob e torná-lo exatamente igual ao estado secreto, Alice deve 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 são trocados. Se Alice ligar para Bob e pedir que ele aplique uma porta $X$ ao seu qubit, ele mudará um $|0\rangle$ para um $|1\rangle$ e vice-versa, e o estado secreto será revelado.

Agora deve estar claro por que não podemos usar essa configuração para enviar informações mais rapidamente 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 ligamos para ele e dizemos: "Medimos $|0\rangle_A|0\rangle_Q$, então você não precisa fazer nada"

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

Experimento 1: Teletransporte básico

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

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

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

Toda a matemática que fizemos acima estava delineando a etapa 1. Vamos implementá-lo 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. Consideraremos que esses são os qubits 1 e 2, e reservaremos 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")

Output:

Isso é tudo o que precisamos fazer para que o estado de Alice seja teletransportado para Bob. No entanto, lembre-se de que, quando medimos um estado quântico $\alpha_0 |0\rangle+\alpha_1|1\rangle$, encontramos $|0\rangle$ ou $|1\rangle.$. Portanto, no final de tudo isso, Bob definitivamente tem o estado secreto de Alice, mas não podemos verificar isso facilmente com uma medição. Para que uma medição nos diga que fizemos isso corretamente, temos que fazer um truque. Tínhamos um operador rotulado como "U" para "unitário", que usamos para preparar o estado secreto de Alice. Podemos aplicar o inverso de U no final do nosso circuito. Se U mapeou o estado $|0\rangle$ de Alice para $\alpha_0 |0\rangle+\alpha_1|1\rangle$, então o inverso de U mapeará o estado $\alpha_0 |0\rangle+\alpha_1|1\rangle$ de Bob de volta para $|0\rangle.$. Portanto, essa última parte não seria necessariamente realizada se o objetivo fosse apenas mover informações quânticas. Isso é feito apenas para que possamos nos verificar.

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

Output:

Portanto, se tivermos feito isso corretamente, nossa medição no qubit de Bob deverá produzir um estado $|0\rangle$. Obviamente, essas medições são probabilísticas. Portanto, se houver uma pequena chance de medir o qubit de Bob para que ele esteja no estado $|1\rangle$, então uma única medição poderia resultar em $|1\rangle.$. Realmente gostaríamos de fazer muitas medições para ter certeza de que a probabilidade de $|0\rangle$ é bastante alta.

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

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

Começaremos carregando vários pacotes que são necessários para a comunicação com os computadores quânticos do IBM. Também devemos selecionar um backend para execução. Podemos escolher o backend menos ocupado ou selecionar um backend específico cujas propriedades conhecemos.

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

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',
# instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

Output:

ibm_sherbrooke

Habilitamos explicitamente a lógica nas 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 subetapas e é um tópico fascinante. Apenas para dar um exemplo de uma subetapa: nem todos os computadores quânticos podem implementar diretamente todas as portas lógicas no Qiskit. Devemos escrever as portas de nosso circuito em termos de portas que o computador quântico pode implementar. Podemos realizar esse processo e outros, usando um gerenciador de passes predefinido. A configuração de optimization = 3 (o nível mais alto de otimização) garante que o mapeamento de nosso circuito quântico abstrato para as instruções fornecidas ao computador quântico seja tão eficiente quanto nosso pré-processamento possa obtê-lo.

# 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 "amostrador" é um primitivo projetado 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 o Qiskit Runtime Sampler para cá:

# 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 razoavelmente simulados em computadores clássicos. Esse simples teletransporte definitivamente pode ser, mas não é de todo surpreendente que possamos classicamente salvar informações em um lugar ou outro. É altamente recomendável realizar esses cálculos usando um computador quântico real IBM. Mas caso você tenha esgotado seu uso mensal gratuito, ou se algo precisar ser concluído em sala de aula e não puder esperar na fila, esse módulo pode ser concluído usando um simulador. Para fazer isso, basta executar a célula abaixo e descomentar as linhas associadas nas etapas "Execute".

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

Passo 3: Executar

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

Output:

Verifique sua compreensão

Quais dos estados acima indicam um teletransporte bem-sucedido, e como é possível saber?

• Resposta

  Os estados $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ são todos consistentes com o teletransporte bem-sucedido. Isso ocorre porque adicionamos um portão para desfazer a preparação inicial do estado secreto. Se o estado secreto foi teletransportado com sucesso para o qubit de Bob, esse portão adicional deve retornar o qubit de Bob para o estado $|0\rangle$. Portanto, qualquer estado acima com o qubit de Bob (qubit 0, também medido como o 0º componente do registro clássico e, portanto, o mais alto/mais à direita) no estado $|0\rangle$ indica sucesso.

Esse gráfico mostra todos os resultados de medição dos três qubits, em mais de 5.000 tentativas ou "disparos". Já mencionamos anteriormente que Alice mediria todos os estados possíveis dos qubits A e Q com a mesma probabilidade. Atribuímos os qubits 0-2 do 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 fato de o qubit de Bob ser $|0\rangle$ e os outros dois qubits estarem em todas as combinações possíveis com probabilidade aproximadamente igual. Observe 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á um punhado de disparos (~5%) que produziram o qubit de Bob no estado $|1\rangle$. Logicamente, isso não deveria ser possível. Entretanto, todos os computadores quânticos modernos sofrem com ruídos 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: Teletransporte através de um processador

Sem dúvida, a parte mais interessante do teletransporte quântico é que um estado quântico pode ser teletransportado instantaneamente por longas distâncias (embora a comunicação clássica de portas extras não seja instantânea). Como já foi dito, não podemos separar os qubits do processador e movê-los. Mas podemos mover as informações de um qubit para outro, até que os qubits envolvidos no teletransporte estejam em lados opostos do processador. Vamos repetir as etapas anteriores, mas agora faremos um circuito maior com qubits suficientes para abranger o processador.

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

Dessa vez, os qubits correspondentes a Alice e Bob serão alterados. Portanto, não nomearemos um único qubit como "A" e outro como "B". Em vez disso, numeraremos os qubits e usaremos variáveis para representar a posição atual das informações nos qubits pertencentes a Alice e Bob. Todas as outras etapas, exceto as portas de troca, 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")

Output:

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

Passo 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 o mais eficientes possível. Nesse caso, não há razão computacional para transferirmos os estados dos qubits 6 e 7 para os qubits 1 e 12. Isso foi apenas algo que fizemos para demonstrar o teletransporte à distância. Se pedirmos ao gerenciador de passagens para otimizar nosso circuito, ele perceberá que não há motivo lógico para essas portas de troca e as removerá e executará as operações de porta em qubits adjacentes. Portanto, para esse 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())

Output:

105

Podemos visualizar em que parte do processador quântico esses qubits estão usando a função plot_circuit_layout .

Passo 3: Executar

Como antes, recomendamos a execução em computadores quânticos reais IBM. Se o seu uso mensal gratuito tiver sido atingido, sinta-se à vontade para descomentar as células do simulador para 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)

Output:

Etapa 4: Pós-processamento clássico

Novamente, vemos que as probabilidades dos 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$ depois de inverter o código secreto, o que significa que há uma forte probabilidade de que tenhamos teletransportado corretamente o estado secreto pelo processador de Q para Bob (qubits 0 a 12). No entanto, observamos que agora há uma chance maior de não medir $|0\rangle$ para Bob. Essa é uma lição importante na computação quântica: quanto mais portas você tiver, especialmente portas de vários qubits, como as portas de troca, mais ruído e erros você encontrará.

Perguntas

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

Conceitos críticos

• Os qubits podem ser emaranhados, o que significa que a medição de um qubit afeta ou até determina o estado de outro qubit.
• O entrelaçamento é diferente das correlações clássicas; por exemplo, os qubits A e B poderiam estar em uma superposição de estados como $\alpha_0|00\rangle+\alpha_1|11\rangle.$. O estado de A ou B poderia ser indeterminado pela natureza e, ainda assim, seria possível garantir que A e B estivessem no mesmo estado.
• Por meio de uma combinação de emaranhados e medições, podemos transferir um estado (que pode armazenar informações) de um qubit para outro. Essa transferência pode ser feita até mesmo em longas distâncias, e isso é chamado de teletransporte quântico.
• O teletransporte quântico se baseia em medições quânticas, que são probabilísticas. Assim, a comunicação clássica pode ser necessária para ajustar os estados teletransportados. Isso impede que o teletransporte quântico mova as informações mais rapidamente do que a luz. O teletransporte quântico não viola a relatividade ou a causalidade.
• Os computadores quânticos modernos são mais suscetíveis a ruídos e erros do que os computadores clássicos. Espere um erro de alguns por cento.
• Quanto mais portas você adicionar em sequência (especialmente portas de 2 qubits), mais erros e ruídos você poderá esperar.

Questões de verdadeiro/falso

1. T/F O teletransporte quântico pode ser usado para enviar informações mais rapidamente do que a luz.
2. T/F As evidências modernas sugerem que o colapso de um estado quântico se propaga mais rápido que a luz.
3. T/F No Qiskit, os qubits são ordenados em estados com o qubit de menor número à direita, como em $|q_3,q_2,q_1, q_0\rangle$

Perguntas do MC

1. Os Qubits A e B são emaranhados e, em seguida, separados por uma grande distância $d$. O Qubit A é medido. Qual afirmação está correta sobre a velocidade na qual o estado do qubit B é afetado?

• a. O Qubit B é afetado instantaneamente, dentro da tolerância experimental, nos experimentos realizados até o momento.
• b. O Qubit B é afetado após um tempo $d/c$, o que significa que o estado quântico "entra em colapso" aproximadamente na 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 ela ocorre em um tempo maior que $d/c$.
• d. Nenhuma das opções acima

2. Lembre-se de que a probabilidade de medição está relacionada a amplitudes em estados quânticos. Por exemplo, se um qubit estiver 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 corresponderão exatamente a essas probabilidades, devido à amostragem finita (assim como o lançamento de 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. Qual dos seguintes estados mostra que os qubits A e B estão emaranhados? Selecione todas as opções 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 emaranhado: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Mas há muitos outros estados emaranhados que poderiam ser usados em um protocolo semelhante. Qual dos estados abaixo poderia gerar 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 teletransporte quântico, do início ao fim, para seu parceiro/grupo. Veja se eles têm algo a acrescentar ou se têm perguntas.

2. Há algo de exclusivo no estado inicial emaranhado entre Alice e Bob: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Em caso afirmativo, o que há de único nele? Se não, que outros estados emaranhados poderíamos ter usado?