entangled-states.ipynb

Kernel: Python 3

Estados emaranhados

Estados de produto e estados emaranhados

Nas seções anteriores, já vimos como expressar estados multi-qubit como vetores. Por exemplo, aqui está o vetor de estado para dois qubits,

ParseError: KaTeX parse error: Undefined control sequence: \cssId at position 1: \̲c̲s̲s̲I̲d̲{_ket-psi}{|\ps…

O que não vimos até agora é a estrutura dessas superposições e como isso afeta seu comportamento e para que podem ser usadas. Por exemplo, considere os dois estados a seguir.

ParseError: KaTeX parse error: Undefined control sequence: \cssId at position 1: \̲c̲s̲s̲I̲d̲{_ket-plus-0}{|…

De relance, eles podem parecer bastante semelhantes. Ambos são uma superposição igualmente ponderada de duas strings de bits diferentes. No entanto, vamos dar uma olhada mais de perto.

Em particular, vejamos o estado $|{+}{0} \rangle$. Este é composto por dois termos:

• $|00\rangle$: Ambos os qubits estão no estado $|0\rangle$;

• $|10\rangle$: Os estados do qubit são $|1\rangle$ (à esquerda) e $|0\rangle$ (à direita).

Ambos os termos contam a mesma história para o qubit à direita: está no estado $|0\rangle$. Com isso em mente, vemos que toda a superposição neste estado pertence ao outro qubit. Especificamente, o qubit à esquerda pode ser descrito pelo único estado de qubit ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{ket-plus}{|+\r….

Portanto, o estado $|{+}0\rangle$ é um vetor de estado de dois qubits que realmente descreve um par de estados de um único qubit: ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{ket-plus}{|+\r… e $|0\rangle$ .

Lembrete

Pedido de Qubit No código Qiskit, qubits e bits são indexados de 0 e numerados da direita para a esquerda. Então, para um estado de quatro qubits como $|1000\rangle$, os quatro qubits são numerados 0, 1, 2 e 3. É o qubit 3 que está no estado $|1\rangle$, enquanto o resto está no estado $| 0\rângulo$. Isso ocorre por design, de modo que o índice do qubit também é a potência de 2 que ele representa.

Questionário rápido

Suponha que você tenha dois qubits, com qubit 0 no estado ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{ket-plus}{|+\r…, qubit 1 no estado ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{ket-minus}{|-\…. Que estado de dois qubits representaria isso?

1. $|{+}{-}\rangle$

1. $|{-}{+}\rangle$

1. $|0\rangle$

Estados de produto

O $|{+}0 \rangle$ é um exemplo de um tipo de estado multi-qubit conhecido como 'estado de produto'. Estes representam casos que podem alternativamente ser escritos como uma sequência de estados de qubit únicos.

Para uma forma geral de estados de produto de dois qubits, precisamos começar com dois estados gerais de um único qubit,

ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{_ket-vague}{|a…

Usaremos $|ba\rangle$ para nos referirmos ao estado combinado de produto destes, onde $|a\rangle$ representa o qubit à direita e $|b\rangle$ é o da esquerda. Podemos escrever isso como:

$$|b , a\rangle = \begin{bmatrix} b_0 a_0 \ b_0 a_1 \ b_1 a_0 \ b_1 a_1 \end{bmatrix}.$$

Novamente, essas regras seguem as regras de probabilidade padrão: Se quisermos encontrar a probabilidade de dois eventos não relacionados ocorrerem, multiplicamos suas probabilidades. Para estender essa regra à mecânica quântica, apenas trocamos probabilidades com amplitudes. Portanto, a amplitude do estado $|00\rangle$ é a amplitude do qubit $a$ ser $|0\rangle$, multiplicada pela amplitude do qubit $b$ ser $|0\rangle$.

Vamos verificar se isso funciona: Suponha que ambos os qubits sejam medidos, qual é a probabilidade de que o qubit à direita seja 0 ? Esta será a soma das probabilidades para os dois resultados que têm um 0 à direita, ou seja, 00 e 10 ,

ParseError: KaTeX parse error: Undefined control sequence: \cssId at position 1: \̲c̲s̲s̲I̲d̲{*pa0}{p*{|a\ra…

Agora podemos substituir nos cálculos por esses estados dados acima e fazer álgebra simples

ParseError: KaTeX parse error: Undefined control sequence: \cssId at position 49: …rangle) &= \̲c̲s̲s̲I̲d̲{_p00}{(b_0 a_0…

Isso nos dá exatamente o que obteríamos com apenas o cálculo de um único qubit. Usando este método, você também encontraria $p_{|b\rangle}(|0\rangle) = b_0^2$.

Estados emaranhados

Agora vamos olhar novamente para o estado $|\Phi^+ \rangle$,

$$|\Phi^+ \rangle = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 \ 0 \ 0 \ 1 \end{bmatrix} = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle).$$

Não há pares de estados de qubit únicos $|a \rangle$ e $|b\rangle$ cujo estado de produto seria assim. Experimente você mesmo tentando encontrar os valores $b_0$, $b_1$, $c_0$ e $c_1$ que correspondam a $|\Phi^{+} \rangle$. Você verá que não é possível!

Isso representa um tipo diferente de estado de dois qubits, distinto dos estados de produto, que não podem ser descritos como uma combinação de estados simples de um único qubit. Estes são conhecidos como estados emaranhados .

Questionário rápido

A qual destes estados de produto corresponde o estado a seguir?

$$\frac{1}{2} \begin{bmatrix} 1 \ -1 \ -1 \ 1 \end{bmatrix}$$

1. $|{+}{-}\rangle$

1. $|{-}{-}\rangle$

1. $|{-}{+}\rangle$

Questionário rápido

Qual dos seguintes estados está emaranhado?

1. $\frac{1}{2} \begin{bmatrix} 1 \\ -1 \\ -1 \\ 1 \end{bmatrix}$

1. $\frac{1}{\sqrt{2}} \begin{bmatrix} 1 \\ 1 \\ 0 \\ 0 \end{bmatrix}$

1. $\frac{1}{\sqrt{2}} \begin{bmatrix} 0 \\ 1 \\ 1 \\ 0 \end{bmatrix}$

Portas emaranhantes

Computações quânticas geralmente começam em um estado de produto. Especificamente, eles começam no estado de produto mais simples de todos, onde todos os qubits estão no estado $|0\rangle$.

Se aplicarmos apenas estados de qubit únicos, manipularemos esses estados de um qubit. Alguns podem ser girados para $|+\rangle$ por um Hadamard, ou uma superposição mais complexa por uma rotação mais geral. Mas, no entanto, eles permanecerão em um estado de produto.

Para criar emaranhamento, precisamos aplicar portas multi-qubit. Os mais proeminentes são as portas controladas, sendo as portas cx e cz os exemplos mais simples.

A porta cx

Para ver a porta cx em ação, vamos começar com o estado de dois qubits $|00\rangle$.

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)

# This calculates what the state vector of our qubits would be
# after passing through the circuit 'qc'
ket = Statevector(qc)

# The code below writes down the state vector.
# Since it's the last line in the cell, the cell will display it as output
ket.draw()

$$|00\rangle$$

(Na saída da célula acima, os vetores de estado são desenhados horizontalmente em vez de verticalmente, como geralmente os desenhamos, mas eles significam a mesma coisa aqui).

A porta cx atua em dois qubits, que são conhecidos como 'controle' e 'alvo'. Vamos primeiro tentar usar o qubit 0 como controle e o qubit 1 como alvo e ver o que acontece.

qc.cx(0,1)

ket = Statevector(qc)
ket.draw()

$$|00\rangle$$

Esta porta cx não teve efeito. O estado permanece $|00\rangle$.

Agora vamos tentar com o controle e o alvo invertidos.

qc.cx(1,0)

ket = Statevector(qc)
ket.draw()

$$|00\rangle$$

Novamente, nenhum efeito!

Este desempenho decepcionante da porta cx é realmente esperado. Podemos interpretar sua ação como condicional ao estado do qubit de controle: se o controle estiver no estado $|0\rangle$, a cx não faz nada. Se o controle estiver no estado $|1\rangle$, a cx executa uma x no qubit de destino.

Então, se queremos ver a porta cx fazer algo, precisamos inverter o qubit de controle para o estado $|1\rangle$.

qc.x(1,0)

ket = Statevector(qc)
ket.draw()

$$|10\rangle$$

Agora, quando executamos uma porta cx , ela também inverte o qubit de destino.

qc.cx(1,0)

ket = Statevector(qc)
ket.draw()

$$|11\rangle$$

Até agora, ainda não vimos nenhum emaranhamento. Isso ocorre quando o qubit de controle não é apenas um simples $|0\rangle$ ou $|1\rangle$, mas uma superposição dos dois. Por exemplo, suponha que temos o estado $|{+}{0}\rangle$ anterior.

# Let's create a fresh quantum circuit
qc = QuantumCircuit(2)

qc.h(1)

ket = Statevector(qc)
ket.draw()

$$\frac{\sqrt{2}}{2} |00\rangle+\frac{\sqrt{2}}{2} |10\rangle$$

Agora se aplicarmos a porta cx , ela atuará em paralelo nos dois estados. Ela deixará o estado $|00\rangle$ inalterado, já que o qubit de controle está no estado $|0\rangle$. Mas o $|10\rangle$ tem o controle no estado $|1\rangle$, então o alvo é invertido para fazer o estado $|11\rangle$.

qc.cx(1,0)

ket = Statevector(qc)
ket.draw()

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

O resultado é nosso estado emaranhado favorito: $|\Phi^+ \rangle$. A porta cx criou emaranhamento!

A porta cz

A cz é uma porta cujo efeito é bastante semelhante à cx . Ela também atua em dois qubits: o alvo e o controle. Também não faz nada quando o qubit de controle está no estado $|0\rangle$. Mas para o estado de controle $|1\rangle$, ela executa uma z para o destino.

Ou pelo menos, essa é a interpretação padrão desta porta. Mas se pensarmos um pouco mais, veremos que outra interpretação também é possível.

A porta z aplicada a um único qubit tem o efeito de não fazer nada para $|0\rangle$, e dar uma fase de $-1$ ao estado $|1\rangle$. Portanto, para a porta cz , ela só tem algum efeito quando ambos os qubits estão no estado $|1\rangle$. Não importa o que decidimos rotular e 'controle' e 'alvo', o efeito é o mesmo. Poderíamos igualmente tê-la definido como a porta que não faz nada quando o estado de alvo é $|0\rangle$ e, caso contrário, executa uma z no controle .

O fato de a mesma porta poder ser interpretada de duas maneiras aparentemente contraditórias é apenas uma expressão dos efeitos interessantes que veremos com estados emaranhados.

A porta cx revisitada

A porta cx também é conhecida como controlled-X ou controlled-NOT, devido ao seu efeito de inverter o bit de destino com base no estado do controle. No entanto, assim como vimos com a porta cx , outras interpretações também são possíveis.

Por exemplo, vamos começar com o caso em que ambos os qubits estão no estado $|+ \rangle$.

qc = QuantumCircuit(2)

qc.h(0)
qc.h(1)

ket = Statevector(qc)
ket.draw()

$$\frac{1}{2} |00\rangle+\frac{1}{2} |01\rangle+\frac{1}{2} |10\rangle+\frac{1}{2} |11\rangle$$

Aqui também descobriremos que a cx não tem efeito, não importa de que maneira o façamos.

qc.cx(1,0)

ket = Statevector(qc)
ket.draw()

$$\frac{1}{2} |00\rangle+\frac{1}{2} |01\rangle+\frac{1}{2} |10\rangle+\frac{1}{2} |11\rangle$$

No entanto, vamos agora inverter o qubit alvo de $|+\rangle$ para $|-\rangle$ usando a porta de um qubit z.

qc.z(0)

ket = Statevector(qc)
ket.draw()

$$\frac{1}{2} |00\rangle- \frac{1}{2} |01\rangle+\frac{1}{2} |10\rangle- \frac{1}{2} |11\rangle$$

Se fizermos a cx agora, veremos um efeito. Ela também inverte o qubit de controle para $|-\rangle$.

qc.cx(1,0)

ket = Statevector(qc)
ket.draw()

$$\frac{1}{2} |00\rangle- \frac{1}{2} |01\rangle- \frac{1}{2} |10\rangle+\frac{1}{2} |11\rangle$$

Esse efeito às vezes é conhecido como 'retorno de fase': quando há uma superposição nos qubits de controle e de destino, algumas características da superposição do alvo podem realimentar o controle.

Esse efeito também pode nos motivar a fazer uma interpretação alternativa da cx . Podemos pensar nisso como aplicar uma z ao controle se o alvo estiver no estado $|-\rangle$, e não fazer nada se estiver no estado $|+\rangle$.

O poder do emaranhamento

O emaranhamento é um ingrediente chave de muitos aspectos da computação quântica. Ele potencializa os algoritmos e métodos que usamos e é uma parte necessária de qualquer vantagem quântica. Para ter uma ideia de por que isso acontece, vamos dar alguns exemplos específicos de emaranhamento.

Estados emaranhados e simulação

Para descrever completamente o estado de $n$ qubits, podemos precisar acompanhar amplitudes de até $2^n$. Como esses vetores crescem exponencialmente com o número de qubits, computadores quânticos com grande número de qubits tornam-se muito difíceis de simular. Um laptop moderno pode lidar facilmente com amplitudes de $2^{20}$ (o máximo necessário para 20 qubits), mas processar amplitudes de $2^{100}$ (o máximo necessário para 100 qubits) é muito difícil até mesmo para os maiores supercomputadores.

Mas às vezes há uma maneira mais inteligente. Por exemplo, suponha que começamos em um estado de produto. Isso significa que cada qubit pode ser descrito independentemente por um único estado de qubit com duas amplitudes.

Agora suponha que executamos um circuito com apenas portas de um qubit. Essas manipulações podem ser facilmente descritas modificando os estados de um qubit, o que significa fazer alterações nos pares específicos de amplitudes afetadas. Então, quando cada qubit é medido, a probabilidade do resultado 0 ou 1 para cada qubit é determinada por suas respectivas amplitudes.

Durante esse processo, os estados permaneceram como estados de produto. Como tal, nunca houve realmente um cálculo de $n$ qubits, mas sim cálculos separados de um único qubit $n$. Isso torna possível calcular tudo com $2 n$ amplitudes, em vez das $2^n$ totais. Para tais situações, simular milhares de qubits seria fácil até para o seu telefone.

Algoritmos quânticos úteis precisam ser capazes de fazer coisas que os computadores clássicos não podem simular, então eles devem funcionar de uma maneira que impeça que truques como esse sejam encontrados. Eles devem envolver manipulações mais complexas dos qubits, criando estados para os quais não há atalhos fáceis. Isso significa que eles devem usar estados para os quais a descrição completa da amplitude $2^n$ é necessária e, portanto, precisarão envolver mais do que apenas estados de produto. E como qualquer coisa que não seja um estado de produto é um estado emaranhado, descobrimos que o emaranhamento é um ingrediente necessário de qualquer vantagem quântica.

Qubits trabalhando juntos: codificação superdensa

Veremos agora um exemplo prático de emaranhamento usando um protocolo para comunicação quântica. Como a computação quântica, isso é baseado na manipulação de qubits com portas quânticas. Mas também incorpora a ideia de qubits sendo transmitidos entre diferentes partes e explora aplicações baseadas no envio de informações em vez de se processamento.

Para a comunicação clássica, há um limite fundamental de quanta informação podemos enviar com um determinado número de bits. Por definição, não podemos enviar mais do que $n$ bits de informação quando enviamos $n$ bits. Para informações quânticas, a mesma regra se aplica: não mais do que $n$ bits de informação podem ser codificados de forma confiável e recuperados de $n$ qubits. No entanto, existem maneiras de ultrapassar os limites para fazer coisas que não são classicamente possíveis e, para isso, precisamos de emaranhamento. Aqui veremos um exemplo, no qual a transferência de um qubit pode permitir que uma mensagem de dois bits seja enviada.

Suponha que temos duas pessoas, Alice e Bob. Alice deseja enviar uma mensagem de dois bits para Bob - 00 , 01 , 10 ou 11 - e deseja fazê-lo enviando qubits.

A maneira mais simples de fazer isso é com dois qubits. Alice pode simplesmente usar os qubits para codificar os valores dos bits, aplicando uma porta x para invertê-los para um estado 1 .

# The message
MESSAGE = '00'

# Alice encodes the message
qc_alice = QuantumCircuit(2, 2)
if MESSAGE[-1]=='1':
    qc_alice.x(0)
if MESSAGE[-2]=='1':
    qc_alice.x(1)

Depois que Alice envia os qubits para Bob, tudo o que ele precisa fazer é medi-los.

from qiskit import Aer
backend = Aer.get_backend('aer_simulator')

# Bob measures
qc_bob = QuantumCircuit(2,2)
qc_bob.measure([0,1],[0,1])

backend.run(qc_alice.compose(qc_bob)).result().get_counts()

{'00': 1024}

O resultado obtido por Bob será exatamente o que Alice colocou.

Este protocolo não envolveu qualquer emaranhamento. Uma maneira de inseri-lo seria Alice adicionar portas h e cx após codificar as informações. Vejamos os estados que são criados por essas portas.

MESSAGE = '00'

qc_alice = QuantumCircuit(2,2)

# Alice encodes the message
if MESSAGE[-1]=='1':
    qc_alice.x(0)
if MESSAGE[-2]=='1':
    qc_alice.x(1)

# then she creates entangled states
qc_alice.h(1)
qc_alice.cx(1,0)

ket = Statevector(qc_alice)
ket.draw()

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

Para uma mensagem 00 , o estado criado por essas portas é $|\Phi^+ \rangle$. Para as outras mensagens, obtemos outros estados emaranhados, conhecidos como $|\Phi^- \rangle$, $|\Psi^+ \rangle$ e $|\Psi^- \rangle$.

$$\mathtt{00} \rightarrow |\Phi^+ \rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle) \ \mathtt{01} \rightarrow |\Psi^+ \rangle = \frac{1}{\sqrt{2}}(|01\rangle+|10\rangle) \ \mathtt{10} \rightarrow |\Phi^- \rangle = \frac{1}{\sqrt{2}}(|00\rangle-|11\rangle) \ \mathtt{11} \rightarrow |\Psi^- \rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$$

Quando Bob recebe esses estados, ele precisa desemaranhá-los, desfazendo a porta h e a porta cx . Então ele pode medir e recuperar a mensagem como antes.

qc_bob = QuantumCircuit(2,2)
# Bob unentangles
qc_bob.cx(1,0)
qc_bob.h(1)
# Then measures
qc_bob.measure([0,1],[0,1])

Então aqui usamos estados emaranhados, mas eles não nos deram nenhuma vantagem. Para isso, precisamos olhar para a relação entre esses quatro estados emaranhados.

Por exemplo, o estado $|\Phi^+ \rangle$ é uma superposição de $|00\rangle$ e $|11\rangle$, enquanto $|\Psi^+ \rangle$ é uma superposição de $|01\ rangle$ e $|10\rangle$. Portanto, uma porta x simples em qualquer qubit é suficiente para girar um $|\Phi^+ \rangle$ em $|\Psi^+ \rangle$ e vice-versa. O mesmo vale para a rotação entre $|\Phi^- \rangle$ para $|\Psi^- \rangle$. Da mesma forma, a diferença entre $|\Phi^+ \rangle$ e $|\Phi^- \rangle$ é simplesmente a fase relativa, que pode ser alterada por uma porta z em qualquer qubit, e o mesmo com $|\Psi^+ \rangle$ e $|\Psi^- \rangle$. Assim, Alice poderia enviar sua mensagem criando primeiro um estado emaranhado e depois alterando-o usando portas x e z para codificar a mensagem correta.

MESSAGE = '00'

qc_alice = QuantumCircuit(2,2)
qc_alice.h(1)
qc_alice.cx(1,0)

if MESSAGE[-2]=='1':
    qc_alice.z(1)
if MESSAGE[-1]=='1':
    qc_alice.x(1)

ket = Statevector(qc_alice)
ket.draw()

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

Como Bob está recebendo os mesmos estados de antes, ele não precisa alterar seu circuito.

backend.run(qc_alice.compose(qc_bob)).result().get_counts()

{'00': 1024}

O importante a notar aqui é que as portas x e z podem ser aplicadas a apenas um único qubit (qubit 1 neste caso). Isso significa que Alice poderia enviar o qubit 0 para Bob assim que ela criasse o par emaranhado. Na verdade, ela poderia enviá-lo antes mesmo de saber qual mensagem deseja enviar!

Isso fica ainda mais surpreendente se você imaginar um terceiro, cujo trabalho é apenas criar estados $|\Phi^+ \rangle$ e enviar os qubits.

qc_charlie = QuantumCircuit(2,2)

qc_charlie.h(1)
qc_charlie.cx(1,0)

Esse terceiro pode enviar diretamente um qubit para Bob e depois o outro para Alice. Alice pode codificar sua mensagem de dois qubits manipulando apenas esse único qubit e enviar apenas esse qubit para Bob.

MESSAGE = '01'

qc_alice = QuantumCircuit(2,2)

if MESSAGE[-2]=='1':
    qc_alice.z(1)
if MESSAGE[-1]=='1':
    qc_alice.x(1)

Agora Bob pode aplicar o mesmo processo de antes e extrair a mensagem de seus dois qubits.

complete_qc = qc_charlie.compose(qc_alice.compose(qc_bob))
backend.run(complete_qc).result().get_counts()

{'01': 1024}

O resultado final de tudo isso é que Alice enviou dois bits de informação para Bob e só precisou enviar um qubit para fazer isso. Isso foi possível pelo fato de que o qubit fazia parte de um par emaranhado. Como tal, enquanto Alice apenas aplicava portas a um qubit, ela estava manipulando o conjunto maior de quatro pares emaranhados dos quais ele fazia parte.

Isso serve como um exemplo simples de como os qubits podem nos permitir fazer coisas que os bits normais não podem, e como o emaranhamento é um recurso crucial para isso.

Tente você mesmo

Crie uma função que receba um QuantumCircuit e uma string de dois bits como entrada e aplique as portas que codificam a string no estado emaranhado para que Bob possa decodificá-la. Verifique se funciona em todas as entradas.

Experimente no IBM Quantum Lab

Correlações únicas: o paradoxo de Hardy

Algumas correlações clássicas

Agora vamos considerar outra situação com nossos amigos Alice, Bob e Charlie. Primeiro, vamos considerar um caso completamente clássico.

Suponha que Charlie empacota um par de formas coloridas todos os dias, enviando uma para Alice e a outra para Bob. Todos os dias, Alice e Bob olham para sua forma e comparam o que receberam. Para cada forma, eles observam uma de duas propriedades: se era um cubo ou não, e se era azul ou não.

Depois de muitos dias e muitas opções de olhar para a forma ou a cor, eles fazem duas observações

1. Elas nunca são ambas um cubo.

2. Se uma não for azul, a outra será um cubo.

Claramente Charlie não está apenas enviando formas aleatórias. Existe algum grau de correlação entre os objetos que Charlie escolhe enviar.

Com essas observações em mente, Alice e Bob imaginam o caso em que ambos olham para a cor e ambos descobrem que sua forma não é azul. Bob poderia então aplicar a observação 2 e inferir que a forma de Alice é certamente um cubo. Alice poderia fazer o mesmo e inferir que a forma de Bob é um cubo. No entanto, a partir da observação 1 eles sabem que isso é impossível. Então eles concluem que uma de suas formas sempre será azul.

Este é um cenário bastante artificial, mas mostra que há limites no tipo de correlações possíveis com sistemas clássicos (como formas coloridas). O fato de a cor e a forma de cada objeto serem ambas simultaneamente bem definidas significa que podemos aplicar cadeias de lógica como as acima, que usam os resultados de um para deduzir coisas sobre o outro.

Para qubits, no entanto, os resultados de uma medida não são bem definidos antes que a medida seja feita. Então, podemos encontrar diferentes tipos de comportamento?

Medindo um qubit

No cenário acima, analisamos duas propriedades diferentes de um objeto clássico: forma e cor. Para uma contraparte quântica, precisaremos fazer o mesmo para qubits.

A única informação que extraímos de um qubit é por meio de medidas: aplicamos a operação de medida e recebemos de volta um 0 ou um 1 . A maneira como isso é implementado fisicamente em um computador quântico depende dos detalhes de como seu qubit é construído. Para alguns tipos de qubit, é possível girar o dispositivo de medida para fazer diferentes tipos de medida e ver um comportamento diferente dos resultados.

Para outros tipos de qubit, girar seu dispositivo de medida apenas o quebrará. No entanto, existe uma maneira simples de obter o mesmo efeito: basta girar o qubit! Ao realizar portas de um qubit antes de fazer uma medida padrão, reproduzimos os efeitos dessas formas alternativas de medida.

O exemplo mais comum disso é simplesmente executar uma porta h imediatamente antes da medida. Isso nos dá o que é conhecido como uma medida x .

meas_x = QuantumCircuit(1,1)
meas_x.h(0)
meas_x.measure(0,0)

meas_x.draw()

A forma padrão de medição, que é feita apenas com uma porta de measure , é conhecida como medida z neste contexto.

meas_z = QuantumCircuit(1,1)
meas_z.measure(0,0)

meas_z.draw()

Como você pode adivinhar pelos nomes, também há algo chamado de medida y , mas não precisaremos usar isso aqui.

Agora vamos ver o que acontece com certos estados quando fazemos essas medidas. Começaremos com o estado $|0\rangle$.

qc = QuantumCircuit(1,1)

qc.draw()

Para a medida padrão, como sabemos, isso certamente resultará em 0 .

print('Results from z measurement:',
      backend.run(qc.compose(meas_z)).result().get_counts())

Results from z measurement: {'0': 1024}

Para uma medida x, no entanto, obteremos resultados completamente aleatórios.

print('Results from x measurement:',
      backend.run(qc.compose(meas_x)).result().get_counts())

Results from x measurement: {'1': 522, '0': 502}

Uma situação semelhante ocorre para o estado $|1\rangle$.

qc = QuantumCircuit(1,1)
qc.x(0)

qc.draw()

A medida z produz o resultado esperado com certeza, mas a medida x fornece resultados aleatórios.

for basis,circ in [('z', meas_z), ('x', meas_x)]:
    print('Results from ' + basis + ' measurement:',
      backend.run(qc.compose(circ)).result().get_counts())

Results from z measurement: {'1': 1024}
Results from x measurement: {'0': 520, '1': 504}

As tabelas estão viradas para o estado $|+\rangle$.

qc = QuantumCircuit(1,1)
qc.h(0)

qc.draw()

Embora os resultados sejam aleatórios para a medida z, eles produzem 0 com certeza para uma medida x.

for basis,circ in [('z', meas_z), ('x', meas_x)]:
    print('Results from ' + basis + ' measurement:',
      backend.run(qc.compose(circ)).result().get_counts())

Results from z measurement: {'1': 506, '0': 518}
Results from x measurement: {'0': 1024}

Questionário rápido

Quais seriam os resultados para um estado $|-\rangle$?

1. Aleatório para ambas as medidas z e x.

1. Aleatório para a medida z, 0 para a medida x.

1. Aleatório para a medida z, 1 para a medida x.

1. 0 para a medida z, 1 para a medida x.

Para outros estados, podemos encontrar um ajuste entre os dois. Por exemplo, podemos experimentar diferentes ângulos para as rotações ry .

from math import pi

qc = QuantumCircuit(1, 1)
qc.ry(-pi/4, 0)

Para o ângulo $-\pi/4$, vemos que ambos os resultados são parcialmente aleatórios, mas não completamente.

for basis,circ in [('z', meas_z), ('x', meas_x)]:
    print('Results from ' + basis + ' measurement:',
      backend.run(qc.compose(circ)).result().get_counts())

Results from z measurement: {'0': 867, '1': 157}
Results from x measurement: {'1': 865, '0': 159}

O princípio da incerteza

Todos esses resultados são consequência do princípio da incerteza descoberto por Werner Heisenberg, que é um dos aspectos mais importantes da mecânica quântica. Ele afirma que para certos pares de atributos de um sistema quântico, é impossível conhecer ambos com certeza.

Isso não é verdade para a cor e a forma de um objeto, como em nosso exemplo anterior. Como sabemos pela experiência cotidiana, saber exatamente qual é a forma de algo não faz com que sua cor se torne aleatória.

É verdade, no entanto, para os resultados das medidas z e x. Estas são duas maneiras diferentes que podemos escolher para codificar um pouco de informação em um qubit. Podemos fazer isso da maneira normal, usando os estados $|0\rangle$ e $|1\rangle$ para codificar os valores de bit 0 e 1 e usando a medida z para lê-los. Ou podemos fazer isso de uma maneira alternativa, usando os estados $|+\rangle$ e $|-\rangle$ para codificar os valores de bit e a medida x para leitura. Mas o princípio da incerteza garante que não podemos fazer as duas coisas ao mesmo tempo.

Especificamente, para as medidas z podemos definir uma quantidade

ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{expectation-va…

onde $p_z(0)$ é a probabilidade do resultado ser 0 e $p_z(1)$ é a probabilidade dele ser 1 . Essa quantidade atinge seu valor máximo de $1$ para um estado que certamente produzirá 0 e seu valor mínimo de $-1$ para um estado que certamente produzirá 1 . Observe que em ambos os casos em que a saída é certa, $\langle Z \rangle^2 = 1$. Para um resultado completamente aleatório, no entanto, encontraríamos $\langle Z \rangle = \langle Z \rangle^2 = 0$.

Da mesma forma, podemos definir a quantidade ParseError: KaTeX parse error: Undefined control sequence: \class at position 1: \̲c̲l̲a̲s̲s̲{_expectation-v… para os resultados de medidas x. Para estes podemos encontrar que, para qualquer vetor de estado válido

$$\langle Z \rangle^2 + \langle X \rangle^2 \leq 1.$$

Este é o princípio da incerteza para um qubit, especificamente quanta certeza pode ser compartilhada entre esses tipos de medição.

Correlações quânticas únicas

Com as noções dessas diferentes bases de medição, podemos começar a olhar para correlações únicas que são possíveis para qubits.

Por exemplo, vamos considerar novamente nossos amigos Alice, Bob e Charlie. Charlie cria um estado emaranhado particular e envia um qubit para Alice e outro para Bob. Eles fazem medições e comparam os resultados. Então Charlie envia outro estado identicamente preparado. Isso se repete muitas vezes, então Alice e Bob podem construir estatísticas sobre todos os diferentes resultados de medidas.

Vamos considerar o caso em que Charlie envia o seguinte estado emaranhado.

qc_charlie = QuantumCircuit(2,2)
qc_charlie.ry(1.911,1)
qc_charlie.cx(1,0)
qc_charlie.ry(0.785,0)
qc_charlie.cx(1,0)
qc_charlie.ry(2.356,0)

qc_charlie.draw()

Primeiro Alice e Bob tentam fazer medidas z de seus qubits.

meas_zz = QuantumCircuit(2,2)
meas_zz.measure([0,1],[0,1])

De muitas amostras, eles encontram os seguintes resultados.

from qiskit.visualization import plot_histogram

print('Results for z measurements:')
counts = backend.run(qc_charlie.compose(meas_zz)).result().get_counts()
plot_histogram(counts)

Results for z measurements:

A partir disso, eles fazem a observação de que os qubits nunca produzem 0 para medidas z.

Em seguida, vamos ver os resultados de um quando Bob realiza uma medida x e Alice realiza uma medida z.

meas_zx = QuantumCircuit(2,2)
meas_zx.h(0)
meas_zx.measure([0,1],[0,1])

print('Results for a z and an x measurement:')
counts = backend.run(qc_charlie.compose(meas_zx)).result().get_counts()
plot_histogram(counts)

Results for a z and an x measurement:

Nesse caso, descobrimos que os qubits nunca produzem 1 . O mesmo acontece quando Bob faz a medida z e Alice faz a medida x.

meas_xz = QuantumCircuit(2,2)
meas_xz.h(1)
meas_xz.measure([0,1],[0,1])

print('Results for an x and a z measurement:')
counts = backend.run(qc_charlie.compose(meas_xz)).result().get_counts()
plot_histogram(counts)

Results for a z and an x measurement:

Com essas informações, Alice e Bob podem começar a especular sobre o que aconteceria se ambos realizassem uma medida x.

Eles podem resumir seus resultados até agora nas duas observações a seguir:

1. Se as medidas z forem feitas em ambos os qubits, eles nunca produzirão 0 ;

2. Se uma medida x de um qubit produzir 1 , a medida z do outro produzirá 0 (porque o resultado 11 nunca ocorre nesses casos).

Estes correspondem exatamente às observações feitas para as formas coloridas no cenário clássico. Se aplicarmos a mesma lógica que fizemos nesse caso, podemos analisar o caso em que Alice e Bob fazem uma medida x e ambos obtêm o resultado 1 . Bob poderia então aplicar a observação 2 e inferir que, Alice certamente teria obtido um 0 se ela tivesse feito uma medida z. Alice pode fazer o mesmo, deduzindo que Bob teria obtido um 1 se tivesse feito uma medida z. Então, juntos, eles concluem que, se ambos tivessem feito medidas z, ambos teriam obtido a saída 0 . Como a observação 1 nos mostra que tal resultado seria impossível, Alice e Bob poderiam prever que o resultado 11 nunca ocorreria.

Então vamos ver se eles estariam certos.

meas_xx = QuantumCircuit(2,2)
meas_xx.h([0,1])
meas_xx.measure([0,1],[0,1])

print('Results for an x and an x measurement:')
counts = backend.run(qc_charlie.compose(meas_xx)).result().get_counts()
plot_histogram(counts)

Results for a z and an x measurement:

Estariam errados! O resultado 11 não é provável, mas certamente não é impossível.

Os resultados dos qubits não são bem definidos antes da medição. Embora isso possa parecer que significa que os qubits são mais aleatórios que as variáveis clássicas, nem sempre é uma qualidade negativa. Isso também significa que as restrições aplicadas às variáveis clássicas nem sempre se aplicam aos qubits e que as correlações quânticas podem ter propriedades que seriam impossíveis classicamente. Essas correlações únicas são uma das propriedades únicas de estados emaranhados.