Guide du débutant sur l’informatique quantique avec Python

Mécanique quantique est une théorie fondamentale de la physique qui explique les phénomènes à l’échelle microscopique (comme les atomes et les particules subatomiques). Ce « nouveau » domaine (1900) diffère de la physique classique, qui décrit la nature à une échelle macroscopique (comme les corps et les machines) et ne s’applique pas au niveau quantique.

Informatique quantique est l’exploitation des propriétés de la mécanique quantique pour effectuer des calculs et résoudre des problèmes qu’un ordinateur classique ne peut pas et ne pourra jamais résoudre.

Les ordinateurs normaux parlent le code binaire langage : ils attribuent un modèle de chiffres binaires (1 et 0) à chaque caractère et instruction, et stockent et traitent ces informations dans morceaux. Même votre code Python est traduit en chiffres binaires lorsqu’il s’exécute sur votre ordinateur portable. Par exemple:

Le mot « Salut » → « h » : 01001000 et « je »: 01101001 → 01001000 01101001

D’un autre côté, les ordinateurs quantiques traitent les informations avec qubits (bits quantiques), qui peuvent être à la fois 0 et 1. Cela rend les machines quantiques considérablement plus rapides que les machines normales pour des problèmes spécifiques (c’est-à-dire le calcul probabiliste).

Ordinateurs quantiques

Les ordinateurs quantiques utilisent des atomes et des électrons, au lieu des puces classiques à base de silicium. En conséquence, ils peuvent exploiter la mécanique quantique pour effectuer des calculs beaucoup plus rapidement que les machines normales. Par exemple, 8 bits suffisent à un ordinateur classique pour représenter n’importe quel nombre compris entre 0 et 255, mais 8 qubits suffisent à un ordinateur quantique pour représenter tous les nombres compris entre 0 et 255. en même temps. Quelques centaines de qubits suffiraient à représenter plus de nombres qu’il n’y a d’atomes dans l’univers.

Le cerveau d’un ordinateur quantique est un petit puce qubit en métaux ou en saphir.

Cependant, la partie la plus emblématique est le grand système de refroidissement en or qui ressemble à un lustre suspendu à l’intérieur d’un cylindre en acier : le réfrigérateur à dilution. Il refroidit la puce à une température plus froide que l’espace, car la chaleur détruit les états quantiques (en gros, plus il fait froid, plus elle devient précise).

Il s’agit du principal type d’architecture, appelé qubits supraconducteurs : des atomes artificiels créés à partir de circuits utilisant des supraconducteurs (comme l’aluminium) qui présentent une résistance électrique nulle à des températures ultra-basses. Une architecture alternative est celle des pièges à ions (atomes chargés piégés dans des champs électromagnétiques sous ultra-vide), plus précis mais plus lents que la première.

Il n’existe pas de décompte public exact du nombre d’ordinateurs quantiques existants, mais les estimations tournent autour de 200 dans le monde. A ce jour, les plus avancés sont :

1. IBM Condorle plus grand nombre de qubits construit jusqu’à présent (1 000 qubits), même si cela à lui seul ne constitue pas un calcul utile, car les taux d’erreur sont toujours importants.
2. Google Willow (105 qubits), avec un bon taux d’erreur mais encore loin d’être un calcul à grande échelle tolérant aux pannes.
3. IonQ Tempo (100 qubits), ordinateur quantique à pièges à ions avec de bonnes capacités mais toujours plus lent que les machines supraconductrices.
4. Quantinum Hélios (98 qubits), utilise une architecture de pièges à ions avec une précision parmi les plus élevées signalées aujourd’hui.
5. Rigetti Informatique Ankaa (80 qubits).
6. Intel Chutes du tunnel (12 qubits).
7. Canada Xanadu Aurore (12 qubits), le premier ordinateur quantique photonique, utilisant la lumière au lieu des électrons pour traiter l’information.
8. de Microsoft Majoranele premier ordinateur conçu pour évoluer jusqu’à un million de qubits sur une seule puce (mais il dispose actuellement de 8 qubits).
9. Chinois SpinQ Minile premier ordinateur quantique portable à petite échelle (2 qubits).
10. NVIDIA QPU (Unité de traitement quantique), le premier système quantique accéléré par GPU.

À l’heure actuelle, il est impossible pour une personne normale de posséder un ordinateur quantique à grande échelle, mais vous pouvez y accéder via le cloud.

Installation

En Python, il existe plusieurs bibliothèques pour travailler avec les ordinateurs quantiques dans le monde :

• Kit Qiskit by IBM est l’écosystème de haut niveau le plus complet pour exécuter des programmes quantiques sur des ordinateurs quantiques IBM, parfait pour les débutants.
• Cirque par Google, dédié au contrôle de bas niveau sur leur matériel, plus adapté à la recherche.
• PennyLane by Xanadu est spécialisé dans l’apprentissage automatique quantique, il fonctionne sur leurs ordinateurs photoniques propriétaires mais il peut également se connecter à d’autres fournisseurs.
• ProjetQ par l’ETH Zurich University, un projet open source qui tente de devenir le principal package généraliste pour l’informatique quantique.

Pour ce tutoriel, j’utiliserai le logiciel IBM Kit Qiskit car c’est le leader du secteur (pip install qiskit).

Le code le plus basique que nous puissions écrire est de créer un circuit quantique (environnement de calcul quantique) avec un seul qubit et initialisez-le à 0. Afin de mesurer l’état du qubit, nous avons besoin d’un vecteur d’étatqui vous indique essentiellement la réalité quantique actuelle de votre circuit.

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

q = QuantumCircuit(1,0) #circuit with 1 quantum bit and 0 classic bit
state = Statevector.from_instruction(q) #measure state
state.probabilities() #print prob%

Cela signifie : la probabilité que le qubit soit 0 (premier élément) est de 100 %, tandis que la probabilité que le qubit soit 1 (deuxième élément) est de 0 %. Vous pouvez l’imprimer comme ceci :

print(f"[q=0 {round(state.probabilities()[0]*100)}%, 
         q=1 {round(state.probabilities()[1]*100)}%]")

Visualisons l’état :

from qiskit.visualization import plot_bloch_multivector

plot_bloch_multivector(state, figsize=(3,3))

Comme vous pouvez le voir sur la représentation 3D de l’état quantique, le qubit est à 100 % à 0. C’était l’équivalent quantique de «Bonjour le monde« , et maintenant nous pouvons passer à l’équivalent quantique de « 1+1=2« .

Qubits

Les qubits ont deux propriétés fondamentales de la mécanique quantique : la superposition et l’intrication.

Superposition — les bits classiques peuvent être 1 ou 0, mais jamais les deux. Au contraire, un qubit peut être les deux (techniquement, c’est une combinaison linéaire d’un nombre infini d’états entre 1 et 0), et seulement lorsqu’elle est mesurée, la superposition s’effondre à 1 ou 0 et reste ainsi pour toujours. En effet, l’acte d’observer une particule quantique la force à adopter un état binaire classique de 1 ou 0 (essentiellement l’histoire de Le chat de Schrödinger que nous connaissons et aimons tous). Un qubit a donc une certaine probabilité de s’effondrer à 1 ou 0.

q = QuantumCircuit(1,0)
q.h(0) #add Superposition
state = Statevector.from_instruction(q) 
print(f"[q=0 {round(state.probabilities()[0]*100)}%, 
         q=1 {round(state.probabilities()[1]*100)}%]")
plot_bloch_multivector(state, figsize=(3,3))

Avec la superposition, nous avons introduit le « caractère aléatoire », donc l’état vectoriel est compris entre 0 et 1. Au lieu d’une représentation vectorielle, nous pouvons utiliser une q-sphère où la taille des points est proportionnelle à la probabilité du terme correspondant dans l’état.

from qiskit.visualization import plot_state_qsphere

plot_state_qsphere(state, figsize=(4,4))

Le qubit est à la fois 0 et 1, avec respectivement 50 % de probabilité. Mais que se passe-t-il si nous mesure il? Parfois ce sera un 1 fixe, et parfois un 0 fixe.

result, collapsed = state.measure() #Superposition disappears
print("measured:", result)
plot_state_qsphere(collapsed, figsize=(4,4)) #plot collapsed state

Enchevêtrement — les bits classiques sont indépendants les uns des autres, tandis que les qubits peuvent être intriqués les uns avec les autres. Lorsque cela se produit, les qubits sont toujours corrélés, quelle que soit la distance (souvent utilisée comme métaphore mathématique de l’amour).

q = QuantumCircuit(2,0) #circuit with 2 quantum bits and 0 classic bit
q.h([0]) #add Superposition on the 1st qubit
state = Statevector.from_circuit(q) 
plot_bloch_multivector(state, figsize=(3,3))

Nous avons le premier qubit en superposition entre 0-1, le second à 0, et maintenant je vais les enchevêtrer. Par conséquent, si la première particule est mesurée et s’effondre à 1 ou 0, la deuxième particule changera également (pas nécessairement avec le même résultat, l’une peut être 0 tandis que l’autre est 1).

q.cx(control_qubit=0, target_qubit=1) #Entanglement
state = Statevector.from_circuit(q)
result, collapsed = state.measure([0]) #measure the 1st qubit
plot_bloch_multivector(collapsed, figsize=(3,3))

Comme vous pouvez le voir, le premier qubit qui était en superposition a été mesuré et réduit à 1. Dans le même temps, le deuxième quibit est intriqué avec le premier et a donc également changé.

Conclusion

Cet article a été un tutoriel pour introduire les bases de l’informatique quantique avec Python et Qiskit. Nous avons appris à travailler avec les qubits et leurs 2 propriétés fondamentales : Superposition et Intrication. Dans le prochain didacticiel, nous utiliserons des qubits pour créer des modèles quantiques.

Code complet pour cet article : GitHub

J’espère que vous l’avez apprécié ! N’hésitez pas à me contacter pour des questions et des commentaires ou simplement pour partager vos projets intéressants.

👉 Connectons-nous 👈

_{^{(Toutes les images sont de l’auteur, sauf indication contraire)}}