What does Liability Percolation and Guarantee Tail Ruin conclude, in numbers, about “Personal Guarantees: Ruin Amplification under Heavy-Tailed Losses and the Single Big Jump”?

Answer: Chapter 4 shows that a personal guarantee multiplies the owner's ten-year chance of ruin by 7.0 under light tails and 48.6 under heavy tails, ruin being driven by one large year.

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: 48.6, 7.0

P(owner ruined within 10 years) by guarantee cap G
loss lawG = 0G = 1G = 4unlimitedratio
exponential0.00520.01600.03490.03627.0
lognormal0.00970.03390.11240.145815.0
Pareto a=2.50.00040.00180.01520.022349.5
Pareto a=1.50.00200.01010.06160.098648.6
Show the full program
# Chapter 4. p41: how a personal guarantee turns a business's loss tail
# into the owner's ruin. Each year the company (capital E) takes a loss L
# with mean 1. If L > E the company fails: the owner refounds it (pays E)
# and pays min(L - E, G) under a personal guarantee capped at G. The
# owner starts with W0 outside the company and earns Y a year; ruin =
# personal wealth below zero within T years. Four loss laws share the
# same mean. Seeded Monte Carlo, common random numbers across G.
# All parameters are illustrative.
import math
import random

E, W0, Y, T, PATHS = 3.0, 4.0, 0.8, 10, 100000
CAPS = (0.0, 1.0, 4.0, math.inf)
rng = random.Random(20261112)
S_LN = 1.2


def draw(kind):
    u = 1.0 - rng.random()
    if kind == "exponential":
        return -math.log(u)
    if kind == "lognormal":
        return math.exp(rng.gauss(-S_LN * S_LN / 2, S_LN))
    if kind == "Pareto a=2.5":
        return 0.6 * u ** (-1 / 2.5)
    return (1 / 3) * u ** (-1 / 1.5)          # Pareto a=1.5, mean 1


def ruin_row(kind):
    hits = [0] * len(CAPS)
    for _ in range(PATHS):
        losses = [draw(kind) for _ in range(T)]
        for c, cap in enumerate(CAPS):
            w = W0
            for x in losses:
                w += Y
                if x > E:
                    w -= E + min(x - E, cap)
                if w < 0:
                    hits[c] += 1
                    break
    return [h / PATHS for h in hits]


print("P(owner ruined within {} years) by guarantee cap G".format(T))
print("{:14s}{:>10s}{:>10s}{:>10s}{:>11s}{:>9s}".format(
    "loss law", "G = 0", "G = 1", "G = 4", "unlimited", "ratio"))
for kind in ("exponential", "lognormal", "Pareto a=2.5", "Pareto a=1.5"):
    r = ruin_row(kind)
    print("{:14s}{:10.4f}{:10.4f}{:10.4f}{:11.4f}{:9.1f}".format(
        kind, *r, r[3] / r[0]))

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 4: Personal Guarantees: Ruin Amplification under Heavy-Tailed Losses and the Single Big Jump. 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