What does Five-Adversary Business Wargaming conclude, in numbers, about “The Liquidity Shock: Gambler's Ruin, Refund Runs and Frozen Channels”?

Answer: Chapter 5 covers gambler's ruin, presale runs and frozen channels; doubling opening cash lowers ruin to 0.0080.

Scope of the numbers: Marked boxes separate evidence, runnable Python calculations (22 programs), classical sources and 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.0080

frz hold ch spiral cash0ruin95% intervalmdd95t_med
0.04410.856,000 0.2165 [0.1990, 0.2351]9,69940.0
0.08410.856,000 0.2220 [0.2043, 0.2407]9,63340.0
0.081310.856,000 0.2615 [0.2427, 0.2812]9,22138.0
0.081340.856,000 0.2330 [0.2150, 0.2520]8,55236.5
0.04411.006,000 0.2390 [0.2208, 0.2582]9,73940.0
0.04410.859,000 0.0605 [0.0509, 0.0718] 10,87846.0
0.04410.85 12,000 0.0080 [0.0049, 0.0130] 11,32748.5
Show the full program
# Chapter 5. p53: channel freezes, the fire-sale spiral and reserves
# The p13 engine, unchanged. The liquidity agent freezes a channel's
# net receipts for four rounds with probability freeze per channel
# per round, triggers refund runs, and, when cash falls below a
# quarter of the opening reserve, forces a discount (spiral). Here
# freeze rate, channel count, spiral and opening cash are varied.
import math
import random
import statistics

ND = statistics.NormalDist()
AGENTS = ("buyer", "arbitrage", "auditor", "imitator", "liquidity")
PLAN = {"price": 199.0, "cost": 60.0, "fixed": 600.0, "fee": 0.12,
        "cash0": 6000.0, "arrivals": 14.0, "med": 210.0, "sig": 0.35,
        "window": 14.0, "loopholes": 3.0, "violations": 1.0,
        "delay": 8.0, "runrate": 0.02, "freeze": 0.04, "lam": 2.25,
        "disc": 0.15, "rate": 0.4, "exploit": 80.0, "audit": 0.06,
        "fine": 600.0, "spiral": 0.85, "channels": 1.0,
        "hold": 4.0, "rr0": 0.02}


def p_buy(price, ref, lam, eta, med, sig):
    if ref >= price:
        gl = eta * (ref - price)
    else:
        gl = -eta * lam * (price - ref)
    need = price - gl
    if need <= 1.0:
        return 1.0
    z = (math.log(need) - math.log(med)) / sig
    return 1.0 - ND.cdf(z)


def poisson(rng, mu):
    if mu <= 0.0:
        return 0
    lim = math.exp(-mu)
    k, p = 0, rng.random()
    while p > lim:
        k += 1
        p *= rng.random()
    return k


def run_path(rng, pl, on, horizon=52):
    """One path; returns (ruin_round or 0, max_drawdown, final_cash)."""
    cash = pl["cash0"]
    peak, mdd = cash, 0.0
    ref = pl["price"]
    cum, seen, delist = 0.0, 0, 0
    due = 0.0
    held = {}
    hist = []
    for t in range(1, horizon + 1):
        entered = on["imitator"] and seen and t >= seen + pl["delay"]
        price = pl["price"] * (0.9 if entered else 1.0)
        arr = pl["arrivals"] * (0.6 if entered else 1.0)
        if on["liquidity"] and cash < 0.25 * pl["cash0"]:
            price *= pl["spiral"]
        if on["buyer"]:
            mkt = price * 0.75 if rng.random() < pl["disc"] else price
            ref += 0.3 * (mkt - ref)
            pb = p_buy(price, ref, pl["lam"], 0.5, pl["med"], pl["sig"])
            rr = pl["rr0"] + 0.0015 * pl["window"] + \
                0.25 * max(0.0, (price - ref) / price)
        else:
            pb = p_buy(price, price, 1.0, 0.0, pl["med"], pl["sig"])
            rr = pl["rr0"] + 0.0015 * pl["window"]
        n = 0
        if delist > 0:
            delist -= 1
        else:
            n = poisson(rng, arr * pb)
        gross = n * price
        net = gross * (1.0 - pl["fee"]) - n * pl["cost"]
        refund_now = due
        due = poisson(rng, rr * n) * price
        inflow = net
        if on["liquidity"]:
            ch = int(pl["channels"])
            parts = [inflow / ch for _ in range(ch)
                     if rng.random() < pl["freeze"]]
            stuck = math.fsum(parts)
            back = t + int(pl["hold"])
            held[back] = held.get(back, 0.0) + stuck
            inflow -= stuck
        inflow += held.pop(t, 0.0)
        loss = 0.0
        if on["arbitrage"]:
            loss += pl["exploit"] * poisson(rng, pl["rate"] * pl["loopholes"])
        if on["auditor"] and rng.random() < pl["audit"]:
            found = 0
            for _ in range(int(pl["violations"])):
                if rng.random() < 0.7:
                    found += 1
            loss += pl["fine"] * found
            if found:
                delist = 1
        hist.append(gross)
        if on["liquidity"] and rng.random() < pl["runrate"]:
            phi = rng.uniform(0.10, 0.30)
            loss += phi * math.fsum(hist[-8:])
        flow = math.fsum([inflow, -pl["fixed"], -refund_now, -loss])
        cash += flow
        cum += flow
        if on["imitator"] and not seen and cum > 3000.0:
            seen = t
        peak = max(peak, cash)
        mdd = max(mdd, peak - cash)
        if cash < 0.0:
            return t, mdd, cash
    return 0, mdd, cash


def wilson(k, n, z=1.959964):
    p = k / n
    d = 1.0 + z * z / n
    c = (p + z * z / (2 * n)) / d
    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d
    return max(0.0, c - h), min(1.0, c + h)


def scenario(pl, on, n=2000):
    rng = random.Random(40613)
    res = [run_path(rng, pl, on) for _ in range(n)]
    ruins = sorted(r[0] for r in res if r[0])
    mdds = sorted(r[1] for r in res)
    fin = [r[2] for r in res]
    lo, hi = wilson(len(ruins), n)
    return {"ruin": len(ruins) / n, "lo": lo, "hi": hi,
            "t_med": float(statistics.median(ruins)) if ruins else 0.0,
            "mdd50": mdds[n // 2], "mdd95": mdds[int(0.95 * n)],
            "cash": math.fsum(fin) / n}

ALL = dict.fromkeys(AGENTS, True)
print("frz hold ch spiral cash0   ruin    95% interval      mdd95  t_med")
CASES = [(0.04, 4, 1, 0.85, 6000.0), (0.08, 4, 1, 0.85, 6000.0),
         (0.08, 13, 1, 0.85, 6000.0), (0.08, 13, 4, 0.85, 6000.0),
         (0.04, 4, 1, 1.00, 6000.0), (0.04, 4, 1, 0.85, 9000.0),
         (0.04, 4, 1, 0.85, 12000.0)]
for fr, hd, ch, sp, c0 in CASES:
    pl = dict(PLAN, freeze=fr, hold=float(hd), channels=float(ch),
              spiral=sp, cash0=c0)
    r = scenario(pl, ALL)
    print("{:.2f} {:>3} {:>3} {:>5.2f} {:>6,.0f} {:.4f} [{:.4f}, {:.4f}] "
          "{:>6,.0f} {:>5.1f}".format(fr, hd, ch, sp, c0, r["ruin"],
                                     r["lo"], r["hi"], r["mdd95"],
                                     r["t_med"]))

Single source and citation

Fan, Y. (2026). Axiom-Driven Business Wargaming, Multi-Agent Adversarial Stress-Testing and Pre-Launch Zero-Tuition Sandboxes (Version 1.0.0), Chapter 5: The Liquidity Shock: Gambler's Ruin, Refund Runs and Frozen Channels. 5D Library. DOI pending

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

BibTeX
@book{fan2026406,
  author    = {Fan, Yafu},
  title     = {Axiom-Driven Business Wargaming, Multi-Agent Adversarial Stress-Testing and Pre-Launch Zero-Tuition Sandboxes},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book