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
alphaG after removing: top-load node (rounds)a random node (mean of 5)homogeneous, top-load
0.00.02 (1)0.460.02
0.10.17 (3)0.991.00
0.20.44 (4)1.001.00
0.30.63 (3)1.001.00
0.50.79 (2)1.001.00
0.80.86 (2)1.001.00
1.20.90 (3)1.001.00
1.40.96 (2)1.001.00
2.00.97 (2)1.001.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