Come sarebbe un programma quantistico molto semplice?

15

Dopo aver letto il " primo chip fotonico quantico programmabile ". Mi chiedevo come sarebbe il software per un computer che utilizza l'entanglement quantistico.

Esiste un esempio di codice per la programmazione quantistica specifica? Come pseudocodice o linguaggio di alto livello? In particolare, qual è il programma più breve che può essere utilizzato per creare uno stato Bell partendo da uno stato inizializzato autilizzando sia una simulazione e uno di IBMQuantum Experienceprocessori, comel'ibmqx4?

| ψ ⟩ = \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>$

Fare il salto concettuale dalla programmazione tradizionale all'entanglement non è così facile.

Ho trovato di C libquantum troppo.

simulation ibm-q-experience programming

— DIDIx13
fonte

12

Supponendo che stai prendendo in considerazione un computer quantistico basato su gate, il modo più semplice per produrre uno stato coinvolto è quello di produrre uno degli stati Bell. Il seguente circuito mostra lo stato di Bell . $\left| \Phi^+ \right>$

Esaminando , e possiamo determinare lo stato Entagled dopo l'applicazione di tutte le porte: $\left| \psi_0 \right>$ $\left| \psi_1 \right>$ $\left| \psi_2 \right>$

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

| ψ_{0} ⟩ = | 00 ⟩

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

$\left| \psi_1 \right>$

Hadamard-Gate si applica al primo qubit che si traduce in quanto segue:

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

$\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>$

Ora viene applicato un gate CNOT e lancia il secondo qubit ma solo dove il primo ha il valore 1. Il risultato è

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

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

$\left| \psi_2 \right>$

Sebbene l'approccio di cui sopra potrebbe non sembrare una programmazione come al solito, applicare le porte agli stati è fondamentalmente come funziona la programmazione di un computer quantistico basato su gate. Esistono livelli di astrazione che ti consentono di eseguire una programmazione di alto livello ma traducono i comandi nell'applicazione di gate. L' interfaccia IBM Quantum Experience fornisce tali funzionalità.

In un linguaggio come il Q # di Microsoft, l'esempio sopra potrebbe essere simile al seguente:

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]);
         }
     }
}

Una versione più dettagliata (compresa la misurazione) è disponibile qui: Microsoft: Writing a Quantum Program .

— dtell
fonte

14

Un modo di scrivere programmi quantistici è con QISKit. Questo può essere usato per eseguire i programmi sui dispositivi IBM. Il sito web QISKit suggerisce il seguente frammento di codice per iniziare, che è un circuito intrecciato come desideri. È anche lo stesso processo della risposta per datell. Lo commenterò riga per riga.

# 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'))

Si noti che il comando 'execute' qui specifica solo il programma da eseguire. Tutte le altre impostazioni, come il dispositivo che si desidera utilizzare, il numero di volte che si desidera ripeterlo per ottenere statistiche, ecc. Sono impostate sui valori predefiniti. Per eseguire su ibmqx4 per 1024 scatti, puoi invece utilizzare

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

— James Wootton
fonte

4

Il più semplice programma quantistico che mi viene in mente è un generatore di numeri casuali (1 bit) vero. Come un circuito quantistico, assomiglia a questo:

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

— piramidi
fonte