Un algoritmo cuántico de muestra, útil para demostrar idiomas

9

Estoy buscando un algoritmo cuántico que pueda usar para demostrar la sintaxis de diferentes lenguajes cuánticos. Mi pregunta es similar a esto , sin embargo, para mí, "bueno" significa:

Lo que hace podría describirse en 1-2 párrafos, y debería ser fácil de entender.
Debería usar más elementos del "mundo de programación cuántica" (quiero decir que el algoritmo debería usar algunas constantes clásicas, mediciones, condiciones, registros q, operadores, etc., la mayor cantidad posible).
El algoritmo debe ser pequeño (como máximo 15-25 líneas de pseudocódigo largas).

Los algoritmos útiles son a menudo demasiado largos / difíciles, pero el algoritmo de Deutsch no usa tantos elementos. ¿Alguien puede sugerirme un algoritmo bueno para demostración?

algorithm resource-request programming

— klenio
fuente

¿Es su requisito también que debe ser un "algoritmo" con una entrada clásica y una salida clásica, y un claro beneficio / diferencia de la forma en que funcionaría el algoritmo clásico equivalente?

— DaftWullie

@DaftWullie Estos no son obligatorios. El parámetro de un operador o la inicialización constante clásica pueden representar la "entrada" para mí, y proporcionaré el formato de salida si es necesario. No necesita hacer / ser especial. El foco está en la sintaxis de los idiomas, la descripción es solo para validar que los códigos en diferentes idiomas son los mismos. El significado del algoritmo es irrelevante.

— klenium

¡Bienvenido a Quantum Computing SE! Solo para verificar, ¿es su criterio para una buena respuesta la mayor cantidad de elementos en el pseudocódigo más corto?

— Mithrandir24601

1

@ Mithrandir24601 ¡Gracias! Sí, de alguna manera así.

— klenium

3

Sugiero mirar los protocolos de estimación de valores propios / vectores propios. Hay mucha flexibilidad para hacer que el problema sea tan fácil o difícil como desee.

Comience eligiendo dos parámetros, y . Desea diseñar una unidad unitaria, que tenga valores propios de la forma para enteros . Asegúrese de que al menos uno de esos valores propios sea único y llámelo . También asegúrese de que un estado del producto simple, digamos , tiene no nulo solapamiento con el vector propio de valor propio . $n$ $k$ $n$ $U$ $e^{-2\pi iq/2^k}$ $q$ $\omega$ $|0\rangle^{\otimes n}$ $\omega$

El objetivo sería implementar un algoritmo de estimación de fase en esto, recibir el valor y la tarea de generar un vector que es el vector propio correspondiente al valor propio . En general, esto comprenderá un circuito de qubits (a menos que necesite ancillas para implementar controlado ). $k$ $|\psi\rangle$ $\omega$ $n+k$ $U$

Esto funciona de la siguiente manera:

configure dos registros, uno de qubits y el otro de qubits. ( uso de registros cuánticos ) $k$ $n$

cada qubit se inicializa en el estado . ( inicialización de registros cuánticos ) $|0\rangle$

aplicar un Hadamard a cada qubit en el primer registro ( compuertas de un solo qubit )

de qubit en el primer registro, aplicar controlada , la orientación del segundo registro ( multi-qubit controlada puertas ) $r$ $U^{2^{r}}$

aplique la transformada inversa de Fourier en el primer registro y mida cada qubit del primer registro en la base estándar. Estos se pueden combinar, implementando la transformada de Fourier semiclásica . ( medición y avance de datos clásicos )

para el resultado de medición correcto, el segundo registro está en el estado deseado . $|\psi\rangle$

Para simplificar, puede elegir , , por lo que necesita una matriz unitaria con valores propios . Usaría algo como donde denota el NOT controlado. Solo hay un vector propio con valor propio -1, que es $n=2$ $k=1$ $4\times 4$ $\pm 1$

(U_{1} \otimes U_{2}) C (U_{1}^{†} \otimes U_{2}^{†}),

$(U_1\otimes U_2)C(U_1^\dagger\otimes U_2^\dagger),$

C

$C$

, y puede meterse con las opciones de

y

para explorar la implementación de

usando la descomposición en términos de un conjunto de compuerta universal (probablemente establecería esto como un problema preliminar). Luego, la

controladase implementa fácilmente simplemente reemplazando la puerta controlada-NO por una puerta controlada-controlada-NO (Toffoli). Finalmente, la transformada inversa de Fourier es solo una puerta de Hadamard.

| ψ ⟩ = (U_{1} \otimes U_{2}) | 1 ⟩ \otimes (| 0 ⟩ - | 1 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)|1\rangle\otimes(|0\rangle-|1\rangle)/\sqrt{2}$

U_{1}

$U_1$

U_{2}

$U_2$

U

$U$

U

$U$

$k=3$ $C$

(\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \end{array})

$\left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \\ \end{array} \right)$

ω = e^{\pm i π / 4}

$\omega=e^{\pm i\pi/4}$

| ψ ⟩ = (U_{1} \otimes U_{2}) (| 01 ⟩ \pm | 10 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)(|01\rangle\pm|10\rangle)/\sqrt{2}$

— DaftWullie
fuente

3

Parece que quieres un "Hola Mundo" cuántico. La versión cuántica más sencilla de esto sería escribir una versión codificada en binario del texto Hello Worlden un registro de qubits. Pero esto requeriría ~ 100 qubits y sería más largo que su límite superior para la longitud del código.

Así que escribamos una porción de texto más corta. Vamos a escribir;) , necesitamos una cadena de bits de longitud 16. Específicamente, usando codificación ASCII

;)  =  00111011 00101001

Usando QISKit, haría esto usando el siguiente código.

from qiskit import QuantumProgram
import Qconfig

qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url

# set up registers and program
qr = qp.create_quantum_register('qr', 16)
cr = qp.create_classical_register('cr', 16)
qc = qp.create_circuit('smiley_writer', [qr], [cr])

# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])

# second eight (qu)bits have 00111011
# these differ only on the rightmost two bits
qc.x(qr[9])
qc.x(qr[8])
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])

# measure
for j in range(16):
    qc.measure(qr[j], cr[j])

# run and get results
results = qp.execute(["smiley_writer"], backend='ibmqx5', shots=1024)
stats = results.get_counts("smiley_writer")

Por supuesto, esto no es muy cuántico. Entonces, podrías hacer una superposición de dos emoticones diferentes. El ejemplo más fácil es superponer;) con 8), ya que las cadenas de bits para estos difieren solo en los qubits 8 y 9.

;)  =  00111011 00101001
8)  =  00111000 00101001

Entonces puedes simplemente reemplazar las líneas

qc.x(qr[9])
qc.x(qr[8])

de lo anterior con

qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a cnot

El Hadamard crea una superposición de 0y 1, y el nudo lo convierte en una superposición de 00y11 en dos qubits. Esta es la única superposición requerida para ;)y 8).

Si desea ver una implementación real de esto, se puede encontrar en el tutorial QISKit (divulgación completa: fue escrito por mí).

— James Wootton
fuente

Obtengo 404 para ese enlace. ¿Movió el archivo a otra parte?

— klenium

Parece que el tutorial se acaba de actualizar. Cambié el enlace, por lo que debería funcionar ahora.

— James Wootton el

1

Yo propondría el generador de números aleatorios (perfecto) de 1 bit. Es casi trivialmente fácil:

Comienza con un solo qubit en el estado inicial habitual $\left|0\right>$ . Luego aplicas la puerta Hadamard $H$ que produce la superposición igual de $\left|0\right>$ y $\left|1\right>$ . Finalmente, mides este qubit para obtener 0 o 1, cada uno con un 50% de probabilidad.

— pirámides
fuente