Cook's write-up, titled 'The Formal Method Revolution,' explicitly argues that the delivery format is the real headline, not the mathematical result. He emphasizes that shipping a Lean 4 proof means anyone can verify end-to-end with `lake build` — no anonymous referees, no two-year journal cycle, no need to trust a single human reviewer.
By submitting the piece with a title framing that centers the Lean 4 formal proof rather than the Navier-Stokes result itself, the submitter foregrounds verifiability-as-delivery-format as the newsworthy angle. The 151-point score suggests the HN audience agreed the format was the story.
Cook situates the release inside a longer arc: Lean 4's rise from a 2013 Microsoft Research project, mathlib crossing a million lines of formalized code, Kevin Buzzard's Xena Project, Terence Tao's live-formalization streams, and the Liquid Tensor Experiment. His framing — 'OpenAI just landed a commercial plane on it' — credits the volunteer mathlib community for building the runway that made this delivery possible.
The editorial explicitly pushes back on the naive 'AI is doing math now' reading, noting AlphaProof and DeepMind's 2024 IMO work already established that. The new signal here is delivery format and verifiability — a direct response to the legitimate criticism that AI-generated technical content is hard to trust because you can't easily check it.
OpenAI's release around the Navier-Stokes equations landed with something the field has been waiting on for a decade: a full Lean 4 formal proof shipped alongside the paper. John D. Cook's write-up on it — titled, tellingly, *The Formal Method Revolution* — flags the delivery format as the real headline, not the mathematical result itself. The proof is machine-checkable. Anyone with `lake build` and enough patience can verify it end-to-end without trusting a single human reviewer, an anonymous referee pool, or a two-year journal cycle.
Navier-Stokes needs no introduction to anyone who has taken a fluid-dynamics class, but for context: proving existence and smoothness of solutions in three dimensions is one of the seven Clay Millennium Prize problems, with a $1M bounty attached since 2000. Progress has been steady but not sensational. What's sensational here isn't necessarily that OpenAI cracked the whole problem — the write-up is careful about the scope of the result — but that whatever they *did* prove was delivered in a form that removes the human referee from the trust chain.
Lean 4, the theorem prover backing the proof, has gone from a Microsoft Research curiosity in 2013 to the default choice for large-scale formalization projects in about seven years. The mathlib community — a volunteer-run library of formalized mathematics — crossed a million lines of Lean code sometime last year. Kevin Buzzard's Xena Project at Imperial, Terence Tao's live-formalization streams, and the Liquid Tensor Experiment (which formalized a key theorem of Peter Scholze's in 18 months) built the runway. OpenAI just landed a commercial plane on it.
The naive read is "AI is doing math now." That's not new — AlphaProof and DeepMind's IMO work made that point in 2024. The new signal is about delivery format and verifiability, and it cuts against one of the more legitimate criticisms of AI-generated technical content: that you can't tell if it's right without doing the work yourself.
A Lean 4 proof is different. The kernel — a small, auditable piece of code that checks whether a proof is valid — is the entire trust boundary. You don't have to trust OpenAI. You don't have to trust the model. You don't have to trust the mathlib maintainers. You have to trust the ~few thousand lines of the Lean kernel, which has been scrutinized by adversarial mathematicians for years. This is roughly the same trust model that lets people use `seL4` in avionics: the kernel is small enough that humans can actually verify it, and everything above it is verified against the kernel.
Compare this to the alternative. When DeepMind announced AlphaProof solved four of six IMO problems, the community had to take the solutions largely on faith or reconstruct them by hand. When large models write mathematical arguments in natural language, referees spend weeks chasing hallucinated citations and skipped steps. The Lean 4 format skips that entire loop. If it type-checks, it's correct — modulo the axioms, which are themselves auditable.
The community reaction on Hacker News (151 points and climbing) has been split between "this changes everything" and "this is what we've been building toward for a decade — glad someone in industry finally noticed." Both are right. Terence Tao has been arguing since at least 2023 that AI + proof assistants is a genuinely new phase of mathematics, one where the bottleneck stops being individual genius and starts being collaborative infrastructure. This release is a data point that Tao's bet is correct, and that the timeline is faster than most people assumed.
There's also a subtler point about incentive alignment. A formal proof is a costly signal. It is much harder to fake than a benchmark score, much harder to cherry-pick than a demo, and much harder to walk back than a blog post. When a lab ships one, they are staking their reputation on the exact object they released. This is close to the opposite of the current AI-eval discourse, where every leaderboard is suspect and every claim needs a footnote about training-set contamination.
Most readers of this piece aren't going to write a Navier-Stokes proof in Lean 4 next week. But the tooling that made this release possible is the same tooling that's slowly seeping into software correctness work, and that's where practitioners should be paying attention.
The playbook — write a specification, then have an AI-assisted tactic search generate a proof against it — generalizes directly to program verification. Projects like Verus (Rust), F* (used at Microsoft for portions of Azure), and CompCert (a formally verified C compiler that Airbus uses in flight-control software) have been quietly demonstrating that formal verification of *code*, not just math, is tractable when the tooling is good enough. Lean 4's success in mathematics has been feeding back into these projects: better elaboration, better metaprogramming, better tactic combinators.
The practical implication is that the cost curve for formal verification is bending. Five years ago, verifying a small parser might have taken a PhD-year of effort. Today, with LLM-assisted proof generation and mature tactic libraries, it's a week for a competent engineer with some training. In another five years, if the current trajectory holds, it will be a day. That doesn't mean everyone will formally verify their CRUD app — the economics still don't work — but it does mean that the small set of things that genuinely need to be right (crypto primitives, consensus protocols, compilers, hypervisors, safety-critical control systems) will increasingly be shipped with proofs attached, and the market will start to notice which ones aren't.
If you want to actually engage with this now: install Lean 4, work through *Mathematics in Lean* (free, online, ~40 hours to get productive), and try formalizing a small algorithm you already trust — a sort, a hash-map invariant, a queue's FIFO property. It's the fastest way to develop an intuition for what formal methods can and can't do, and to build the mental model you'll need when your CTO starts asking whether the payments service can ship with a proof attached.
The near-term question isn't whether formal methods go mainstream — that trajectory looks locked in — but who owns the toolchain when they do. Lean 4 is open source (Apache 2.0), mathlib is community-run, and the underlying research is public. But the AI-assisted proof-generation layer is exactly the kind of thing labs are going to want to keep proprietary. Watch for the fight over whether "AI-assisted formalization" is a service you rent from OpenAI, or a workflow you run locally with open weights. That's the interesting business story hiding underneath the mathematical one, and it will matter far more to working developers than the Millennium Prize ever will.
They estimated $40M of agent costs (it was a large fleet of them). Using the number in the post its closer to ~880,000 hours × $150/hour = $132 million for the human case. Still an amazing feat not quite "four orders of magnitude". The comparison is obviously pointless because coordin
People seem to be talking about anything except the actual results with this particular announcement.Its still astonishing that any sort of generalized computer program can solve a problem of this magnitude, and we have witnessed it happening in real time. I'd be curious to see if the new model
IMO the "forty hours per page" rule is not up to date, and more a consequence of lacking proof automation in 2005. From what I understand about Lean, this has been one of the things that they have put a lot of effort into improving, making proof mechanization more palatable to the mathemat
How do you know that it's formalizing what you think it's formalizing? If your Lean 4 has a bug, won't you be proving something other than what you thought?
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
It's kinda funny to realize that Lean is apparently so slow that for Fermat's Last Theorem proof verification runs only 1 order of magnitude faster than agents could generate the Lean code (15h verification with 230GB of RAM vs 11 days to generate it).To what extent can you optimize Lean?