Os algoritmos anteriores continham apenas um qubit e o estado desse qubit era descrito por:
$$ \left|\psi_{0}\right\rangle = \alpha_{0} \left|0\right\rangle + \beta_{0} \left|1\right\rangle. $$Ao método utilizado para implementar o medidor quântico foi dado como argumento o objeto que representava o circuito quântico. Logo, a medição do estado do qubit é, na verdade, a medição do estado do sistema que era formado por apenas um qubit. Quando o circuito quântico tem dois qubits, os resultados possíveis do processo de medição devem ser 00, 01, 10 e 11. Os estados associados a esses resultados são $\left|00\right\rangle$, $\left|01\right\rangle$, $\left|10\right\rangle$ e $\left|11\right\rangle$. Portanto, o estado do sistema é descrito por:
$$ \left|\psi_{1}\right\rangle = \alpha_{0}\alpha_{1} \left|00\right\rangle + \alpha_{0}\beta_{1} \left|01\right\rangle + \beta_{0}\alpha_{1} \left|10\right\rangle + \beta_{0}\beta_{1} \left|11\right\rangle, $$onde $\alpha_{0}$ e $\beta_{0}$ são as constantes complexas associadas ao primeiro qubit e $\alpha_{1}$ e $\beta_{1}$ são as constantes complexas associadas ao segundo qubit. Para um sistema de 3 qubits, o estado do sistema é:
$$ \left|\psi_{2}\right\rangle = \alpha_{0}\alpha_{1}\alpha_{2} \left|000\right\rangle + \alpha_{0}\alpha_{1}\beta_{2} \left|001\right\rangle + \alpha_{0}\beta_{1}\alpha_{2} \left|010\right\rangle + \alpha_{0}\beta_{1}\beta_{2} \left|011\right\rangle + \beta_{0}\alpha_{1}\alpha_{2} \left|100\right\rangle + \beta_{0}\alpha_{1}\beta_{2} \left|101\right\rangle + \beta_{0}\beta_{1}\alpha_{2} \left|110\right\rangle + \beta_{0}\beta_{1}\beta_{2} \left|111\right\rangle, $$onde $\alpha_{0}$ e $\beta_{0}$ são as constantes complexas associadas ao primeiro qubit, $\alpha_{1}$ e $\beta_{1}$ são as constantes complexas associadas ao segundo qubit e $\alpha_{2}$ e $\beta_{2}$ são as constantes complexas associadas ao terceiro qubit.
O quarto algoritmo, que é apresentado abaixo em suas versões para Qiskit, Forest e Cirq, tem como objetivo mostrar o estado de um sistema de dois qubits. Para isso são instanciados dois qubits no circuito quântico e uma porta de Hadamard é aplicada em cada qubit do circuito.
No Qiskit, a quantidade de qubits que precisa ser instanciada no circuito deve ser fornecida como argumento para o construtor
QuantumRegister(). Nesse algoritmo, dois qubits são instanciados por:
qr = QuantumRegister(2).
Agora, a variável qr identifica um vetor de qubits e cada qubit é acessado através do índice que o identifica
nesse vetor. Portas de Hadarmad devem ser aplicadas aos qubits qr[0] e qr[1] por:
qc.h(qr[0])
e
qc.h(qr[1]).
Essas foram as alterações em relação ao algoritmo anterior. O terceiro algoritmo para o SDK Qiskit é mostrado
a seguir:
from qiskit import QuantumCircuit
from qiskit import QuantumRegister
from qiskit import Aer
from qiskit import execute
qr = QuantumRegister(2)
qc = QuantumCircuit(qr)
qc.h(qr[0])
qc.h(qr[1])
backend = Aer.get_backend( 'statevector_simulator' )
job = execute(qc,backend)
resultado = job.result()
estado = resultado.get_statevector()
print(estado)
O resultado do algoritmo acima é [0.5 + 0.j 0.5 + 0.j 0.5 + 0.j 0.5 + 0.j], onde j é a unidade imaginária. Portanto, temos quatro constantes complexas que são iguais a 0,5. Essas quatro constantes correspondem aos produtos $\alpha_{0}\alpha_{1}$, $\alpha_{0}\beta_{1}$, $\beta_{0}\alpha_{1}$ e $\beta_{0}\beta_{1}$ que aprecem na equação
$$ \left|\psi_{1}\right\rangle = \alpha_{0}\alpha_{1} \left|00\right\rangle + \alpha_{0}\beta_{1} \left|01\right\rangle + \beta_{0}\alpha_{1} \left|10\right\rangle + \beta_{0}\beta_{1} \left|11\right\rangle, $$onde $\alpha_{0}$ e $\beta_{0}$ são as constantes complexas associadas ao primeiro qubit e $\alpha_{1}$ e $\beta_{1}$ são as constantes complexas associadas ao segundo qubit.
Para o SDK Forest, a única mudança nesse quarto algoritmo em relação ao segundo, é o acréscimo da linha
de comando:
p += H(1).
Essa linha de comando implementa a porta de Hadamard sobre o segundo qubit.
from pyquil import Program
from pyquil.gates import *
from pyquil.api import WavefunctionSimulator
p = Program()
p += H(0)
p += H(1)
wf_sim = WavefunctionSimulator()
wavefunction = wf_sim.wavefunction(p)
print(wavefunction)
O resultado é (0.5 + 0j) $\left|00\right\rangle$ + (0.5 + 0j)$\left|01\right\rangle$ + (0.5 + 0j)$\left|10\right\rangle$ + (0.5 + 0j)$\left|11\right\rangle$, onde j é a unidade imaginária. Como no resultado obtido com o uso do SDK Qiskit, temos: $\alpha_{0}\alpha_{1} = 0.5 + 0j$, $\alpha_{0}\beta_{1} = 0.5 + 0j$, $\beta_{0}\alpha_{1} = 0.5 + 0j$ e $\beta_{0}\beta_{1} = 0.5 + 0j$. A probabilidade de que o resultado de uma medição, caso fosse realizada, seja 00 é $\left| 0,5 \right|^2 = 0,25$. Essa é a mesma probabilidade para os resultados 01, 10 e 11.
No Cirq, é preciso instanciar dois qubits o que é feito por meio de
qr0 = cirq.NamedQubit('q[0]')
e
qr1 = cirq.NamedQubit('q[1]').
As duas portas de Hadamard que devem ser adicionadas ao circuito são implementadas por:
qc.append(cirq.H(qr0))
e
qc.append(cirq.H(qr1)).
Os comandos para instanciar o simulador e simular o circuito são os mesmos do algoritmo anterior. O algoritmo 4 completo para o SDK Cirq
é mostrado abaixo.
import cirq
qc = cirq.Circuit()
qr0 = cirq.NamedQubit('q[0]')
qr1 = cirq.NamedQubit('q[1]')
qc.append(cirq.H(qr0))
qc.append(cirq.H(qr1))
simulador = cirq.Simulator()
resultado = simulador.simulate(qc)
print(resultado)
O resultado obtido com a execução desse algoritmo é:
measurements: (no measurements)
output vector: 0.5$\left|00\right\rangle$ + 0.5$\left|01\right\rangle$ + 0.5$\left|10\right\rangle$ + 0.5$\left|11\right\rangle$
Não há medição do estado do qubit nesse algoritmo. Não temos um medidor quântico implementado para realizar essa operação. O resultado da simulação retorna o estado do qubit que nos diz que: $\alpha_{0}\alpha_{1}$ = 0,5, $\alpha_{0}\beta_{1}$ = 0,5, $\beta_{0}\alpha_{1}$ = 0,5 e $\beta_{0}\beta_{1}$ = 0,5. Logo, temos a probabilidade de 0,25 para cada um dos possíveis resultados.