Como seria um programa quântico muito simples?

15

Depois de ler o " primeiro chip fotônico quântico programável ". Eu estava imaginando como seria um software para um computador que usa emaranhamento quântico.

Existe algum exemplo de código para programação quântica específica? Como pseudocódigo ou linguagem de alto nível? Especificamente, qual é o programa mais curto que pode ser usado para criar um estado de Bell a partir de um estado inicializado parausando tanto uma simulação e um dos da IBMQuantum Experiênciaprocessadores, como oibmqx4?

| ψ ⟩ = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left|\psi\right> = \frac{1}{\sqrt 2} \left(\left|00\right> + \left|11\right> \right)$

| ψ_{0} ⟩ = | 00 ⟩

$\left|\psi_0\right> = \left|00\right>$

Fazer o salto conceitual da programação tradicional para o emaranhamento não é tão fácil.

Eu encontrei de C libquantum também.

simulation ibm-q-experience programming

— DIDIx13
fonte

12

Supondo que você esteja considerando um computador quântico baseado em portas, a maneira mais fácil de produzir um estado enredado é produzir um dos estados de Bell. O circuito a seguir mostra o estado de Bell . $\left| \Phi^+ \right>$

Examinando , e podemos determinar o estado Entagled após a aplicação de todas as portas; $\left| \psi_0 \right>$ $\left| \psi_1 \right>$ $\left| \psi_2 \right>$

1. : $\left| \psi_0 \right>$

| ψ_{0 0} ⟩ = | 0 0 0 0 ⟩

$\left| \psi_0 \right> = \left | 0 0 \right >$

$\left| \psi_1 \right>$

O Hadamard-Gate se aplica ao primeiro qubit, o que resulta no seguinte:

| ψ_{1} ⟩ = (H \otimes Eu) | 0 0 0 0 ⟩ = H | 0 0 ⟩ \otimes | 0 0 ⟩ = \frac{1}{\sqrt{2}} (| 0 0 ⟩ + | 1 ⟩) | 0 0 ⟩ = \frac{1}{\sqrt{2}} (| 0 0 0 0 ⟩ + | 1 0 0 ⟩)

$\left| \psi_1 \right> =(H \otimes I)\left | 0 0 \right > = H\left | 0 \right > \otimes \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 \right > + \left | 1 \right > \right ) \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 0 \right > \right )$

$\left| \psi_2 \right>$

Agora, uma porta CNOT é aplicada e vira o segundo qubit, mas apenas onde o primeiro tem o valor 1. O resultado é

| ψ_{2} ⟩ = \frac{1}{\sqrt{2}} (| 0 0 0 0 ⟩ + | 11 ⟩)

$\left| \psi_2 \right> = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 1 \right > \right )$

$\left| \psi_2 \right>$

Embora a abordagem acima possa não parecer programação para você no sentido usual, aplicar portas aos estados é basicamente como funciona a programação de um computador quântico baseado em portas. Existem camadas de abstração que permitem executar a programação de alto nível, mas traduzem os comandos para a aplicação de portas. A interface do IBM Quantum Experience fornece esses recursos.

Em um idioma como o Q # da Microsoft, o exemplo acima pode ser semelhante a este:

operation BellTest () : ()
{
    body
    {
        // Use two qubits
        using (qubits = Qubit[2])
        {
            Set (One, qubits[0]);
            Set (Zero, qubits[1]);

            // Apply Hadamard gate to the first qubit
            H(qubits[0]);

            // Apply CNOT gate
            CNOT(qubits[0],qubits[1]);
         }
     }
}

Uma versão mais detalhada (incluindo medição) pode ser encontrada aqui: Microsoft: Escrevendo um programa Quantum .

— dtell
fonte

14

Uma maneira de escrever programas quânticos é com o QISKit. Isso pode ser usado para executar os programas nos dispositivos da IBM. O site do QISKit sugere o seguinte snippet de código para você começar, que é um circuito emaranhado conforme desejado. É também o mesmo processo que na resposta por datell. Vou comentar linha por linha.

# import and initialize the method used to store quantum programs
from qiskit import QuantumProgram
qp = QuantumProgram()
# initialize a quantum register of two qubits
qr = qp.create_quantum_register('qr',2) 
# and a classical register of two bits
cr = qp.create_classical_register('cr',2) 
# create a circuit with them which we call 'Bell'
qc = qp.create_circuit('Bell',[qr],[cr]) 
# apply a Hadamard to the first qubit
qc.h(qr[0]) 
# apply a controlled not with the first qubit as control
qc.cx(qr[0], qr[1]) 
# measure the first qubit and store its result on the first bit
qc.measure(qr[0], cr[0]) 
# the same for the second qubit and bit
qc.measure(qr[1], cr[1]) 
# run the circuit
result = qp.execute('Bell') 
# extract the results
print(result.get_counts('Bell'))

Observe que o comando 'execute' aqui especifica apenas o programa a ser executado. Todas as outras configurações, como o dispositivo que você deseja usar, o número de vezes que você deseja repeti-lo para obter estatísticas, etc. são definidas com seus valores padrão. Para executar no ibmqx4 para 1024 fotos, você pode usar

results = qp.execute(['Bell'], backend='ibmqx4', shots=1024)

— James Wootton
fonte

4

O programa quântico mais simples que consigo pensar é um gerador de números aleatórios verdadeiro (1 bit). Como um circuito quântico, fica assim:

Você primeiro prepara um qubit no estado $|0 \rangle$ $\frac{\sqrt{2}}{2} ( \left| 0 \right> + \left| 1 \right> )$ que você então medir na base computacional. O resultado da medição é $|0\rangle$ ou $|1\rangle$

— pirâmides
fonte