What does Liability Percolation and Guarantee Tail Ruin conclude, in numbers, about “Threshold Contagion: Default Avalanches on Guarantee Graphs and an Exact Enumeration”?

Answer: Chapter 2 uses threshold contagion and an exact enumeration of all 1,024 mutual-guarantee patterns of a small group to show that guarantee payments do not thin out as partners multiply.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (17 programs), 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 onlyprinted values that match the answer: 1024

edges patternsmean failuresworst patternP(all five fail)
011.0001.0000.000
1101.1601.4000.000
2451.3471.8000.000
31201.5702.2000.000
42101.8672.8000.000
52522.2733.4000.000
62102.8654.2000.108
71203.6004.2000.357
8454.4135.0000.764
9104.8405.0000.960
1015.0005.0001.000
patterns enumerated: 1,024
Show the full program
# Chapter 2. p22: exact enumeration of every mutual-guarantee pattern in
# a five-entity group. Each of the 10 possible pairs may or may not sign
# a mutual guarantee of size G. When an entity fails, each surviving
# partner is called for G and fails once its calls exceed its capital.
# One entity, chosen uniformly, fails first. All 1,024 patterns are
# enumerated, so the averages below are exact. Capitals are illustrative.
import itertools
from fractions import Fraction

CAP = [13, 9, 7, 5, 4]              # capital of entities 0 to 4
G = 6                               # guarantee called per failed partner
PAIRS = list(itertools.combinations(range(5), 2))


def cascade(edges, first):
    nbr = {i: [] for i in range(5)}
    for a, b in edges:
        nbr[a].append(b)
        nbr[b].append(a)
    failed, calls, todo = {first}, [0] * 5, [first]
    while todo:
        j = todo.pop()
        for i in nbr[j]:
            if i in failed:
                continue
            calls[i] += G
            if calls[i] > CAP[i]:
                failed.add(i)
                todo.append(i)
    return len(failed)


rows = {}
for mask in range(1 << len(PAIRS)):
    edges = [PAIRS[t] for t in range(len(PAIRS)) if mask >> t & 1]
    sizes = [cascade(edges, f) for f in range(5)]
    mean = Fraction(len([0 for s in sizes for _ in range(s)]), 5)
    whole = Fraction(len([s for s in sizes if s == 5]), 5)
    rows.setdefault(len(edges), []).append((mean, whole))
print("edges patterns  mean failures  worst pattern  P(all five fail)")
for k in sorted(rows):
    r = rows[k]
    m = Fraction(0)
    w = Fraction(0)
    for a, b in r:
        m += a
        w += b
    worst = max(a for a, _ in r)
    print("{:5d} {:8d} {:14.3f} {:14.3f} {:17.3f}".format(
        k, len(r), float(m / len(r)), float(worst), float(w / len(r))))
print("patterns enumerated: {:,}".format(1 << len(PAIRS)))

Single source and citation

Fan, Y. (2026). Liability Percolation across Subsidiary Graphs, Tail-Ruin Amplification from Personal Guarantees and Risk-Bucket Partitioning of Operating Assets (Version 1.0.0), Chapter 2: Threshold Contagion: Default Avalanches on Guarantee Graphs and an Exact Enumeration. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-177 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026177,
  author    = {Fan, Yafu},
  title     = {Liability Percolation across Subsidiary Graphs, Tail-Ruin Amplification from Personal Guarantees and Risk-Bucket Partitioning of Operating Assets},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book