The Real Complexity of the Lorenz System

Introduction

In 1961, meteorologist Edward Lorenz was running a weather simulation on an early computer. To save time he re-entered a printout midway through a run — but typed 0.506 instead of the stored 0.506127. The difference was one part in a thousand. The resulting forecast diverged completely from the original within simulated weeks.

That accident gave birth to chaos theory. Lorenz spent years distilling the phenomenon into its purest mathematical form: three coupled differential equations that model convection in the atmosphere.

dx/dt = σ(y − x)
dy/dt = x(ρ − z) − y
dz/dt = xy − βz

With the classic parameters $\sigma = 10$ , $\rho = 28$ , $\beta = 8/3$ , the solution never repeats and never settles — it traces the now-iconic butterfly shape forever without crossing itself. The system is perfectly deterministic: knowing the exact state pins the future exactly. Yet in practice no measurement is ever exact, and a deviation of one part in a billion doubles roughly every 0.9 seconds of simulated time. After a couple of minutes of model time the trajectories from two almost-identical starts look completely unrelated.

This is not a failure of our equations. It is a property of the equations themselves, and Lorenz proved it is unavoidable for this kind of system.

Watch Two Paths Diverge

Below two trajectories start from almost the same point — differing by just 0.001 in the x-coordinate. Watch them trace the Lorenz butterfly together at first, then peel apart and explore completely different lobes.

<p class="hint">Two trajectories start 0.001 apart in x. Blue = reference path, Red = perturbed path. Watch them trace the Lorenz butterfly together — then fly apart. That is the butterfly effect.</p>
<canvas id="canvas" width="560" height="300"></canvas>
<div class="controls">
  <button id="btnRun" type="button">Run</button>
  <button id="btnReset" type="button" class="ghost">Reset</button>
  <label>Speed <input type="range" id="speed" min="1" max="12" value="4"></label>
</div>
<div id="status" class="status">Press Run to start.</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #fff; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
canvas { display: block; background: #0d1117; border-radius: 8px; width: 100%; max-width: 560px; }
.controls { display: flex; align-items: center; gap: .7rem; flex-wrap: wrap; margin: .6rem 0; }
button { font: 600 14px system-ui; padding: .4rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
label { font-size: .88rem; display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 90px; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.4em; color: #333; }
.status.diverged { color: #c92f3c; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Lorenz system: dx/dt = s(y-x), dy/dt = x(r-z)-y, dz/dt = xy-bz
// Classic parameters: sigma=10, rho=28, beta=8/3.
// Two trajectories start at (0,1,0) and (0.001,1,0).
// We integrate with 4th-order Runge-Kutta and project onto a 2D canvas.
const S = 10, R = 28, B = 8/3;

function lorenz(x, y, z) {
  return [S*(y-x), x*(R-z)-y, x*y-B*z];
}

function rk4(x, y, z, dt) {
  const [k1x,k1y,k1z] = lorenz(x,y,z);
  const [k2x,k2y,k2z] = lorenz(x+dt/2*k1x, y+dt/2*k1y, z+dt/2*k1z);
  const [k3x,k3y,k3z] = lorenz(x+dt/2*k2x, y+dt/2*k2y, z+dt/2*k2z);
  const [k4x,k4y,k4z] = lorenz(x+dt*k3x,   y+dt*k3y,   z+dt*k3z);
  return [
    x + dt/6*(k1x+2*k2x+2*k3x+k4x),
    y + dt/6*(k1y+2*k2y+2*k3y+k4y),
    z + dt/6*(k1z+2*k2z+2*k3z+k4z)
  ];
}

// Project 3D Lorenz state onto 2D canvas.
// We use x-axis → canvas x, z-axis → canvas y (the classic butterfly view).
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;

// Lorenz attractor lives roughly x∈[-20,20], z∈[0,50].
function project(lx, lz) {
  const cx = (lx + 25) / 50 * W;
  const cy = H - (lz / 55) * H;
  return [cx, cy];
}

const DT = 0.005;
let state1, state2, trail1, trail2, animId, running, t;
const MAX_TRAIL = 3000;

function initState() {
  state1 = [0, 1, 0];
  state2 = [0.001, 1, 0];   // perturbed by 0.001 in x
  trail1 = [];
  trail2 = [];
  t = 0;
}

function draw() {
  ctx.clearRect(0, 0, W, H);
  // Draw trail1 (blue)
  if (trail1.length > 1) {
    ctx.beginPath();
    ctx.strokeStyle = 'rgba(80,160,255,0.75)';
    ctx.lineWidth = 1.2;
    const start = Math.max(0, trail1.length - MAX_TRAIL);
    const [x0, y0] = project(trail1[start][0], trail1[start][2]);
    ctx.moveTo(x0, y0);
    for (let i = start+1; i < trail1.length; i++) {
      const [px, py] = project(trail1[i][0], trail1[i][2]);
      ctx.lineTo(px, py);
    }
    ctx.stroke();
  }
  // Draw trail2 (red)
  if (trail2.length > 1) {
    ctx.beginPath();
    ctx.strokeStyle = 'rgba(230,60,60,0.75)';
    ctx.lineWidth = 1.2;
    const start = Math.max(0, trail2.length - MAX_TRAIL);
    const [x0, y0] = project(trail2[start][0], trail2[start][2]);
    ctx.moveTo(x0, y0);
    for (let i = start+1; i < trail2.length; i++) {
      const [px, py] = project(trail2[i][0], trail2[i][2]);
      ctx.lineTo(px, py);
    }
    ctx.stroke();
  }
  // Draw current heads
  if (trail1.length) {
    const [px, py] = project(state1[0], state1[2]);
    ctx.beginPath(); ctx.arc(px,py,3.5,0,2*Math.PI);
    ctx.fillStyle='#50a0ff'; ctx.fill();
  }
  if (trail2.length) {
    const [px, py] = project(state2[0], state2[2]);
    ctx.beginPath(); ctx.arc(px,py,3.5,0,2*Math.PI);
    ctx.fillStyle='#e63c3c'; ctx.fill();
  }
}

function dist3(a, b) {
  return Math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2+(a[2]-b[2])**2);
}

function step() {
  const stepsPerFrame = parseInt(document.getElementById('speed').value, 10);
  for (let i = 0; i < stepsPerFrame * 3; i++) {
    trail1.push([...state1]);
    trail2.push([...state2]);
    state1 = rk4(...state1, DT);
    state2 = rk4(...state2, DT);
    t += DT;
  }
  draw();

  const d = dist3(state1, state2);
  const initialD = 0.001;
  const status = document.getElementById('status');
  if (d > 5) {
    status.textContent = fmt('t = %t% — Paths have diverged! Distance = %d% (started at %initialD%)', { t: t.toFixed(1), d: d.toFixed(2), initialD: initialD });
    status.className = 'status diverged';
  } else {
    status.textContent = fmt('t = %t% — Distance between paths: %toExponential%', { t: t.toFixed(1), toExponential: d.toExponential(3) });
    status.className = 'status';
  }

  animId = requestAnimationFrame(step);
}

function startRun() {
  if (running) return;
  running = true;
  document.getElementById('btnRun').textContent = 'Running…';
  document.getElementById('btnRun').disabled = true;
  animId = requestAnimationFrame(step);
}

function reset() {
  if (animId) { cancelAnimationFrame(animId); animId = null; }
  running = false;
  document.getElementById('btnRun').textContent = 'Run';
  document.getElementById('btnRun').disabled = false;
  initState();
  draw();
  document.getElementById('status').textContent = 'Press Run to start.';
  document.getElementById('status').className = 'status';
}

document.getElementById('btnRun').addEventListener('click', startRun);
document.getElementById('btnReset').addEventListener('click', reset);

initState();
draw();

// Node.js verification shim (ignored in browser)
if (typeof module !== 'undefined') {
  module.exports = { rk4, lorenz, dist3 };
}

<p class="hint">Two trajectories start 0.001 apart in x. Blue = reference path, Red = perturbed path. Watch them trace the Lorenz butterfly together — then fly apart. That is the butterfly effect.</p>
<canvas id="canvas" width="560" height="300"></canvas>
<div class="controls">
  <button id="btnRun" type="button">Run</button>
  <button id="btnReset" type="button" class="ghost">Reset</button>
  <label>Speed <input type="range" id="speed" min="1" max="12" value="4"></label>
</div>
<div id="status" class="status">Press Run to start.</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; background: #fff; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
canvas { display: block; background: #0d1117; border-radius: 8px; width: 100%; max-width: 560px; }
.controls { display: flex; align-items: center; gap: .7rem; flex-wrap: wrap; margin: .6rem 0; }
button { font: 600 14px system-ui; padding: .4rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
label { font-size: .88rem; display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 90px; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.4em; color: #333; }
.status.diverged { color: #c92f3c; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Lorenz system: dx/dt = s(y-x), dy/dt = x(r-z)-y, dz/dt = xy-bz
// Classic parameters: sigma=10, rho=28, beta=8/3.
// Two trajectories start at (0,1,0) and (0.001,1,0).
// We integrate with 4th-order Runge-Kutta and project onto a 2D canvas.
const S = 10, R = 28, B = 8/3;

function lorenz(x, y, z) {
  return [S*(y-x), x*(R-z)-y, x*y-B*z];
}

function rk4(x, y, z, dt) {
  const [k1x,k1y,k1z] = lorenz(x,y,z);
  const [k2x,k2y,k2z] = lorenz(x+dt/2*k1x, y+dt/2*k1y, z+dt/2*k1z);
  const [k3x,k3y,k3z] = lorenz(x+dt/2*k2x, y+dt/2*k2y, z+dt/2*k2z);
  const [k4x,k4y,k4z] = lorenz(x+dt*k3x,   y+dt*k3y,   z+dt*k3z);
  return [
    x + dt/6*(k1x+2*k2x+2*k3x+k4x),
    y + dt/6*(k1y+2*k2y+2*k3y+k4y),
    z + dt/6*(k1z+2*k2z+2*k3z+k4z)
  ];
}

// Project 3D Lorenz state onto 2D canvas.
// We use x-axis → canvas x, z-axis → canvas y (the classic butterfly view).
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;

// Lorenz attractor lives roughly x∈[-20,20], z∈[0,50].
function project(lx, lz) {
  const cx = (lx + 25) / 50 * W;
  const cy = H - (lz / 55) * H;
  return [cx, cy];
}

const DT = 0.005;
let state1, state2, trail1, trail2, animId, running, t;
const MAX_TRAIL = 3000;

function initState() {
  state1 = [0, 1, 0];
  state2 = [0.001, 1, 0];   // perturbed by 0.001 in x
  trail1 = [];
  trail2 = [];
  t = 0;
}

function draw() {
  ctx.clearRect(0, 0, W, H);
  // Draw trail1 (blue)
  if (trail1.length > 1) {
    ctx.beginPath();
    ctx.strokeStyle = 'rgba(80,160,255,0.75)';
    ctx.lineWidth = 1.2;
    const start = Math.max(0, trail1.length - MAX_TRAIL);
    const [x0, y0] = project(trail1[start][0], trail1[start][2]);
    ctx.moveTo(x0, y0);
    for (let i = start+1; i < trail1.length; i++) {
      const [px, py] = project(trail1[i][0], trail1[i][2]);
      ctx.lineTo(px, py);
    }
    ctx.stroke();
  }
  // Draw trail2 (red)
  if (trail2.length > 1) {
    ctx.beginPath();
    ctx.strokeStyle = 'rgba(230,60,60,0.75)';
    ctx.lineWidth = 1.2;
    const start = Math.max(0, trail2.length - MAX_TRAIL);
    const [x0, y0] = project(trail2[start][0], trail2[start][2]);
    ctx.moveTo(x0, y0);
    for (let i = start+1; i < trail2.length; i++) {
      const [px, py] = project(trail2[i][0], trail2[i][2]);
      ctx.lineTo(px, py);
    }
    ctx.stroke();
  }
  // Draw current heads
  if (trail1.length) {
    const [px, py] = project(state1[0], state1[2]);
    ctx.beginPath(); ctx.arc(px,py,3.5,0,2*Math.PI);
    ctx.fillStyle='#50a0ff'; ctx.fill();
  }
  if (trail2.length) {
    const [px, py] = project(state2[0], state2[2]);
    ctx.beginPath(); ctx.arc(px,py,3.5,0,2*Math.PI);
    ctx.fillStyle='#e63c3c'; ctx.fill();
  }
}

function dist3(a, b) {
  return Math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2+(a[2]-b[2])**2);
}

function step() {
  const stepsPerFrame = parseInt(document.getElementById('speed').value, 10);
  for (let i = 0; i < stepsPerFrame * 3; i++) {
    trail1.push([...state1]);
    trail2.push([...state2]);
    state1 = rk4(...state1, DT);
    state2 = rk4(...state2, DT);
    t += DT;
  }
  draw();

  const d = dist3(state1, state2);
  const initialD = 0.001;
  const status = document.getElementById('status');
  if (d > 5) {
    status.textContent = fmt('t = %t% — Paths have diverged! Distance = %d% (started at %initialD%)', { t: t.toFixed(1), d: d.toFixed(2), initialD: initialD });
    status.className = 'status diverged';
  } else {
    status.textContent = fmt('t = %t% — Distance between paths: %toExponential%', { t: t.toFixed(1), toExponential: d.toExponential(3) });
    status.className = 'status';
  }

  animId = requestAnimationFrame(step);
}

function startRun() {
  if (running) return;
  running = true;
  document.getElementById('btnRun').textContent = 'Running…';
  document.getElementById('btnRun').disabled = true;
  animId = requestAnimationFrame(step);
}

function reset() {
  if (animId) { cancelAnimationFrame(animId); animId = null; }
  running = false;
  document.getElementById('btnRun').textContent = 'Run';
  document.getElementById('btnRun').disabled = false;
  initState();
  draw();
  document.getElementById('status').textContent = 'Press Run to start.';
  document.getElementById('status').className = 'status';
}

document.getElementById('btnRun').addEventListener('click', startRun);
document.getElementById('btnReset').addEventListener('click', reset);

initState();
draw();

// Node.js verification shim (ignored in browser)
if (typeof module !== 'undefined') {
  module.exports = { rk4, lorenz, dist3 };
}

Result

Console

Press Run to start. The blue path is the reference trajectory; the red path starts 0.001 away. They stay close for a while, then suddenly diverge. Reset returns to the beginning. Use the Speed slider to slow down and appreciate how long the two paths stay together before chaos takes over.

This is sensitive dependence on initial conditions — the hallmark of chaos. No matter how close the two starts, they will eventually separate. Doubling measurement precision only buys a tiny extra window of prediction.

The Real Complexity

The Lorenz system is chaotic in a precise, measurable sense:

Sensitive dependence on initial conditions. Two nearby trajectories diverge exponentially fast. The largest Lyapunov exponent of the Lorenz attractor is approximately $\lambda_1 \approx 0.906$ , meaning a tiny initial gap $\varepsilon$ grows to $\varepsilon \cdot e^{0.906\,t}$ . Double your measurement precision and you gain only $\ln(2)/0.906 \approx 0.76$ units of extra prediction time.
It is provably non-periodic. The attractor is a strange attractor — a fractal set with Hausdorff dimension approximately 2.06. The solution never repeats and never settles to a fixed point or a simple cycle.
Determinism ≠ predictability. Knowing the exact state today pins the future exactly — but "exact" requires infinite precision, which is physically impossible. Any finite measurement error amplifies without bound.
Warwick Tucker's proof (2002). Using interval arithmetic and computer-assisted proof, Tucker formally verified that the Lorenz attractor is indeed a strange attractor and not merely numerically chaotic. The result is proven, not just observed.

The Lorenz system is not NP-hard or undecidable — it is simply chaotic in the mathematical sense. Long-term prediction fails not because we lack a fast algorithm, but because the required initial precision grows faster than any practical measurement can supply. Compare this to computational limits like the halting problem: there the barrier is logical impossibility; here it is physical.

Where It Matters

The discovery that deterministic systems can be unpredictable reshaped multiple fields:

Numerical weather prediction. Lorenz's insight is why modern forecasts come with ensemble runs — dozens of slightly perturbed simulations — rather than a single authoritative prediction. The spread of the ensemble is itself the forecast of uncertainty. Practical skill drops below useful levels beyond roughly 10–14 days, a fundamental horizon set by the atmosphere's Lyapunov exponent.
Turbulence research. The transition from smooth (laminar) to chaotic (turbulent) flow in fluids is governed by the same sensitive-dependence mechanism. Lorenz's equations are a simplified model of convection, the very process driving ocean currents and atmospheric dynamics.
Cryptography and random-number generation. Chaotic maps (simpler cousins of the Lorenz system) are used as pseudorandom number generators and studied in stream-cipher designs, precisely because tiny seed differences produce uncorrelated outputs.
Cardiology. Healthy heart rhythms show low-level chaos; the loss of that variability is a clinical marker. Researchers use Lyapunov exponents to distinguish healthy from pathological cardiac dynamics.
Climate science. The Lorenz system underpins the argument that weather is unpredictable even as climate (long-run statistics) can be stable — a subtle but crucial distinction in public debates about forecasting.

See also the closely related Monte Carlo integration, where controlled randomness is turned into a computational tool, and logistic map, an even simpler one-dimensional chaotic system.

Conclusion

The Lorenz attractor dismantled a 300-year-old assumption: that a deterministic universe is a predictable one. Three equations, a butterfly-shaped orbit, and an exponentially growing gap between almost-identical starting points proved otherwise.

The lesson is precise: it is not that we lack clever enough algorithms or powerful enough computers. The required precision of measurement grows faster than exponentially with the prediction horizon, hitting a hard physical wall. Lorenz showed this in 1963; Tucker proved it rigorously in 2002.

So the next time a weather forecast is wrong on day five, don't blame the meteorologists. They are fighting a battle that mathematics has already declared unwinnable beyond a certain horizon — and they are winning it as long as the physics allows.

Comments

Loading comments...

https://www.kipuhub.com/en/article/lorenz-attractor/Content licensed under CC BY-NC 4.0.

Cookies & privacy

The Lorenz Attractor

When a tiny difference today becomes a completely different tomorrow