Quantum Computing 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.

Comment la blockchain et les cryptomonnaies évolueront-elles à l'ère post-quantique ?

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

1. Introduction : L’approche de l’ère post-quantique et la crise de la blockchain

Depuis la création du Bitcoin par Satoshi Nakamoto en 2009, la technologie de la blockchain s’est développée pour devenir l’infrastructure des systèmes financiers et des applications à travers le monde, en tant que « registre décentralisé et infalsifiable ». Cette sécurité robuste repose sur des technologies cryptographiques modernes : la cryptographie à clé publique (Public Key Cryptography) et les fonctions de hachage cryptographique (Cryptographic Hash Functions).

Ces technologies cryptographiques garantissent la sécurité en s’appuyant sur la « difficulté de calcul » mathématique, c’est-à-dire qu’un ordinateur classique (les PC ou supercalculateurs que nous utilisons aujourd’hui) mettrait un temps comparable à l’âge de l’univers pour les déchiffrer.

Cependant, cette prémisse est sur le point d’être fondamentalement bouleversée par le développement rapide et la mise en pratique des ordinateurs quantiques (Quantum Computers), qui représentent la frontière de la physique et des sciences de l’information. Les ordinateurs quantiques, qui utilisent les propriétés de la mécanique quantique telles que la « superposition (Superposition) » et l’« intrication (Entanglement) », font preuve d’une puissance de calcul surpassant de loin les ordinateurs classiques pour certains problèmes mathématiques, ce que l’on appelle la « suprématie quantique (Quantum Supremacy) ».

Dans cet article, nous explorerons en profondeur, d’un point de vue technique et mathématique, les menaces spécifiques auxquelles la technologie de la blockchain est confrontée à cause des ordinateurs quantiques, ainsi que les dernières tendances de la cryptographie post-quantique (PQC : Post-Quantum Cryptography) qui s’annonce comme la solution, et les scénarios de transition pour les réseaux de crypto-actifs.

2. Les bases de l’informatique quantique et ses 2 grandes menaces pour la blockchain

Les systèmes de blockchain actuels sont principalement constitués des deux éléments cryptographiques suivants, chacun étant exposé à des menaces différentes de la part des algorithmes quantiques.

graph TD A["Puissance de calcul phénoménale des ordinateurs quantiques"] --> B["Algorithme de Shor (Shor's Algorithm)"] A --> C["Algorithme de Grover (Grover's Algorithm)"] B --> D["Effondrement de la cryptographie à clé publique (ECDSA/RSA/DSA)"] C --> E["Impact sur les fonctions de hachage cryptographique (SHA-256)"] D --> F["Identification de la clé privée d'autrui et falsification de transactions"] E --> G["Avantage dans le minage PoW et attaques sur certaines adresses"] F --> H["Menace fatale et directe pour la blockchain"] G --> I["Menace gérable par ajustement de l'algorithme (ex. augmentation de la taille de la clé)"] style H fill:#ff9999,stroke:#cc0000,stroke-width:2px; style I fill:#ffff99,stroke:#cccc00,stroke-width:2px;

2.1. Les fondements de la cryptographie sur les courbes elliptiques (ECDSA) et la difficulté de calcul

De nombreuses blockchains, dont le Bitcoin et l’Ethereum, utilisent l’algorithme de signature numérique sur courbe elliptique (ECDSA : Elliptic Curve Digital Signature Algorithm) comme algorithme de signature numérique. Plus précisément, le Bitcoin utilise une courbe elliptique avec le paramètre secp256k1.

La sécurité de la cryptographie sur les courbes elliptiques dépend de la difficulté de calcul du problème du logarithme discret sur courbe elliptique (ECDLP : Elliptic Curve Discrete Logarithm Problem). La courbe elliptique est définie par l’équation sous forme de Weierstrass suivante :

$$ y^2 \equiv x^3 + ax + b \pmod{p} $$

Pour le secp256k1 du Bitcoin, $a = 0, b = 7$, et $p$ est un très grand nombre premier. Soit $G$ un point de base sur cette courbe, et $k$ la clé privée, qui est un très grand nombre entier de 256 bits choisi au hasard. Alors, la clé publique $K$ est obtenue par l’addition de $G$ à lui-même $k$ fois (multiplication scalaire).

$$ K = k \times G = \underbrace{G + G + \dots + G}_{k \text{ fois}} $$

En utilisant un ordinateur classique, calculer la clé privée $k$ à partir de la clé publique $K$ (calculer le logarithme discret) nécessite un temps de calcul exponentiel $\mathcal{O}(\sqrt{p})$ même avec les meilleurs algorithmes classiques tels que l’algorithme rho de Pollard. Pour une clé de 256 bits, environ $2^{128}$ opérations sont nécessaires, ce qui est impossible à résoudre même en faisant fonctionner les supercalculateurs actuels pendant des milliards d’années.

2.2. L’effondrement causé par l’algorithme de Shor (Shor’s Algorithm)

Cependant, l’algorithme de Shor, publié par Peter Shor en 1994, a complètement détruit cette hypothèse. L’algorithme de Shor a été initialement proposé pour résoudre le problème de la factorisation en nombres premiers (la base du chiffrement RSA) en temps polynomial, mais il s’applique également au problème du logarithme discret et au problème du logarithme discret sur courbe elliptique.

Le cœur de l’algorithme de Shor réside dans l’utilisation de la transformée de Fourier quantique (QFT : Quantum Fourier Transform) pour trouver rapidement la « période (Period) » d’une fonction.

$$ \text{Complexité classique} = \mathcal{O}(2^{n/2}) \quad (n\text{ est la longueur en bits}) $$ $$ \text{Complexité de l'algorithme quantique} = \mathcal{O}(n^3) $$

Ainsi, l’algorithme de Shor réduit considérablement un temps exponentiel à un temps polynomial (Polynomial Time). Si un ordinateur quantique doté d’un nombre suffisant de qubits logiques est achevé, il sera possible d’identifier la clé privée $k$ à partir de la clé publique $K$ publiée sur le réseau en quelques minutes ou quelques secondes. Par conséquent, un attaquant pourra facilement obtenir la clé privée du portefeuille de quelqu’un d’autre et prendre le contrôle total des fonds.

2.2.1 Étapes par étapes de la résolution de l’ECDLP par l’algorithme de Shor

Voyons étape par étape le processus interne par lequel un ordinateur quantique résout le problème du logarithme discret sur courbe elliptique (ECDLP).

Définition du problème : Dans $K = k \times G$, $G$ et $K$ sont connus, et nous voulons trouver l’entier inconnu $k$ (la clé privée). Soit $N$ l’ordre de la courbe elliptique.

Étape 1 : Création de l’état de superposition Tout d’abord, nous préparons deux registres quantiques et appliquons une porte de Hadamard (Hadamard Gate) à chacun d’eux pour créer un état de superposition de toutes les combinaisons possibles d’entiers.

$$ |\psi_1\rangle = \frac{1}{N} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} |x\rangle |y\rangle |0\rangle $$

Étape 2 : Application de l’oracle quantique (évaluation de la fonction) Ensuite, à l’aide d’un circuit quantique (oracle) qui effectue l’addition de points sur la courbe elliptique, nous calculons la fonction $f(x, y) = x \times G + y \times K$ dans le troisième registre.

$$ |\psi_2\rangle = \frac{1}{N} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} |x\rangle |y\rangle |x \times G + y \times K\rangle $$

Ce qui est important ici, c’est que puisque $K = k \times G$, cela peut être réécrit comme $f(x, y) = (x + y \cdot k) \times G$.

Étape 3 : Mesure du troisième registre Lorsque le troisième registre est mesuré, il s’effondre sur un certain point $R$ sur la courbe elliptique. Par conséquent, les premier et deuxième registres s’effondrent dans un état de superposition des paires $(x, y)$ satisfaisant $x + y \cdot k \equiv c \pmod{N}$ (où $c$ est une constante).

$$ |\psi_3\rangle = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1} |c - y \cdot k \pmod{N}\rangle |y\rangle $$

Étape 4 : Application de la transformée de Fourier quantique (QFT) Cet état a une périodicité liée à la période $k$. En appliquant ici la transformée de Fourier quantique inverse (Inverse QFT), on provoque des interférences de phase et on convertit l’information de période en amplitude.

Étape 5 : Mesure et post-traitement classique Lorsque les premier et deuxième registres sont mesurés, une valeur contenant des informations sur $k$ est obtenue avec une forte probabilité. En appliquant des algorithmes de théorie des nombres classiques tels que le développement en fractions continues (Continued Fractions) à la valeur mesurée, la clé privée inconnue $k$ peut être complètement identifiée.

Le nombre de portes quantiques requis pour l’ensemble de ce processus est $\mathcal{O}(\log^3 N)$, ce qui permet de révéler la clé privée à une vitesse ultra-rapide, incomparable avec la recherche $\mathcal{O}(\sqrt{N})$ par un ordinateur classique.

2.3. L’algorithme de Grover (Grover’s Algorithm) et son impact sur les fonctions de hachage

L’autre menace est l’algorithme de Grover, proposé par Lov Grover en 1996. Celui-ci a un impact majeur sur les fonctions de hachage (ex. : SHA-256).

Dans la blockchain, les fonctions de hachage sont utilisées pour garantir l’intégrité des données, générer des adresses et servent de base au minage PoW (Proof of Work) du Bitcoin. L’inversion d’une fonction de hachage (calcul de la préimage) peut être considérée comme un « problème de recherche dans une base de données non structurée », consistant à trouver une valeur d’entrée $x$ telle que $H(x) = y$ pour une valeur de sortie $y$ donnée.

Dans un ordinateur classique, pour trouver la bonne réponse parmi $N$ possibilités, il faut en moyenne $\frac{N}{2}$ essais, et $N$ essais dans le pire des cas. En d’autres termes, la complexité est $\mathcal{O}(N)$. Cependant, l’algorithme de Grover utilise une technique quantique appelée « amplification d’amplitude (Amplitude Amplification) ». En amplifiant itérativement l’amplitude de probabilité de l’état correspondant à la bonne réponse parmi toutes les possibilités dans un état de superposition, le temps de recherche est réduit à sa racine carrée.

$$ \text{Complexité de l'algorithme de Grover} = \mathcal{O}(\sqrt{N}) $$

Dans le cas de SHA-256, puisque $N = 2^{256}$, une recherche exhaustive classique nécessiterait environ $2^{256}$ essais. Cependant, en utilisant l’algorithme de Grover, il suffit de $\sqrt{2^{256}} = 2^{128}$ essais. Cela signifie qu’une fonction de hachage de 256 bits voit son niveau de sécurité effectivement divisé par deux, à 128 bits, face à un ordinateur quantique.

2.3.1. SHA-256 survivra-t-il ? (Quantum Supremacy in Hashing)

Bien que la sécurité soit réduite de moitié, « une sécurité de 128 bits » reste extrêmement solide. $2^{128}$ opérations représentent un chiffre astronomique même selon les standards technologiques actuels, nécessitant une échelle de temps comparable à la durée de vie de l’univers. Par conséquent, il est largement considéré que « SHA-256 maintiendra un niveau de sécurité pratique même face aux ordinateurs quantiques ». S’il s’avère nécessaire d’augmenter la marge de sécurité à l’avenir, il suffira simplement de doubler la longueur de sortie du hachage (par exemple, passer de SHA-256 à SHA-512) pour maintenir le niveau de sécurité classique de 256 bits dans le monde quantique.

En conclusion, on peut dire que la menace quantique pesant sur les fonctions de hachage est « mineure et gérable », tandis que la menace sur la cryptographie à clé publique (ECDSA) est « fatale ».

3. Analyse des impacts concrets sur les crypto-actifs actuels (Bitcoin, Ethereum)

Dans un monde où le déchiffrement de l’ECDSA par un ordinateur quantique deviendrait possible, à quelles vulnérabilités spécifiques les réseaux de crypto-actifs seront-ils confrontés ? Nous ferons ici une analyse détaillée en prenant l’exemple du fonctionnement du Bitcoin, du point de vue du « timing d’exposition de la clé publique ».

3.1. Génération d’adresses et « confidentialité » de la clé publique

Les adresses Bitcoin (P2PKH : Pay-to-Public-Key-Hash ou P2WPKH : Pay-to-Witness-Public-Key-Hash) n’utilisent pas la clé publique elle-même, mais un hachage multiple de la clé publique.

$$ \text{Bitcoin Address} = \text{Base58Check}(\text{RIPEMD160}(\text{SHA256}(\text{Public Key}))) $$

Comme mentionné précédemment, les fonctions de hachage résistent aux attaques quantiques (l’algorithme de Grover), il est donc impossible, même pour un ordinateur quantique, de retrouver la « clé publique » d’origine à partir de « l’adresse » (la valeur de hachage). En d’autres termes, pour « une adresse inutilisée (qui n’a jamais envoyé de fonds) », la clé publique n’est exposée nulle part sur la blockchain, et seule la valeur de hachage est enregistrée. Par conséquent, tant que la clé publique est inconnue, il n’y a pas de cible pour exécuter l’algorithme de Shor, et la clé privée ne peut pas être identifiée. On peut dire que les portefeuilles dans cet état sont sûrs sur le plan quantique (Quantum-safe).

3.2. La vulnérabilité fatale lors de l’envoi de transactions (Attaque de front-running)

Le problème survient au moment où un utilisateur envoie des fonds. Lorsqu’il diffuse (broadcast) une transaction sur le réseau, l’utilisateur doit inclure sa signature numérique ainsi que sa propre clé publique dans les données de la transaction pour la vérification, et la rendre publique sur tout le réseau.

sequenceDiagram participant User as "Utilisateur (Alice)" participant Mempool as "Mempool (Pool de transactions non confirmées)" participant QuantumAttacker as "Attaquant quantique" participant Miner as "Mineur (Génération de blocs)" User->>Mempool: Envoi de la transaction (incluant la clé publique + signature) Mempool-->>QuantumAttacker: Interception de la clé publique sur le réseau note right of QuantumAttacker: Exécution de l'algorithme de Shor en quelques minutes
(Calcul de la clé privée à partir de la clé publique) QuantumAttacker->>QuantumAttacker: Génération d'une nouvelle signature avec la clé privée d'Alice QuantumAttacker->>Mempool: Diffusion d'une transaction frauduleuse avec des frais de minage plus élevés Miner->>Miner: Inclusion prioritaire de la transaction frauduleuse avec des frais (Gas) élevés dans un bloc Miner-->>User: Enregistrement sur la blockchain (Perte des fonds d'Alice)

Une fois que la clé publique est envoyée au Mempool (la zone d’attente des transactions non confirmées), ces données sont partagées avec les nœuds du monde entier. Si un attaquant possède un ordinateur quantique ultra-rapide, il peut voler les fonds grâce au processus suivant :

Intercepter la transaction légitime de l’utilisateur (Alice) depuis le Mempool et en extraire la clé publique.
Exécuter l’algorithme de Shor et calculer la clé privée à partir de la clé publique en quelques minutes (avant que le bloc ne soit confirmé).
Utiliser la clé privée obtenue pour créer une fausse transaction envoyant les fonds d’Alice vers l’adresse de l’attaquant.
Définir pour cette fausse transaction des frais de minage (Fee) beaucoup plus élevés que ceux de la transaction originale d’Alice et l’envoyer sur le réseau.

Les mineurs, obéissant aux incitations économiques, incluront en priorité la transaction avec les frais les plus élevés dans un bloc. Par conséquent, la transaction frauduleuse de l’attaquant sera confirmée en premier, et la transaction légitime d’Alice sera rejetée pour « fonds insuffisants (Double Spend) ». Cette séquence d’événements est appelée attaque de front-running (Front-running Attack). Dans un monde où les ordinateurs quantiques sont devenus réalité, cela entraînera une situation effrayante où les fonds seront volés par des pirates informatiques à la seconde où quelqu’un appuiera sur le bouton d’envoi.

3.3. Le danger des adresses réutilisées et des anciennes adresses (P2PK)

Un problème encore plus grave est que les adresses à partir desquelles des fonds ont été envoyés au moins une fois par le passé (comme lorsqu’elles sont réutilisées comme adresses de monnaie de retour) ont déjà leur clé publique enregistrée de manière permanente sur la blockchain. Celles-ci risquent de voir leur clé privée calculée et leur solde volé à tout moment, sans même attendre l’envoi d’une transaction.

De plus, dans le format P2PK (Pay-to-Public-Key), qui était dominant autour de 2009-2010 et qui inclut les récompenses de minage initiales de Satoshi Nakamoto (plus d’un million de BTC), la clé publique elle-même, et non un hachage, était directement enregistrée sur la blockchain comme adresse. Ces énormes quantités de bitcoins dormants deviendront les cibles les plus faciles pour les ordinateurs quantiques, et pourraient déclencher un krach majeur des prix en étant volées en masse et déversées sur le marché.

4. Scénarios de transition vers la cryptographie post-quantique (PQC : Post-Quantum Cryptography)

Afin d’éviter la catastrophe du « Q-Day (le jour où les ordinateurs quantiques briseront la cryptographie) », la communauté cryptographique et celle de la blockchain prévoient de migrer vers une cryptographie post-quantique (PQC) difficile à déchiffrer même avec des algorithmes quantiques. Le National Institute of Standards and Technology (NIST) des États-Unis mène depuis de nombreuses années un processus de standardisation PQC, et après plusieurs phases d’évaluations rigoureuses, quelques systèmes de chiffrement prometteurs ont été sélectionnés comme normes finales.

Nous expliquerons en détail les principaux algorithmes PQC qui attirent l’attention en tant qu’alternatives aux signatures numériques de la blockchain, ainsi que leurs mécanismes mathématiques.

4.1. Signatures basées sur le hachage (Hash-Based Signatures)

Les signatures basées sur le hachage sont un schéma cryptographique dont la sécurité repose uniquement sur une base très simple et robuste : la « résistance aux collisions des fonctions de hachage ». Étant donné que la sécurité des fonctions de hachage contre les ordinateurs quantiques a déjà été prouvée (comme mentionné précédemment, une marge de sécurité de 128 bits est suffisante), il s’agit d’une approche extrêmement fiable. Parmi les exemples représentatifs, citons la signature de Lamport (Lamport Signatures), son extension WOTS (Winternitz One-Time Signature), et le candidat à la standardisation du NIST, SPHINCS+ (désormais appelé SLH-DSA sous FIPS 205).

4.1.1. Détails mathématiques de la signature de Lamport (One-Time Signature)

Examinons plus en détail le fonctionnement mathématique de la signature de Lamport. Soit une fonction de hachage $H: \{0, 1\}^* \to \{0, 1\}^{256}$.

[Génération des clés] Alice (l’expéditrice) utilise un véritable générateur de nombres aléatoires (TRNG) pour générer 256 paires de clés privées.

$$ \text{sk}_{i,0} \in \{0, 1\}^{256}, \quad \text{sk}_{i,1} \in \{0, 1\}^{256} \quad (1 \le i \le 256) $$

Ainsi, la clé privée $\text{sk}$ se compose d’un total de 512 chaînes de 256 bits (taille : $512 \times 32 = 16 384$ octets).

Ensuite, elle calcule la clé publique $\text{pk}$. Chaque composant de la clé privée est haché.

$$ \text{pk}_{i,0} = H(\text{sk}_{i,0}), \quad \text{pk}_{i,1} = H(\text{sk}_{i,1}) $$

La clé publique fait également $16 384$ octets. Celle-ci est publiée sur le réseau de la blockchain.

[Génération de la signature] Pour signer les données de transaction $M$, Alice calcule d’abord sa valeur de hachage.

$$ h = H(M) \in \{0, 1\}^{256} $$

Soit $h_i \in \{0, 1\}$ le $i$-ème bit de la valeur de hachage $h$. La signature d’Alice, $\sigma$, sera l’ensemble des composants de la clé privée correspondant à chaque bit $h_i$.

$$ \sigma = (\text{sk}_{1, h_1}, \text{sk}_{2, h_2}, \dots, \text{sk}_{256, h_{256}}) $$

En d’autres termes, si le bit du hachage du message est 0, elle révèle $\text{sk}_{i,0}$, et s’il est 1, elle révèle $\text{sk}_{i,1}$. La taille de la signature sera de $256 \times 32 = 8 192$ octets.

[Vérification de la signature] Le mineur (vérificateur) vérifie en utilisant la transaction $M$ reçue, la signature $\sigma = (s_1, s_2, \dots, s_{256})$ et la clé publique $\text{pk}$. Il recalcule le hachage de la transaction $h = H(M)$ et vérifie si le hachage de chaque $s_i$ correspond à l’élément correspondant de la clé publique, $\text{pk}_{i, h_i}$.

$$ H(s_i) \overset{?}{=} \text{pk}_{i, h_i} \quad (\text{pour tout } 1 \le i \le 256) $$

Ce processus est mathématiquement très simple, et à moins qu’un ordinateur quantique ne puisse inverser $H$, il est impossible de falsifier une signature. Cependant, une fois signée, la moitié de la clé privée est exposée au réseau. Si la même paire de clés est utilisée pour signer un autre message, les clés privées exposées se combinent, donnant à un attaquant la possibilité de forger des signatures. Cela crée une forte contrainte : la clé ne peut être utilisée qu’« une seule fois (One-Time) ». Pour rendre cela pratique, des technologies comme XMSS, qui utilise un arbre de Merkle pour regrouper de nombreuses clés à usage unique en une seule clé publique racine, ou SPHINCS+, qui est sans état, ont été développées, mais elles présentent l’inconvénient de tailles de signature atteignant des dizaines de kilo-octets.

4.2. Cryptographie fondée sur les réseaux euclidiens (Lattice-Based Cryptography)

Actuellement, la cryptographie qui suscite le plus d’attentes en tant que courant principal du PQC, et qui a été adoptée comme norme principale du NIST (FIPS 204 : ML-DSA / anciennement CRYSTALS-Dilithium, ou Falcon), est la cryptographie fondée sur les réseaux euclidiens.

La sécurité de la cryptographie sur les réseaux euclidiens repose sur des problèmes dont la difficulté a été mathématiquement prouvée, tels que le « problème du vecteur le plus court dans un réseau multidimensionnel (SVP : Shortest Vector Problem) » ou le « problème d’apprentissage avec erreurs (LWE : Learning With Errors) ». Il n’existe aucun algorithme connu capable de résoudre efficacement les problèmes de réseau, même avec un ordinateur quantique.

Modèle mathématique du LWE (Learning With Errors) : L’idée fondamentale du problème LWE est d’ajouter intentionnellement un « petit bruit (erreur) » à un système d’équations linéaires, ce qui rend le problème considérablement plus difficile. Soit un vecteur secret $\mathbf{s} \in \mathbb{Z}_q^n$. Il y a une grande matrice publique choisie aléatoirement $\mathbf{A} \in \mathbb{Z}_q^{m \times n}$ et un vecteur de petit bruit intentionnellement ajouté $\mathbf{e} \in \mathbb{Z}_q^m$. La clé publique $\mathbf{b}$ est calculée comme suit :

$$ \mathbf{b} = \mathbf{A}\mathbf{s} + \mathbf{e} \pmod{q} $$

Même si la matrice $\mathbf{A}$ et le vecteur $\mathbf{b}$ (clé publique) sont publiés, il devient très difficile de calculer la clé privée $\mathbf{s}$ à l’envers en raison de la présence du bruit $\mathbf{e}$. S’il n’y avait pas de bruit, cela pourrait être résolu par une simple élimination de Gauss, mais le bruit provoque une explosion de l’espace de recherche dans toutes les dimensions, offrant une sécurité robuste contre les ordinateurs classiques et quantiques. Dans les algorithmes réels utilisés dans les blockchains et ailleurs (comme Dilithium), cela est déployé sur des anneaux polynomiaux, ce que l’on appelle Ring-LWE (ou Module-LWE), afin de réduire la taille des clés et d’accélérer les calculs.

Avantages : Comparé aux signatures basées sur le hachage, la taille des clés publiques et des signatures est relativement petite (de l’ordre de quelques kilo-octets), et la vitesse de calcul pour la génération et la vérification des signatures est très élevée (équivalente ou supérieure à l’ECDSA).
Inconvénients : La structure mathématique est complexe et la période d’examen historique est courte, de sorte que le risque de découverte de nouveaux algorithmes de déchiffrement à l’avenir n’est pas nul.

5. Les défis techniques de la migration PQC pour la blockchain

Ce n’est pas parce que des algorithmes PQC (comme Dilithium ou SPHINCS+) existent qu’ils peuvent être introduits demain dans Bitcoin ou Ethereum. Plusieurs défis majeurs spécifiques aux systèmes décentralisés se posent.

5.1. L’augmentation de la taille des signatures et l’effondrement de la scalabilité

Le plus grand obstacle à l’introduction de la PQC est l’augmentation significative de la taille des données. Alors que la taille actuelle d’une signature ECDSA est d’environ 70 octets, dans le cas du Dilithium (ML-DSA) basé sur les réseaux, la taille de la signature est d’environ 2 420 octets à 4 595 octets (selon le niveau de sécurité), et la taille de la clé publique dépasse 1 300 octets. Quant au SPHINCS+ basé sur le hachage, la signature seule atteint des dizaines de milliers d’octets.

Si le Bitcoin introduisait la PQC en conservant la limite de taille de bloc actuelle (un poids d’environ 4 Mo en incluant SegWit), le nombre de transactions pouvant être stockées dans un seul bloc chuterait considérablement. Le débit du réseau (TPS : Transactions Per Second) s’effondrerait, et les congestions de transferts deviendraient la norme. Pour résoudre ce problème, il faudrait augmenter considérablement la taille des blocs, mais cela accroîtrait les besoins en stockage et en bande passante des nœuds complets, rendant difficile l’exploitation de nœuds par des particuliers et entraînant en conséquence une centralisation du réseau, créant ainsi un dilemme.

pie title "Comparaison de la taille des données de signature dans la blockchain (Schéma conceptuel)" "ECDSA (env. 70 Octets)" : 2 "Dilithium ML-DSA (env. 2 500 Octets)" : 58 "SPHINCS+ (env. 17 000 Octets)" : 40

(※ L’augmentation de la taille des données de transaction due à l’introduction du PQC constitue un goulot d’étranglement fatal pour la scalabilité)

5.2. Impact sur l’Ethereum Virtual Machine (EVM) et les contrats précompilés

Dans une plateforme de contrats intelligents Turing-complète comme Ethereum, l’introduction de la PQC nécessitera une mise à niveau fondamentale de l’EVM (Ethereum Virtual Machine). L’EVM actuel dispose d’un contrat précompilé (Precompiled Contract) appelé ecrecover (adresse : 0x01) pour vérifier les signatures ECDSA, qui est optimisé pour effectuer la vérification de signature avec des frais de gaz très faibles (3000 Gas).

Cependant, le processus de vérification des nouveaux algorithmes de cryptographie sur réseau tels que Dilithium ou Falcon implique des calculs polynomiaux et matriciels complexes. Si l’on tente de l’implémenter uniquement avec les codes d’opération (Opcodes) de l’EVM existant, une seule vérification de signature pourrait consommer des millions, voire des dizaines de millions de gaz. Cela suffirait à épuiser la limite de gaz de bloc actuelle (environ 30 millions de Gas) avec une seule transaction.

Pour éviter cela, il est nécessaire, via un hard fork du réseau, d’intégrer dans l’EVM lui-même un nouveau contrat précompilé pour la vérification PQC (par exemple, assigner DilithiumVerify à 0x10). Cela nécessitera un long processus dans lequel les développeurs principaux de chaque client Ethereum (Geth, Nethermind, Erigon, etc.) devront collaborer pour implémenter de manière optimisée la logique de vérification de la cryptographie sur réseau au niveau des langages C++, Go, Rust, etc., et réaliser des audits de sécurité.

5.3. La difficulté d’atteindre un consensus par hard fork

Pour modifier l’algorithme de signature sous-jacent, un hard fork (Hard Fork) mettant à jour le protocole de l’ensemble du réseau est indispensable. Cependant, dans les communautés qui accordent une grande importance à « ne pas changer les règles et rester décentralisé » comme le Bitcoin, le processus de recherche de consensus est politiquement très difficile. Il faudra probablement des années de discussions et de tests entre la proposition d’un BIP (Bitcoin Improvement Proposal) pour la transition PQC et sa mise en œuvre.

6. Quand le « Q-Day » arrivera-t-il ? La feuille de route vers la transition

Quand viendra le « Q-Day » (le jour où un ordinateur quantique déchiffrera complètement la cryptographie sur les courbes elliptiques de 256 bits) ? Les avis des chercheurs divergent, mais de nombreux experts prédisent l’apparition d’ordinateurs quantiques à grande échelle dotés d’au moins quelques milliers à plusieurs dizaines de milliers de qubits logiques stables (qubits corrigés des erreurs avec une tolérance au bruit) « entre le milieu des années 2030 et les années 2040 ». Toutefois, selon les percées dans l’architecture matérielle ou la découverte d’algorithmes quantiques plus efficaces, il n’est pas impossible que cela arrive plus tôt (vers 2030).

La feuille de route que l’écosystème des crypto-actifs devrait suivre avant qu’il ne soit trop tard est la suivante :

Phase 1 : Signatures hybrides et abstraction de compte (Maintenant - vers 2028)

L’industrie actuelle de la blockchain, et en particulier les développeurs d’Ethereum (comme Vitalik Buterin), envisage des « signatures hybrides » combinant l’ECDSA et le PQC (signatures basées sur le hachage ou cryptographie sur réseau). C’est une approche où les transactions reçoivent à la fois la signature ECDSA sécurisée existante et une signature PQC, garantissant la sécurité même si l’une des deux est compromise. De plus, en utilisant l’abstraction de compte (Account Abstraction, ERC-4337), des initiatives sont en cours pour implémenter et prendre en charge les signatures PQC sur des portefeuilles de contrats intelligents via opt-in (pour les utilisateurs qui le souhaitent) sans attendre un hard fork au niveau du protocole.

Phase 2 : Utilisation des preuves à divulgation nulle de connaissance (ZK-Rollups) (2025 - )

L’atout majeur attendu pour résoudre le plus grand point faible de la PQC, à savoir « l’augmentation de la taille des données de signature », est l’utilisation des ZK-Rollups (preuves à divulgation nulle de connaissance), une technologie de couche 2 (Layer 2). Plutôt que d’écrire d’énormes données de signature PQC directement sur la couche 1 (Layer 1, la chaîne principale), de nombreuses transactions PQC sont vérifiées et agrégées sur la couche 2. Ensuite, à l’aide de ZK-SNARKs ou ZK-STARKs, elles sont compressées en une très petite « donnée de preuve (Proof) » unique qui est enregistrée sur la couche 1. Il convient de noter que certaines configurations de SNARKs (comme Groth16) sont intrinsèquement vulnérables au niveau quantique, de sorte que l’adoption des ZK-STARKs, qui ne dépendent que des fonctions de hachage résistantes au quantique, sera essentielle.

Phase 3 : Hard fork au niveau du protocole (vers 2030)

Une fois la standardisation de la PQC par le NIST pleinement établie, et que les bibliothèques standards de l’industrie seront disponibles et suffisamment testées, un hard fork devrait être effectué sur les principales chaînes telles que Bitcoin et Ethereum pour migrer complètement l’algorithme de signature par défaut vers la PQC. Durant cette période de transition, des annonces à grande échelle exhorteront les utilisateurs à « transférer leurs fonds de leurs anciens portefeuilles vers de nouveaux portefeuilles compatibles PQC ».

Exemples de projets pionniers

Certains projets de blockchain ont anticipé cette menace quantique et sont développés avec une résistance quantique revendiquée dès les premières étapes.

QRL (Quantum Resistant Ledger) : Une blockchain précoce qui a implémenté nativement au niveau de son protocole la PQC basée sur le hachage appelée XMSS (eXtended Merkle Signature Scheme).
Algorand / Cellframe : Projets qui possèdent une architecture modulaire de couche cryptographique flexible en vue des futures mises à jour PQC, et qui explorent activement l’intégration de la cryptographie sur les réseaux euclidiens.

7. Conclusion : L’avenir des crypto-actifs et la protection de nos actifs

L’arrivée de « l’ère post-quantique » a dépassé le simple stade de la science-fiction et se présente déjà devant nous comme un défi technique concret pour les systèmes cryptographiques réels.

Les deux épées des ordinateurs quantiques, l’algorithme de Shor et l’algorithme de Grover, menacent respectivement la cryptographie à clé publique et les fonctions de hachage qui constituent les fondations des blockchains actuelles. La vulnérabilité de l’ECDSA, en particulier, est fatale, et la transition vers la cryptographie post-quantique (PQC) est absolument incontournable pour éviter le risque de vol de fonds via les attaques de front-running.

Cependant, le monde de la technologie et la communauté de la blockchain ne se contentent pas de croiser les bras en attendant la fin du monde. La sélection et la standardisation des algorithmes PQC, comme la cryptographie sur les réseaux euclidiens et les signatures basées sur le hachage, progressent de manière constante. De plus, grâce à l’utilisation des preuves à divulgation nulle de connaissance (ZK-STARKs) et des technologies de scalabilité de couche 2, la voie pour surmonter le principal obstacle à l’introduction du PQC, à savoir « l’augmentation de la taille des données », commence à se dessiner.

En tant qu’utilisateurs ordinaires de crypto-actifs et investisseurs, nous n’avons pas besoin de paniquer immédiatement ni de vendre tous nos fonds. Toutefois, il est important d’avoir les connaissances de base suivantes et d’être conscient de l’importance de l’autoprotection :

Éviter la réutilisation des adresses : Pour des raisons non seulement de confidentialité mais aussi de sécurité, assurez-vous de ne pas conserver vos fonds à long terme sur des « adresses utilisées (des adresses ayant envoyé des fonds au moins une fois, dont la clé publique a été exposée sur la blockchain) ».
Prêter attention aux tendances technologiques : Restez à l’affût des actualités concernant les discussions sur la transition PQC et les hard forks des principaux réseaux, comme les BIP de Bitcoin et les EIP d’Ethereum, afin de pouvoir procéder à la migration de votre portefeuille de manière appropriée lorsque cela sera nécessaire.

L’histoire de la blockchain est aussi l’histoire d’améliorations constantes et de résilience (capacité de récupération) face aux nouvelles menaces technologiques. Tout comme l’écosystème a surmonté les problèmes de scalabilité et les problèmes environnementaux (par la transition du PoW au PoS, par exemple), il cherchera sans aucun doute des solutions et s’adaptera globalement à cette menace quantique sans précédent. Plutôt que d’être détruites par leur confrontation, on peut s’attendre à ce que la nouvelle sagesse de l’humanité qu’est l’ordinateur quantique et la technologie de confiance qu’est le registre décentralisé soient sublimées en un système robuste fusionné à un niveau supérieur.

Références et liens utiles :

National Institute of Standards and Technology (NIST) - Post-Quantum Cryptography Standardization Project
Shor, P. W. (1994). Algorithms for quantum computation: discrete logarithms and factoring.
Grover, L. K. (1996). A fast quantum mechanical algorithm for database search.
Buterin, V. (2024). How to hard-fork to save most users’ funds in a quantum emergency.

Différence entre le recuit quantique et le modèle à portes quantiques expliquée simplement

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

Différence entre le recuit quantique et le modèle à portes quantiques expliquée simplement

L’informatique quantique est une technologie de calcul de nouvelle génération qui a le potentiel de résoudre des problèmes spécifiques, nécessitant un temps énorme pour les ordinateurs classiques actuels (y compris les superordinateurs conventionnels), de manière exponentiellement plus rapide en utilisant les principes de la mécanique quantique (superposition et intrication quantique).

Actuellement, il existe deux principaux paradigmes d’approche pour la réalisation des ordinateurs quantiques : “le recuit quantique (Quantum Annealing)” et “le modèle à portes quantiques (Quantum Gate Model)”. Ces deux méthodes diffèrent considérablement dans leurs approches physiques sous-jacentes, les tâches de calcul dans lesquelles elles excellent, et les défis matériels liés à leur mise en œuvre.

Cet article compare et explique ces deux méthodes en profondeur, depuis une perspective hautement détaillée et technique, abordant les principes physiques, les modèles mathématiques (modèle d’Ising, QUBO, transformations unitaires, etc.), les limites technologiques actuelles, jusqu’aux cas d’utilisation spécifiques.

1. Fondements du calcul quantique : Différences fondamentales avec les ordinateurs classiques

Les ordinateurs classiques traitent l’information sous forme de “bits (Bit)” qui prennent l’état “0” ou “1”. En revanche, les ordinateurs quantiques utilisent des “qubits (Qubit)”. Grâce au principe de “superposition (Superposition)” de la mécanique quantique, un qubit peut posséder simultanément et de manière probabiliste les états 0 et 1.

De plus, en utilisant un phénomène appelé “intrication quantique (Entanglement)”, les états de plusieurs qubits deviennent fortement corrélés, de sorte qu’une opération sur un qubit affecte instantanément l’ensemble du système. Cela permet des calculs de type traitement parallèle (parallélisme quantique).

Cependant, les états quantiques sont extrêmement vulnérables aux bruits externes (chaleur, ondes électromagnétiques, etc.), et le phénomène de “décohérence (Decoherence)”, où l’état se brise et revient à un état classique, constitue un défi majeur. La différence dans l’approche de ce problème de bruit conduit à une grande différence dans la philosophie de conception entre le recuit et le modèle à portes.

2. Détails du recuit quantique (Quantum Annealing)

Le recuit quantique est une architecture de calcul spécialisée principalement dans la résolution de “problèmes d’optimisation combinatoire”. Il est basé sur une théorie proposée en 1998 par Manpei Kadowaki et Hidetoshi Nishimori de l’Institut de Technologie de Tokyo (Tokyo Tech), et est devenu largement connu lorsque l’entreprise canadienne D-Wave Systems l’a commercialisé pour la première fois au monde.

2.1. Mécanisme physique : Modèle d’Ising en champ transverse et fluctuations quantiques

Le recuit quantique utilise la propriété des systèmes physiques naturels qui tendent à s’installer dans “l’état d’énergie le plus bas (état fondamental)” pour effectuer des calculs.

Dans l’approche classique du “recuit simulé (Simulated Annealing)”, les fluctuations thermiques sont utilisées pour échapper aux solutions optimales locales (minimums locaux). En revanche, le recuit quantique utilise les “fluctuations quantiques (Quantum Fluctuation)” pour traverser les barrières d’énergie grâce à “l’effet tunnel quantique (Quantum Tunneling)”, explorant ainsi plus efficacement la solution optimale globale (minimum global).

L’évolution temporelle du système de recuit quantique est décrite par le Hamiltonien suivant (l’opérateur représentant l’énergie totale du système) $H(t)$.

$$ H(t) = A(t) H_0 + B(t) H_P $$

Ici, $t$ est le temps, $A(t)$ est une fonction décroissante progressivement, et $B(t)$ est une fonction croissante progressivement.

$H_0$ (Hamiltonien initial) : Représente le champ transverse (Transverse field) et génère les fluctuations quantiques. $$ H_0 = - \sum_{i} \sigma_i^x $$ ($\sigma_i^x$ est la matrice de Pauli X, représentant l’inversion du bit.)
$H_P$ (Hamiltonien du problème) : Le modèle d’Ising (Ising Model) représentant le problème d’optimisation à résoudre.

À l’état initial ($t=0$), $A(0)$ est au maximum, et le système est dans l’état fondamental de $H_0$ (un état où tous les états sont superposés de manière égale). À partir de là, on affaiblit lentement le champ transverse au fil du temps, tout en renforçant simultanément l’interaction du Hamiltonien du problème.

2.2. Calcul quantique adiabatique (Adiabatic Quantum Computation)

Ce qui est important dans ce processus, c’est le “Théorème adiabatique (Adiabatic Theorem)”. Selon le théorème adiabatique, si le système est modifié “suffisamment lentement (adiabatiquement)”, le système restera toujours dans l’état fondamental du Hamiltonien à chaque instant.

En d’autres termes, lorsque finalement $A(t) \to 0$ et $B(t) \to 1$, le système a atteint l’état fondamental de $H_P$, c’est-à-dire “la solution exacte du problème d’optimisation”.

graph TD A["Hamiltonien H_0 (État initial)"] -->|"Changement adiabatique (suffisamment lent)"| B["Maintien constant de l'état fondamental"] A -->|"Changement non-adiabatique (trop rapide / bruit thermique)"| C["Transition vers l'état excité (Erreur)"] B --> D["Hamiltonien H_P (Solution optimale globale)"] C --> E["Piégé dans une solution optimale locale"] D --> F["Lecture de la solution"] E --> F

2.3. Cartographie de QUBO au modèle d’Ising

Pour résoudre des problèmes du monde réel avec un recuiseur quantique, le problème doit être formulé sous la forme QUBO (Quadratic Unconstrained Binary Optimization : Optimisation binaire quadratique sans contrainte).

La fonction objectif de QUBO est définie comme suit.

$$ \min_{x \in \{0,1\}^n} \sum_{i} Q_{ii} x_i + \sum_{i < j} Q_{ij} x_i x_j $$

Ici, $x_i \in \{0, 1\}$ sont des variables binaires, et $Q$ est la matrice de poids.

Étant donné que le matériel (comme D-Wave) gère des spins physiques (vers le haut / vers le bas), il est nécessaire de convertir les variables en un modèle d’Ising utilisant $\sigma_i \in \{-1, +1\}$. La formule de conversion est la suivante.

$$ x_i = \frac{1 - \sigma_i}{2} \quad \text{ou} \quad \sigma_i = 1 - 2x_i $$

En substituant cela dans l’équation de QUBO et en simplifiant, on obtient le Hamiltonien $H_P$ du modèle d’Ising.

$$ H_P = - \sum_{i

$J_{ij}$ : Interaction entre les spins (coefficient de couplage). La force de couplage entre les qubits physiques.

$h_i$ : Champ magnétique local (biais) pour chaque spin.

2.4. Matériel et défis du recuit quantique (L’exemple de D-Wave)

Les processeurs quantiques de D-Wave sont réalisés à l’aide de dispositifs supraconducteurs à interférence quantique (SQUID). Le couplage entre les qubits physiques dépend du câblage matériel et n’est pas un couplage complet (un état où tous les bits sont interconnectés). Évoluant du “Graphe Chimera (Chimera graph)” initial, au “Graphe Pegasus (Pegasus)” puis au “Graphe Zephyr (Zephyr)”, la connectivité s’est améliorée, mais il reste encore des limitations.

Par conséquent, un processus appelé “Plongement mineur (Minor Embedding)” est nécessaire pour cartographier un problème avec une structure de graphe complexe sur le graphe physique. Étant donné que cela utilise plusieurs qubits physiques (une chaîne) pour représenter une variable logique, il y a le problème que le nombre effectif de qubits utilisables diminue, ce qui entraîne une réduction de la précision de calcul.

3. Détails du modèle à portes quantiques (Quantum Gate Model)

Le modèle à portes quantiques est une extension mécanique quantique des portes logiques des ordinateurs classiques (AND, OR, NOT, etc.), et est une architecture qui permet le “Calcul Quantique Universel (Universal Quantum Computation)”. De nombreuses entreprises comme IBM, Google, Rigetti et IonQ ont adopté cette approche.

3.1. Transformation unitaire et vecteur d’état

Dans le modèle à portes quantiques, l’état de l’ensemble du système de qubits est représenté comme un “Vecteur d’état (State Vector)” $|\psi\rangle$. L’état d’un qubit unique est exprimé par la combinaison linéaire des états de base $|0\rangle$ et $|1\rangle$ comme suit.

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

Ici, $\alpha$ et $\beta$ sont des amplitudes de probabilité complexes, satisfaisant $|\alpha|^2 + |\beta|^2 = 1$. Cet état est géométriquement visualisé comme un point sur la “Sphère de Bloch (Bloch Sphere)”.

L’étape de calcul quantique est décrite comme l’application d’un opérateur unitaire (Unitary Operator) $U$ au vecteur d’état. Une matrice unitaire a la propriété que $U^\dagger U = I$ (le produit avec son conjugué hermitien donne la matrice identité), ce qui est une opération réversible correspondant à l’évolution temporelle de l’équation de Schrödinger en mécanique quantique.

$$ |\psi_{t+1}\rangle = U_t |\psi_t\rangle $$

3.2. Portes quantiques de base et modèle de circuit

L’algorithme de calcul quantique est conçu comme une séquence de portes quantiques (circuit quantique).

Portes de Pauli (X, Y, Z) : Rotation de 180 degrés autour de chaque axe sur la sphère de Bloch. La porte X équivaut à la porte NOT classique.
Porte de Hadamard (H) : Transforme $|0\rangle$ en $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$, créant un état de superposition. $$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$
Porte CNOT (Controlled-NOT) : Porte à 2 qubits. Applique une porte X au bit cible uniquement lorsque le bit de contrôle est $|1\rangle$. Cela génère l’intrication quantique (Entanglement).

Tout algorithme quantique peut être exprimé de manière approximative par une combinaison d’un petit nombre de portes à 1 qubit et de portes CNOT (ensemble de portes universelles).

graph LR Q0["Qubit 0: |0>"] --> H1["Porte de Hadamard (H)"] Q1["Qubit 1: |0>"] --> I1["Opération identité (I)"] H1 --> C1["Bit de contrôle (Control)"] I1 --> T1["Bit cible (Target)"] C1 -. "Intrication" .- T1 C1 --> M0["Mesure (Measurement)"] T1 --> M1["Mesure (Measurement)"] M0 --> Result["Résultat classique (0 ou 1)"] M1 --> Result

3.3. Correction d’erreurs et le chemin de NISQ à FTQC

Le plus grand défi du modèle à portes quantiques est la “décohérence”, où l’état quantique est détruit par le bruit. À mesure que les étapes de calcul (profondeur de circuit) s’allongent, les erreurs s’accumulent.

Pour effectuer des calculs idéaux, la correction d’erreurs quantiques (Quantum Error Correction) est essentielle. Par exemple, avec des méthodes comme le “Code de surface (Surface Code)”, plusieurs qubits physiques sont regroupés pour former un seul “qubit logique (Logical Qubit)” sans erreur. Cependant, la création d’un qubit logique nécessite des milliers à des dizaines de milliers de qubits physiques, ce qui entraîne une énorme surcharge.

L’étape à laquelle nous nous trouvons actuellement est l’ère des dispositifs NISQ (Noisy Intermediate-Scale Quantum) de plusieurs dizaines à centaines de qubits sans correction d’erreurs. La réalisation d’un FTQC (Fault-Tolerant Quantum Computing : Calcul quantique tolérant aux pannes) avec une correction d’erreurs complète nécessite encore de nombreuses percées.

4. Résumé de la comparaison technique et mathématique

Comparaison des différences fondamentales entre les deux architectures.

Élément de comparaison	Recuit quantique (Quantum Annealing)	Modèle à portes quantiques (Gate Model)
Modèle de calcul	Calcul quantique adiabatique (évolution temporelle continue du Hamiltonien)	Transformation unitaire (séquence d’opérations de portes discrètes)
Problèmes adaptés	Problèmes d’optimisation combinatoire (QUBO, modèle d’Ising)	Universel (simulation de chimie quantique, factorisation en nombres premiers, recherche, etc.)
Capacité d’expression	Optimisation heuristique (solution approximative)	Équivalent à la machine de Turing quantique universelle (tout calcul est théoriquement possible)
Exemples d’implémentation	D-Wave Systems	IBM, Google, Quantinuum, IonQ, etc.
Tolérance au bruit	Relativement forte (car il reste près de l’état fondamental, un certain niveau de bruit thermique est tolérable)	Très faible (un léger bruit décale la phase et détruit le résultat du calcul)
Évolutivité	Échelle de milliers à dizaines de milliers de qubits (dépend de la structure physique. La création de bits logiques est difficile)	Échelle de centaines de qubits (nécessite une échelle de millions pour le FTQC)

Le recuit quantique est adapté à la résolution de problèmes d’optimisation en tant que “coprocesseur spécifique” complétant les limites des ordinateurs classiques. D’autre part, le modèle à portes quantiques est la version quantique de l’“ordinateur polyvalent”, et vise ultimement à une capacité de calcul qui surpasse les ordinateurs classiques (suprématie quantique), mais la construction du matériel est extrêmement difficile.

5. Limites et défis actuels

Limites du recuit quantique

Limitation de la connectivité (Connectivity) : En raison du plongement mineur mentionné précédemment, lorsque la taille du problème augmente, le nombre de qubits physiques nécessaires augmente de manière exponentielle.
Précision des coefficients (Precision) : L’erreur physique lors du réglage des paramètres analogiques tels que $J_{ij}$ et $h_i$ sur le matériel affecte directement la qualité de la solution.
Température et transitions non-adiabatiques : Étant donné que la température du système n’est pas au zéro absolu, il y a une probabilité de s’écarter de la solution optimale en raison de l’excitation thermique.

Limites du modèle à portes quantiques

Temps de cohérence (Coherence Time) : Le temps pendant lequel un état quantique peut être maintenu n’est que de quelques microsecondes à quelques millisecondes, ce qui limite sévèrement le nombre de portes (profondeur de circuit) pouvant être exécutées pendant ce temps.
Fidélité des portes (Gate Fidelity) : Le taux d’erreur de fonctionnement des portes à 2 qubits (CNOT, etc.) n’est toujours pas suffisamment bas (généralement autour de 99.x%). Pour réaliser le FTQC, cela doit être élevé à plus de 99.99%.
Volume quantique (Quantum Volume) : Le plus grand défi actuel est de mettre à l’échelle non seulement le nombre de qubits, mais aussi la capacité de calcul effective (volume quantique), qui tient compte de l’interconnexion et des taux d’erreur.

6. Cas d’utilisation spécifiques et algorithmes

Examinons les domaines d’application spécifiques dans lesquels chaque méthode excelle.

6.1. Cas d’utilisation du recuit quantique

Logistique et Routage : Optimisation des itinéraires de livraison pour de multiples véhicules (une variation du problème du voyageur de commerce). Recherche d’itinéraire en temps réel tenant compte des embouteillages.
Ingénierie financière : Optimisation de portefeuille. Recherche d’une combinaison de titres qui maximise le rendement tout en minimisant les risques.
Apprentissage automatique : Sélection de caractéristiques (Feature Selection). Extraction de la combinaison de variables contribuant le plus à la prédiction à partir d’ensembles de données massifs.
Industrie manufacturière : Problème d’ordonnancement d’atelier (Job-shop scheduling) dans les usines (quelle machine doit traiter quelle pièce et dans quel ordre pour être le plus rapide).

6.2. Cas d’utilisation du modèle à portes quantiques

Simulation de chimie quantique : Simule les états énergétiques des molécules et les réactions chimiques avec une grande précision.
Factorisation en nombres premiers (Algorithme de Shor) : Un algorithme qui factorise d’énormes nombres composés en temps polynomial. Lorsque cela sera mis en pratique, les infrastructures de cryptographie à clé publique actuelles, telles que le chiffrement RSA, seront compromises, rendant la transition vers la cryptographie post-quantique (PQC) urgente.
Recherche dans une base de données (Algorithme de Grover) : Lors de la recherche de données cibles dans une base de données non triée, les ordinateurs classiques nécessitent $O(N)$ étapes, mais l’algorithme de Grover peut effectuer la recherche en $O(\sqrt{N})$ étapes.

6.3. Algorithmes hybrides de l’ère NISQ : VQE et QAOA

Pour surmonter la limitation des circuits quantiques peu profonds des dispositifs NISQ, les “Algorithmes quantiques variationnels (Variational Quantum Algorithms)”, qui combinent les avantages des ordinateurs quantiques et classiques, attirent l’attention.

VQE (Variational Quantum Eigensolver) : Algorithme pour trouver l’énergie de l’état fondamental d’une molécule. Il prépare un état quantique à l’aide d’un circuit quantique paramétré (Ansatz) et mesure l’espérance de l’énergie $\langle \psi(\theta) | H | \psi(\theta) \rangle$. En utilisant cette espérance comme fonction objectif, un algorithme d’optimisation classique (comme la descente de gradient) est utilisé pour mettre à jour les paramètres $\theta$. En répétant cela jusqu’à convergence, l’état énergétique précis de la molécule est trouvé.
QAOA (Quantum Approximate Optimization Algorithm) : Algorithme pour résoudre des problèmes d’optimisation combinatoire à l’aide du modèle à portes quantiques. L’évolution temporelle adiabatique du recuit quantique est approximée en opérations de portes discrètes par la “Trotterisation (Trotterization)”, et une solution approximative est obtenue en appliquant alternativement des Hamiltoniens. Le QAOA est prometteur comme un moyen puissant de résoudre des problèmes d’optimisation avec la méthode des portes.

graph TD User["Problème de l'utilisateur"] --> Formulation{"Nature du problème"} Formulation -- "Optimisation combinatoire" --> QA_Path["Recuit quantique / Machine d'Ising"] QA_Path --> QUBO["Formulation QUBO"] QUBO --> DWave["Exécution sur D-Wave"] Formulation -- "Calcul chimique / Calcul général" --> Gate_Path["Modèle à portes quantiques"] Gate_Path --> Circuit["Conception de circuit quantique (VQE / QAOA)"] Circuit --> IBMGoogle["Exécution matérielle quantique IBM / Google"]

7. Conclusion

Le recuit quantique et le modèle à portes quantiques sont identiques en ce sens qu’ils utilisent tous deux les propriétés mystérieuses de la mécanique quantique comme ressources de calcul, mais leurs approches et leurs objectifs sont très différents.

Le recuit quantique est un “moteur heuristique spécialisé” conçu pour fournir des résultats pratiques à un stade précoce pour le problème réel spécifique de l’optimisation combinatoire. Actuellement, des démonstrations de faisabilité (PoC) sont déjà en cours par diverses entreprises.
Le modèle à portes quantiques est un “ordinateur quantique universel” qui a le potentiel de renverser fondamentalement les paradigmes de la science informatique, des simulations rigoureuses en physique et chimie jusqu’au décryptage. Cependant, une recherche et développement à long terme est nécessaire pour surmonter l’énorme obstacle de la correction d’erreurs.

À l’avenir, il est attendu qu’un environnement de “Calcul hétérogène (Heterogeneous computing)” sera construit, où un superordinateur classique (HPC) servira de noyau, tout en faisant appel à des machines de recuit pour les tâches d’optimisation et à des ordinateurs quantiques de type porte pour les calculs de chimie quantique.

Les ordinateurs quantiques sont encore une technologie en développement, mais ils évoluent rapidement tant au niveau du matériel que des algorithmes. Comprendre les mathématiques du modèle d’Ising et les bases des circuits quantiques sera une arme majeure pour la prochaine ère quantique native.

Cet article explique de manière exhaustive les concepts fondamentaux de l’informatique quantique jusqu’aux dernières tendances matérielles. Restez à l’écoute des futures tendances de recherche.

Simulation de l'algorithme de Shor en Python

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

1. Introduction : La crise de la cryptographie provoquée par les ordinateurs quantiques

Une grande partie de la sécurité dans notre société Internet moderne repose sur la cryptographie à clé publique (en particulier le chiffrement RSA). Lorsque nous transmettons nos informations de carte de crédit lors d’achats en ligne ou que nous échangeons des données hautement confidentielles, ces communications sont solidement protégées par le chiffrement RSA.

La sécurité du chiffrement RSA repose sur un fait mathématique : « la factorisation en nombres premiers de très grands entiers est extrêmement difficile pour les ordinateurs classiques (les PC ou supercalculateurs que nous utilisons habituellement) ». Cependant, l’« algorithme de Shor » (Shor’s Algorithm), publié en 1994 par Peter Shor, a complètement remis en cause ce postulat. Il a été prouvé mathématiquement que si l’algorithme de Shor était exécuté sur un ordinateur quantique à grande échelle, il pourrait résoudre en quelques minutes ou quelques heures une factorisation qui prendrait plus de temps que l’âge de l’univers sur un ordinateur classique.

Dans cet article, nous expliquerons en détail comment cet algorithme de Shor parvient à effectuer cette factorisation à grande vitesse, de son mécanisme mathématique jusqu’à une implémentation de simulation concrète en Python utilisant le framework de calcul quantique Qiskit.

2. Le changement spectaculaire de la complexité : De la fonction exponentielle au temps polynomial

Pourquoi la factorisation en nombres premiers est-elle si difficile ? Même en utilisant le « crible général du corps de nombres » (General Number Field Sieve, GNFS), connu comme le meilleur algorithme de factorisation pour les ordinateurs classiques, sa complexité en temps reste sous-exponentielle.

La complexité en temps pour factoriser un nombre composé de $N$ chiffres avec une méthode classique est la suivante :

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Pour cette raison, il suffit d’augmenter la longueur de la clé (par exemple à 2048 ou 4096 bits) pour que le temps de décryptage sur un ordinateur classique devienne irréaliste, atteignant des milliers ou des dizaines de milliers d’années.

Cependant, en utilisant l’algorithme de Shor sur un ordinateur quantique, la complexité est considérablement réduite à un temps polynomial par rapport au nombre de bits d’entrée $\log N$.

$$ O((\log N)^3) $$

Cela signifie que si l’on double le nombre de bits, le temps de calcul augmente de manière astronomique pour un ordinateur classique, alors qu’il n’est multiplié que par 8 environ pour un ordinateur quantique. Cette réduction de la classe de complexité d’un temps exponentiel à un temps polynomial (inclusion dans la classe BQP) est ce qui rend l’algorithme de Shor si impressionnant.

graph TD A["Augmentation de la taille de l'entrée N (nombre de bits)"] --> B{"Choix de l'algorithme"} B -->|Classique : Crible général du corps de nombres| C["Augmentation sous-exponentielle O(exp(...))"] B -->|Quantique : Algorithme de Shor| D["Temps polynomial O((log N)^3)"] C --> E["Milliers à milliards d'années (Indéchiffrable)"] D --> F["Quelques minutes à quelques heures (Déchiffrable en un temps réaliste)"]

3. Vue d’ensemble de l’algorithme et contexte mathématique

En réalité, l’algorithme de Shor n’effectue pas toutes les opérations sur un ordinateur quantique. Il repose sur la collaboration entre des pré-traitements et post-traitements par un ordinateur classique, et la partie centrale (l’algorithme de recherche de période) exécutée par un ordinateur quantique.

Le flux global de l’algorithme est le suivant :

graph TD A["Entrée : Nombre composé N à factoriser"] --> B["Choisir un nombre aléatoire a tel que a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Oui" --> D["Afficher le facteur trivial gcd(a, N) et terminer"] C -- "Non" --> E["Trouver la période r de f(x) = a^x mod N avec un algorithme quantique"] E --> F{"r est pair ET a^(r/2) ≢ -1 mod N ?"} F -- "Non" --> B F -- "Oui" --> G["Calculer les facteurs p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Sortie : p, q"]

Réduction de la factorisation au problème de recherche de période

L’intuition géniale de Shor réside dans la transformation du « problème de factorisation » en un « problème de recherche de période » (Order Finding Problem).

Considérons un entier $N$ (le nombre à factoriser) et un entier premier avec lui $a$ ($1 < a < N$). Nous définissons la fonction d’exponentiation modulaire suivante :

$$ f(x) = a^x \bmod N $$

Cette fonction possède une certaine période $r$. Cela signifie que pour tout $x$, on a $f(x+r) = f(x)$. En particulier pour $x=0$, le plus petit entier positif $r$ tel que :

$$ a^r \equiv 1 \pmod N $$

est appelé l’« ordre » (Order) de $a$ modulo $N$. Si nous parvenons à trouver cette période $r$, nous pouvons en déduire les facteurs premiers de la manière suivante.

En transformant l’équation, on obtient :

$$ a^r - 1 \equiv 0 \pmod N $$

Si $r$ est pair, nous pouvons factoriser en utilisant la différence de deux carrés :

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Cela implique que $N$ partage un diviseur commun avec $(a^{r/2} - 1)$ ou $(a^{r/2} + 1)$ (à condition que $a^{r/2} \not\equiv -1 \pmod N$). Ainsi, en utilisant l’algorithme d’Euclide pour calculer :

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

nous pouvons trouver des facteurs non triviaux $p$ et $q$ de $N$. Ces calculs (le plus grand commun diviseur et la génération de nombres aléatoires) sont très rapides sur un ordinateur classique. Le cœur du problème est donc de savoir comment trouver rapidement la période $r$. Sur un ordinateur classique, trouver cette période requiert un temps exponentiel. C’est ici que l’ordinateur quantique entre en jeu.

4. La partie algorithmique quantique : Le mécanisme de recherche de période

La sous-routine permettant de trouver la période $r$ à l’aide d’un ordinateur quantique se compose des 4 étapes suivantes :

graph LR subgraph "Évolution de l'état quantique" S1["|0⟩|0⟩ (Initialisation)"] --> S2["Porte H : Superposition Σ|x⟩|0⟩"] S2 --> S3["Oracle U : Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT : Extraction de la période par interférence"] S4 --> S5["Mesure : Obtention de la valeur approchée y"] end

Étape 1 : Initialisation des registres quantiques et superposition

Tout d’abord, nous préparons deux registres quantiques. Le premier registre sert à entrer l’état, et le second sert à stocker le résultat du calcul de la fonction. L’état initial est entièrement $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Nous appliquons une porte de Hadamard (Hadamard Gate) à tous les qubits du premier registre, créant un état de superposition équiprobable de toutes les entrées possibles $x$ (de $0$ à $Q-1$, avec $Q=2^n$).

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

Ainsi, l’ordinateur quantique conserve simultanément l’état pour les $Q$ entrées en une seule opération. C’est la source puissante du parallélisme quantique.

Étape 2 : Application de la fonction oracle (exponentiation modulaire)

Ensuite, nous utilisons un circuit quantique $U_f$ pour calculer la fonction $f(x) = a^x \bmod N$ et stockons le résultat dans le second registre.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

À ce stade, le premier et le second registre sont dans un état d’intrication quantique (entanglement). Si (hypothétiquement) nous observions le second registre et obtenions une valeur spécifique $k = a^{x_0} \bmod N$, l’état du premier registre s’effondrerait sur la superposition des $x$ qui donnent cette valeur $k$. Puisque la fonction a une période $r$, les états restants seront espacés de $r$, soit $x_0, x_0+r, x_0+2r, \dots$.

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Cependant, ce n’est pas $x_0$ que nous voulons connaître, mais la période $r$ elle-même. Il est impossible d’observer directement $r$ à partir de cet état. C’est pourquoi nous utilisons la transformée de Fourier quantique.

Étape 3 : Interférence de phase par la transformée de Fourier quantique (QFT)

Nous appliquons la transformée de Fourier quantique (Quantum Fourier Transform, QFT) au premier registre. La QFT est la version quantique de la transformée de Fourier discrète classique et convertit les amplitudes des vecteurs d’état. L’action de la QFT sur l’état de base $|x\rangle$ est définie comme suit :

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Où $\omega = e^{2\pi i / Q}$.

Lorsque la QFT est appliquée, les amplitudes de l’état interfèrent. Bien que nous omettions les détails mathématiques, lorsqu’on applique la QFT à un état ayant une période $r$, les ondes provoquent une interférence constructive uniquement lorsque $y$ est très proche d’un multiple entier de $Q/r$. Pour les autres états, les amplitudes de probabilité s’annulent à cause d’une interférence destructive et s’approchent de zéro.

Étape 4 : Mesure et développement en fractions continues

Enfin, nous mesurons le premier registre. La valeur mesurée $y$ satisfait très probablement à la condition suivante :

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ est un entier inconnu tel que $0 \le c < r$)

En appliquant un algorithme classique de développement en fractions continues (Continued Fraction Expansion) au nombre rationnel obtenu $y/Q$, nous pouvons calculer la fraction approchée $c/r$ et extraire la période $r$ du dénominateur.

5. Implémentation de simulation avec Python et Qiskit

Puisque la théorie seule peut être abstraite, simulons l’algorithme de Shor en pratique avec Python et le framework quantique d’IBM, Qiskit.

Nous implémenterons ici le scénario le plus classique et le plus célèbre : « factoriser $N=15$ en utilisant $a=7$ ».

Préparation de l’environnement d’exécution

Veuillez installer Qiskit au préalable.

1

pip install qiskit qiskit-aer numpy

Aperçu du code de l’implémentation Python

Le code suivant est un exemple d’implémentation de l’algorithme de Shor spécifiquement pour $N=15$ et $a=7$. Étant donné que le coût de calcul pour construire un circuit d’exponentiation modulaire généralisé est trop élevé sur les simulateurs actuels, la logique des portes pour le cas particulier de $a=7$ a été codée en dur (hardcoded).

 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
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Fonction pour construire la transformée de Fourier quantique inverse (QFT†)
def qft_dagger(n):
 """Génère le circuit de la transformée de Fourier quantique inverse pour n qubits"""
 qc = QuantumCircuit(n)
 # Portes SWAP pour inverser l'ordre
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Application des portes de phase contrôlée et H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Fonction pour construire l'opération contrôlée d'exponentiation modulaire 7^x mod 15
def c_amod15(a, power):
 """Génère la porte U contrôlée pour un 'a' spécifique et une puissance (Dédié à N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Logique codée en dur pour 7^x mod 15 avec a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Construction du circuit quantique principal
def shor_circuit(a, n_count):
 # n_count : nombre de bits du registre de contrôle
 # Le registre cible utilise 4 bits pour représenter de 0 à 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Initialisation du 1er registre (registre de contrôle) pour créer la superposition
 for q in range(n_count):
 qc.h(q)

 # Initialisation du 2ème registre (registre cible) à |1> (0001)
 qc.x(3 + n_count)

 # Application de l'opération d'exponentiation modulaire contrôlée (Oracle)
 for q in range(n_count):
 # Applique l'opération à la puissance 2^q
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Application de la transformée de Fourier quantique inverse au 1er registre
 qc.append(qft_dagger(n_count), range(n_count))

 # Mesure du 1er registre
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Section d'exécution ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Utilisation de 8 qubits pour le registre de contrôle (Q=256)

 print(f"Paramètres de recherche : N={N}, a={a}, qubits de contrôle={n_count}")

 # Génération du circuit
 qc = shor_circuit(a, n_count)

 # Exécution avec le simulateur
 sim = AerSimulator()
 # La transpilation est recommandée dans les versions récentes de Qiskit
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nRésultats de la mesure (chaîne de bits : nombre d'observations) :")
 for bitstring, count in counts.items():
 print(f" {bitstring} : {count} fois")

 # Post-traitement classique : Détermination de la période r via les fractions continues
 print("\n--- Calcul de la période et factorisation ---")
 phases = []
 for output in counts:
 # Conversion de la chaîne de bits en décimal
 decimal = int(output, 2)
 # Phase = valeur mesurée / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Obtention de la fraction approchée. Le dénominateur max est N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Mesure : {decimal:3d} | Phase : {phase:.4f} | Fraction continue : {frac} | Période estimée r = {r}")

 # Vérification : la période r est-elle paire et produit-elle un résultat valide ?
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Succès ! Les facteurs de {N} sont {guess1} et {guess2}.")
 else:
 print(f" => Facteurs triviaux uniquement. À refaire.")
 else:
 print(f" => Échec car la période est impaire.")

Explication du code et analyse des résultats

L’exécution du code ci-dessus montre des pics spécifiques (valeurs mesurées) avec une forte probabilité pour le registre de contrôle. Dans le cas où n_count=8 ($Q=256$), si nous avions un ordinateur quantique idéal (ou un simulateur), les valeurs 0, 64, 128, 192 apparaîtraient avec une probabilité écrasante.

En divisant ces valeurs par $Q=256$, nous obtenons les phases respectives $y/Q$ de $0.0$, $0.25$, $0.5$ et $0.75$. Le développement en fractions continues de ces phases donne :

$0.25 \to 1/4$ (Période estimée $r=4$)
$0.50 \to 1/2$ (Période estimée $r=2$)
$0.75 \to 3/4$ (Période estimée $r=4$)

En utilisant la période $r=4$ ainsi obtenue, nous calculons les facteurs premiers. Puisque $a=7$ et $r=4$, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Nous avons réussi brillamment la factorisation de $15 = 3 \times 5$.

[!TIP] Si la valeur mesurée est $y=128$ (phase $0.5$), le dénominateur devient $2$, et nous obtenons un diviseur de la vraie période au lieu de $r=4$. Dans ce cas, nous pouvons relancer l’algorithme ou tester les multiples de la période $r$ obtenue pour trouver la vraie période.

6. Défis pour l’application pratique et les limites de l’ère NISQ

Bien qu’il soit facile de factoriser $N=15$ sur un simulateur, factoriser le chiffrement RSA-2048 utilisé dans le monde réel (un nombre de 617 chiffres) se heurte encore à de nombreux obstacles avec les ordinateurs quantiques actuels.

L’époque dans laquelle nous vivons actuellement est appelée l’ère NISQ (Noisy Intermediate-Scale Quantum : ordinateurs quantiques bruités de taille intermédiaire). Les qubits sont extrêmement sensibles au bruit ambiant et subissent de la « décohérence » pendant les calculs, ce qui détruit leur état.

Pour exécuter avec précision un circuit profond (avec de nombreuses portes quantiques) comme l’algorithme de Shor, il est indispensable de disposer de la correction d’erreurs quantiques (Quantum Error Correction). Pour créer un seul « qubit logique » sans bruit, il faut encoder des milliers de « qubits physiques » en utilisant des méthodes comme le code de surface (Surface Code).

Pour casser le chiffrement RSA 2048 bits, on estime qu’il faudrait quelques milliers de qubits logiques parfaits, ce qui nécessiterait un ordinateur quantique tolérant aux pannes (fault-tolerant) doté de plusieurs millions à dizaines de millions de qubits physiques. Les processeurs quantiques les plus avancés d’aujourd’hui ne comptant que quelques centaines à quelques milliers de qubits physiques, les chiffrements du monde entier ne seront pas brisés dans l’immédiat.

[!WARNING] Cependant, il existe un modèle de menace appelé « Store Now, Decrypt Later » (Sauvegarder maintenant, déchiffrer plus tard). Des attaquants pourraient stocker massivement les communications chiffrées actuelles et les déchiffrer entièrement dans 10 à 20 ans dès qu’un ordinateur quantique suffisamment puissant sera construit.

7. Transition vers la cryptographie post-quantique (PQC)

Pour se préparer à l’arrivée du « Q-Day » (le jour où les ordinateurs quantiques briseront la cryptographie), les cryptographes du monde entier, menés par le National Institute of Standards and Technology (NIST) américain, élaborent la cryptographie post-quantique (Post-Quantum Cryptography, PQC).

La PQC est basée sur de nouveaux problèmes mathématiques (problèmes de réseaux euclidiens, polynômes multivariés, fonctions de hachage, etc.) que l’on considère impossibles à résoudre efficacement même avec l’algorithme de Shor (ou l’algorithme de Grover). Des algorithmes comme « CRYSTALS-Kyber » et « CRYSTALS-Dilithium » ont déjà été sélectionnés comme normes standards, et leur intégration commence progressivement dans les protocoles de communication des navigateurs web ou iMessage d’Apple.

Pour les ingénieurs qui gèrent les infrastructures informatiques, intégrer l’« agilité cryptographique » (la capacité à changer rapidement de méthode de chiffrement) pour passer du RSA existant ou de la cryptographie sur les courbes elliptiques à la PQC, constituera une mission majeure dans le futur.

8. Conclusion

Dans cet article, nous avons fourni une explication exhaustive d’environ 10 000 caractères, allant du contexte mathématique théorique de l’algorithme de Shor aux mécanismes d’extraction de période par la transformée de Fourier quantique, jusqu’au code de simulation concret avec Python et Qiskit.

Le fait que les lois physiques du monde microscopique de la mécanique quantique bouleversent fondamentalement les fondations de l’informatique macroscopique telles que la théorie de la complexité et la cryptographie est l’un des changements de paradigme les plus excitants de l’histoire des sciences. Il est crucial de continuer à suivre cette bataille en cours entre l’évolution des technologies informatiques quantiques et les nouvelles technologies cryptographiques conçues pour y résister.

N’hésitez pas à exécuter le code Python présenté dans cet article sur votre propre environnement pour expérimenter la « magie du calcul » créée par la superposition et l’interférence des états quantiques.

Références

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Documentation Qiskit : https://qiskit.org/documentation/

【Illustration PQC】 Comparaison des principaux algorithmes de la cryptographie post-quantique

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

1. Introduction : La « crise de la cryptographie » provoquée par les ordinateurs quantiques

Dans la société Internet moderne, la cryptographie à clé publique est une infrastructure indispensable pour protéger la confidentialité des communications et l’intégrité des données. Les méthodes de cryptographie largement utilisées aujourd’hui, telles que RSA et la cryptographie sur les courbes elliptiques (ECC), reposent sur des barrières mathématiques telles que la « difficulté de la factorisation de très grands nombres composés » ou la « difficulté du problème du logarithme discret sur les courbes elliptiques » pour garantir leur sécurité. Avec les ordinateurs classiques (les ordinateurs que nous utilisons actuellement, y compris les superordinateurs), il a été prouvé qu’il faudrait plus de temps que l’âge de l’univers pour résoudre ces problèmes mathématiques, ce qui constitue le fondement de leur sécurité.

Cependant, cette prémisse solide est sur le point d’être fondamentalement bouleversée par l’avancée de la théorie et de la mise en pratique des ordinateurs quantiques. En 1994, l’algorithme de Shor, publié par le cryptographe Peter Shor (« Algorithme de Shor »), a prouvé théoriquement que les problèmes de factorisation et de logarithme discret pourraient être résolus en « temps polynomial » s’ils étaient exécutés sur un ordinateur quantique universel tolérant aux pannes (CRQC : Cryptographically Relevant Quantum Computer) d’une capacité suffisante. Cela signifie que toutes les cryptographies à clé publique utilisées actuellement seront rendues inefficaces.

graph TD A["Ordinateur quantique à grande échelle (CRQC)"] -->|Exécution| B["Algorithme de Shor"] B -->|Déchiffrement en temps polynomial| C["Problème de factorisation en nombres premiers (RSA)"] B -->|Déchiffrement en temps polynomial| D["Problème du logarithme discret (ECC / ECDSA)"] C --> E["Écoute de communications chiffrées, altération de données, usurpation d'identité"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

Il est très dangereux de penser que « l’achèvement à grande échelle des ordinateurs quantiques n’est pas prévu avant plusieurs décennies, il n’y a donc pas de problème ». En effet, la méthode d’attaque appelée Store Now, Decrypt Later (SNDL : Stocker maintenant, déchiffrer plus tard) est déjà une menace réelle. Il s’agit d’une attaque dans laquelle des États malveillants ou des groupes de pirates stockent massivement les données de communication chiffrées actuelles (comme le trafic TLS) sur des supports de stockage, afin de les déchiffrer toutes dès qu’un ordinateur quantique puissant sera disponible à l’avenir. Les secrets d’État, les informations d’infrastructure et les données médicales qui doivent être protégées à long terme sont déjà exposés à cette menace.

De plus, il existe l’algorithme de Grover, découvert en 1996, qui s’applique à la cryptographie à clé symétrique (comme AES) et aux fonctions de hachage (comme SHA-256). Cet algorithme réduit la complexité de l’attaque par force brute à sa racine carrée. En d’autres termes, le niveau de sécurité de l’AES-128 est effectivement réduit de moitié, pour atteindre 2 à la puissance 64. Par conséquent, à l’ère quantique, il est recommandé d’utiliser des longueurs de clés et des longueurs de hachage plus grandes, telles que l’AES-256 et le SHA-384.

Pour faire face à cette crise cryptographique sans précédent, une nouvelle cryptographie post-quantique (Post-Quantum Cryptography : PQC) a vu le jour, reposant sur de nouveaux problèmes mathématiques difficiles à déchiffrer même avec des ordinateurs quantiques. Cet article explique de manière très détaillée, sur la base des résultats du processus de standardisation PQC mené par le National Institute of Standards and Technology (NIST) des États-Unis, les principaux algorithmes PQC, depuis leur contexte mathématique jusqu’à leurs mécanismes et la comparaison de leurs architectures.

2. Aperçu et histoire du projet de standardisation PQC par le NIST

La transition des technologies cryptographiques, qui implique la refonte des protocoles, la mise à jour des systèmes et le remplacement du matériel, prendra des années, voire des décennies. C’est pourquoi les cryptographes du monde entier ont commencé très tôt à faire des recherches sur la PQC. Le NIST (National Institute of Standards and Technology) américain a joué un rôle central dans ce domaine. En 2016, le NIST a lancé un appel public pour le processus de standardisation de la PQC et a accepté des propositions de tout nouveaux algorithmes cryptographiques de la part de la communauté cryptographique mondiale.

Les deux principales catégories ciblées par la standardisation étaient les suivantes :

Cryptographie à clé publique / Mécanisme d’encapsulation de clé (KEM : Key Encapsulation Mechanism) : Mécanisme permettant de partager (distribuer) en toute sécurité une clé symétrique pour chiffrer le canal de communication dans des connexions telles que TLS.
Signatures numériques (Digital Signatures) : Mécanisme permettant de prouver, dans les mises à jour logicielles et les certificats électroniques, que les données n’ont pas été altérées et qu’il n’y a pas d’usurpation d’identité de l’expéditeur (authenticité).

Après environ six années de concurrence acharnée en matière d’évaluation, d’analyse et de cryptanalyse (Round 1 à Round 3), une évaluation supplémentaire (Round 4) a été menée pour certains algorithmes. En conséquence, les algorithmes suivants ont été officiellement publiés en tant que Federal Information Processing Standards (FIPS) en 2024, s’établissant comme les futures normes mondiales.

FIPS 203 (ML-KEM) : KEM basé sur CRYSTALS-Kyber
FIPS 204 (ML-DSA) : Signature numérique basée sur CRYSTALS-Dilithium
FIPS 205 (SLH-DSA) : Signature basée sur le hachage sans état (stateless) reposant sur SPHINCS+
(À formuler ultérieurement) FN-DSA : Signature numérique basée sur FALCON

Ces algorithmes sélectionnés reposent chacun sur des « problèmes de difficulté » mathématiques différents. Ainsi, si une vulnérabilité fatale venait à être découverte dans l’un des algorithmes à l’avenir, la diversité (Crypto Agility) est assurée pour éviter que l’ensemble du système ne s’effondre. Dans le processus de standardisation, la cryptographie basée sur les réseaux (Lattice-based cryptography) a joué le rôle principal en raison de ses performances, mais la cryptographie basée sur le hachage et la cryptographie basée sur les codes ont été adoptées comme de solides solutions de secours.

3. Classification des principales approches mathématiques de la PQC

Les algorithmes PQC sont principalement classés en cinq catégories en fonction des problèmes mathématiques qui sous-tendent leur sécurité. Dans cet article, nous approfondirons particulièrement les trois premiers.

Cryptographie basée sur les réseaux (Lattice-based Cryptography) : Elle repose sur le problème du vecteur le plus court (SVP) et le problème du vecteur le plus proche (CVP) dans un espace de réseau multidimensionnel, ainsi que sur le problème LWE qui en dérive. Elle est au cœur de la standardisation du NIST, et Kyber, Dilithium et FALCON en font partie. Elle offre le meilleur équilibre entre la vitesse de traitement, la taille de la clé publique et la taille du texte chiffré, ce qui la rend adaptée à une utilisation polyvalente.
Cryptographie basée sur le hachage (Hash-based Cryptography) : Elle fonde sa sécurité uniquement sur la « résistance aux collisions » et la « propriété unidirectionnelle » des fonctions de hachage cryptographique (telles que SHA-2 et SHAKE). Bien qu’elle ne soit applicable qu’aux signatures numériques (comme SPHINCS+), ses preuves de sécurité sont les plus robustes et elle se caractérise par une résistance extrêmement élevée aux attaques mathématiques inconnues.
Cryptographie basée sur les codes (Code-based Cryptography) : Basée sur la théorie des codes correcteurs d’erreurs, elle dépend de la difficulté du problème du décodage de syndrome (Syndrome Decoding Problem). Le Classic McEliece, proposé dans les années 1970, en est représentatif et possède une très longue histoire et une sécurité éprouvée, bien que la taille de la clé publique soit extrêmement importante (de l’ordre du mégaoctet).
Cryptographie polynomiale multivariée (Multivariate Polynomial Cryptography) : Elle repose sur la difficulté de résoudre des systèmes d’équations quadratiques à plusieurs variables sur un corps fini (problème MQ). Principalement proposée pour les signatures numériques (comme Rainbow), une méthode d’attaque puissante permettant de la déchiffrer en quelques jours sur un simple PC a été découverte lors du dernier round du NIST, entraînant l’élimination de nombreux algorithmes de la standardisation.
Cryptographie basée sur les isogénies (Isogeny-based Cryptography) : Elle repose sur le problème de recherche de chemin sur des graphes d’isogénies de courbes elliptiques. Avec des tailles de clé très petites, elle était attendue comme le successeur légitime de l’ECC, mais « SIKE », le candidat final, a été complètement déchiffré en seulement quelques heures sur un PC normal en 2022 à l’aide de mathématiques classiques (comme l’attaque de Castryck-Decru), symbolisant la fin dramatique, ainsi que la difficulté et le danger liés à la conception de la PQC.

4. Les abysses de la cryptographie sur les réseaux : Les bases mathématiques du problème LWE et du Module-LWE

Considérée aujourd’hui comme la plus prometteuse et devenue le centre de la standardisation, voici la cryptographie basée sur les réseaux (Lattice cryptography). À la base de sa sécurité se trouve le problème LWE (Learning with Errors : Apprentissage avec erreurs). Proposé par Oded Regev en 2005, cette réalisation historique lui a valu le prix Gödel. Il est impossible de parler de la PQC moderne sans comprendre le problème LWE.

4.1. Qu’est-ce que le problème LWE (Learning with Errors) ?

Considérons tout d’abord un simple système d’équations linéaires. Sous un certain module $q$ (modulo $q$), supposons que nous ayons une matrice aléatoire connue $A$, un vecteur secret inconnu $\vec{s}$, et que leur produit $\vec{b}$ soit donné.

$$ \vec{b} = A\vec{s} \pmod q $$

Dans ce cas, il est facile de trouver le vecteur inconnu $\vec{s}$ à partir des informations publiques $A$ et $\vec{b}$. En utilisant un algorithme classique comme « l’élimination de Gauss (ou pivot de Gauss) », on peut facilement calculer $\vec{s}$ en temps polynomial.

Cependant, si l’on ajoute à cette équation une « petite erreur intentionnelle (bruit) », le niveau de difficulté du problème augmente considérablement. C’est ce qu’on appelle le problème LWE.

On prépare un vecteur secret inconnu $\vec{s} \in \mathbb{Z}_q^n$ et une matrice choisie au hasard $A \in \mathbb{Z}_q^{m \times n}$. De plus, un vecteur d’erreur $\vec{e} \in \mathbb{Z}_q^m$ dont « la valeur des éléments est suffisamment petite » est choisi selon une distribution normale ou binomiale, et $\vec{b}$ est calculé comme suit.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Le problème Search LWE (LWE de recherche) consiste à « trouver l’information secrète $\vec{s}$ à partir des informations publiques $(A, \vec{b})$ ». En raison de la présence de cette erreur $\vec{e}$, toute tentative d’utiliser des méthodes de résolution algébriques telles que l’élimination de Gauss fera que l’erreur $\vec{e}$ s’amplifiera de manière exponentielle lors de l’addition et de la soustraction des équations, devenant finalement indiscernable d’une valeur aléatoire et conduisant à un échec.

La puissance du problème LWE réside dans le fait qu’il existe une forte preuve théorique (réduction) affirmant que le problème LWE ne peut pas non plus être résolu en moyenne (Average-case), à moins qu’il n’existe un algorithme quantique capable de résoudre le problème du plus court vecteur de décision (GapSVP) ou le problème des vecteurs indépendants les plus courts (SIVP), qui sont des problèmes de « complexité dans le pire des cas (Worst-case hardness) » sur les réseaux. En d’autres termes, même pour des clés de chiffrement générées aléatoirement, une sécurité robuste, soutenue par des limites théoriques, est garantie.

4.2. Amélioration drastique de l’efficacité grâce à Ring-LWE et Module-LWE

Le problème LWE normal (Standard LWE) a une base de sécurité très claire, mais n’est pas pratique car la taille de la matrice $A$ devient très grande et les tailles de clés atteignent le niveau du mégaoctet. L’approche proposée a donc été d’utiliser des anneaux de polynômes (Polynomial Rings) pour lui donner une structure algébrique.

Dans le problème Ring-LWE, on utilise des éléments (polynômes) d’un certain anneau de polynômes $R_q$ au lieu de simples vecteurs et matrices. Dans la norme NIST, l’anneau de polynômes cyclotomiques suivant est généralement utilisé.

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Ici, $n$ est une puissance de 2 (par exemple 256) et $q$ est un nombre premier approprié. Sur cet anneau, on calcule $b = a \cdot s + e \pmod q$ en utilisant les éléments $a, s, e \in R_q$. Comme un seul polynôme $a$ possède $n$ coefficients, les données peuvent être considérablement compressées. De plus, l’utilisation d’une version de transformée de Fourier rapide (FFT) sur corps fini, appelée NTT (Number Theoretic Transform : Transformée de la théorie des nombres), permet une multiplication de polynômes ultra-rapide avec une complexité de calcul de $O(n \log n)$.

Cependant, il y avait des inquiétudes concernant le Ring-LWE quant à « l’existence possible de vulnérabilités inconnues dues à la structure algébrique spécifique de l’anneau ». Il y avait également le défi d’ingénierie selon lequel, lors de la modification du niveau de sécurité (par exemple, équivalent à AES-128, 192, 256), il fallait modifier le degré $n$ du polynôme lui-même, ce qui nécessitait de réécrire l’ensemble de l’implémentation, y compris l’algorithme NTT.

C’est pourquoi les algorithmes standardisés Kyber et Dilithium ont adopté le problème Module-LWE (M-LWE). Le Module-LWE est un compromis situé exactement entre le Standard LWE sans structure et le Ring-LWE qui possède trop de structure, en utilisant une matrice de taille $k \times k$ (module) dont les composants sont les éléments de l’anneau de polynômes $R_q$.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Le plus grand avantage du Module-LWE est qu’il permet de faire évoluer facilement le niveau de sécurité en modifiant simplement la dimension $k$ de la matrice, tout en gardant fixe le degré $n$ du polynôme (dans la norme NIST, $n=256$). Par exemple, pour Kyber, la dimension $k$ est ajustée de la manière suivante :

Kyber512 (Niveau 1) : $k = 2$ (équivalent AES-128)
Kyber768 (Niveau 3) : $k = 3$ (équivalent AES-192)
Kyber1024 (Niveau 5) : $k = 4$ (équivalent AES-256)

Cela a permis de réutiliser à 100 % le code NTT sous-jacent et le circuit matériel des opérations polynomiales pour tous les niveaux de sécurité, ce qui a permis d’améliorer considérablement la sécurité et l’efficacité de l’implémentation.

5. CRYSTALS-Kyber (ML-KEM) : Le mécanisme d’encapsulation de clé de nouvelle génération

Officiellement standardisé sous le nom de FIPS 203 (ML-KEM), CRYSTALS-Kyber est un mécanisme d’encapsulation de clé (KEM) basé sur le problème Module-LWE susmentionné. Il s’agira de la norme mondiale de facto pour le partage sécurisé des clés de session à l’avenir, notamment pour TLS 1.3 et SSH.

5.1. Architecture du KEM (Key Encapsulation Mechanism)

À l’ère de la PQC, l’approche directe telle que RSA où « le client crée une clé partagée, la chiffre avec la clé publique du serveur et l’envoie » est remplacée par le cadre d’encapsulation appelé KEM.

sequenceDiagram participant Client as "Client (Alice)" participant Server as "Serveur (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Générer la clé secrète (sk) et la clé publique (pk)" Client->>Server: "Envoyer la clé publique (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Générer une clé partagée aléatoire (K)" Server->>Server: "Encapsuler K avec pk pour créer le texte chiffré (c)" Server->>Client: "Envoyer le texte chiffré (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Déchiffrer le texte chiffré (c) à l'aide de la clé secrète (sk)" Client->>Client: "Désencapsuler et extraire la clé partagée (K)" Note over Client, Server: "Commencer la communication chiffrée (par ex. AES) avec la clé partagée (K)"

5.2. Fonctionnement interne de Kyber et Transformation de Fujisaki-Okamoto

La conception de Kyber est extrêmement raffinée. Tout d’abord, un schéma de chiffrement à clé publique (Kyber.CPAPKE), sûr uniquement contre les attaques à texte clair choisi (CPA), est construit, puis une technique cryptographique très puissante appelée Transformation de Fujisaki-Okamoto (Fujisaki-Okamoto Transform) est appliquée, ce qui permet de le faire évoluer vers un KEM complet et sûr contre les attaques à chiffré choisi adaptatif (CCA).

Le mécanisme de chiffrement et de déchiffrement au cœur de CPAPKE est le suivant :

Génération de clé (Key Generation) :
- À partir d’une valeur de graine aléatoire (seed), générer une matrice $A \in R_q^{k \times k}$ sur le domaine NTT. Le modulo $q$ utilisé est $3329$.
- Échantillonner un vecteur secret $\vec{s}$ et un vecteur d’erreur $\vec{e}$ avec de petits coefficients à partir d’une distribution binomiale centrée (CBD).
- Calculer $\vec{t} = A\vec{s} + \vec{e}$. La clé publique est $(A, \vec{t})$ et la clé secrète est $\vec{s}$. (En pratique, $A$ est publiée en tant que valeur de graine (seed) pour économiser de la bande passante).
Chiffrement (Encryption) :
- Encoder le message de 32 octets (matériau de la clé partagée) $m$ que l’on souhaite partager en un polynôme.
- Générer un nouveau vecteur aléatoire $\vec{r}$ et de petites erreurs $\vec{e_1}, e_2$.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- Le texte chiffré est $(\vec{u}, v)$.
Déchiffrement (Decryption) :
- Le destinataire calcule $v - \vec{s}^T\vec{u}$.
- Le développement de cette équation donne ce qui suit. $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- En remplaçant $\vec{t} = A\vec{s} + \vec{e}$, le terme principal $\vec{s}^TA^T\vec{r}$ s’annule.
- Il reste $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- Les termes entre parenthèses étant des « produits ou sommes de petites erreurs », l’ensemble reste une valeur (bruit) suffisamment petite. Par conséquent, en déterminant si chaque coefficient est proche de $0$ ou de $q/2$, les bits (0 ou 1) du message d’origine $m$ peuvent être parfaitement restaurés sans aucune erreur.

La plus grande force de Kyber réside dans sa vitesse de traitement impressionnante et sa taille de clé modérée. Pour Kyber768, la taille de la clé publique est de 1 184 octets et la taille du texte chiffré est de 1 088 octets. Bien qu’elles soient plus importantes par rapport à RSA-3072 (taille de clé d’environ 384 octets), il est possible de les faire tenir dans l’unité de transmission maximale (MTU) des communications Internet modernes sans fragmentation des paquets, ce qui n’a presque aucun impact négatif sur la latence du réseau.

6. CRYSTALS-Dilithium (ML-DSA) : Signature numérique polyvalente basée sur les réseaux

Dans la standardisation des signatures numériques, des algorithmes avec différentes philosophies de conception ont concouru au sein de la même approche de la cryptographie sur les réseaux. Parmi eux, CRYSTALS-Dilithium a été sélectionné comme signature numérique polyvalente sous le nom de FIPS 204 (ML-DSA).

6.1. Le paradigme Fiat-Shamir with Aborts

Comme Kyber, Dilithium est un schéma de signature numérique basé sur le problème Module-LWE (ainsi que sur le problème Module-SIS). À la base de sa conception, le paradigme extrêmement important appelé « Fiat-Shamir with Aborts (Transformation de Fiat-Shamir avec rejets) » est utilisé.

La transformation de Fiat-Shamir elle-même est une méthode standard pour convertir un protocole interactif de preuve à divulgation nulle (zero-knowledge proof) en une signature numérique non interactive. Le prouveur (signataire) génère un engagement (commitment) $y$, calcule $w = Ay$ et le passe par une fonction de hachage pour obtenir un défi aléatoire $c$, puis calcule la réponse $z = y + cs$.

Cependant, dans la cryptographie sur les réseaux, l’application naïve de cette méthode entraînait un problème fatal (fuite mathématique de type canal auxiliaire) où la distribution de la réponse $z$ devenait asymétrique en fonction de la valeur de la clé secrète $s$, et un attaquant observant de nombreuses signatures obtiendrait peu à peu des informations sur la clé secrète $s$.

L’équipe de conception de Dilithium (Lyubashevsky et al.) a introduit une technique appelée « Échantillonnage par rejet (Rejection Sampling) » : si les coefficients du résultat de la signature $z$ ne tombent pas dans une plage de seuil de sécurité prédéfinie, l’ensemble du processus de signature est abandonné (Abort) et le calcul est recommencé depuis le début en utilisant un nouveau nombre aléatoire $y$.

Grâce à cela, la signature finale produite $z$ est une distribution complètement uniforme qui ne dépend en aucun cas de la clé secrète, réussissant à prévenir complètement la fuite d’informations sur le plan mathématique.

6.2. Les avantages de Dilithium et la facilité de son implémentation

Le grand avantage de la conception de Dilithium est qu’elle n’utilise absolument pas d’« échantillonnage complexe à partir de distributions gaussiennes » ou d’« opérations en virgule flottante » dans le processus de génération de signature. Puisqu’il peut être mis en œuvre uniquement avec un échantillonnage à partir d’une distribution uniforme, des opérations simples en modulo entier, des NTT et des fonctions de hachage (SHAKE), il est facile de l’implémenter de manière sécurisée et en temps constant (Constant-time) dans un large éventail d’environnements, allant des microcontrôleurs embarqués aux serveurs cloud. De ce fait, il possède également une forte résistance contre les attaques physiques par canal auxiliaire, telles que les attaques par chronométrage (timing attacks).

7. FALCON (FN-DSA) : Signature sur réseaux ultra-compacte

Le NIST a sélectionné FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) comme autre candidat standard de signature basée sur les réseaux, avec des caractéristiques différentes de celles de Dilithium (actuellement en cours de rédaction en tant que FN-DSA).

7.1. Réseaux NTRU et échantillonnage gaussien

La plus grande caractéristique de FALCON est qu’il n’utilise pas le problème LWE, mais plutôt le réseau NTRU (N-th degree Truncated polynomial Ring Units), très ancien et existant depuis 1996. De plus, il adopte le paradigme « Hash-and-Sign (Hachage et Signature) » basé sur le framework GPV (Gentry-Peikert-Vaikuntanathan).

Dans Hash-and-Sign, la valeur de hachage du message est utilisée comme point cible dans l’espace, et le point sur le réseau le plus proche de ce point (une solution approchée du problème du vecteur le plus proche) est trouvé pour servir de signature. Pour cela, il est nécessaire d’échantillonner des points selon une distribution gaussienne discrète en utilisant une « base courte de bonne qualité » qui est la clé secrète.

FALCON a considérablement accéléré ce calcul intensif en utilisant une technique appelée « Orthogonalisation de Fourier rapide (Fast Fourier Orthogonalization : FFO) ».

7.2. Avantages et inconvénients de FALCON

L’avantage écrasant de FALCON réside dans le fait que la taille de sa signature et la taille de sa clé publique sont extrêmement petites (compactes). Alors que la taille de la signature de Dilithium3 est d’environ 3 309 octets, celle de FALCON-512 n’est que d’environ 666 octets. La clé publique est également très petite, avec 897 octets, ce qui en fait un sauveur dans les environnements où la bande passante de communication est extrêmement limitée, pour les appareils IoT et dans certains protocoles réseau.

Cependant, il existe un inconvénient majeur. Puisque l’échantillonnage gaussien discret impliquant des opérations complexes en virgule flottante (64-bit IEEE 754) est indispensable lors de la génération de la signature, l’implémentation en temps constant (Constant-time implementation) pour prévenir les fuites de temps est extrêmement difficile, et le code devient énorme. C’est pourquoi FALCON est positionné comme un puissant algorithme spécialisé pour des usages spécifiques, par opposition à l’utilisation polyvalente (Dilithium).

graph LR A["Exigences en matière de signatures numériques"] --> B{"Quelle est la contrainte prioritaire ?"} B -->|"Simplicité d'implémentation, polyvalence, facilité d'implémentation en temps constant"| C["Dilithium (ML-DSA)"] B -->|"Minimisation de la bande passante de communication, compacité de la taille des données"| D["FALCON (FN-DSA)"] C --> E["Certificats TLS génériques, signature électronique de logiciels"] D --> F["Protocoles avec des limites strictes de taille de paquet, environnements spéciaux"]

8. SPHINCS+ (SLH-DSA) : Signature basée sur le hachage offrant la plus forte sécurité

Pour se préparer au pire des scénarios (le cas échéant) où la sécurité de la cryptographie sur les réseaux serait brisée à l’avenir par une percée d’un brillant mathématicien, le NIST a formulé FIPS 205 (SLH-DSA), c’est-à-dire SPHINCS+, en tant que norme basée sur une approche complètement différente de celle de la cryptographie sur les réseaux.

SPHINCS+ est classé comme une signature basée sur le hachage. Sa sécurité repose uniquement sur un seul point : « la fonction de hachage cryptographique utilisée (comme SHA-2 ou SHAKE256) possède une résistance aux collisions et une propriété unidirectionnelle ». Contrairement au LWE ou à la factorisation, qui dépendent de problèmes mathématiques possédant des structures algébriques spécifiques, SPHINCS+ peut faire face à n’importe quel algorithme quantique puissant qui pourrait apparaître à l’avenir, simplement en allongeant la longueur de sortie de la fonction de hachage. Il s’enorgueillit ainsi d’une sécurité extrêmement robuste (la sécurité la plus conservatrice).

8.1. Architecture sans état (stateless) avec WOTS+ et FORS

L’histoire des signatures basées sur le hachage est ancienne et remonte aux signatures Lamport et aux signatures à usage unique (One-Time Signatures) Winternitz (WOTS) des années 1970. Il s’agissait de clés jetables où « l’on ne peut signer en toute sécurité qu’une seule fois ». Afin de pouvoir les utiliser plusieurs fois, des algorithmes tels que XMSS (eXtended Merkle Signature Scheme) et LMS ont été développés en combinant des arbres de Merkle pour gérer d’innombrables clés à usage unique avec un seul hachage racine.

Cependant, XMSS et LMS présentaient un défaut majeur : ils étaient « avec état (stateful) ». Chaque fois qu’une signature était effectuée, il était nécessaire de conserver un enregistrement strict de l’état de l’index « quelle clé à usage unique a été utilisée » dans une mémoire non volatile. Si l’état était restauré (par exemple, par la restauration d’un snapshot de machine virtuelle) et que la même clé à usage unique était utilisée deux fois, la clé secrète serait immédiatement divulguée et le système s’effondrerait.

SPHINCS+ est une signature basée sur le hachage « sans état (stateless) » qui a résolu les tracas liés à la gestion des états. Sa technologie de base est la combinaison suivante :

WOTS+ (Winternitz One-Time Signature Plus) : Signature à usage unique de base.
FORS (Forest of Random Subsets) : Technologie de signature à faible fréquence d’utilisation (Few-Time Signature). La sécurité est maintenue même si la même clé est réutilisée un petit nombre de fois.
Hyper-Tree (Structure arborescente géante) : Structure géante composée de plusieurs couches d’arbres de Merkle empilées.

Dans SPHINCS+, lors de la signature, au lieu de gérer des états, une clé FORS est sélectionnée de manière aléatoire parmi un nombre colossal de clés au bas de l’Hyper-Tree à l’aide d’un nombre pseudo-aléatoire pour effectuer la signature. Étant donné que le nombre de feuilles de l’arbre est astronomique, la probabilité de sélectionner la même clé deux fois par accident (collision) est si faible qu’elle peut être ignorée, ce qui permet d’atteindre l’absence d’état (stateless).

La seule et plus grande faiblesse de SPHINCS+ est que la taille de sa signature est extrêmement grande. Selon les paramètres, la taille de la signature peut atteindre 17 kilo-octets à 49 kilo-octets, et la vitesse de génération des signatures est également très lente par rapport à la cryptographie sur les réseaux. Par conséquent, il est prévu de l’utiliser dans des applications nécessitant une sécurité absolue à long terme et où les signatures ne sont pas effectuées fréquemment, telles que les signatures de mise à jour logicielle et les certificats d’Autorité de Certification (CA) racine, plutôt que pour la navigation Web quotidienne.

9. Cryptographie basée sur les codes : Classic McEliece, le bon vieux géant

Dans le processus de standardisation du NIST, Classic McEliece, de la cryptographie basée sur les codes, est une approche importante dont l’évaluation se poursuit toujours en tant que candidat final de la phase 4.

Proposé par Robert McEliece en 1978, cet algorithme est l’un des plus anciens de l’histoire de la cryptographie à clé publique, aux côtés du RSA. Il utilise des codes de géométrie algébrique appelés « codes de Goppa », qui ajoutent intentionnellement une erreur (vecteur de bruit) au message lors du chiffrement. Seule la personne possédant la matrice de contrôle de parité du code de Goppa comme clé secrète peut utiliser sa puissante capacité de correction d’erreurs pour supprimer l’erreur et déchiffrer le message d’origine, un principe basé sur le « problème du décodage de syndrome (Syndrome Decoding Problem) ».

$$ \vec{c} = \vec{m} G + \vec{e} $$

（$G$ est la matrice génératrice brouillée qui est la clé publique, et $\vec{e}$ est le vecteur d’erreur de poids $t$）

Ce qui est surprenant avec Classic McEliece, c’est son bilan impressionnant : bien que plus de 40 ans se soient écoulés depuis sa proposition et qu’il ait fait l’objet d’intenses recherches de déchiffrement par des cryptographes du monde entier, aucune vulnérabilité intrinsèque n’y a jamais été découverte. Il possède la « sécurité éprouvée par le temps » la plus solide de toute la PQC.

De plus, il a l’avantage d’avoir une taille de texte chiffré très petite (seulement 100 à 200 octets). Cependant, il présente un défaut majeur : la taille de la clé publique est en mégaoctets (Mo). Même pour le niveau de sécurité le plus bas (équivalent à AES-128), la clé publique est d’environ 250 Ko, et elle dépasse 1 Mo pour des niveaux plus élevés.

Pour cette raison, il est totalement inadapté aux applications qui envoient des clés publiques sur le réseau à chaque communication, telles que les poignées de main TLS. Cependant, pour des cas d’utilisation spécifiques où la clé publique peut être placée à l’avance dans le système, comme l’échange de clés pré-partagées pour les VPN, le codage en dur de clés publiques dans le firmware ou la communication par satellite, il continue d’être considéré comme une option très prometteuse en raison de sa forte sécurité.

10. Comparaison des performances et compromis de chaque algorithme PQC

Le tableau suivant résume les caractéristiques de performance des principaux algorithmes abordés jusqu’à présent à des niveaux de sécurité courants (équivalents aux niveaux 2 à 3 du NIST, soit le niveau AES-128 à 192).

Algorithme (Nom standard)	Catégorie	Base mathématique	Taille de la clé publique	Taille de la clé secrète	Taille du chiffré/signature	Tendance de la vitesse de traitement	Principales caractéristiques et utilisations
Kyber768 (ML-KEM)	KEM	Module-LWE	1 184 octets	2 400 octets	1 088 octets	Très rapide	Meilleur équilibre entre taille de clé et vitesse. Norme KEM générique comme TLS 1.3.
Dilithium3 (ML-DSA)	Signature	Module-LWE	1 952 octets	4 032 octets	3 309 octets	Génération et vérification rapides	Implémentation simple. Norme de signature numérique polyvalente.
FALCON-512 (FN-DSA)	Signature	Réseaux NTRU	897 octets	1 281 octets	666 octets	Génération plus lente, vérification ultra-rapide	Taille de signature minime. Nécessite des opérations en virgule flottante. Pour IoT/embarqué.
SPHINCS+ (SLH-DSA)	Signature	Fonction de hachage	32 octets	64 octets	Env. 17 000 octets	Génération très lente	Risque mathématique quasi nul. Pour applications de haute sécurité comme certificats racine.
Classic McEliece	KEM	Codes de Goppa	Env. 1.04 Mo	13 568 octets	188 octets	Encapsulation rapide	40 ans de sécurité éprouvée. Clé publique énorme. Pour environnements avec codage en dur.

Comprendre les compromis

Dans le monde de la PQC, il n’existe pas d’algorithme unique et magique qui soit « petit en taille, rapide, et avec des garanties mathématiques parfaites ».

Les normes d’Internet (Kyber / Dilithium) : Elles offrent le meilleur équilibre des performances et sont les mieux adaptées au remplacement direct (drop-in replacement) du RSA et de l’ECC actuels.
La conservativité ultime (SPHINCS+) : Elle est choisie lorsque l’on souhaite une assurance absolue contre les futures percées mathématiques, même au prix de la taille des données et de la vitesse de traitement.
Pour des environnements spécifiques (FALCON / Classic McEliece) : Ce sont des armes spécialisées choisies en fonction des contraintes de l’environnement, telles que des bandes passantes de communication extrêmement étroites ou la possibilité d’une distribution préalable.

11. Défis vers la mise en pratique et la solution réaliste de la « cryptographie hybride »

Avec l’achèvement de la standardisation par le NIST et la publication officielle des normes FIPS, la transition mondiale de l’infrastructure informatique vers la PQC (Migration PQC) a véritablement commencé. Le navigateur Chrome de Google, iMessage d’Apple (protocole PQ3) et les fournisseurs de réseaux comme Cloudflare ont déjà implémenté le support de la PQC dans leurs protocoles et ont commencé leur exploitation commerciale.

Cependant, basculer soudainement et complètement vers de nouveaux algorithmes de cryptographie comporte des risques très élevés. Si un brillant mathématicien venait à découvrir dans quelques années une faille mathématique fatale dans la cryptographie sur les réseaux (comme Kyber) qui pourrait être résolue même par un ordinateur classique, l’ensemble des systèmes qui en dépendent seraient instantanément exposés.

L’approche réaliste et recommandée pour atténuer ce risque d’incertitude est la « cryptographie hybride (Hybrid Cryptography) ».

Dans la cryptographie hybride, l’échange de clés est effectué en utilisant simultanément les cryptographies classiques actuelles ayant fait leurs preuves depuis longtemps (par exemple, la cryptographie sur courbe elliptique comme X25519) et les nouvelles PQC (par exemple, Kyber768). Les composants de la clé partagée sont générés individuellement par chaque algorithme, puis enfin, une fonction de dérivation de clé (KDF) sécurisée est utilisée pour mélanger les deux composants et générer le secret maître final.

graph TD A["Client"] -->|① Envoi de la clé publique X25519 + clé publique Kyber| B["Serveur"] B -->|② Réponse avec clé partagée X25519 + chiffré encapsulé Kyber| A A --> C{"Dérivation du secret maître (KDF)"} B --> C C -->|"Entrée : (Clé partagée X25519) || (Clé partagée Kyber)"| D["Clé de communication sécurisée (AES-256 / ChaCha20)"] D -->|"Résistance aux menaces quantiques ET aux vulnérabilités classiques"| E["Communication chiffrée hybride sécurisée (TLS 1.3)"]

Grâce à cela, il est possible d’atteindre une sécurité robuste à deux niveaux : « même si un ordinateur quantique est réalisé et que l’ECC est brisé, Kyber protège la communication », et inversement, « même si un défaut mathématique inconnu est trouvé dans Kyber, l’ECC protège la communication ». Un exemple typique est le brouillon X25519MLKEM768 (anciennement X25519Kyber768) en cours de standardisation à l’IETF, et la communication entre les navigateurs Web actuels et les serveurs de pointe est précisément réalisée à l’aide de cette méthode hybride.

De plus, le concept de Crypto Agility (Agilité cryptographique), qui consiste à concevoir des systèmes avec « une architecture qui ne dépend pas excessivement d’un algorithme cryptographique spécifique et qui permet de basculer rapidement vers un autre algorithme (par exemple, de Kyber à McEliece, de Dilithium à SPHINCS+) en cas de compromission de l’algorithme », deviendra une exigence indispensable dans le développement futur des systèmes.

12. Conclusion : Un nouvel horizon pour les technologies cryptographiques

Paradoxalement, l’ordinateur quantique, la technologie de rêve de l’humanité, est devenu la plus grande menace, capable de briser les barrières mathématiques telles que la « factorisation en nombres premiers » et le « problème du logarithme discret » sur lesquelles nous nous reposons depuis de nombreuses années. Cependant, les cryptographes du monde entier ne se sont pas avoués vaincus et ont exploré des domaines mathématiques multidimensionnels plus complexes et profonds, tels que la théorie des réseaux, les arbres de fonctions de hachage et les codes correcteurs d’erreurs, pour bâtir une nouvelle barrière : la cryptographie post-quantique (PQC).

L’achèvement de la standardisation des normes FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) et FIPS 205 (SLH-DSA) par le NIST n’est pas une ligne d’arrivée. Ce n’est que la première étape d’un voyage épique de migration vers la PQC qui durera plusieurs décennies. Pour les ingénieurs logiciels et les architectes système, le grand défi technique de l’avenir consistera à adapter au mieux l’« augmentation de la taille des clés » et les « changements de coûts de calcul » apportés par ces nouveaux algorithmes aux protocoles réseau et aux systèmes.

La bataille entre l’ordinateur quantique et la cryptographie est un domaine passionnant où la quête mathématique de l’humanité et l’évolution technologique se croisent de la manière la plus intense. À travers cet article, nous espérons que vous aurez acquis une compréhension approfondie de la belle théorie mathématique qui sous-tend la PQC, ainsi que des mécanismes surprenants de chaque algorithme qui façonnera l’avenir de la cybersécurité.

Références :

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

Le jour où les ordinateurs quantiques seront mis en pratique : situation en 2026

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

1. Introduction : Où en sont les ordinateurs quantiques en 2026 ?

En 2026, l’informatique quantique a connu un changement décisif, passant d’un ancien “rêve théorique” à une “réalité technique”. Alors que les limites des dispositifs NISQ (Noisy Intermediate-Scale Quantum), qui dominaient jusqu’à il y a quelques années, sont devenues claires, les instituts de recherche et les géants de la technologie du monde entier se sont orientés vers la réalisation de “l’informatique quantique tolérante aux pannes (FTQC : Fault-Tolerant Quantum Computing)”.

Dans cet article, nous explorerons en profondeur l’état actuel des ordinateurs quantiques, en intégrant les dernières avancées de 2026. En particulier, nous détaillerons la correction d’erreurs quantiques (code de surface), la différence entre les qubits physiques et les qubits logiques, les progrès de l’informatique quantique topologique, et l’avant-garde des méthodes à supraconducteurs et à pièges à ions.

2. Fondements de l’état quantique et fidélité (Fidelity)

L’unité fondamentale d’un ordinateur quantique, le bit quantique (Qubit), contrairement au bit classique (0 ou 1), peut prendre un état de superposition de 0 et de 1. L’état d’un seul qubit est représenté comme un vecteur dans l’espace de Hilbert comme suit :

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

Ici, $\alpha$ et $\beta$ sont des amplitudes de probabilité complexes, satisfaisant la condition de normalisation suivante :

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

Un indicateur extrêmement important pour mesurer les performances des calculs quantiques est la fidélité (Fidelity). La fidélité $F$ entre l’état quantique idéal $|\psi\rangle$ et la matrice densité réelle $\rho$, qui s’est dégradée pour devenir un état mixte à cause du bruit, est définie comme suit :

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

À l’heure actuelle en 2026, la fidélité des portes à 2 qubits (ex : portes CNOT et portes CZ) dépasse désormais de manière stable le mur des 99,99 % (ce que l’on appelle les “4 neufs”) dans les systèmes supraconducteurs. Il s’agit d’un chiffre qui dépasse largement le seuil de correction d’erreurs par le code de surface (environ 99 %), et constitue l’une des plus grandes avancées vers une application pratique.

3. Les limites de l’ère NISQ et le changement de paradigme vers FTQC

La période allant de la fin des années 2010 au début des années 2020 fut l’ère des NISQ (Noisy Intermediate-Scale Quantum), des dispositifs de quelques dizaines à quelques centaines de qubits dépourvus de correction d’erreurs. Cependant, les dispositifs NISQ avaient des limites claires.

À mesure que la profondeur (Depth) du circuit augmente, les erreurs s’accumulent de manière exponentielle, rendant impossible l’obtention de résultats de calcul significatifs. La probabilité de succès globale $P_{success}$ à une profondeur de circuit $D$ décroît par rapport à la fidélité d’une seule porte $f$ et au nombre de portes $N$ comme suit :

$$ P_{success} \approx f^N $$

Si $f = 0.99$ et que 1000 portes sont appliquées, le résultat sera $0.99^{1000} \approx 4.3 \times 10^{-5}$, et sera presque enfoui dans le bruit aléatoire. Pour cette raison, en 2026, au lieu d’une mise à l’échelle directe des algorithmes NISQ (comme VQE ou QAOA), les ressources se concentrent sur la génération de qubits logiques (Logical Qubit).

4. Correction d’erreurs quantiques et qubits logiques : À la pointe du code de surface

La correction d’erreurs quantiques (QEC : Quantum Error Correction) est une technologie qui encode plusieurs “qubits physiques” pour créer un “qubit logique”, permettant de détecter et de corriger les erreurs. Actuellement, le code le plus prometteur est le code de surface (Surface Code).

4.1 Structure du code de surface (Surface Code)

Dans le code de surface, les qubits sont disposés dans une grille bidimensionnelle. Les qubits de données (conservant les informations réelles) et les qubits de mesure (pour la mesure du syndrome) sont disposés comme sur un damier.

graph TD A["Qubit de données (D1)"] --- B["Qubit de mesure (M1)"] B --- C["Qubit de données (D2)"] C --- D["Qubit de mesure (M2)"] D --- E["Qubit de données (D3)"] B --- F["Qubit de données (D4)"] D --- G["Qubit de données (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

Il utilise les opérateurs de stabilisateur $S_x$ et $S_z$ pour surveiller constamment le retournement de bit (erreur X) et le retournement de phase (erreur Z).

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

L’avancée majeure de 2026 est le dépassement complet du “seuil de rentabilité (Break-even point)”. En d’autres termes, le bruit éliminé par la correction d’erreurs est devenu plus important que le bruit causé par les circuits supplémentaires pour l’effectuer, permettant ainsi à la durée de vie du qubit logique de dépasser de plusieurs ordres de grandeur celle du qubit physique.

4.2 Cycle de correction d’erreurs quantiques

La correction d’erreurs fonctionne comme une boucle de rétroaction continue.

sequenceDiagram participant D as "Qubits de données" participant M as "Qubits ancillaires/de mesure" participant C as "Contrôleur classique" loop "Cycle d'extraction de syndrome (approx 1 microsec)" D->>M: "Intriquer (CNOT/CZ)" M->>C: "Mesurer l'état (Syndrome)" C->>C: "Décoder le syndrome (ex: Minimum Weight Perfect Matching)" C-->>D: "Appliquer la correction de Pauli (si nécessaire)" end

Aujourd’hui, la technologie pour exécuter ce traitement de décodage classique (analyse de syndrome) en nanosecondes avec des FPGA ou des ASIC dédiés a été établie, et la correction d’erreurs en temps réel est entrée dans la phase de mise en œuvre pratique.

5. Évolution de l’architecture matérielle (Édition 2026)

Le matériel quantique en 2026 évolue principalement selon trois axes : la “méthode à supraconducteurs”, la “méthode à pièges à ions” et la “méthode topologique”.

5.1 Intégration des qubits supraconducteurs

La méthode supraconductrice est un domaine mené par IBM et Google, et le qubit transmon utilisant des jonctions Josephson y est dominant. En 2026, des mégapuces intégrant des milliers à dix mille qubits physiques sur une seule puce ont été réalisées.

Il convient de noter tout particulièrement l’établissement d’interconnexions quantiques inter-modules (Quantum Interconnects). La téléportation quantique entre puces utilisant des photons micro-ondes a été implémentée au niveau commercial, permettant de contourner les limites de taille d’un seul réfrigérateur à dilution.

5.2 Mise à l’échelle bidimensionnelle des pièges à ions et interconnexion optique

La méthode des pièges à ions (menée par Quantinuum, IonQ, etc.) utilise les états d’énergie interne des ions en suspension dans le vide comme qubits. Comparée à la méthode supraconductrice, elle présente l’avantage d’un temps de cohérence T1/T2 extrêmement long et permet une connectivité globale (All-to-All Connectivity).

La percée de 2026 fut la bidimensionnalisation de l’architecture QCCD (Quantum Charge Coupled Device) et la génération d’intrication à grande vitesse entre plusieurs pièges à l’aide d’interconnexions photoniques. Cela a considérablement amélioré la “lenteur de la vitesse de porte” et la “scalabilité”, qui étaient les points faibles des pièges à ions.

5.3 Informatique quantique topologique : Contrôle des anyons

L’informatique quantique topologique, longtemps considérée comme une existence théorique, est finalement entrée dans la phase de démonstration expérimentale en 2026. Cette méthode, promue par des entreprises telles que Microsoft, utilise des anyons non abéliens (Non-Abelian Anyons) appelés “modes zéro de Majorana (Majorana Zero Modes)”.

Les portes quantiques sont exécutées par une opération de tressage (Braiding) qui intervertit les positions des particules d’anyons.

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

Ici, $B_{ij}$ est l’opérateur de tressage. L’approche topologique est intrinsèquement résistante au bruit de l’environnement (tolérance aux pannes au niveau matériel) car la préservation de l’information ne dépend pas de l’état local de la particule, mais de la topologie globale du “nœud”. En 2026, la création du premier qubit logique topologique à haute fidélité au monde a été confirmée, attirant l’attention en tant que raccourci puissant vers le FTQC.

6. Feuille de route et perspectives vers une application pratique

Pour que l’ordinateur quantique démontre véritablement l’avantage quantique (Quantum Advantage) en surpassant les ordinateurs classiques (supercalculateurs) dans des domaines tels que la “chimie computationnelle”, la “science des matériaux” et la “modélisation financière”, des milliers de qubits logiques sont nécessaires.

gantt title "Feuille de route de l'informatique quantique (Révisée en 2026)" dateFormat YYYY axisFormat %Y section "Ère NISQ" "Qubits bruités (<1000)" :done, 2018, 2024 section "Début de la FTQC" "Démonstration du seuil de rentabilité" :done, 2024, 2026 "Centaines de qubits logiques" :active, 2026, 2028 section "FTQC à grande échelle" "1000+ qubits logiques (App commerciale)" : 2028, 2030 "Ordinateur quantique universel tolérant aux pannes" : 2030, 2035

6.1 Défis actuels et avenir

Le plus grand défi à l’heure actuelle en 2026 réside dans la capacité de refroidissement des immenses cryostats (réfrigérateurs à dilution) nécessaires au maintien de températures extrêmement basses, et dans le câblage (goulot d’étranglement des E/S) reliant l’équipement de contrôle à température ambiante et la puce quantique à température cryogénique. Face à cela, le développement de puces de contrôle CMOS fonctionnant en environnement cryogénique (Cryo-CMOS) progresse à un rythme effréné.

Conclusion

L’année 2026 sera enregistrée dans l’histoire des ordinateurs quantiques comme “l’année inaugurale de la mise à l’échelle des qubits logiques”. Grâce à la démonstration des algorithmes de correction d’erreurs, à la modularisation du matériel et aux progrès rapides de l’approche topologique, le “jour de la mise en pratique” n’est plus une histoire lointaine, mais un jalon concret à atteindre d’ici quelques années. Pour les développeurs d’algorithmes quantiques et les entreprises, c’est le moment idéal pour investir sérieusement dans la résolution de problèmes en mode “quantum-native”.

Cet article a été rédigé sur la base des dernières recherches et tendances de l’industrie de l’informatique quantique en 2026.