What does Liability Percolation and Guarantee Tail Ruin conclude, in numbers, about “Partitioning into Risk Buckets: Number of Buckets, Tail Index and Piercing the Veil”?

Answer: Chapter 5 shows that the effect of risk buckets depends on the tail: eight buckets raise the chance of ruin from 0.0102 to 0.0355 under light tails and cut it from 0.0489 to 0.0027 under heavy tails, while a chain of seven guarantees between buckets raises it to 0.0943.

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.0027, 0.0102, 0.0355, 0.0489

P(ruin) and mean buckets failed per year, by number of buckets k
loss lawk = 1k = 2k = 4k = 8
exponential0.01020.0100.08230.0840.05620.3670.03551.081
lognormal0.06050.0610.16970.1780.06740.4420.01600.959
Pareto 1.50.04890.0490.11140.1150.02330.2560.00270.545
Show the full program
# Chapter 5. p51: splitting eight business lines into k risk buckets
# (separate entities). Each line loses X a year, mean 0.5, independent.
# Equity C = 8 and going-concern value F = 8 are split evenly over the
# buckets. A bucket whose loss exceeds its equity fails: the owner loses
# its equity and its going-concern value; otherwise the owner bears the
# loss. Ruin = the owner loses more than half of C + F. No guarantees and
# no piercing here (see p52). Seeded Monte Carlo; illustrative inputs.
import math
import random

LINES, C, F, PATHS = 8, 8.0, 8.0, 100000
KS = (1, 2, 4, 8)
rng = random.Random(20261112)


def draw(kind):
    u = 1.0 - rng.random()
    if kind == "exponential":
        return -0.5 * math.log(u)
    if kind == "lognormal":
        return 0.5 * math.exp(rng.gauss(-0.72, 1.2))
    return (0.5 / 3) * u ** (-1 / 1.5)        # Pareto, tail index 1.5


print("P(ruin) and mean buckets failed per year, by number of buckets k")
print("{:12s}".format("loss law") +
      "".join("{:>15s}".format("k = {}".format(k)) for k in KS))
for kind in ("exponential", "lognormal", "Pareto 1.5"):
    ruin = [0] * len(KS)
    fails = [0] * len(KS)
    for _ in range(PATHS):
        xs = [draw(kind) for _ in range(LINES)]
        for i, k in enumerate(KS):
            per = LINES // k
            cap, fr = C / k, F / k
            lost = []
            for b in range(k):
                lb = math.fsum(xs[b * per:(b + 1) * per])
                if lb > cap:
                    lost.append(cap + fr)
                    fails[i] += 1
                else:
                    lost.append(lb)
            if math.fsum(lost) > (C + F) / 2:
                ruin[i] += 1
    print("{:12s}".format(kind) + "".join(
        "{:8.4f} {:6.3f}".format(r / PATHS, f / PATHS)
        for r, f in zip(ruin, fails)))

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 5: Partitioning into Risk Buckets: Number of Buckets, Tail Index and Piercing the Veil. 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