6.3 稳健性与告警

#!/usr/bin/env python3
# file: sim/gd_mech_06_robustness.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/gd_mech_06_robustness.py
"""卷一 6.3 稳健性与告警（S 层）：临界点附近的胜率分类成稳健 / 脆弱区间。

判据（整数千分比）：稳健步 = |Δ胜率| ≤ 100‰；脆弱步 = |Δ胜率| ≥ 200‰；中间为过渡步；
稳健区间 = 连续稳健步的极大区间；脆弱区间 = 含脆弱步的极大区间。产出
out/mech06_warnings.json（hardFail=false）与 out/mech06_robustness.svg。
**永远 exit 0**：B 档软告警不硬失败。自带粗扫 + 二分，故可独立运行。
"""
import copy
import json
import os
import sys
import time
import xml.etree.ElementTree as ET

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
OUT = os.path.join(ROOT, "out")
CONFIG = os.path.join(ROOT, "config/gd_mech_06_perturb.json")
sys.path.insert(0, HERE)
import ashlib  # noqa: E402


def scan(spec, cfg):
    """粗扫 + 二分定位临界点 → 并集网格。返回 (critical, table, cache)。"""
    param, seeds = cfg["param"], cfg["seeds"]
    lo, hi, step = cfg["coarse"]["from"], cfg["coarse"]["to"], cfg["coarse"]["step"]
    cross, radius = cfg["bisect"]["crossPermille"], cfg["fine"]["radius"]
    cache = {}

    def cell(v):
        if v not in cache:
            wins = php = 0
            for sd in seeds:
                s = copy.deepcopy(spec)
                s["seed"] = sd
                s["params"][param] = v
                snap = ashlib.run_spec(s)
                wins += 1 if snap["won"] else 0
                php += snap["playerHp"]
            cache[v] = (1000 * wins // len(seeds), php // len(seeds))
        return cache[v]

    coarse = [(v, cell(v)[0]) for v in range(lo, hi + 1, step)]
    a, b = next((a, b) for a, b in zip(coarse, coarse[1:]) if a[1] >= cross > b[1])
    lo_b, hi_b = a[0], b[0]
    while hi_b - lo_b > 1:
        mid = (lo_b + hi_b) // 2
        lo_b, hi_b = (mid, hi_b) if cell(mid)[0] >= cross else (lo_b, mid)
    grid = sorted(set(range(lo, hi + 1, step))
                  | set(range(max(lo, hi_b - radius), min(hi, hi_b + radius) + 1)))
    return hi_b, [{"value": v, "winPermille": cell(v)[0], "avgPlayerHp": cell(v)[1]}
                  for v in grid], cache


def classify(table, stable_step, fragile_step):
    """相邻网格点 → 步差表：稳健 / 过渡 / 脆弱。"""
    out = []
    for a, b in zip(table, table[1:]):
        d = b["winPermille"] - a["winPermille"]
        kind = "fragile" if abs(d) >= fragile_step else ("stable" if abs(d) <= stable_step else "mixed")
        out.append({"from": a["value"], "to": b["value"], "deltaPermille": d, "kind": kind})
    return out


def runs(steps, kinds):
    """连续同类步的极大区间 [(from, to), ...]。"""
    out, cur = [], None
    for s in steps:
        if s["kind"] in kinds:
            cur = (s["from"], s["to"]) if cur is None else (cur[0], s["to"])
        elif cur:
            out.append(cur)
            cur = None
    if cur:
        out.append(cur)
    return out


def draw(steps, fragile_step, param, path):
    """逐点步差 |Δ胜率| 条形图：脆弱步涂红。"""
    root = ashlib.svg_begin(700, 300)
    ashlib.svg_text(root, 62, 24, f"{param} 逐点步差 |Δ胜率|（红 = 脆弱步 ≥ {fragile_step}‰）", 14)
    for i, s in enumerate(steps):
        h = min(abs(s["deltaPermille"]), 1000) * 200 // 1000
        ET.SubElement(root, "rect", {"x": str(62 + i * 28), "y": str(240 - h), "width": "24",
                                     "height": str(max(h, 1)),
                                     "fill": "#ef4444" if s["kind"] == "fragile" else "#38bdf8"})
    return ashlib.svg_save(root, path)


def jarr(key, rows):
    body = ",\n".join("    " + json.dumps(r, ensure_ascii=False, sort_keys=True) for r in rows)
    return f'  "{key}": [\n{body}\n  ]'


def main():
    t0 = time.perf_counter_ns()
    with open(CONFIG, encoding="utf-8") as f:
        cfg = json.load(f)
    param, seeds = cfg["param"], cfg["seeds"]
    cross, radius = cfg["bisect"]["crossPermille"], cfg["fine"]["radius"]
    stable_step, fragile_step = cfg["classify"]["stableStepPermille"], cfg["classify"]["fragileStepPermille"]
    critical, table, cache = scan(ashlib.load_spec(), cfg)
    steps = classify(table, stable_step, fragile_step)
    span = lambda f, t: [s for s in steps if f <= s["from"] and s["to"] <= t]  # noqa: E731
    robust = [{"from": f, "to": t, "maxAbsStepPermille": max(abs(s["deltaPermille"]) for s in span(f, t))}
              for f, t in runs(steps, {"stable"})]
    fragile = [{"from": f, "to": t, "deltaPermille": min(s["deltaPermille"] for s in span(f, t))}
               for f, t in runs(steps, {"fragile"})]
    fine = [r for r in table if abs(r["value"] - critical) <= radius]
    h_high = max(r["value"] for r in fine if r["winPermille"] >= cfg["bisect"]["bandHighPermille"])
    h_low = min(r["value"] for r in fine if r["winPermille"] <= cfg["bisect"]["bandLowPermille"])
    width = h_low - h_high
    drop = min((table[i + 1]["avgPlayerHp"] - table[i]["avgPlayerHp"], table[i]["value"], table[i + 1]["value"])
               for i in range(len(table) - 1))
    warnings = []
    for f in fragile:
        warnings.append({"code": "FRAGILE_STEP", "severity": "soft", "from": f["from"], "to": f["to"],
                         "deltaPermille": f["deltaPermille"],
                         "message": f"{param} 在 {f['from']}–{f['to']} 区间内胜率变化 {f['deltaPermille']}‰，"
                                    f"此处任何 ±1 的改动都会显著改变难度"})
    warnings.append({"code": "CRITICAL_POINT", "severity": "soft", "value": critical,
                     "message": f"{param}={critical} 是胜率跌破 {cross}‰ 的临界点，"
                                f"把初始值钉在临界点 ±1 内等于把难度钉在刀尖上"})
    warnings.append({"code": "NARROW_TRANSITION", "severity": "soft", "width": width,
                     "message": f"临界宽度只有 {width}：{param} 从 {h_high} 到 {h_low} 就走完 900‰→100‰，"
                                f"过渡带太窄，难度没有可调的中间档"})
    warnings.append({"code": "AVG_HP_DROP", "severity": "soft", "from": drop[1], "to": drop[2],
                     "deltaPlayerHp": drop[0],
                     "message": f"平均剩余 HP 在 {drop[1]}–{drop[2]} 上掉 {drop[0]}，跨过临界点后玩家受伤明显变多"})
    text = "{\n" + ",\n".join([
        '  "id": "gd_mech_06_warnings"',
        '  "tier": "B"',
        '  "hardFail": false',
        '  "note": "B 档软告警：只提示风险区间，不使任何构建失败"',
        f'  "param": "{param}"',
        f'  "seeds": {len(seeds)}',
        f'  "criticalPoint": {critical}',
        f'  "criticalWidth": {width}',
        f'  "classify": {{"stableStepPermille": {stable_step}, "fragileStepPermille": {fragile_step}}}',
        jarr("robustIntervals", robust),
        jarr("fragileIntervals", fragile),
        jarr("warnings", warnings),
    ]) + "\n}\n"
    os.makedirs(OUT, exist_ok=True)
    with open(os.path.join(OUT, "mech06_warnings.json"), "w", encoding="utf-8") as f:
        f.write(text)
    size = draw(steps, fragile_step, param, os.path.join(OUT, "mech06_robustness.svg"))
    for r in table:
        print(f"{param}={r['value']:>3}  winRate={r['winPermille']:>4}‰  avgPlayerHp={r['avgPlayerHp']:>2}")
    for r in robust:
        print(f"ROBUST  {param} [{r['from']}, {r['to']}]  maxAbsStep={r['maxAbsStepPermille']}‰")
    for f in fragile:
        print(f"FRAGILE {param} [{f['from']}, {f['to']}]  delta={f['deltaPermille']}‰")
    for w in warnings:
        print(f"SOFT WARN {w['code']}: {w['message']}")
    print(f"criticalPoint={critical}  criticalWidth={width}  warnings={len(warnings)}  hardFail=false")
    print(f"cells={len(cache)}  runs={len(cache) * len(seeds)}  "
          f"elapsed={(time.perf_counter_ns() - t0) // 1000000} ms  svg={size} bytes")
    print("wrote out/mech06_warnings.json out/mech06_robustness.svg")
    ET.parse(os.path.join(OUT, "mech06_robustness.svg"))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

ROBUST  enemyHp [20, 78]  maxAbsStep=63‰
ROBUST  enemyHp [79, 80]  maxAbsStep=0‰
FRAGILE enemyHp [78, 79]  delta=-875‰
SOFT WARN FRAGILE_STEP: enemyHp 在 78–79 区间内胜率变化 -875‰，此处任何 ±1 的改动都会显著改变难度
SOFT WARN CRITICAL_POINT: enemyHp=79 是胜率跌破 500‰ 的临界点，把初始值钉在临界点 ±1 内等于把难度钉在刀尖上
SOFT WARN NARROW_TRANSITION: 临界宽度只有 4：enemyHp 从 75 到 79 就走完 900‰→100‰，过渡带太窄，难度没有可调的中间档
SOFT WARN AVG_HP_DROP: 平均剩余 HP 在 78–79 上掉 -4，跨过临界点后玩家受伤明显变多
criticalPoint=79  criticalWidth=4  warnings=4  hardFail=false
cells=22  runs=352  elapsed=16 ms  svg=1720 bytes
wrote out/mech06_warnings.json out/mech06_robustness.svg

  "warnings": [
    {"code": "FRAGILE_STEP", "deltaPermille": -875, "from": 78, "message": "enemyHp 在 78–79 区间内胜率变化 -875‰，此处任何 ±1 的改动都会显著改变难度", "severity": "soft", "to": 79},
    {"code": "CRITICAL_POINT", "message": "enemyHp=79 是胜率跌破 500‰ 的临界点，把初始值钉在临界点 ±1 内等于把难度钉在刀尖上", "severity": "soft", "value": 79},
    {"code": "NARROW_TRANSITION", "message": "临界宽度只有 4：enemyHp 从 75 到 79 就走完 900‰→100‰，过渡带太窄，难度没有可调的中间档", "severity": "soft", "width": 4},
    {"code": "AVG_HP_DROP", "deltaPlayerHp": -4, "from": 78, "message": "平均剩余 HP 在 78–79 上掉 -4，跨过临界点后玩家受伤明显变多", "severity": "soft", "to": 79}
  ]
}

#!/usr/bin/env python3
# file: sim/gd_mech_06_robustness_bench.py
# tier: B
# verify: /opt/homebrew/bin/python3 sim/gd_mech_06_robustness_bench.py
"""卷一 6.3 稳健性基准（B 层）：把**分类阈值本身**当成可扰动参数。

告警清单依赖两个人的判断（stableStepPermille=100 / fragileStepPermille=200），
所以真正该问的是——阈值同时缩放 50% / 75% / 150% / 200% 时，脆弱区间会不会翻盘？
复用 sim/gd_mech_06_robustness.py 的 scan / classify / runs，不重写扫描逻辑。
**永远 exit 0**：B 档软告警不硬失败——翻盘只打印 SOFT，不抛异常、不返回非零。
"""
import json
import os
import sys
import time

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import ashlib  # noqa: E402
import gd_mech_06_robustness as rb  # noqa: E402


def main():
    t0 = time.perf_counter_ns()
    with open(rb.CONFIG, encoding="utf-8") as f:
        cfg = json.load(f)
    critical, table, _ = rb.scan(ashlib.load_spec(), cfg)
    s0, f0 = cfg["classify"]["stableStepPermille"], cfg["classify"]["fragileStepPermille"]
    rows = []
    for pct in (50, 75, 100, 150, 200):
        steps = rb.classify(table, s0 * pct // 100, f0 * pct // 100)
        rows.append({"scale": pct, "stable": s0 * pct // 100, "fragileLine": f0 * pct // 100,
                     "robustSegments": len(rb.runs(steps, {"stable"})),
                     "fragile": [list(r) for r in rb.runs(steps, {"fragile"})]})
    base = next(r["fragile"] for r in rows if r["scale"] == 100)
    flipped = [r["scale"] for r in rows if r["fragile"] != base]
    for r in rows:
        print(f"scale={r['scale']:>3}%  stable={r['stable']:>3}‰ fragile={r['fragileLine']:>3}‰  "
              f"robustSegments={r['robustSegments']}  fragileIntervals={r['fragile']}  "
              f"{'SAME' if r['fragile'] == base else 'FLIPPED'}")
    seg = sorted({r["robustSegments"] for r in rows})
    print(f"criticalPoint={critical}  fragileIntervalStable={not flipped}  flippedScales={flipped}")
    if flipped:
        print(f"SOFT WARN THRESHOLD_FLIP: 阈值缩放到 {flipped} 时脆弱区间改变，告警清单需人工复核")
    else:
        print(f"SOFT OK: 脆弱区间在 50%–200% 阈值扰动下不变；"
              f"稳健区间段数在 {min(seg)}–{max(seg)} 之间浮动（阈值越低切得越碎）")
    print(f"SOFT: hardFail=false（B 档软告警不硬失败）  elapsed={(time.perf_counter_ns() - t0) // 1000000} ms")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

scale= 50%  stable= 50‰ fragile=100‰  robustSegments=4  fragileIntervals=[[78, 79]]  SAME
scale= 75%  stable= 75‰ fragile=150‰  robustSegments=2  fragileIntervals=[[78, 79]]  SAME
scale=100%  stable=100‰ fragile=200‰  robustSegments=2  fragileIntervals=[[78, 79]]  SAME
scale=150%  stable=150‰ fragile=300‰  robustSegments=2  fragileIntervals=[[78, 79]]  SAME
scale=200%  stable=200‰ fragile=400‰  robustSegments=2  fragileIntervals=[[78, 79]]  SAME
criticalPoint=79  fragileIntervalStable=True  flippedScales=[]
SOFT OK: 脆弱区间在 50%–200% 阈值扰动下不变；稳健区间段数在 2–4 之间浮动（阈值越低切得越碎）
SOFT: hardFail=false（B 档软告警不硬失败）  elapsed=8 ms