ScienceNot yet confirmed elsewhere1 publisher3 min readPublished
OpenAI's Lean code for its Navier-Stokes proof loosens a bound set in the written paper
Cambridge and King's College London mathematicians say the Lean code for OpenAI's Navier-Stokes proof states a weaker step than the written paper. Both proofs may hold up, but Lean verifies only the code it is given, so a person still has to check that the code matches the text.
The Scientist · Science desk

What happened
- OpenAI announced a Navier-Stokes solution on 8 September, publishing a natural-language proof alongside a Lean version meant to let a computer verify each logical step.
- In Lemma 8.6 the written proof requires a value to stay below m + 4, with m a whole number, while the Lean code requires only that it stay below m + 5.
- The team found the divergence by asking ChatGPT to flag possible discrepancies and checking each by hand, and many flagged items proved consistent on inspection.
- OpenAI told New Scientist it knows of the mismatch, that it does not make either proof invalid, and that it will fix errors in the written proof as they are found.
Why it matters
- decision Anyone citing the Lean repository as verification of the paper now has to say which version of Lemma 8.6 they rely on, since OpenAI's description treats the two as the same results.
- cost The comparison falls on human mathematicians; Hansen expects every LLM-generated proof to need human reading and calls that an enormous extra burden.
- exposure The 722 papers OpenAI released this week include Lean proofs not yet checked by hand, so any of them could carry the same gap between code and text.
The looser bound matters because a weaker inequality proves less. New Scientist gives a schoolroom version: if x + 3 = 6, it is true that x is less than 4 and also true that x is less than 5, but the second statement admits more answers [5]. A proof built on the weaker step can still reach a valid result [9]. At that step, though, it is a different proof from the one on paper [4].
Hansen said the gap comes from what the formalising model is required to produce [7]. Its Lean has to compile, meaning the code is self-consistent and returns no error. When a section of the written argument will not compile, the model looks for a workaround, even one that departs from the paper [7]. Lean then checks the statements in the code it was given, workaround included [2].
The team's claim is narrow, and Hansen set its limits himself [3]. "We are not saying that the natural-language proof is wrong," Hansen said. "Nor do we say that it is correct." [8] Both versions could solve the problem, in the way Pythagoras's theorem has hundreds of valid proofs [9]. The objection is to the label. OpenAI's GitHub repository says it "contains Lean 4 formalizations of the results presented in" the paper "Finite time blowup for Navier-Stokes" [6]. At Lemma 8.6 the code formalises a weaker statement than the paper makes [4].
Finding the mismatch took far longer than producing the proof. The team needed about two weeks to identify one true discrepancy, against the 88 hours OpenAI said its agents spent generating the proofs [14]. Two weeks of calendar time is 336 hours, about 3.8 times the agent figure [18]. The two numbers are in different units, a team's elapsed time set against a machine total that OpenAI supplied, so the ratio is rough. "Going through all of these things manually was a nightmare," Hansen said [13]. "OpenAI boast about how quickly they were able to generate this result, but that's only part of the process," said Alexander Bastounis of King's College London, a member of the team [15].
"This formalisation process is trying to replace peer review," said Fabian Circelli, also of Cambridge [10]. "Peer review would mean that human eyes look at the proofs. But what we've shown in this paper is that using this type of AI auto-formalisation can't serve the same purpose." [10] I think the evidence supports a slightly narrower version of that. On this paper, the Lean check did not do a reviewer's job, and it took a hand check of machine-flagged candidates to show it [12]. So far the team has reported one true discrepancy, in one lemma [4] [14].
What to watch
- Whether OpenAI changes the Lean code or the written Lemma 8.6 so that both state the same bound.
- Whether other groups run the same code-against-text comparison on the Lean proofs attached to OpenAI's other released papers.
- Independent human review of the written blowup proof, the question the Cambridge team chose to leave open.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence62
- Adoption
- Insufficient
- Hype gap+35
- Incentives40
- Confidence60
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
On 8 September, OpenAI announced that it had found a solution to the Navier-Stokes problem, one of the most famous open problems in mathematics, and published the proof in two versions: one in natural language and one in the computer code Lean.
ReportedSupportedSource: New Scientist2 sources— create a free account to open themView cited source - [2]
The Lean proof is meant to be a formalisation of the natural-language version, allowing a computer to mechanically verify that all of its logical statements are true.
ReportedSupportedSource: New Scientist2 sources— create a free account to open themView cited source - [3]
A team of mathematicians including Anders Hansen and Fabian Circelli of the University of Cambridge and Alexander Bastounis of King's College London says OpenAI's natural-language and Lean proofs do not match.
ReportedSupportedSource: Hansen and team, via New Scientist2 sources— create a free account to open themView cited source - [4]
In Lemma 8.6 of the natural-language proof, an equation requires a certain value to be below m + 4, where m is a whole number; in the Lean proof the equivalent value is required to be below m + 5, which is mathematically weaker.
ReportedSupportedSource: Hansen and team, via New Scientist2 sources— create a free account to open themView cited source - [5]
Illustration: for x + 3 = 6, it is possible to prove both that x is less than 4 and that x is less than 5; both are true, but the latter allows more possible answers and is mathematically weaker.
ReportedSupportedSource: New Scientist2 sources— create a free account to open themView cited source - [6]
OpenAI's GitHub repository states: "This repository contains Lean 4 formalizations of the results presented in [the paper] 'Finite time blowup for Navier-Stokes'".
- [7]
According to Hansen, the mismatch occurs because the AI has to produce a Lean proof that compiles; if a section does not compile, it attempts a workaround even if that diverges from the natural-language proof.
- [8]
"We are not saying that the natural-language proof is wrong," says Hansen. "Nor do we say that it is correct."
- [9]
The researchers are not saying OpenAI failed to solve the problem; it is possible both proofs provide a solution, just as there are hundreds of valid proofs of Pythagoras's theorem.
- [10]
"This formalisation process is trying to replace peer review," says Fabian Circelli, University of Cambridge. "Peer review would mean that human eyes look at the proofs. But what we've shown in this paper is that using this type of AI auto-formalisation can't serve the same purpose."
- [11]
"What has to be done with all of these large language model-generated proofs is that they will have to be read by humans, and this creates an enormous extra burden on mathematicians," says Anders Hansen.
- [12]
The team found the divergence by asking ChatGPT to look for potential discrepancies between the natural-language and Lean proofs, then checking them by hand; many suggested discrepancies turned out to be consistent on inspection.
- [13]
"Going through all of these things manually was a nightmare," says Hansen.
- [14]
It took the team about two weeks to identify a true discrepancy, compared with the 88 hours OpenAI said its agents spent generating the proofs.
- [15]
"OpenAI boast about how quickly they were able to generate this result, but that's only part of the process," says Alexander Bastounis at King's College London.
- [16]
OpenAI told New Scientist it is aware of the mismatch between the natural-language proof and the Lean code, that this does not mean either proof is invalid, and that it will rectify any errors in the natural-language proof as they are found.
- [17]
OpenAI will continue formalising the 722 maths papers it released this week, only some of which are accompanied by Lean proofs, which themselves have not been checked by hand.
- [18]
Two weeks of calendar time is about 336 hours, roughly 3.8 times the 88 agent hours OpenAI reported.
Sources
1 independent publisher whose own reporting we read for this story.
- newscientist.comOpenAI mistranslated mathematics into code for its Navier-Stokes proof
2 articles · October 8, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- Formal VerificationFollow
- AI for MathematicsFollow
- Navier-Stokes problemFollow
- Auto-formalisationFollow
Entities
- Fabian CircelliFollow
- OpenAIFollow
- ChatGPTFollow
- King's College LondonFollow
- Alexander BastounisFollow
- Anders HansenFollow
- Kevin BuzzardFollow
- LeanFollow
- University of CambridgeFollow