Aula 04 – Computação Quântica – Primeiro Circuito

toticavalcanti

Aula 04 – Computação Quântica – Primeiro Circuito

Computação Quântica – IBM Q – Hello World

Voltar para página principal do blog

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Meus links de afiliados:

Computação Quântica – IBM Q – Primeiro Circuito

Vamos criar uma aplicação quântica básica com mecânica quântica usando o Qiskit.

Executando sua primeira aplicação quântica

Agora que seu ambiente tá pronto, com tudo o que você precisa instalado e com sua conexão com a máquina quântica da IBM configurada, chegou a hora de rodar sua primeira aplicação quântica.

Abra o Anaconda navigator e em seguida o Jupyter.

O Jupyter pode solicitar senha ou token de acesso, para evitar essa exigência, você pode também rodar o comando abaixo no Anaconda prompt que ele vai abrir o Jupyter sem pedir senha nem token:

jupyter notebook --ip='*' --NotebookApp.token='' --NotebookApp.password=''

Com o jupyter aberto

Agora que você tá com o jupyter aberto, crie um novo notebook, dê um nome a ele(ex. qiskit01) e crie a célula com o import do IBMQ e em seguida configure seu acesso, substituindo MY_API_TOKEN no código abaixo, pelo valor do token da API que você criou em:

https://quantum-computing.ibm.com/account


from qiskit import IBMQ
IBMQ.save_account('MY_API_TOKEN')

Pronto, agora você tá credenciado para acessar a máquina da IBM.

Importe tudo do Qiskit:


from qiskit import *

Pronto, com o Qiskit importado, o próximo passo é construir um circuito quântico, para isso, precisaremos de dois bits quânticos, ou seja, dois qbits.

Então o que vamos fazer primeiro é criar os dois registradores quânticos, isto é, os dois bits quânticos.


qr = QuantumRegister(2)

A segunda coisa é criar os dois registradores clássicos, isto é, os dois bits binários.


cr = ClassicalRegister(2)

Agora que temos dois registradores quânticos e dois clássicos, podemos criar um circuito.


circuit = QuantumCircuit(qr, cr)

Criamos um circuito quântico, em qualquer ponto que nós modificarmos o circuito, podemos visualizar ele com:


%matplotlib inline
circuit.draw()

Saída:

q0_0: |0>
         
q0_1: |0>
         
c1_0: 0 
         
c1_1: 0

No circuito temos dois bits quânticos, q0_0 e q0_1, e dois bis clássicos c1_0 e c1_1.

Até agora nada de mais, não há nada de interessante nisso ainda, não temos nenhum gate.

Então vamos criar um gate.

Para criar esse emaranhamento quântico, o primeiro passo é aplicar o que é chamado de hadamard gate no seu primeiro qbit.

O que vamos fazer então é criar um circuito hadamard e aplicar ao primeiro qbit.

E também plotar a saída usando o matplotlib.


# the quantum circuit has one qubit. It is indexed as qubit 0
circuit.h(0)
circuit.draw(output='mpl')

Saída:

Circuito quântico

Vamos criar agora uma operação com os dois qbits chamada de controle X, funciona parecido com a lógica condicional do if.


circuit.cx(0,1) # order is: control(0) and target(1)

Saída:

<qiskit.circuit.instructionset.InstructionSet at 0x208316deb48>

Vamos desenhar o circuito com:


circuit.draw(output='mpl')

Saída:

Circuito quântico controle

O circuito agora tem um hadamard gate e um controle.

A ideia é que com essas duas operações simples, nós seremos capazes de gerar emaranhamentos em bits quânticos q0_0, q0_1.

Então, agora que criamos nosso circuito quântico, usando o hadamard gate e o controle x, o que vamos fazer agora é medir o bit quântico, pegar sua medição e armazenar em um bit clássico.


circuit.measure(qr, cr)
circuit.draw(output='mpl')

Saída:

Circuito quântico medido

Nosso circuito quântico está da forma mostrada acima.

Temos uma operação quântica, o hadamard gate e o controlled x gate e temos a medição.

O próximo passo é executar o circuito, e iremos fazer duas coisas:

Executar o circuito em um computador clássico e ver o que acontece quando simulamos um computador quântico.
Executar em um dispositivo quântico real da IBM e então observar os resultados retornados.

Para simular o circuito quântico, o que vamos fazer é importar o componente Aer do Qiskit.

A ideia é usar o Aer no nosso computador local para simular o circuito quântico.


simulator = Aer.get_backend('qasm_simulator')

Execute:


result = execute(circuit, backend=simulator).result()

Faça o import do plot_histogram


from qiskit.visualization import plot_histogram

Agora vamos plotar o resultado



plot_histogram(result.get_counts(circuit))

Saída:

Circuito plotado

Tivemos aproximadamente 50% ou 0.5 de probabilidade de zero zero e quase 50% também de um um.

Esse pequeno erro é porque estamos executando um limitado número de tentativas em nossa simulação ao invés de infinitas.

Vamos executar agora o mesmo experimento em um dispositivo quântico real e ver o que acontece.

Vamos carregar nossas credenciais de acesso, a máquina quântica da IBM.


IBMQ.load_account()

Diga ao provider para usar o ibm-q:


provider = IBMQ.get_provider('ibm-q')

Agora defina qual é a máquina, o dispositivo que vai rodar o circuito:


qcomp = provider.get_backend('ibmq_16_melbourne')

Esse dispositivo fica em algum lugar em Melbourne.

Defina o job.


job = execute(circuit, backend=qcomp)

Importe o job_monitor


from qiskit.tools.monitor import job_monitor
job_monitor(job)

A ideia aqui é que esse job seja submetido a o computador quântico real, e como ele é um dispositivo público, existe uma fila.

É o job_monitor que permite que eu coloque esse job criado na fila do processamento da máquina quântica real.

Depois de concluído, você vai ver a mensagem:

Job Status: job has successfully run

Você pode rodar então:


result = job.result()
plot_histogram(result.get_counts(circuit))

Comparando o resultado das duas plotagens, o da simulação você só teve estados zero zero e um um.

No dispositivo quântico tivemos um pequeno número de resultados aparecendo estados zero um e um zero.

Mesmo a maioria dos resultados tendo sido estados zero zero e um um tivemos esse pequeno número de ‘erros‘ estados zero um e um zero.

Circuito quântico real

Isso acontece porque a simulação emula um computador quântico perfeito, só que o dispositivo quântico real é suscetível a pequenos erros quânticos.

Esses erros quânticos tem sido melhorados a cada dia como resultado do avanço tecnológico, então podemos esperar que esses erros diminuam ao longo dos próximos anos, chegando cada vez mais perto da perfeição.