📔 👨‍🎓 😳 El libro "Desarrollo usando computadoras cuánticas" 👨🏿‍🎤 👱 🤘🏿

Hola habrozhiteli! ¡La computación cuántica no solo cambia la realidad! Nace una industria completamente nueva ante nuestros ojos para crear lo impensable antes y devaluar algunos de los logros del pasado. Este libro discute los componentes más importantes de una computadora cuántica: qubits, puertas lógicas y circuitos cuánticos, y también explica la diferencia entre la arquitectura cuántica y la tradicional. Puede experimentar con ellos de forma gratuita tanto en el simulador como en un dispositivo cuántico real utilizando IBM Q Experience.

Aprenderá cómo se realizan los cálculos cuánticos utilizando QISKit (herramientas de software para procesar información cuántica), el SDK de Python y otras API, en particular QASM.

Finalmente, estudiará algoritmos cuánticos modernos que implementan entrelazamiento, generación de números aleatorios, búsqueda lineal, factorización de enteros y otros. Nos ocuparemos de los estados de Bell que describen el enredo, el algoritmo de búsqueda lineal de Grover, el algoritmo de Shor para la factorización de enteros, algoritmos de optimización y mucho más. .

Aprenderá: • Ejecutar programas de forma remota utilizando la API REST de Q Experience. • Escribir algoritmos que brinden el mayor rendimiento en comparación con los análogos para computadoras tradicionales. • Cree un cliente REST en Node.js para autenticar, escuchar dispositivos remotos, solicitar información sobre procesadores cuánticos, controlar de forma remota y realizar experimentos en la nube. • Utiliza la teletransportación cuántica. Usando cálculos clásicos y entrelazamiento cuántico entre el emisor y el receptor, transmita el estado exacto del qubit (información cuántica). • Programa y juega la versión cuántica de Sea Battle. • Utilice Q Experience Composer para crear programas / experimentos visuales.

Extracto. Teoría del juego: con la mecánica cuántica, la ventaja siempre está de tu lado

Este capítulo explora dos acertijos de juegos que demuestran la impresionante superioridad de los algoritmos cuánticos sobre sus contrapartes clásicas.

El acertijo de la moneda falsa. Este es el clásico problema de pesaje propuesto por el matemático E.D. Shell en 1945. En él, utilizando una báscula de laboratorio para un número limitado de pesadas, debe determinar una moneda cuyo peso difiere del peso de los demás (falso).
El cuadrado mágico de Mermin - Pérez. Este es un ejemplo de pseudo telepatía cuántica, o la capacidad de los jugadores para lograr resultados que son posibles solo si leen los pensamientos de los demás durante el juego.

En ambos casos, la computación cuántica capacita a los jugadores con habilidades pseudo-mágicas, como si estuvieran haciendo trampa todo el tiempo. Veamos cómo sucede esto.

El acertijo de monedas falsas

El jugador tiene ocho monedas y una escala de laboratorio. Una de las monedas es falsa y, por lo tanto, pesa menos que el resto. ¿Puedes encontrarla? Veamos brevemente la solución que se muestra en la fig. 7.1.

1. Coloque las monedas 1-3 en el lado izquierdo de la escala y 4-6 en el derecho. Ponga a un lado las monedas 7 y 8.

2. Si el lado derecho de la balanza ha superado, entonces falso - entre las monedas 1-3 (a la izquierda). Recuerda que la moneda falsa es más fácil. Luego retire la moneda 3 y coloque la moneda 1 en el lado izquierdo de la escala y la moneda 2 en el derecho.

Si el tazón derecho supera, entonces falso - moneda 1.
Si el tazón izquierdo supera, entonces el falso - moneda 2.
Si el saldo está equilibrado, entonces falso - moneda 3.

3. Si el lado izquierdo de la balanza ha superado, el falso, entre las monedas 4–6. Retire la moneda 6 y coloque la moneda 4 en el lado izquierdo de la escala y la moneda 5 a la derecha.

Si el tazón derecho supera, entonces falso - moneda 4.
Si el tazón izquierdo supera, entonces el falso - moneda 5.
Si el saldo está equilibrado, entonces falso - moneda 6.

4. Si la balanza está equilibrada, la moneda falsificada es 7 u 8. Coloque la moneda 7 en el lado izquierdo de la balanza y la moneda 8 en el lado derecho y péselo.

Si el tazón derecho supera, entonces falso - moneda 7.
Si el tazón izquierdo pesa más que la moneda falsa 8.

El algoritmo clásico se puede implementar independientemente del número total de monedas N y el número de monedas falsas k. En general, la complejidad temporal para el problema de moneda falsa generalizada es O (k log (N / k)).

NOTA
Se ha demostrado que se necesitan al menos dos intentos para detectar una moneda falsificada utilizando una balanza de laboratorio en una computadora clásica.

Solución cuántica

Lo creas o no, hay un algoritmo cuántico que puede encontrar una moneda falsa en un pesaje cuántico, ¡independientemente del número de monedas N! En términos generales, para cualquier cantidad de monedas falsas k, independientemente de N, la complejidad temporal de dicho algoritmo es imagen

NOTA El
algoritmo cuántico para determinar una moneda falsa es un ejemplo de aceleración de cuarto grado en comparación con su contraparte clásica.

Entonces, en la fig. 7.2 muestra la superioridad del algoritmo cuántico sobre la contraparte clásica para resolver el enigma de la moneda falsa. Consideremos con más detalle. El algoritmo de búsqueda cuántica para una moneda falsificada imagen

se puede dividir en tres etapas: una solicitud de pesos cuánticos, la creación de pesos cuánticos y la definición de una moneda falsificada.

Paso 1. Solicitud de pesos cuánticos

El algoritmo cuántico consultará los pesos cuánticos en superposición. Para hacer esto, use una cadena de consulta binaria para codificar monedas en las escalas. Por ejemplo, la línea de consulta 11101111 significa que todas las monedas están en la balanza, excepto la moneda con índice 3. Las balanzas se equilibran si no hay monedas falsas y, de lo contrario, se inclinan. Esto se ilustra en la siguiente tabla.

El algoritmo de acciones es el siguiente.

1. Use dos registros cuánticos para consultar pesos cuánticos, donde el primer registro es para la cadena de consulta y el segundo para el resultado.

2. Prepare una superposición de todas las cadenas de consulta binarias con un número par de unidades.

3. Para obtener una superposición de estados con un número par de unidades, realice la transformación de Hadamard en el estado base y verifique si el peso de Hamming para | x | incluso. Se puede demostrar que el peso de Hamming para | x | es incluso si y solo si x1 ⊕ x2 ⊕ ... ⊕ xN = 0.

NOTA
El peso de Hamming (hw) de una cadena es el número de caracteres distintos del carácter nulo del alfabeto utilizado. Por ejemplo, hw (11101) = 4, hw (11101000) = 4, hw (000000) = 0.

4. Finalmente, mida el segundo registro. Si se observa una condición imagen

, el primer registro es una superposición de todas las cadenas de consulta binarias deseadas. Si se recibe imagen

, debe repetir el procedimiento hasta que se observe una condición. imagen

Tenga en cuenta que con cada repetición, la probabilidad de éxito es exactamente 0.5. Sin embargo, después de varias repeticiones, podemos obtener la superposición deseada de estados. El listado 7.1 muestra la implementación del programa cuántico para consultar los pesos, y el diagrama gráfico correspondiente se muestra en la Fig. 7.3.

NOTA
Para simplificar la percepción, el programa para determinar una moneda falsa se divide en listados 7.1–7.3. Aunque espero que pueda combinar estos listados para ejecutar el programa, el código completo se encuentra en la fuente del archivo Workspace\Ch07\p_counterfeitcoin.py.

Listado 7.1. Script de consulta de pesos cuánticos

# -------    
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])

#  numberOfCoins +1 / 
#      
#  
qr = Q_program.create_quantum_register("qr", numberOfCoins + 1)

#     qr
cr = Q_program.create_classical_register("cr", numberOfCoins + 1)

circuitName = "QueryStateCircuit"
circuit = Q_program.create_circuit(circuitName, [qr], [cr])

N = numberOfCoins

#       N
for i in range(N):
     circuit.h(qr[i])

#  XOR(x)     CNOT  qr[0]
#  qr[N–1]     qr[N]
for i in range(N):
     circuit.cx(qr[i], qr[N])

#  qr[N]     cr[N]. ,
#  cr[N]  ,     
circuit.measure(qr[N], cr[N])

#     ,     
# cr[0]...cr[N],     |1>,
#   |0> - |1>  qr[N]
circuit.x(qr[N]).c_if(cr, 0)
circuit.h(qr[N]).c_if(cr, 0)

#      cr[N]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 2**N)

En la Fig. 7.3 es un esquema completo del rompecabezas de monedas falsas con ocho monedas y una falsa con índice 6. Muestra todos los pasos descritos aquí para la plataforma IBM Q Experience. La segunda etapa del algoritmo es la creación de pesas.

Paso 2. Crear pesos cuánticos

En la sección anterior, creamos una superposición de todas las cadenas de consulta binarias para las cuales el peso de Hamming es par. En este paso, cree un equilibrador cuántico, estableciendo la posición de la moneda falsa. Por lo tanto, si k es la posición de la moneda falsificada en relación con la cadena binaria, las imagen

escalas cuánticas devolverán:

Esto se implementa usando la puerta CNOT con xk como el qubit de control y el segundo registro como el objetivo (ver Listado 7.2).

Listado 7.2. Creando pesos cuánticos

#-----   
k = indexOfFalseCoin

#       
# (  cr,  )
circuit.cx(qr[k], qr[N]).c_if(cr, 0)

Paso 3. Identifica una moneda falsa

Para revelar una moneda falsa después de una consulta a los pesos, aplique la transformación Hadamard a la cadena de consulta binaria. Se supone que estamos haciendo una consulta sobre pesos cuánticos con cadenas binarias con un peso de Hamming uniforme, por lo tanto, después de haber realizado una medición en la base computacional después de la transformación de Hadamard, podemos determinar una moneda falsa, ya que solo su etiqueta difiere de la mayoría de las etiquetas (ver Listado 7.3).

Listado 7.3. Definición de moneda falsa

# ---   
#     qr[0] ... qr[N-1]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 0)

#  qr[0] ... qr[N–1]
for i in range(N):
     circuit.measure(qr[i], cr[i])

results = Q_program.execute([circuitName], backend=backend, shots=shots)
answer = results.get_counts(circuitName)

print("Device " + backend + " counts " + str(answer))

#     
for key in answer.keys():
     normalFlag, _ = Counter(key[1:]).most_common(1)[0]

for i in range(2,len(key)):
     if key[i] != normalFlag:
          print("False coin index is: ", len(key) - i - 1)

Cuando el bit más a la izquierda es 0, el índice de moneda falsificada se puede determinar encontrando uno cuyo peso es diferente del peso de los demás. Por ejemplo, con N = 8 y el índice de monedas falsas 6, el resultado debe ser 010111111 o 001000000. Tenga en cuenta que dado que usamos cr [N] para controlar la operación antes y después de la solicitud de pesos:

si el bit más a la izquierda es 0, entonces hemos identificado con éxito la moneda falsificada;
si el bit más a la izquierda es 1, entonces no obtuvimos la superposición deseada y debemos repetir el proceso nuevamente.

Cuando ejecuta el programa en un simulador remoto de IBM Q Experience, obtendrá el resultado que se muestra en el código fuente del libro Workspace\Ch07\p_counterfeitcoin.py. Tenga en cuenta que uso Windows: si no tiene acceso al código fuente del libro, pero aún así desea experimentar con este script, coloque los fragmentos de código de las secciones anteriores en el contenedor de script del Listado 7.4 (verifique la sangría, esta función de sintaxis de Python es simple loco). Listado 7.4. El contenedor de script principal para el acertijo de monedas falsas

c:\python36-64\python.exe p_counterfeitcoin.py
Device ibmq_qasm_simulator counts {'001000000': 1}
False coin index is: 6

import sys
import matplotlib.pyplot as plt
import numpy as np
from math import pi, cos, acos, sqrt
from collections import Counter
from qiskit import QuantumProgram
sys.path.append('../Config/')
import Qconfig

#      
import basic plot tools
from qiskit.tools.visualization import plot_histogram

def main(M = 16, numberOfCoins = 8 , indexOfFalseCoin = 6
      , backend = "local_qasm_simulator" , shots = 1 ):

      if numberOfCoins < 4 or numberOfCoins >= M:
           raise Exception("Please use numberOfCoins between 4 and ", M-1)
      if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
           raise Exception("indexOfFalseCoin must be between 0 and ",
           numberOfCoins-1)

      //   7.1–7.3 

#################################################
# main
#################################################
if __name__ == '__main__':
     M = 8                      #    
     numberOfCoins = 4          #  M-1,  M —   
     indexOfFalseCoin = 2             #   0, 1... numberOfCoins — 1

     backend = "ibmq_qasm_simulator"
     #backend = "ibmqx3"
     shots = 1                         #      

     main(M, numberOfCoins, indexOfFalseCoin, backend, shots)

Algoritmo generalizado para cualquier cantidad de monedas falsas

Para resolver el enigma de las monedas falsas, los matemáticos Terhal y Smolin en 1998 crearon un algoritmo generalizado para cualquier cantidad de monedas falsas (k> 1). En su implementación, se utiliza el modelo "B-oracle" ("oráculo equilibrado"), mientras que:

en la entrada
se crea una cadena de consulta, que consta de N triples de bits de manera que con el mismo número de 1 y –1;
la respuesta es uno de esos bits

NOTA El
Oracle es parte del algoritmo, considerado como un cuadro negro. Se utiliza para simplificar esquemas y comparar la complejidad de algoritmos cuánticos y clásicos. Un buen oráculo debe ser rápido, versátil y fácil de implementar.

Un ejemplo del uso del oráculo B para dos monedas falsas con k = 2 y N = 6 se muestra en la Fig. 7.4.

En general, el enigma de la moneda falsa es un ejemplo típico de la aceleración del algoritmo cuántico en comparación con la contraparte clásica. En la siguiente sección, consideraremos otro rompecabezas pseudo-mágico peculiar llamado "el cuadrado mágico de Mermin - Pérez".

Sobre el Autor

Vladimir Silva se graduó de la Universidad Estatal Middle TN con una maestría en Ciencias de la Computación. Durante cinco años, trabajó en IBM como ingeniero de investigación, donde adquirió una amplia experiencia en informática distribuida y GRID.

Vladimir tiene muchos certificados, incluidos OCP (Oracle Certified Professional), MCSD (Microsoft Certified Solutions Developer) y MCP (Microsoft Certified Professional). También es autor de una gran cantidad de artículos técnicos para el sitio de IBM developerWorks. Ha escrito los siguientes libros: Grid Computing for Developers (Charles River Media), Practical Eclipse Rich Client Platform (Apress), Pro Android Games (Apress) y Advanced Android 4 Games (Apress).

Vladimir es un ávido corredor de maratón que participó en 16 carreras en Carolina del Norte (al momento de escribir este artículo). Le encanta tocar la guitarra clásica y reflexionar sobre cosas tan sorprendentes como la mecánica cuántica.

Sobre editores de ciencias

Edición original

Jason Whitehorn es un emprendedor experimentado y desarrollador de software. Ha ayudado a muchas compañías de petróleo y gas a automatizar y mejorar su tecnología a través de la recopilación de datos operativos, SCADA (Control de supervisión y adquisición de datos) y aprendizaje automático. Jason se graduó de la Universidad Estatal de Arkansas con una licenciatura en Ciencias de la Computación.

A Jason le encanta pasar tiempo libre con su esposa y sus cuatro hijos. Vive en Tulsa, Oklahoma. Puede encontrar más información sobre Jason en su sitio web jason.whitehorn.us .

Edición rusa

Mikhail Korobko- un físico, se dedica a la teoría y los experimentos sobre la aplicación de óptica cuántica, optomecánica y mediciones cuánticas para mejorar la sensibilidad de los detectores de ondas gravitacionales. Desde 2012, ha sido miembro de la colaboración internacional de científicos en el detector de ondas gravitacionales LIGO.

Mikhail se graduó del Departamento de Física de la Universidad Estatal de Moscú. Lomonosov, actualmente es un estudiante graduado del Instituto de Física Láser de la Universidad de Hamburgo. Pasa su tiempo libre con su familia, escribe artículos de divulgación científica sobre física cuántica y publica publicaciones en Twitter (@hbar_universe).

»Se puede encontrar más información sobre el libro en el sitio web de la editorial
» Tabla de contenido
» Extracto

para Savingsbenders Cupón de 25% de descuento - Silva

Tras el pago de la versión en papel del libro, se envía un libro electrónico por correo electrónico.

El libro "Desarrollo usando computadoras cuánticas"