关于「级联失效:冗余容量与相互依赖」,《临界转变与韧性》给出的定量结论是什么?
结论:在容量—负荷模型中,负荷越不均匀,越容易被一个关键节点的失效拖垮:300 个节点的无标度网络中,10% 的冗余足以应付随机故障,但挡住对负荷最高节点的攻击需要约 140%。最关键的冗余平时最像浪费。两个一对一相互依赖的随机网络在保留约 61% 的节点时突然全部瘫痪,单个网络要到 25% 才连续地消失;依赖减弱后崩溃又变为连续的。这些结论都依赖明确的模型假设。
数据口径:本书不是医疗建议,也不作投资或金融预测;企业与生理的例子都是类比。 书中以标注框区分已发表的证据、可运行的 Python 计算(15 段程序,全部核对)、原典与作者的假说。
对照数据表
下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库
| 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) |
查看完整验算程序
# 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}
}