The Fire That Draws the Threshold in Time
Last time a single cluster snapped across a grid at one sharp density and that was that, a still picture of a phase transition. Now light a spark on the edge and let it burn. Whether the flames cross is exactly the same threshold, but a fire has a clock, and the clock does something the picture could not: at the critical density the burn takes longest, a lifetime that diverges right at the edge. Then take the dial away entirely and let trees grow and lightning strike, and the forest tunes itself to that same edge with nobody touching the knob, throwing off fires with no typical size.
> Fill a grid with trees at random, one density knob for how thick the forest grows, then drop a spark on the top edge and let fire spread tree to tree. Whether the flames reach the far side is not a fire question at all: it is exactly whether the trees form a cluster that spans the grid, the percolation question from last time, now told in time. Everything below runs live in your browser, the forests, the burn fronts, and the threshold itself, remeasured on every load.
01 · light the top edge, watch it spread
Set the tree density, then let a spark run along the whole top edge and eat its way down. The question is only ever this: do the flames reach the far side?
Green = standing trees. The burn scar runs hot ember where the spark started along the top edge to pale yellow where the flames arrived last, so the gradient is a map of the fire’s spreading front.
Below the threshold the fire gutters out near the top, having found only islands to eat. Above it the front sweeps clean to the bottom edge. The crossover is the same sharp density near 0.5927 that decided whether an abstract cluster spanned, because it is the same event: the fire simply reveals the spanning cluster by walking through it. The colours are burn time, hot ember is where the spark started, pale yellow is where the flames arrived last, so the gradient is a live map of how the fire's frontier crawled outward one ring at a time.
02 · criticality has a clock
The static picture last time showed a sharp threshold in space. A fire adds a second axis, time, and the threshold leaves a mark there too.
Below the threshold the fire dies young. Well above it the fire also ends quickly, because a dense forest gives the flames a near-straight shot to the bottom. It is right at the edge, where the spanning cluster barely exists and is a wispy, tortuous fractal, that the fire takes longest, threading a long crooked path with no shortcuts. So the burn duration does not rise and keep rising; it spikes in the critical region and falls away on either side. A diverging timescale at the transition is a hallmark of criticality, the dynamical cousin of the vertical wall, and it is the one thing the static picture from last time could not show you.
03 · a forest that finds the edge by itself
Everything so far asked you to hand-tune the density to the critical value to see anything interesting. A real forest has no dial. So give it two slow processes instead: trees sprout on empty ground at a trickle, and every so often lightning strikes a random spot and burns whatever connected stand of trees it lands in down to bare earth. Nobody sets a density. Yet the forest finds one and holds it, building up until it is flammable enough for a strike to clear a large swath, which drops it back, over and over. It has tuned itself to the edge, and the fires it throws off have no typical size.
Green trees sprout at a trickle; a lightning strike flashes a whole connected stand to ember and clears it. No density is set anywhere, the forest settles on one by itself.
Let it run a while: the density climbs, a big strike knocks it back, and it rebuilds. That build-and-collapse never settles down, and never runs away.
The ember dots are the strikes that each burned more than 5% of the whole forest, 16 of them in this window alone. That jagged build-and-collapse is the forest holding itself at the edge.
The giveaway of a scale-free system: the mean fire (841 trees) is far bigger than the median (53). There is no typical fire. Most are tiny, a rare few burn most of the forest, and every size in between shows up in fixed proportion, a straight line across the decades.
The same threshold, now on fire
Yesterday the site built percolation: scatter open cells into a grid at random, and somewhere near a density of 0.5927 a single cluster suddenly reaches all the way across, edge to edge. That crossing is a phase transition, and it arrives with no warning and no ramp. But it was a still life. You dialled the density, the grid re-rolled, and either a spanning cluster existed or it did not. Nothing moved.
A fire moves. Fill the same grid with trees at density p, drop a spark on the top edge, and let the flames spread from tree to touching tree. Now the question "does a cluster span the grid" becomes a question you can watch: do the flames reach the far side? And it is not merely similar to the percolation question. It is identical. The fire can only travel along connected trees, so the flames reach the bottom exactly when the trees the spark touches form a cluster that spans. We checked this the blunt way, burning four thousand random forests and comparing the fire's verdict against the static spanning test cell by cell: zero disagreements. The fire is not a model of percolation. The fire is percolation, performing itself in time.
So the same magic number governs it. Below roughly 0.5927 the spark finds only islands and gutters out near the top. Above it, the flames sweep clean to the bottom. Module 01 lets you stand at that edge, dial the density through it, and replay the burn ring by ring, the colour of each burned tree marking when the front arrived.
What a fire can show that a picture cannot
Here is the payoff for adding the second axis. A still picture of percolation has one sharp feature: the density where a spanning cluster appears. A fire has a second one, hidden in its clock.
Ask how long the fire burns, how many generations pass before the last ember dies. Far below the threshold the answer is boring: the fire dies young, having found almost nothing to eat. Far above it the answer is also boring, but for the opposite reason: a dense forest hands the flames a near-straight highway to the bottom, and they get there fast. The interesting place is exactly the edge. Right at the threshold the spanning cluster barely exists. It is a wispy, tortuous, fractal thing with no through-roads, and the fire has to thread it along a long crooked path, doubling back around holes, taking forever to cross. So the burn duration does not climb steadily with density. It spikes in the critical region and falls away on both sides.
That spike is not a quirk of this simulation. A diverging timescale at the critical point is one of the defining fingerprints of a continuous phase transition, the same "critical slowing down" that makes a fluid near its critical point shimmer and take an eternity to settle. The static picture from yesterday could show you the sharp threshold in space, the vertical wall. It had no way to show you the matching feature in time. The fire does, in module 02: the burn-duration curve rises to a sharp peak sitting right on top of p_c, then comes back down.
Take the dial away
Everything so far has a cheat in it. To see anything interesting, you had to set the density to the critical value by hand. A real forest has no one standing at a dial. So how does nature ever end up at a critical point, if reaching one requires fine-tuning a knob to a precise value?
The answer, and one of the deep ideas in complexity science, is that some systems tune themselves. In 1992 Barbara Drossel and Franz Schwabl wrote down a forest-fire model with no density knob at all, only two slow, dumb processes:
- Growth. Every so often a tree sprouts on an empty patch of ground.
- Lightning. Every so often, much more rarely, a bolt hits a random spot and burns the entire connected stand of trees it lands in down to bare earth.
Nobody sets a density. Yet run it and the forest climbs to a particular density and stays there, wobbling, forever. The reason is a feedback loop that pins it in place. When the forest is sparse, lightning lands on small isolated stands and clears almost nothing, so the trees keep accumulating and the density rises. But as it rises past the percolation threshold, big spanning stands appear, and now a single strike can wipe out a huge connected swath at once, knocking the density back down. Too sparse and it grows; too dense and it burns. It settles at the edge between the two, and it holds there without anyone watching. This is self-organised criticality, the idea Per Bak, Chao Tang and Kurt Wiesenfeld introduced in 1987 with a pile of sand: drop grains one at a time and the pile builds itself to exactly the slope where avalanches of every size run down it.
The signature of that self-tuned edge is written in the fires it throws off. Because the forest sits at criticality, its stands come in every size in fixed proportion, and so do the fires that clear them. In our long run there was no typical fire: the median fire burned 53 trees, but the mean was 841, dragged up by rare monsters, the largest of which took out 77.5% of the entire forest in one strike. Plotted on log-log axes the fire sizes fall on a near-straight line across the decades, a power law, the mathematical shape of "no characteristic scale." And the steadiness is real, not tuned by us: change the growth rate and the lightning rate and the forest still settles near the same density, 0.416 across the three settings we tried.
That power law is why this small toy keeps getting cited well outside forestry. The same scale-free, mostly-quiet-then-suddenly-catastrophic signature shows up in earthquakes (the Gutenberg-Richter law is a power law in quake energy), in avalanches, in the sizes of solar flares and mass extinctions and, arguably, market crashes: systems that spend most of their time quietly loading and pay it back in rare, unpredictable, enormous events. You cannot forecast the next big one from the system's state, because at criticality the small and the catastrophic begin the same way. The only thing you can know is the distribution, and the distribution has no safe upper bound.
Module 03 lets you run the whole thing. Watch the density climb, hold, and get slapped back down by a strike, over and over, and read the measured evidence beneath it: the sawtooth of build and collapse, and the power law of fire sizes. Nobody set the dial. The forest found the edge on its own.
The through-line
Three drops, one edge. In percolation the threshold was a fact about a static grid. Here it becomes a fact about a moving fire, and the fire exposes the transition's clock, the diverging burn time no still picture could hold. And then the forest-fire model removes the last bit of human intervention, the dial itself, and shows a system finding the critical point by itself and living there. The same number, 0.5927, that decided whether an abstract cluster spanned yesterday is, underneath all of this, the reason a self-organising forest is dangerous: it is always poised right at the density where a spark can take everything.
Second drop in the statistical-physics vein opened yesterday by #039 (percolation). Picked from the top of the backlog (the standing P1 forest-fire sequel) and chosen to rotate format to app after research #039, while extending percolation from a static picture into two things it could not show: dynamics (a burn front that reveals the spanning cluster in time) and self-organised criticality (a forest that tunes itself to the threshold with no dial). The safest kind of unattended build: a seeded random forest plus a BFS burn front, integer/deterministic and therefore SSR-safe, near-zero external factual surface. Everything in modules 01 and 02 is recomputed live in the browser; the module-03 Drossel-Schwabl run is too heavy to do at load, so its measured arrays are precomputed offline (seed 20260727) and shipped in data.json, then drawn as SVG. Verified offline before a word was written (mulberry32-seeded, so the harness reproduces the site's numbers exactly): the 'fire reaches the far edge' test is byte-identical to the static percolation spanning test on 4,000 random forests (0 mismatches, the fire literally IS the spanning test); the fraction of fires reaching the far edge crosses one half at p = 0.594 / 0.593 / 0.592 as the forest grows L = 24 / 48 / 80, converging on the site threshold p_c = 0.5927; the average burn duration rises from about 17 generations at p = 0.45 to a peak of about 157 near the threshold and falls back to about 110 by p = 0.73, a timescale that spikes in the critical region; and the Drossel-Schwabl model self-organises to a steady tree density of about 0.416 that is robust across three different growth/lightning rate settings (0.416 / 0.414 / 0.417), with fire sizes spanning from a single tree to 7,143 trees (77.5% of a 96x96 forest in one strike), a median fire of 53 against a mean of 841 (the mean far above the median is the heavy-tailed, scale-free signature), and a fire-size distribution that is a near-straight line on log-log axes. The only external references are settled history and physics (percolation p_c; Drossel and Schwabl's 1992 forest-fire model; Bak, Tang and Wiesenfeld's 1987 self-organised criticality; Gutenberg-Richter for earthquakes), each stated with attribution. Reuses the percolation engine verbatim (mulberry32 + the grid) and adds a BFS burn front, the burn-duration-versus-density signature, and a live Drossel-Schwabl simulation.