Each firefly has a charge that rises to a threshold, then fires and resets. The only coupling is a pulse: a flash bumps every other charge up by ε, and if that tips someone over threshold, they fire in the same instant — a cascade. Mirollo and Strogatz proved, in 1990, something stronger than it has any right to be: from almost any starting condition, any number of fireflies reach perfect unison in finite time and stay there, because once two fire together they are one oscillator forever. The whole proof hangs on one property of the charging curve — that it bends downward, concave. Flatten it to a straight line and the guarantee is gone: for two fireflies it becomes impossible — same fireflies, same pulses, and they drift past each other for good — and even in larger swarms sync is no longer promised, only sometimes stumbled into by chance.
Live canvas visualisations are unavailable in this browser, so the fields and charts below are blank; the surrounding text and the stored numbers still describe what they show.
Below, 300 fireflies charge on the main thread, live — each a disc glowing at a brightness equal to its charge, blooming bright at the instant it fires. It begins as a rain of uncorrelated sparks. The coupling here is deliberately weak (ε = 0.4/N, chosen so the collapse unfolds as a cascade of partial avalanches rather than one instant snap — see the note below the field) so the merges arrive gradually, over tens of seconds, rather than all at once. Beside it, a phase circle: every oscillator is a tick at its phase; a merged group of more than one is drawn as one thicker tick in a shared colour, so every absorption is visible as two ticks becoming one.
ε = 0.4/N is the page's own choice, not a kernel default: it keeps the population comfortably below the avalanche threshold N·ε ≈ 1.1 (see report §8) so a single firing cannot drag the whole field over threshold at once, and the staircase in Section II actually has steps to show. The kernel's own default is ε = 0.1, which for a few hundred fireflies is deep supercritical and collapses in one event — try it with "Run to sync" and a fresh restart at high speed to see the difference described in the report.
The number of distinct groups against time is a staircase that provably never rises — co-firing only merges groups, and a merged group can never split again. That is not observed, it is guaranteed by construction: the absorption rule can only merge groups, never split them, for any f (concave, linear, or convex). So the page uses it as a live self-test: the chart below is drawn straight from the swarm running in Section I, and if the count were ever to tick up, that would mean the absorption logic is broken. It never does.
Every step recorded from the live simulation above is checked here, in your browser, as it happens: 0 steps checked, 0 upward violations. Restart Section I to redraw this chart from scratch.
Below, hundreds of independent seeded runs accumulate in the background — a few per idle tick, never blocking the animation above — at N = 2, 4, 8 … 512, in two regimes that give opposite answers, which is why the ε convention has to sit right next to any scaling claim: Series A holds ε fixed at 0.05 (denser swarms avalanche faster, so sync time falls with N); Series B holds ε·N fixed at 0.5 (subcritical at every N), and events-to-sync grow with N roughly as N0.83 — sub-linear, but not the weak growth the "log N" folklore has in mind; that comparison is really about continuous cycles-to-sync (not shown here), which the report finds grows far more slowly, ~N0.14 (see report §7).
No exponent is asserted beyond what these runs support — both fits carry a standard error, printed once enough runs are in; compare against the recorded run in report §7 (Series A ≈ N−1.75±0.16, Series B events ≈ N0.826±0.021) in the provenance table.
For two fireflies, strobe the system just after A fires: B is somewhere at phase φ. One firing-pair later, B's new phase is R(φ) — the return map. It has a closed form, returnMap(b,ε), derived from the charging curve; the page samples it from the live simulation and draws both together. The map has a fixed point u* (the anti-phase orbit); its slope there is what decides everything. The verifiable fact: that slope crosses exactly 1 as b passes through 0. Concave (b>0) gives slope > 1, so the anti-phase orbit is unstable and trajectories are pushed away from it, toward full merger — sync. Linear (b=0) gives slope = 1 exactly: neutral, the map is the identity, no sync. Convex (b<0) gives slope < 1: the anti-phase orbit is stable, so nearby trajectories settle there instead of merging — also no sync, by the opposite mechanism.
—
Fixed at ε = 0.1 here so the crossing at b = 0 is the only thing moving; the dial in Section IV varies ε too.
Three controls. Curvature b sets the charging curve f(φ) = ln(1+(eb−1)φ)/b: concave above 0 (synchrony guaranteed by the theorem), exactly linear at b→0 (the hypothesis fails), leaky-integrate-and-fire at b=1, faster collapse as b grows. Pulse strength ε sets how hard a firing kicks everyone else. Transmission delay τd is the landmark that breaks the theorem the other way: instead of a hypothesis about the curve failing, the coupling itself arrives late, and — in the right regime — persistent splits appear where a theorem-obeying system would have merged.
This experiment runs its own small demonstration population (N=100, ε=0.003, comfortably subcritical — N·ε≈0.3) so the delay effect is visible regardless of what ε you left above: the report shows the effect needs ε ≲ 1/N, which the dial above usually is not. Slide delay away from zero and watch the same population that always reaches sync at delay=0 stop reaching it at all.
—
You control one oscillator with the spacebar, coupled at the same strength ε as everyone else. Round 1 — join: the swarm is still finding itself; tap along and try to land your own flashes on top of the crowd's. Round 2 — break: the swarm (N=200) is already perfectly synchronised; you get 30 flashes and complete freedom of timing. The theorem says a single actor cannot desync it, and you will not — watch the group count stay pinned at one the entire round: a single actor can't even put a dent in it. Losing round 2 is the lesson. Then the rules change.
A related but different measurement, not from this round's N=200 run: a single oscillator knocked off a synced N=50 group reabsorbs in ≈0.71 cycle on average stored — see Provenance.
Thirty flashes could not do it. A transmission delay can — but only if it is switched on before the swarm finishes merging (a fully-merged single group can never re-split, by any means: see report §8) and only in the subcritical regime the report measured. This is a different, smaller demonstration population, not the N=200 above.
Four phase circles, real snapshots from independent runs at different moments. Click the one that has already reached a single group.
The event-driven trajectory, absorption (bit-identical merges), the N=2 return map and its fixed-point slope, and the group-monotonicity guarantee are computed here from closed forms or checked live against the running simulation — no error bars. Time-to-sync scaling exponents, the avalanche threshold, and the reabsorption/perturbation-decay times are measured, fitted with a standard error, and never asserted beyond what the fit supports. A handful of numbers that need many more seeds than a live browser session should spend are quoted from the kernel's recorded test run and tagged stored.
| Quantity | Status | Value / evidence |
|---|---|---|
| Mirollo–Strogatz theorem: concave + all-to-all ⇒ finite-time sync | exact | Mirollo & Strogatz 1990; kernel checked 10,000 random inits, N∈[2,1000], 0 monotonicity violations, 10,000/10,000 reach one group |
| N=2 return map R, fixed point u*, slope R'(u*) | exact | closed form in the kernel; matched to mpmath dps=50 to <1e-9; slope crosses 1 exactly as b passes 0 |
| Absorption is bit-identical, no δ-tolerance needed | exact | merged groups set to the literal value 0; verified never split over 10⁵+ events |
| N=2 linear (gap 0.5>ε): never syncs | exact | R is an exact involution for linear f; verified over t=500 cycles |
| Time-to-sync scaling, Series A (fixed ε=0.05) | stored | Tsync ~ N−1.75±0.16, N=2..512, 120-200 seeds/N (report §7) |
| Time-to-sync scaling, Series B (ε·N=0.5 fixed) | stored | events ~ N0.826±0.021, cycles ~ N0.140±0.030 (report §7; peer reference agrees to within its own error bars) |
| Delay breaks sync only when N·ε ≲ 1 | stored | N=200, ε=0.5/N: 0/20 reach sync at delay≥0.05; ε=0.1 default (N·ε=20): 20/20, delay invisible (report §8) |
| Single actor cannot desync a merged swarm | stored | N=200 synced, 30 adversarial injected flashes at ε=0.02: stays 1 group throughout, 0 exceptions (report §9) |
| Reabsorption time, lone oscillator off a synced N=50 group | stored | 200/200 offsets/timings reabsorbed, mean ≈0.71 cycle (report §9) |
| Performance, N=1000 to full sync | stored | worst case <50ms across ε∈[1e-4,0.2] (report §10) |
| Two independently-authored references agree | exact | trajectories, sync times, return-map samples match to <1e-9; peer half-map convention cross-checked (report §6) |
R. E. Mirollo & S. H. Strogatz, Synchronization of pulse-coupled biological oscillators, SIAM J. Appl. Math. 50, 1645 (1990). C. S. Peskin, Mathematical Aspects of Heart Physiology, Courant Institute, NYU (1975). S. H. Strogatz, Sync (2003), the fireflies chapter. Cited from knowledge: this build had no network, so page/line numbers are unverified; the mathematics is built from first principles in the kernel and checked numerically against two independent references, not taken on faith from the sources.
Contact the author: np56123@icloud.com