Navier–Stokes Blowup: An Interactive Explainer

An interactive walkthrough of OpenAI's announcement, On the Navier–Stokes Millennium Prize Problem (September 8, 2026). Sliders and plots below let you play with the scaling arithmetic that sits at the heart of the claim.

1. What was announced

OpenAI reported an AI-generated resolution of the Navier–Stokes existence-and-smoothness problem — in the negative direction: smooth initial data plus a smooth force can produce a genuine blowup in finite time. They released a writeup and a Lean formalization, and separately a disproof of regularity for the unforced Euler equations.

The three headline claims:

They also stated they do not intend to claim the prize money for the result.

2. The equations

For an incompressible fluid of constant density in ℝ3, momentum balance is Newton's F=m*a written for a continuum:

(∂_t)(u)+(u⋅∇)*u=−∇*p+ν*Δ(u)+ƒ

together with the incompressibility constraint

∇⋅u=0

Here u(x,t) is velocity, p is pressure, ν>0 is viscosity, and ƒ is an external force. The four mechanisms map onto the four terms: acceleration, momentum transfer (advection), pressure gradient, and viscous diffusion.

The problem: starting from smooth (u_0) with ∇⋅(u_0)=0, does a smooth solution exist for all t>0? Leray showed in 1934 that weak solutions always exist; whether they stay smooth stayed open for about 90 years.

Blowup means

(lim_t→T−)((sup_x)(u(x,t)))=∞

for some finite T, while the energy 1/2*(∫_^)||u|2*d(x)| stays finite the whole time.

3. Interactive: the self-similar scaling budget

The obstruction to blowup is a bookkeeping problem. Suppose near the singularity time T the velocity concentrates on a shrinking length scale

ℓ(t)=(T−t)β

with velocity amplitude

U(t)=(T−t)(−α)

Each term in the equation then has its own power of T−t. Setting the exponents equal is what forces α and β to be related, and the energy and viscosity conditions carve out the allowed region. Move the sliders to see which constraints survive.

import marimo as mo
import numpy as np
import matplotlib.pyplot as plt

beta_slider = mo.ui.slider(0.30, 0.70, 0.01, value=0.45, label="length-scale exponent β")
beta_slider

beta = beta_slider.value
alpha = 1.0 - beta                      # advection balance: α = 1 - β
energy_exp = 3 * beta - 2 * alpha       # energy ~ U² ℓ³ = (T-t)^(3β-2α)
viscous_exp = alpha + 1 - (alpha + 2 * beta)
mo.Html(
    f"<p>&alpha; = <b>{alpha:.2f}</b> &middot; "
    f"energy exponent <b>{energy_exp:+.2f}</b> &middot; "
    f"viscous&ndash;inertia gap <b>{viscous_exp:+.2f}</b></p>"
)

def scaling_plot(b):
    a = 1.0 - b
    s = np.linspace(1e-3, 1.0, 400)          # s = T - t
    fig, ax = plt.subplots(figsize=(6, 3.6))
    ax.loglog(s, s ** (-a), label="velocity  U ~ s^-α")
    ax.loglog(s, s ** b, label="length  ℓ ~ s^β")
    ax.loglog(s, s ** (3 * b - 2 * a), label="energy  U²ℓ³")
    ax.set_xlabel("s = T - t  (time to blowup)")
    ax.legend(fontsize=8)
    ax.invert_xaxis()
    return fig

scaling_plot(beta_slider.value)

Two things to notice while dragging. The velocity curve blows up as s→0 for any β<1, but the energy curve only stays bounded when 3*β−2*α≥0, i.e. β≥2/5. And viscosity is never negligible: the gap 1−2*β tells you how the diffusive term compares to inertia, which is why the viscous case is so much harder than Euler.

4. Interactive: the vortex geometry

The announced solution is described as a vortex that spirals inward while stretching along its axis — the "spaghetti" picture. Incompressibility ties the two together: if a tube of fluid narrows radially by a factor λ, it must lengthen by λ2, and conservation of angular momentum spins it up. That is the amplification engine.

strain_slider = mo.ui.slider(0.2, 3.0, 0.1, value=1.2, label="axial strain rate γ")
strain_slider

swirl_slider = mo.ui.slider(0.5, 6.0, 0.25, value=3.0, label="swirl strength Γ")
swirl_slider

def spiral(gamma, gam_swirl, n=5, steps=1400, dt=0.004):
    paths = []
    for r0 in np.linspace(0.35, 1.0, n):
        r, th, z = r0, 0.0, 0.25
        pts = []
        for _ in range(steps):
            r += dt * (-0.5 * gamma * r)
            th += dt * gam_swirl / (r ** 2 + 0.02)
            z += dt * gamma * z
            pts.append((r * np.cos(th), r * np.sin(th), z))
        paths.append(np.array(pts))
    return paths

def vortex_fig(gamma, gam_swirl):
    fig = plt.figure(figsize=(6.4, 4.6))
    ax = fig.add_subplot(111, projection="3d")
    for p in spiral(gamma, gam_swirl):
        speed = gam_swirl / (np.hypot(p[:, 0], p[:, 1]) + 0.02)
        ax.scatter(p[:, 0], p[:, 1], p[:, 2], c=speed, cmap="cool", s=1.2)
    ax.set_xlabel("x"); ax.set_ylabel("y"); ax.set_zlabel("z")
    ax.set_title(f"inward spiral + axial stretch (γ={gamma:.1f}, Γ={gam_swirl:.2f})")
    return fig

vortex_fig(strain_slider.value, swirl_slider.value)

Turn Γ up and the color gradient steepens toward the axis — that is the unbounded circulating speed. Turn γ up and the trajectories elongate vertically, thinning the core. The real construction is far more delicate than this toy field, but the qualitative mechanism is the same.

5. Why "big yet cancelling" is the hard part

The announcement's key technical remark is worth restating carefully. It is easy to make velocity blow up if you are allowed to inject an infinite force. The requirement is that

ƒ=(∂_t)(u)+(u⋅∇)*u+∇*p−ν*Δ(u)

stays smooth and bounded while each individual term on the right diverges. So the construction needs a near-exact cancellation among four separately-exploding quantities, sustained all the way to time T.

You can feel the difficulty in one number: if U∼(T−t)(−α), then the advection term scales like U2/ℓ and the viscous term like ν*U/ℓ2. Their ratio is the local Reynolds number U*ℓ/ν, which for α=1−β goes like (T−t)(2*β−1). For β<1/2 viscosity wins at small scales, which is exactly the classical intuition for why blowup should be impossible — and exactly what the construction has to defeat.

6. How the proof was produced

The methodology is arguably as notable as the result:

• A new internal model, described as more capable than GPT-6 Astra, in training since late August 2026.

• A multi-agent system with cached web access and code execution, organized into communicating groups; the Navier–Stokes group ran on the order of 10,000 concurrent agents.

• Different groups were seeded with different variants of the problem statement — versions "A"/"B" (proof side) and "C"/"D" (disproof side) — so the search covered both outcomes.

• The easier Euler warm-up problem was solved first by roughly 100 agents over about 50 hours, and that result was then fed back as a prompt to the Navier–Stokes groups.

• Total resolution time was about 88 hours from launch, plus about 17 hours of Lean formalization.

• Aggregate cost across all attempted problems: about 4.9 million inter-agent messages and roughly 300 billion output tokens, of which 2.7 million messages and about 130 billion tokens went to Navier–Stokes.

7. Concurrent work and open questions

There was parallel activity: Levent Alpöge and Tristan Buckmaster independently obtained a resolution of the forced Euler problem, and OpenAI's post recognizes their priority on that. The two Euler results differ in the forced-versus-unforced distinction.

Worth keeping in mind as you read:

• A Lean formalization is strong evidence, but its value depends on whether the formal statement faithfully encodes the Clay problem's conditions. That is a human review question, not a machine one.

• The result is a disproof of global regularity, which means the physical continuum model breaks down in this regime rather than being validated.

• Independent verification by the fluid dynamics community is the step that actually settles it.

Sources: the announcement, the paper, the Euler paper, and the Lean formalization.