5.3.3 Double Pendulum Chaos

Overview

A single pendulum is the textbook example of predictable physics — it swings back and forth on a sinusoid forever. Hang a second pendulum from its end and the system becomes one of the simplest known examples of deterministic chaos: the equations of motion are fully written down, the simulation is exact, and yet two near-identical starting positions produce wildly different trajectories within seconds. Edward Lorenz discovered this property in atmospheric models in 1963 and named the popular shorthand the “butterfly effect” [1]. In this lesson you will derive the equations from coupling, integrate them with the Runge-Kutta 4th-order (RK4) method, animate the swinging arm, and visually demonstrate sensitivity to initial conditions by running two simulations whose starting angles differ by 0.06 degrees.

Learning objectives

1. Read the double-pendulum equations of motion and identify the coupling terms that make them chaotic.
2. Implement RK4 numerical integration and understand why Euler is not enough here.
3. Define chaos as extreme sensitivity to initial conditions — not randomness.
4. Visualise chaos by comparing trajectories from very nearly identical starting states.

Quick start — see it in action

Run the script. It writes three files: a GIF of the swinging arm, a still frame, and a comparison plot of two near-identical pendulums diverging.

python double_pendulum.py

Core concepts

Concept 1 — Coupled physics, simple in shape

A double pendulum is two rigid rods connected end-to-end. The first rod hangs from a fixed pivot; the second hangs from the end of the first. Each rod has a length (L1, L2), a mass concentrated at its tip (m1, m2), and an angle from vertical (theta1, theta2). The system has four state variables — those two angles and their angular velocities omega1, omega2.

The motion of each rod affects the other. When the first swings, it carries the second with it. When the second swings, its momentum yanks back on the first. That mutual influence — the coupling — is the engine of the chaos.

The equations of motion come from Lagrangian mechanics [2]. They look heavy, but the essential point is just: the acceleration of each rod depends on both angles and both angular velocities.

def compute_accelerations(theta1, omega1, theta2, omega2):
    delta = theta1 - theta2
    denom = 2 * m1 + m2 - m2 * np.cos(2 * delta)

    alpha1 = (
        -g * (2 * m1 + m2) * np.sin(theta1)
        - m2 * g * np.sin(theta1 - 2 * theta2)
        - 2 * np.sin(delta) * m2 * (
            omega2**2 * L2 + omega1**2 * L1 * np.cos(delta)
        )
    ) / (L1 * denom)

    alpha2 = (
        2 * np.sin(delta) * (
            omega1**2 * L1 * (m1 + m2)
            + g * (m1 + m2) * np.cos(theta1)
            + omega2**2 * L2 * m2 * np.cos(delta)
        )
    ) / (L2 * denom)

    return alpha1, alpha2

Concept 2 — Chaos is determinism plus sensitivity

Chaos does not mean randomness. Every step of the double pendulum’s motion is exactly determined by its previous step. Given identical initial conditions and infinite precision, the trajectory is repeatable. The unpredictability comes from a different property: extreme sensitivity to initial conditions.

Start two pendulums with angles differing by 0.001 radians (about 0.06 degrees, narrower than the width of a pencil line at arm’s length). For the first three seconds they trace the same path. By five seconds you can see them parting. By fifteen seconds they are unrelated.

The rate at which nearby trajectories pull apart is called the Lyapunov exponent [3]. A positive exponent means exponential divergence — small errors double, then double again, then again. The double pendulum has measurable positive Lyapunov exponents, which is the formal statement that “it is chaotic” [4].

Concept 3 — Why RK4 instead of Euler

The simplest integrator — Euler’s method — updates the state with new = old + derivative * dt. In Module 5.1.1 (sand) that was plenty accurate, because each particle was independent and short-lived. For the double pendulum it is a disaster: Euler accumulates ~dt² of error per step, those errors look like extra perturbations to the initial condition, and chaotic systems amplify perturbations exponentially. Within a few seconds Euler diverges from the “true” trajectory of the same starting state.

The Runge-Kutta 4th-order method (RK4) samples the derivative four times per step at carefully-chosen interior points and combines them with a weighted average. The error per step is now ~dt⁵ — many orders of magnitude smaller [5].

def rk4_step(theta1, omega1, theta2, omega2, dt):
    def f(th1, w1, th2, w2):
        a1, a2 = compute_accelerations(th1, w1, th2, w2)
        return w1, a1, w2, a2

    k1 = f(theta1, omega1, theta2, omega2)
    k2 = f(theta1 + k1[0]*dt/2, omega1 + k1[1]*dt/2,
           theta2 + k1[2]*dt/2, omega2 + k1[3]*dt/2)
    k3 = f(theta1 + k2[0]*dt/2, omega1 + k2[1]*dt/2,
           theta2 + k2[2]*dt/2, omega2 + k2[3]*dt/2)
    k4 = f(theta1 + k3[0]*dt, omega1 + k3[1]*dt,
           theta2 + k3[2]*dt, omega2 + k3[3]*dt)

    weighted = lambda i: (k1[i] + 2*k2[i] + 2*k3[i] + k4[i]) * dt / 6
    return (theta1 + weighted(0), omega1 + weighted(1),
            theta2 + weighted(2), omega2 + weighted(3))

Exercises

Three exercises in Execute → Modify → Create order: run the canonical chaos demo, retune physics parameters, then implement the integrator from scratch.

damping = 0.05
alpha1 -= damping * omega1
alpha2 -= damping * omega2

Downloads

Summary

Common pitfalls to avoid

• Using Euler instead of RK4. The simulation will look fine for one second and absurd by five.
• Expecting bit-exact reproducibility across machines. Different float-rounding orders are themselves tiny perturbations.
• Confusing chaos with randomness. The system has no stochastic input — the unpredictability is structural.
• Plotting only one trajectory. Chaos is invisible from a single run; you need a pair to see it.
• Forgetting units. Lengths in metres, time in seconds, g = 9.81. Mixing pixels with metres will not crash but it will lie about the physics.

References