关于「级联失效:冗余容量与相互依赖」,《临界转变与韧性》给出的定量结论是什么?

结论:在容量—负荷模型中,负荷越不均匀,越容易被一个关键节点的失效拖垮:300 个节点的无标度网络中,10% 的冗余足以应付随机故障,但挡住对负荷最高节点的攻击需要约 140%。最关键的冗余平时最像浪费。两个一对一相互依赖的随机网络在保留约 61% 的节点时突然全部瘫痪,单个网络要到 25% 才连续地消失;依赖减弱后崩溃又变为连续的。这些结论都依赖明确的模型假设。

数据口径:本书不是医疗建议,也不作投资或金融预测;企业与生理的例子都是类比。 书中以标注框区分已发表的证据、可运行的 Python 计算(15 段程序,全部核对)、原典与作者的假说。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库

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)
查看完整验算程序
# 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})")

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《复杂系统相变、临界慢化与生态韧性的非线性动力学》第 5 章「级联失效:冗余容量与相互依赖」(版本 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23770082

DOI: 10.5281/zenodo.23770082 · 阅读本章所在专著 · 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}
}

本书其他章节结论