Vérifier Riemann en Lean : leçons pour les ingénieurs
Une preuve Lean de 17 millions de lignes de l'hypothèse de Riemann a résisté à plusieurs vérificateurs indépendants. Leçons pour les ingénieurs.

Le morceau de génie logiciel le plus audacieux livré récemment n'est ni un framework, ni une base de données, ni un agent IA. C'est une preuve. Levent Alpöge a publié une vérification Lean de l'hypothèse de Riemann sous la forme d'une bibliothèque d'environ dix-sept millions de lignes de code. En à peine un jour, une équipe distribuée de bénévoles l'avait compilée, avait fait correspondre son théorème final à l'énoncé canonique de Mathlib, et avait re-vérifié la preuve exportée avec plusieurs noyaux indépendants, dont deux disposent d'arguments vérifiés par machine affirmant qu'ils ne peuvent pas accepter une fausse preuve.
Voici mon affirmation à contre-courant, que je vais défendre puis en partie nuancer : c'est l'événement le plus important de cette décennie en matière de langages de programmation, et il a presque tout à voir avec la théorie des nombres. L'hypothèse de Riemann est presque accessoire. Ce qui compte, c'est que nous disposons désormais d'un exemple concret, à l'échelle de la recherche, d'un problème que les ingénieurs logiciels tournent autour sans jamais s'y attaquer vraiment : comment construire un artefact si gros qu'aucun humain ne peut le relire, mais si rigoureusement vérifié que des inconnus acceptent d'engager leur réputation professionnelle dessus ?
Ce que signifient réellement dix-sept millions de lignes de vérification Lean
Lean repose sur une idée que Nicolaas de Bruijn a formalisée à la fin des années 1960 avec Automath, l'un des premiers systèmes permettant d'encoder les mathématiques sous une forme vérifiable par machine. Cette idée porte aujourd'hui le nom de critère de de Bruijn : un assistant de preuve doit produire des objets de preuve qu'un petit programme de vérification indépendant peut contrôler seul. La partie grosse et astucieuse du système (l'élaborateur, le moteur de tactiques, l'automatisation qui transforme des scripts de preuve écrits pour des humains en objets formels) n'est explicitement pas de confiance. C'est un compilateur, et comme tout compilateur, il a le droit d'être bogué. La confiance réside dans le noyau, un petit programme qui vérifie entièrement les termes de preuve élaborés selon les règles de la logique.
C'est exactement cette architecture qui rend un artefact de dix-sept millions de lignes significatif. Personne n'a lu cette preuve. Personne ne le pouvait. Elle représente l'équivalent d'un composant majeur de système d'exploitation, et elle est en grande partie générée et façonnée par des machines. Mais le processus de vérification la traite comme un bon système de build traite un binaire compilé : des dizaines de personnes ont compilé la bibliothèque indépendamment et ont reproduit le même fichier d'export brut de la preuve, octet pour octet. C'est un build hermétique et déterministe produisant un artefact adressable par contenu, et la partie intéressante commence alors, car c'est l'artefact, et non le source, que consomment les vérificateurs.
Une preuve qu'on ne peut pas lire peut tout de même être une preuve à laquelle on peut se fier. Cette inversion de la revue de code classique est toute l'histoire.
Les développeurs devraient méditer un instant sur cette inversion. Notre mécanisme d'assurance standard consiste à ce qu'un humain ouvre un diff et fronce les sourcils. Cela passe à l'échelle de quelques milliers de lignes par relecteur et par semaine, avant que le froncement de sourcils ne devienne du théâtre. La réponse de la communauté Lean consiste à déplacer la confiance vers le bas de la pile : faire confiance à un petit noyau, faire confiance à la diversité des réimplémentations indépendantes de ce noyau, et traiter tout ce qui se trouve au-dessus, quelles que soient les millions de lignes, comme des données à vérifier plutôt que comme de la prose à relire. Ce n'est pas un tour de passe-passe mathématique. C'est une posture d'ingénierie.
Le problème de l'énoncé : prouver le bon théorème
La première chose que la communauté a vérifiée n'était pas la preuve, mais l'énoncé. C'est un point que les non-spécialistes sous-estiment systématiquement, et c'est là que les projets de formalisation meurent discrètement. Un assistant de preuve vous laissera volontiers prouver la mauvaise chose avec une rigueur totale : la logique se moque de ce que vous vouliez dire. L'exemple classique est une routine de tri vérifiée dont la spécification affirme que la sortie est ordonnée, mais oublie de préciser qu'il s'agit d'une permutation de l'entrée. La liste vide est parfaitement triée. La preuve passe. La fonction ne vaut rien.
Le certificat de ce travail repose donc sur un fait facile à survoler : l'énoncé RiemannHypothesis existait déjà dans Mathlib, où il avait été examiné par des personnes qui connaissent réellement à la fois la théorie analytique des nombres et les conventions d'encodage de Lean (là où les zéros peuvent se trouver, comment les zéros triviaux sont exclus, sur quoi la fonction est même définie). Ensuite, la communauté a ajouté un fichier isolant exactement cet énoncé, n'important rien d'autre que Mathlib, et a utilisé deux outils indépendants (comparator et con-leche --compare) pour confirmer que le théorème prouvé par la bibliothèque d'Alpöge est exactement cet énoncé. Pas une quasi-correspondance, pas un sosie définitionnel dont une hypothèse aurait été discrètement affaiblie. J'ai déjà défendu l'idée que l'écart entre spécification et implémentation est là où vivent les bugs, et les mathématiques formelles sont l'endroit où cette vérité cesse d'être un article de blog pour devenir un point de checklist, accompagné d'outils dédiés.
Remarquez à quel point cette discipline est inhabituelle selon les standards de l'industrie. Quand avez-vous vu pour la dernière fois une équipe construire un outil dédié dont le seul rôle est de prouver que ce que fait son système est bien ce que dit le contrat ? Nous écrivons des tests qui échantillonnent le contrat. Nous écrivons des signatures de types qui le suggèrent. La communauté Lean a construit des comparateurs qui l'identifient. Si vous ne retenez qu'une pratique de toute cette affaire, retenez celle-ci : avant de vous réjouir que la machine ait vérifié votre preuve, vérifiez que la machine vérifie bien votre affirmation.

Confiance dans le noyau et écosystème des vérificateurs
Le noyau officiel de Lean est petit, mais « petit » ne suffit pas à lui seul comme argument de sécurité : c'est une invitation à le réimplémenter. La vérification a largement répondu à cette invitation. La preuve exportée a été vérifiée non seulement par le noyau de Lean, mais aussi par con-leche et con-ron, ainsi que par plusieurs vérificateurs tiers écrits dans différents langages de programmation, tous consommant le même fichier d'export inerte. Ce mot inerte compte : les vérificateurs n'exécutent jamais le code des sources de preuve, donc un hypothétique fragment malveillant caché dans dix-sept millions de lignes n'a aucun environnement d'exécution où agir. C'est la différence entre relire un document et exécuter une pièce jointe.
Les deux poids lourds méritent une mention spéciale, car con-leche et con-ron sont chacun accompagnés d'une preuve formelle, relative à la théorie des ensembles, qu'ils ne peuvent pas accepter une fausse preuve. Cela referme la régression habituelle : oui, le noyau de Lean pourrait théoriquement avoir un bug de correction, donc on vérifie avec un autre noyau ; oui, celui-ci pourrait aussi en avoir un ; mais lorsque l'argument de correction du vérificateur est lui-même vérifié par machine contre un fondement différent, la surface d'attaque se réduit à « un bug qui survit simultanément à travers plusieurs implémentations, plusieurs langages et plusieurs systèmes fondationnels ». Pas impossible. Pas quelque chose sur quoi l'on construit ses plans. J'ai écrit sur le fait que même le borrow checker de Rust a livré une faille de correction, donc je ne dis pas « faites confiance au noyau » à la légère. La réponse n'a jamais été un composant unique et de confiance. C'est une population diversifiée de vérificateurs et un format de preuve partagé et portable : de la programmation N-versions, que l'avionique pratique depuis des décennies, appliquée enfin à la vérité elle-même.
import Mathlib
-- The statement, maintained and vetted in Mathlib, that the
-- new library proves. Anybody can inspect what the words mean.
#check RiemannHypothesis
-- A trivial kernel-checked proof. The kernel reduces 2 + 2 to 4
-- and accepts rfl; no tactic code runs at check time.
theorem two_add_two : 2 + 2 = 4 := rfl
-- Ask the kernel what this proof's trust base actually is:
#print axioms two_add_two
-- reports that the proof depends on no axioms at all
-- Had someone snuck in `sorry` (Lean's escape hatch) or a custom
-- axiom, this is where it shows up: as `sorryAx` or worse, in
-- the dependency list of the final theorem.
Ce dernier mécanisme est la piste d'audit que la plupart des systèmes n'ont pas. #print axioms demande au noyau, a posteriori, sur quelles hypothèses repose réellement une preuve. Toute triche dans Lean (sorry, un axiome déclaré par l'utilisateur, un unsafe mal employé) laisse une empreinte dans cette liste. Imaginez que votre build puisse répondre à « que supposiez-vous ? » avec la même précision : ce service suppose que l'horloge est monotone, celui-ci suppose TLS 1.3, celui-là suppose que la file livre au moins une fois. La plupart de nos systèmes portent exactement ces hypothèses. Presque aucun ne peut les énumérer à la demande.
Gestion des dépendances à l'échelle de Mathlib
Une ligne de l'énoncé de la communauté relève de la pure poésie de gestion des dépendances : la base de code ne dépend directement que de Mathlib. Ni forks vendorisés, ni branches privées de la bibliothèque standard, ni correctifs gardés hors de l'arbre principal. Dix-sept millions de lignes de mathématiques de recherche reposent sur une seule amont partagée et intégrée en continu. Cela ne fonctionne que parce que Mathlib fonctionne moins comme un dépôt de paquets que comme un organisme de normalisation doté d'une CI : une revue exigeante, un cache partagé pour que les contributeurs ne recompilent pas l'univers à chaque pull request, et une culture où remonter vos définitions en amont est la norme plutôt qu'une faveur faite à la communauté.
Et cet ordre, d'abord l'énoncé puis la preuve, est précisément ce que les équipes d'ingénierie font à l'envers. La définition de l'hypothèse de Riemann a été fusionnée, relue et durcie dans la bibliothèque partagée avant l'arrivée de la preuve. Lorsque la charge de dix-sept millions de lignes a atterri, il n'y avait aucune discussion sur ce qu'elle affirmait : l'affirmation faisait déjà partie de l'infrastructure. Comparez avec la façon dont la plupart des grandes bases de code absorbent une contribution massive : les interfaces sont définies par la contribution elle-même, la revue se fait sous pression du temps, et quand quelqu'un remarque que le contrat a dérivé, trois autres équipes dépendent déjà de la version dérivée. La discipline de Mathlib (canoniser le vocabulaire en public, puis laisser le travail s'appuyer dessus) est exactement ce que fait une équipe plateforme saine avec ses API internes. La différence, c'est qu'elle le fait vraiment.

Là où l'affirmation à contre-courant se heurte à ses limites
Passons maintenant à la nuance, car cette affirmation mérite un test de résistance honnête. Les vérificateurs indépendants ne sont pas aussi indépendants que la rhétorique le suggère. Ils partagent une métathéorie, plusieurs partagent une lignée de conception, et les auteurs de vérificateurs se parlent entre eux : la diversité des langages de programmation n'est pas une diversité de logique. Il existe aussi des précédents de dérapage : une fausse réfutation de la conjecture de Collatz est passée une fois à travers l'un de ces vérificateurs indépendants avant que quiconque ne la repère. La formulation honnête de l'argument de confiance est celle d'un observateur attentif : pour que la preuve soit fausse, un seul bug devrait affecter à la fois les preuves de cohérence internes des vérificateurs et cette preuve précise, à travers toutes les implémentations. Quasi nul. Mais « quasi nul » est une probabilité, et l'énoncé de la communauté parle de « confiance totale », ce qui relève de la sociologie.
Il y a aussi un mur porteur humain que les quatre critères publiés ne mentionnent pas. Selon tous les témoignages, cette preuve a été produite avec une aide massive de l'IA, Alpöge tenant la barre : en décomposant le problème, en reconnaissant les impasses, en sachant quels lemmes sentaient mauvais. Cette expertise humaine fait un travail épistémique réel, et le certificat tel qu'il est rédigé ne s'appuie pas du tout dessus, ce qui me dérange. J'ai déjà couvert la séparation entre la génération de conjectures par les LLM et la vérification mécanique des preuves, et ceci en est la version à enjeux maximaux : la machine a proposé à une échelle sans précédent, la machine a vérifié à une échelle sans précédent, et un rare humain se tenait à la jonction, rendant l'ensemble lisible. Retirer cet humain du récit officiel rend l'histoire plus propre, mais moins vraie.
Leçons d'ingénierie pour les logiciels vérifiés par machine
- Gardez la base de confiance (TCB) minuscule et ennuyeuse. Chaque ligne que vous devez croire est un passif ; chaque ligne que vous vous contentez de vérifier n'est que de la donnée.
- Exportez dans un format inerte et portable. La vérification doit porter sur un document, pas sur un processus vivant capable d'exécuter des surprises.
- Vérifiez l'affirmation, pas seulement l'argument. Construisez le comparateur. Prouvez que votre artefact correspond au contrat avant de célébrer la preuve.
- Diversifiez réellement vos vérificateurs. Les langages différents aident ; les fondements différents aident davantage ; un seul vérificateur avec une preuve de cohérence vaut mieux que deux qui copient leurs devoirs l'un de l'autre.
- Rendez vos builds reproductibles et vos artefacts adressables par contenu. « Des dizaines de personnes ont reproduit le même fichier d'export » est une phrase à laquelle tout pipeline de release devrait aspirer.
- Canonisez le vocabulaire partagé en amont avant l'arrivée de la grosse contribution. D'abord les définitions, ensuite les exploits.
- Énumérez vos hypothèses mécaniquement. Si votre système ne peut pas répondre à « de quoi dépendez-vous ? », vous ne savez pas ce que vous avez livré.
Au fond de cette liste se trouve une idée : les tests échantillonnent un espace, les preuves l'épuisent, et le juste milieu intéressant (test basé sur les propriétés, model checking, exécution symbolique) est l'industrie qui avance lentement, à contrecœur, du premier camp vers le second. Personne ne vous demande de formaliser votre application CRUD. Mais la frontière de ce qui « doit être vérifié par machine » ne cesse de reculer : primitives cryptographiques, protocoles de consensus, smart contracts, logiciels embarqués de vol, vérificateurs eBPF du noyau Linux. Chacune de ces communautés a connu son moment « on devrait vraiment faire ça à la façon Lean », généralement juste après un incident coûteux. La vérification de Riemann démontre que l'outillage, la culture et l'écosystème des vérificateurs peuvent porter le poids de quelque chose de véritablement énorme. Le placard des excuses est vide.
Cent ans d'essais
En tant que spécialiste des langages, je ne peux m'empêcher de voir dans ceci le retour sur investissement d'un très vieux pari. Hilbert a inscrit l'hypothèse de Riemann sur sa liste en 1900. De Bruijn a lancé Automath en 1967. Robin Milner a conçu ML dans les années 1970 spécifiquement comme métalangage pour écrire des tactiques de preuve : toute la famille ML, qui mène à OCaml et Haskell et jusqu'au système de types de Rust, descend d'outils pour la preuve vérifiée par machine. Le manifeste QED des années 1990 demandait pourquoi l'ensemble des mathématiques n'était pas encore formalisé, et n'a surtout récolté des haussements d'épaules. Puis le théorème des quatre couleurs a été formalisé dans Coq, puis le théorème de Feit–Thompson, puis l'Expérience du tenseur liquide a prouvé que les mathématiques de recherche modernes, pas seulement les classiques, pouvaient survivre au contact d'un noyau. Chacun de ces projets a été qualifié de coup de com' par quelqu'un. Chacun a formé la communauté et durci la bibliothèque sur laquelle s'appuyait le suivant.
Alors, mon affirmation d'ouverture est-elle juste ? En partie. Les mathématiciens ont obtenu un théorème, et dès le lendemain matin ils posaient déjà la meilleure question : que nous enseigne la preuve ? C'est ce qu'aucune ligne de code vérifiée, même dix-sept millions, n'enseigne automatiquement. Les ingénieurs ont obtenu quelque chose de plus rare : un plan, validé sous un examen maximal, pour construire des artefacts trop gros pour être lus par n'importe quel humain, et engager malgré tout le nom d'une communauté dessus. La prochaine fois qu'on vous dira en revue de conception que la vraie vérification ne passe pas à l'échelle, vous saurez exactement quel journal de build lui montrer.


