· via Hacker News – Front Page (native)
Riemann hypothesis reportedly proved via 17 million lines of AI-assisted Lean code
A widely shared note says the Riemann hypothesis was proved with 17 million lines of AI-assisted Lean code and certified correct, and argues the same methods should remake software engineering.

A note that reached Hacker News's front page claims that one of mathematics' most famous open problems has fallen to a machine. According to the post at anil.recoil.org, published November 22, 2026, the Riemann hypothesis was cracked last week with roughly 17 million lines of AI-assisted Lean code, and the argument has since been certified correct — even though no human yet understands how it works.
The author says they followed events as they unfolded in the Lean community's chat, and draws a broad conclusion from it: the future of mathematics, and much of science, will be built on human-AI collaboration. But most of the note is about something else — what the author sees as a lifetime of failure in software engineering, and how formally verified, machine-generated code might finally fix it.
Software engineering's long unpaid bill
The author's diagnosis is that there has always been a gap between what the theory of computation tells us and how fast society has deployed software anyway. Decades of human-written code turned out to be riddled with bugs, and because that code now underpins daily life, the consequences have become absurd — the note jokes that securing supermarket fridges now takes spy-thriller heroics. The author also observes that security was manageable in pre-AI times roughly because attackers and defenders were symmetric, but points to recently disclosed issues in Java, PHP and Linux, along with mysteriously correlated outages, as signs that security pain may accelerate into 2027. Mathematician Tim Gowers, the author notes, has joined a Pause AI march.
Route one: derive code from specifications
In April 2026 the same author had written that formally specifying every layer of hardware and software, and rolling it out in production, seemed implausible — ever. A few months of frontier-model progress changed their mind. The proposal is to define formal specifications for services first, derive all new software from those specifications, and use AI to translate the vast body of existing legacy code into verified form. That would mean rebuilding operating system stacks from the ground up and even reshaping instruction sets. Unikernels built with a library-OS linking discipline and shared-memory interconnects are cited as a way to shrink the number of interfaces in the stack, which makes the specification problem less daunting. Machine-checked fixes re-derived from a spec could also answer attacks faster than a pipeline that waits on maintainer triage. The remaining human job, in this picture, is iterating on the interfaces alongside an AI.
Route two: engineer diversity on purpose
Reuse has pushed software toward monoculture, so a single bug can compromise enormous numbers of hosts at once. Because any decent specification admits multiple valid implementations, generation agents could instead deliberately produce diverse, genetically varied implementations so services are not all simultaneously infected — a shift away from the Internet's traditional robustness principle of being liberal in what you accept. The catch, the author warns, is that if a handful of gated frontier models generate all our software, the monoculture simply moves up a level, so diversity has to extend to the models and harnesses too. The RFC process is offered as evidence that shared specifications can stay unified while implementations vary.
The social fallout
Open source communities have run for decades on social contracts of human review and trust, and the author says every community they belong to is now struggling with questions of AI disclosure. Humans are not out of a job: somebody still has to decide what the specifications contain. New research problems also open up — how to debug systems where no two nodes run the same code, how to force simplicity onto agent-maintained systems, and how blame gets settled when things inevitably go wrong.
Why it matters
If the account holds up, a machine-certified proof of the Riemann hypothesis would be a landmark for AI-assisted mathematics: correctness established by a proof assistant rather than human comprehension, in an artifact far too large for any person to read. The same mechanism — verification against a formal specification — is exactly what the author proposes as the escape hatch for mainstream software, where bugs now carry societal-scale costs. The caveats deserve equal weight. The claim rests on a single widely circulated post rather than an announced, peer-reviewed result, and the details beyond it are scarce. A certified proof is only as good as its specification and tooling, and concentrating code generation in a few frontier models could trade old fragilities for new ones. Still, for a field that has shipped code faster than anyone can understand it for decades, the question the note poses — whether software was simply always too complex for humans — has stopped being rhetorical.
- #riemann-hypothesis
- #lean
- #formal-verification
- #theorem-proving
- #software-security