Introduction

Hang a pendulum from the end of another pendulum and you have one of the most famous demonstrations in all of physics. The rules are exact: Newton's laws of motion, fully written down in 1687, govern every instant of the motion. There is nothing random, nothing hidden, nothing uncertain about the equations.

Yet watch two double pendulums released from starting positions that differ by just a hair — a fraction of a millimeter, an imperceptible angle — and within a handful of seconds they are doing completely different things. One swings left while the other flips over. The initial difference has grown so fast that it swallowed any resemblance.

This is chaos: not randomness, but an exquisite sensitivity to initial conditions that makes long-term prediction physically impossible in practice, no matter how powerful your computer. The equations are exact; our knowledge of the starting state is not — and in a chaotic system, that gap grows without bound.

Try It

Two double pendulums start from positions that differ by a tiny angle offset (default: 0.001 radians — about the width of a human hair at arm's length). Press Release and watch them evolve. The red pendulum is the reference; the blue one starts almost identically. Within seconds they are doing completely different things.

<div class="controls">
  <label>Offset <span id="offsetVal">0.001</span> rad
    <input type="range" id="offsetSlider" min="0" max="0.1" step="0.001" value="0.001">
  </label>
  <button id="releaseBtn" type="button">Release</button>
  <button id="resetBtn" type="button" class="ghost">Reset</button>
</div>
<canvas id="canvas" width="480" height="360"></canvas>
<div class="info">
  <span id="timeEl">t = 0.00 s</span>
  <span id="sepEl">separation: 0.000 rad</span>
</div>

* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; background: #f4f6f8; color: #222; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap;
            padding: .5rem .6rem; background: #e8eef3; border-bottom: 1px solid #cdd9e3; }
label { font-size: .85rem; display: flex; align-items: center; gap: .4rem; }
input[type=range] { width: 120px; }
button { font: 600 13px system-ui; padding: .35rem .8rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 6px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
#canvas { display: block; background: #fff; border-bottom: 1px solid #e0e4e8; }
.info { display: flex; gap: 1.2rem; padding: .4rem .7rem; font-size: .82rem;
        background: #f9fafb; border-top: 1px solid #e8eef3; color: #555; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Double pendulum simulation using 4th-order Runge-Kutta.
// State: [theta1, omega1, theta2, omega2]  (angles from downward vertical)
// Equations derived from the Lagrangian for m1=m2=m, L1=L2=L:
//   System: [2  cd][a1] = [-w2^2*sd - 2g/L*sin(t1)]
//           [cd  1][a2]   [ w1^2*sd - g/L*sin(t2) ]
// where d=t1-t2, sd=sin(d), cd=cos(d), det=2-cd^2.
// Energy E = (mL^2/2)*(2w1^2+w2^2+2w1*w2*cd) - mgL*(2cos(t1)+cos(t2)) is conserved.

const g = 9.81, L = 1;

function deriv(s) {
  const [t1, w1, t2, w2] = s;
  const d = t1 - t2;
  const sd = Math.sin(d), cd = Math.cos(d);
  const det = 2 - cd * cd;
  const rhs1 = -w2 * w2 * sd - 2 * (g / L) * Math.sin(t1);
  const rhs2 =  w1 * w1 * sd - (g / L) * Math.sin(t2);
  const a1 = (rhs1 - cd * rhs2) / det;
  const a2 = (2 * rhs2 - cd * rhs1) / det;
  return [w1, a1, w2, a2];
}

function rk4(s, dt) {
  const k1 = deriv(s);
  const k2 = deriv(s.map((v,i) => v + dt/2*k1[i]));
  const k3 = deriv(s.map((v,i) => v + dt/2*k2[i]));
  const k4 = deriv(s.map((v,i) => v + dt*k3[i]));
  return s.map((v,i) => v + dt/6*(k1[i]+2*k2[i]+2*k3[i]+k4[i]));
}

const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;
const cx = W/2, cy = 120;
const PX = 110; // pixels per unit length

let state1, state2, t, running, rafId;
const trail1 = [], trail2 = [];
const TRAIL_LEN = 200;

function initStates() {
  const offset = parseFloat(document.getElementById('offsetSlider').value);
  state1 = [Math.PI/2, 0, Math.PI/2, 0];
  state2 = [Math.PI/2 + offset, 0, Math.PI/2, 0];
  t = 0; trail1.length = 0; trail2.length = 0;
}

function pendPos(s) {
  const [t1,,t2] = s;
  const x1 = cx + PX*Math.sin(t1);
  const y1 = cy + PX*Math.cos(t1);
  const x2 = x1 + PX*Math.sin(t2);
  const y2 = y1 + PX*Math.cos(t2);
  return { x1, y1, x2, y2 };
}

function drawPendulum(s, color, alpha) {
  const { x1, y1, x2, y2 } = pendPos(s);
  ctx.save();
  ctx.globalAlpha = alpha;
  ctx.strokeStyle = color;
  ctx.lineWidth = 2;
  ctx.beginPath(); ctx.moveTo(cx, cy); ctx.lineTo(x1, y1); ctx.stroke();
  ctx.beginPath(); ctx.moveTo(x1, y1); ctx.lineTo(x2, y2); ctx.stroke();
  ctx.fillStyle = color;
  ctx.beginPath(); ctx.arc(x1, y1, 7, 0, 2*Math.PI); ctx.fill();
  ctx.beginPath(); ctx.arc(x2, y2, 9, 0, 2*Math.PI); ctx.fill();
  ctx.restore();
}

function drawTrail(trail, color) {
  if (trail.length < 2) return;
  ctx.save();
  ctx.strokeStyle = color;
  ctx.lineWidth = 1;
  for (let i = 1; i < trail.length; i++) {
    ctx.globalAlpha = i / trail.length * 0.55;
    ctx.beginPath();
    ctx.moveTo(trail[i-1].x, trail[i-1].y);
    ctx.lineTo(trail[i].x, trail[i].y);
    ctx.stroke();
  }
  ctx.restore();
}

function draw() {
  ctx.clearRect(0, 0, W, H);
  // pivot
  ctx.fillStyle = '#888';
  ctx.beginPath(); ctx.arc(cx, cy, 5, 0, 2*Math.PI); ctx.fill();

  drawTrail(trail1, '#e63946');
  drawTrail(trail2, '#1d6fa5');
  drawPendulum(state1, '#e63946', 0.9);
  drawPendulum(state2, '#1d6fa5', 0.9);

  // separation indicator bar
  const sep = Math.sqrt(
    (state1[0]-state2[0])**2 + (state1[2]-state2[2])**2
  );
  const barW = Math.min(sep / 0.5, 1) * (W - 20);
  ctx.fillStyle = `hsl(${Math.round((1 - Math.min(sep/0.5,1))*120)},70%,45%)`;
  ctx.fillRect(10, H-18, barW, 8);
  ctx.strokeStyle = '#ccc'; ctx.lineWidth = 1;
  ctx.strokeRect(10, H-18, W-20, 8);

  document.getElementById('timeEl').textContent = 't = ' + t.toFixed(2) + ' s';
  document.getElementById('sepEl').textContent = fmt('separation: %sep% rad', { sep: sep.toFixed(3) });
}

function step() {
  const DT = 0.005;
  const SUBSTEPS = 4;
  for (let i = 0; i < SUBSTEPS; i++) {
    state1 = rk4(state1, DT/SUBSTEPS);
    state2 = rk4(state2, DT/SUBSTEPS);
    t += DT/SUBSTEPS;
  }
  const p1 = pendPos(state1), p2 = pendPos(state2);
  trail1.push({x: p1.x2, y: p1.y2});
  trail2.push({x: p2.x2, y: p2.y2});
  if (trail1.length > TRAIL_LEN) trail1.shift();
  if (trail2.length > TRAIL_LEN) trail2.shift();
  draw();
  if (running) rafId = requestAnimationFrame(step);
}

document.getElementById('offsetSlider').addEventListener('input', function() {
  document.getElementById('offsetVal').textContent = parseFloat(this.value).toFixed(3);
  if (!running) { initStates(); draw(); }
});

document.getElementById('releaseBtn').addEventListener('click', function() {
  if (running) {
    running = false;
    cancelAnimationFrame(rafId);
    this.textContent = 'Release';
  } else {
    initStates();
    running = true;
    this.textContent = 'Pause';
    rafId = requestAnimationFrame(step);
  }
});

document.getElementById('resetBtn').addEventListener('click', function() {
  running = false;
  cancelAnimationFrame(rafId);
  document.getElementById('releaseBtn').textContent = 'Release';
  initStates();
  draw();
});

initStates();
draw();
Result
Console

Drag the Offset slider toward zero and the pendulums stay together longer — but they always diverge eventually. Move it higher and they split almost immediately. This exponential growth of the separation is the signature of chaos, quantified by the Lyapunov exponent: even the tiniest offset gets amplified by a factor of e≈2.718e \approx 2.718 roughly every Lyapunov time (~1–2 seconds for this system).

The Real Complexity

How hard is predicting the double pendulum? Much harder than it looks.

  • Deterministic but chaotic. The equations of motion are four coupled nonlinear ordinary differential equations — completely deterministic. Given exact initial conditions, the future is fixed. But "exact" is the catch.
  • Errors grow exponentially. If your initial measurement has error Δ\varepsilon, after time t the error has grown to roughly Δ⋅eλt\varepsilon \cdot e^{\lambda t}, where λ\lambda is the Lyapunov exponent (positive for chaotic systems, roughly 3–7 s⁻Âč for the double pendulum). Double your measurement precision and you gain only one Lyapunov time of extra predictability.
  • The prediction horizon is fundamental. To predict 10 extra seconds into the future you would need to measure the initial angle roughly eλ⋅10≈1013e^{\lambda \cdot 10} \approx 10^{13} times more precisely. At some point you hit the limits of quantum mechanics — atoms cannot be located with infinite precision — so there is a hard physical ceiling on prediction, not just a practical one.
  • Not NP-hard, but computationally unsimulatable in the long run. The chaos in the double pendulum is a phenomenon in continuous dynamics rather than in discrete complexity classes. It was studied rigorously by Henri PoincarĂ© (1890s) and formalized in the modern theory of dynamical systems by mathematicians like Andronov and later Lorenz (1963), who discovered chaotic sensitivity in weather models.
  • Status: well-understood phenomenon, open challenges remain. The chaotic nature of the double pendulum is firmly established and is not an open problem. What remains open is the quantitative prediction of transition points — exactly when and where a given trajectory flips from regular to chaotic — and the Kolmogorov–Arnold–Moser (KAM) theory of partially stable islands in phase space still has active research frontiers.

The contrast with a simple pendulum is sharp: a single pendulum is integrable — its equations can be solved in closed form for small angles, and errors do not amplify. Add one more joint and everything changes.

Where It Matters

The double pendulum is a teaching machine for chaos, but the same exponential error growth appears everywhere:

  • Weather and climate forecasting: Lorenz discovered chaos in 1963 while simulating atmospheric convection. The famous "butterfly effect" is exactly the double-pendulum divergence, scaled up to global weather. Modern ensemble forecasting runs dozens of slightly-perturbed simulations and reports probabilities — because a single run is meaningless after ~10 days.
  • Orbital mechanics: small gravitational tugs from Jupiter can eventually send asteroids into chaotic orbits. Long-term solar system stability (beyond ~100 million years) cannot be established by integration alone.
  • Robotics and legged locomotion: multi-link robot arms and walking legs are mechanical double-pendulum analogs. Controlling them requires fast feedback loops precisely because tiny disturbances amplify rapidly.
  • Cryptography and random number generation: chaotic maps (logistic map, standard map) are the mathematical cousins of the double pendulum and underlie some pseudorandom generators and chaos-based encryption schemes.
  • Structural engineering: suspension bridges and tall buildings can enter chaotic vibration regimes under wind loading — the Tacoma Narrows collapse (1940) is a textbook example of resonance tipping into destructive oscillation.

Understand the double pendulum and you understand why simulation cannot outrun chaos — and why probabilistic forecasting is not a failure of models but a fundamental feature of the physical world.

Conclusion

The double pendulum is one of nature's most honest demonstrations: the equations are perfect, the physics is deterministic, and yet reliable long-term prediction is physically impossible. Not because we lack computing power, but because our knowledge of the initial state is always imperfect — and in a chaotic system, any imperfection grows exponentially until it consumes all predictive value.

Laplace once imagined a demon that, knowing the position of every atom, could compute all of history. The double pendulum is a polite refutation: even a demon would need to know initial conditions to infinite precision, and quantum mechanics forbids that. Determinism and predictability are not the same thing, and the gap between them is chaos.

The next time a weather forecast is wrong beyond ten days, or a robot arm shudders unexpectedly, remember the pendulum swinging the other way — and the exponential that made it inevitable. For a deeper look at how chaos connects to computation, see simulation and the logistic map.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

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