Riemann in Lean verifizieren: Lehren für Entwickler
Ein 17-Millionen-Zeilen-Lean-Beweis der Riemannschen Vermutung hielt unabhängigen Checkern stand. Was Beweisassistenten Entwickler lehren.

Die kühnste Softwareentwicklungsleistung der letzten Zeit ist weder ein Framework, eine Datenbank noch ein KI-Agent. Es ist ein Beweis. Levent Alpöge hat eine Lean-Verifikation der Riemannschen Vermutung als Bibliothek mit rund siebzehn Millionen Codezeilen veröffentlicht. Innerhalb von etwa einem Tag hatte ein verteilter Trupp Freiwilliger alles kompiliert, das Endtheorem mit der kanonischen Formulierung in Mathlib abgeglichen und den exportierten Beweis mit mehreren unabhängigen Kernels nachgeprüft, zwei davon mit maschinell geprüften Argumenten, dass sie keinen falschen Beweis akzeptieren können.
Hier kommt meine unbequeme These, die ich verteidige und dann teilweise zurücknehme: Das ist das wichtigste Ereignis in Programmiersprachen dieses Jahrzehnts, und es hat fast nichts mit Zahlentheorie zu tun. Die Riemannsche Vermutung ist praktisch Nebensache. Entscheidend ist, dass wir jetzt ein Beispiel in echter Forschungsgröße haben für ein Problem, das Softwareingenieure immer wieder umkreisen, ohne sich festzulegen: Wie baut man ein Artefakt, das so groß ist, dass kein Mensch es prüfen kann, und das trotzdem so streng geprüft ist, dass Fremde ihren beruflichen Ruf darauf verwetten?
Was siebzehn Millionen Zeilen Lean-Verifikation tatsächlich bedeuten
Lean baut auf einer Idee auf, die Nicolaas de Bruijn Ende der 1960er-Jahre mit Automath ausgearbeitet hat, einem der ersten Systeme, um Mathematik in maschinenprüfbarer Form zu kodieren. Die Idee heißt heute de-Bruijn-Kriterium: Ein Beweisassistent sollte Beweisobjekte erzeugen, die ein kleines, unabhängiges Prüfprogramm für sich allein verifizieren kann. Der große, clevere Teil des Systems, also der Elaborator, die Taktik-Engine und die Automatisierung, die menschenfreundliche Beweisskripte in formale Objekte übersetzt, wird ausdrücklich nicht vertraut. Er ist ein Compiler, und wie jeder Compiler darf er Fehler haben. Vertrauen liegt im Kernel, einem kleinen Programm, das vollständig ausgearbeitete Beweisterme gegen die Regeln der Logik typprüft.
Genau diese Architektur macht einen Artefakt mit siebzehn Millionen Zeilen überhaupt sinnvoll. Niemand hat diesen Beweis gelesen. Niemand könnte es. Er entspricht etwa der Größenordnung einer großen Betriebssystemkomponente und ist größtenteils maschinell erzeugt und maschinell strukturiert. Aber der Verifikationsprozess behandelt ihn wie ein guter Build-Prozess ein kompiliertes Binary: Dutzende Leute haben die Bibliothek unabhängig kompiliert und exakt dieselbe rohe Beweis-Exportdatei reproduziert, Byte für Byte. Das ist ein hermetischer, deterministischer Build, der ein inhaltsadressierbares Artefakt erzeugt. Der spannende Teil beginnt erst dann, denn das Artefakt, nicht der Quelltext, ist das, was die Prüfer konsumieren.
Einen Beweis, den man nicht lesen kann, kann man trotzdem vertrauen. Diese Umkehrung der üblichen Code-Review ist die ganze Geschichte.
Softwareleute sollten sich diese Umkehrung einen Moment lang durch den Kopf gehen lassen. Unser übliches Qualitätssicherungsverfahren ist ein Mensch, der einen Diff öffnet und die Stirn runzelt. Das skaliert auf vielleicht einige tausend Zeilen pro Reviewer und Woche, bevor das Stirnrunzeln zum Theater wird. Die Lean-Community antwortet, indem sie das Vertrauen nach unten im Stack verlagert: einem kleinen Kernel vertrauen, der Vielfalt unabhängiger Neuimplementierungen dieses Kernels vertrauen und alles darüber, egal wie viele Millionen Zeilen, als zu prüfende Daten statt als zu lesende Prosa behandeln. Das ist kein mathematischer Trick. Es ist eine ingenieurtechnische Haltung.
Das Aussageproblem: den richtigen Satz beweisen
Das Erste, was die Community prüfte, war nicht der Beweis, sondern die Aussage. Das unterschätzen Außenstehende regelmäßig, und genau dort sterben Formalisierungsprojekte still und leise. Ein Beweisassistent lässt dich bereitwillig das Falsche mit vollkommener Strenge beweisen, denn die Logik kümmert sich nicht darum, was du meinst. Das klassische Spielzeugbeispiel ist eine verifizierte Sortierroutine, deren Spezifikation besagt, die Ausgabe sei geordnet, aber vergisst zu sagen, dass sie eine Permutation der Eingabe ist. Die leere Liste ist wunderbar sortiert. Der Beweis geht durch. Die Funktion ist Müll.
Das Zertifikat dieser Arbeit beruht also auf einer Tatsache, über die man leicht hinwegliest: Die Aussage RiemannHypothesis existierte bereits in Mathlib, wo sie von Leuten geprüft worden war, die sowohl analytische Zahlentheorie als auch Lean-Kodierungskonventionen wirklich kennen, also wo die Nullstellen liegen dürfen, wie die trivialen Nullstellen ausgeschlossen werden und worauf die Funktion überhaupt definiert ist. Dann hat die Community eine Datei ergänzt, die genau diese Aussage isoliert, nur Mathlib importiert und zwei unabhängige Werkzeuge (comparator und con-leche --compare) eingesetzt, um zu bestätigen, dass der Satz, den Alpöges Bibliothek beweist, genau diese Aussage ist. Kein knapper Fehlgriff, kein definitorisches Double mit einer stillschweigend weggelassenen Voraussetzung. Ich habe schon argumentiert, dass die Lücke zwischen Spezifikation und Implementierung der Ort ist, an dem Bugs leben, und in der formalen Mathematik hört diese Wahrheit auf, ein Blogpost zu sein, und wird zu einem Checklistenpunkt mit eigenen Werkzeugen.
Beachte, wie ungewöhnlich diese Disziplin nach Industriemaßstäben ist. Wann hast du zuletzt ein Team gesehen, das ein eigenes Werkzeug gebaut hat, dessen einziger Zweck es ist zu beweisen, dass das, was das System tut, das ist, was der Vertrag sagt? Wir schreiben Tests, die den Vertrag stichprobenartig abdecken. Wir schreiben Typsignaturen, die in seine Richtung deuten. Die Lean-Community hat Comparatoren gebaut, die ihn tatsächlich identifizieren. Wenn du aus dieser ganzen Geschichte nur eine Praxis mitnimmst, dann diese: Bevor du feierst, dass die Maschine deinen Beweis geprüft hat, prüfe, dass die Maschine auch deine Behauptung prüft.

Kernel-Vertrauen und das Ökosystem der Prüfer
Lean's offizieller Kernel ist klein, aber „klein“ ist allein kein Sicherheitsargument. Es ist eine Einladung zur Neuimplementierung, und die Verifikation hat diese Einladung kräftig angenommen. Der exportierte Beweis wurde nicht nur vom Lean-Kernel geprüft, sondern auch von con-leche und con-ron sowie mehreren Drittanbieter-Prüfern in verschiedenen Programmiersprachen, die alle dieselbe inerte Exportdatei verarbeiteten. Das Wort inert ist wichtig: Die Prüfer führen nie Code aus den Beweisquellen aus, daher hat ein hypothetisches bösartiges Snippet, das irgendwo in siebzehn Millionen Zeilen versteckt ist, keine Laufzeitumgebung, in der es wirken könnte. Das ist der Unterschied zwischen dem Prüfen eines Dokuments und dem Ausführen eines Anhangs.
Die beiden Schwergewichte verdienen besondere Erwähnung, denn con-leche und con-ron bringen jeweils einen formalen Beweis, relativ zur Mengenlehre, dass sie keinen falschen Beweis akzeptieren können. Das schließt die übliche Regression: Ja, der Lean-Kernel könnte theoretisch einen Korrektheitsfehler haben, also prüft man mit einem anderen Kernel; ja, der könnte auch einen haben. Wenn aber die Korrektheitsargumentation des Prüfers selbst maschinell gegen eine andere Grundlage geprüft ist, schrumpft die Angriffsfläche auf „ein Fehler, der über mehrere Implementierungen, mehrere Sprachen und mehrere Grundlagensysteme hinweg gleichzeitig überlebt“. Nicht unmöglich. Nichts, womit man planen sollte. Ich habe darüber geschrieben, dass selbst Rusts Borrow Checker ein Soundness-Loch hatte, deshalb sage ich „vertraue dem Kernel“ nicht leichtfertig. Die Antwort war nie eine einzige vertrauenswürdige Komponente. Es ist eine vielfältige Population von Prüfern und ein gemeinsames, portables Beweisformat: N-Version-Programmierung, die die Luftfahrt seit Jahrzehnten praktiziert, endlich auf die Wahrheit selbst angewendet.
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.
Dieser letzte Mechanismus ist die Prüfspur, die den meisten Systemen fehlt. #print axioms fragt den Kernel nachträglich, auf welchen Annahmen ein Beweis tatsächlich beruht. Jeder Trick in Lean, etwa sorry, ein selbst deklariertes Axiom oder ein missbrauchtes unsafe, hinterlässt einen Fingerabdruck in dieser Liste. Stell dir vor, dein Build könnte auf die Frage „Was hast du angenommen?“ mit derselben Präzision antworten: Dieser Service setzt voraus, dass die Uhr monoton läuft, dieser, dass TLS 1.3 genutzt wird, dieser, dass die Queue mindestens einmal zustellt. Die meisten unserer Systeme tragen genau solche Annahmen mit sich. Kaum eines kann sie auf Anfrage aufzählen.
Abhängigkeitsmanagement im Mathlib-Maßstab
Eine Zeile in der Aussage der Community ist reine Abhängigkeitsmanagement-Poesie: der Code hängt direkt nur von Mathlib ab. Keine vendorisierten Forks, keine privaten Branches der Standardbibliothek, keine außerhalb des Baums gehaltenen Patches. Siebzehn Millionen Zeilen Forschungsmathematik ruhen auf einer einzigen, gemeinsamen, kontinuierlich integrierten Upstream-Quelle. Das funktioniert nur, weil Mathlib weniger wie ein Paket-Repository und eher wie ein Normungsgremium mit CI arbeitet: strenge Reviews, ein gemeinsamer Cache, damit Mitwirkende nicht bei jedem Pull das ganze Universum neu bauen, und eine Kultur, in der das Upstreamen der eigenen Definitionen der Normalfall ist und kein Gefallen an der Community.
Und genau diese Reihenfolge, erst die Aussage und dann der Beweis, ist der Teil, den Engineering-Teams verkehrt herum machen. Die Definition der Riemannschen Vermutung wurde in der gemeinsamen Bibliothek zusammengeführt, geprüft und gehärtet, bevor der Beweis eintraf. Als die siebzehn Millionen Zeilen landeten, gab es keine Diskussion darüber, was sie behaupteten; die Behauptung war bereits Infrastruktur. Vergleiche das mit der Art, wie die meisten großen Codebasen einen massiven Beitrag aufnehmen: Die Schnittstellen werden durch den Beitrag selbst definiert, das Review findet unter Zeitdruck statt, und bis jemand merkt, dass der Vertrag abgedriftet ist, hängen drei andere Teams von der abgedrifteten Version ab. Mathlibs Disziplin, das Vokabular öffentlich zu kanonisieren und dann darauf aufbauen zu lassen, ist genau das, was ein gesundes Plattformteam mit seinen internen APIs tut. Der Unterschied ist, dass sie es tatsächlich tun.

Wo die These zusammenbricht
Jetzt die Kehrtwende, denn die These verdient einen ehrlichen Belastungstest. Die unabhängigen Prüfer sind nicht so unabhängig, wie die Rhetorik suggeriert. Sie teilen eine Metatheorie, mehrere haben eine gemeinsame Designherkunft, und die Autoren der Prüfer sprechen miteinander; Vielfalt der Programmiersprache ist nicht Vielfalt der Logik. Es gibt auch Präzedenzfälle für Ausrutscher: Eine gefälschte Widerlegung der Collatz-Vermutung ist einmal an einem dieser unabhängigen Prüfer vorbeigekommen, bevor jemand sie bemerkt hat. Die ehrliche Formulierung des Vertrauensarguments ist die, die ein sorgfältiger Beobachter angeboten hat: Damit der Beweis falsch wäre, müsste ein einzelner Fehler sowohl die internen Konsistenzbeweise der Prüfer als auch diesen speziellen Beweis betreffen, über jede Implementierung hinweg. Verschwindend gering. Aber „verschwindend gering“ ist eine Wahrscheinlichkeit, und die Aussage der Community lautet „volles Vertrauen“, was eher Soziologie als Mathematik ist.
Außerdem gibt es eine menschliche tragende Wand, die die vier veröffentlichten Kriterien nicht erwähnen. Nach allem, was man hört, wurde dieser Beweis mit massiver KI-Unterstützung erstellt, wobei Alpöge das Steuer hielt: Er zerlegte das Problem, erkannte Sackgassen und wusste, welche Lemmata verdächtig rochen. Diese menschliche Expertise leistet echte epistemische Arbeit, und das Zertifikat, so wie es formuliert ist, stützt sich überhaupt nicht darauf, was mich stört. Ich habe schon über die Aufteilung zwischen Vermutungsgenerierung durch LLMs und mechanischer Beweisprüfung geschrieben, und das hier ist diese Aufteilung unter maximalen Einsätzen: Die Maschine hat in noch nie dagewesenem Umfang vorgeschlagen, die Maschine hat in noch nie dagewesenem Umfang geprüft, und ein seltener Mensch saß an der Schnittstelle und machte das Ganze lesbar. Diesen Menschen aus der offiziellen Geschichte zu streichen, macht die Geschichte sauberer und weniger wahr.
Ingenieurslektionen für maschinell geprüfte Software
- Halte die vertrauenswürdige Rechenbasis winzig und langweilig. Jede Codezeile, der du vertrauen musst, ist eine Belastung; jede Zeile, die du nur prüfst, sind Daten.
- Exportiere in ein inertes, portables Format. Die Verifikation sollte auf einem Dokument laufen, nicht auf einem laufenden Prozess, der Überraschungen ausführen kann.
- Verifiziere die Behauptung, nicht nur die Argumentation. Baue den Comparator. Beweise, dass dein Artefakt dem Vertrag entspricht, bevor du den Beweis feierst.
- Diversifiziere deine Prüfer wirklich. Verschiedene Sprachen helfen; verschiedene Grundlagen helfen noch mehr; ein einzelner Prüfer mit einem Konsistenzbeweis ist mehr wert als zwei, die voneinander abschreiben.
- Mache Builds reproduzierbar und Artefakte inhaltsadressierbar. „Dutzende Leute haben dieselbe Exportdatei reproduziert“ ist ein Satz, nach dem jede Release-Pipeline streben sollte.
- Kanonisiere gemeinsames Vokabular upstream, bevor der große Beitrag landet. Erst die Definitionen, dann die Heldentaten.
- Zähle deine Annahmen maschinell auf. Wenn dein System nicht beantworten kann „wovon hängst du ab?“, weißt du nicht, was du ausgeliefert hast.
Unter der Liste steckt eine Idee: Tests stichprobenartig einen Raum ab, Beweise erschöpfen ihn, und die spannende Zwischenzone, also property-based Testing, Model Checking und symbolische Ausführung, ist die Industrie, die langsam und widerwillig vom ersten Lager zum zweiten kriecht. Niemand verlangt, dass du deine CRUD-App formalisierst. Aber die Grenze dessen, was „maschinell geprüft werden muss“, wandert ständig: kryptografische Primitive, Konsensprotokolle, Smart Contracts, Flugsoftware, eBPF-Verifier im Kernel. Jede dieser Communities hatte ihren Moment „Eigentlich sollten wir das auf die Lean-Art machen“, meist direkt nach einem teuren Vorfall. Die Riemann-Verifikation zeigt, dass Werkzeuge, Kultur und Prüfer-Ökosystem das Gewicht von etwas wirklich Gewaltigem tragen können. Die Ausrede-Kiste ist leer.
Hundert Jahre Versuche
Als Sprachenmensch kann ich nicht anders, als das als Auszahlung einer sehr alten Wette zu sehen. Hilbert setzte die Riemannsche Vermutung 1900 auf seine Liste. De Bruijn begann 1967 mit Automath. Robin Milner baute in den 1970er-Jahren ML eigens als Metasprache zum Schreiben von Beweistaktiken. Der gesamte ML-Stammbaum, der über OCaml und Haskell bis in Rusts Typsystem reicht, stammt aus Werkzeugen für maschinell geprüfte Beweise. Das QED-Manifest der 1990er-Jahre fragte, warum nicht die gesamte Mathematik formalisiert sei, und erntete meist Achselzucken. Dann kam der Vierfarbensatz in Coq, dann der Satz von Feit–Thompson, dann bewies das Liquid-Tensor-Experiment, dass moderne Forschungsmathematik, nicht nur Klassiker, den Kontakt mit einem Kernel überleben kann. Jedes dieser Projekte wurde von irgendjemandem als Spielerei abgetan. Jedes hat die Community geschult und die Bibliothek gehärtet, auf der das nächste aufbaute.
Also: Stimmt meine eingangs aufgestellte These? Teilweise. Die Mathematiker haben einen Satz bekommen, und bis zum Morgen stellten sie schon die bessere Frage: Was lehrt der Beweis? Das ist etwas, was siebzehn Millionen geprüfte Zeilen nicht automatisch leisten. Die Ingenieure haben etwas Seltener bekommen: einen Bauplan, unter maximaler Prüfung validiert, um Artefakte zu konstruieren, die kein Mensch lesen kann, und trotzdem den Namen einer Community dafür zu verwetten. Das nächste Mal, wenn jemand in einem Design-Review behauptet, echte Verifikation skaliere nicht, weißt du genau, auf welches Build-Log du zeigen musst.


