One Place

English change ringing has no tunes in it. Six bells ring in a row, and the next row is the same six bells in a slightly different order, and the next, for hours, and the whole art is composing which orders come in which sequence. Everybody who hears about it asks the same question, which is why not just play a melody, and gets the same answer, which is that you can’t, and the answer is usually left there as a fact about tradition.

It isn’t. It’s a fact about a pendulum, and you can compute it.

A bell rung full circle sits mouth-up, just short of the balance, held on a rope. The ringer pulls; it comes off the balance, swings all the way down and all the way round, sounds near the top of the other side, and settles just short of the balance again. The ringer’s only verb is how hard to pull, and the only thing that verb controls is how close to the balance the bell comes to rest.

Everything below follows from that, and the first thing it produces is a control that nothing in your hands has prepared you for.

Pull harder and the blow comes later

The bell’s angle is θ from mouth-down, so the balance is at ±π and

θ̈ = -ω₀² sin θ,     ω₀² = M g d / I

Write the normalised energy u = E / 2Mgd, so u = 1 is exactly the balance and u > 1 goes over the top. A bell that stops ε short has u = cos²(ε/2), and the time it then takes to fall from there to the bottom is a quarter-swing of a pendulum with that amplitude:

t = K(cos(ε/2)) / ω₀  ~  ln(8/ε) / ω₀

A logarithm. Pulling harder puts the bell nearer the balance, and a bell nearer the balance takes longer to fall away from it. So the strength of the pull and the earliness of the blow run in opposite directions, and they do it through a log, which means the last tenth of a second costs as much as the first second did.

And it is not even this blow you are controlling. Writing out the next two blows from the moment the bell turns:

T_B = now + quarter(cur) + rise(out)
T_C = T_B + [quarter(out) - rise(out)] + quarter(out) + rise(after)
    = now + quarter(cur) + 2·quarter(out) + rise(after)

the rise(out) term cancels. The pull you are making now lands blow C. Blow B was decided one stroke ago and there is nothing left to do about it. Inverted, logarithmic, and lagged — three different ways of being hard, all out of the same line.

The numerics are checked against the closed form

A quarter-swing is a complete elliptic integral K, and the rise to the clapper is an incomplete F. The demo doesn’t use either: it integrates the ODE with RK4, because it has to draw the bell moving. So the integrator is checked against the functions it is allowed to replace.

Sub-microsecond on the blow, a tenth of a millisecond on the whole stroke.

The handstroke gap is not a rest, it is work

Rows alternate handstroke and backstroke, and after every backstroke row there is one blow of silence — the handstroke gap, which everyone hears as a lilt. It means a bell’s two strokes are not the same length: six blows one way, seven the other. The bell has no way to produce two different stroke lengths except by sitting at two different heights, and the ringer has to put it at both, every row, for as long as the ringing lasts.

The lilt is four to six degrees of bell, found and re-found a couple of thousand times an hour.

The window

Two walls. Up, the balance: past it the bell goes over, the stay takes the whole swing, and the stay breaks. Down, the clapper: a bell that swings too low doesn’t sound at all. Between them is the entire authority a ringer has over when their bell speaks, and measuring it in blows rather than radians is the whole point.

Across a factor of 2.8 in bell weight the window barely moves. It can’t: the stroke length is itself 2 ln(8/ε)/ω₀, so ω₀ cancels out of the count and what is left is a ratio of logs, ln(clapper/safe) / (ω₀ · blow) — which agrees with the measurement to 2.1% across the ring. A bell’s weight decides where in the window it sits. It does not decide how wide the window is.

Where it sits is worth its own line. Heavier bells are slower, and a slower bell has to start further from the balance to fall in the same time, so it sits low — with more room above it and less below:

Which is the tenor ringer’s complaint stated as a number: a big bell will let you hold it all day and will not be hurried.

The one you still have once the stroke has started

The window above is what the previous stroke can do. Once the bell is falling, the descent is spent, and all that is left is how hard you pull on the way out — which moves the clapper’s arrival a little, in one direction only.

Two thirds of a place later; not one millisecond earlier. Ringers learn this as you can always hold, you can never catch up, and it turns out to be a statement about which end of a quarter-swing the rope is still attached to.

One place, in halvings

Buying dt of delay multiplies what is left between the bell and the balance by exp(−ω₀ dt). The margin halves every ln2/ω₀ — about 165 ms, which on 300 ms blows means a place of hold is a bit under two halvings. For the Fourth, sitting at 10.73°:

The margin is an angle and it halves. The energy is that angle squared, so it quarters. A single place of hold costs eight parts in ten of everything the bell had left, and the second place costs eight parts in ten of the remainder.

Note the absolute scale in that middle column, too. Everything the bell has above it — all the room between where it sits and going over the stay — is under one percent of its energy. The bearings take 2% on every swing, so the pull that merely holds station is already more than twice the size of the entire upward control band. A ringer hauling on a rope hard enough to turn several hundredweight of bronze is mostly just re-supplying it. The steering is the difference between two much larger numbers, which is its own kind of hard.

Reachable is not ringable

Two places is inside the window. Every bell in the ring can be got there. What none of them can do is get there repeatedly, which is what a method asks for — because energy and margin are quadratically related near the top, so a fixed error in the ringer’s pull becomes a timing error of 2δu/(ω₀ε²), and that term runs away as the margin closes.

Against a pull good to one part in ten thousand of the balance energy:

One place: a slip is worth a few milliseconds, and the stay is four to ten slips away. Two places: the same slip is worth a good fraction of a blow, and the stay is the very next one. The window is three places wide and one place deep.

So the rule is not that two-place changes are forbidden. It is that nobody could ring one twice.

What that leaves you to compose with

A change is legal iff every bell moves at most one place, so from any row the reachable rows are exactly the sets of disjoint adjacent transpositions — which is a Fibonacci number:

Thirteen doors out of any room, and an extent has to visit all 720 rooms exactly once. The composition problem the entire art is built around is a Hamiltonian path, and a pendulum drew the edges. Two centuries of people naming methods — Plain Bob, Grandsire, Stedman, Cambridge Surprise — were exploring a graph whose degree was fixed by ln(8/ε).

Playing it

You have one bell in a band of six. The other five are rung by a controller solving the same equations you are. ↑ holds up, ↓ checks, and the dial reads in milliseconds and places, because seconds are what you are choosing. Next to it the gauge reads the same quantity in degrees of margin, and the two do not move together — your hand slides linearly while the margin runs away exponentially. That mismatch is the feel of the thing.

The aim resets after every blow: one pull, one decision. Both walls are reachable and both are survivable. Hold two places up and the bell goes over the stay, which here is a few seconds of being half a stroke out of the rhythm rather than a carpentry bill. Check it below the clapper and it stops sounding at all, which is worse, because you now have no blows to count from. Hand it back to the autopilot and it rejoins in about a dozen rows.

Four buttons. Rounds is just keeping time. Plain Hunt drags you from the front of the row to the back and home again, one place per row, for twelve rows. Plain Bob Minor is a real method, sixty rows to the plain course. Two Places is plain hunt with every other row deleted, so each change asks every bell to move two at once — nothing else about it is different, and it is the only one of the four that doesn’t work. The band can reach the places. Watch the striking column on the right go to pieces anyway: 84 ms rms against 12 for plain hunt, with blows 120 ms out. That is the argument, played rather than asserted.

It makes a sound, and the sound is a bell: hum an octave under the prime, a tierce a minor third above it, a quint, and the nominal an octave above the prime — two above the hum, and the one you actually hear as the note. That minor third is why a ring of bells tuned to a major scale still sounds faintly like bad news, and it is the one thing about bells that everyone has noticed without being able to say why.

Inside the bell panel, the small ticks around the circle are the swing sampled at equal time intervals. They crowd at the top. That picture is the whole piece: all of a ringer’s control lives in the part of the circle where the bell is barely moving.

What is physics here, and what isn’t

• Derived, and checked against the closed form: the elliptic-integral quarter-swing and the ln(8/ε) it goes to; the RK4 agreeing with it to a fifth of a microsecond; u = cos²(ε/2) and the 2δu/(ω₀ε²) that falls out of differentiating it; the margin halving every ln2/ω₀; the ω₀ cancelling out of the window width; the rise(out) term cancelling out of the next-but-one blow.
• Measured, not asserted: that the window is about three places for every bell in the ring; that one place costs four fifths of the remaining energy and the next costs four fifths of what is left; that a band solving these equations rings plain hunt to 11.8 ms rms and cannot ring two-place changes at all. node scripts/measure.mjs regenerates every table above and runs 23 checks that fail if any of it stops being true.
• Chosen: 300 ms blows and six bells; ω₀ from 4.42 down to 4.02 across the ring; the 2% energy the bearings take per swing; the safe wall at 0.69° of margin, which is a judgement about ringers and not a fact about bells — the window’s width is ln(clapper/safe), so moving that line moves the answer, and the table would say two and a half places if I put it at 2°.
• Simplified, and it matters: the clapper is modelled as landing at a fixed bell angle. Really it is a pendulum inside the bell with its own period, it strikes when it overtakes, and the angle drifts with how fast the bell is going — which is exactly the regime the “no sound” wall lives in. The rope’s work lands as one impulse at the bottom rather than spread over the wheel’s arc; that is worth a fraction of a millisecond in the blow, and it makes the delivered energy exact, which matters when the whole control band is a thousandth of the bell’s energy.
• Not modelled: odd-struckness (real bells do not strike symmetrically at hand and back, and every tower has its own); the stay actually breaking, which here is a few seconds of being out of the rhythm rather than a carpentry bill; the rope’s own mass and stretch; the ringer’s grip, which is the entire physical skill. And there is no ropesight — the demo shows you the grid, and a ringer has to build it from six ropes moving in a dark tower, which is the part that takes a year.

Reuse

src/one-place.mjs is framework-free with no canvas in it.

• ellipticK / ellipticF / carlsonRF — Carlson’s symmetric forms, good to 1e-12, useful anywhere a large-amplitude pendulum turns up.
• quarterTime / transitTime / riseToStrike / strikeTime / blowGap — the timing of a full-circle swing, closed form. marginForTransit and marginForBlowGap invert them.
• energyOf / marginOf / normalisedEnergy / speedAt / applyStrokeEnergy — the energy bookkeeping, including the one place the rope and the bearings touch the swing.
• correctionWindow / placesAvailable / sameStrokeWindow / placesClosedForm — the window, measured and in closed form.
• marginAfterDelay / halvingDelay / timingErrorFrom / overTheStayAt — the four lines the mechanic is actually made of.
• strokeTrack — the swing sampled at equal times, for drawing the thing that makes the whole argument visible at a glance.
• applyChange / parseNotation / rowsOf / withinOnePlace / reachableCount — place notation and the permutation layer. parseNotation handles the &-palindrome convention, so x16x16x16,12 expands to the twelve changes of a Plain Bob Minor lead.
• integrate — plain RK4 on θ̈ = -ω₀² sin θ, exported because the demo needs the same one the measurements used.

Port notes: the whole module is arithmetic on numbers, no DOM and no allocation in the hot path. stepBell in demo/demo.js is 40 lines and is the only part that knows about time passing.

The demo is demo/index.html + demo/demo.js with its own copy of the module (ADR-0002). It sizes itself to its viewport, so the site’s full-screen button just works, and it rings itself on autopilot until you touch a control.

node scripts/screenshot-demo.mjs regenerates the thumb and media and is the smoke test: 18 assertions, any page error fails the run, and it drives the live demo to check that the window it reports matches the closed form, that autopilot rings plain hunt to 11.8 ms rms, that the same controller asked for two-place changes falls apart, and that a bell driven into either wall — over the stay, or checked silent — finds its way back. The ringers’ hand noise is a seeded PRNG so that last comparison means something from one run to the next.