Half Again

Everybody has seen the video: a tile the size of a grain of rice goes over, and thirteen dominoes later something the size of a door does. The number attached to it is half again — each domino can knock over one about 1.5× its own size — and it is quoted as though it were a law. It is not. It is a working number, several per cent under a ceiling that is set by geometry, and the interesting thing about building one of these is not the growth factor at all.

Three numbers, and the one everybody quotes is not the ceiling

A domino of height h and thickness t has to be lifted onto its own corner before gravity will take it the rest of the way. Both energies are pure geometry:

barrier  =  m·g·(√(h²+t²) − h) / 2        standing → balanced
release  =  m·g·(√(h²+t²) − t) / 2        balanced → flat

Mass goes as h³ and the lever as h, so both scale as h⁴ and their ratio does not scale at all:

One domino carries 70.8× the energy needed to start the next one, across five decades of size, and since energy goes as h⁴ that licenses a growth factor of 70.8^(1/4) = 2.90×. Every domino could topple one nearly three times its height, if the energy could be delivered.

It cannot, and src/half-again.mjs is there to say by how much. Each domino is one degree of freedom — an angle about its own front bottom edge — with inelastic contact and Coulomb friction between the falling corner and the face it slides up. That model buys two exact facts, and they are the whole piece:

a normal push on the back face, τ up from the floor,
has moment arm exactly τ about the pivot           →  hit low, get nothing

the falling domino's corner pushes with moment arm
h₁·cos(a₁ − a₂) about its own pivot                →  and the two must agree

The second number is the measured one: 1.56×, at the best spacing there is. Folklore’s 1.5 is not the ceiling. It is about four per cent under it, which turns out to be exactly the right place to be.

The chain has no memory, and that is not a metaphor

A row where every domino is g times the last and every gap is λ times the falling one is scale-invariant: scale the picture by g and you have the same row, one step along. So the only honest way to read the arrival speed is the one form that survives that scaling, ŵ = ω·√(h/g) — and in that form a row has a fixed point it goes to no matter how it was started.

A flick carrying 4000× the kinetic energy of another is gone in six dominoes. You cannot shove a chain into working. Every step pays for itself out of its own fall, which is why the demo’s camera zooms with the wave — at constant growth the view is identical at every step, because the physics is.

The demo makes this the main view on purpose. The thing people expect to see is a chain getting more impressive; what you actually watch is the same event fourteen times, with the ruler underneath changing units.

Spacing has two optima and they are at opposite ends

Two things worth stopping on. The wave speed peaks around λ = 0.30 at 0.75 m/s — in the right neighbourhood for a real 48 mm domino — while the growth ceiling, below, peaks at λ = 0.96. Fastest and strongest are not the same spacing and they are not close.

And the resting angles, which are the tell. I expected a tight row to stall and it never does: it goes down leaning, every domino propped on the one in front, finishing in the sixties rather than flat. The push is still travelling; it is just arriving from a domino that has barely started to fall. That has an exact bound. A domino can lean at most asin(λ) before its corner lands on the next face, and it needs atan(t/h) = 8.87° just to pass its own balance point:

The simulator finds that limit to within 0.24° without being told it, which is the check I trust most in the whole file — and the error is one-sided, always a fraction of a degree past asin(λ), because contact is detected at the end of a timestep rather than during one. Below sin(8.87°) = 0.154 no domino in the row can reach its own balance point while its neighbour stands — the row can only be shoved along as a block.

The ceiling, measured

Half again is not available at all below λ = 0.70. The curve climbs to 1.564 and then turns over, because the gap is approaching the only hard wall in the problem: at λ = 1 the falling domino’s corner stops reaching the next face. The best growth in the game sits where there is 4% of reach left over.

One definition matters more than it looks. I first measured this over seven-domino ladders and published a ceiling several per cent too high, because a ladder a little over its ceiling does not die at the second domino. At λ = 0.75, where the ceiling is 1.502:

I expected the 102% row to show a slow bleed, and it does not. The arrival speed holds inside one per cent for eight dominoes and then the ninth does not go over. The self-similar state is not one number — the contact height and the phase of the domino behind are in it too — so a per cent of drift in the one number you can watch is the whole margin, at the ceiling. There is no early warning available, which is the single most load-bearing fact in the piece: “it knocked the next one over” is not evidence about a step. The 104% row knocks its first domino down perfectly well and stops.

So maxGrowth runs thirteen dominoes, and the demo’s shipped CEILING table is re-measured by scripts/measure.mjs, which fails if it has drifted.

What a chain at its ceiling is actually worth

Twenty-five builds of the same ladder, 2% of slop in every gap and 20% in the flick — roughly what a careful hand on a real table manages:

Four per cent of headroom costs one domino and buys all of it back. The cliff is that sharp because the ladder is self-similar: at the ceiling every step is equally marginal, so a fourteen-domino chain is fourteen coin flips, and the deaths scatter through it instead of piling up anywhere. There is no step to go and fix, and — per the table above — no reading you could have taken at #12 that would have told you. The thing that killed it at #13 is the growth factor you chose at #1.

The row that makes the point

Same growth factor, same count, same final height, different gap:

Those two middle rows are the same build by every measure a builder would write down. One of them completes 14 times out of 25 and the other 25 out of 25, and the only difference is 30 cm of extra table. At λ = 0.75 the ceiling happens to be 1.502, so “half again” is sitting at 99.9% of it; at λ = 0.88 the ceiling is 1.530 and the identical chain has room. The growth factor is the number everyone argues about and the gap is the one doing the work.

That is what the demo is for. You set growth with ▲ ▼ and the gap with ◀ ▶, and the instrument under the table plots the measured ceiling with every step you have placed sitting against it. test ×25 is the only honest score: once is not the same as reliably, and a chain that finished once will tell you nothing about which it was.

The clock, which is the only thing not self-similar

Every step takes 3.24·√(h/g), flat to ±10% over the whole ladder — so each one takes √g ≈ 1.22× as long as the last, and half of a 4.5-second run is the last three dominoes (the last two are 38%). The geometry repeats; the clock does not. It is the one cue in the demo that tells you how far along you are, since the picture deliberately will not.

What is physics here and what isn’t

• Derived and checked against the integrator: the h⁴ scaling and the scale-free energy ratio; the τ and h₁cos(a₁−a₂) moment arms; the asin(λ) lean limit, found to 0.24°; the fixed point in ŵ and its independence from the flick; the √(h/g) step time.
• Measured, not assumed: the whole ceiling curve, the reliability cliff, the wave speed. node scripts/measure.mjs prints every table above and exits non-zero if any of them stops agreeing.
• A modelling choice: each domino is pinned at its leading edge. Real ones slide, and on a slippery table a row skates instead of toppling — that is a real failure mode this model cannot show. Restitution is 0 (dominoes do not bounce; anything above a few per cent looks obviously wrong) and contact friction is µ = 0.4.
• Settled, not assumed: windowing, iteration order and iteration count all change the answer by less than 0.01 in g_max, and the timestep by less than 0.001 in arrival speed. I checked because an early version silently used its own solver window as the “has the wave advanced?” signal, which made a perfectly ordinary uniform row die at the eighth domino.

Reuse

src/half-again.mjs is framework-free with no canvas in it.

• createChain(sizes, gaps) + flick(chain, ŵ) + settle(chain, {dt, onStep}) is the simulator; settle takes an onStep callback and stops on its own once the wave has stopped advancing, so it is safe to call per frame with a one-frame tMax to run a chain in real time.
• ladder(h0, g, lam, n) and plan({h0, target, g, lam}) build the two shapes worth building; layout(sizes, gaps) gives the x positions.
• ceiling(lam) is the shipped curve — cheap enough to call on every keypress, which maxGrowth (which bisects a thirteen-domino simulation per point) is very much not.
• reliability(sizes, gaps, {runs, slop}) is the number that matters.
• findContact(d1, d2) returns the penetration and both moment arms, if you want the geometry without the solver.

Port notes: the whole integrator is scalar — one angle and one angular velocity per body, and two scalar impulses per contact — normal, then friction clamped against it — with no vectors and no matrices anywhere. It translates into a tick method directly. The one thing not to change casually is DT (1/3000 s): the contact is stiff and the entire result is an impulse transfer.

The demo bundles its own copy of the module (ADR-0002) — if you touch src/, re-copy it into demo/. node scripts/screenshot-demo.mjs regenerates the thumb and media and doubles as the smoke test: it drives the real keyboard, then builds the same chain at the ceiling and 4% under it and asserts the first is a coin flip and the second is not.