Lyapunov Exponent

Definition

Take a deterministic system and run two copies of it that start almost — but not exactly — in the same state. Call their initial separation δ₀ (a tiny number). The Lyapunov exponent λ is the average exponential rate at which that separation grows or shrinks:

δ(t) = δ₀ · e^(λt)

Solve for λ and average over a long trajectory:

λ = lim (t→∞)  (1/t) · ln( δ(t) / δ₀ )

The sign of λ tells you everything about the system's character:

• λ > 0 — nearby states fly apart exponentially. The system is chaotic: sensitive dependence on initial conditions, the butterfly effect.
• λ = 0 — neutral. Errors grow at most polynomially (a marginal, conservative, or quasiperiodic system).
• λ < 0 — states converge. The system relaxes onto a stable fixed point or limit cycle; tiny errors heal themselves.

The units of λ are inverse time (s⁻¹). If you take the logarithm in base 2 instead of base e, λ comes out in bits per second — the rate at which the system destroys information about its initial state.

How it works

The deep idea is stretching plus folding. In a bounded chaotic system, trajectories cannot actually separate forever — the state space is finite, so the divergence cannot literally continue to infinity. Instead the dynamics repeatedly stretches a little blob of nearby states (that is the e^(λt) growth) and then folds it back over itself to keep everything bounded — like a baker kneading dough, stretching and folding, stretching and folding. The Lyapunov exponent captures the local stretching rate, averaged over the whole attractor.

Because the stretching is exponential, the curve of log-separation versus time is a straight line, and its slope is λ. This is the single most useful picture to carry around: plot ln δ(t) against t, fit a line, read off the slope. That is exactly what the interactive scene above does — two dots start a hair apart, peel away from each other, and the running log-distance traces out a line whose slope is the exponent.

For a system with more than one dimension there is not one exponent but a whole spectrum. Imagine the tiny ball of initial conditions around your starting point. As the flow evolves, that ball deforms into an ellipsoid. Each principal axis stretches (or shrinks) at its own rate, giving exponents λ₁ ≥ λ₂ ≥ … ≥ λₙ. The largest, λ₁ — the maximal Lyapunov exponent — wins the long-term race and is what people usually mean by "the" Lyapunov exponent.

A worked example: how far can you predict?

Suppose you are tracking a chaotic system with a measured maximal Lyapunov exponent of λ = 0.9 per second. Your sensors pin down the initial state to a relative precision of δ₀ = 10⁻⁶ (one part in a million — quite good). You declare a forecast "useless" once the error grows to order 1.

Use the horizon formula:

T ≈ (1/λ) · ln(1/δ₀)
  = (1 / 0.9) · ln(10⁶)
  = 1.111 · 13.816
  ≈ 15.4 seconds

So with a million-fold-precise measurement you can predict for about 15 seconds. Now the sobering part. Suppose you spend a fortune and improve your instrument a thousand-fold, to δ₀ = 10⁻⁹. The new horizon:

T ≈ (1 / 0.9) · ln(10⁹)
  = 1.111 · 20.723
  ≈ 23.0 seconds

A thousand times better data bought you about 7.7 extra seconds. That is the tyranny of the logarithm: each factor-of-e improvement in initial precision adds exactly one Lyapunov time (1/λ ≈ 1.11 s here) to the horizon. To double the 15-second forecast you would need to square the precision — improve your measurement to δ₀ = 10⁻¹². The wall is not technological; it is mathematical.

Lyapunov times in the wild

System	Max λ (approx.)	Lyapunov time τ = 1/λ	Consequence
Earth's atmosphere (weather)	≈ 0.4–0.7 / day	≈ 1.5–2.5 days	~2-week practical forecast ceiling
Inner Solar System orbits	≈ 2×10⁻⁷ / yr	≈ 5 million years	Planet positions unpredictable past ~100 Myr
Double pendulum (energetic)	≈ 5–10 / s	≈ 0.1–0.2 s	Path diverges within a swing or two
Lorenz system (σ=10, ρ=28, β=8/3)	≈ 0.906 / time-unit	≈ 1.1 time-units	Canonical textbook chaos
Logistic map at r = 4	ln 2 ≈ 0.693 / step	≈ 1.44 steps	Loses ~1 bit of precision per iteration
Chaotic electronic circuit (Chua)	≈ 10³–10⁵ / s	microseconds	Used as a hardware noise/entropy source
Healthy heart-rate variability	small positive	seconds–minutes	Mild chaos = healthy; too regular can signal disease

Regimes and the full spectrum

The sign pattern of the exponent spectrum classifies the dynamics cleanly. For a continuous flow, one exponent is always zero (the direction along the trajectory itself — nudging "forward in time" neither grows nor shrinks).

Spectrum signs	Attractor type	Behavior
(−, −, −)	Stable fixed point	Everything decays to a point; errors heal
(0, −, −)	Limit cycle	Stable periodic orbit; no chaos
(0, 0, −)	Torus (quasiperiodic)	Two incommensurate frequencies; still predictable
(+, 0, −)	Strange attractor	Chaos: stretch (+), flow (0), contract (−)
(+, +, …)	Hyperchaos	Two or more independent stretching directions

Two further facts pin down the geometry. For a dissipative system the exponents must sum to a negative number, Σλᵢ < 0 — phase-space volume shrinks, which is what makes an attractor an attractor. For a Hamiltonian (conservative) system the exponents come in ± pairs that sum to zero, so volume is preserved exactly (Liouville's theorem). And the Kaplan–Yorke dimension stitches the spectrum into the fractal dimension of the attractor, linking "how fast it stretches" to "how crinkled it is."

Estimating λ from data — Python

# Maximal Lyapunov exponent of the logistic map x -> r*x*(1-x).
# For 1D maps, lambda is the time-average of ln|f'(x)|.
import math

def logistic_lyapunov(r, n=100_000, warmup=1000):
    x = 0.123456            # arbitrary seed inside (0,1)
    for _ in range(warmup): # let the orbit settle onto the attractor
        x = r * x * (1 - x)
    total = 0.0
    for _ in range(n):
        deriv = r * (1 - 2 * x)        # f'(x) = r(1 - 2x)
        total += math.log(abs(deriv))  # accumulate ln|f'|
        x = r * x * (1 - x)
    return total / n                   # average slope = lambda

print(logistic_lyapunov(3.2))   # ~ -0.31  -> stable 2-cycle (lambda < 0)
print(logistic_lyapunov(3.5))   # ~ -0.87  -> stable 4-cycle
print(logistic_lyapunov(3.83))  # ~ -0.20  -> period-3 window (order returns!)
print(logistic_lyapunov(4.0))   # ~ +0.693 = ln 2  -> full chaos (lambda > 0)

The clean result λ = ln 2 ≈ 0.693 at r = 4 says the map loses exactly one bit of information about its initial condition per step — after 50 iterations, 50 bits of your starting precision are gone. That is the information-theoretic face of the same exponent.

Why renormalization is required — JavaScript

For a flow you evolve the state alongside a tiny separation vector, but you cannot just let that vector grow as e^(λt) — it would overflow to infinity in microseconds. The trick (the Benettin algorithm) is to renormalize the separation back to a fixed small size on every step and accumulate the logs of the stretch factors.

// Maximal Lyapunov exponent of the Lorenz system via Benettin's method.
function lorenzMaxLyapunov({ sigma = 10, rho = 28, beta = 8 / 3,
                             dt = 0.001, steps = 2_000_000, d0 = 1e-8 } = {}) {
  const f = (s) => [
    sigma * (s[1] - s[0]),
    s[0] * (rho - s[2]) - s[1],
    s[0] * s[1] - beta * s[2],
  ];
  const rk4 = (s) => {            // one Runge–Kutta 4 step
    const a = f(s);
    const b = f(s.map((v, i) => v + 0.5 * dt * a[i]));
    const c = f(s.map((v, i) => v + 0.5 * dt * b[i]));
    const e = f(s.map((v, i) => v + dt * c[i]));
    return s.map((v, i) => v + (dt / 6) * (a[i] + 2 * b[i] + 2 * c[i] + e[i]));
  };

  let x = [1, 1, 1];
  for (let i = 0; i < 10000; i++) x = rk4(x);   // settle onto the attractor
  let xp = [x[0] + d0, x[1], x[2]];             // perturbed twin, distance d0

  let sumLogs = 0, counted = 0;
  for (let i = 0; i < steps; i++) {
    x = rk4(x); xp = rk4(xp);
    const dx = xp.map((v, j) => v - x[j]);
    const dist = Math.hypot(...dx);
    sumLogs += Math.log(dist / d0);             // log of this step's stretch
    counted++;
    const k = d0 / dist;                        // renormalize twin back to d0
    xp = x.map((v, j) => v + dx[j] * k);
  }
  return sumLogs / (counted * dt);              // -> ~0.906
}

console.log(lorenzMaxLyapunov().toFixed(3));    // 0.906

The cost is one extra trajectory plus a square root per step — O(1) overhead per integration step, O(steps) total. The result, λ ≈ 0.906, gives a Lyapunov time of about 1.1 time-units: integrate the Lorenz equations forward from two states 10⁻⁸ apart and they will be visibly on opposite wings of the butterfly within ~20 time-units.

Where the Lyapunov exponent shows up

• Weather and climate. The atmosphere's λ caps useful weather forecasts at roughly two weeks — Edward Lorenz discovered this in 1963 and coined the butterfly effect. Ensemble forecasting (running many slightly perturbed initial states) is a direct response to λ > 0.
• Celestial mechanics. The Solar System is mildly chaotic with a Lyapunov time near 5 million years, so planetary positions cannot be predicted beyond ~100 million years even with perfect models.
• Engineering and control. Chaos control (the OGY method) stabilizes chaotic systems by exploiting the unstable directions that λ identifies; conversely, "anti-control" deliberately makes λ positive to enhance mixing.
• Cryptography and RNGs. Chaotic maps with large λ are used as entropy sources and stream-cipher cores precisely because they shred initial-condition information fast.
• Biology and medicine. Lyapunov analysis of heart-rate and EEG time series probes the difference between healthy variability and pathological states; epileptic seizures are associated with shifts in the exponent.
• Lasers, fluids, and plasmas. Turbulence, laser instabilities, and plasma confinement all live or die by their Lyapunov spectra, which set mixing and decorrelation rates.

Common pitfalls and misconceptions

• "Chaotic means random." No. Chaos is fully deterministic — same initial state, same future, every time. The unpredictability is entirely about finite precision being amplified by λ > 0, not about any randomness in the rules.
• Reporting one number for a multidimensional system. There is a whole spectrum λ₁ ≥ … ≥ λₙ. "The" exponent usually means the maximal one, λ₁, but the rest carry the dissipation and dimension information.
• Forgetting to renormalize. Naively tracking δ(t) overflows almost instantly. You must periodically rescale the separation vector and sum the logs (Benettin/Wolf), or the computed λ is garbage.
• Treating λ > 0 as constant in time. λ is a long-time average. The local stretching rate fluctuates wildly along the orbit — some regions contract even in a chaotic system. Short windows give noisy estimates.
• Confusing it with the prediction horizon directly. λ has units of 1/time; the horizon T depends on λ and on your initial precision δ₀ through the logarithm. Halving λ doubles the horizon; improving δ₀ helps only logarithmically.
• Assuming λ > 0 forbids any forecasting. You can still forecast comfortably within a few Lyapunov times. λ tells you when to give up, not that forecasting is impossible from the start.

Derivation sketch and the logarithm wall

Linearize the dynamics about a trajectory x(t). A small perturbation δ obeys the variational equation dδ/dt = J(t)·δ, where J is the Jacobian of the flow evaluated along the orbit. The growth of |δ| over a long time is governed by the product of the per-step linear maps; taking the log of the largest singular value of that product and dividing by t gives, in the limit, the maximal Lyapunov exponent (this limit existing is the content of Oseledets' multiplicative ergodic theorem, 1968).

The horizon formula then falls out by inverting the divergence law. Set δ(T) = δ_max (the error level at which forecasts fail) in δ(T) = δ₀·e^(λT):

δ_max = δ₀ · e^(λT)
  →  T = (1/λ) · ln(δ_max / δ₀)
  ≈  (1/λ) · ln(1/δ₀)        (taking δ_max ≈ 1)

That logarithm is the whole story of why chaos is a practical death sentence for long-range prediction. Predictability scales like the logarithm of your effort: throwing 10× the precision at the problem adds a fixed, small ln 10 ≈ 2.3 Lyapunov times to the horizon, every time, forever. You don't hit diminishing returns — you hit a logarithmic wall.