No primeiro algoritmo quântico, observou-se que a medição de um qubit pode retornar 0 ou 1 demonstrando o caráter probabilístico da leitura de um qubit. A porta de Hadamard foi utilizada para alterar o estado do qubit de $\left|0\right\rangle$ para $\left(1/\sqrt{2}\right) \left|0\right\rangle + \left(1/\sqrt{2}\right) \left|1\right\rangle$. Nesse algoritmo serão feitas algumas alterações no algoritmo anterior para visualizar o resultado da ação da porta de Hadamard sobre um qubit.
O simulador utilizado na execução do algoritmo 1 foi o QASM Simulator. Esse simulador permite múltiplas
execuções, mas para visualizar o vetor de estado associado ao qubit deve-se utilizar o método get_statevector()
que pertence ao simulador Statevector Simulator. Assim, para visualizar a ação da porta de Hadamard sobre o estado do qubit, o
simulador do algoritmo 1, que foi selecionado pelo método get_backend(), foi modificado para:
backend = Aer.get_backend ( 'statevector_simulator' ).
O medidor quântico também deve ser retirado do circuito quântico porque o processo de medição interfere no estado
do qubit. Logo, não será preciso um registrador clássico para armazenar o resultado. O algoritmo 2 completo é mostrado a seguir:
from qiskit import QuantumCircuit
from qiskit import QuantumRegister
from qiskit import Aer
from qiskit import execute
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.h(qr)
backend = Aer.get_backend ( 'statevector_simulator' )
job = execute(qc,backend)
resultado = job.result()
estado = resultado.get_statevector()
print(estado)
O resultado da execução desse algoritmo é [0.70710678 + 0.j 0.70710678 + 0.j], onde j é a unidade imaginária. Os valores de $\alpha$ e $\beta$ encontram-se separados por um espaço dentro de colchetes [$\alpha$ $\beta$] de modo que $\alpha$ = 0.70710678 + 0.j e $\beta$ = 0.70710678 + 0.j. Embora a unidade imaginária seja usualmente representada pela letra i, no SDK Qiskit, a letra j é usada para identificar a unidade imaginária. O valor 0,70710678 é o valor $1/\sqrt{2}$ que as variáveis $\alpha$ e $\beta$ assumem após a ação da porta de Hadamard.
No SDK Forest, pode-se utilizar o simulador Wavefunction para visualizar o efeito da porta de Hadamard. Para isso, inclui-se entre as
bibliotecas importadas no início do programa:
from pyquil.api import WavefunctionSimulator.
É preciso instanciar um objeto do tipo WavefunctionSimulator através de:
wf_sim = WavefunctionSimulator().
O método wavefunction() é utilizado para obter o estado do qubit. Logo, adicona-se ao programa:
wavefunction = wf_sim.wavefunction(p).
O estado do qubit pode ser impresso na tela do terminal pelo comando:
print(wavefunction).
O método get_outcome_probs() possibilita obter as probabilidades associadas a cada resultado. Esse método pode ser
implementado por:
print(wavefunction.get_outcome_probs( )).
O algoritmo 2 completo, escrito para o SDK Forest, é mostrado abaixo.
from pyquil import Program
from pyquil.gates import *
from pyquil.api import WavefunctionSimulator
p = Program()
p += H(0)
wf_sim = WavefunctionSimulator()
wavefunction = wf_sim.wavefunction(p)
print(wavefunction)
print(wavefunction.get_outcome_probs ())
O resultado da execução do algoritmo acima é:
(0.7071067812 + 0j)$\left|0\right\rangle$ + (0.7071067812 + 0j)$\left|1\right\rangle$
{'0': 0.4999999999999999, '1': 0.4999999999999999}
O valor 0,7071067812 equivale a $1/\sqrt{2}$. A ação da porta de Hadamard sobre o estado do qubit resulta em $\alpha$ = 0.7071067812 + 0j e $\beta$ = 0.7071067812 + 0j, onde j é a unidade imaginária. O comando print(wavefunction.get_outcome_probs ()) resulta em {'0': 0.4999999999999999, '1': 0.4999999999999999} onde o valor entre aspas simples é o resultado possível e o valor após os dois pontos é a probabilidade desse resultado. Essa probabilidade é $\left| 1/\sqrt{2} \right|^2$ = 0,5.
No SDK Cirq, o resultado da ação da porta de Hadamard pode ser visualizado através do algoritmo abaixo.
import cirq
qc = cirq.Circuit()
qr = cirq.NamedQubit('q[0]')
qc.append(cirq.H(qr))
simulador = cirq.Simulator()
resultado = simulador.simulate(qc)
print(resultado)
As alterações em relação ao algoritmo 1 são: a exclusão do medidor quântico e o uso do
método simulate() ao invés do método run(). O resultado da execução desse algoritmo é:
measurements: (no measurements)
output vector: 0.707$\left|0\right\rangle$ + 0.707$\left|1\right\rangle$
Não foi realizada a medição do estado do qubit nesse algoritmo assim como nos algoritmos para os SDKs Qiskit e Forest. Não há medidores quânticos implementados. A simulação realizada fornece o estado do qubit instanciado no algoritmo. O valor 0,707 é o valor de $\alpha$ e $\beta$ que equivale a $1/\sqrt{2}$.