The maintainers state unambiguously that no proof of RH exists in Lean, nothing is close, and mathlib contains only the definitions of the zeta function, analytic continuation, and classical equivalences — exactly matching the open status of the problem on paper. They felt compelled to publish a joint statement because they are repeatedly asked to validate screenshots of LLM-generated 'proofs' circulating online.
Surfaced the joint statement to a wide developer audience, implicitly endorsing the maintainers' framing that these claims need public correction. The submission drew 285 points and 206 comments, signaling broad community agreement that the issue is worth airing.
The maintainers emphasize that a Lean file is meaningful only against the definitions it imports: redefining `RiemannHypothesis : Prop := True` and proving it is a valid compilation but a trivial tautology, not a proof of RH. The compiler is doing its job correctly; the human is misrepresenting what was proved.
The statement frames the surge of bogus 'verifications' as a pattern enabled by frontier models that can produce Lean files which compile but smuggle in mock definitions or trivial propositions. Rather than quietly ignoring each case, the maintainers argue the pattern itself is worth naming so outside observers stop treating screenshots as evidence.
The Lean prover community — the maintainers behind mathlib and the Lean 4 ecosystem — published a joint statement addressing a growing stream of claims that the Riemann Hypothesis, or large chunks of it, has been "verified in Lean." The short version: no such verification exists, none is close, and the pattern of claims is itself a problem worth naming.
The immediate trigger is familiar to anyone watching the intersection of LLMs and formal math. Over the past year, people have been posting Lean files — often generated or heavily assisted by frontier models — that appear to state and prove famous open problems. The files compile. The `#check` returns the expected type. Screenshots circulate. The catch, which the Lean maintainers spell out, is that a Lean file only means something relative to the definitions it imports. If you write your own `def RiemannHypothesis : Prop := True` and then prove it, you have proven `True`. The compiler is doing its job. You have not done mathematics.
The statement goes further than the obvious disclaimer. It lays out the actual state of play: mathlib contains the definitions of the Riemann zeta function and its analytic continuation, a substantial chunk of complex analysis, and some of the classical equivalences — but the hypothesis itself is an open conjecture in Lean exactly as it is in the rest of mathematics. There is no proof. There are no serious partial results formalized beyond what is already known on paper. And the maintainers are, politely but unmistakably, tired of being asked to validate screenshots.
This is not really a story about the Riemann Hypothesis. It is a story about what formal verification actually certifies, and about a failure mode that LLMs have made cheap and abundant.
A Lean proof is a proof of a specific proposition against a specific set of definitions and axioms — change the proposition or swap in a mock definition, and the guarantee evaporates. Mathlib's value is that thousands of mathematicians have painstakingly agreed, by review, that its definitions match the informal mathematical objects they are supposed to represent. When a student proves a theorem against `Mathlib.NumberTheory.LSeries.RiemannZeta`, the social layer of mathlib review is doing enormous work in the background. When someone imports nothing and defines their own zeta function, that social layer isn't present, and the type-checker — which cares only about syntactic correctness — happily accepts whatever they wrote.
The HN thread is instructive. The top comments are not from skeptics debunking the claim; they are from working formalists explaining, patiently and for the hundredth time, that `sorry` is not the only way to cheat. You can cheat by stating the wrong theorem. You can cheat by using a weakened definition. You can cheat by assuming a lemma as an axiom. The compiler will not stop you, because stopping you is not its job. Several commenters note that LLMs are particularly good at producing files that look like proofs to a non-expert — correct Lean syntax, plausible-looking tactic blocks, invocations of real mathlib lemmas — while being mathematically vacuous. Fluent-sounding nonsense used to require effort; now it compiles.
There is a second layer the statement is careful to make. The maintainers are not dismissing LLM-assisted formalization as a research direction. Tools like LeanDojo, Lean Copilot, and the various proof-search models are genuinely useful for closing short goals, suggesting lemmas, and lowering the activation energy of formalization. The problem is not AI in proof assistants. The problem is treating a clean compile of an unreviewed file as evidence of a mathematical fact — a category error that no amount of better models will fix, because the error is in how the output is read, not in how it is generated.
The parallel to software engineering is almost too direct to be interesting, and yet most teams get it wrong anyway. A test suite proves what it asserts, against the mocks it imports, in the environment it runs. It does not prove your system is correct; it proves that your assertions about your system are consistent with your model of your system. If the assertions are weak, or the mocks diverge from production, or the model is wrong, a green bar certifies nothing.
This matters more now, not less, because the volume of machine-generated code — including machine-generated tests — is going up fast. An LLM that writes a function and a test for that function is pattern-matching on "things that pass CI," which is exactly the failure mode mathlib's maintainers are describing one abstraction level up. The test will reflect the model's beliefs about the code, which are the same beliefs that produced the code. Both can be wrong in the same direction, and the build will still be green. Code review, like mathlib review, is the layer where someone asks "does this assertion actually mean what you think it means" — and that layer does not scale by shipping more agents.
The practical move: treat formal and semi-formal artifacts the way the Lean community treats mathlib. Pin the definitions you depend on. Make the spec the thing under review, not just the implementation. When an AI tool produces a proof-like artifact — a type signature, a contract, a test, a schema — ask what it is proved against, not whether it compiles. And when someone shows you a screenshot of a green check next to a strong claim, assume the interesting question is which definitions were used, not whether the tool ran successfully.
Formalization is going to keep eating mathematics; mathlib crossed a million lines this year and the pace is accelerating. More LLM-assisted proofs will land, and most of them will be real contributions. The RH-in-Lean genre of viral post will also keep showing up, because the gap between "it compiled" and "it is true" is exactly the kind of thing that does not survive the trip from Lean IDE to Twitter. The Lean maintainers have done the field a small favor by naming the pattern explicitly. The rest of us can borrow the framing: a verifier's output is only as strong as the spec you handed it, and the spec is where the work lives.
If I understand correctly, for the purpose of the proof Claude formalized a huge chunk of all modern math. So it's a big result not only for GRH, but math foundations and formalization.
A fake refutation of the Collatz conjecture already got through one of these independent checkers in the past.What's harder, proving GRH or finding a way to get through every checker (which aren't as independent as they are sometimes touted to be)?In this case there was a human expert in t
We need to give Levent a lot of credit for this. As much as we talk about Claude proving it, Levent seems to have a rare talent for getting the most out of it.
Do huge results like this open up even larger questions? Is there some question even more important that mathematicians dared not approach without doing big problems like Riemann first?
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
While still possible, the proof exploiting a bug is vanishingly small now. Following a few bugs and bad proofs this year, there are a number of different implementations, in different languages, and with different levels of proofs of their consistency. con-leche and con-ron are the heavy hitters, wi