Double the swing. Why does the clock barely change?

What a clock asks for

A mechanical clock counts swings. For “minute” to mean what we want it to mean, every swing must take the same amount of time. The bob does not have to swing with any particular amplitude — only with a constant period regardless of how much energy the escapement happens to have given it on this tick. Whether the period actually has this property depends on the equation of motion.

The real equation

For a bob of mass $m$ on a rigid rod of length $L$, the only force giving it angular acceleration is the component of gravity tangent to the arc, which equals $−mg \sin θ$ for angle $θ$ measured from straight down. Newton’s second law along the arc gives:

θ̈ = −(g/L) · sin θ

That is a nonlinear differential equation. There is no clean elementary solution; the period does depend on the amplitude $θ₀$ the bob is launched at. If the world worked exactly like this, no mechanical clock could keep time.

The small-angle move

Look at $\sin θ$ near zero. Its tangent line at the origin is just $y = θ$. So $\sin θ ≈ θ$ for small $θ$ (in radians). At $θ = 5°$ (≈ 0.087 rad) the error is about 0.1%. At $30°$ it’s about 4.5%. At $60°$ it’s nearly 18% — the approximation breaks down quickly. This is the small-angle approximation ; replacing a nonlinear function by its tangent line is linearization in general.

The crisis: the equation in §2 is hard. The move: replace $\sin θ$ by $θ$ wherever it appears. The trade: the new equation will be wrong for big swings; the gamble is that real clocks operate in the regime where it isn’t.

The linearized equation

Substitute. The pendulum equation becomes:

θ̈ = −(g/L) · θ

That is simple harmonic motion : the acceleration is proportional to the negative of the displacement. The general solution is $θ(t) = θ₀ \cos(ω·t + φ)$ for $ω = \sqrt{g/L}$. Plug in initial conditions (“released from rest at angle $θ₀$”) and the phase $φ$ goes to zero, leaving $θ(t) = θ₀ \cos(\sqrt{g/L} · t)$.

import math

# Linearized pendulum: small-angle solution.
# θ̈ = −(g/L)·sin θ   →   (sin θ ≈ θ)   →   θ̈ = −(g/L)·θ
# Solutions are simple harmonic: θ(t) = θ₀·cos(ω·t),  ω = √(g/L).
def theta(t, L, g, theta0):
    omega = math.sqrt(g / L)
    return theta0 * math.cos(omega * t)

def period_small(L, g):
    return 2 * math.pi * math.sqrt(L / g)

period_small(1.0, 9.8)            # ≈ 2.007 s   (1-meter rod on Earth)
period_small(1.0, 1.62)           # ≈ 4.929 s   (same rod on the Moon)

The clock formula — period without amplitude

The cosine has period $2π$; the angular frequency $ω$ ticks at $2π/T$ radians per second. So:

T = 2π √(L/g)

The amplitude is gone. Period depends only on the rod length $L$ and the local $g$; not on the bob’s mass, not on how widely it’s swinging. That is the property a clock needs, derived as a clean consequence of the linearized equation. A 1-meter rod on Earth swings with $T ≈ 2.007 s$; on the Moon, where $g ≈ 1.62 m/s²$, the same rod swings with $T ≈ 4.93 s$.

The lie, examined honestly

The amplitude does not vanish from the real period — it shrinks. The next term in the expansion is well known:

T(θ₀) = T₀ · (1  +  θ₀²/16  +  …)

At $θ₀ = 10°$ (≈ 0.175 rad) the correction is about 0.2% — a tolerable second per eight minutes. At $30°$ it’s 1.7%, half a minute per half-hour — already worse than a digital watch. At $60°$ it’s 6.9%, six minutes per hour — uselessly far from a clock. The widget shows it: with correction on and $θ_B = 60°$, pendulum B drifts visibly behind A within a handful of swings.

Real pendulum clocks worked because their escapements force the bob to swing in small arcs — 17th-century clockmakers added cycloidal “cheeks” to the suspension to compensate for what amplitude error remained, and modern designs keep the arc small enough for the linear approximation to stay nearly true. The entire technology is built around the regime in which the lie holds. That, more than the formula itself, is the lesson worth pinning.

# What the small-angle formula is missing — Borda's leading correction.
# Real period grows with amplitude: T(θ₀) ≈ T₀ · (1 + θ₀²/16).
def period_corrected(L, g, theta0_rad):
    return period_small(L, g) * (1 + theta0_rad**2 / 16)

# How much does the clock drift if the bob actually swings 30°?
T0  = period_small(1.0, 9.8)
T30 = period_corrected(1.0, 9.8, math.radians(30))
(T30 - T0) / T0 * 100              # ≈ 1.7 %   slow, every period

# 60° (a wild swing) gives ~6.9 % slow — many minutes per day. The
# actual clocks of the 17th century constrained the bob to small
# arcs (the cycloidal-cheek trick); modern ones use escapements that
# keep the amplitude small enough for the linear approximation to
# stay nearly true. The whole technology is built around the lie.