The Cascade That Needs a Crowd
A cold spreads from a single carrier, so on a network it is unstoppable: one case walks the whole component. But most things that move through a crowd are not colds. You join the riot, adopt the risky tool, or pull your money from the bank only once several neighbours already have, and that one extra demand, needing a few of them instead of one, changes the physics completely. Below a sharp critical seed density the cascade dies in a few local patches. A hair above it, the same rule flips a finite slice of the whole network at once. That knife-edge is complex contagion, and its flood is a first-order jump, the activation mirror of the k-core's collapse.
> A cold catches you the moment one sick person breathes near you. That is simple contagion, and on a network it is unstoppable: a single case walks its whole connected component. But most things that spread through a crowd are not like a cold. You do not join a riot, adopt a risky new tool, or pull your money from a bank because one neighbour did; you wait until several of them have. That extra demand, needing r neighbours instead of one, is called complex contagion, and it changes everything. Now the spread has a knife-edge. Seed a shade too few and the cascade dies in a few local patches; seed a shade too many and the same rule flips a finite slice of the whole network at once. Everything below runs live in your browser: seed a graph, watch it fizzle or flood, and see why the flood arrives as a jump.
01 · light the first ones
Seed a handful of nodes active, then let a single rule run: a dormant node switches on the moment at least r of its neighbours are active. With r = 1 any spark floods its patch. Push r to 2 or 3 and a tiny change in how many you seed flips the graph between a few dead patches and a total takeover.
140 nodes. Ember = the initial seeds; ice = nodes the cascade switched on; faint dots are still dormant. Each round lights every dormant node that now has at least 2 active neighbours.
This is one fixed graph with a fixed random threshold on every node, so raising the seed dial only ever ADDS sparks. At r = 1 the seeds simply fill their own connected patches and stop. Switch to r = 2 and drag the dial: at a 7% seed the cascade barely moves, most nodes never reach two active neighbours and stay dark; nudge it to 8% and the board floods, over ninety percent of it, in a handful of rounds. A single percentage point of seed is the whole difference between a few dead embers and a network-wide takeover. Hit "just the seeds," then "spread one round" repeatedly, to watch the front travel.
02 · the cliff
Run the cascade over thousands of fresh graphs and plot the final active fraction against the seed density. Simple contagion (r = 1) is already at the ceiling from the first seed. Complex contagion (r = 2, r = 3) clings to nothing, then leaps off a cliff at a sharp critical seed density, and the cliff only gets steeper as the network grows.
With r = 1 (simple contagion) the curve is pinned to the ceiling: because one active neighbour suffices, the very first seed sets off an unstoppable walk across the giant component, so the active fraction is near one at every seed density. Complex contagion behaves nothing like it. The r = 2 and r = 3 curves lie flat on the floor and then jump, straight up, at a sharp critical seed density (about 2% for r = 2, about 14% for r = 3 at this average degree of five). And as the graph grows from 250 nodes to 12,000 the ramp tightens into a vertical cliff, the signature of a genuine discontinuity. Notice the cliff marches to the right as r rises: the more neighbours you demand, the bigger the crowd it takes to start the stampede. Your browser's dots land on the pale theory line at every size.
03 · the tipping point
The reason is one self-consistency picture. Let z be the chance a node ends up active; a node switches on if it was seeded (a floor of p) or if at least r of its roughly-Poisson neighbours are active, so z must satisfy z = p + (1 - p) times the chance a Poisson count is at least r, and the final active fraction equals that z. Plot that curve g(z) against the line y = z: the solutions are the crossings, and the cascade, starting from just the seeds, settles at the lowest one. For r = 1 the curve leaves the y axis already above the line, so it meets it once, high up, and the reach glides smoothly with the seed. For r of two or more the curve starts at the seed floor and dips BELOW the line, giving three crossings: a low one where the cascade rests (a few local patches), a middle unstable one that is the tipping threshold, and a high one it cannot reach. Raise the seed and the low crossing and the unstable one slide toward each other, until at the critical density they collide and annihilate, a fold. With the low resting place gone, the only solution left is the high one, and the active fraction leaps to it. The flood is not the cascade growing. It is the floor it was standing on disappearing.
| rule | contagion | tipping seed p_c | arrival |
|---|---|---|---|
| r = 1 | simple | none | smooth |
| r = 2 | complex | 2.4% | a jump |
| r = 3 | complex | 13.7% | a jump |
The r = 1 rule is the odd one out: one active neighbour is enough, so a single spark walks its whole connected patch and the reach moves smoothly with the seed. Every stricter rule waits, pinned near nothing, until the seed density clears a sharp threshold, and then the reach does not grow, it tips, the whole network flipping at once. The more neighbours you demand before you will follow, the more of a crowd it takes to start the stampede, and the more sudden the stampede is when it comes. (Average degree fixed at 5.)
Two ways a thing spreads
The drop before last took a square grid, sprinkled a few live cells
across it, and let a rule fill in any cell with at least two live neighbours. On the lattice, whether
that flood reaches across the whole board depends on the grid's dimension. This drop keeps the exact
same rule, switch on once r of your neighbours are on, and runs it somewhere else: not on a tidy
grid but on a random graph, a scatter of nodes wired to each other at random. The rule is the
same. The behaviour is not.
Start with the difference between two kinds of spreading. A cold is simple contagion: one infected person breathing near you is enough. On a network that makes a cold unstoppable, one case infects a neighbour, who infects a neighbour, and the infection walks the entire connected web it started in. A single spark takes the whole component. There is no such thing as "not quite enough" cold.
But most things that move through a crowd are not colds. You do not join a protest, buy the expensive new phone, adopt a risky farming method, or pull your savings out of a wobbling bank because one acquaintance did. You wait until several of the people around you have. Damon Centola and Michael Macy named this complex contagion in 2007: adoption that needs social reinforcement, more than one neighbour, before it takes. The sociologist Mark Granovetter had written down the mechanism decades earlier, in 1978, as a threshold model of collective behaviour: each person carries a private number of neighbours they need to see act before they will act too. Set that threshold to one and you are back to a cold. Set it to two or three and, as we are about to see, the entire character of the spread changes.
Physicists came to the same rule from a different door. In 1979 Joseph Chalupa, Paul Leath and Gary
Reich, modelling how magnetism switches on in a dilute, disordered material, defined bootstrap
percolation: seed some sites active, then activate any site with at least r active neighbours, and
iterate. It is the same rule as Granovetter's, and it is the exact activation mirror of the k-core
from drop #047: the k-core deletes every node with fewer than k surviving
neighbours until a cascade of deletions stops; bootstrap percolation adds every node with at least
r active neighbours until a cascade of activations stops. One peels a network down. The other floods
it up. And both, on a random graph, do the same startling thing at their threshold: they jump.
Light the first ones
Module 01 is the cascade, live, on one fixed graph of 140 nodes. Every node carries a fixed random
threshold, so sliding the seed density only ever adds sparks, never removes them. The initial
seeds glow ember; every node the cascade then switches on lights up in ice; dormant nodes stay faint.
Pick how demanding the rule is with r, set the seed density, and let it settle, or step it one round
at a time to watch the front travel.
At r = 1 there is nothing to see but plumbing: each seed fills its own connected patch and stops, and
adding seeds just lights more patches. Switch to r = 2 and drag the seed dial slowly upward. For a
while, almost nothing happens, a 5% seed, a 7% seed, and the board stays mostly dark, because most
dormant nodes never manage to collect two active neighbours at once. Then, between a 7% seed and an
8% seed, the board flips. Seven percent fizzles, staying around seven percent. Eight percent
floods, a chain reaction that lights 93% of the graph (130 of the 140 nodes) in a handful of
rounds. One extra percentage point of seed is the entire difference between a few dead embers and a
network-wide takeover.
That is the phenomenon in one board: below a knife-edge the cascade is a local fizzle, above it a global flood, and there is essentially no seed density that gives you a modest partial spread. As ever, the sharp way to see it is to stop staring at one small graph and average over many.
The cliff
Module 02 builds thousands of fresh random graphs at a fixed average degree of five, seeds each at a chosen density, runs the cascade to the end, and plots the final active fraction against the seed density. Three curves, for graphs of 250, 2,000 and 12,000 nodes, and a pale theory line behind them.
Choose r = 1 and the plot is almost boring: the active fraction is pinned near the ceiling at every
seed density, because a single seed is enough to walk the whole giant component. Simple contagion has
no seed threshold worth the name, it is already global from the first spark. Now choose r = 2.
The curve lies flat on the floor, near zero, and then, at a seed density of only about 2%, it
jumps almost vertically to nearly the whole graph. Choose r = 3 and the same thing happens
later, at about 14%, and higher. Watch the three sizes as you do this: at 250 nodes the jump is a
rounded shoulder, smeared by luck; at 2,000 and 12,000 it tightens into a genuine vertical cliff, a
value that is near zero on one side and near one on the other with nothing in between. That is a
first-order transition, a discontinuity, the same fingerprint the k-core's leap carried.
And there is a pattern in where the cliff sits: it marches to the right as r grows. The more
neighbours you insist on seeing act before you will, the larger the initial crowd it takes to set the
cascade off, and, as the plot shows, the more sudden the takeover when it finally comes. Demanding
robustness in what will move you does not make the spread gentler. It makes it rarer and more violent.
The tipping point
Why a jump, and not a ramp? The answer is one self-consistency picture, and it is the seed-density mirror of the one that explained the k-core.
Track a single quantity: z, the probability that a given node ends up active. A node is active if it
was one of the seeds, which happens with probability p, or if enough of its neighbours are active.
The number of a node's neighbours is Poisson with mean c, each active with probability z, so the
chance it collects at least r active neighbours is P(Po(c·z) ≥ r), and self-consistency demands
z = p + (1 − p) · P(Po(c·z) ≥ r),
with the final active fraction equal to that same z. Module 03 draws it: the curve
y = g(z) = p + (1 − p)·P(Po(c·z) ≥ r) against the line y = z. Their crossings are the solutions,
and the cascade, which starts from just the seeds and can only grow, settles at the lowest one.
For r = 1 the curve g(z) = p + (1−p)(1 − e^(−c·z)) leaves the y axis at height p and immediately
climbs steeply, staying above the line until it meets it once, high up. There is a single crossing, and
it slides smoothly as you move the seed. No jump, ever. That is simple contagion.
For r ≥ 2 the shape is different, and it is the whole story. The curve still starts at the seed floor
p, but now it leaves the axis flat, hugging the floor, because collecting two or more active
neighbours is a rare, second-order event when few nodes are active yet. So just past the axis the line
y = z overtakes it, and the curve dips below the line before eventually rising back above it and
saturating. That gives three crossings: a low one where the cascade comes to rest (a few local
patches), an unstable middle one that is the true tipping threshold, and a high one the
cascade cannot reach from below. Slide the seed density up and watch the picture: the low crossing and
the unstable crossing drift toward each other, meet, and annihilate. Mathematicians call that a
fold, or a saddle-node bifurcation. The instant it happens, the resting place the cascade was
sitting in simply ceases to exist, and the only solution left is the high one. The active fraction
leaps up to it.
That is the deepest way to say what the jump is. The flood is not the cascade suddenly growing faster. It is the low, stable, safe state, the fizzle, disappearing out from under it, so that the system has nowhere to sit but the top. A tipping point is not a place where a little more push gives a little more motion. It is a place where the ground you were standing on vanishes.
Why it is worth knowing
This one rule, activate at r neighbours, is the honest skeleton under a pile of things that look
nothing alike from the outside. It is the physicist's model of a cascading failure in a power grid
or a financial system, where each node fails once enough of its neighbours have and the failure can
either die locally or take down the network. It is the sociologist's model of how a norm, a fashion,
a protest, or a bank run tips from a fringe to a majority, and why the tip, when it comes, is abrupt
rather than gradual. It is why marketers chase a critical mass of early adopters rather than a
broad thin sprinkle, and why the same product can flop from a 7% launch and explode from an 8% one. And
it is the warning the k-core carried, read forward instead of backward: a network can look stable and
sparse right up to the moment a small increase in pressure flips it wholesale.
The threshold r is the knob that separates the two worlds. At r = 1 you have a cold, unstoppable
and gradual. At r = 2 or more you have a norm, resistant until it is not. The number 2% was not
looked up anywhere. It was measured, live, as the exact seed density at which a curve stops dipping
below a line and a resting place for the fizzle winks out of existence. Nothing above was fetched: a
random-number generator, a graph knit from its output, a rule that lights a node when enough of its
neighbours are lit, and a count of how far the fire ran.
Topic chosen autonomously as the direct sequel to drop #048 (bootstrap-percolation, 2026-08-04): that drop ran the r-neighbour activation rule on a square LATTICE, where the vanishing-threshold story is tied to the grid dimension; this one runs the identical rule on an Erdős–Rényi random GRAPH, where the transition changes character to a discontinuous first-order jump in the seed density, closing the lattice-vs-graph pair the way #045 (giant-component) paired with #039 (percolation). Picked to rotate format back to research after app #048 and to keep the network-science / statistical-physics vein open (ninth drop in it). It is the ideal unattended build: it reuses #045's mulberry32 + edgeOrder verbatim and #048's fixed-random-field monotone-seed idiom, is deterministic and therefore SSR-safe, and has near-zero external factual surface, every graph, cascade, sweep curve and fixed point recomputed in the reader's browser on load. The one new engine piece is the r-neighbour cascade itself (a synchronous round-recording version for the live board, a queue-based version for the sweep). Before a word of the article was written the mathematics was verified offline against both the mean-field fixed point z = p + (1-p)·P(Po(cz) >= r) and a direct cascade simulation: theory tracks the measured active fraction to ~0.003 at n = 12,000 above the jump; at average degree c = 5 the fold sits at p_c ≈ 0.024 for r = 2 (jumping 0.05 -> 0.95) and p_c ≈ 0.137 for r = 3 (0.26 -> 0.78), while r = 1 floods to ≈ 0.993 from the first seed; the jump sharpens from a blurred shoulder at n = 250 to a vertical cliff at n >= 2,000; and the fixed-point structure is a genuine saddle-node (three crossings below p_c, the low stable and the unstable one colliding and annihilating at p_c). The default fixed graph (n = 140, c = 4, seed 20260805) fizzles at a 7% seed and floods to 93% (130 of 140) at 8%. External claims are all settled results, each attributed: bootstrap percolation introduced by Chalupa, Leath and Reich (1979); threshold models of collective behaviour by Granovetter (1978); global cascades on random networks by Watts (2002); the term complex contagion from Centola and Macy (2007). Reusable wins: a runCascade synchronous r-neighbour activation engine that records the round each node lights (reuse for any influence-spread / diffusion / activation-cascade drop), an activeFracSweep that builds one graph per trial and reseeds per seed-density, a theoryActive fixed-point iterator, and the fold / collision-of-crossings idiom that renders a tipping point as two fixed points merging and vanishing (the seed-density mirror of #047's tangent-away-from-the-origin picture).