IBM on kenji.blog

Introduction à la programmation quantique avec Qiskit

Fri, 11 Sep 2026 20:00:00 +0900

1. Introduction

Les ordinateurs modernes (ordinateurs classiques) ont radicalement changé nos vies et soutiennent tous les aspects de la société grâce à leur puissance de calcul avancée. Cependant, il est connu que pour certains problèmes spécifiques (par exemple, la factorisation de très grands nombres, la simulation de structures moléculaires complexes, les problèmes d’optimisation, etc.), même les superordinateurs de pointe actuels nécessiteraient un temps supérieur à l’âge de l’univers.

Les ordinateurs quantiques (Quantum Computer) ont le potentiel de briser ces “limites des ordinateurs classiques”. En utilisant les propriétés étranges de la mécanique quantique (superposition et intrication quantique) comme ressources de calcul, on pense que certains problèmes peuvent être résolus de manière considérablement plus rapide.

Dans cet article, nous ferons notre premier pas dans le monde de la programmation quantique en utilisant Qiskit, un framework d’informatique quantique open source fourni par IBM. Il s’agit d’un guide d’introduction très détaillé couvrant tout le processus, allant des bases de la physique et des mathématiques jusqu’à l’écriture de code en Python et l’exécution de circuits quantiques sur un simulateur.

2. Fondements physiques et mathématiques du calcul quantique

Pour comprendre la programmation quantique, vous devez d’abord comprendre les concepts de base de la mécanique quantique. Nous expliquons ici trois piliers importants : les qubits, la superposition et l’intrication quantique.

2.1 Bits classiques et bits quantiques (Qubit)

L’unité d’information d’un ordinateur classique est le “bit”. Un bit prend toujours l’un des deux états : 0 ou 1.

D’autre part, la plus petite unité d’information d’un ordinateur quantique est appelée bit quantique (Qubit : Quantum bit). Un qubit peut non seulement prendre les états 0 et 1, mais il peut également maintenir ces deux états en même temps.

Mathématiquement, l’état d’un qubit $|\psi\rangle$ s’exprime comme une combinaison linéaire (superposition) des états de base $|0\rangle$ et $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Ici, $\alpha$ et $\beta$ sont des nombres complexes, représentant respectivement l’amplitude de probabilité d’observer les états $|0\rangle$ et $|1\rangle$. D’après les principes de base de la mécanique quantique, la somme des probabilités doit être égale à 1, ce qui satisfait à la condition de normalisation suivante :

$$ |\alpha|^2 + |\beta|^2 = 1 $$

graph LR A["Bit classique (Classical Bit)"] --> B["État défini : 0 ou 1"] C["Qubit (Qubit)"] --> D["Superposition : à la fois 0 et 1"] D --> E["L'état est déterminé de manière probabiliste par la mesure"]

2.2 Superposition (Superposition)

Comme mentionné précédemment, l’état dans lequel $|0\rangle$ et $|1\rangle$ sont mélangés est appelé superposition (Superposition).

Par exemple, si un seul qubit est dans un état de superposition parfaitement égale, alors $\alpha = \frac{1}{\sqrt{2}}$ et $\beta = \frac{1}{\sqrt{2}}$.

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

Lorsque cet état est mesuré, $|0\rangle$ et $|1\rangle$ sont observés chacun avec une probabilité de 50%. Si vous avez deux qubits, vous pouvez créer une superposition de quatre états : $|00\rangle, |01\rangle, |10\rangle, |11\rangle$. Si vous avez $n$ qubits, vous pouvez exprimer $2^n$ états simultanément, ce qui est l’une des sources de la capacité de traitement parallèle des ordinateurs quantiques.

2.3 Intrication quantique (Entanglement)

La propriété la plus puissante et la plus mystérieuse du calcul quantique est l’intrication quantique (Entanglement). Ce phénomène, appelé “action fantôme à distance” par Einstein, est la propriété selon laquelle deux ou plusieurs qubits sont si fortement liés que lorsque l’état de l’un d’eux est déterminé, l’état de l’autre est instantanément déterminé, quelle que soit la distance physique qui les sépare.

L’un des états d’intrication quantique les plus célèbres, l’« état de Bell (Bell State) », l’état $\Phi^+$, est exprimé comme suit :

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

Dans cet état, les états $|01\rangle$ ou $|10\rangle$ n’existent pas. Par conséquent, si le premier qubit est mesuré et s’avère être $|0\rangle$, il est certain que le second est $|0\rangle$ sans même avoir besoin de le mesurer. Inversement, si le premier est $|1\rangle$, le second sera inévitablement $|1\rangle$.

3. Portes logiques quantiques (Quantum Logic Gates)

Tout comme les ordinateurs classiques utilisent des portes logiques telles que AND, OR et NOT pour effectuer des calculs, les ordinateurs quantiques utilisent des portes quantiques pour manipuler l’état des qubits. L’état quantique étant un vecteur, une porte quantique est représentée par une “matrice unitaire” agissant sur ce vecteur.

3.1 Portes de Pauli (Pauli-X, Y, Z)

Les portes de Pauli sont des opérations de base sur un seul qubit.

・Porte Pauli-X (Porte NOT) Équivalent à la porte NOT classique. Elle inverse $|0\rangle$ en $|1\rangle$, et $|1\rangle$ en $|0\rangle$. (Rotation de 180 degrés autour de l’axe X sur la sphère de Bloch)

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

・Porte Pauli-Y Effectue une rotation de 180 degrés autour de l’axe Y. Elle a pour effet d’inverser à la fois la phase et le bit.

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Porte Pauli-Z (Porte d’inversion de phase) Laisse l’état $|0\rangle$ tel quel et inverse la phase de l’état $|1\rangle$ (en le multipliant par $-1$). (Rotation de 180 degrés autour de l’axe Z)

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

3.2 Porte de Hadamard (Hadamard Gate)

La porte de Hadamard (porte H) est une porte extrêmement importante qui convertit un état défini ($|0\rangle$ ou $|1\rangle$) en un état superposé.

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

L’application de la porte H à $|0\rangle$ donne $|+\rangle$, qui est un état de superposition égale.

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 Portes de phase (Phase Gates)

La porte de phase est une généralisation de la porte Z, qui fait tourner la phase de l’état $|1\rangle$ d’un angle spécifié $\theta$.

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

Les représentantes typiques sont la porte S ($\theta = \pi/2$) et la porte T ($\theta = \pi/4$).

3.4 Porte CNOT (Controlled-NOT Gate)

La porte CNOT (porte CX) est une porte qui opère entre deux qubits et est essentielle pour générer l’intrication quantique. Elle se compose d’un “bit de contrôle (Control)” et d’un “bit cible (Target)”.

Elle n’applique la porte X (opération NOT) au bit cible que si le bit de contrôle est $|1\rangle$, et ne fait rien si le bit de contrôle est $|0\rangle$.

$$ CNOT = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

4. Bases de Qiskit et configuration de l’environnement

À partir de là, nous allons écrire des programmes quantiques en utilisant Python et Qiskit.

4.1 Qu’est-ce que Qiskit ?

Qiskit est un kit de développement logiciel (SDK) d’informatique quantique open source développé par IBM Quantum. En utilisant Python, vous pouvez construire intuitivement des circuits quantiques et les exécuter sur un simulateur local ou sur de véritables ordinateurs quantiques IBM via le cloud.

4.2 Méthode d’installation

Pour utiliser Qiskit, vous avez besoin d’un environnement Python. Installez Qiskit et les packages associés (simulateurs, bibliothèques de dessin) à l’aide de la commande suivante.

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 Flux de base de la programmation

La programmation quantique avec Qiskit se déroule principalement selon les étapes suivantes.

graph TD A["1. Construction du circuit (Build)"] --> B["2. Compilation / Transpilation (Compile)"] B --> C["3. Exécution (Execute)"] C --> D["4. Analyse et visualisation des résultats (Analyze)"]

Construction du circuit : Créez un objet QuantumCircuit et ajoutez-y des portes.
Compilation : Optimisez le circuit pour le backend d’exécution (machine réelle ou simulateur).
Exécution : Envoyez le job au backend et obtenez les résultats.
Analyse : Tracez des histogrammes des résultats de mesure, etc.

5. Pratique : Construction d’un circuit pour créer un état de Bell (intrication quantique)

Essayons de créer « l’intrication quantique (état de Bell) » apprise en théorie avec Qiskit. L’état cible est $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$.

5.1 Conception du circuit

Pour créer un état de Bell, suivez ces étapes :

Préparez deux qubits (l’état initial est $|0\rangle$ pour les deux).
Appliquez une porte de Hadamard (H) au premier qubit pour le mettre dans un état superposé.
Appliquez une porte CNOT avec le premier qubit comme “bit de contrôle” et le deuxième qubit comme “bit cible”.
Effectuez une mesure (Measure) pour lire les résultats.

5.2 Implémentation du code Python/Qiskit

Examinons le code réel.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. Initialisation du circuit
# Créer un circuit quantique avec 2 qubits et 2 bits classiques
qc = QuantumCircuit(2, 2)

# 2. Application de la porte H
# Appliquer la porte de Hadamard au qubit 0 (q0)
qc.h(0)

# 3. Application de la porte CNOT
# Appliquer CNOT avec q0 comme bit de contrôle et q1 comme bit cible
qc.cx(0, 1)

# 4. Mesure
# Mesurer les qubits 0 et 1 et les écrire respectivement dans les bits classiques 0 et 1
qc.measure([0, 1], [0, 1])

# Dessiner le diagramme du circuit (en utilisant matplotlib)
# qc.draw('mpl')
print(qc.draw())

Lorsque vous exécutez ce code, le schéma de circuit quantique suivant s’affiche en art ASCII sur la console.

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H représente la porte de Hadamard, la combinaison de ■ et X représente la porte CNOT, et M représente la mesure.

5.3 Exécution sur le simulateur et interprétation des résultats

Ensuite, nous allons exécuter ce circuit sur le simulateur hautes performances d’IBM Aer et vérifier les résultats.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Obtenir le backend du simulateur Aer
simulator = Aer.get_backend('qasm_simulator')

# Transpiler (optimiser) le circuit pour le simulateur
compiled_circuit = transpile(qc, simulator)

# Exécuter le circuit (ici, exécution de 1000 tirs)
job = simulator.run(compiled_circuit, shots=1000)

# Obtenir le résultat
result = job.result()

# Obtenir le nombre d'observations (counts) des états
counts = result.get_counts(compiled_circuit)
print("\nRésultat de mesure :", counts)

# Tracer l'histogramme
# plot_histogram(counts)
# plt.show()

Interprétation des résultats

La sortie de la console devrait ressembler à ceci : Résultat de mesure : {'00': 495, '11': 505} (* Les probabilités étant aléatoires, les valeurs fluctueront légèrement à chaque exécution)

Dans un environnement de simulation idéal, les résultats de mesure pour 00 et 11 sont observés à environ 50 % chacun, tandis que 01 et 10 ne sont pas du tout observés. Cela correspond parfaitement à la prédiction théorique de l’état de Bell $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ que nous avons créé. “L’intrication quantique”, où si le premier qubit est 0 le second est toujours 0, et s’il est 1 le second est toujours 1, est simulée avec précision.

Notez que lors de l’exécution sur une véritable machine quantique (IBM Quantum Hardware), en raison de l’influence du bruit (décohérence quantique et erreurs de porte), 01 ou 10 peuvent être légèrement observés. Comment réduire ce bruit (correction d’erreurs quantiques) est l’un des plus grand défis du développement actuel des ordinateurs quantiques.

6. Mise à l’échelle vers des algorithmes plus avancés

La création d’un état de Bell est comparable au “Hello World” de la programmation quantique. En développant cela plus loin, il est possible de construire de puissants algorithmes surpassant les ordinateurs classiques.

6.1 Algorithme de Deutsch-Jozsa (Deutsch-Jozsa Algorithm)

Il s’agit du problème de déterminer si une fonction donnée $f(x)$ est une “fonction constante (sort toujours 0 ou toujours 1 indépendamment de l’entrée)” ou une “fonction équilibrée (sort 0 pour la moitié des entrées et 1 pour l’autre moitié)”. Un ordinateur classique nécessite dans le pire des cas $2^{n-1} + 1$ évaluations de la fonction, mais l’algorithme de Deutsch-Jozsa peut prendre cette décision avec une seule évaluation en utilisant le parallélisme quantique. Ceci illustre le modèle de base d’un algorithme quantique : entrer un état superposé, utiliser l’interférence (Interference) pour annuler les états inutiles, et amplifier la réponse souhaitée.

6.2 Algorithme de Grover (Grover’s Algorithm)

Dans le problème de recherche d’une donnée spécifique parmi $N$ bases de données non triées, alors qu’un algorithme classique nécessite en moyenne $N/2$ calculs, l’algorithme de Grover permet de trouver la donnée cible en $\sqrt{N}$ fois. Cet algorithme utilise une boîte noire appelée “Oracle (Oracle)” pour inverser la phase de la solution cible, puis effectue une “amplification d’amplitude (Amplitude Amplification)” pour augmenter considérablement la probabilité que la solution cible soit observée.

graph TD A["Initialisation (superposition de tous les états)"] --> B["Oracle (inversion de la phase de la bonne réponse)"] B --> C["Opérateur de diffusion (amplification de l'amplitude par inversion autour de la moyenne)"] C --> D{"Probabilité suffisante atteinte ?"} D -- "No" --> B D -- "Yes" --> E["Mesure"]

7. Conclusion et apprentissage futur

Dans cet article, nous avons expliqué en détail les concepts fondamentaux du calcul quantique tels que la superposition et l’intrication quantique, la manipulation de portes logiques quantiques à l’aide de Qiskit, puis la construction, la simulation et l’interprétation des résultats d’un état de Bell.

Qiskit pouvant être écrit en Python, un langage familier, c’est un outil puissant qui permet de surmonter les barrières mathématiques et physiques pour se concentrer sur la construction d’algorithmes. Les ordinateurs quantiques sont actuellement à l’ère des dispositifs quantiques à échelle intermédiaire bruités (NISQ : Noisy Intermediate-Scale Quantum), mais la recherche appliquée progresse rapidement dans le monde entier dans de nombreux domaines tels que l’apprentissage automatique (Quantum Machine Learning), la simulation chimique (Quantum Chemistry) et la cryptanalyse.

Profitez de cette occasion pour créer vous-même divers circuits quantiques à l’aide de Qiskit et essayez de les faire fonctionner sur de véritables processeurs IBM Quantum. Vous devriez pouvoir expérimenter par vous-même le paradigme informatique du futur.

Références

Documentation officielle de Qiskit
Qiskit Textbook - Texte officiel recommandé pour ceux qui souhaitent approfondir leurs connaissances sur le contexte mathématique et les algorithmes
IBM Quantum Learning

Bienvenue dans le monde quantique !

Qu'est-ce que la suprématie quantique ? Les dernières tendances de Google et IBM

Fri, 11 Sep 2026 18:00:00 +0900

1. Introduction : L’aube de l’informatique quantique et la « Suprématie quantique »

L’informatique quantique recèle le potentiel de résoudre des problèmes complexes, insolubles dans un délai réaliste par des ordinateurs classiques (les PC et les superordinateurs que nous utilisons quotidiennement), en appliquant les principes fondamentaux de la physique, à savoir la mécanique quantique, au traitement de l’information. Pendant longtemps, ce domaine a été principalement limité à la recherche théorique, mais ces dernières années, les progrès rapides du matériel ont intensifié la course vers une application pratique.

Parmi ces développements, l’un des mots-clés ayant attiré le plus d’attention est la « Suprématie quantique » (Quantum Supremacy). Cela désigne le moment où un ordinateur quantique démontre une puissance de calcul écrasante par rapport à un ordinateur classique pour une tâche de calcul spécifique. Dans cet article, nous partirons de la définition rigoureuse de la suprématie quantique, puis nous expliquerons en détail l’expérience du processeur « Sycamore » de Google, annoncée en 2019 comme ayant atteint ce jalon historique pour la première fois au monde. Nous aborderons également la réfutation et l’approche unique d’IBM, ainsi que les dernières tendances vers la « Correction d’erreurs quantiques » (Quantum Error Correction : QEC) et le « Calcul quantique tolérant aux pannes » (Fault-Tolerant Quantum Computing : FTQC), qui constituent les obstacles majeurs à une véritable mise en pratique, tout en approfondissant les aspects techniques et mathématiques.

2. Contexte théorique : Fondements du calcul quantique et classes de complexité

Pour comprendre la suprématie quantique, il est d’abord nécessaire d’appréhender les fondements mathématiques du calcul quantique et son positionnement dans la théorie de la complexité algorithmique.

Qubits et Superposition

Alors que la plus petite unité d’information dans un ordinateur classique est le bit (0 ou 1), un ordinateur quantique utilise le qubit (Quantum bit). L’état d’un seul qubit $|\psi\rangle$ est représenté par une combinaison linéaire complexe des états de base $|0\rangle$ et $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Ici, $\alpha, \beta \in \mathbb{C}$, et ils satisfont la condition de normalisation $|\alpha|^2 + |\beta|^2 = 1$. Cette propriété est appelée « Superposition » (Superposition).

Intrication (Entanglement) et Produit tensoriel

Lorsqu’il existe plusieurs qubits, l’état du système global est représenté par le produit tensoriel des espaces d’états des qubits individuels. Un système de $n$ qubits devient un vecteur sur un espace de Hilbert de dimension $2^n$, $\mathcal{H}^{\otimes n}$.

$$ |\Psi\rangle = \sum_{x \in \{0, 1\}^n} c_x |x\rangle $$

Ici, $\sum |c_x|^2 = 1$. L’état dans lequel les qubits ne sont pas indépendants et où l’état de l’un dépend de l’autre est appelé « Intrication quantique » (Quantum Entanglement). Grâce à cela, un ordinateur quantique possède le potentiel de traiter simultanément un espace d’états exponentiellement vaste.

Définition de la suprématie quantique dans la théorie de la complexité algorithmique

Dans la théorie de la complexité algorithmique, la classe des problèmes pouvant être résolus efficacement (en temps polynomial) par un ordinateur classique est appelée BPP (Bounded-error Probabilistic Polynomial time). D’autre part, la classe des problèmes pouvant être résolus efficacement par un ordinateur quantique est BQP (Bounded-error Quantum Polynomial time).

Démontrer la suprématie quantique signifie « exécuter une tâche spécifique qui est incluse dans BQP mais pas dans BPP (ou dont la probabilité d’y être est extrêmement faible) sur du matériel quantique réel, et surpasser en temps et en ressources une simulation par un superordinateur classique ». On peut dire que c’est une tentative historique de réfuter par une expérience physique la thèse étendue de Church-Turing (« tout modèle de calcul physiquement réalisable peut être simulé en temps polynomial par une machine de Turing probabiliste »).

3. 2019 : Démonstration de la suprématie quantique par Google

En octobre 2019, l’équipe Google Quantum AI a annoncé dans la revue scientifique Nature avoir atteint la suprématie quantique en utilisant le processeur supraconducteur « Sycamore » de 53 qubits.

Architecture du processeur Sycamore

Le processeur Sycamore est composé de 54 qubits supraconducteurs de type Transmon arrangés dans une grille bidimensionnelle (un qubit étant défectueux lors de l’expérience, 53 ont été utilisés). Des coupleurs ajustables (Tunable Couplers) sont placés entre les qubits adjacents, permettant de réaliser des portes à 2 qubits (un hybride entre la porte iSWAP et la porte Z contrôlée) rapides et très précises.

graph TD A["Entrée d'algorithme quantique"] --> B["Processeur Sycamore (53 Qubits)"] B --> C["Appliquer des portes quantiques aléatoires"] C --> D["Mesurer les états quantiques (Chaînes de bits)"] D --> E["Évaluation par entropie croisée (XEB)"] E --> F["Vérifier la suprématie quantique"]

Échantillonnage de circuits quantiques aléatoires (Random Circuit Sampling : RCS)

La tâche choisie par Google est « l’échantillonnage de circuits quantiques aléatoires ». Cela consiste à appliquer de manière répétée des portes quantiques à un qubit et à deux qubits choisies au hasard sur plusieurs cycles (profondeur $m$), puis à effectuer un échantillonnage à partir de la distribution de probabilité des chaînes de bits obtenues en mesurant l’état final.

La probabilité d’obtenir une chaîne de bits $x$ à partir d’un circuit quantique aléatoire idéal (sans bruit) ne suit pas une distribution uniforme, mais présente un motif semblable à des franges d’interférence, appelé distribution de Porter-Thomas (Porter-Thomas distribution). Pour échantillonner à partir de cette distribution avec un ordinateur classique, il est nécessaire de simuler l’ensemble du vecteur d’état, et la complexité de calcul augmente de manière exponentielle avec le nombre de qubits $n$ et la profondeur du circuit $m$.

Évaluation de la fidélité (Fidelity) : Évaluation par entropie croisée linéaire (XEB)

Pour prouver que les résultats de l’expérience n’étaient pas simplement du bruit, mais bien les résultats d’un calcul quantique réel, Google a utilisé l’évaluation par entropie croisée linéaire (Linear Cross-Entropy Benchmarking : XEB). La probabilité idéale $P(x_i)$ du circuit pour la chaîne de bits $x_i$ obtenue lors de l’expérience est calculée par un ordinateur classique, et la fidélité $\mathcal{F}_{\text{XEB}}$ est déterminée par la formule suivante.

$$ \mathcal{F}_{\text{XEB}} = 2^n \langle P(x_i) \rangle_{i} - 1 $$

Si $\mathcal{F}_{\text{XEB}}$ est de 0, cela signifie un bruit complet, et s’il est de 1, cela signifie un processeur quantique idéal sans bruit. Le processeur Sycamore a atteint $\mathcal{F}_{\text{XEB}} \approx 0,002$ (0,2 %) pour un circuit d’une profondeur de 20. Bien que cela paraisse faible au premier abord, il s’agissait d’une valeur statistiquement significative supérieure à zéro, et d’un exploit remarquable ayant réussi à contrôler un espace d’états de $2^{53} \approx 9 \times 10^{15}$.

Le taux d’erreur global a été modélisé de manière approximative comme le produit des erreurs de portes individuelles, des erreurs de mesure, etc.

$$ \mathcal{F} \approx (1 - e_1)^{N_1}(1 - e_2)^{N_2} \cdots \approx \prod_{g \in 1Q} (1 - e_g) \prod_{g \in 2Q} (1 - e_g) \prod_{q} (1 - e_{RO}) $$

(* $e_g$ correspond à l’erreur de porte, $e_{RO}$ à l’erreur de mesure)

Google a affirmé qu’il faudrait environ 10 000 ans pour simuler ce circuit sur le superordinateur classique (Summit). En revanche, Sycamore a terminé l’échantillonnage en seulement 200 secondes.

4. La réfutation d’IBM : De la « Suprématie » à l’« Utilité » (Utility)

L’annonce de Google a provoqué une onde de choc dans le monde entier, mais IBM, qui a développé le plus grand superordinateur du monde « Summit » et qui est également un leader dans le développement d’ordinateurs quantiques, a immédiatement publié un article pour réfuter cette affirmation.

Amélioration de la simulation classique par contraction de réseaux tensoriels

Le cœur de la réfutation d’IBM résidait dans le fait que « l’optimisation des algorithmes et des ressources du côté des ordinateurs classiques était insuffisante ». Google avait estimé le délai de 10 000 ans en se basant sur un simulateur de vecteur d’état calculant directement l’évolution temporelle de l’équation de Schrödinger. IBM a cependant souligné que l’utilisation d’une méthode appelée « Réseaux tensoriels » (Tensor Network) permettait de réduire drastiquement le temps de simulation.

Dans les réseaux tensoriels, les opérations de portes d’un circuit quantique sont représentées comme des calculs de tableaux multidimensionnels (tenseurs), et l’ordre de la « contraction » (Contraction) du réseau est optimisé. De plus, IBM a affirmé qu’en exploitant pleinement le stockage massif de 250 Po de Summit (hiérarchisation du disque et de la mémoire), il était possible de réaliser une simulation de plus haute précision en seulement « 2,5 jours » tout en conservant l’intégralité du vecteur d’état.

Avantage quantique (Quantum Advantage) et Utilité quantique (Quantum Utility)

À la suite de ce débat, la tendance générale de l’industrie est passée de l’obsession d’« exécuter une tâche artificielle impossible classiquement (Supremacy) » à celle de « démontrer un avantage substantiel par rapport aux approches classiques sur des problèmes utiles du monde réel (Quantum Advantage) », puis à la phase où « l’ordinateur quantique agit comme un nouvel outil de découverte scientifique (Quantum Utility) ».

IBM elle-même évite le terme « suprématie » et propose des métriques de performance globale des processeurs quantiques telles que le « Volume quantique » (Quantum Volume) ou les « CLOPS (Circuit Layer Operations Per Second) », en poursuivant un développement qui met l’accent sur l’équilibre entre l’échelle et la qualité du matériel.

timeline title "L'évolution des jalons quantiques" 2019 : "Google Sycamore (53Q)" : "Annonce de la suprématie quantique" 2019 : "Réfutation d'IBM" : "Simulation sur superordinateur Summit en 2,5 jours" 2021 : "IBM Eagle (127Q)" : "Franchissement de la barre des 100 qubits" 2022 : "IBM Osprey (433Q)" : "Avancement de l'échelle des processeurs" 2023 : "Code de surface Google" : "Mise à l'échelle de la correction d'erreurs (d=3 à d=5)" 2023 : "Utilité quantique d'IBM" : "Simulation de modèle de spin complexe sur 127Q" 2024 : "Au-delà" : "Ère des qubits logiques et de l'atténuation des erreurs"

5. La prochaine frontière : Atténuation des erreurs (Error Mitigation) et Correction d’erreurs quantiques (QEC)

Les ordinateurs quantiques actuels sont appelés « NISQ (Noisy Intermediate-Scale Quantum) ». Ils sont sensibles aux bruits (erreurs dues aux interactions avec l’environnement externe ou à des imperfections de contrôle), et lors de longs calculs, les résultats se retrouvent noyés dans le bruit. Pour surmonter ce problème, il existe deux grandes approches : l’« Atténuation des erreurs » (Error Mitigation) et la « Correction d’erreurs quantiques » (Quantum Error Correction).

Atténuation des erreurs (Error Mitigation)

L’atténuation des erreurs est une méthode qui élimine l’impact du bruit de la valeur attendue des résultats de calcul par un post-traitement classique, sans modifier le matériel quantique. En 2023, en combinant son processeur « Eagle » de 127 qubits avec des techniques d’atténuation des erreurs telles que l’« Extrapolation du bruit à zéro » (Zero-Noise Extrapolation : ZNE), IBM a atteint une précision dépassant la méthode des réseaux tensoriels approximatifs de pointe dans la simulation de l’évolution temporelle d’un modèle d’Ising complexe, démontrant ainsi l’« Utilité quantique » (Quantum Utility).

Correction d’erreurs quantiques (QEC) et Qubits logiques

Cependant, pour pouvoir finalement exécuter n’importe quel algorithme complexe (par exemple, l’algorithme de factorisation de Shor ou des calculs de chimie quantique complexes), l’atténuation des erreurs seule est insuffisante, et la « Correction d’erreurs quantiques » (QEC), qui détecte et corrige dynamiquement les erreurs, est indispensable.

L’approche dominante en matière de QEC est le « Code de surface » (Surface Code). Il s’agit d’une méthode consistant à arranger plusieurs qubits physiques (qubits de données) dans une grille bidimensionnelle, et à placer des qubits de mesure (qubits ancilla) entre eux pour effectuer de manière continue des vérifications de parité appelées « Stabilisateurs » (Stabilizer).

graph LR Q1["Qubit de données (Données)"] --- M1["Mesurer le stabilisateur X (Ancilla)"] Q2["Qubit de données (Données)"] --- M1 Q3["Qubit de données (Données)"] --- M2["Mesurer le stabilisateur Z (Ancilla)"] Q4["Qubit de données (Données)"] --- M2 M1 --> EC["Décodage du syndrome d'erreur (Classique)"] M2 --> EC EC --> LQ["Mise à jour de l'état du qubit logique"]

Théorème du seuil (Threshold Theorem) et Distance $d$

La correction d’erreurs quantiques s’appuie sur le « Théorème du seuil ». Si le taux d’erreur des qubits physiques $p$ est inférieur à un certain seuil $p_{th}$ (environ 1 % pour le code de surface), il est possible de réduire de manière exponentielle le taux d’erreur logique $p_L$ en augmentant la distance de code (Distance) $d$ (c’est-à-dire en allouant plus de qubits physiques à un seul qubit logique).

La formule approximative du taux d’erreur logique s’exprime comme suit :

$$ p_L \approx \Lambda \left( \frac{p}{p_{th}} \right)^{\frac{d+1}{2}} $$

Ici, $\Lambda$ est une constante. Si $p < p_{th}$, plus $d$ est grand, plus $p_L$ diminue. Cependant, si $p > p_{th}$, l’ajout de qubits physiques entraîne une accumulation de bruit, détériorant le taux d’erreur logique.

Jalon de Google en 2023 : Démonstration de la réduction des erreurs par l’extension de la distance

En février 2023, Google a publié un article monumental dans Nature. En utilisant son processeur Sycamore de 3ème génération, ils ont démontré pour la première fois au monde qu’en étendant la distance du code de surface de $d=3$ (utilisation de 17 qubits physiques) à $d=5$ (utilisation de 49 qubits physiques), le taux d’erreur logique diminuait légèrement, passant de 3,028 % à 2,914 %.

Cela signifie qu’ils ont pénétré dans la zone où $p < p_{th}$, et cela indique que la validation de principe (Proof of Concept) la plus importante vers le FTQC, à savoir que plus on augmente le nombre de qubits physiques, plus les performances s’améliorent, a été réalisée.

6. Feuille de route et perspectives vers le FTQC (Calcul quantique tolérant aux pannes)

Google et IBM, bien qu’adoptant des architectures et des approches différentes, se livrent à une course au développement acharnée vers leur objectif final, le FTQC (Fault-Tolerant Quantum Computing).

L’approche d’IBM : Modularisation et grille Heavy-Hex

IBM se concentre sur la mise à l’échelle de ses processeurs tout en cherchant à réduire drastiquement le taux d’erreur. Tout en repoussant les limites des puces uniques avec « Eagle (127Q) », « Osprey (433Q) » et « Condor (1121Q) », ils ont annoncé une architecture modulaire appelée « Quantum System Two ». De plus, ils adoptent une « Grille Heavy-Hex » (Heavy-Hex lattice) pour la topologie de couplage de leurs qubits, ce qui réduit la diaphonie (crosstalk) indésirable et augmente la stabilité. La stratégie d’IBM est une approche hybride : poursuivre l’utilité à court terme grâce à une atténuation avancée des erreurs, tout en introduisant progressivement la QEC.

L’approche de Google : Amélioration de la qualité des qubits logiques

La stratégie de Google met davantage l’accent sur la réduction extrême du taux d’erreur d’un seul qubit logique (par exemple, jusqu’à $10^{-6}$) plutôt que sur l’augmentation rapide du nombre de qubits physiques. Sur cette base, ils visent à établir une technologie de transfert des états quantiques entre les modules (Quantum Interconnects) et à créer un système à grande échelle faisant fonctionner plusieurs milliers à plusieurs dizaines de milliers de qubits physiques en parallèle.

La mise en œuvre de protocoles permettant d’exécuter des portes non-Clifford avec une tolérance aux pannes, comme la distillation d’états magiques (Magic State Distillation), constituera également un obstacle technique majeur à l’avenir. Pour exécuter un algorithme de Shor pratique capable de casser un chiffrement RSA de 2048 bits, il faudrait des milliers de qubits logiques avec un taux d’erreur inférieur à $10^{-8}$, ce qui équivaut à plusieurs millions ou dizaines de millions de qubits physiques, ce qui indique que le chemin est encore long.

7. Conclusion

La « Suprématie quantique » a constitué une étape importante dans l’histoire des ordinateurs quantiques, prouvant physiquement le potentiel théorique de ces machines. La démonstration de Google en 2019 et la réfutation constructive d’IBM ont poussé l’ensemble de l’industrie au-delà d’une simple preuve théorique vers la poursuite d’une utilité réelle (Utility), puis vers l’ère de l’ingénierie à part entière menant au calcul quantique tolérant aux pannes (FTQC).

Aujourd’hui, nous assistons à une période de transition entre les dispositifs NISQ remplis de bruit et les dispositifs à qubits logiques dotés d’une correction d’erreurs. Au cours des cinq à dix prochaines années, de nouvelles découvertes en science des matériaux, des révolutions dans le processus de découverte de médicaments, et des avancées majeures dans les problèmes d’optimisation deviendront réalité en tandem avec l’évolution de ce matériel quantique.

Il faudra continuer de suivre de près les développements de Google, d’IBM, et des chercheurs du monde entier qui façonnent l’informatique de demain.