¿Cómo sería un programa cuántico muy simple?

Después de leer el " primer chip fotónico cuántico programable ". Me preguntaba cómo sería un software para una computadora que usa enredos cuánticos.

¿Hay algún ejemplo de código para la programación cuántica específica? ¿Te gusta el pseudocódigo o el lenguaje de alto nivel? Específicamente, ¿cuál es el programa más corto que se puede usar para crear un estado Bell

$$\left|\psi\right> = \frac{1}{\sqrt 2} \left(\left|00\right> + \left|11\right> \right)$$ a partir de un estado inicializado a$\left|\psi_0\right> = \left|00\right>$utilizando tanto una simulación y una de las de IBMQuantum Experiencia procesadores, tales como el ibmqx4 ?

Hacer el salto conceptual de la programación tradicional al enredo no es tan fácil.

---

He encontrado de C libquantum también.

Suponiendo que esté considerando una computadora cuántica basada en compuerta, la forma más fácil de producir un estado enredado es producir uno de los estados de Bell. El siguiente circuito muestra el estado de Bell .$\left| \Phi^+ \right>$

Al examinar , | ψ 1 ⟩ y | ψ 2 $\left| \psi_0 \right>$$\left| \psi_1 \right>$$\left| \psi_2 \right>$ podemos determinar el estado Entagled después de la aplicación de todas las puertas:

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

No sucede mucho aquí ya que no se aplicaron puertas en este punto. Por lo tanto, el estado de todo el sistema es solo el producto tensorial de los estados individuales que escribimos así:

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

$\left| \psi_1 \right>$ :

La puerta de Hadamard se aplica al primer qubit que da como resultado lo siguiente:

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

Ahora se aplica una puerta CNOT y voltea el segundo qubit pero solo donde el primero tiene el valor 1. El resultado es

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

$\left| \psi_2 \right>$ es un estado Entagled y por lo general la forma más natural para llegar a tal situación. Los estados de campana ocurren en muchos algoritmos cuánticos interesantes, como la codificación súper densa o la teletransportación.

Aunque el enfoque anterior puede no parecerte programar en un sentido habitual, aplicar puertas a los estados es básicamente cómo funciona la programación de una computadora cuántica basada en puertas. Existen capas de abstracción que le permiten realizar programación de alto nivel pero traducir los comandos a la aplicación de puertas. La experiencia cuántica de IBM interfaz de proporciona tales características.

En un lenguaje como el Q # de Microsoft, el ejemplo anterior podría parecerse a esto:

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

Puede encontrar una versión más detallada (incluida la medición) aquí: Microsoft: Escribir un programa cuántico .

Una forma de escribir programas cuánticos es con QISKit. Esto se puede utilizar para ejecutar los programas en los dispositivos de IBM. El sitio web de QISKit sugiere el siguiente fragmento de código para ponerlo en marcha, que es un circuito enredado como desee. También es el mismo proceso que en la respuesta de datell. Lo comentaré línea por línea.

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

Tenga en cuenta que el comando 'ejecutar' aquí solo especifica el programa a ejecutar. Todas las demás configuraciones, como el dispositivo que desea usar, la cantidad de veces que desea repetirlo para obtener estadísticas, etc., se establecen en sus valores predeterminados. Para ejecutar ibmqx4 para 1024 disparos, puede usar

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

El programa cuántico más simple que se me ocurre es un generador de números aleatorios verdaderos (1 bit). Como circuito cuántico, se ve así:

Primero preparas un qubit en el estado $|0 \rangle$, luego aplique una puerta Hadamard para producir la superposición $\frac{\sqrt{2}}{2} ( \left| 0 \right> + \left| 1 \right> )$que luego mides en la base computacional. El resultado de la medición es$|0\rangle$ o $|1\rangle$, cada uno con una probabilidad del 50%.