Skip to content
The AI-First Web

Claimed Navier-Stokes blowup proof leaves its numerical check outside Lean

The authors' repository shows what a machine verified and what it did not. Leaders can borrow that habit when judging AI work.

W
WebPulse Newsroom
AI-assisted · 4 min read
Share on X LinkedIn
Claimed Navier-Stokes blowup proof leaves its numerical check outside Lean
In brief
  • NYU's Tristan Buckmaster and Anthropic's Levent Alpöge claim an AI-aided proof of Navier-Stokes blowup, with a Lean formalization of about 600,000 lines.
  • Their repository says the certificate and the interval-arithmetic check are not part of the formalization and are not in it. The patched package was not rebuilt.
  • When AI delivers work, ask what a machine verified, what sits outside that check, and whether the verified version is the final one.

A result is only as strong as its fence

AI systems now produce results that few people can check by hand. The useful question is no longer whether the work looks convincing. It is which parts were verified by a machine and which parts were not.

A new claim in mathematics shows how that looks in practice. NYU professor Tristan Buckmaster and Anthropic's Levent Alpöge published a paper titled "Finite-time blow-up for the Navier–Stokes equations". It is 79 pages long, and the version is dated 20 November 2026. A Lean 4 formalization accompanies it. Their repository is unusually frank about where its checking stops.

What happened

The Navier-Stokes equations model how fluids move. "Blowup" means the equations predict a fluid speed that becomes infinite. Scientific American reports that OpenAI claimed a blowup proof in September. It satisfied the Clay Mathematics Institute's $1-million prize conditions, but many experts disliked how. Scientific American says that proof relied on an unrealistic, finely tuned stirring force, which many consider a loophole.

Buckmaster and Alpöge say their new work closes that loophole. Scientific American reports that Buckmaster posted it on Mastodon at 8:37 A.M. EST. He said the write-up was unpolished because, "after last time," they "couldn't risk waiting." He had earlier suspected OpenAI of trying to scoop him. Scientific American notes that OpenAI denied foul play.

This is a claim, not an accepted result. Scientific American calls the work AI-aided. The repository text does not describe how AI was used.

What the machine checked

Lean is a proof checker. A person writes a statement, and Lean confirms that each step follows from the one before. In the repository, the statement files define terms and state the theorems with the placeholder "sorry" where a proof would go. A separate file, Solution.lean, supplies the proofs from a library.

The supporting library is very big: the authors count roughly 2,270 files and 600,000 lines of code. They add that rebuilding all of it demands heavy memory and long run times. Each comparator file lists the theorems whose statements must match. It permits only three axioms: propext, Quot.sound and Classical.choice. Axioms are the starting assumptions every step rests on.

What sits outside the fence

The README lists the gaps itself. No data ships with the formalization, and the paper's own source files are also missing. The paper quotes a hash, a fingerprint, of a certificate, but the certificate itself is absent from the repository. The paper promises to release it.

The authors say a rigorous computation confirms that the certificate meets the conditions in Appendix B. That computation uses interval arithmetic, which tracks rounding error as a range, working to 128 bits of precision. It relies on the Arb library, accessed through FLINT. They say it is not part of the formalization and not in the repository.

One more detail matters. The repository applies a patch dated 20 November 2026 to the cell-layer statements and the library proofs that depend on them. It alters how one bound is weighted, lets one cell constant equal zero, and limits a cell's model harmonics to those that stay nonzero in that cell. The authors say the patched package was not rebuilt when the repository was assembled.

None of this says the proof is wrong. It says that today's machine-checked part and the full argument are different things. An outside reader has to take the rest on trust until the certificate and the computation are public.

Verification is a boundary, not a stamp

The lesson here is that a verified result has an edge, and the risk sits at that edge. Think of an audit report that covers the main ledger but notes that one subsidiary's books were not examined. The report is honest and useful, but a reader who skips the note overestimates what was checked.

The same applies when AI writes code, analysis or a security review for your organisation. As an illustration, not a finding about this proof, the convincing part is sometimes the part that was checked. The decisive part may be the piece that ran somewhere else, or changed after the last test.

Questions to put to your team

Ask what was verified by a machine, what was verified by a person, and what was not verified at all. Ask where the checked part ends and who holds the artefacts beyond it. Ask whether the version that was tested is the version being shipped. The patch note above is the same question in practice.

Ask what it costs to repeat the check. The authors say a full build is heavy on memory and time. If you cannot afford to rerun a check, you are trusting someone else's run.

A claim backed by a machine check is stronger than one without. It is strongest when you can see exactly where the check stops.

Produced by the WebPulse Newsroom with AI assistance from the original reporting credited below, and checked against that source by our editorial review. How we use AI.
Original reporting: Tristan Buckmaster (NYU) and Levent Alpöge (Anthropic).