What does Liability Percolation and Guarantee Tail Ruin conclude, in numbers, about “The Percolation Threshold: Guarantee Density, the Giant Component and the Failure of Ring-Fencing”?

Answer: Chapter 3 locates the percolation threshold: at 1.2 guarantee ties per entity the giant component already holds 0.3137, and a ring-fenced entity with one liability edge is reached by the risky entity with probability 0.1129 instead of zero.

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: 0.3137, 1.2

cS exactS simulatedP(two entities
N = 2,000share a fate)
0.50.00000.00640.0000
0.80.00000.02230.0000
1.00.00000.07600.0000
1.20.31370.29820.0984
1.50.58280.57440.3397
2.00.79680.79750.6349
3.00.94050.94140.8845
4.00.98020.98040.9607
Show the full program
# Chapter 3. p31: the giant component of a random guarantee graph.
# Entities are nodes; a guarantee, cross-guarantee or cash-pool tie is an
# undirected edge; c is the mean number of ties per entity. Erdos and
# Renyi (1960): above c = 1 a giant component holding a share S of all
# entities appears, with S = 1 - exp(-c S). We solve S exactly by
# iteration and check it with seeded G(n, m) graphs and union-find.
import math
import random

N, GRAPHS = 2000, 30
rng = random.Random(20261112)


def s_exact(c):
    if c <= 1.0:                    # no positive root at or below c = 1
        return 0.0
    s = 1.0
    for _ in range(100000):
        s_new = 1 - math.exp(-c * s)
        if abs(s_new - s) < 1e-14:
            break
        s = s_new
    return s


def largest(c):
    parent = list(range(N))

    def find(x):
        while parent[x] != x:
            parent[x] = parent[parent[x]]
            x = parent[x]
        return x
    for _ in range(int(round(c * N / 2))):
        a, b = rng.randrange(N), rng.randrange(N)
        ra, rb = find(a), find(b)
        if ra != rb:
            parent[ra] = rb
    count = [0] * N
    for x in range(N):
        count[find(x)] += 1
    return max(count) / N


print("{:>6s} {:>10s} {:>12s} {:>16s}".format(
    "c", "S exact", "S simulated", "P(two entities"))
print("{:>6s} {:>10s} {:>12s} {:>16s}".format(
    "", "", "N = {:,}".format(N), "share a fate)"))
for c in (0.5, 0.8, 1.0, 1.2, 1.5, 2.0, 3.0, 4.0):
    sim = math.fsum(largest(c) for _ in range(GRAPHS)) / GRAPHS
    s = s_exact(c)
    print("{:6.1f} {:10.4f} {:12.4f} {:16.4f}".format(c, s, sim, s * s))

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 3: The Percolation Threshold: Guarantee Density, the Giant Component and the Failure of Ring-Fencing. 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