Verificare Riemann in Lean: lezioni per gli ingegneri
Una dimostrazione Lean da 17 milioni di righe dell'ipotesi di Riemann ha superato più verificatori indipendenti. Ecco cosa insegna agli ingegneri.

Il pezzo di ingegneria del software più audace rilasciato di recente non è un framework, un database o un agente AI. È una dimostrazione. Levent Alpöge ha pubblicato una verifica in Lean dell'ipotesi di Riemann sotto forma di una libreria di circa diciassette milioni di righe di codice, e in circa un giorno un gruppo distribuito di volontari l'ha compilata, ha confrontato il suo teorema finale con l'enunciato canonico in Mathlib e ha ricontrollato la prova esportata con diversi kernel indipendenti, due dei quali portano argomentazioni verificate meccanicamente sul fatto che non possono accettare una dimostrazione falsa.
Ecco la mia tesi controcorrente, che difenderò per poi in parte ritrattare: questo è l'evento più importante nei linguaggi di programmazione di questo decennio, e ha quasi nulla a che fare con la teoria dei numeri. L'ipotesi di Riemann è quasi irrilevante. Ciò che conta è che ora abbiamo un esempio concreto, a una scala di vera ricerca, di un problema che gli ingegneri del software continuano a girare intorno senza mai affrontarlo davvero: come si costruisce un artefatto così grande che nessun essere umano può revisionarlo, eppure così rigorosamente controllato che sconosciuti sono disposti a giocarsi la reputazione professionale su di esso?
Che cosa significano davvero diciassette milioni di righe di verifica in Lean
Lean si basa su un'idea che Nicolaas de Bruijn elaborò alla fine degli anni Sessanta con Automath, uno dei primi sistemi per codificare la matematica in una forma verificabile dalla macchina. Oggi l'idea si chiama criterio di de Bruijn: un assistente di dimostrazione dovrebbe produrre oggetti di prova che un programma di verifica piccolo e indipendente possa controllare da solo. La parte grande e astuta del sistema, cioè l'elaboratore, il motore delle tattiche e l'automazione che trasforma gli script di prova scritti per gli esseri umani in oggetti formali, è esplicitamente non attendibile. È un compilatore e, come ogni compilatore, può avere dei bug. La fiducia risiede nel kernel, un piccolo programma che verifica i tipi dei termini di prova completamente elaborati secondo le regole della logica.
È esattamente questa architettura a rendere significativo un artefatto da diciassette milioni di righe. Nessuno ha letto quella dimostrazione. Nessuno poteva farlo. È paragonabile a un componente importante di un sistema operativo ed è in gran parte generato e modellato dalle macchine. Ma il flusso di verifica la tratta come un buon sistema di build tratta un binario compilato: decine di persone hanno compilato la libreria in modo indipendente e hanno riprodotto lo stesso file di esportazione grezzo della dimostrazione, byte per byte. Si tratta di una build ermetica e deterministica che produce un artefatto indirizzabile per contenuto, e la parte interessante comincia proprio qui, perché ciò che i verificatori consumano è l'artefatto, non il sorgente.
Una dimostrazione che non puoi leggere può comunque essere una dimostrazione di cui ti puoi fidare. Questa inversione rispetto alla normale revisione del codice è l'intera storia.
Chi lavora con il software dovrebbe soffermarsi un momento su questa inversione. Il nostro meccanismo standard di garanzia è una persona che apre un diff e lo guarda accigliata. Questo regge forse qualche migliaio di righe a settimana per revisore, prima che l'accigliarsi diventi teatro. La risposta della comunità Lean è spostare la fiducia più in basso nello stack: fidarsi di un kernel piccolo, fidarsi della diversità di re-implementazioni indipendenti di quel kernel, e trattare tutto ciò che sta sopra, quali che siano i milioni di righe, come dati da verificare anziché come prosa da rivedere. Non è un trucco matematico. È una scelta ingegneristica.
Il problema dell'enunciato: dimostrare il teorema giusto
La prima cosa che la comunità ha controllato non è stata la dimostrazione, ma l'enunciato. È la parte che chi viene da fuori sottovaluta sistematicamente, ed è dove i progetti di formalizzazione muoiono in silenzio. Un assistente di dimostrazione ti lascerà dimostrare con totale rigore la cosa sbagliata: la logica non si preoccupa di ciò che intendevi. Il classico esempio da giocattolo è una routine di ordinamento verificata la cui specifica dice che l'output è ordinato ma dimentica di dire che è una permutazione dell'input. La lista vuota è perfettamente ordinata. La dimostrazione passa. La funzione è spazzatura.
Quindi il certificato di questo lavoro poggia su un fatto facile da scorrere senza notarlo: l'enunciato RiemannHypothesis esisteva già in Mathlib, dove era stato esaminato da persone che conoscono davvero sia la teoria analitica dei numeri sia le convenzioni di codifica di Lean, cioè dove possono trovarsi gli zeri, come vengono esclusi quelli banali e su che cosa è definita la funzione. Poi la comunità ha aggiunto un file che isola esattamente quell'enunciato, importando solo Mathlib, e ha usato due strumenti indipendenti (comparator e con-leche --compare) per confermare che il teorema dimostrato dalla libreria di Alpöge è esattamente quell'enunciato, non un quasi-miss né un sosia definitorio con un'ipotesi attenuata e lasciata cadere in silenzio. Ho già sostenuto che il divario tra specifica e implementazione è dove vivono i bug, e la matematica formale è il punto in cui questa verità smette di essere un post sul blog e diventa una voce di checklist con strumenti dedicati.
Nota quanto questa disciplina sia insolita rispetto agli standard del settore. Quando hai visto l'ultima volta un team costruire uno strumento dedicato il cui unico compito è dimostrare che ciò che il sistema fa è ciò che dice il contratto? Scriviamo test che campionano il contratto. Scriviamo firme di tipo che ne accennano il contenuto. La comunità Lean ha costruito comparatori che lo identificano. Se porti via una sola pratica da questa vicenda, prendi questa: prima di festeggiare che la macchina ha verificato la tua dimostrazione, controlla che la macchina stia verificando la tua affermazione.

Fiducia nel kernel e ecosistema dei verificatori
Il kernel ufficiale di Lean è piccolo, ma «piccolo» non è di per sé un argomento di sicurezza: è un invito a reimplementarlo. La verifica ha accolto questo invito con decisione. La prova esportata è stata controllata non solo dal kernel di Lean ma anche da con-leche e con-ron, più diversi verificatori di terze parti scritti in linguaggi diversi, che consumano tutti lo stesso file di esportazione inerte. La parola inerte conta: i verificatori non eseguono mai codice dai sorgenti della prova, quindi un eventuale frammento malevolo nascosto in diciassette milioni di righe non ha alcun runtime in cui agire. È la differenza tra leggere un documento ed eseguire un allegato.
I due pesi massimi meritano una menzione speciale, perché con-leche e con-ron arrivano ciascuno con una dimostrazione formale, relativa alla teoria degli insiemi, del fatto che non possono accettare una dimostrazione falsa. Questo chiude la solita regressione: sì, il kernel di Lean potrebbe in teoria avere un bug di correttezza, quindi si verifica con un altro kernel; sì, anche quello potrebbe averne uno; ma quando l'argomentazione di correttezza del verificatore è a sua volta verificata meccanicamente rispetto a un fondamento diverso, la superficie d'attacco si riduce a «un bug che sopravvive contemporaneamente a più implementazioni, più linguaggi e più sistemi fondazionali». Non impossibile. Non qualcosa su cui pianificare. Ho scritto di come anche il borrow checker di Rust abbia rilasciato una falla di soundness, quindi non dico «fidati del kernel» alla leggera. La risposta non è mai stata un unico componente fidato. È una popolazione diversificata di verificatori e un formato di prova condiviso e portabile: programmazione N-version, che l'avionica pratica da decenni, finalmente applicata alla verità stessa.
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.
Quest'ultimo meccanismo è la traccia di audit che alla maggior parte dei sistemi manca. #print axioms chiede al kernel, a posteriori, su quali assunzioni poggi davvero una dimostrazione. Ogni trucco in Lean (sorry, un assioma dichiarato dall'utente, un uso improprio di unsafe) lascia un'impronta in quell'elenco. Immagina che la tua build sappia rispondere a «che cosa hai assunto?» con la stessa precisione: questo servizio assume che l'orologio sia monotono, quest'altro assume TLS 1.3, quell'altro assume che la coda consegni almeno una volta. La maggior parte dei nostri sistemi porta con sé esattamente queste assunzioni. Quasi nessuno sa elencarle su richiesta.
Gestione delle dipendenze su scala Mathlib
Una riga dell'enunciato della comunità è pura poesia della gestione delle dipendenze: il codice dipende direttamente solo da Mathlib. Nessun fork vendorizzato, nessun ramo privato della libreria standard, nessuna patch tenuta fuori dall'albero. Diciassette milioni di righe di matematica di ricerca poggiano su un unico upstream condiviso e integrato in modo continuo. Questo funziona solo perché Mathlib opera meno come un repository di pacchetti e più come un ente di standardizzazione con CI: revisione aggressiva, una cache condivisa perché i contributori non debbano ricompilare l'universo a ogni pull, e una cultura in cui portare a monte le proprie definizioni è la norma e non un favore fatto alla comunità.
E questo ordine, prima l'enunciato e poi la dimostrazione, è la parte che i team di ingegneria fanno al contrario. La definizione dell'ipotesi di Riemann è stata integrata, revisionata e consolidata nella libreria condivisa prima dell'arrivo della prova. Quando il carico da diciassette milioni di righe è atterrato, non c'era discussione su ciò che affermava: l'affermazione era già infrastruttura. Confrontalo con il modo in cui la maggior parte delle grandi codebase assorbe un contributo enorme: le interfacce vengono definite dal contributo stesso, la revisione avviene sotto pressione di tempo e, quando qualcuno si accorge che il contratto è slittato, altre tre squadre dipendono già dalla versione slittata. La disciplina di Mathlib, cioè canonizzare il vocabolario in pubblico e poi lasciare che il lavoro vi si appoggi, è esattamente ciò che fa un buon team di piattaforma con le proprie API interne. La differenza è che loro lo fanno davvero.

Dove la tesi controcorrente si rompe
Ora la ritrattazione, perché la tesi merita un vero stress test. I verificatori indipendenti non sono indipendenti quanto suggerisce la retorica. Condividono una metateoria, molti condividono una linea di discendenza progettuale, e gli autori dei verificatori si parlano tra loro: la diversità di linguaggio di programmazione non è diversità di logica. C'è anche un precedente di scivolata: una confutazione fabbricata della congettura di Collatz ha superato uno di questi verificatori indipendenti prima che qualcuno se ne accorgesse. La formulazione onesta dell'argomento di fiducia è quella che un osservatore attento ha proposto: perché la prova sia sbagliata, un singolo bug dovrebbe colpire contemporaneamente le dimostrazioni di coerenza interna dei verificatori e questa specifica prova, attraverso ogni implementazione. Probabilità minuscola. Ma «minuscola» è una probabilità, mentre l'enunciato della comunità dice «piena fiducia», che è una questione di sociologia.
C'è anche un muro portante umano che i quattro criteri pubblicati non menzionano. Secondo tutti i resoconti, questa dimostrazione è stata prodotta con un forte supporto dell'AI, con Alpöge alla guida: scomponendo il problema, riconoscendo i vicoli ciechi, sapendo quali lemmi puzzavano di errore. Questa competenza umana svolge un lavoro epistemico reale, e il certificato così com'è scritto non vi si appoggia affatto, e questo mi preoccupa. Ho già trattato la divisione tra generazione di congetture con LLM e verifica meccanica delle dimostrazioni, e questo è quello stesso confine portato al massimo della posta in gioco: la macchina ha proposto su scala senza precedenti, la macchina ha verificato su scala senza precedenti, e un raro essere umano stava in mezzo a tutto, rendendo il quadro leggibile. Eliminare quell'essere umano dalla versione ufficiale rende la storia più pulita e meno vera.
Lezioni di ingegneria per il software verificato meccanicamente
- Mantieni la base di calcolo fidata piccola e noiosa. Ogni riga di codice di cui devi fidarti è una responsabilità; ogni riga che ti limiti a verificare è un dato.
- Esporta in un formato inerte e portabile. La verifica dovrebbe girare su un documento, non su un processo attivo che può eseguire sorprese.
- Verifica l'affermazione, non solo l'argomentazione. Costruisci il comparatore. Dimostra che il tuo artefatto corrisponde al contratto prima di festeggiare la dimostrazione.
- Diversifica davvero i tuoi verificatori. Linguaggi diversi aiutano; fondamenta diverse aiutano di più; un verificatore con una dimostrazione di coerenza vale più di due che copiano i compiti l'uno dall'altro.
- Rendi le build riproducibili e gli artefatti indirizzabili per contenuto. «Decine di persone hanno riprodotto lo stesso file di esportazione» è una frase a cui ogni pipeline di rilascio dovrebbe aspirare.
- Canonizza il vocabolario condiviso a monte prima che arrivi il grande contributo. Prima le definizioni, poi gli eroismi.
- Enumera le tue assunzioni in modo meccanico. Se il tuo sistema non sa rispondere a «da che cosa dipendi?», non sai che cosa hai rilasciato.
Alla base dell'elenco c'è un'idea sola: i test campionano uno spazio, le dimostrazioni lo esauriscono, e la zona intermedia interessante (property-based testing, model checking, esecuzione simbolica) è l'industria che striscia lentamente e controvoglia dal primo campo verso il secondo. Nessuno ti chiede di formalizzare la tua app CRUD. Ma il confine di ciò che «deve essere verificato meccanicamente» continua a spostarsi: primitive crittografiche, protocolli di consenso, smart contract, software di volo, verificatori eBPF del kernel. Ciascuna di queste comunità ha avuto il suo momento del tipo «dovremmo davvero farlo alla maniera Lean», di solito subito dopo un incidente costoso. La verifica dell'ipotesi di Riemann dimostra che gli strumenti, la cultura e l'ecosistema dei verificatori possono reggere il peso di qualcosa di davvero enorme. Gli alibi sono finiti.
Cento anni di tentativi
Da linguista, non posso fare a meno di vedere in tutto questo il frutto di una scommessa molto antica. Hilbert inserì l'ipotesi di Riemann nella sua lista nel 1900. De Bruijn avviò Automath nel 1967. Robin Milner costruì ML negli anni Settanta proprio come metalinguaggio per scrivere tattiche di dimostrazione: l'intero albero genealogico della famiglia ML, che passa per OCaml e Haskell e arriva fino al sistema di tipi di Rust, discende da strumenti per la dimostrazione meccanica. Il manifesto QED degli anni Novanta chiedeva perché non tutta la matematica fosse ancora formalizzata e ottenne per lo più spallucce. Poi il teorema dei quattro colori entrò in Coq, poi il teorema di Feit–Thompson, poi il Liquid Tensor Experiment dimostrò che la matematica di ricerca moderna, non solo quella classica, poteva sopravvivere al contatto con un kernel. Ciascuno di questi episodi fu liquidato da qualcuno come un'acrobazia. Ognuno ha addestrato la comunità e rafforzato la libreria su cui si è appoggiato il successivo.
Quindi: la mia tesi iniziale è giusta? In parte. I matematici hanno ottenuto un teorema e, entro la mattina, si ponevano già la domanda migliore: che cosa insegna la dimostrazione, cosa che diciassette milioni di righe verificate non fanno automaticamente. Gli ingegneri hanno ottenuto qualcosa di più raro: un progetto, validato sotto il massimo scrutinio, per costruire artefatti troppo grandi perché un essere umano possa leggerli, e impegnare comunque il nome di una comunità su di essi. La prossima volta che qualcuno, in una revisione di progettazione, ti dirà che la verifica reale non scala, saprai esattamente quale log di build mostrargli.


