💃🏼 🐆 🔦 Le livre "Développement utilisant des ordinateurs quantiques" 🤳🏿 🆕 ✖️

Bonjour, habrozhiteli! L'informatique quantique ne change pas seulement la réalité! Une toute nouvelle industrie est en train de naître sous nos yeux afin de créer l'impensable d'avant et de dévaluer certaines des réalisations du passé. Ce livre traite des composants les plus importants d'un ordinateur quantique: qubits, portes logiques et circuits quantiques, et explique également la différence entre l'architecture quantique et traditionnelle. Vous pouvez les expérimenter gratuitement à la fois dans le simulateur et sur un véritable appareil quantique à l'aide d'IBM Q Experience.

Vous apprendrez comment les calculs quantiques sont effectués à l'aide de QISKit (outils logiciels pour le traitement des informations quantiques), du SDK Python et d'autres API, en particulier QASM.

Enfin, vous étudierez des algorithmes quantiques modernes qui implémentent l'intrication, la génération de nombres aléatoires, la recherche linéaire, la factorisation des nombres entiers, etc. .

Vous apprendrez: • Exécuter des programmes à distance à l'aide de l'API Q Experience REST. • Écrire des algorithmes qui offrent les meilleures performances par rapport aux analogues pour les ordinateurs traditionnels. • Créez un client REST sur Node.js pour vous authentifier, écouter les périphériques distants, demander des informations sur les processeurs quantiques, contrôler à distance et exécuter des expériences dans le cloud. • Utilisez la téléportation quantique. En utilisant des calculs classiques et l'intrication quantique entre l'expéditeur et le récepteur, transmettez l'état exact du qubit (informations quantiques). • Programmez et jouez la version quantique de Sea Battle. • Utilisez Q Experience Composer pour créer des programmes / expériences visuels.

Extrait. Théorie des jeux: avec la mécanique quantique, l'avantage est toujours de votre côté

Ce chapitre explore deux puzzles de jeu qui démontrent la supériorité impressionnante des algorithmes quantiques sur leurs homologues classiques.

L'énigme de la fausse pièce. C'est le problème de pesée classique proposé par le mathématicien E.D. Shell en 1945. Dans ce document, en utilisant une balance de laboratoire pour un nombre limité de pesées, vous devez déterminer une pièce dont le poids diffère du poids des autres (faux).
Le carré magique de Mermin - Perez. Ceci est un exemple de pseudo-télépathie quantique, ou la capacité des joueurs à obtenir des résultats qui ne sont possibles que s'ils se lisent mutuellement pendant le jeu.

Dans les deux cas, l'informatique quantique donne aux joueurs des capacités pseudo-magiques, comme s'ils trichaient tout le temps. Voyons comment cela se produit.

L'énigme de la fausse pièce

Le joueur possède huit pièces et une balance de laboratoire. L'une des pièces est fausse et pèse donc moins que les autres. Peux-tu la trouver? Jetons un bref coup d'œil à la solution illustrée à la fig. 7.1.

1. Placez les pièces 1-3 sur le côté gauche de l'échelle et 4-6 sur la droite. Mettez de côté les pièces 7 et 8.

2. Si le côté droit de la balance a dépassé, faussement - parmi les pièces 1-3 (à gauche). N'oubliez pas que la fausse pièce est plus facile. Retirez ensuite la pièce 3 et placez la pièce 1 sur le côté gauche de l'échelle et la pièce 2 sur la droite.

Si le bol droit l'emporte, alors faux - pièce 1.
Si le bol gauche l'emporte, alors le faux - pièce 2.
Si le solde est équilibré, alors faux - pièce 3.

3. Si le côté gauche de la balance a dépassé le poids, alors le faux - parmi les pièces 4–6. Retirez la pièce 6 et placez la pièce 4 sur le côté gauche de l'échelle et la pièce 5 sur la droite.

Si le bol droit l'emporte, alors faux - pièce 4.
Si le bol gauche l'emporte, alors le faux - pièce 5.
Si le solde est équilibré, alors faux - pièce 6.

4. Si la balance est équilibrée, la pièce contrefaite est 7 ou 8. Placez la pièce 7 sur le côté gauche de la balance et la pièce 8 sur le côté droit et pesez-la.

Si le bol droit l'emporte, alors faux - pièce 7.
Si le bol gauche l'emporte, la pièce contrefaite 8.

L'algorithme classique peut être mis en œuvre quel que soit le nombre total de pièces N et le nombre de pièces contrefaites k. En général, la complexité temporelle du problème généralisé des fausses pièces est O (k log (N / k)).

NOTE
Il a été prouvé qu'au moins deux tentatives sont nécessaires pour détecter une pièce contrefaite à l'aide d'une balance de laboratoire sur un ordinateur classique.

Solution quantique

Croyez-le ou non, il existe un algorithme quantique qui peut trouver une fausse pièce dans une pesée quantique, quel que soit le nombre de pièces N! D'une manière générale, pour un nombre quelconque de fausses pièces k, quel que soit N, la complexité temporelle d'un tel algorithme est

REMARQUE L'
algorithme quantique pour déterminer une fausse pièce est un exemple d'accélération du quatrième degré par rapport à son homologue classique.

Ainsi, dans la fig. 7.2 montre la supériorité de l'algorithme quantique sur l'homologue classique dans la résolution de l'énigme des fausses pièces. Examinons-le plus en détail. L'algorithme de recherche quantique d'une pièce contrefaite

peut être divisé en trois étapes: une demande de poids quantiques, la création de poids quantiques et la définition d'une pièce contrefaite.

Étape 1. Demande de poids quantiques

L'algorithme quantique interroge les poids quantiques en superposition. Pour ce faire, utilisez une chaîne de requête binaire pour coder les pièces sur les échelles. Par exemple, la ligne de requête 11101111 signifie que toutes les pièces sont sur les échelles, à l'exception de la pièce avec l'index 3. Les échelles sont équilibrées s'il n'y a pas de pièces contrefaites et sont inclinées autrement. Ceci est illustré dans le tableau suivant.

L'algorithme d'actions est le suivant.

1. Utilisez deux registres quantiques pour interroger les poids quantiques, où le premier registre est pour la chaîne de requête et le second pour le résultat.

2. Préparez une superposition de toutes les chaînes de requête binaires avec un nombre pair d'unités.

3. Pour obtenir une superposition d'états avec un nombre pair d'unités, effectuez la transformation de Hadamard dans l'état de base et vérifiez si le poids de Hamming pour | x | même. On peut montrer que le poids de Hamming pour | x | est pair si et seulement si x1 ⊕ x2 ⊕ ... ⊕ xN = 0.

REMARQUE
Le poids de Hamming (hw) d'une chaîne est le nombre de caractères autres que le caractère nul de l'alphabet utilisé. Par exemple, hw (11101) = 4, hw (11101000) = 4, hw (000000) = 0.

4. Enfin, mesurez le deuxième registre. Si une condition est observée

, le premier registre est une superposition de toutes les chaînes de requête binaires souhaitées. Si elle est reçue

, vous devez répéter la procédure jusqu'à ce qu'une condition soit observée.

Notez qu'à chaque répétition, la probabilité de réussite est exactement de 0,5. Cependant, après plusieurs répétitions, nous pouvons obtenir la superposition d'états souhaitée. Le listing 7.1 montre la mise en œuvre du programme quantique pour interroger les poids, et le diagramme graphique correspondant est montré sur la Fig. 7.3.

REMARQUE
Pour simplifier la perception, le programme de détermination d'une fausse pièce est divisé en listes 7.1–7.3. Bien que j'espère que vous pourrez combiner ces listes pour exécuter le programme, le code complet se trouve dans la source du fichier Workspace\Ch07\p_counterfeitcoin.py.

Listing 7.1. Script de requête de poids quantiques

# -------    
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 figue. 7.3 est un diagramme complet du puzzle de fausses pièces avec huit pièces et un faux avec index 6. Il montre toutes les étapes décrites ici pour la plateforme IBM Q Experience. La deuxième étape de l'algorithme est la création de poids.

Étape 2. Création de poids quantiques

Dans la section précédente, nous avons créé une superposition de toutes les chaînes de requête binaires pour lesquelles le poids de Hamming est pair. À cette étape, créez un équilibreur quantique, définissant la position de la fausse pièce. Ainsi, si k est la position de la pièce contrefaite par rapport à la chaîne binaire,

alors les échelles quantiques renverront:

Ceci est implémenté en utilisant la porte CNOT avec xk comme qubit de contrôle et le deuxième registre comme cible (voir l'extrait 7.2).

Listing 7.2. Création de poids quantiques

#-----   
k = indexOfFalseCoin

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

Étape 3. Identifiez une fausse pièce

Pour révéler une fausse pièce après une requête sur les poids, appliquez la transformation Hadamard à la chaîne de requête binaire. Il est supposé que nous effectuons une requête sur les poids quantiques avec des chaînes binaires avec un poids de Hamming pair.Par conséquent, après avoir effectué une mesure sur la base de calcul après la transformation de Hadamard, nous pouvons déterminer une fausse pièce, car seule son étiquette est différente de la plupart des étiquettes (voir l'extrait 7.3).

Listing 7.3. Définition de fausses pièces

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

Lorsque le bit le plus à gauche est 0, l'indice de la pièce contrefaite peut être déterminé en trouvant celui dont le poids est différent du poids des autres. Par exemple, avec N = 8 et un indice de pièce contrefait 6, le résultat devrait être 010111111 ou 001000000. Notez que puisque nous utilisons cr [N] pour contrôler l'opération avant et après la demande de poids:

si le bit le plus à gauche est 0, alors nous avons réussi à identifier la pièce contrefaite;
si le bit le plus à gauche est 1, alors nous n'avons pas obtenu la superposition souhaitée et devons répéter le processus à nouveau.

Lorsque vous exécutez le programme sur un simulateur IBM Q Experience distant, vous obtiendrez le résultat affiché dans le code source du livre Workspace\Ch07\p_counterfeitcoin.py. Notez que j'utilise Windows: si vous n'avez pas accès au code source du livre, mais que vous souhaitez toujours expérimenter avec ce script, placez les extraits de code des sections précédentes dans le conteneur de script du Listing 7.4 (vérifiez l'indentation, cette fonctionnalité de syntaxe Python est simple fou). Listing 7.4. Le conteneur de script principal pour l'énigme des fausses pièces

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)

Algorithme généralisé pour n'importe quel nombre de pièces contrefaites

Pour résoudre le mystère des fausses pièces, les mathématiciens Terhal et Smolin ont créé en 1998 un algorithme généralisé pour n'importe quel nombre de fausses pièces (k> 1). Dans leur mise en œuvre, le modèle «oracle B» («oracle équilibré») est utilisé, alors que:

à l'entrée
une chaîne de requête est créée, composée de N triplets de bits tels qu'avec le même nombre de 1 et –1;
la réponse est telle que

REMARQUE L'
Oracle fait partie de l'algorithme, considéré comme une boîte noire. Il est utilisé pour simplifier les schémas et comparer la complexité des algorithmes quantiques et classiques. Un bon oracle doit être rapide, polyvalent et facile à mettre en œuvre.

Un exemple d'utilisation de l'oracle B pour deux pièces contrefaites avec k = 2 et N = 6 est illustré à la Fig. 7.4.

En général, l'énigme de la fausse pièce est un exemple typique de l'accélération de l'algorithme quantique par rapport à son homologue classique. Dans la section suivante, nous considérerons un autre casse-tête pseudo-magique particulier appelé «le carré magique de Mermin - Perez».

A propos de l'auteur

Vladimir Silva est diplômé de la Middle TN State University avec une maîtrise en informatique. Pendant cinq ans, il a travaillé chez IBM en tant qu'ingénieur de recherche, où il a acquis une riche expérience en informatique distribuée et GRID.

Vladimir possède de nombreux certificats, dont OCP (Oracle Certified Professional), MCSD (Microsoft Certified Solutions Developer) et MCP (Microsoft Certified Professional). Il est également l'auteur d'un grand nombre d'articles techniques pour le site IBM developerWorks. Il a écrit les livres suivants: Grid Computing for Developers (Charles River Media), Practical Eclipse Rich Client Platform (Apress), Pro Android Games (Apress) et Advanced Android 4 Games (Apress).

Vladimir est un coureur de marathon passionné qui a participé à 16 courses en Caroline du Nord (au moment de la rédaction). Il aime jouer de la guitare classique et réfléchir à des choses aussi étonnantes que la mécanique quantique.

À propos des rédacteurs scientifiques

Edition originale

Jason Whitehorn est un entrepreneur et développeur de logiciels expérimenté. Il a aidé de nombreuses sociétés pétrolières et gazières à automatiser et à améliorer leur technologie grâce à la collecte de données opérationnelles, SCADA (contrôle de supervision et acquisition de données) et l'apprentissage automatique. Jason est diplômé de l'Arkansas State University avec un baccalauréat en informatique.

Jason aime passer du temps libre avec sa femme et ses quatre enfants. Vit à Tulsa, Oklahoma. Plus d'informations sur Jason peuvent être trouvées sur son site Web jason.whitehorn.us .

Édition russe

Mikhail Korobko- un physicien, est engagé dans la théorie et les expériences sur l'application de l'optique quantique, l'optomécanique et les mesures quantiques pour améliorer la sensibilité des détecteurs d'ondes gravitationnelles. Depuis 2012, il est membre de la collaboration internationale des scientifiques du détecteur d'ondes gravitationnelles LIGO.

Mikhail est diplômé du Département de physique de l'Université d'État de Moscou. Lomonosov, est actuellement étudiant diplômé de l'Institut de physique des lasers de l'Université de Hambourg. Il passe son temps libre avec sa famille, écrit des articles scientifiques populaires sur la physique quantique et publie des publications sur Twitter (@hbar_universe).

»Vous trouverez plus d'informations sur le livre sur le site Web de l'éditeur
» Table des matières
» Extrait

pour les épargnants 25% de réduction sur le coupon - Silva

Lors du paiement de la version papier du livre, un livre électronique est envoyé par e-mail.

Le livre "Développement utilisant des ordinateurs quantiques"