关于「模仿竞争者与合规审查官:产能承诺、进入延迟与条款清单的随机抽查」,《五方敌对代理兵棋沙盘》给出的定量结论是什么?

结论:第四章说明产能先定时原独家经营者保留 0.4444 的利润,整改违规使破产概率降到 0.0920。

数据口径:本书用一台回合制沙盘证伪它:五类敌对代理,即价格敏感买家、套利投机者、合规审查官、模仿竞争者与流动性冲击,单独出手时最坏只让示意方案的破产概率升到 0.0010;五类同时出手,破产概率是 0.2165,九成五区间从 0.1990 到 0.2351。 书中参数为示意,单位是无币种的点;全部计算由书中程序生成;本书是非个人化经营分析,不构成投资、法律或财务建议,也不构成任何收益承诺;套利代理只用于找出并堵上自家规则漏洞。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库与结论吻合的打印值: 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
查看完整验算程序
# 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"]))

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《四百卷公理驱动商业兵棋推演、五方敌对代理压力测试与零学费试错沙盘母典》第 4 章「模仿竞争者与合规审查官:产能承诺、进入延迟与条款清单的随机抽查」(版本 1.0.0). 5D Library. DOI 待发布

DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 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}
}

本书其他章节结论