What does Critical Transitions and Resilience conclude, in numbers, about “Cascading Failure: Spare Capacity and Interdependence”?
Answer: In the capacity–load model, the more uneven the load, the more easily the failure of one key node brings the network down: in a 300-node scale-free network, 10 % spare capacity is enough for random faults, but withstanding an attack on the highest-load node takes about 140 %. The most important redundancy looks most like waste in ordinary times. Two one-to-one interdependent random networks collapse completely and suddenly when about 61 % of nodes are kept, while a single network vanishes continuously only at 25 %; with weaker dependence the collapse becomes continuous again. All these conclusions rest on explicit model assumptions.
Scope of the numbers: The book is not medical advice and makes no investment or financial forecasts; its business and physiological examples are analogies. Marked boxes separate published evidence, runnable Python calculations (15 programs, all checked), classical sources and the author's hypotheses.
Data table
The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python only
| scale-free: max degree 28, top load 7510 (mean 395); homogeneous: top load 720 | |||
| alpha | G after removing: top-load node (rounds) | a random node (mean of 5) | homogeneous, top-load |
| 0.0 | 0.02 (1) | 0.46 | 0.02 |
| 0.1 | 0.17 (3) | 0.99 | 1.00 |
| 0.2 | 0.44 (4) | 1.00 | 1.00 |
| 0.3 | 0.63 (3) | 1.00 | 1.00 |
| 0.5 | 0.79 (2) | 1.00 | 1.00 |
| 0.8 | 0.86 (2) | 1.00 | 1.00 |
| 1.2 | 0.90 (3) | 1.00 | 1.00 |
| 1.4 | 0.96 (2) | 1.00 | 1.00 |
| 2.0 | 0.97 (2) | 1.00 | 1.00 |
| alpha_c (G >= 0.95 at every alpha from here to 3.0, step 0.1): 1.4 | (G = 0.96; at 1.3: 0.91) |
Show the full program
# Overload cascades (Motter & Lai 2002). Load L_i = number of shortest paths between other
# pairs that pass through i (Brandes's algorithm); capacity C_i = (1 + alpha) L_i0. Remove one
# node, recompute loads, remove every overloaded node, repeat. G = largest component / N.
# Scale-free (Barabasi-Albert, N = 300, m = 2, 597 links) vs homogeneous (all degrees 4, 600 links).
import random
from collections import deque
rng = random.Random(10)
N = 300
def ba(m=2):
adj = {i: set() for i in range(N)}; targets = []
for i in range(m + 1):
for j in range(i): adj[i].add(j); adj[j].add(i); targets += [i, j]
for v in range(m + 1, N):
chosen = set()
while len(chosen) < m: chosen.add(rng.choice(targets))
for t in chosen: adj[v].add(t); adj[t].add(v); targets += [v, t]
return adj
def regular(k=4):
while True: # configuration model, retry until simple
stubs = [v for v in range(N) for _ in range(k)]; rng.shuffle(stubs)
adj = {i: set() for i in range(N)}; ok = True
for a, b in zip(stubs[::2], stubs[1::2]):
if a == b or b in adj[a]: ok = False; break
adj[a].add(b); adj[b].add(a)
if ok: return adj
def loads(adj, alive):
L = dict.fromkeys(alive, 0.0)
for s in alive: # Brandes (2001), unweighted
pred = {v: [] for v in alive}; sig = dict.fromkeys(alive, 0); sig[s] = 1
dist, order, q = {s: 0}, [], deque([s])
while q:
v = q.popleft(); order.append(v)
for w in adj[v]:
if w not in alive: continue
if w not in dist: dist[w] = dist[v] + 1; q.append(w)
if dist[w] == dist[v] + 1: sig[w] += sig[v]; pred[w].append(v)
delta = dict.fromkeys(alive, 0.0)
for w in reversed(order):
for v in pred[w]: delta[v] += sig[v] / sig[w] * (1 + delta[w])
if w != s: L[w] += delta[w]
return {v: x / 2 for v, x in L.items()} # each unordered pair counted twice
def giant(adj, alive):
seen, best = set(), 0
for s in alive:
if s in seen: continue
seen.add(s); st, n = [s], 0
while st:
v = st.pop(); n += 1
for w in adj[v]:
if w in alive and w not in seen: seen.add(w); st.append(w)
best = max(best, n)
return best
def cascade(adj, L0, alpha, first):
alive, rounds = set(adj) - {first}, 0
while True:
L = loads(adj, alive)
over = {v for v in alive if L[v] > (1 + alpha) * L0[v] + 1e-9}
if not over: return giant(adj, alive) / N, rounds
alive -= over; rounds += 1
if __name__ == "__main__":
sf, h = ba(), regular()
L0, Lh = loads(sf, set(sf)), loads(h, set(h))
top, toph = max(L0, key=L0.get), max(Lh, key=Lh.get)
print(f"scale-free: max degree {max(len(v) for v in sf.values())}, top load {L0[top]:.0f}"
f" (mean {sum(L0.values()) / N:.0f}); homogeneous: top load {Lh[toph]:.0f}")
randoms, res = rng.sample(range(N), 5), {}
print(" alpha G after removing: top-load node (rounds) a random node (mean of 5)"
" homogeneous, top-load")
for alpha in (0.0, 0.1, 0.2, 0.3, 0.5, 0.8, 1.2, 1.4, 2.0):
g1, r1 = cascade(sf, L0, alpha, top); res[alpha] = g1
g2 = sum(cascade(sf, L0, alpha, v)[0] for v in randoms) / 5
print(f" {alpha:3.1f} {g1:5.2f} ({r1}) {g2:5.2f}"
f" {cascade(h, Lh, alpha, toph)[0]:5.2f}")
grid = [i / 10 for i in range(31)] # alpha_c on a 0.1 grid up to 3.0
gs = {a: res[a] if a in res else cascade(sf, L0, a, top)[0] for a in grid}
ac = min(a for a in grid if all(gs[b] >= 0.95 for b in grid if b >= a))
print(f"alpha_c (G >= 0.95 at every alpha from here to 3.0, step 0.1): {ac}"
f" (G = {gs[ac]:.2f}; at {ac - 0.1:.1f}: {gs[round(ac - 0.1, 1)]:.2f})")Single source and citation
Fan, Y. (2026). Phase Transitions, Critical Slowing Down and Resilience in Complex Dynamical Systems (Version 1.0.0), Chapter 5: Cascading Failure: Spare Capacity and Interdependence. 5D Library. https://doi.org/10.5281/zenodo.23770082
DOI: 10.5281/zenodo.23770082 · Read the monograph · 5DL-B-028 · v1.0.0 · CC-BY-NC-ND-4.0
BibTeX
@book{fan2026028,
author = {Fan, Yafu},
title = {Phase Transitions, Critical Slowing Down and Resilience in Complex Dynamical Systems},
year = {2026},
publisher = {5D Library},
edition = {1.0.0},
doi = {10.5281/zenodo.23770082},
url = {https://doi.org/10.5281/zenodo.23770082}
}Other chapter answers in this book
- Chapter 1 · Folds, Hysteresis and Flips That Are Hard to Undo
- Chapter 2 · Critical Slowing Down: Why Recovery Gets Slower
- Chapter 3 · The Limits of Early Warning: Signal to Noise, Selection Bias and Flips Without Warning
- Chapter 4 · Two Kinds of Resilience: Recovering Quickly or Withstanding the Blow
- Chapter 6 · Tight Coupling and Modularity: Normal Accidents and High Reliability
- Chapter 8 · Practice and a Pre-registered Trial