Verificando Riemann no Lean: Lições para Engenheiros
Uma prova em Lean de 17 milhões de linhas sobre a Hipótese de Riemann passou em vários verificadores independentes. Veja o que ela ensina a engenheiros.

O software mais ousado lançado recentemente não é um framework, um banco de dados nem um agente de IA. É uma prova. Levent Alpöge publicou uma verificação em Lean da Hipótese de Riemann como uma biblioteca de cerca de dezessete milhões de linhas de código — e em cerca de um dia, um grupo distribuído de voluntários a compilou, comparou seu teorema final com o enunciado canônico no Mathlib e rechecou a prova exportada com vários kernels independentes, dois dos quais trazem argumentos verificados por máquina de que não conseguem aceitar uma prova falsa.
Aqui vai minha tese contraintuitiva, que vou defender e depois parcialmente retirar: este é o evento mais importante em linguagens de programação desta década, e ele quase não tem a ver com teoria dos números. A Hipótese de Riemann é quase irrelevante nesse sentido. O que importa é que agora temos um exemplo concreto, numa escala de pesquisa genuína, de um problema que engenheiros de software ficam rondando sem nunca encarar de frente: como construir um artefato tão grande que nenhum ser humano consegue revisá-lo, mas tão rigorosamente checado que estranhos estão dispostos a apostar a própria reputação profissional nele?
O que significam, na prática, dezessete milhões de linhas de verificação em Lean
O Lean se baseia numa ideia que Nicolaas de Bruijn desenvolveu no fim dos anos 1960 com o Automath, um dos primeiros sistemas para codificar matemática de forma verificável por máquina. A ideia hoje se chama critério de de Bruijn: um provador de teoremas deve produzir objetos de prova que um programa verificador pequeno e independente consiga checar sozinho. A parte grande e engenhosa do sistema — o elaborador, o motor de táticas, a automação que transforma scripts de prova escritos por humanos em objetos formais — é explicitamente não confiável. É um compilador, e como todo compilador, pode ter bugs. A confiança mora no kernel, um pequeno programa que verifica tipos dos termos de prova totalmente elaborados segundo as regras da lógica.
É essa arquitetura que torna um artefato de dezessete milhões de linhas significativo. Ninguém leu aquela prova. Ninguém conseguiria. Ela tem a ordem de grandeza de um componente importante de sistema operacional e é, em grande parte, gerada e moldada por máquina. Mas o fluxo de verificação trata a prova como um bom sistema de build trata um binário compilado: dezenas de pessoas compilaram a biblioteca de forma independente e reproduziram o mesmo arquivo bruto de exportação da prova, byte a byte. Isso é um build hermético e determinístico produzindo um artefato endereçado por conteúdo, e aí começa a parte interessante — porque é o artefato, não o código-fonte, que os verificadores consomem.
Uma prova que você não consegue ler ainda pode ser uma prova em que você pode confiar. Essa inversão da revisão de código comum é a história inteira.
Pessoas de software deveriam ficar um momento com essa inversão. Nosso mecanismo padrão de garantia é um humano abrindo um diff e franzindo a testa. Isso escala para talvez alguns milhares de linhas por revisor por semana, até que o franzir de testa vira teatro. A resposta da comunidade Lean é descer a confiança na pilha: confiar num kernel pequeno, confiar na diversidade de reimplementações independentes desse kernel e tratar tudo que está acima — por maiores que sejam os milhões de linhas — como dados a serem verificados, e não como prosa a ser revisada. Isso não é truque de matemática. É uma postura de engenharia.
O problema do enunciado: provar o teorema certo
A primeira coisa que a comunidade checou não foi a prova. Foi o enunciado. Essa é a parte que quem está de fora costuma subestimar, e é onde projetos de formalização morrem em silêncio. Um provador de teoremas vai deixar você provar a coisa errada com rigor total — a lógica não se importa com o que você quis dizer. O exemplo clássico de brinquedo é uma rotina de ordenação verificada cuja especificação diz que a saída está ordenada, mas esquece de dizer que ela é uma permutação da entrada. A lista vazia está lindamente ordenada. A prova passa. A função é lixo.
Então o certificado deste trabalho se apoia num fato fácil de passar batido: o enunciado RiemannHypothesis já existia no Mathlib, onde foi examinado por pessoas que realmente conhecem teoria analítica dos números e as convenções de codificação do Lean — onde os zeros podem estar, como os zeros triviais são excluídos, sobre o que a função é de fato definida. Depois, a comunidade adicionou um arquivo isolando exatamente esse enunciado, importando apenas o Mathlib, e usou duas ferramentas independentes (comparator e con-leche --compare) para confirmar que o teorema provado pela biblioteca de Alpöge é exatamente esse enunciado — não um quase-acerto, nem um sósia definicional com uma hipótese relaxada silenciosamente removida. Já defendi antes que a lacuna entre especificação e implementação é onde moram os bugs, e a matemática formal é onde essa verdade deixa de ser um post de blog e vira um item de checklist com ferramentas dedicadas.
Repare como essa disciplina é incomum pelos padrões da indústria. Quando foi a última vez que você viu uma equipe construir uma ferramenta dedicada cujo único trabalho é provar que aquilo que o sistema faz é aquilo que o contrato diz? Escrevemos testes que amostram o contrato. Escrevemos tipos que apenas insinuam isso. A comunidade Lean construiu comparadores que identificam o contrato. Se você levar uma prática desta história toda, leve esta: antes de comemorar que a máquina checou sua prova, confira se a máquina está checando a sua afirmação.

Confiança no kernel e o ecossistema de verificadores
O kernel oficial do Lean é pequeno, mas 'pequeno' não é um argumento de segurança por si só — é um convite para reimplementar. A verificação se apoiou nesse convite com força. A prova exportada foi checada não só pelo kernel do Lean, mas também por con-leche e con-ron, além de vários verificadores de terceiros escritos em linguagens de programação diferentes, todos consumindo o mesmo arquivo de exportação inerte. Essa palavra inerte importa: os verificadores nunca executam código dos fontes da prova, então um trecho malicioso hipotético escondido em dezessete milhões de linhas não tem nenhum runtime onde agir. É a diferença entre revisar um documento e executar um anexo.
Os dois pesos-pesados merecem menção especial, porque con-leche e con-ron vêm cada um com uma prova formal — relativa à teoria dos conjuntos — de que não conseguem aceitar uma prova falsa. Isso fecha a regressão usual: sim, o kernel do Lean poderia, em teoria, ter um bug de corretude, então verifique com outro kernel; sim, esse kernel também pode ter um; mas quando o argumento de corretude do verificador é ele próprio verificado por máquina contra uma fundação diferente, a superfície de ataque se reduz a 'um bug que sobrevive simultaneamente a várias implementações, várias linguagens e vários sistemas fundacionais'. Não é impossível. Não é algo com que você planeja. Já escrevi sobre como até o borrow checker do Rust trouxe um buraco de corretude, então não digo 'confie no kernel' levianamente. A resposta nunca foi um único componente confiável. É uma população diversa de verificadores e um formato de prova compartilhado e portátil — programação N-versões, que a aviação pratica há décadas, finalmente aplicada à própria verdade.
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.
Esse último mecanismo é a trilha de auditoria que a maioria dos sistemas não tem. #print axioms pergunta ao kernel, depois do fato, em quais suposições uma prova realmente se apoia. Todo atalho no Lean — sorry, um axioma declarado pelo usuário, um unsafe mal empregado — deixa uma marca nessa lista. Imagine se seu build pudesse responder 'o que você assumiu?' com essa mesma precisão: este serviço assume que o relógio é monotônico, aquele assume TLS 1.3, aquele outro assume que a fila entrega pelo menos uma vez. A maioria dos nossos sistemas carrega exatamente essas suposições. Quase nenhum consegue enumerá-las sob demanda.
Gerenciamento de dependências em escala Mathlib
Uma linha do enunciado da comunidade é pura poesia de gerenciamento de dependências: a base de código depende diretamente apenas do Mathlib. Sem forks vendorizados, sem branches privados da biblioteca padrão, sem patches mantidos fora da árvore. Dezessete milhões de linhas de matemática de pesquisa repousam sobre um único upstream compartilhado e continuamente integrado. Isso só funciona porque o Mathlib opera menos como um repositório de pacotes e mais como um órgão de padronização com CI — revisão agressiva, um cache compartilhado para que os contribuidores não recompilem o universo a cada pull request, e uma cultura em que subir suas definições para o upstream é o padrão, e não um favor feito à comunidade.
E essa ordem — enunciado primeiro, prova depois — é a parte que equipes de engenharia costumam inverter. A definição da Hipótese de Riemann foi integrada, revisada e endurecida na biblioteca compartilhada antes de a prova chegar. Quando a carga de dezessete milhões de linhas caiu, não houve discussão sobre o que ela afirmava; a afirmação já era infraestrutura. Compare com a forma como a maioria das grandes bases de código absorve uma contribuição enorme: as interfaces são definidas pela própria contribuição, a revisão acontece sob pressão de prazo, e quando alguém percebe que o contrato derivou, três outros times já dependem da versão alterada. A disciplina do Mathlib — canonizar o vocabulário em público e só então deixar o trabalho construir sobre ele — é exatamente o que um time de plataforma saudável faz com suas APIs internas. A diferença é que eles realmente fazem isso.

Onde a tese contraintuitiva deixa de se sustentar
Agora a parte da retirada, porque a tese merece um teste de estresse honesto. Os verificadores independentes não são tão independentes quanto a retórica sugere. Eles compartilham uma metateoria, vários compartilham linhagem de design, e os autores dos verificadores conversam entre si; diversidade de linguagem de programação não é diversidade de lógica. Também há precedentes de escorregões: uma refutação fabricada da conjectura de Collatz chegou a passar por um desses verificadores independentes antes de alguém perceber. A formulação honesta do argumento de confiança é a que um observador cuidadoso ofereceu: para que a prova estivesse errada, um único bug teria que afetar tanto as provas internas de consistência dos verificadores quanto esta prova específica, em todas as implementações. Improvável a ponto de ser quase zero. Mas 'quase zero' é uma probabilidade, e o enunciado da comunidade diz 'confiança total', o que é sociologia.
Há também uma parede de sustentação humana que os quatro critérios publicados não mencionam. Segundo todos os relatos, esta prova foi produzida com forte assistência de IA, com Alpöge no comando — decompondo o problema, reconhecendo becos sem saída, sabendo quais lemas pareciam suspeitos. Essa expertise humana faz um trabalho epistêmico real, e o certificado, como está escrito, não se apoia nela de forma alguma, o que me incomoda. Já cobri a divisão entre geração de conjecturas por LLMs e verificação mecânica de provas, e este caso é essa divisão no nível máximo de risco: a máquina propôs em escala inédita, a máquina checou em escala inédita, e um raro humano ficou na junção tornando tudo legível. Remover esse humano da história oficial deixa a narrativa mais limpa e menos verdadeira.
Lições de engenharia para software verificado por máquina
- Mantenha a base confiável computacional pequena e sem graça. Cada linha de código em que você precisa confiar é um passivo; cada linha que você apenas verifica é dado.
- Exporte para um formato inerte e portátil. A verificação deve rodar sobre um documento, não sobre um processo vivo que pode executar surpresas.
- Verifique a afirmação, não só o argumento. Construa o comparador. Prove que seu artefato corresponde ao contrato antes de comemorar a prova.
- Diversifique seus verificadores de verdade. Linguagens diferentes ajudam; fundações diferentes ajudam mais; um verificador com uma prova de consistência vale mais que dois que copiam o dever de casa um do outro.
- Torne os builds reprodutíveis e os artefatos endereçáveis por conteúdo. 'Dezenas de pessoas reproduziram o mesmo arquivo de exportação' é uma frase que qualquer pipeline de release deveria almejar.
- Canonize o vocabulário compartilhado no upstream antes de a grande contribuição chegar. Definições primeiro, heroísmo depois.
- Enumere suas suposições de forma mecânica. Se seu sistema não consegue responder 'do que você depende?', você não sabe o que colocou em produção.
Por baixo da lista há uma ideia só: testes amostram um espaço, provas o esgotam, e o meio-termo interessante — testes baseados em propriedades, model checking, execução simbólica — é a indústria avançando devagar e a contragosto do primeiro campo rumo ao segundo. Ninguém está pedindo que você formalize seu app CRUD. Mas a fronteira do que 'precisa ser verificado por máquina' continua se movendo: primitivas criptográficas, protocolos de consenso, smart contracts, software de voo, verificadores de eBPF no kernel do Linux. Cada uma dessas comunidades já teve seu momento de 'deveríamos fazer isso do jeito Lean', geralmente logo depois de um incidente caro. A verificação da Hipótese de Riemann é a demonstração de que as ferramentas, a cultura e o ecossistema de verificadores aguentam o peso de algo genuinamente enorme. A desculpa acabou.
Cem anos tentando
Como alguém da área de linguagens, não consigo deixar de ver isto como o pagamento de uma aposta muito antiga. Hilbert incluiu a Hipótese de Riemann na sua lista em 1900. De Bruijn começou o Automath em 1967. Robin Milner construiu o ML nos anos 1970 justamente como metalinguagem para escrever táticas de prova — toda a família ML, que passa por OCaml e Haskell e chega ao sistema de tipos do Rust, descende de ferramentas para prova verificada por máquina. O manifesto QED dos anos 1990 perguntou por que toda a matemática ainda não estava formalizada e recebeu, em geral, de ombros. Depois veio o Teorema das Quatro Cores no Coq, depois o teorema de Feit–Thompson, e então o Liquid Tensor Experiment mostrou que a matemática de pesquisa moderna — não só a clássica — podia sobreviver ao contato com um kernel. Cada um desses foi chamado de truque por alguém. Cada um treinou a comunidade e endureceu a biblioteca sobre a qual o próximo se apoiou.
Então: minha tese de abertura está certa? Em parte. Os matemáticos ganharam um teorema, e de manhã já estavam fazendo a pergunta melhor — o que a prova ensina, algo que dezessete milhões de linhas verificadas não fazem automaticamente. Os engenheiros ganharam algo mais raro: uma planta, validada sob o máximo escrutínio, para construir artefatos grandes demais para qualquer humano ler e, mesmo assim, apostar o nome de uma comunidade neles. Na próxima vez que alguém numa revisão de design disser que verificação de verdade não escala, você saberá exatamente qual log de build mostrar a ele.


