groundy
Open Source

Verifying the Navier-Stokes Blow-Up Claim: What the Lean 4 Formalization Covers

The public Lean 4 formalization for the Navier-Stokes blow-up claim allows inspection of the formal layer, but the missing numerical certificate and unbuilt patch prevent full

Published 10 references
On this page10 sections

The practical finding is narrower than the headline: you can inspect and attempt to rebuild the public Lean 4 formal layer, but you cannot yet verify the complete blow-up argument from the public artifacts. The numerical certificate and the interval-arithmetic computation that checks it are absent, and the authors say the patched package was not rebuilt when the repository was assembled. For a citation, team discussion, or AI answer, “a public Lean 4 formalization accompanies the paper” is supportable; “Navier–Stokes is solved” or “the entire proof is machine-verified” is not.

That distinction also determines where to spend verification effort. A build is worth running, but a green build would answer only part of the question.

What shipped on 20 November 2026

As of 21 November 2026, the Alpöge and Buckmaster repository says it holds Finite-time blow-up for the Navier, Stokes equations by L. Alpöge and T. Buckmaster and its accompanying Lean 4 formalization. The repo-stated paper length is 79 pages, for the version of 20 November 2026. The repo-stated toolchain is Lean v4.33.1 with Mathlib pinned at the revision in lean/lakefile.toml.

The repository’s lean/README.md describes how the formal statements relate to Theorem 1.1, Theorem 7.1, Corollary 7.2 and Appendix B, including where the formal proofs differ from the paper. lean/NOTICE describes the contents of each statement file and what is proved. Those are the right entry points for checking the claim’s scope, but their correspondence to the paper is currently an assertion by the authors, not an independently confirmed mapping.

The stakes should not be blurred by earlier results with similar names. A recent review of Navier, Stokes blow-up mechanisms lists Tao’s 2016 theorem for an averaged three-dimensional Navier, Stokes equation. Blow-up for an averaged or model equation is a different category from the claim now attached to the 3D Navier, Stokes equations.

How the formal layer is wired

The repository separates statements from their proofs. According to its README, the statement files at the top of lean/ contain definitions and state the theorems with sorry in place of proofs. Solution.lean then proves those theorems using the library in lean/Breakdown/.

That arrangement is useful for verification because it makes the statement files comparatively small places to start reading. It also means a naive repository-wide search for sorry would be misleading: placeholders are expected in the statement files. The relevant question is whether the proving path through Solution.lean and Breakdown is complete, not whether the string appears anywhere in the checkout.

Each comparator*.json file pairs a statement file with Solution.lean, names the theorems whose statements must agree, and permits only three axioms: propext, Quot.sound and Classical.choice. This provides two specific checks:

  1. The proved statement must agree with the intended formal statement, rather than merely sharing a theorem name.
  2. The proof’s axiom dependencies must stay within the declared set.

For comparison, a Lean axiom-audit example from another formalization prints output such as depends on axioms: [propext, Quot.sound]. That is the kind of concrete dependency evidence a verifier should look for, rather than treating “formalized” as synonymous with “axiom-free.”

There is a tooling detail to resolve before relying on the JSON files. A paper on a formally verified mathematical-finance library notes that lake comparator has been available only since Lean v4.35.0. The Navier, Stokes repository pins v4.33.1. This does not show that its comparators are ineffective, but it does mean a verifier should identify what actually reads and enforces these files instead of assuming that lake build automatically does so.

What it costs to run the build

The documented procedure, from lean/, is:

Terminal window
lake exe cache get
lake build

The repo-stated library size is about 2,270 files and 600,000 lines, and the README says a full build needs “a great deal of memory and time.” Those figures are supplied by the authors, not independently measured, and the repository does not provide a hardware or runtime budget. Plan for a substantial verification job rather than a quick CI check.

The trust model is also worth stating precisely. In a reference Lean 4 formalization, the trusted base consists of the Lean 4 kernel, which checks proof terms; Mathlib, which supplies mathematical infrastructure; and Lake, which orchestrates compilation. That paper also notes that the absence of sorry and admit can be checked mechanically. Applying the same reasoning here, a successful build would re-check the package’s Lean proofs against that software stack. It would not independently validate the authors’ mathematical interpretation, the paper-to-statement correspondence, or an external numerical artifact.

A build failure would need equally careful handling. It could establish that the inspected revision did not build in the reported environment; it would not, by itself, disprove the mathematics. Record the pinned toolchain and the exact failure before drawing even that narrower conclusion.

CheckWhat the public artifact suppliesWhat a successful check would supportWhat it still would not settle
Lean buildPinned Lean/Mathlib package, Solution.lean, Breakdown library and build commandsThe checked Lean proof terms compile in that environmentPaper-to-statement fidelity or numerical certification
Comparator and axiom auditcomparator*.json files, named theorem correspondences and three permitted axiomsStatement agreement and restricted axiom dependencies, if the comparator is actually enforcedWhether either statement faithfully expresses the paper’s theorem
README/NOTICE reviewAuthors’ mapping to Theorem 1.1, Theorem 7.1, Corollary 7.2 and Appendix BA documented route for manual comparisonIndependent confirmation of that mapping
Certificate verificationA hash in the paper and a description of the intended computationNo public end-to-end check is currently available from the repositoryWhether the certificate exists as described and satisfies Appendix B

A green build cannot prove the statement means what you think it means

Mechanical checks are strongest when the question is already formal. They are weaker at the boundary between prose mathematics and Lean definitions.

The mathematical-finance formalization paper puts the problem directly: “Two failure modes pass every mechanical gate. The first is vacuity.” A theorem can be proved correctly while its hypotheses make it inapplicable, or while its formal statement says less than an informal summary suggests.

A separate rate, distortion formalization report supplies a concrete alignment example. Its authors say they checked definitions and theorem statements against the intended mathematics before using AI assistance, after the AI initially used a weaker achievability notion. Lean could still check a proof of such a statement; the problem would be what had been proved, not whether the kernel had accepted the proof term.

For the Navier, Stokes repository, this makes manual comparison of hypotheses, definitions and conclusions part of verification, not an optional scholarly flourish. The README’s mapping is a guide for that work, not a substitute for it. A repository audit is not an independent expert assessment of the mathematics, and none is offered here.

Caution is warranted by the field’s history without implying that this claim is wrong. A 2012 singularity model was withdrawn “for major revision and correction of conclusions for Navier-Stokes flows,” and a 2018 finite-time blow-up claim for a Navier-Stokes model is marked withdrawn. Those precedents concern other papers and models. Their relevance here is procedural: check the exact claim and its supporting artifacts before repeating a verdict.

The missing certificate changes what “verified” can mean

The repository is unusually explicit about the gap. Its limits section states: “The formalization contains no data.” The certificate whose hash appears in the paper is not included, although the paper says it will be released.

The computation that checks whether the certificate satisfies Appendix B is absent too. The repo-stated method is rigorous interval arithmetic with 128 bits of precision, using Arb through FLINT. It is neither part of the Lean formalization nor included separately in the repository.

This is more than a missing convenience file. A hash can identify a particular artifact, but it cannot supply the artifact’s contents or let a reader rerun its validation. Until the certificate and the relevant computation are available, public verification stops at the formal layer. Releasing the certificate later would add a new checkable artifact; it would not retroactively make today’s build an end-to-end verification.

The surrounding numerical literature explains why that distinction matters. Work on quantitative classification of potential Navier, Stokes singularities describes Hou’s numerical candidate for a singular 3D solution as motivation for further investigation. Numerical evidence can motivate serious mathematical work while still requiring rigorous certification before it supports a theorem.

The unbuilt patch is a reproducibility limit, not a verdict

The repository says a patch dated 20 November 2026 changed the cell-layer statements and dependent library proofs. Specifically, the README says one bound’s weight becomes $(|m|+\tfrac12)^2$ instead of $m^2+\tfrac14$, one cell constant may be zero, and the harmonics of the model in a cell are restricted to those that do not vanish there. Appendix B states the conditions in this patched form.

It then says: “The patched package was not rebuilt when this repository was assembled.”

That does not establish that the current source fails to build. It does establish that the public evidence supplied here contains no completed build of the final patched state. Running the documented commands therefore has real value: it checks a state the authors say they did not rebuild when assembling the repository. Even success would leave the certificate and statement-alignment limits intact.

Keep November’s artifact apart from September’s AI stories

The November repository is a different event from September 2026’s Lean-related news. According to the rate, distortion paper’s account, an internal OpenAI model generated a 166-page proof of Statements C and D from the Clay Mathematics Institute’s millennium-prize announcement and verified it in Lean that September. That is not a description of the November Alpöge and Buckmaster repository, and it should not be used as evidence about how this formalization was produced.

Buckmaster also posted on 8 September about “the sheer magnitude of what frontier models can now do” amid the earlier community controversy. Whatever bearing that discussion has on the September episode, it does not document LLM involvement in the November release.

For a citation now, the defensible formulation is:

Alpöge and Buckmaster have published a paper accompanied by a public Lean 4 formalization. The repository supports rebuilding and auditing the formal layer, but its asserted correspondence to the paper has not been independently confirmed here, the patched package was not rebuilt before assembly, and the numerical certificate and its interval-arithmetic verification have not been released.

“Formalized” describes the existence of Lean statements and proofs. “Built” should be reserved for a build actually completed in a specified environment. “Fully verified” and “solved” require more than the public artifact currently establishes.

A checklist for this and future machine-checkable claims

  1. Pin the artifact. Record the repository revision and the Lean/Mathlib versions before building.
  2. Read the statements, not just the theorem names. Compare definitions, hypotheses and conclusions with the paper using lean/README.md and lean/NOTICE as guides.
  3. Trace the proving path. Inspect how Solution.lean uses Breakdown; do not treat expected sorry placeholders in statement files as proof of incompleteness on their own.
  4. Identify the comparator enforcement mechanism. The repository’s Lean v4.33.1 pin predates the lake comparator availability reported for v4.35.0, so confirm what consumes each comparator*.json.
  5. Audit axioms explicitly. Check that dependencies stay within propext, Quot.sound and Classical.choice.
  6. Run the documented build. Use lake exe cache get followed by lake build, allowing for the repo-stated memory and time burden.
  7. List artifacts outside the Lean build. Here that list decisively includes the numerical certificate and its Arb/FLINT interval-arithmetic verification, neither of which is public in the repository.

The durable lesson is that a kernel-checked proof and a rigorous numerical certificate can be separate links in one argument. Verification language should identify which links were actually checked.

Frequently Asked Questions

Which axioms are permitted in the proof according to the comparator files?

Each comparator*.json file pairs a statement file with Solution.lean, names the theorems whose statements must agree, and permits only three axioms: propext, Quot.sound and Classical.choice.

References

Follow the links in the article for context. The supporting material is collected here for further reading.

  1. Alpöge and Buckmaster repositorygithub.comAccessed
  2. Recent review of Navier, Stokes blow-up mechanismsarxiv.orgAccessed
  3. Lean axiom-audit example from another formalizationarxiv.orgAccessed
  4. Reference Lean 4 formalizationarxiv.orgAccessed
  5. Rate, distortion formalization reportarxiv.orgAccessed
  6. 2012 singularity modelarxiv.orgAccessed
  7. Buckmaster Mastodon postmastodon.socialAccessed

Join the discussion

Share a useful perspective or ask a question about this article.

Discussion guidelinesComments privacy