What does Five-Adversary Business Wargaming conclude, in numbers, about “The Imitating Competitor and the Compliance Auditor: Capacity Commitment, Entry Delay and Random Checks against a Clause List”?

Answer: Chapter 4 shows that under capacity commitment the former monopolist keeps 0.4444 of its profit, and that resolving violations lowers ruin to 0.0920.

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.4444

monopolyq 17.00 price 230.00 profit 2,890.0
Cournotq 11.33 each, price 173.33, profit 1,284.4 each
Bertrandprice 60.00, profit 0.0
incumbent keeps 0.4444 of monopoly profit under Cournot
entry delayruin(all five)95% intervalt_medcash
20.2495[0.2310, 0.2689]41.03,075
40.2450[0.2267, 0.2643]42.03,174
80.2165[0.1990, 0.2351]40.03,358
130.2070[0.1898, 0.2253]40.03,620
260.1770[0.1609, 0.1943]39.04,170
never0.1635[0.1479, 0.1804]38.04,483
Show the full program
# Chapter 4. p41: the imitating competitor, capacity and entry delay
# Part 1, after Kreps and Scheinkman (1983): with linear demand
# P = a - b Q and unit cost c, a rival that first commits capacity and
# then competes on price lands on the Cournot outcome, not on the
# Bertrand price c. Part 2: the p13 engine, unchanged, with the
# imitator's entry delay varied. Parameters are illustrative.
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}

A, B, C = 400.0, 10.0, 60.0
qm = (A - C) / (2 * B)
qc = (A - C) / (3 * B)
pm, pc = A - B * qm, A - B * 2 * qc
print("monopoly   q {:.2f} price {:.2f} profit {:,.1f}".format(
    qm, pm, (pm - C) * qm))
print("Cournot    q {:.2f} each, price {:.2f}, profit {:,.1f} each".format(
    qc, pc, (pc - C) * qc))
print("Bertrand   price {:.2f}, profit 0.0".format(C))
print("incumbent keeps {:.4f} of monopoly profit under Cournot".format(
    (pc - C) * qc / ((pm - C) * qm)))
ALL = dict.fromkeys(AGENTS, True)
NOIMI = {a: a != "imitator" for a in AGENTS}
print("entry delay  ruin(all five)  95% interval      t_med  cash")
for d in (2, 4, 8, 13, 26):
    r = scenario(dict(PLAN, delay=float(d)), ALL)
    print("{:>11}  {:>14.4f}  [{:.4f}, {:.4f}] {:>5.1f} {:>6,.0f}".format(
        d, r["ruin"], r["lo"], r["hi"], r["t_med"], r["cash"]))
r = scenario(PLAN, NOIMI)
print("{:>11}  {:>14.4f}  [{:.4f}, {:.4f}] {:>5.1f} {:>6,.0f}".format(
    "never", r["ruin"], r["lo"], r["hi"], r["t_med"], r["cash"]))

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 4: The Imitating Competitor and the Compliance Auditor: Capacity Commitment, Entry Delay and Random Checks against a Clause List. 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