What does Five-Adversary Business Wargaming conclude, in numbers, about “The Arbitrage Speculator: a Red Team That Reads Only Our Own Rule Book, a Breach List and the Order of Repairs”?
Answer: Chapter 3 lets the arbitrage agent read only our own rule book; closing every loophole lowers joint ruin to 0.0670.
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.0670
| open | ruin(arb only) | ruin(all five) | 95% interval | mdd95 | cash |
| 3 | 0.0000 | 0.2165 | [0.1990, 0.2351] | 9,699 | 3,358 |
| 2 | 0.0000 | 0.1425 | [0.1279, 0.1585] | 9,772 | 4,227 |
| 1 | 0.0000 | 0.1075 | [0.0947, 0.1218] | 9,852 | 4,726 |
| 0 | 0.0000 | 0.0670 | [0.0569, 0.0788] | 9,611 | 5,414 |
| ruin cut from 3 to 0 open loopholes: 0.2165 -> 0.0670 (ratio 0.309) |
Show the full program
# Chapter 3. p32: closing loopholes, seen through the whole sandbox
# The p13 engine, unchanged. The arbitrage agent's open loopholes go
# from 3 to 0 (each open loophole draws Poisson(0.4) uses a round at
# 80 points each), with the other four adversaries on and off.
# Ruin is cash below zero within 52 rounds; 2,000 seeded paths.
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)
ONLY = {a: a == "arbitrage" for a in AGENTS}
print("open ruin(arb only) ruin(all five) 95% interval "
"mdd95 cash")
rows = []
for k in (3, 2, 1, 0):
pl = dict(PLAN, loopholes=float(k))
a = scenario(pl, ONLY)
b = scenario(pl, ALL)
rows.append(b["ruin"])
print("{:>4} {:>14.4f} {:>14.4f} [{:.4f}, {:.4f}] {:>6,.0f} "
"{:>6,.0f}".format(k, a["ruin"], b["ruin"], b["lo"], b["hi"],
b["mdd95"], b["cash"]))
print("ruin cut from 3 to 0 open loopholes: {:.4f} -> {:.4f} "
"(ratio {:.3f})".format(rows[0], rows[-1], rows[-1] / rows[0]))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 3: The Arbitrage Speculator: a Red Team That Reads Only Our Own Rule Book, a Breach List and the Order of Repairs. 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
- Chapter 1 · The Axiom Table and the Round-Based Engine: Nineteen Conclusions, Zero-Intelligence Agents and a Sandbox That Can Go Bankrupt
- Chapter 2 · The Price-Sensitive Buyer: Reference Points, Loss Aversion and the Hangover after a Promotion
- Chapter 4 · The Imitating Competitor and the Compliance Auditor: Capacity Commitment, Entry Delay and Random Checks against a Clause List
- Chapter 5 · The Liquidity Shock: Gambler's Ruin, Refund Runs and Frozen Channels
- Chapter 6 · The Joint Attack, Coverage and Global Sensitivity: Rewriting "Exhaustive" as Three Numbers That Can Be Checked
- Chapter 7 · Eastern and Western Classics: the Temple Calculation of the Sunzi and Clausewitz's Friction
- Chapter 8 · Field Tools and Checker Specifications: the Sandbox Planning Ledger, Backfill Calibration and a Pre-Registered Test