visualizing-entanglement.ipynb

Kernel: Python 3

Visualizando Emaranhamento

from hello_qiskit import run_puzzle

No conjunto de exercícios a seguir, apresentaremos e usaremos uma visualização para dois estados de qubit. Com isso, você poderá montar sua própria versão de um experimento famoso: provar a singularidade da mecânica quântica através das desigualdades de Bell.

Conhecendo seu qubit

Exercício 1: Invertendo um Qubit

Para começar, vamos começar com um único qubit. Execute a seguinte célula de código para ver como visualizamos um qubit.

puzzle = run_puzzle(0)

Aqui você vê duas linhas que representam as probabilidades para diferentes resultados de medição. A vertical representa as medidas padrão (também conhecidas como 'medidas z'), e a horizontal representa as 'medidas x' discutidas na última seção. Em ambos os casos, o comprimento da barra roxa representa a probabilidade de obter o resultado 1 .

No estado acima, não vemos barra roxa na linha vertical. Isso nos diz que a probabilidade de obter 1 para uma medida z é zero. Para a linha horizontal, a barra roxa ocupa metade da linha e, portanto, a probabilidade de obter 1 para uma medida x é $1/2$. Com essas informações, podemos identificar qual estado está sendo representado aqui: Esses resultados são exatamente o que vimos na última seção para o estado $|0\rangle$.

Para ver como funciona para o estado $|1\rangle$, você pode aplicar uma porta x . Use os botões abaixo da visualização para fazer isso. Você precisará primeiro selecionar a porta x e, em seguida, o qubit q[0] ao qual estamos aplicando a porta e, finalmente, pressionar 'Aplicar operação'.

Tente fazer isso três vezes para alternar entre o estado $|0\rangle$ e o estado $|1\rangle$.

Exercício 2: Trocando os Eixos

O estado visualizado abaixo tem um resultado aleatório para a medida z, mas com certeza produzirá um 0 para uma medida x. Podemos, portanto, identificar que é o $|+\rangle$.

Você pode notar que o estado $|0\rangle$ e o estado $|+\rangle$ têm fortes semelhanças. Especificamente, o que for verdadeiro para um desses estados ao fazer medidas z é verdadeiro para o outro ao fazer medidas x. O estado $|1\rangle$ e o estado $|-\rangle$ também têm a mesma relação.

Com isso em mente, vamos pensar nos efeitos da porta $H$,

$$H |0\rangle = |+\rangle, \quad H |1\rangle = |-\rangle\H |+\rangle = |0\rangle, \quad H |-\rangle = |1\rangle.$$

Isso transforma o estado $|0\rangle$ no estado $|+\rangle$ e vice-versa, e também o estado $|1\rangle$ no estado $|-\rangle$ e vice-versa. Efetivamente, inverte os papéis da medida z e da medida x. Isso tem um efeito simples nesta visualização: ele troca as duas linhas.

Execute a célula abaixo, aplique a porta h três vezes e veja isso em ação.

puzzle = run_puzzle(1)

Exercício 3: Uma Rotação

Agora vamos tentar uma rotação em torno do eixo y na esfera de Bloch, usando a porta ry(pi/4) . Aplique quatro delas e veja o que acontece.

puzzle = run_puzzle(2)

Os efeitos aqui não são tão fáceis de entender como o Hadamard. Mas há uma maneira de torná-lo mais intuitivo. Tudo o que precisamos fazer é desenhar as duas linhas uma em cima da outra e colocar um ponto onde seus níveis se cruzam.

Como isso está relacionado a um conceito conhecido como esfera de Bloch, usaremos um comando chamado 'Bloch' para fazer isso acontecer. Experimente abaixo, bem como mais alguns portões ry . Você deve ver que o portão efetivamente gira o ponto, com as barras nas linhas mudando de acordo.

puzzle = run_puzzle(3)

Antes de prosseguirmos, observe que você pode recuperar o objeto de circuito Qiskit para os circuitos que estamos criando usando o método puzzle.get_circuit() . Você pode fazer isso para o circuito completo, que inclui as portas usadas para preparar o estado inicial do quebra-cabeça.

puzzle.get_circuit(use_initializer=True).draw()

Ou você pode simplesmente obter o circuito com as portas adicionadas por seus próprios movimentos.

puzzle.get_circuit().draw()

Exercício 4: Um Segundo Qubit

Grande parte da grade está vazia até agora. Parte do espaço é reservado para um segundo qubit à esquerda. Novamente, isso é representado com uma linha vertical para probabilidades de medida z e uma linha horizontal para medidas x.

Para se familiarizar com este novo qubit, use x , h e ry(pi/4) duas vezes cada. Você também pode usar o comando 'Bloch'.

puzzle = run_puzzle(4)

Exercício 5: Dois Qubits ao mesmo tempo

Para visualizar dois qubits ao mesmo tempo, há ainda mais informações que precisamos acompanhar. Para isso, adicionamos quatro novas linhas.

Dessas novas linhas, a de baixo representa $p(|01\rangle)+p(|10\rangle)$: a probabilidade de que os qubits darão resultados diferentes para a medida z de ambos. Como o estado inicial abaixo é $|01\rangle$, essa nova linha é branca para representar que eles certamente discordam.

A nova linha no topo representa a mesma coisa, mas para medidas x em ambos os qubits. Como os resultados das medidas x são completamente aleatórios para o estado $|01\rangle$, se eles concordam ou discordam, também é aleatório. É por isso que esta linha está meio preenchida no estado inicial abaixo.

Aplique portas para garantir que as medidas x em cada qubit darão o mesmo resultado e veja como isso afeta a linha no topo.

puzzle = run_puzzle(5)

As outras duas novas linhas também representam as probabilidades dos resultados serem diferentes, mas para os dois casos de uma medida x em um qubit e medida z no outro.

Com isso em mente, podemos prever como as portas x e h afetarão essas novas linhas. Por exemplo, lembre-se de que a porta x inverte o resultado da medida z em um qubit. Se esse resultado certamente concorda com um de outro qubit, o x , portanto, também garante a discordância e vice-versa. Portanto, afetará todas as linhas ao longo de uma linha da grade.

Tente três portas x abaixo para ver isso em ação.

puzzle = run_puzzle(6)

Como vimos antes, o efeito de h é fazer com que qualquer coisa verdadeira sobre a medida z antes de h se aplique à medida x depois, e vice-versa. Por esse motivo, tem o efeito de trocar linhas inteiras na grade.

Para ver isso, tente três portas h abaixo.

puzzle = run_puzzle(7)

Essa combinação de linhas se torna ainda mais óbvia ao usar o comando 'Bloch'. Combinar as linhas significa que três pares diferentes de linhas são sobrepostos, e as portas ry levam a rotações para cada uma.

Para ver isso, use rotações ry para girar ambos os qubits para seu estado $|1\rangle$. Tente usar o comando 'Bloch' para cada qubit ao realizar as rotações.

puzzle = run_puzzle(8)

Exercício 6: Emaranhando Qubits

Como as novas linhas representam correlações, elas se tornam muito importantes na descrição de estados emaranhados.

A porta mais fácil de entender usando essa visualização é a cz . Como essa porta age simetricamente, não precisaremos escolher em qual qubit aplicá-lo. Ele apenas atuará em ambos os qubits.

Assim como a porta h pode ser entendido trocando as posições das linhas (de uma coluna para outra), podemos usar uma explicação semelhante para a porta cz . Especificamente, ela troca a linha de medida x de cada qubit com a linha vizinha que representa uma correlação.

Experimente abaixo com três portas cz .

puzzle = run_puzzle(9)

Você também deve ter notado que a linha no topo também mudou. Para explicar isso precisamos expandir a visualização para incorporar algo que estávamos perdendo até agora. Há também um conceito de 'medida y', e precisamos adicionar linhas para representar os possíveis resultados para descrever completamente nossos estados de qubit.

puzzle = run_puzzle(10)

Aqui inserimos duas novas linhas e muitas novas linhas para representar os resultados das medidas de y, bem como todas as correlações envolvendo medidas de y.

É importante ficar de olho na do meio, que descreve a probabilidade de obter resultados diferentes quando ambos os qubits são medidos na base y. Essa linha é a que troca com a de cima quando executamos um cz . Faça outras três portas cz para ver isso em ação.

Observe que essas novas linhas também podem ser incorporadas ao comando 'Bloch'. Para isso, criaríamos uma esfera em vez de um círculo, e poderíamos ver que as portas rx e rz também são rotações. Embora não incluamos isso em nossa visualização, você pode criar um gráfico dessas esferas a qualquer momento usando o seguinte comando.

puzzle.plot_spheres()

Exercício 7: Sandbox

Manter o controle de todas as informações sobre as medidas de y torna a grade um pouco complicada. Então, vamos voltar a ignorá-la.

Agora você aprendeu tudo o que precisamos para configurar nosso experimento. Antes de continuarmos, sinta-se à vontade para brincar da maneira que quiser.

puzzle = run_puzzle(11)

Desigualdades de Bell

2.1 Teste de Bell para variáveis clássicas

Agora vamos investigar como as variáveis quânticas (baseadas em qubits) diferem das padrão (baseadas em bits).

Faremos isso criando um par de variáveis, que chamaremos de A e B . Não vamos colocar nenhuma condição sobre o que eles podem ser, ou como eles são inicializados. Portanto, há muitas possibilidades:

• Eles podem ser qualquer tipo de variável, como

  • inteiro

  • lista

  • dicionário

  • ...

• Eles podem ser inicializados por qualquer tipo de processo, como

  • deixado vazio

  • preenchido com um determinado conjunto de valores

  • gerado por um determinado processo aleatório

    • aplicado independentemente a A e B

    • aplicados a A e B juntos, permitindo correlações entre sua aleatoriedade

Se as variáveis forem inicializadas por um processo aleatório, significa que elas terão valores diferentes toda vez que executarmos nosso programa. Não há problema algum. A única regra que precisamos obedecer é que o processo de geração da aleatoriedade é o mesmo para cada execução.

Usaremos a função abaixo para configurar essas variáveis. Isso atualmente tem A e B definidos como sendo números de vírgula flutuante aleatórios parcialmente correlacionados. Mas você pode alterá-los para o que quiser.

import random
def setup_variables():
    
    ### Replace this section with anything you want ###
    
    r = random.random()
    
    A = r*(2/3)
    B = r*(1/3)
    
    ### End of section ###
    
    return A, B

Nosso próximo trabalho é definir uma função de hashing. Isso simplesmente precisa receber uma das variáveis como entrada e, em seguida, fornecer um valor de bit como saída.

Essa função também deve ser capaz de executar dois tipos diferentes de hash. Portanto, ela precisa ser capaz de mastigar uma variável e cuspir um bit de duas maneiras diferentes. Portanto, também precisaremos informar à função que tipo de hash queremos usar.

Para ser consistente com o resto do programa, os dois tipos de hash possíveis devem ser chamados 'H' e 'V' . Além disso, a saída deve estar na forma de uma string de bits de valor único: '0' ou '1' .

No exemplo (bastante arbitrário), os bits foram criados comparando A e B a um determinado valor. A saída é '1' se estiverem abaixo desse valor e '0' caso contrário. O tipo de hash determina o valor usado.

def hash2bit(variable, hash_type):
    
    ### Replace this section with anything you want ###
    
    if hash_type == 'V':
        bit = (variable < 0.5)
    elif hash_type == 'H':
        bit = (variable < 0.25)
        
    bit = str(int(bit)) # Turn True or False into '1' and '0'
    
    ### End of section ###
        
    return bit

Uma vez definidas, há quatro quantidades que desejamos calcular: P['HH'] , P['HV'] , P['VH'] e P['VV'] .

Vamos nos concentrar em P['HV'] como exemplo. Esta é a probabilidade de que o valor de bit derivado de um hash do tipo 'H' em A seja diferente daquele de um tipo 'V' em B . Estimaremos essa probabilidade amostrando muitas vezes e determinando a fração de amostras para as quais os valores de bits correspondentes discordam.

As outras probabilidades são definidas de forma semelhante: P['HH'] compara um hash do tipo 'H' em A e B , P['VV'] compara um hash do tipo V em A e B, e P['VH'] compara um V tipo hash em A com um tipo H tem em B .

Essas probabilidades são calculadas na função a seguir, que retorna todos os valores de P em um dicionário. O parâmetro shots é o número de amostras que usaremos.

shots = 8192
def calculate_P():
    P = {}
    for hashes in ['VV','VH','HV','HH']:
        
        # calculate each P[hashes] by sampling over `shots` samples
        P[hashes] = 0
        for shot in range(shots):

            A, B = setup_variables()

            # hash type for variable `A` is the 1st character of `hashes`
            a = hash2bit(A, hashes[0])
            # hash type for variable `B` is the 2nd character of `hashes`
            b = hash2bit(B, hashes[1])

            P[hashes] += (a != b)/shots
 
    return P

Agora vamos calcular esses valores para o método que escolhemos para configurar e fazer o hash das variáveis.

P = calculate_P()
print(P)

Esses valores variam um pouco de uma execução para outra devido ao fato de que usamos apenas um número finito de fotos. Para alterá-los significativamente, precisamos alterar a maneira como as variáveis são iniciadas e/ou a maneira como as funções de hash são definidas.

Não importa como essas funções sejam definidas, existem certas restrições que os valores de P sempre obedecerão.

Por exemplo, considere o caso em que P['HV'] , P['VH'] e P['VV'] são todos 0.0 . A única maneira de isso ser possível é P['HH'] também ser 0.0 .

Para ver por que, começamos observando que P['HV']=0.0 está nos dizendo que hash2bit(A, H) e hash2bit(B, V) nunca foram diferentes em nenhuma das execuções. Portanto, isso significa que sempre podemos esperar que eles sejam iguais.

    hash2bit(A, H) = hash2bit(B, V)        (1)

De P['VV']=0.0 e P['VH']=0.0 podemos obter similarmente

    hash2bit(A, V) = hash2bit(B, V)        (2)
    
    hash2bit(A, V) = hash2bit(B, H)        (3)

Colocando (1) e (2) juntos implica que

    hash2bit(A, H) = hash2bit(A, V)        (4)

Combinando isso com (3) dá

    hash2bit(A, H) = hash2bit(B, H)        (5)

E se esses valores forem sempre iguais, nunca veremos uma execução em que eles sejam diferentes. Isso é exatamente o que nos propusemos a provar: P['HH']=0.0 .

De maneira mais geral, podemos usar os valores de P['HV'] , P['VH'] e P['VV'] para definir um limite superior para o que P['HH'] pode ser. Adaptando a desigualdade CHSH , encontramos que

$,,,,,,,$ P['HH'] $, \leq ,$ P['HV'] + P['VH'] + P['VV']

Esta não é apenas uma propriedade especial da P['HH'] . Também vale para todas as outras: cada uma dessas probabilidades não pode ser maior que a soma das outras.

Para testar se essa lógica é válida, veremos quão bem as probabilidades obedecem a essas desigualdades. Observe que podemos obter pequenas violações devido ao fato de nossos valores P não serem exatos, mas são estimativas feitas usando um número limitado de amostras.

def bell_test(P):
    sum_P = sum(P.values())
    for hashes in P:
        
        bound = sum_P - P[hashes]
        
        print("The upper bound for P['"+hashes+"'] is "+str(bound))
        print("The value of P['"+hashes+"'] is "+str(P[hashes]))
        if P[hashes]<=bound:
            print("The upper bound is obeyed :)\n")
        else:
            if P[hashes]-bound < 0.1:
                print("This seems to have gone over the upper bound, "
                      "but only by a little bit :S\nProbably just rounding"
                      " errors or statistical noise.\n")
            else:
                print("This has gone well over the upper bound :O !!!!!\n")

bell_test(P)

Com as funções de inicialização e hash fornecidas neste notebook, o valor de P('HV') deve ser praticamente o mesmo que o limite superior. Como os números são estimados estatisticamente e, portanto, são ligeiramente aproximados devido ao ruído estatístico, você pode até vê-lo um ultrapassar um pouco o limite. Mas você nunca o verá ultrapassá-lo significativamente.

Se você não acredita em mim, tente você mesmo. Altere a maneira como as variáveis são inicializadas e como os hashes são calculados e tente fazer com que um dos limites seja significativamente quebrado.

Teste de Bell para variáveis quânticas

Agora vamos fazer a mesma coisa novamente, exceto que nossas variáveis A e B serão variáveis quânticas. Especificamente, eles serão o tipo mais simples de variável quântica: qubits.

Ao escrever programas quânticos, temos que configurar nossos qubits e bits antes de podermos usá-los. Isso é feito pela função abaixo. Ele define um registro de dois bits e os atribui como nossas variáveis A e B . Ele então configura um registro de dois bits para receber as saídas e as atribui como a e b .

Finalmente, ele usa esses registros para configurar um programa quântico vazio. Isso é chamado de qc .

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

def initialize_program():
    qubit = QuantumRegister(2)
    A = qubit[0]
    B = qubit[1]
    
    bit = ClassicalRegister(2)
    a = bit[0]
    b = bit[1]
    
    qc = QuantumCircuit(qubit, bit)
    
    return A, B, a, b, qc

Antes de começarmos a escrever o programa quântico para configurar nossas variáveis, vamos pensar no que precisa acontecer no final do programa. É aqui que definimos as diferentes funções de hash, que transformam nossos qubits em bits.

A maneira mais simples de extrair um bit de um qubit é através de uma medida. Usaremos a medida z como nosso hash do tipo V e a medida x como nosso hash do tipo H

Observe que esta função tem mais entradas do que sua contraparte clássica. Temos que dizer o bit no qual escrever o resultado e o programa quântico, qc , no qual escrevemos as portas.

def hash2bit(variable, hash_type, bit, qc):
    if hash_type == 'H':
        qc.h(variable)
    qc.measure(variable, bit)

Agora é hora de configurar as variáveis A e B . Para escrever este programa, você pode usar a grade abaixo. Você pode seguir o exercício sugerido ou fazer o que quiser. Quando estiver pronto, é só seguir em frente. A célula que contém a função setup_variables() usará o programa que você escreveu com a grade.

Observe que nossa escolha de visualização significa que as probabilidades P['HH'] , P['HV'] , P['VH'] e P['VV'] corresponderão explicitamente aos círculos em nossa grade. Por exemplo, o círculo no topo nos diz qual a probabilidade de as duas saídas X discordarem. Se for branco, então P['HH']=1 ; se for preto, então P['HH']=0 .

Um exemplo de um estado que não obedecerá ao limite superior discutido anteriormente é aquele em que P['HH']>0.5 e P['HV']=P['VH']=P['VV']<0.5 . Isso significa que a linha superior deve ser na maior parte branca, e o restante que descreve as correlações deve ser na maior parte preta.

Encontre uma maneira de criar esse estado abaixo.

puzzle = run_puzzle(12)

Agora o programa como escrito acima será usado para configurar as variáveis quânticas.

import numpy as np
def setup_variables(A, B, qc):
    for line in puzzle.program:
        eval(line)

Os valores de P são calculados na função abaixo. Neste, como nos quebra-cabeças do restante deste notebook, isso é feito executando o trabalho usando o Qiskit e obtendo resultados que nos dizem quantas das amostras retornaram cada saída possível. A saída é dada como uma string de bits, string , que o Qiskit numera da direita para a esquerda. Isso significa que o valor de a , que corresponde a bit[0] é o primeiro da direita

    a = string[-1]

e o valor de b está ao lado dele no segundo a partir da direita

    b = string[-2]

O número de amostras para esta sequência de bits é fornecido pelo dicionário de resultados, stats , como stats[string] .

shots = 8192
from qiskit import assemble, transpile

def calculate_P(backend):
    P = {}
    program = {}
    for hashes in ['VV','VH','HV','HH']:

        A, B, a, b, program[hashes] = initialize_program()

        setup_variables(A, B, program[hashes])

        hash2bit(A, hashes[0], a, program[hashes])
        hash2bit(B, hashes[1], b, program[hashes])
            
    # submit jobs
    t_qcs = transpile(list(program.values()), backend)
    qobj = assemble(t_qcs, shots=shots)
    job = backend.run(qobj)

    # get the results
    for hashes in ['VV','VH','HV','HH']:
        stats = job.result().get_counts(program[hashes])
        
        P[hashes] = 0
        for string in stats.keys():
            a = string[-1]
            b = string[-2]
            
            if a != b:
                P[hashes] += stats[string] / shots

    return P

Agora é hora de escolher e configurar o dispositivo real que vamos usar. Por padrão, usaremos um simulador. Em vez disso, você pode usar um dispositivo real baseado em nuvem alterando o back-end de acordo.

puzzle.program

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

P = calculate_P(backend)
print(P)

bell_test(P)

Se você preparou a sugestão de estado pelo exercício, terá encontrado uma violação significativa do limite superior para P['HH'] . Então o que está acontecendo aqui? A cadeia de lógica em que baseamos o teste de Bell obviamente não se aplica a variáveis quânticas. Mas por que?

A resposta é que há uma suposição oculta nessa lógica. Para ver o porquê, vamos revisitar o ponto (4).

    hash2bit(A, H) = hash2bit(A, V)        (4)

Aqui comparamos o valor que obteríamos de um hash do tipo H da variável A com o valor de um hash do tipo V

Para variáveis clássicas, isso é perfeitamente razoável. Não há nada que nos impeça de calcular os dois hashes e comparar os resultados. Mesmo que o cálculo do hash de uma variável altere a variável, isso não é um problema. Tudo o que precisamos fazer é copiá-lo de antemão e podemos fazer os dois hashes sem nenhum problema.

O mesmo não é verdade para variáveis quânticas. O resultado dos hashes não é conhecido até que realmente os façamos. É só então que o qubit realmente decide qual valor de bit fornecer. E uma vez que ele decida o valor de um tipo de hash, nunca poderemos determinar o que ele teria decidido se tivéssemos usado outro tipo de hash. Também não podemos contornar isso copiando as variáveis quânticas, porque as variáveis quânticas não podem ser copiadas . Isso significa que não há contexto em que os valores hash2bit(A,H) e hash2bit(A,V) estejam bem definidos ao mesmo tempo e, portanto, é impossível compará-los.

Outra suposição oculta é que hash2bit(A,hash) depende apenas do tipo de hash escolhido para a variável A , e não daquele escolhido para a variável B . Isso também é perfeitamente razoável, já que é exatamente assim que configuramos a função hash2bit() . No entanto, o próprio fato de que o limite superior foi violado parece implicar que cada variável sabe qual hash está sendo feito para a outra, então elas podem conspirar para dar um comportamento muito diferente quando ambas têm um hash do tipo H

Mesmo assim, não podemos dizer que nossa escolha de hash em um qubit afeta o resultado do outro. O efeito é mais sutil do que isso. Por exemplo, é impossível determinar qual variável está afetando qual: Você pode alterar a ordem em que os hashes são feitos ou efetivamente fazê-los ao mesmo tempo e obterá os mesmos resultados. O que podemos dizer é que os resultados são contextuais : para entender completamente os resultados de uma variável, às vezes é necessário olhar o que foi feito com outra.

Tudo isso mostra que nem sempre as variáveis quânticas seguem a lógica que estamos acostumados. Elas seguem regras diferentes, as regras da mecânica quântica, que nos permitirão encontrar maneiras de realizar computação de formas novas e diferentes.