What does Liability Percolation and Guarantee Tail Ruin conclude, in numbers, about “The Ledger of the Firewall: Clearing Vectors and One Cross-Guarantee”?

Answer: Chapter 1 uses the Eisenberg–Noe clearing vector to show that once a parent guarantees one subsidiary, the same shock topples four entities instead of one and the loss landing outside the shocked entity rises from 12.50 to 41.10; in Merton's structural model the guarantee multiplies the parent's chance of default by between 1.47 and 3.57.

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: 12.50, 41.10

payment ratio per entity (1.000 = pays in full)
case H A B C D fail
normal year1.000 1.000 1.000 1.000 1.000 0
A shocked, no guarantee1.000 0.375 1.000 1.000 1.000 1
A shocked, H guarantees A0.763 0.375 0.953 0.927 1.000 4
equity = owner's equity summed over the five entities; lender
loss = what outside lenders lose; off-A = equity and lender losses
at H, B, C, D, i.e. outside the entity that was shocked
normal year equity42.00 lender loss 0.00 off-A 0.00
A shocked, no guarantee equity14.50 lender loss 37.50 off-A 12.50
A shocked, H guarantees A equity0.44 lender loss 23.44 off-A 41.10
Show the full program
# Chapter 1. p11: Eisenberg-Noe clearing in a five-entity group, with
# and without one guarantee from the holding company H to the bank of
# subsidiary A. Payments solve p = min(pbar, e + Pi^T p) (Eisenberg and
# Noe 2001); the guarantee adds to H's debts the shortfall A leaves its
# bank, settled jointly by fixed-point iteration from p = pbar.
# Balance sheets are illustrative units, not data from any real group.
import math

NAMES = ["H", "A", "B", "C", "D"]
# intra-group debts L[i][j]: i owes j (B, C, D lent cash upward to H)
L = [[0, 0, 30, 25, 15],
     [20, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0],
     [0, 0, 0, 0, 0]]
BANK = [40, 60, 45, 40, 25]          # debts to outside creditors
E0 = [105, 95, 20, 18, 14]           # outside assets, normal year
SHOCK_A = 30                         # A's outside assets after a shock


def clear(e, guarantee):
    n = len(e)
    out = [math.fsum(L[i]) for i in range(n)]
    p = [out[i] + BANK[i] for i in range(n)]
    g = 0.0
    for _ in range(500):
        pbar = [out[i] + BANK[i] for i in range(n)]
        pbar[0] += g
        new = []
        for i in range(n):
            inflow = math.fsum(L[j][i] / (out[j] + BANK[j] +
                               (g if j == 0 else 0.0)) * p[j]
                               for j in range(n) if L[j][i] > 0)
            new.append(min(pbar[i], max(0.0, e[i] + inflow)))
        ratio_a = new[1] / (out[1] + BANK[1])
        g_new = (1 - ratio_a) * BANK[1] if guarantee else 0.0
        if max(abs(a - b) for a, b in zip(new, p)) < 1e-12 and \
                abs(g_new - g) < 1e-12:
            break
        p, g = new, g_new
    pbar = [out[i] + BANK[i] + (g if i == 0 else 0.0) for i in range(n)]
    inflow = [math.fsum(L[j][i] / pbar[j] * p[j] for j in range(n)
                        if L[j][i] > 0) for i in range(n)]
    equity = [max(0.0, e[i] + inflow[i] - pbar[i]) for i in range(n)]
    ratio = [p[i] / pbar[i] for i in range(n)]
    # creditor losses; A's lender is repaid ratio_A by A plus the call
    lost = [BANK[i] * (1 - ratio[i]) for i in range(n)]
    lost[1] -= g * ratio[0]
    return ratio, equity, lost, g


cases = [("normal year", E0, False),
         ("A shocked, no guarantee", E0[:1] + [SHOCK_A] + E0[2:], False),
         ("A shocked, H guarantees A", E0[:1] + [SHOCK_A] + E0[2:], True)]
print("payment ratio per entity (1.000 = pays in full)")
print("{:27s}".format("case") + "".join("{:>7s}".format(x) for x in NAMES)
      + "  fail")
res = []
for label, e, gflag in cases:
    ratio, equity, lost, g = clear(e, gflag)
    fails = len([r for r in ratio if r < 1 - 1e-9])
    res.append((label, equity, lost, g, fails))
    print("{:27s}".format(label) +
          "".join("{:7.3f}".format(r) for r in ratio) + "{:6d}".format(fails))
print("equity = owner's equity summed over the five entities; lender")
print("loss = what outside lenders lose; off-A = equity and lender losses")
print("at H, B, C, D, i.e. outside the entity that was shocked")
base = res[0][1]
for label, equity, lost, g, fails in res:
    off = math.fsum(base[i] - equity[i] + lost[i] for i in (0, 2, 3, 4))
    print("  {:26s} equity {:6.2f} lender loss {:6.2f} off-A {:6.2f}"
          .format(label, math.fsum(equity), math.fsum(lost), off))

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 1: The Ledger of the Firewall: Clearing Vectors and One Cross-Guarantee. 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