Découverte de l’informatique quantique — partie 2

Par Bertrand CLAVELIER, le

Le programme lancé sur ibm_marrakesh : la clé de 32 octets, puis 126 zéros et 130 uns. Accéléré ×4.

La première partie posait les bases : le qubit et sa mesure, la sphère de Bloch, les portes et les circuits. Celle-ci passe à la pratique, sur deux questions restées ouvertes : peut-on déjà utiliser un ordinateur quantique, et y lancer ses propres programmes ?

Pour expérimenter, un problème concret sert de support : tirer une clé aléatoire de 32 octets. Je le traite avec trois outils d’IBM : le Composer, pour dessiner le circuit en ligne ; Qiskit, pour l’écrire en Python ; puis un vrai processeur quantique, accessible gratuitement en petite quantité. Seul ce dernier donne un hasard réellement quantique.

Le problème du hasard

Avant de passer à l’expérimentation, quelques détails sur ce problème, pour comprendre l’intérêt d’un processeur quantique.

Un ordinateur classique calcule le hasard : ce n’est qu’un pseudo-hasard, issu d’un algorithme déterministe qui, à partir du même point de départ, redonne toujours la même suite.

Or générer un secret, comme une clé privée, peut nécessiter un « vrai » hasard, c’est-à-dire non déterministe. Le classique a ses solutions pour casser ce déterminisme : sous Unix, le système d’exploitation utilise comme source d’aléa « certaines données de l’environnement recueillies auprès de pilotes de périphériques et d’autres sources ». Le quantique, lui, tire ce hasard directement de la mesure.

Le problème retenu pour expérimenter : créer une clé de 32 octets, soit 256 bits, la taille d’une clé AES-256, de manière quantique.

Un octet, c’est 8 bits : il faut donc 8 qubits. Le circuit est très simple : 8 fils, une porte H sur chacun, puis la mesure.

Huit fils partant de |0⟩, chacun traversé par une porte H puis par une mesure. Huit qubits indépendants : chaque lecture donne un octet.

La porte H crée la superposition à 50/50 : elle change $|0\rangle$ en $|+\rangle$, et chaque qubit a autant de chances d’être lu 0 que 1. La lecture casse la superposition et rend une valeur tirée au hasard quantique.

Aucune porte ne relie les fils : les 8 qubits restent indépendants. L’octet lu est donc l’un des $2^8 = 256$ possibles, de 00000000 à 11111111, chacun avec la même chance, $\left(\frac{1}{2}\right)^8 = \frac{1}{256}$.

On lance le circuit 32 fois : chaque lancement repart de $|0\rangle$ sur chaque fil, et sa lecture donne un octet de la clé.

Dans le Composer d’IBM

Premier outil, le Composer d’IBM, déjà croisé à la fin de la première partie. C’est un outil en ligne pour dessiner des circuits, en glissant les portes sur les fils à la souris, et pour voir les probabilités de lecture de chaque résultat.

Sans compte, ses visualisations s’arrêtent à 4 qubits. Sa documentation en annonce jusqu’à 8 une fois connecté, pour la vue des probabilités ; à 8 qubits, je n’ai pourtant obtenu aucune visualisation, même connecté. On monte donc le circuit sur 4 fils : un demi-octet par lancement.

Le circuit se monte en deux gestes :

  1. passer le circuit à 4 qubits ;
  2. poser une porte H sur chaque fil.

Sous le circuit, le Composer affiche la probabilité de chaque résultat. Avec 4 qubits, il y en a $2^4 = 16$, de 0000 à 1111 : tous les demi-octets possibles. Chacun a la même chance de sortir, 1 sur 16, soit 6,25 %. C’est ce qu’on attend d’une clé : aucun résultat n’est favorisé.

Le Composer d’IBM : quatre fils, q[0] à q[3], chacun avec une porte H, et le code OpenQASM à droite. En bas, l’histogramme des probabilités, seize barres égales de 0000 à 1111. Quatre portes H : les seize demi-octets, à 6,25 % chacun.

Mais ce n’est qu’une prévision. Ces probabilités sont calculées par un simulateur, sur un ordinateur classique : rien n’est mesuré, rien n’est tiré. La documentation le précise : les visualisations viennent d’un simulateur distinct du processeur quantique, et ignorent les mesures ajoutées au circuit.

Pour obtenir de vrais tirages, il faut ajouter une mesure au bout de chaque fil, puis lancer le circuit sur l’un des processeurs quantiques d’IBM, en réglant le nombre d’exécutions, les « shots ». Chaque shot repart de $|0\rangle$ et rend un demi-octet : il en faut 64 pour 32 octets.

Ce que je retiens : le Composer calcule les chances de chaque résultat, il n’en tire aucun. Pour obtenir la clé, il faut mesurer sur un vrai processeur.

En code, avec Qiskit

Qiskit est le kit de développement open source d’IBM pour l’informatique quantique, en Python. Il s’installe en une commande :

pip install qiskit

Le circuit tient en trois lignes : 8 fils, une porte H sur chacun, une mesure sur tous. En code, plus de limite à 4 qubits : l’octet entier passe.

Pour l’exécuter sans processeur quantique, Qiskit fournit un simulateur, le StatevectorSampler. Par défaut, il fait 1 024 shots ; on lui en demande 32 : il rend 32 suites de 8 bits, les 32 octets de la clé.

Le programme affiché dans un terminal, puis lancé deux fois. Chaque lancement affiche une clé différente de 64 caractères hexadécimaux. Le programme, puis deux lancements : deux clés différentes.

Les deux dernières lignes du programme changent chaque suite de 8 bits en un octet, et affichent la clé en hexadécimal : 64 caractères.

Mais d’où viennent ces bits ? Le simulateur calcule l’état du circuit : 256 résultats possibles, chacun à 1 sur 256. Puis il tire les 32 résultats avec le générateur de NumPy, la bibliothèque de calcul de Python. Dans le code source de Qiskit, ce tirage tient en une ligne : un choix au hasard parmi les résultats possibles, pondéré par leurs probabilités.

return self._rng.choice(labels, p=probs, size=shots)

Ce générateur est un algorithme, PCG64. C’est donc du pseudo-hasard. Son point de départ, la « graine », est fourni par le système d’exploitation à chaque lancement : c’est pourquoi deux lancements donnent deux clés différentes. À l’inverse, le StatevectorSampler accepte une graine fixée : avec elle, il redonnerait toujours la même clé.

Ce que je retiens : en code, le circuit s’écrit en trois lignes. Mais simulé, il ne fait que calculer les chances ; le tirage reste celui d’un ordinateur classique.

Sur un vrai processeur

IBM ouvre ses processeurs à tous : son offre gratuite, l’Open Plan, donne jusqu’à 10 minutes de calcul par période glissante de 28 jours. Il faut un compte IBM, son jeton d’accès (une clé d’API, générée sur le tableau de bord) et une bibliothèque de plus :

pip install qiskit-ibm-runtime

Le code reste celui du simulateur, avec quatre changements :

  1. se connecter au compte IBM ;
  2. choisir un processeur, ici le moins chargé du moment ;
  3. traduire le circuit pour ce processeur ;
  4. l’exécuter sur ce processeur au lieu du simulateur.

Ce qui change, dans le même ordre :

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2

# 1. Se connecter au compte IBM (le jeton est lu dans son fichier, jamais écrit ici)
service = QiskitRuntimeService(token=jeton)

# 2. Choisir un processeur : le moins chargé du moment
processeur = service.least_busy(operational=True, simulator=False)

# 3. Traduire le circuit dans les portes que ce processeur sait faire
qc_traduit = generate_preset_pass_manager(backend=processeur, optimization_level=1).run(qc)

# 32 shots sur le processeur : 32 octets (attente dans la file comprise)
resultat = SamplerV2(mode=processeur).run([qc_traduit], shots=32).result()[0]

La traduction est nouvelle : un processeur ne sait faire que quelques portes, et H n’en fait pas partie. Qiskit la réécrit avec des rotations qu’il sait faire, sans changer le résultat.

Le circuit part ensuite dans une file d’attente, partagée avec les autres utilisateurs. Le mien est parti sur ibm_marrakesh, et le résultat est revenu en une dizaine de secondes.

La page d’IBM Quantum Platform pour l’exécution du 7 octobre 2026 sur ibm_marrakesh : opération terminée, 7 s au total, dont 2 s d’utilisation. En bas, l’histogramme des 32 mesures, chaque octet sorti une fois, sauf un sorti deux fois. La page de l’exécution sur IBM Quantum Platform : ibm_marrakesh et ses 32 octets mesurés.

À l’exécution, qiskit-ibm-runtime a averti que SamplerV2 est obsolète depuis sa version 0.50. Sa documentation utilise désormais Sampler, importé de qiskit_ibm_runtime.executor_sampler.

Cette fois, aucune chance n’est calculée et aucun générateur n’intervient : chaque bit sort de la mesure d’un qubit. C’est le seul de nos trois essais où le hasard est quantique.

On compte les 0 et les 1 de la clé : 126 zéros et 130 uns sur 256 bits. Même un hasard parfait tombe rarement pile sur 128 et 128, environ une fois sur vingt : un petit écart ne prouve rien à lui seul.

Un vrai processeur a aussi ses imperfections, qu’IBM publie pour chaque qubit : la probabilité de lire 0 alors qu’il était préparé à 1, et l’inverse, ou encore le temps T1, la durée moyenne au bout de laquelle un qubit à $|1\rangle$ retombe à $|0\rangle$. Le hasard est quantique, mais la lecture n’est pas parfaite.

Enfin, cette clé n’est pas secrète : le circuit et ses résultats passent par les serveurs d’IBM, où ils restent consultables. Chaque exécution reçoit un identifiant, qui permet d’en récupérer les résultats plus tard. C’est une démonstration, pas une clé à utiliser.

Ce que je retiens : quatre changements suffisent pour passer du simulateur au processeur. Le hasard y est enfin quantique, mais il passe par les serveurs d’IBM.

Le chemin parcouru

Au début de cette découverte, je posais des questions. Voici ce que j’y réponds aujourd’hui.

Qu’est-ce que l’informatique quantique, réellement ? Un calcul sur des qubits. Un qubit combine 0 et 1 : son état est un vecteur, et la mesure tranche au hasard, avec des chances fixées par ses amplitudes. La sphère de Bloch le rend visible : chaque point est un état, et la lecture le ramène à un pôle.

Comment manipuler un objet quantique en informatique ? Avec des portes, qui font tourner le qubit sur la sphère. H crée la superposition ; sur un circuit, CNOT relie deux fils et peut créer l’intrication.

Qu’existe-t-il aujourd’hui ? Pas d’ordinateur quantique à proprement parler. Le CEA le dit nettement : « on ne dispose pas encore d’une véritable technologie d’ordinateur quantique, qui permettrait d’exploiter toute la puissance du calcul quantique ». Il existe des processeurs quantiques, mais ce sont des outils de laboratoire. On peut toutefois accéder à certains pour y mener ses propres expériences : IBM ouvre les siens gratuitement, en petite quantité. C’est ce qui me marque le plus.

Pouvons-nous écrire des programmes ? Oui. En Python, avec Qiskit, le circuit de la clé tient en trois lignes, et quatre changements suffisent pour l’envoyer du simulateur à un vrai processeur. Seul ce dernier essai donne un hasard réellement quantique.

Et pour quoi faire ? Les usages visés sont identifiés. La première partie en a croisé deux : l’algorithme de Shor, qui factorise les entiers et pourrait casser le chiffrement à clé publique, et celui de Grover, pour chercher dans des données non structurées. Le CEA en cite d’autres : en chimie, « simuler, in silico, de manière exacte, la structure et le fonctionnement de grosses molécules d’intérêt pour la pharmacologie ou pour l’agronomie » ; en optimisation, trouver « la tournée la plus rapide d’un camion de livraison » ou « ajuster l’offre à la demande sur un réseau électrique très décentralisé ». Le risque pour le chiffrement est déjà pris en compte : en 2024, le NIST a publié les premières normes de cryptographie post-quantique.

On n’en est qu’au début. La théorie est largement éprouvée ; la technologie, elle, en est sans doute là où en était l’informatique classique à ses débuts. Mais les usages vont voir le jour dans les années qui viennent.

Avoir quelques bases, et savoir créer un circuit avec des portes, me semble primordial pour l’avenir.

Un dernier problème

Un dernier problème à résoudre avec des portes.

On part de 8 qubits intriqués : la mesure ne peut donner que 00000000 ou 11111111, à 50/50. C’est l’état du troisième circuit de la première partie, étendu de deux qubits à huit.

On change le premier qubit avec X. Attention au sens de lecture : dans les résultats de Qiskit, les qubits se lisent de droite à gauche, le premier est le chiffre de droite. C’est l’inverse de la notation de la première partie, et la documentation de Qiskit reconnaît que cela prête parfois à confusion. La mesure donne alors 00000001 ou 11111110, toujours à 50/50.

Lire l’état du premier qubit permet de connaître les 7 autres. On lit le premier :

  • s’il vaut 0, l’octet est 11111110 : les 7 autres valent 1 ;
  • s’il vaut 1, l’octet est 00000001 : les 7 autres valent 0.

Le défi : construire ce circuit avec les portes déjà vues, H, CNOT, X et la mesure. Pour qui veut chercher, il se teste avec Qiskit, sur le simulateur puis sur un vrai processeur.

Le défi est posé : quelles portes placer, et sur quels fils, pour que la mesure ne rende que 00000001 ou 11111110 ?

Sources

Sommaire