Consistency was only half the promise
In the last guide you built a finite-difference scheme and measured its truncation error: you plugged the exact solution into the discrete formula, Taylor-expanded, and watched the mismatch shrink like a power of the grid spacing. A scheme whose truncation error goes to zero as the grid refines is called consistent — it means the discrete equation really is trying to be the PDE in the limit. That feels like it should be the whole story. Shrink the grid, shrink the error, done. It is not the whole story, and the reason is one of the most important lessons in all of numerical PDEs.
Truncation error measures one step: how badly the discrete formula misrepresents the PDE at a single point, for one application. But a real computation chains thousands of steps together, each one fed the slightly wrong output of the last. The question that matters is not how small one step's error is — it is whether those errors, marching forward together, stay bounded or feed on each other and grow without limit. A scheme can be beautifully consistent, with truncation error vanishing as fast as you like, and still produce a numerical answer that overflows to nonsense in a dozen time steps. Consistency controls the input of error at each step; it says nothing about whether the scheme amplifies error as it runs.
Watch a consistent scheme blow up
Take the most natural scheme for the heat equation u_t = k u_xx: a forward difference in time, a centred difference in space — the FTCS scheme (forward-time, centred-space) from the previous guide. It is consistent; its truncation error is order (time step) plus order (space step squared). Now run it. With a grid spacing h in x and a step dt in time, group the constants into one dimensionless number r = k dt / h^2. As long as r stays at or below 1/2, the computed temperatures behave: they smooth out, decay, and track the true solution. Push r past 1/2 — make the time step just a little too big — and something violent happens.
FTCS for the heat equation, at grid point j, time level n: U[j, n+1] = U[j,n] + r*( U[j+1,n] - 2*U[j,n] + U[j-1,n] ), with r = k*dt / h^2. r <= 1/2 : errors stay bounded -> the answer converges r > 1/2 : a tiny wiggle doubles every step -> overflow A jagged +1,-1,+1,-1 sawtooth is the most dangerous mode: the bracket becomes -4*(that value), so it is scaled by (1 - 4r). |1 - 4r| > 1 exactly when r > 1/2.
Here is the picture. The roughest thing the grid can represent is a sawtooth that flips sign at every point: +1, -1, +1, -1. Feed that into the FTCS update and the centred-difference bracket turns it into -4 times itself, so after one step the sawtooth is scaled by (1 - 4r). If r is bigger than 1/2, then 1 - 4r is more negative than -1, so |1 - 4r| > 1: the sawtooth flips sign and grows every single step. Round-off noise always contains a whiff of this sawtooth, so even starting from smooth, innocent data, that one mode is selected, amplified, doubled and redoubled, until it drowns everything. This is instability, and consistency did nothing to prevent it.
Von Neumann analysis: ask each wave its growth factor
How did we know 1/2 was the magic threshold, and how do we find it for any scheme? The tool is von Neumann stability analysis, and it borrows the central trick of the whole transforms rung: test the scheme one Fourier mode at a time. On a constant-coefficient grid, a single wave U[j,n] = (g)^n e^(i p j h) is preserved in shape by every linear update — only its amplitude changes from one time level to the next, multiplied by a number g called the amplification factor. Substitute that wave into the scheme and almost everything cancels, leaving g as a tidy formula in the wavenumber p. The scheme is stable exactly when |g| <= 1 for every wavenumber the grid can hold — no mode may grow.
- Substitute the trial wave. Put U[j,n] = (g)^n e^(i p j h) into the scheme. Every j-shift e^(i p (j±1) h) factors as e^(±i p h) times the wave, and the n+1 level brings out one extra power of g.
- Cancel the common wave. The factor (g)^n e^(i p j h) appears in every term, so divide it out. You are left with a single equation for g alone — the PDE-solving has become one line of algebra.
- Read g(p). For FTCS, the bracket gives e^(i p h) - 2 + e^(-i p h) = 2 cos(p h) - 2 = -4 sin^2(p h / 2), so g = 1 - 4 r sin^2(p h / 2).
- Demand |g| <= 1 for all p. The worst case is sin^2 = 1 (the sawtooth, p h = pi), giving g = 1 - 4r. Requiring |1 - 4r| <= 1 forces 0 <= r <= 1/2 — the threshold falls out by itself.
The CFL condition: don't outrun the physics
For wave-like equations the stability limit has a vivid physical meaning, captured by the CFL condition (Courant–Friedrichs–Lewy). Recall from the wave-equation rung that information in a hyperbolic problem travels at a finite speed: the value of the true solution at a point depends only on initial data inside that point's domain of dependence, the cone of places a signal could have reached it from. A finite-difference scheme has its own, discrete domain of dependence — the triangle of earlier grid points that actually feed into U[j,n] through the stencil. The CFL condition is the demand that the numerical cone be at least as wide as the true one.
Why must it? Suppose the numerical cone is too narrow — the true solution at U[j,n] depends on a piece of initial data that lies outside the scheme's stencil-triangle. Then the scheme literally cannot see information that the answer needs; no amount of arithmetic on the points it does see can reconstruct what it never sampled. Refining the grid does not help, because shrinking h and dt together keeps the cones in the same proportion. For the advection equation u_t + a u_x = 0, the cone reaches a distance |a| dt in one step, while the stencil reaches h, so the condition is |a| dt <= h, i.e. the Courant number |a| dt / h must be at most 1. In words: in one time step, the wave must not cross more than one grid cell.
Lax equivalence: the theorem that ties the knot
We now have two separate virtues. Consistency says the discrete equation approaches the PDE as the grid refines — local correctness. Stability says errors do not blow up as the steps accumulate — global control. What we actually want is neither of these on its own; we want convergence: that the computed numbers approach the true solution everywhere as h and dt go to zero. The Lax equivalence theorem is the bridge, and for a well-posed linear initial-value problem it says something startlingly clean.
Here is the precise statement. Take a consistent finite-difference scheme applied to a well-posed linear initial-value problem. Then stability and convergence are equivalent: the scheme converges if and only if it is stable. The half you will use constantly is the forward direction — consistency plus stability gives convergence — which turns a hard, infinite-step question (does the answer approach the truth?) into a single-step, checkable one (is the scheme stable?). The converse, that convergence forces stability, is what makes the equivalence airtight: there is no way to sneak past stability and still converge.
Read it slowly, because it reshapes how you work. Convergence — the thing you ultimately care about — is hard to verify directly: it is a statement about a limit you cannot reach on any finite computer. Consistency you already check with Taylor expansion. Stability you check with one von Neumann calculation. Lax's theorem says that for a consistent scheme on a well-posed problem, stability and convergence are the same thing — each implies the other. So the impossible-looking question "does my computation converge to the truth?" is answered by the two tractable checks you can do at your desk: is it consistent, and is it stable? That is why these three words travel together as a single mantra: consistency plus stability equals convergence.
Two honest cautions. First, the theorem assumes the underlying problem is well-posed — that the true solution depends continuously on its data. Hand it an ill-posed problem like running the heat equation backwards in time, and there is no stable scheme to find; the instability is in the mathematics, not the method, and no clever discretisation rescues it. Second, the classical theorem is a statement about linear problems. Nonlinear conservation laws, where smooth data can sharpen into a shock in finite time, need extra structure (entropy conditions, careful flux schemes) that the next guides take up — Lax equivalence is the foundation, not the final word.
What this buys you, and the trade-off ahead
Stand back and see the whole machine. You no longer test a scheme by running it and hoping; you analyse it on paper. Taylor-expand for consistency, substitute one wave for the amplification factor, and read off the step-size restriction. For FTCS on the heat equation that restriction is r = k dt / h^2 <= 1/2 — and notice the sting in it: because h appears squared, halving the space grid forces you to quarter the time step. Refine the mesh tenfold and you must take a hundred times as many time steps, each on a finer grid. This punishing cost is exactly the weakness that implicit schemes are built to escape, and the trade-off between cheap-but-restricted explicit methods and expensive-but-unconditionally-stable implicit ones is the subject of the very next guide.
One last subtlety worth carrying forward. Stability does not mean accuracy — a stable scheme can still be quietly wrong in a characteristic way. The very thing that tames the sawtooth, the damping built into a scheme, often shows up as artificial numerical diffusion: the computed solution is smeared out, as if it solved a heat equation that was never in the problem. A stable advection scheme can blur a sharp pulse into a gentle hump over many steps. So consistency-stability-convergence guarantees you reach the right answer in the limit, but at any finite resolution you must also watch how the error behaves. Reading a scheme's modified equation — the slightly-different PDE it actually solves — is how you diagnose that, and it threads through every method still to come.