Qiskit 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 !

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/