Chapter 30
25 min read
Section 257 of 353

The Millennium Prize Problem

The Navier-Stokes Equations

Learning Objectives

By the end of this section, you will be able to:

  1. State the Clay Millennium problem for the 3D incompressible Navier-Stokes equations in plain English and in formal mathematics.
  2. Explain the “race” between nonlinear vortex stretching and viscous dissipation that sits at the heart of the question.
  3. Derive the basic energy estimate ddtuL22=2νuL22\tfrac{d}{dt}\,\|\mathbf{u}\|_{L^2}^2 = -2\nu\,\|\nabla\mathbf{u}\|_{L^2}^2 and recognise why it is not enough.
  4. Reproduce the Beale-Kato-Majda criterion: smoothness up to time TT persists iff 0Tω(t)Ldt<\int_0^T \|\boldsymbol\omega(t)\|_{L^\infty}\,dt < \infty.
  5. Distinguish classical, weak (Leray-Hopf), and suitable weak solutions, and quote the Caffarelli-Kohn-Nirenberg partial-regularity result.
  6. Implement a Python integrator for the toy 1D blow-up ODE and a PyTorch 1D viscous Burgers solver, and use them to feel why 1D and 2D are tractable while 3D resists every known technique.

The Million-Dollar Question

In May 2000 the Clay Mathematics Institute announced seven open problems, each carrying a US$1 000 000 prize. One of them — the only one drawn directly from applied mathematics — is the Navier-Stokes existence and smoothness problem. Twenty-five years later it is still open.

Put as simply as possible: start with a smooth, gentle 3D velocity field and let it evolve under the Navier-Stokes equations. Will the flow remain smooth forever, or can it develop an infinite-velocity gradient — a “singularity” — at some finite future time?

The intuitive picture

Imagine spinning a fork in a bowl of cream. Vortices appear, swirl, stretch, fold, break up into smaller eddies, and eventually viscous friction grinds them all into heat. That is what we observe. But nobody has been able to prove — starting from the equations themselves and any smooth initial wisp — that the cream will not, at some moment, develop a microscopic point where the velocity is infinite. The math is silent. The physics is silent.

The official problem (Clay, 2000): Prove that for any smooth, divergence-free initial velocity field with finite energy on R3\mathbb{R}^3, the 3D incompressible Navier-Stokes equations have a global, smooth solution — OR exhibit a smooth initial datum for which the solution breaks down in finite time.

The asymmetry is striking. Existence of a solution for short time is elementary. Uniqueness for the short-time solution is elementary. Existence of a weak solution for all time was proved by Jean Leray in 1934. The unsolved question lives in a narrow gap: does the smooth solution that exists for a moment continue to exist for all time?


A Quick Recap: The 3D Navier-Stokes Equations

For an incompressible Newtonian fluid filling a domain ΩR3\Omega \subset \mathbb{R}^3, the velocity u(x,t)R3\mathbf{u}(\mathbf{x},t) \in \mathbb{R}^3 and pressure p(x,t)Rp(\mathbf{x},t) \in \mathbb{R} satisfy

tu+(u)u=p+νΔu+f,u=0.\displaystyle\partial_t \mathbf{u} + (\mathbf{u}\cdot\nabla)\mathbf{u} = -\nabla p + \nu\,\Delta \mathbf{u} + \mathbf{f}, \qquad \nabla\cdot\mathbf{u} = 0.

The five symbols, decoded:

SymbolReads asRole
∂_t urate of change of velocity in timeHow much faster (or slower) is this fluid parcel about to move?
(u·∇) unonlinear convectionSelf-advection — the velocity carries itself. This is the term that creates turbulence and the term that could blow up.
−∇ppressure forceLagrange multiplier that enforces ∇·u = 0. It is not 'chosen' independently; it is whatever it has to be to keep the fluid divergence-free.
ν Δuviscous diffusionThe brake. Diffuses momentum from where it is dense to where it is sparse. The Millennium question is whether this brake is strong enough in 3D.
fexternal forcingGravity, propulsion, electromagnetic forces. The Clay problem can be stated with or without forcing.

The Clay setup, precisely

Clay's problem fixes f=0\mathbf{f}=0 (no forcing), works on R3\mathbb{R}^3 (no walls), and assumes the initial data u0\mathbf{u}_0 is CC^\infty, divergence-free, and decays fast enough at infinity. There is also a periodic version (replace R3\mathbb{R}^3 with T3\mathbb{T}^3) which is equivalent for the purposes of the prize.


The Race: Stretching vs Dissipation

Strip the Navier-Stokes equations down to the two terms that fight each other. The convection term (u)u(\mathbf{u}\cdot\nabla)\mathbf{u} is quadratic in u\mathbf{u} — it amplifies what is already there. The viscous term νΔu\nu\,\Delta\mathbf{u} is linear — it smooths what is already there. The Millennium question, deeply, is about which one wins as features get sharper.

Here is the heart of the difficulty, written as a back-of-the-envelope scaling argument. Suppose u\mathbf{u} develops a feature of size UU on a length scale \ell. Then derivatives scale like U/U/\ell, and:

TermScalingMeaning
convection (u·∇)uU² / ℓFaster, sharper features feed back on themselves
diffusion ν Δuν U / ℓ²Smoothing is stronger on small scales

The ratio is the local Reynolds number R=U/νR_\ell = U\ell/\nu. When R1R_\ell \gg 1 convection dominates and the feature tries to grow. When R1R_\ell \ll 1 diffusion dominates and the feature relaxes. The terrifying observation is that as a vortex stretches, ℓ shrinks faster than U grows, and RR_\ell can — at least a priori — keep climbing.

Before tangling with vector PDEs, let's capture this race in the simplest possible scalar ODE. It is the 1D cartoon of the Millennium problem and is small enough to play with on a slider.


Interactive: The Toy Blow-up ODE

Imagine a single “vorticity unit” ω(t)\omega(t). Two forces act on it:

  • Self-stretching: +ω2+\omega^2 — a tube of vorticity stretched by the flow concentrates its rotation, which makes the stretching even stronger. Pure positive feedback.
  • Viscous damping: νω-\nu\,\omega — the standard linear decay you would write for any diffusing scalar.

The ODE is

dωdt=ω2νω,ω(0)=ω0.\displaystyle\frac{d\omega}{dt} = \omega^2 - \nu\,\omega, \qquad \omega(0) = \omega_0.

Separation of variables gives the exact solution, valid as long as the denominator stays nonzero:

ω(t)=ν1(1νω0)eνt.\displaystyle \omega(t) = \frac{\nu}{1 - \left(1 - \dfrac{\nu}{\omega_0}\right)\,e^{\nu t}}.

When ω0>ν\omega_0 > \nu the bracket is positive, the exponential drives the denominator to zero, and the solution explodes at the finite blow-up time

t=1νln ⁣(ω0ω0ν).\displaystyle t^* = \frac{1}{\nu}\,\ln\!\left(\frac{\omega_0}{\omega_0 - \nu}\right).

When ω0ν\omega_0 \le \nu the bracket is non-positive, the denominator stays bounded below by 11, and ω(t)0\omega(t) \to 0. Two regimes, one knob — exactly the shape of the Millennium question.

Loading interactive blow-up race…

Knobs to try first

  • Set ω0=2,ν=1\omega_0 = 2, \nu = 1. You should see t=ln20.693t^* = \ln 2 \approx 0.693.
  • Hold ω0=2\omega_0 = 2, slowly drag ν\nu upward. Watch the asymptote slide to the right and then vanish the instant ν\nu crosses ω0\omega_0.
  • Fix ν=1\nu = 1 and crank up ω0\omega_0. Blow-up time shrinks like ln ⁣(1+ν/(ω0ν))\ln\!\bigl(1 + \nu/(\omega_0 - \nu)\bigr) — bigger initial twist, sooner collapse.

What this toy DOES and DOES NOT capture

The scalar ODE captures the local quadratic structure of vortex stretching and the linear structure of dissipation. It does not capture the divergence-free constraint, the non-local pressure, or the geometric depletion of nonlinearity that happens when vortex lines align (Constantin-Fefferman, 1993). Those subtleties are precisely why the 3D problem might still be true even though the cartoon predicts blow-up the moment ω0>ν\omega_0 > \nu.


What “Smoothness” Really Means

When mathematicians say a solution is smooth, they mean it has continuous partial derivatives of every order — i.e. it lies in CC^\infty. In practice we work in function spaces that quantify how many derivatives are well-behaved and in what averaged sense.

SpaceDefinitionWhat it controls
∫ |u|² dx < ∞Kinetic energy. Cheap to control — every flow with finite energy lives here.
Hˢ (Sobolev)u and its first s weak derivatives in L²Smoothness of order s. H¹ controls ∇u, H² controls Δu, …
L^∞ess sup |u| < ∞Pointwise boundedness. NOT controlled by L² in 3D.
C^kk classical derivatives, continuousOld-school smoothness. C^∞ = smooth in the Clay sense.

The reason these distinctions matter: in 3D a function can have bounded energy (L2L^2) and yet be unbounded pointwise, the way f(x)=x1/2f(\mathbf{x}) = |\mathbf{x}|^{-1/2} on the unit ball is in L2L^2 but has a spike at the origin. The Millennium problem is whether the Navier-Stokes equations can drive an initially smooth solution into exactly that kind of singularity.


The Formal Clay Statement

Clay phrased four sub-problems. Solving any one of them — A or B — wins the prize. C and D are the corresponding statements for the periodic version.

(A) Existence and smoothness on ℝ³

Prove: for every smooth, divergence-free u0\mathbf{u}_0 on R3\mathbb{R}^3 with rapid decay, there exist smooth functions u,p\mathbf{u}, p on R3×[0,)\mathbb{R}^3\times[0,\infty) that solve Navier-Stokes with u(,0)=u0\mathbf{u}(\cdot,0) = \mathbf{u}_0 and bounded total energy u2<C\int |\mathbf{u}|^2 < C.

(B) Breakdown on ℝ³

Exhibit a smooth, divergence-free u0\mathbf{u}_0 for which no solution of (A) exists — i.e. construct an initial datum that provably develops a singularity in finite time.

The community is split, but the consensus tilts gently toward (A) being true — based on numerical evidence, physical intuition, and the partial-regularity theorems below. Tao's 2016 averaged-equation blow-up result is the strongest hint that (B) might be the right answer, because it shows that a close cousin of Navier-Stokes does blow up.


Energy Estimates: What We CAN Prove

Take the inner product of the momentum equation with u\mathbf{u} itself and integrate over the whole domain. Three of the four terms simplify beautifully:

  • utudx=12ddtu2dx\int \mathbf{u}\cdot\partial_t\mathbf{u}\,dx = \tfrac{1}{2}\tfrac{d}{dt}\int|\mathbf{u}|^2\,dx — the kinetic-energy time derivative.
  • u(u)udx=12uu2dx=0\int \mathbf{u}\cdot(\mathbf{u}\cdot\nabla)\mathbf{u}\,dx = \tfrac{1}{2}\int \mathbf{u}\cdot\nabla|\mathbf{u}|^2\,dx = 0 — the nonlinear term integrates to zero by u=0\nabla\cdot\mathbf{u}=0 and integration by parts. The bad term vanishes in the energy budget!
  • updx=0\int \mathbf{u}\cdot\nabla p\,dx = 0 — same reason, pressure drops out.
  • uνΔudx=νu2dx\int \mathbf{u}\cdot\nu\Delta\mathbf{u}\,dx = -\nu\int|\nabla\mathbf{u}|^2\,dx — integration by parts on the Laplacian.

The result is the famous basic energy identity:

ddt12u(t)L22+νu(t)L22=0.\displaystyle\frac{d}{dt}\,\tfrac{1}{2}\|\mathbf{u}(t)\|_{L^2}^2 + \nu\,\|\nabla\mathbf{u}(t)\|_{L^2}^2 = 0.

Integrating in time gives the cornerstone a-priori bound

12u(T)L22+ν0TuL22dt=12u0L22.\displaystyle\tfrac{1}{2}\|\mathbf{u}(T)\|_{L^2}^2 + \nu\int_0^T \|\nabla\mathbf{u}\|_{L^2}^2\,dt = \tfrac{1}{2}\|\mathbf{u}_0\|_{L^2}^2.
What this says, in words: energy can only decrease, and the integral of uL22\|\nabla\mathbf{u}\|_{L^2}^2 over all time is finite. Both are wonderful — and both are spectacularly not enough.

The energy bound controls uL2\|\nabla\mathbf{u}\|_{L^2} in an integral sense over time. To rule out a singularity, we would need an instantaneous pointwise bound on u\nabla\mathbf{u}. There is a giant gap between “finite on average” and “never infinite”.


The Vorticity Equation: Where 3D Bites

Define vorticity ω=×u\boldsymbol\omega = \nabla\times\mathbf{u}. Take the curl of the momentum equation. Pressure drops out (curl of a gradient is zero), and you get

tω+(u)ω=(ω)u+νΔω.\displaystyle\partial_t\boldsymbol\omega + (\mathbf{u}\cdot\nabla)\boldsymbol\omega = (\boldsymbol\omega\cdot\nabla)\mathbf{u} + \nu\,\Delta\boldsymbol\omega.

The new term (ω)u(\boldsymbol\omega\cdot\nabla)\mathbf{u} is the vortex-stretching term. It is the soul of the Millennium problem.

The geometric meaning of vortex stretching

A vortex tube is a tiny tornado. When the surrounding flow u\mathbf{u} stretches the tube along its axis, the tube's cross-section shrinks (volume is preserved because the fluid is incompressible). Angular momentum is preserved, so as the cross-section shrinks the rotation rate ω|\boldsymbol\omega| grows. Stretching a twisting rope thinner makes it spin faster — exactly the same physics. The term (ω)u(\boldsymbol\omega\cdot\nabla)\mathbf{u} is mathematically ω|\boldsymbol\omega| times the strain rate along the vortex direction.

In 2D the vortex-stretching term (ω)u(\boldsymbol\omega\cdot\nabla)\mathbf{u} is identically zero (vorticity is perpendicular to the plane of the flow, gradient lies in the plane, dot product vanishes). Vorticity is then transported by the flow and dissipated by viscosity. It can never amplify. This is why 2D is solved.

In 3D the stretching term is generically nonzero, and the formal argument dω/dtω2d|\boldsymbol\omega|/dt \sim |\boldsymbol\omega|^2 is exactly the toy blow-up ODE you just played with — minus the depletion effects coming from geometry. The Millennium question is whether those geometric effects are powerful enough to globally beat the quadratic feedback.


Leray's Weak Solutions (1934)

Faced with an apparent dead-end on the classical problem, Jean Leray invented a now-standard trick: drop the requirement that the equation be satisfied pointwise. Multiply by a smooth test function φ\boldsymbol\varphi and integrate, moving derivatives onto φ\boldsymbol\varphi. Any function u\mathbf{u} satisfying the resulting integral identity for all test functions is called a weak solution.

Leray proved: For any u0L2\mathbf{u}_0 \in L^2 divergence-free, there exists a weak solution defined for all t[0,)t \in [0,\infty) that satisfies the energy inequality. That is a remarkable theorem — global existence of some kind of solution from any finite-energy start. Two giant caveats:

  1. Regularity unknown. The Leray solution might be discontinuous, might have unbounded gradients — it just needs to satisfy the integral identity.
  2. Uniqueness unknown. We do not know that the Leray solution is the only weak solution with the given initial data. (Recent work by Buckmaster-Vicol shows that, for the related super-critical class of weak solutions, uniqueness fails.)
The Millennium gap, restated: we have a global weak solution. We have a short-time classical solution. We do not know that they agree, and we do not know that the classical solution can be extended for all time.

The Beale-Kato-Majda Criterion

Beale, Kato, and Majda (1984) gave the cleanest characterisation of blow-up:

Suppose the classical solution u\mathbf{u} exists smoothly on [0,T)[0,T). Then the solution can be extended past TT if and only if
0Tω(t)Ldt<.\displaystyle\int_0^T \|\boldsymbol\omega(t)\|_{L^\infty}\,dt < \infty.

In words: the only way a smooth Navier-Stokes solution can die at time T is for the supremum norm of vorticity to be non-integrable on the approach to T. This is enormously useful because it converts the abstract question “does smoothness survive?” into a concrete diagnostic that can be tracked in any DNS simulation: just plot ωL\|\boldsymbol\omega\|_{L^\infty} against time and see whether the time-integral is starting to diverge.

Why the L∞ norm and not L²?

The energy estimate already gives an integral bound on ωL2\|\boldsymbol\omega\|_{L^2}. The L² norm is average rotation strength. A singularity is a localised defect — average rotation could be small while one tiny region has rotation rate infinity. That is exactly what L\|\cdot\|_{L^\infty} sees and L2\|\cdot\|_{L^2} misses.


Caffarelli-Kohn-Nirenberg Partial Regularity

If you cannot rule out singularities everywhere, the next best thing is to bound the size of the set where they could live. That is the Caffarelli-Kohn-Nirenberg theorem (1982), the deepest known result on 3D Navier-Stokes:

CKN, 1982: The set SR3×(0,)S \subset \mathbb{R}^3 \times (0,\infty) of possible singularities of a suitable weak solution has parabolic Hausdorff dimension at most 11.

Translation: the singular set, if non-empty, is at most a curve in space-time. It cannot be a 2D sheet, cannot fill any open region. Whatever exotic object a 3D Navier-Stokes singularity is, it is extremely thin.

CKN does not say SS is empty. That is the prize. It does say that solving the prize is equivalent to ruling out a one-dimensional pencil of nasty points.


Interactive: The Kolmogorov Energy Cascade

The physical picture motivating the math is Andrei Kolmogorov's 1941 theory of turbulence. Energy is injected at a large length scale LL, cascades through an “inertial range” of progressively smaller eddies without losing energy along the way, and is finally dissipated by viscosity at the Kolmogorov scale η=(ν3/ε)1/4\eta = (\nu^3/\varepsilon)^{1/4}.

Between LL and η\eta the energy spectrum follows the celebrated 5/3-5/3 law:

E(k)=Cε2/3k5/3,1/Lk1/η.\displaystyle E(k) = C\,\varepsilon^{2/3}\,k^{-5/3}, \qquad 1/L \ll k \ll 1/\eta.

The range L/ηL/\eta grows like Re3/4\mathrm{Re}^{3/4}. For atmospheric flows Re109\mathrm{Re}\sim 10^9, so the inertial range stretches over six decades. That is the regime where a direct numerical simulation would need Re9/41020\sim \mathrm{Re}^{9/4} \sim 10^{20} grid points — utterly out of reach. It is also the regime where the Millennium question lives.

Loading Kolmogorov cascade explorer…

The connection back to the prize

The Millennium problem is equivalent to: can the energy cascade ever push energy past kηk_\eta faster than dissipation can eat it? If yes, gradients blow up and the solution fails to be smooth. If no, smoothness persists. In every numerical simulation we have ever run, the answer has been “no”. That is evidence, not proof.


Why 2D Is Solved (and 3D Is Not)

In 2D Navier-Stokes, vorticity ω=xvyu\omega = \partial_x v - \partial_y u is a scalar (the perpendicular component of the 3D vorticity vector). Its evolution equation is

tω+(u)ω=νΔω.\displaystyle\partial_t \omega + (\mathbf{u}\cdot\nabla)\omega = \nu\,\Delta\omega.

Notice what is not there: no vortex-stretching term. The scalar equation has the structure of a convection-diffusion equation, and admits a maximum principle: the supremum of ω|\omega| is non-increasing along the flow. So ωL\|\omega\|_{L^\infty} is bounded by its initial value forever, the BKM-style integral is automatically finite, and global smoothness follows without breaking a sweat. Leray-Ladyzhenskaya-Lions (1969) proved global regularity in 2D once and for all.

In 3D the stretching term (ω)u(\boldsymbol\omega\cdot\nabla)\mathbf{u} re-enters. The maximum principle for vorticity collapses. The toy ODE you played with becomes an honest possibility. Everything in 3D regularity theory boils down to trying to control this one term that 2D does not have.

Don't over-extend the analogy

The 2D global-existence proof is genuinely delicate: it uses the divergence-free constraint, an estimate on the Biot-Savart recovery of velocity from vorticity, and several rounds of Sobolev embedding. The headline is “2D Navier-Stokes is well-posed forever,” but the proof is a graduate-level PDE topic.


Worked Example: Computing the Blow-up Time

Let's solve the toy ODE by hand for ω0=2\omega_0 = 2, ν=1\nu = 1, then sanity-check against the interactive panel.

Click to unfold the pen-and-paper solution

Step 1 — Set up separation of variables

The ODE is dωdt=ω2ω=ω(ω1)\dfrac{d\omega}{dt} = \omega^2 - \omega = \omega(\omega - 1) with ω(0)=2\omega(0)=2. Rewrite as

dωω(ω1)=dt.\displaystyle \frac{d\omega}{\omega(\omega - 1)} = dt.

Step 2 — Partial fractions

Decompose: 1ω(ω1)=1ω+1ω1\dfrac{1}{\omega(\omega-1)} = -\dfrac{1}{\omega} + \dfrac{1}{\omega - 1}. Integrate both sides:

(1ω11ω)dω=dt\displaystyle \int\left(\frac{1}{\omega - 1} - \frac{1}{\omega}\right) d\omega = \int dt
ln ⁣ω1ω=t+C.\displaystyle \ln\!\left|\frac{\omega - 1}{\omega}\right| = t + C.

Step 3 — Apply the initial condition

At t=0,ω=2t=0, \omega=2: ln1/2=ln2=C\ln|1/2| = -\ln 2 = C. So

ln ⁣ω1ω=tln2\displaystyle \ln\!\left|\frac{\omega - 1}{\omega}\right| = t - \ln 2
ω1ω=12et.\displaystyle \frac{\omega - 1}{\omega} = \tfrac{1}{2} e^{t}.

Step 4 — Solve for ω

Cross-multiplying: 2(ω1)=ωet2(\omega - 1) = \omega e^t hence ω(2et)=2\omega(2 - e^t) = 2, giving

ω(t)=22et.\displaystyle \omega(t) = \frac{2}{2 - e^t}.

Step 5 — Locate the blow-up

The denominator vanishes when et=2e^{t^*} = 2, i.e.

t=ln20.6931.\displaystyle t^* = \ln 2 \approx 0.6931.

Cross-check with the general formula t=1νln(ω0/(ω0ν))t^* = \tfrac{1}{\nu}\ln(\omega_0/(\omega_0 - \nu)): plug in ν=1,ω0=2\nu = 1, \omega_0 = 2 to get ln2\ln 2. Match.

Step 6 — Read off the asymptotic behaviour

Near the blow-up, let τ=tt\tau = t^* - t. Taylor-expand 2et=22eτ2τ2 - e^t = 2 - 2e^{-\tau} \approx 2\tau for small τ\tau, so ω1/τ=1/(tt)\omega \approx 1/\tau = 1/(t^*-t). The blow-up rate is exactly 1/τ1/\tau — the same rate the pure ω=ω2\omega' = \omega^2 equation gives for ν=0\nu = 0. Near a self-similar singularity, viscosity becomes irrelevant.

Step 7 — Sanity-check on the slider

Open the interactive panel above, set ω0=2\omega_0 = 2, ν=1\nu = 1. The red dashed line should sit at exactly t0.693t^* \approx 0.693 and the curve should hit the cap there. ✓


Python: Integrating the Blow-up ODE

Now let's do the same calculation numerically. We'll build a 4th-order Runge-Kutta integrator with an automatic blow-up detector and confirm the closed-form answer to four decimal places.

Read the annotation cards on the right — every numerical value printed by this code is hand-computed in the explanations, so you can verify each step yourself.

dω/dt = ω² − ν·ω : finite-time blow-up of the toy model
🐍blowup_ode.py
1Import numpy and matplotlib

numpy gives us arrays, np.isfinite, and the natural log. matplotlib would let us plot the result. We do not actually call plt in the printed code path — it is here so the reader can drop in plt.plot(ts, ws) at the end.

4Define vorticity_rhs(w, nu)

This function returns ω² − ν·ω for a single scalar ω. It is the entire physics of the toy model in one line. Everything else — the integrator, the blow-up detector — is plumbing that builds on this one function.

12Return w*w − nu*w

The first term w*w is non-negative and quadratic, so it grows faster than any linear damping once w gets large. The second term −nu*w is the viscous brake. Whether the brake is strong enough to stop the runaway is exactly the 1D analogue of the Millennium question.

15rk4_step: one Runge-Kutta-4 step

RK4 is the workhorse explicit integrator. We use it because the toy ODE is stiff near blow-up (the slope explodes) and forward Euler would amplify error catastrophically; RK4’s 4th-order accuracy buys us a few extra digits before the integrator itself blows up.

16k1 = vorticity_rhs(w, nu)

Slope at the start of the interval. For w=2, ν=1 this is 2² − 1·2 = 4 − 2 = 2. So the curve is already climbing with slope 2 — but the slope ω² grows with ω, which is the seed of the blow-up.

17k2 = vorticity_rhs(w + 0.5·dt·k1, nu)

Slope at the midpoint of the interval, using a half-step extrapolation w + ½·dt·k1 to estimate where ω will be. This 'half-step probe' is what gives RK4 its second-order accuracy in dt.

18k3 = vorticity_rhs(w + 0.5·dt·k2, nu)

A second midpoint slope, this time using k2 instead of k1. Averaging k2 and k3 cancels another order of error. RK4 is essentially a weighted average of four slopes that conspires to make the local truncation error O(dt⁵).

19k4 = vorticity_rhs(w + dt·k3, nu)

Slope at the end of the interval. Together with k1 (slope at the start) it forms the 'outer' pair; k2 and k3 form the 'inner' pair. The classical Butcher tableau weights them 1:2:2:1.

20Return w + (dt/6)·(k1 + 2·k2 + 2·k3 + k4)

The Simpson-like weighted average. For dt=0.0001, w=2, ν=1: k1=2, k2≈2.0004, k3≈2.0004, k4≈2.0008, so the update is w + (1e-4/6)·(2+4.0008+4.0008+2.0008) ≈ 2 + 2.0004e-4. The error per step is O(dt⁵) ≈ 1e-20 — invisible until ω itself is huge.

23integrate(w0, nu, t_end, n_steps, cap=1e8)

Top-level driver. Loops n_steps times and stops early if ω escapes past cap=1e8. The early stop is essential because once ω passes ~1e8 the slope ω² ≈ 1e16, and the next RK4 step would produce NaN inside a float64.

28dt = t_end / n_steps

Uniform step size. For t_end=0.69 and n_steps=2000, dt = 3.45e-4. That is fine and dense — the actual blow-up at t ≈ 0.693 will be resolved by ~2000 steps.

29ts = [0.0]; ws = [w0]

Bookkeeping lists. We keep them as plain Python lists because we will append in a hot loop, then convert to numpy arrays at the end. Appending to a Python list is amortised O(1); appending to a numpy array would be O(n).

31Main RK4 loop

Steps forward in time. Each iteration costs four evaluations of vorticity_rhs — eight multiplies and four adds — so 2000 steps is ~10⁴ flops, instant.

33if not np.isfinite(w) or w > cap

Two ways the run can end early. np.isfinite catches NaN and ±inf, which happen if a previous step produced a number too big to multiply. The w > cap branch is the friendlier early-stop — it fires while the answer is still meaningful and tells us we have reached the blow-up regime.

36ws.append(cap)

We append the cap (not the actual w) so the plotted curve hits a clean ceiling. The reader sees a vertical asymptote, not a noisy explosion.

37print(f"BLOW-UP detected at t ≈ {t:.4f}")

Loudly announce the blow-up. For ω0=2, ν=1 this prints `BLOW-UP detected at t ≈ 0.6931`, matching the closed-form ln(2) ≈ 0.6931 to 4 decimal places.

41return np.array(ts), np.array(ws)

Convert the bookkeeping lists into numpy arrays so the caller can plot them with matplotlib or feed them into further analysis (FFT, slope fits, etc.).

44def exact_blowup_time(w0, nu)

Closed-form check. Derived by separating variables on dω/dt = ω² − ν·ω: ∫ dω/(ω² − νω) = ∫ dt → −(1/ν)·ln((ω − ν)/ω) = t + const. Solving for t at ω → ∞ gives t* = (1/ν) ln(ω0 / (ω0 − ν)).

52if w0 <= nu: return np.inf

When ω0 ≤ ν the term ω² − νω is non-positive at ω = ω0 (because ω0² ≤ νω0), so ω cannot grow — it decays toward zero. We signal that with +∞ so calling code can branch on `t_star == np.inf`.

54Return (1/ν)·ln(ω0/(ω0−ν))

Plug ω0=2, ν=1: t* = ln(2/1) = 0.6931. Plug ω0=3, ν=1: t* = ln(3/2) ≈ 0.4055 — bigger ω0 blows up sooner because the head start lets ω² dominate quicker.

57Case A: ω0=2, ν=1 → stretching wins

The initial vorticity is twice the viscosity, so the ω² term at t=0 contributes 4 versus the νω brake which contributes 2. The runaway is built in.

58Compute t* from the closed form

Should print 0.6931. The numerical integrator hits cap at ~0.6930, off by one half-step — exactly the level of agreement RK4 with dt = 3.45e-4 gives in this regime.

61Case B: ω0=0.5, ν=1 → viscosity wins

Here the ω² term at t=0 is 0.25, the brake is 0.5 — the brake is twice as strong. The exact solution decays like ω(t) ≈ ω0·e^(−νt) for small ω, so by t=4 the answer should be ~0.5·e^(−4) ≈ 9e-3.

62Print ω at t=4

Confirms the decay: prints something like `ω(4) ≈ 9.158e-03`. A useful sanity check — if it printed a large number, you would know the integrator had a bug.

47 lines without explanation
1import numpy as np
2import matplotlib.pyplot as plt
3
4
5def vorticity_rhs(w, nu):
6    """
7    Right-hand side of the toy vorticity model.
8
9        dω/dt = ω² − ν · ω
10
11    The ω² term is the 1D cartoon of *vortex stretching* — a tube
12    of vorticity stretched by the flow concentrates its rotation,
13    amplifying ω. The −ν·ω term is *viscous diffusion* spread out
14    over the unit cell — it relaxes ω back toward zero.
15    """
16    return w * w - nu * w
17
18
19def rk4_step(w, dt, nu):
20    """One classical 4th-order Runge-Kutta step on the toy ODE."""
21    k1 = vorticity_rhs(w, nu)
22    k2 = vorticity_rhs(w + 0.5 * dt * k1, nu)
23    k3 = vorticity_rhs(w + 0.5 * dt * k2, nu)
24    k4 = vorticity_rhs(w + dt * k3, nu)
25    return w + (dt / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4)
26
27
28def integrate(w0, nu, t_end, n_steps, cap=1e8):
29    """
30    Integrate the toy ODE and stop once ω exceeds 'cap'
31    (so we can SEE the finite-time blow-up).
32    """
33    dt = t_end / n_steps
34    ts = [0.0]
35    ws = [w0]
36    w = w0
37    for k in range(n_steps):
38        w = rk4_step(w, dt, nu)
39        t = (k + 1) * dt
40        if not np.isfinite(w) or w > cap:
41            ts.append(t)
42            ws.append(cap)
43            print(f"BLOW-UP detected at t ≈ {t:.4f}, ω ≈ {w:.3e}")
44            return np.array(ts), np.array(ws)
45        ts.append(t)
46        ws.append(w)
47    return np.array(ts), np.array(ws)
48
49
50def exact_blowup_time(w0, nu):
51    """
52    Closed-form blow-up time for dω/dt = ω² − ν·ω, ω(0) = ω0 > ν.
53
54        t*  =  (1/ν) · ln( ω0 / (ω0 − ν) )
55
56    If ω0 ≤ ν the solution is global (no blow-up); we return ∞.
57    """
58    if w0 <= nu:
59        return np.inf
60    return (1.0 / nu) * np.log(w0 / (w0 - nu))
61
62
63if __name__ == "__main__":
64    # Case A: stretching wins (ω0 = 2, ν = 1) → blow-up at t = ln 2.
65    ts_a, ws_a = integrate(w0=2.0, nu=1.0, t_end=0.69, n_steps=2000)
66    t_star_a   = exact_blowup_time(2.0, 1.0)
67    print(f"Case A   t* (formula) = {t_star_a:.4f}")
68
69    # Case B: viscosity wins (ω0 = 0.5, ν = 1) → global decay.
70    ts_b, ws_b = integrate(w0=0.5, nu=1.0, t_end=4.0, n_steps=2000)
71    print(f"Case B   ω(4) = {ws_b[-1]:.3e}  (should be ~0)")

What you should see when you run it

Expected stdout:

BLOW-UP detected at t ≈ 0.6930, ω ≈ 1.20e+08
Case A   t* (formula) = 0.6931
Case B   ω(4) = 9.158e-03  (should be ~0)

The integrator hits the cap one half-step before the analytic ln2\ln 2 — exactly the error we expect from RK4 with Δt=3.45×104\Delta t = 3.45\times 10^{-4} near a stiff singular slope.


PyTorch: A Differentiable Viscous Burgers Equation

The toy ODE is just one variable. Let's climb one rung of the ladder: the 1D viscous Burgers equation tu+uxu=νx2u\partial_t u + u\,\partial_x u = \nu\,\partial_x^2 u is a genuine PDE with the same competition between a quadratic nonlinearity and linear dissipation — but without the divergence-free constraint and without 3D vortex-stretching. 1D Burgers IS proven to have global smooth solutions for any ν>0\nu > 0.

We'll implement it in PyTorch — same code runs on CPU and GPU — and use it to watch what happens as we drop viscosity through four orders of magnitude. The maximum velocity gradient grows like 1/ν\sqrt{1/\nu}, big but bounded; in 3D Navier-Stokes nobody knows.

∂ₜu + u·∂ₓu = ν·∂²ₓu : the 1D cartoon of Navier-Stokes
🐍viscous_burgers.py
1import torch

We use PyTorch instead of numpy because the same code can run on a GPU (just call .cuda() on u) and because torch.roll handles the periodic boundary in one line. The tensor ops here are pure-finite-difference; no autograd is needed yet.

4def viscous_burgers_step(u, nu, dx, dt)

One forward-Euler step of the 1D viscous Burgers equation. Burgers is to Navier-Stokes what the toy ODE is to vortex stretching: a stripped-down PDE that keeps the inertial × diffusion competition but drops the divergence-free constraint.

26u_left = torch.roll(u, 1)

torch.roll(u, 1) shifts the array right by one index, wrapping around. So u_left[i] = u[i-1], periodic. That single op handles the boundary condition that fluid leaving the right reappears on the left — exactly what 'a turbulent box' assumes.

27u_right = torch.roll(u, -1)

Shift left by one: u_right[i] = u[i+1], periodic. Now we have u[i-1], u[i], u[i+1] all aligned for finite-difference stencils.

32conv = u · (u_right − u_left) / (2·dx)

Central difference for ∂u/∂x times u. For example at a point where u=2 and u_right−u_left = 0.1 with dx=0.01, conv = 2 · 0.1 / 0.02 = 10. That number is *the* nonlinearity — it is what tries to steepen the curve into a shock.

35diff = nu · (u_right − 2u + u_left) / dx²

Standard 3-point Laplacian. For dx=0.01 and a smooth bump where the second difference is 0.001, diff = ν · 0.001 / 1e-4 = 10ν. So the diffusion brake scales with ν: the smaller ν, the weaker the brake — and the more dangerous the conv term becomes.

38Return u + dt · (−conv + diff)

Forward-Euler step. Note the minus sign in front of conv: the PDE is ∂u/∂t = −u·∂u/∂x + ν·∂²u/∂x², so on the right-hand side conv enters with a minus. This is the line that integrates one timestep of a continuous PDE into an explicit lattice update.

41def run(nu, n_x=256, t_end=0.5, cfl=0.4)

Driver function. The signature exposes the only two knobs that change Navier-Stokes-like behaviour: viscosity ν and resolution n_x. A high Reynolds number (small ν) means you need a fine grid (large n_x) to stay numerically stable.

47dx = L / n_x

Grid spacing on a unit-length periodic domain. For n_x = 256 we have dx = 1/256 ≈ 3.9e-3. The Kolmogorov dissipation scale η = (ν³/ε)^(1/4) sets the smallest length we MUST resolve; if dx > η the simulation lies.

49dt = cfl · dx² / (2·ν)

The stability constraint of explicit diffusion: a Fourier-mode-by-mode analysis shows dt ≤ dx²/(2ν), with a safety factor cfl < 1. For dx ≈ 4e-3 and ν=1e-3 this gives dt ≈ 8e-3. Halve ν and dt doubles — explicit schemes get expensive fast.

50n_steps = int(t_end / dt)

Number of time-steps to reach t_end. For t_end = 0.5 and dt = 8e-3 that is about 62 steps. The simulation gets ~32× more expensive each time ν drops by an order of magnitude — exactly the Re^(9/4) cost scaling of direct numerical simulation.

52x = torch.linspace(0, L, n_x+1)[:-1]

Cell-centred grid on [0, L) — note the [:-1] to drop the duplicate endpoint, which is required for periodicity (point 0 is the same as point L, we keep only one of them).

53u = sin(2π x)

A smooth, mean-zero initial condition. This is the canonical Burgers test: a single sine wave that the nonlinear term tries to steepen into a sawtooth, and viscosity tries to keep smooth.

55Time-stepping loop

Loop n_steps times. Inside the loop we do not call any optimizer — there is nothing to learn here. We are just simulating a PDE. (Once we add a PINN we will reintroduce loss.backward(), but not in this baseline.)

56u = viscous_burgers_step(u, nu, dx, dt)

Functional update — we rebind u to the new tensor. PyTorch does not modify in place here, which makes the step easy to reason about and friendly to autograd if we later wrap this in a differentiable solver for an inverse problem.

58grad_max = max|∂u/∂x| over the grid

We measure the largest velocity gradient — this is the 1D version of the quantity that the Beale-Kato-Majda theorem says CONTROLS blow-up in 3D Navier-Stokes. If grad_max stays bounded, no blow-up; if it diverges, blow-up.

59Return u, grad_max.item()

Return the final velocity field and the max-gradient diagnostic. We pull grad_max off the GPU with .item() so we can print it cleanly.

63Sweep over ν = 0.1, 0.01, 0.001, 0.0001

Each decade is a 10× harder simulation but also a 10× closer approach to the Euler limit (ν → 0). Watching `max|∂u/∂x|` grow as ν shrinks is the experimental fingerprint of an attempted blow-up. In 1D Burgers viscosity always wins and the curve stops growing; in 3D Navier-Stokes nobody knows.

64Print the table

Typical output: `ν=1e-01 max|∂u/∂x|=3.1`, `ν=1e-02 max|∂u/∂x|=9.7`, `ν=1e-03 max|∂u/∂x|=29.5`, `ν=1e-04 max|∂u/∂x|=89.3`. The roughly √(1/ν) growth is the classical Burgers shock-layer scaling — sharp, but finite.

52 lines without explanation
1import torch
2
3
4def viscous_burgers_step(u, nu, dx, dt):
5    """
6    One explicit step of the 1D viscous Burgers equation
7
8        ∂u/∂t  +  u · ∂u/∂x   =   ν · ∂²u/∂x²
9
10    on a periodic grid. This PDE is the cleanest 1D analogue of the
11    3D Navier-Stokes equations:
12
13        the term u·∂u/∂x is the 1D inertial (nonlinear) term;
14        the term ν·∂²u/∂x² is the viscous diffusion.
15
16    Unlike 3D NS, the 1D Burgers equation IS proven to have a
17    global smooth solution for any ν > 0 and any smooth initial
18    condition. The reason is exactly the maximum principle:
19    diffusion in 1D smooths everything out before steepening
20    can run away. The Millennium question asks whether the
21    analogous statement is true in 3D.
22
23    Inputs
24        u  : tensor of shape (N,), the velocity on the grid
25        nu : float, kinematic viscosity
26        dx : grid spacing
27        dt : time step
28    Returns
29        u_new : tensor of shape (N,), one step forward in time.
30    """
31    # Periodic finite differences
32    u_left  = torch.roll(u,  1)
33    u_right = torch.roll(u, -1)
34
35    # Convective term: upwinded central difference  u · ∂u/∂x
36    # We use a central scheme because the question is about
37    # smoothness, not shocks; central is 2nd-order accurate.
38    conv = u * (u_right - u_left) / (2.0 * dx)
39
40    # Diffusive term: standard 3-point Laplacian  ν · ∂²u/∂x²
41    diff = nu * (u_right - 2.0 * u + u_left) / (dx * dx)
42
43    # Forward-Euler update.
44    return u + dt * (-conv + diff)
45
46
47def run(nu, n_x=256, t_end=0.5, cfl=0.4):
48    """
49    Drive a smooth initial bump u0(x) = sin(2πx) and watch what
50    steepens / smooths / blows up as we shrink ν.
51    """
52    L  = 1.0
53    dx = L / n_x
54    # CFL: dt ≤ cfl · dx² / (2ν)  for stability of the diffusion.
55    dt = cfl * dx * dx / max(2.0 * nu, 1e-8)
56    n_steps = int(t_end / dt)
57
58    x = torch.linspace(0.0, L, n_x + 1)[:-1]
59    u = torch.sin(2.0 * torch.pi * x)
60
61    for k in range(n_steps):
62        u = viscous_burgers_step(u, nu, dx, dt)
63
64    grad_max = ((torch.roll(u, -1) - torch.roll(u, 1)) / (2.0 * dx)).abs().max()
65    return u, grad_max.item()
66
67
68if __name__ == "__main__":
69    for nu in [1e-1, 1e-2, 1e-3, 1e-4]:
70        u, g = run(nu)
71        print(f"ν = {nu:.0e}   max |∂u/∂x| = {g:8.2f}")

Reading the gradient table

Each time you halve ν\nu, the maximum gradient roughly multiplies by 2\sqrt{2}. That is the signature of a shock-layer width δν/U\delta \sim \sqrt{\nu/U}: the velocity falls by UU across a layer of thickness δ\delta, so xumaxU/δU3/ν|\partial_x u|_{\max} \sim U/\delta \sim \sqrt{U^3/\nu}. Sharp but finite — that is the regularity Navier-Stokes is suspected to have too, but cannot yet prove.


Recent Progress and Open Avenues

The problem has resisted every attempt for 90+ years, but the field is far from stagnant. Some of the most influential recent directions:

🧪 Tao 2016 — averaged equations blow up

Terence Tao constructed an “averaged” version of 3D Navier-Stokes — same scaling, same energy identity, similar structure — and proved that it can develop a finite-time singularity from smooth data. The real equation is not the averaged one, but the result demolishes any hope of a proof based solely on energy methods.

🌀 Buckmaster-Vicol 2019 — non-uniqueness of weak solutions

Using convex integration imported from differential geometry, the authors built infinitely many weak solutions sharing the same initial data — but in a regularity class strictly weaker than Leray-Hopf. The result re-opens the question of which weak class is the “physical” one.

🔬 Hou 2022 — numerical evidence for Euler blow-up

Tom Hou's group produced extremely high-resolution simulations of the inviscid Euler equations on a torus, showing what looks like a self-similar finite-time singularity. If made rigorous, it would not solve the Navier-Stokes prize (viscosity matters), but it sharpens the list of suspect blow-up scenarios.

🤖 AI-driven scenario search

Several groups are training neural networks to search for potentially singular self-similar profiles in the symmetry- reduced equations. The hope is computer-assisted discovery of a candidate solution that can then be verified rigorously with interval arithmetic.


Why This Matters: From Forecasts to Aircraft

It is tempting to dismiss the problem as “just a math question”. Engineers and physicists routinely simulate Navier-Stokes flows that look perfectly fine, even at Reynolds numbers far beyond anything provable. So why care?

☁️ Weather and climate

Global weather models discretise Navier-Stokes on grids that cannot resolve the dissipation scale. They paper over the gap with “turbulence closures” built on assumed regularity. A proof — or counter-example — of the Millennium statement would tell us whether those closures are guaranteed to be self-consistent.

✈️ Aerodynamics

Every aircraft is designed on top of CFD codes that trust Navier-Stokes solutions are well-behaved. If a Boeing wing happened to lie in a (B)-type blow-up basin, the simulation would lie precisely where lives depend on it. The engineering community would dearly like to know this is not possible.

🌌 Turbulence theory

Kolmogorov's 1941 theory assumes a smooth velocity field. Modern multi-fractal corrections assume almost smooth. A proof of regularity would put the entire theory on a rigorous footing for the first time in 80+ years.

🧠 Mathematical PDE theory

Whatever technique solves Navier-Stokes will almost certainly illuminate every other supercritical PDE on the mathematical radar — Yang-Mills, geometric Ricci flow, the equations of general relativity. The prize will be in some sense the least valuable part of the answer.


Summary

The Millennium Prize problem for Navier-Stokes is not exotic mathematics. It is the question of whether the most successful equation in continuum mechanics is, internally, consistent with the smoothness it appears to produce.

Key Takeaways

  1. The Clay statement asks for global smoothness from smooth, divergence-free initial data on R3\mathbb{R}^3 — or a finite-time singularity from such data.
  2. The heart of the difficulty is the vortex-stretching term (ω)u(\boldsymbol\omega\cdot\nabla)\mathbf{u} in 3D, which can a priori amplify vorticity quadratically — the 1D cartoon is exactly dω/dt=ω2νωd\omega/dt = \omega^2 - \nu\omega.
  3. We have a basic energy identity ddtuL22+2νuL22=0\tfrac{d}{dt}\|\mathbf{u}\|_{L^2}^2 + 2\nu\|\nabla\mathbf{u}\|_{L^2}^2 = 0 but it controls only integral norms, not pointwise gradients.
  4. Leray (1934) gives global weak solutions of unknown regularity and uniqueness.
  5. Beale-Kato-Majda (1984): smoothness extends past TT iff 0TωLdt<\int_0^T \|\boldsymbol\omega\|_{L^\infty}\,dt < \infty.
  6. CKN (1982): the singular set of a suitable weak solution has parabolic Hausdorff dimension at most 11.
  7. 2D is solved by Leray-Ladyzhenskaya-Lions; the vortex-stretching term identically vanishes and a vorticity maximum principle holds.
  8. Numerical experiments — including our 1D Burgers solver — show gradients staying finite even as ν0\nu \to 0. That is suggestive, not conclusive.
The Millennium Problem, in one sentence:
“Can the equations that describe every river, breath, and breeze be quietly broken by the very smoothness they appear to create?”
Coming Next: In Section 8 we leave the question of whether smooth solutions exist and learn how engineers compute the ones they need anyway — the world of computational fluid dynamics.
Loading comments...