Did OpenAI Really Solve Navier-Stokes? Verifying the Disputed Proof

On September 8, 2026, OpenAI announced that roughly 10,000 of its AI agents, running for about 88 hours, had produced a proof resolving a variant of the Navier-Stokes existence and smoothness problem, one of the seven Clay Mathematics Institute Millennium Prize Problems and the only one of the seven built entirely around a set of equations engineers use every day [1][5]. Within hours the announcement was overshadowed by a public dispute with an NYU mathematician who says the effort was triggered by, and possibly trained on, his own unpublished work, a story that spread from tech press to mainstream outlets within a single news cycle [9][20].

This is a different kind of story than the one Miraflow covered a few weeks earlier, when an unreleased OpenAI model solved ten decades-old problems in group theory, complexity, and cryptography and shipped every one of them as a zero-gap, publicly buildable Lean 4 proof that a Fields Medalist personally reviewed and endorsed [25]. That post is not repeated here. What matters for this one is the contrast: the same lab, five weeks apart, produced two very differently received claims, and understanding exactly why one sailed through with cautious praise while the other ignited a credit war is a genuinely useful lesson in how to evaluate any frontier AI research claim, not just this one.

This post walks through what the Navier-Stokes problem actually asks mathematically, what OpenAI's agents reportedly did, why named mathematicians are disputing the result on at least three separate and distinct grounds, and how you can apply the same verification habits to the next headline like this one, whichever lab it comes from.

Step 1: What the Navier-Stokes Millennium Prize Problem Actually Asks

Strip away the headlines and the Navier-Stokes problem is a question about a single set of partial differential equations that describe how a fluid's velocity changes over time. In the formulation Charles Fefferman wrote for the Clay Mathematics Institute in 2000, the equations for an incompressible fluid filling three-dimensional space are

∂u/∂t + (u·∇)u = ν∆u − ∇p + f, with ∇·u = 0,

where u(x,t) is the fluid's velocity, p(x,t) is pressure, ν is viscosity, and f is any externally applied force such as gravity [3]. The first equation is just Newton's second law, f = ma, applied to a small parcel of fluid. The second equation says the fluid cannot compress. Given a smooth, well-behaved starting velocity field, the question is deceptively simple to state and has resisted a full answer since the equations were first written down by Claude-Louis Navier and George Gabriel Stokes in the 19th century [2]: do smooth, physically reasonable solutions to these equations keep existing forever, or can a fluid that starts out perfectly smooth develop a genuine mathematical singularity, a point where velocity becomes literally infinite, in a finite amount of time?

To give solvers, in Fefferman's own words, "reasonable leeway... while retaining the heart of the problem," the official Clay statement does not demand one single theorem. It accepts a proof of any one of four alternatives [3]:

• (A) Prove that smooth, physically reasonable solutions always exist for all time on unbounded space R³, for any smooth initial data, with no external force.
• (B) Prove the same existence-and-smoothness result on the periodic case, a fluid that repeats itself on a 3D torus R³/Z³, again with no external force.
• (C) Disprove it: exhibit a smooth initial condition and a smooth, appropriately decaying external force on R³ for which no smooth global solution exists, a finite-time blowup.
• (D) The same disproof, but on the periodic torus R³/Z³ instead of unbounded space.

That last detail, that (C) and (D) explicitly permit a smooth external force while (A) and (B) explicitly require the force to be zero, turns out to be the single most important sentence in this entire controversy, and it is worth holding onto before the next section.

The reason this problem has stayed open for more than a century of serious attention is not a lack of trying. Jean Leray proved in 1934 that a weaker, less demanding kind of solution, a "weak solution" built by relaxing exactly how strictly the equations have to hold, always exists in 3D, but nobody has shown those weak solutions are unique or that they stay smooth [3]. Luis Caffarelli, Robert Kohn, and Louise Nirenberg proved in 1982 that any potential singularity has to be confined to an extremely small set in space and time, a partial regularity result still considered the best general theorem on the subject more than forty years later [3]. For the closely related, inviscid Euler equations, the Beale-Kato-Majda criterion shows that if a solution does blow up, the vorticity, roughly speaking how fast the fluid is spinning locally, has to blow up too, in a very specific quantitative way [3]. None of these results, individually or together, settle the question, and Fefferman's own closing line in the official problem statement is blunt about why: "standard methods from PDE appear inadequate to settle the problem. Instead, we probably need some deep, new ideas" [3].

It is also worth being explicit about why you cannot just run a computer simulation and look. Fefferman notes that "many numerical computations appear to exhibit blowup" for the related Euler equations, "but the extreme numerical instability of the equations makes it very hard to draw reliable conclusions" [3]. A finite-difference or spectral simulation has finite resolution. As a solution approaches a genuine singularity, the true velocity field is developing structure at arbitrarily small scales, and a discretized simulation simply cannot represent that, so a simulation that looks like it is blowing up could just as easily be a numerical artifact of insufficient resolution, not real blowup. This is the deep reason the Millennium Prize exists at all: it rewards a rigorous mathematical proof precisely because numerical evidence, however dramatic looking, cannot substitute for one.

The Clay Mathematics Institute set aside a $7 million prize fund across its seven Millennium Prize Problems, $1 million per problem [4]. In the roughly quarter-century since the list was announced, exactly one of the seven has been resolved to the Institute's satisfaction: Grigori Perelman's 2003 proof of the Poincaré conjecture, which Perelman famously declined to accept payment for [4]. Navier-Stokes existence and smoothness has, until this announcement, remained fully open, still listed as unsolved on the Institute's own page at the time this post was written [17].

Step 2: What OpenAI Actually Announced on September 8

OpenAI's own account, published the same day as the controversy broke, describes an internal model, described in coverage as "significantly more capable" than the publicly released GPT-6 Astra rather than Astra itself, that was set loose on the problem starting September 1, 2026 [23][1]. Roughly 10,000 agent instances worked the problem concurrently, exchanging about 2.7 million messages and consuming on the order of 130 billion output tokens, reaching a candidate result by September 5, about 88 hours after the effort began [6]. A further 17 hours were then spent formalizing and machine-checking the result in the Lean 4 proof assistant, this stage specifically using the publicly released GPT-6 Astra model, the same flagship model OpenAI had shipped with benchmark and cybersecurity claims of its own just five days earlier, on September 3 [6][26].

The compute bill depends heavily on what gets counted, and different outlets have reported meaningfully different figures, which is itself worth noticing rather than glossing over. OpenAI's chief research officer Mark Chen described the total cost as roughly 1,000 times what the company's earlier, less contested math results typically run, putting it "in the ballpark of" millions of dollars [9]. A separate accounting citing 300 billion total output tokens, likely including exploratory runs and the formalization pass beyond the headline 130 billion figure, put the figure closer to $22.5 million [10]. That is the exact same "cost of the final successful run versus cost of the entire search" ambiguity that showed up around August's much smaller $2,000-per-problem figure, just two orders of magnitude larger, and it is a pattern worth watching for in every AI research cost claim, not only this one.

What the agents actually claim to have proven is narrower than the headlines suggest, and the precision matters. OpenAI's own framing, and the published GitHub repository, state that the result establishes Clay statements (C) and (D): a finite-time blowup for the forced Navier-Stokes equations on both R³ and the periodic torus T³, plus a separate, unforced finite-time blowup for the 3D incompressible Euler equations [7][8]. The Euler equations, note, are not themselves a Clay Millennium Problem, though Fefferman's own statement calls the analogous questions for Euler "also open and very important" [3].

OpenAI explicitly said it does not intend to claim the $1 million prize [6][21]. The 2.7 million-message figure and the general shape of the 88-hour timeline were independently reported across several outlets covering the announcement, not just OpenAI's own framing of it [22]. The Clay Mathematics Institute, for its part, has made no move to accept the result. Institute president Martin Bridson has said any formal evaluation will be "deliberately unhurried" and "absolutely rigorous," and the problem remained listed as unsolved on the Institute's own site as coverage of the dispute continued [17]. Given everything covered in the rest of this post, that caution reads less like institutional slowness and more like exactly the right call.

If you want to visualize what a 10,000-agent parallel search over three and a half days actually looks like rather than just reading the numbers, here is a video generation prompt built around that idea, written for a Wan-style video model.

An overhead view of a vast dark server hall dissolves into a stylized abstract visualization: thousands of small glowing blue threads spread across a black void, each one a thin line searching and branching through an invisible three-dimensional maze, representing parallel reasoning paths. Over eight seconds the threads multiply and pulse faster, most dead-ending and fading to gray, until one single golden thread breaks through the noise, straightens, and connects in a clean unbroken line from one edge of the frame to the other, locking into place with a soft flash of light. A small stopwatch-style ring at the frame's edge fills clockwise throughout, completing exactly as the golden thread locks. Cool blue and dark charcoal palette shifting to warm gold only on the successful thread, smooth continuous camera drift inward, no readable text overlays, no logos, no people, clean minimal sci-fi visualization style, no flicker artifacts or garbled shapes.

Step 3: A Tale of Two OpenAI Math Claims, Five Weeks Apart

It would be easy to read this as "OpenAI's math claims are getting sloppier." The more accurate reading, once you check the actual facts, is more interesting and more useful.

Both releases ship a public, independently buildable Lean formalization. August's ten-problem release lives at github.com/openai/ten-proofs; September's Navier-Stokes and Euler release lives at a separate repository, github.com/openai/NavierStokesAndEuler, built against Lean 4.34.0-rc2 with standard lake exe cache get and lake build instructions [7][8]. If your mental model of this controversy is "the August proofs were machine-checked and this one is just a prose claim," that model is wrong, and it is worth correcting explicitly, because getting this specific detail right is exactly the kind of due diligence this whole post is arguing for.

What actually differs between the two releases is more subtle than presence or absence of formal verification, and it splits into three real, distinct gaps.

The first is review time. August's proofs sat in front of the mathematical community, and specifically in front of Fields Medalist Sir Timothy Gowers, for enough time that he was willing to say he would recommend at least one result for publication in a top journal without hesitation [25]. September's result was disputed within hours of publication, before any comparable outside mathematical review had a chance to happen at all [9].

The second is what a compiling Lean file actually proves versus what a reader assumes it proves. A zero-sorry compile confirms that every logical step in the formalized statement follows correctly. It says nothing about whether that formalized statement is an honest, non-gerrymandered translation of the informal question people actually care about. This is precisely why the "forced" qualifier in Step 5 below matters so much: a perfectly verified, zero-gap Lean proof of a narrower or easier statement than the one the reader assumes is being answered is a subtler and more common failure mode than an outright error, and it is one formal verification alone cannot catch.

The third gap, and the one that generated the most public attention, has nothing to do with mathematics or formal verification at all: a credit and provenance dispute that Steps 4 and 6 cover in detail.

Step 4: The Provenance Dispute, In the Mathematicians' Own Words

The origin of the specific technique behind September's result predates OpenAI's involvement entirely. Mathematicians Diego Córdoba and Luis Martínez-Zoroa, joined by Fan Zheng on some of the work, spent several years developing a construction for forced blowup, building a solution in stages by repeatedly layering small, high-frequency corrections onto a background flow designed to become progressively more unstable [15]. Their published result proved finite-time blowup for a "hypodissipative" variant of Navier-Stokes using a rough, non-smooth external force [15].

NYU mathematician Tristan Buckmaster and Levent Alpöge, a mathematician affiliated with Anthropic, spent close to a year, working as what Buckmaster describes as "a purely personal collaboration, free of any institutional agreements," pushing that Córdoba-Martínez-Zoroa construction from rough forcing to smooth forcing, and extending it from the porous-medium equation to the Boussinesq system and to the unforced 3D incompressible Euler equations, using Anthropic's Claude and OpenAI's own Codex and GPT-5.6 Sol models heavily throughout [12]. Progress was slow for most of that year, then accelerated sharply: they reached their Boussinesq and Euler blowup results on August 15, 2026, verified in Lean a week later on August 22, and eventually made all three of their results public as separate preprints with accompanying Lean formalizations, including a paper extending the original Córdoba-Martínez-Zoroa construction for the incompressible porous medium equation [12][14]. Terence Tao reviewed the work publicly on his blog on September 7, calling it heavily AI-assisted, noting the underlying method has "a high likelihood of also extending to Navier-Stokes as well," and separately remarking that understanding the mathematical insight behind a result matters more than the headline of solving it [13].

Buckmaster published a detailed public statement on September 8 laying out, in his own words, exactly what happened next [12]. On September 3, with rumors already circulating that a major open problem had been resolved, he emailed a mathematician at OpenAI directly, disclosing that he and Alpöge had unpublished results and explicitly stating the work was a private collaboration, not an institutional one. Over the following days, requests to talk moved from "the following week" to "any point today," and on Sunday, September 6, Sébastien Bubeck, who leads OpenAI's math team, joined the call. Buckmaster was told an internal model had produced a roughly 100-page proof of forced blowup, stated as "existence of forced blowup in R3 and T3," with the model reportedly told to target "option c and d in Fefferman," the exact statements defined in Step 1 above [12]. Buckmaster writes that hearing "forced" specifically was "a bright red flag" precisely because the route through a smooth external force was the one he and Alpöge had "quietly chosen to attack," building on a program that "almost nobody else" was working on [12][10].

Two specific claims sit at the center of the dispute. First, Buckmaster says he was initially told "very little human input" had gone into the result, before it emerged over the course of the call that an entire team had been working the problem, that multiple approaches had been tried in parallel, and that the exact prompt he had been shown was itself written by prompting OpenAI's own Codex model [12]. Second, and more seriously, Buckmaster asked directly whether the model had been trained on, or had access to, the Codex sessions where he and Alpöge had been storing drafts throughout the entire project. He says he was told the model "did not look up user data," and when he asked again specifically about training, he did not get an answer [12][11].

Buckmaster also describes being offered two publication arrangements, one where OpenAI would publish its result the day after his, and a second where he alone would write up the Navier-Stokes result crediting an internal OpenAI model, in both cases with Bubeck reportedly pushing to have Alpöge left off authorship because he works at Anthropic [12]. Buckmaster says that when he indicated he would go public about the conversation, the reply was "Why would you ruin your career?", and when he asked why, "If you don't want me to be nice, then I don't have to be nice" [12]. He is careful to frame what he does and does not know: "I have not seen OpenAI's proof. I do not know what their model did, or how. I do not know whether our data was used. I am not accusing anyone of anything. I am stating what I was told, when, and what was proposed to me" [12].

OpenAI's Bubeck disputed the characterization, stating "we did not use their prompts or proofs to prompt our models or direct our agents," and that neither researchers nor agents "did not see any of their work until they were released publicly," while separately saying OpenAI "recognizes the priority of Levent Alpöge and Tristan Buckmaster's work" [11]. Diego Córdoba, whose original method sits underneath all of this, told reporters he was caught off guard by how fast the field moved: "We're a little bit in shock... if it's done, that will be a big surprise for us" [19]. Fellow PDE researcher Luis Silvestre summed up the mood in the field bluntly: "Yesterday and today are crazy days... we're all, in the community, discussing the implications of this" [19].

Step 5: Why "Forced" Is the Word That Actually Matters

Return to Step 1's four Clay statements for a moment, because the single technical distinction driving most of this dispute is easy to state precisely. Statements (A) and (B), existence and smoothness with no external force, are what most working mathematicians and most non-specialist readers mean when they say "the Navier-Stokes problem." Statements (C) and (D), breakdown allowing a smooth external force, are officially, explicitly Clay-eligible too, exactly as written in Fefferman's own statement, but they describe a meaningfully different and, by consensus among mathematicians close to this problem, meaningfully easier question [17].

The intuition is not complicated once it is stated plainly. A fluid governed by the unforced equations only has whatever energy it started with; viscosity constantly drains that energy away, and proving the fluid can nonetheless organize itself into an actual singularity, entirely on its own, with nothing pushing it, is the version of the question that has resisted a proof for over a century. Add a smooth external force back into the equations and you gain a second lever entirely: you can shape the force itself to continuously pump energy in, in exactly the right way, to help drive the construction toward blowup. Córdoba and Martínez-Zoroa's original breakthrough used precisely this lever, with a rough, not-yet-smooth forcing term [15]; Buckmaster and Alpöge's contribution was pushing that same lever to work with a fully smooth force satisfying Fefferman's technical decay conditions [12]. Both are genuine, hard, publishable mathematics. Neither is the harder question most people mean when they say "solved Navier-Stokes."

This is exactly the gap flagged in Implicator's coverage of the Clay Institute's reaction: "while Charles Fefferman's official problem formulation permits smooth forcing in statements C and D, most working mathematicians exclude this case from the question they actually care about solving," and, critically, "there is no public evidence that the construction works without it" [17]. OpenAI's own published result is honest about scope on this exact point, its GitHub repository explicitly frames the Navier-Stokes result as establishing statements (C) and (D) specifically, not (A) or (B) [8]. The unforced 3D Euler result the same repository contains is arguably the more mathematically significant of the two results in the release, precisely because it required no forcing lever at all, but the Euler equations are not on the Clay Institute's prize list [3].

None of this makes OpenAI's technical claim false. It makes the plain-English framing in most headline coverage, "OpenAI solved Navier-Stokes," meaningfully imprecise in a way that matters if you are trying to actually understand what changed in the field this week versus what did not, a gap one outlet summarized bluntly as OpenAI's agents having "solved the wrong problem," with the harder, unforced one still fully open [16].

Step 6: The Data Contamination Question, and Why Outsiders Cannot Fully Resolve It

Set the priority dispute aside and there is a second, distinct kind of skepticism worth separating out clearly: the question of whether OpenAI's models had privileged, indirect access to Buckmaster and Alpöge's unpublished intermediate work, not through anyone deliberately leaking it, but through the ordinary mechanics of how frontier labs use product usage data to improve their models.

Buckmaster's account is specific and narrow on this point, and it is worth reading his exact framing rather than a paraphrase, because the distinction he draws matters. He was told the model "did not look up user data" when he asked whether it had real-time access to his Codex sessions, a direct-access question, and he accepts that answer at face value [12]. What he says he could not get answered was the separate, training-time question: whether de-identified data from those sessions, footing a bill for OpenAI's own tools that he paid out of his own research funds, had at any point flowed into a training or fine-tuning pipeline for the model that then, within days, independently rediscovered the exact same forced-blowup approach [12][9].

This distinction, real-time lookup versus historical training influence, is exactly the kind of nuance that a benchmark-contamination controversy in machine learning usually turns on too, and it generalizes well beyond this one dispute. A model that scores suspiciously well on a benchmark is rarely caught looking the answer up live; it is caught because the answer, or something close enough to it, was present somewhere in its training corpus, often via a route nobody explicitly intended, a scraped forum post, a cached webpage, or in this case, potentially, usage logs from a paying customer's own API sessions. Outsiders essentially never have the access needed to rule this out directly. What they can do, and what Buckmaster explicitly did here, is document the exact question asked, the exact answer given, and the gap between the two, publicly and with dates attached, so that the record exists independent of either party's later characterization of events.

Terence Tao's broader public comments on this controversy, made separately from his review of Buckmaster and Alpöge's actual mathematics, frame the stakes at the level of the research ecosystem rather than any single dispute. He warned that "prematurely solving the problem by purely AI-powered methods, particularly without full transparency into the solution process, can contaminate this process," arguing that "human-directed efforts to solve these problems tend to spur further development of the field" in ways a closed, high-compute sprint by a single company does not [18]. In a separate remark he compared labs treating famous open problems purely as marketing proof points to "the indiscriminate strip-mining of open problems for solutions," warning it "may destroy the ecosystem from which the next generation of mathematical techniques, problems, and practitioners would have developed" [11]. Notably, this is the same mathematician who publicly praised Buckmaster and Alpöge's own heavily AI-assisted work days earlier [13], which makes his concern legible as being about transparency and process, not about AI assistance in mathematics itself.

A general heuristic worth having in your toolkit, for this dispute and the next one, is to look for near-duplicate structure between a claimed "independent" result and any prior text you can access, rather than relying on a lab's own characterization of independence. Here is a simple, illustrative version of that idea using shingled n-gram overlap, a standard, cheap first-pass technique for flagging suspicious textual similarity before deeper investigation.

python
/code
# A simple shingled n-gram overlap heuristic for flagging suspicious
# textual similarity between a claimed "independent" result and any
# prior draft text you have access to. This is a cheap FIRST-PASS
# screening tool, not proof of contamination on its own, real cases
# need follow-up investigation and, ideally, access neither outside
# readers nor most researchers actually have.

import re

def shingles(text: str, k: int = 8) -> set:
    """Break text into overlapping k-word shingles after normalizing
    whitespace and case, a standard first step in near-duplicate
    detection pipelines."""
    words = re.findall(r"[a-z0-9]+", text.lower())
    return {
        " ".join(words[i:i + k])
        for i in range(len(words) - k + 1)
    }

def jaccard_overlap(text_a: str, text_b: str, k: int = 8) -> float:
    shingles_a = shingles(text_a, k)
    shingles_b = shingles(text_b, k)
    if not shingles_a or not shingles_b:
        return 0.0
    intersection = len(shingles_a & shingles_b)
    union = len(shingles_a | shingles_b)
    return intersection / union

if __name__ == "__main__":
    draft_text = """paste the private draft or unpublished proof sketch here"""
    published_text = """paste the newly published, claimed-independent result here"""

    score = jaccard_overlap(draft_text, published_text, k=8)
    print(f"8-gram Jaccard overlap: {score:.4f}")

    if score > 0.15:
        print("Flag: unusually high structural overlap, worth a closer,")
        print("human review of matching passages before drawing conclusions.")
    else:
        print("No strong overlap signal from this heuristic alone.")
    # Remember: a LOW score here does not prove independence, and a
    # nonzero score does not prove copying, shared mathematical notation
    # and standard phrasing produce overlap on their own. Treat this as
    # a triage signal, not a verdict.

Step 7: How to Actually Verify a Claim Like This Yourself

The single most useful habit from this entire controversy is one anyone can apply without a mathematics PhD: do not trust the plain-English summary of a formal result, check the formal statement itself, or find someone qualified who has.

Start with the repository. Both of OpenAI's 2026 math releases ship a real, independently buildable Lean project, and building it yourself takes a few minutes on a laptop.

bash
/code
# Install elan (Lean's toolchain version manager) if you do not already have it
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh

# Clone OpenAI's published Navier-Stokes and Euler formalization
git clone https://github.com/openai/NavierStokesAndEuler
cd NavierStokesAndEuler

# Pull the prebuilt mathlib cache instead of rebuilding it from source
lake exe cache get

# Build every formalized result against the Lean kernel
lake build

# Independently audit the repository for admitted proof gaps (the `sorry`
# placeholder). A zero-result here, combined with a clean `lake build`,
# is what actually substantiates a fully verified claim, rather than
# just trusting the accompanying write-up.
grep -rn --include="*.lean" -E '(^|[^a-zA-Z_])sorry([^a-zA-Z_]|$)' . | grep -v '^--' \
  || echo "No admitted gaps found in $(find . -name '*.lean' | wc -l) Lean files."

# Read the actual theorem statements before repeating the headline claim.
# Look specifically for a forcing term as a hypothesis, this is the
# single detail that separates a Clay statement (C)/(D) result from (A)/(B).
grep -rn --include="*.lean" -iE 'theorem|force|forcing' . | head -40

If that build succeeds and the sorry search comes back empty, you have independently confirmed the narrow, specific thing formal verification actually promises: every logical step in the formalized theorem statement holds. You have not yet confirmed that the formalized statement is the one you assumed was being proven. For this release specifically, read the actual theorem names and hypotheses in the repository before repeating a headline. If a theorem's statement includes a forcing term f as a hypothesis rather than setting it to zero, you are looking at a Clay statement (C) or (D) result, not (A) or (B), regardless of how the surrounding press coverage describes it.

Second, understand why nobody can substitute a numerical simulation for a proof here, since it comes up in every conversation about this problem. A useful, genuinely instructive toy model for building intuition, without any of the real complexity, is the Constantin-Lax-Majda equation, a 1985 one-dimensional simplification of 3D vorticity dynamics that keeps the real equations' nonlocal vortex-stretching structure while being exactly solvable [24]. Even the simplest scalar version of its blowup mechanism, θ'(t) = θ(t)², has an exact solution θ(t) = θ₀/(1 − θ₀t) that blows up at a precise, finite time T = 1/θ₀. Here is a short script that numerically integrates that toy equation and tries to detect the approaching singularity from the trajectory alone, the same basic diagnostic idea researchers use on much harder numerical simulations of the real Euler and Navier-Stokes equations, and it is worth running specifically to see how easy detecting blowup is in a toy model with an exact closed-form answer, compared to how unreliable the same diagnostic becomes once you are looking at a genuinely under-resolved simulation of the full 3D equations, which is exactly the trap Fefferman's own problem statement warns about in Step 1.

python
/code
# A minimal, exactly-solvable toy model of finite-time blowup, in the
# spirit of the Constantin-Lax-Majda (1985) one-dimensional vorticity
# model. This is NOT a Navier-Stokes or Euler solver, it is a scalar
# ODE, theta'(t) = theta(t)^2, chosen because it has a known closed-form
# blowup time, so we can check a numerical detector against ground truth.

import numpy as np

def exact_blowup_time(theta0: float) -> float:
    """theta(t) = theta0 / (1 - theta0 * t), blows up at t = 1/theta0."""
    return 1.0 / theta0

def integrate_and_detect(theta0: float, dt: float = 1e-4, max_steps: int = 200_000):
    """Explicit Euler integration with a simple blow-up detector: fit
    1/theta(t) as a line and extrapolate where it hits zero, exactly
    the diagnostic style used on much harder PDE simulations."""
    theta = theta0
    t = 0.0
    history = []
    for step in range(max_steps):
        history.append((t, theta))
        if theta > 1e6:  # numerical solver is about to lose meaning
            break
        theta = theta + dt * theta ** 2
        t += dt

    ts = np.array([h[0] for h in history[-20:]])
    inv_theta = np.array([1.0 / h[1] for h in history[-20:]])
    slope, intercept = np.polyfit(ts, inv_theta, 1)
    estimated_blowup = -intercept / slope
    return estimated_blowup

if __name__ == "__main__":
    theta0 = 2.0
    true_T = exact_blowup_time(theta0)
    estimated_T = integrate_and_detect(theta0)
    print(f"Exact blow-up time:      T = {true_T:.6f}")
    print(f"Detector's estimate:     T ~ {estimated_T:.6f}")
    print(f"Absolute error:          {abs(true_T - estimated_T):.6e}")
    # In this toy scalar case the detector is essentially exact because
    # we know the closed-form solution to check it against. The full
    # 3D Euler and Navier-Stokes equations have no known closed-form
    # solution near a candidate singularity, so the same diagnostic,
    # run on a under-resolved grid simulation, cannot be checked against
    # ground truth this way. That gap is exactly why Fefferman's official
    # problem statement warns that numerical evidence of blowup is
    # unreliable, and why a machine-checked proof is the only thing
    # that actually settles the question.

Third, separate the mathematical dispute from the credit dispute, and evaluate each on its own terms rather than letting one contaminate your read of the other. The mathematical question, does the published Lean repository actually establish statements (C) and (D) as claimed, is answerable by building the repository and reading the theorem statements, and nothing in Buckmaster's account disputes that OpenAI's model produced a valid forced-blowup construction. The credit and provenance question, whether that construction was reached independently or with undisclosed help from Buckmaster and Alpöge's unpublished work, is a question about process and disclosure that a compiling Lean file cannot answer either way, and it is the one still actively disputed by the people closest to it.

Step 8: A General Framework for Evaluating the Next AI Math Claim

This will not be the last "AI solved a famous open problem" headline, from OpenAI or any other lab. A few checks, drawn directly from the gaps this specific case exposed, generalize well:

• Read the actual theorem statement, not the headline. Check every hypothesis. A forcing term, a smallness assumption, a restricted class of initial data, or a periodic-domain assumption can turn an eye-catching headline into a real but narrower result, exactly as happened here with the forced-versus-unforced distinction.
• Check whether formal verification exists, and separately, whether you can actually build it yourself. Both of OpenAI's 2026 releases pass this bar; not every AI research claim does, and this is the single fastest way to separate a genuinely checkable claim from a prose-only one.
• Look for the timeline, not just the announcement. Buckmaster's public statement is powerful specifically because it is a dated, sequential account: who contacted whom, on which day, saying what. A claim with no verifiable timeline invites exactly the kind of dispute this one produced.
• Distinguish direct data access from training-time influence. These are different technical questions with different, sometimes unanswerable, evidentiary standards, and a denial of one is not a denial of the other, as Step 6 covers.
• Read the cost figure skeptically, and ask what it is actually counting. The gap between $2 million, $22.5 million, and "millions of dollars" for the same underlying event is a direct echo of the $2,000-versus-true-cost ambiguity from August's release, just at a different scale [10][9].
• Weigh named, on-record mathematical commentary over anonymous or aggregated reaction. Córdoba's genuine surprise, Silvestre's description of the field's mood, and Tao's dual role, praising the underlying mathematics while separately warning about process, are each real, attributable signals worth more than an unsourced "mathematicians are skeptical" line [19][13].

It is also worth situating this within the broader, faster-moving pattern of AI systems working on formal mathematics through 2026. Google DeepMind's AlphaProof reached IMO silver-medal-equivalent performance on competition mathematics back in 2024, with some problems taking up to three days of search [27], and Gemini Deep Think reached officially recognized gold-medal performance a year later [28]. The underlying research trend making an 88-hour, 10,000-agent search over an open research problem possible at all is the same test-time compute scaling work showing that spending more inference-time search on a harder problem can substitute for a much larger model [29]. None of that trend explains or excuses the provenance dispute in Step 4. It does explain why claims at this scale and speed are becoming more common rather than less, and why the verification habits in this section are worth actually building into a routine rather than reserving for one unusually public controversy.

Common Mistakes When Reading a Claim Like This

• Treating "OpenAI solved Navier-Stokes" as a complete, accurate headline. As Step 5 covers in detail, the published result establishes the forced blowup statements (C) and (D), not the unforced existence-and-smoothness statements (A) and (B) most people mean by the phrase, and OpenAI's own repository is explicit about this scope.
• Assuming the credit dispute means the mathematics is wrong. Nothing in Buckmaster's own public statement disputes that OpenAI's model produced a valid construction; his stated concerns are about process, disclosure, and authorship, a genuinely separate question from mathematical correctness.
• Assuming a Lean-verified proof settles every open question about a claim. It settles the internal logical validity of the formalized statement. It does not settle whether that statement is the one you assumed, whether the underlying idea was independently discovered, or whether the result is illuminating in the way a human mathematician would want it to be.
• Quoting a single compute-cost figure as though it were undisputed. As Step 2 covers, credible outlets cite figures from roughly $2 million to $22.5 million for the same event, and the gap traces back to exactly the same successful-run-versus-total-search ambiguity flagged around August's smaller $2,000 figure.
• Reading "OpenAI declined to claim the prize" as pure modesty. It is also consistent with an internal recognition that a forced result may not be what the Clay Institute or the mathematical community will ultimately accept as resolving "the heart of the problem," exactly the caution Institute president Martin Bridson signaled with his "deliberately unhurried" framing.
• Skipping the primary sources because the news summaries feel sufficient. Buckmaster's own public statement and Terence Tao's technical review are both public documents anyone can read directly rather than through a secondhand paraphrase, and reading them changes how several of the disputed details actually land.

Verifying AI-Generated Claims Is the Same Skill as Verifying AI-Generated Content

Everything in Step 7's checklist, read the actual formal statement, check whether an independent build is even possible, separate what a source can and cannot confirm, is the same underlying discipline a creator needs before publishing anything an AI tool produced on their behalf, whether that is a research summary, a generated image, or a video clip presented as real. A generated image with a subtly wrong architectural detail or a fabricated statistic in a caption fails the same test a mathematics proof fails when its formalized statement quietly does not match its headline: it looks complete without actually being checked.

That is part of why it matters which models sit underneath the tools you use for that work. Miraflow AI builds its image and video generation on well-documented, publicly benchmarked models rather than an opaque black box, the same underlying principle behind favoring a Lean-verified proof you can build yourself over a prose claim you cannot check. Whether you are fact-checking a viral AI math claim before sharing it or reviewing an AI-generated thumbnail before it goes live through Miraflow's YouTube Thumbnail Maker, the habit is the same: verify the specific, checkable claim in front of you before you amplify it, and treat "an AI produced this" as a reason to look closer, not a reason to skip the check.

Conclusion

Strip away the dueling headlines and two things are true at once, and both are worth holding onto rather than collapsing into a single verdict. OpenAI's roughly 10,000-agent effort did produce a genuine, Lean-verified mathematical construction establishing forced finite-time blowup for the 3D Navier-Stokes equations on both R³ and the periodic torus, plus a separate unforced blowup for the 3D Euler equations, published in a repository anyone can build and check themselves. That is real, checkable mathematics, not a prose claim asking to be trusted on faith. At the same time, the plain-English framing that dominated headline coverage overstates what was shown relative to the unforced existence-and-smoothness question most mathematicians actually mean by "the Navier-Stokes problem," and the circumstances behind the announcement, a rapid, high-compute sprint that began within days of learning a specific competing team was close to a related result, with unresolved questions about training-data influence that OpenAI has not fully answered, are exactly the kind of provenance gap that makes "trust but verify" the only reasonable posture. The Clay Mathematics Institute's own deliberately unhurried stance is the correct model to follow here: read the actual theorem statement, build the repository yourself if you can, and give the credit dispute the same careful, dated, sourced scrutiny Buckmaster gave his own account of it, rather than accepting either side's summary at face value.

Frequently Asked Questions

Did OpenAI actually solve the Navier-Stokes Millennium Prize Problem? OpenAI's published result establishes Clay statements (C) and (D), a finite-time blowup for the forced Navier-Stokes equations, not the unforced existence-and-smoothness statements (A) and (B) most mathematicians mean by the full problem. OpenAI itself has explicitly declined to claim the $1 million prize, and the Clay Mathematics Institute still listed the problem as unsolved on its own site as of this writing.

What does "forced" versus "unforced" actually mean here? The unforced equations only have whatever energy the fluid started with, since viscosity constantly drains it away, which is why proving blowup with no forcing is considered the harder, more meaningful question. Adding a smooth external force gives a second lever to shape the construction toward blowup, which the official Clay statement explicitly allows in cases (C) and (D) but which most working mathematicians treat as a distinctly easier problem than the unforced case.

Is the proof actually formally verified, like August's ten math proofs? Yes, in the narrow, technical sense. OpenAI published a Lean 4 formalization at github.com/openai/NavierStokesAndEuler that anyone can build and check. What differs from August's release is not the presence of formal verification, but the review time it has had, and a separate, unresolved dispute over the priority and possible data-contamination behind how the result was reached.

What exactly is Tristan Buckmaster accusing OpenAI of? In his own public statement, Buckmaster says he does not know what OpenAI's model actually did or whether his and Levent Alpöge's unpublished work influenced it, and is explicit that he is not accusing anyone of anything. He documents a specific timeline: OpenAI learning of his and Alpöge's progress, a proposal to publish in a way that would have excluded Alpöge from authorship because of his Anthropic affiliation, and an unanswered question about whether his private Codex sessions may have influenced the model's training.

Who are Diego Córdoba and Luis Martínez-Zoroa, and why do they matter here? They are the mathematicians who originated the forced-blowup construction technique, years before this controversy, first proving a version with rough, non-smooth forcing. Buckmaster and Alpöge extended that technique to smooth forcing using AI assistance, and OpenAI's own agents reportedly targeted the same "option C and D" route Buckmaster says he and Alpöge had quietly chosen to attack.

Can I verify any of this myself without being a mathematician? Yes, to a meaningful degree. You can clone and build the public Lean repository to confirm the formal proof compiles with no admitted gaps, and you can read the primary sources, Buckmaster's own public statement and Terence Tao's public review, directly rather than through secondhand summaries. What you cannot verify independently is whether training-data contamination occurred, since that requires access neither outside mathematicians nor readers actually have.

References

1. OpenAI, "On the Navier–Stokes Millennium Prize Problem."
2. Clay Mathematics Institute, "Navier-Stokes Equation."
3. Charles L. Fefferman, "Existence and Smoothness of the Navier-Stokes Equation," Clay Mathematics Institute official problem statement.
4. Clay Mathematics Institute, "Millennium Prize Problems."
5. CNBC, "OpenAI claims to have solved the 90-year-old Navier-Stokes math problem in 88 hours."
6. Interesting Engineering, "10,000 OpenAI agents crack 90-year-old Navier-Stokes mystery in just 88 hours."
7. GitHub, "openai/NavierStokesAndEuler: Lean certificates accompanying Navier-Stokes and Euler results."
8. GitHub, "NavierStokesAndEuler/README.md."
9. Science (AAAS), "How an AI math breakthrough ignited a controversy."
10. TechCrunch, "OpenAI fought dirty on career-making math problem, says NYU mathematician."
11. Fortune, "OpenAI says it cracked Navier-Stokes, one of math's grand challenges."
12. Tristan Buckmaster, public statement (PDF), NYU Courant Institute.
13. Terence Tao, "Finite time blowup with smooth forcing term for the incompressible porous medium, Boussinesq, and incompressible Euler equations," What's New.
14. Levent Alpöge and Tristan Buckmaster, "Extending the Córdoba-Martínez-Zoroa IPM Blow-Up" (PDF).
15. Córdoba, Martínez-Zoroa, and Zheng, "Finite time blow-up for the hypodissipative Navier Stokes equations with a force in L¹ₜC¹,εₓ ∩ L∞ₜL²ₓ," arXiv.
16. Forkast News, "OpenAI's 10,000-Agent Navier-Stokes Claim Solves the Wrong Problem, and the Right One Has a Provenance Controversy."
17. Implicator.ai, "Clay Institute Won't Call Navier-Stokes Solved by OpenAI."
18. MIT Technology Review, "What OpenAI's latest controversy tells us about the future of math."
19. Scientific American, "OpenAI Claims Blockbuster Math Breakthrough Amid Swirl of Controversy."
20. Axios, "OpenAI's historic math solution overshadowed by credit controversy."
21. TheNextWeb, "OpenAI publishes its Navier-Stokes proof and says it will not claim the Millennium Prize."
22. The Rundown AI, "OpenAI's claimed Navier-Stokes proof raises the ceiling for AI research."
23. officechai, "OpenAI Shares Solution To Navier-Stokes Problem Created By A Model 'Significantly More Capable' Than Astra."
24. Peter Constantin, Peter D. Lax, and Andrew Majda, "A simple one-dimensional model for the three-dimensional vorticity equation," Communications on Pure and Applied Mathematics, 1985.
25. Miraflow AI Blog, "Astra Explained: How an Unreleased OpenAI Model Solved 10 Open Math Problems With Zero-Sorry Lean Proofs."
26. Miraflow AI Blog, "GPT-6 Astra Explained: Inside OpenAI's First 'Critical'-Threshold Model."
27. Google DeepMind, "AI achieves silver-medal standard solving International Mathematical Olympiad problems."
28. Google DeepMind, "Advanced version of Gemini with Deep Think officially achieves gold-medal standard at the International Mathematical Olympiad."
29. Snell, Lee, Xu, and Kumar, "Scaling LLM Test-Time Compute Optimally Can Be More Effective Than Scaling Model Parameters," arXiv.