12.3 从测试到决策

#!/usr/bin/env python3
# file: sim/nm_12_3_decision.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/nm_12_3_decision.py
"""卷三 12.3 从测试到决策（S 层）：假设被证伪时，是改规格还是改假设？

12.1 落了四条可证伪假设，12.2 把 24 条路径在浏览器里真跑了一遍。本节做**判定**：逐条读出
实测值，对照阈值给出「通过 / 被证伪」。被证伪的假设不能含糊过去——它逼出一个二选一的决定：
**这份规格有缺陷**（改规格），还是**这次测试的设计有缺陷**（改假设）？

判据不是拍脑袋，而是一次**样本量扫描**：把被证伪的指标在 N = 24 / 100 / 500 / 2000 / 8000
上各算一遍。若指标随 N 增大收敛到阈值之上，说明**指标本身没问题、是样本太小**——那是测试
设计缺陷，决定是改假设（提高 N 或降阈值），**规格一行不改**；若无论 N 多大都压在阈值之下，
才是规格缺陷，决定是改规格。本节实测：H4（结局分布熵）属于前者。

读 out/nm_12_1_hypothesis.json + out/nm_12_2_batch_paths.json + out/nm_12_2_w_batch.json，
产出 out/nm_12_3_decision.json。公共底座见 sim/nm_12_common.py。全部整数。
"""
from __future__ import annotations

import json
import os
import sys

import nm_12_common as cm

SEED = 20261016
SWEEP = [24, 100, 500, 2000, 8000]


def read_json(name: str) -> dict:
    with open(os.path.join(cm.ROOT, "out", name), encoding="utf-8") as fh:
        return json.load(fh)


def entropy_at(spec: dict, n: int) -> tuple[int, dict]:
    """同一 PRNG 序列在 N 条路径上的结局分布与熵（前缀一致，可逐 N 对照）。"""
    dist: dict[str, int] = {}
    for p in cm.sample_paths(spec, n, SEED):
        dist[p["ending"]] = dist.get(p["ending"], 0) + 1
    return cm.entropy_milli_bits(list(dist.values()), n), dist


def main() -> int:
    hyp, batch, wbatch, spec = (read_json("nm_12_1_hypothesis.json"), read_json("nm_12_2_batch_paths.json"),
                                read_json("nm_12_2_w_batch.json"), cm.load_spec())
    measured = {"coverage_permille": batch["coverage"]["permille"],
                "endings_reached": batch["endings_reached"],
                "browser_python_match": wbatch["match"],
                "ending_entropy_milli_bits": batch["ending_entropy_milli_bits"]}

    verdicts = []
    for h in hyp["hypotheses"]:
        v = measured[h["metric"]]
        passed = v >= h["threshold"] if h["op"] == ">=" else v <= h["threshold"]
        verdicts.append({"id": h["id"], "metric": h["metric"], "value": v, "op": h["op"],
                         "threshold": h["threshold"], "verdict": "通过" if passed else "被证伪"})

    print(f"批跑规模 N={batch['n']}  seed={batch['seed']}")
    print("假设  指标                        实测值   判据      阈值   结论")
    for v in verdicts:
        print(f"  {v['id']}  {v['metric']:<26}{v['value']:>6}  {v['op']:>2}  {v['threshold']:>6}   {v['verdict']}")

    # 样本量扫描：只对被证伪的假设做诊断
    sweep = []
    for v in [x for x in verdicts if x["verdict"] == "被证伪"]:
        if v["metric"] == "ending_entropy_milli_bits":
            print(f"== 诊断：{v['id']} 被证伪，做样本量扫描（熵是否随 N 收敛到阈值之上）")
            for n in SWEEP:
                e, dist = entropy_at(spec, n)
                sweep.append({"n": n, "entropy_milli_bits": e, "above_threshold": e >= v["threshold"],
                              "endings": {k: c for k, c in sorted(dist.items())}})
                print(f"   N={n:>5}  熵 {e:>5} 毫比特  {'>=' if e >= v['threshold'] else '< '} 阈值 "
                      f"{v['threshold']}  结局 {json.dumps({k: c for k, c in sorted(dist.items())}, ensure_ascii=False)}")

    decisions = []
    for v in verdicts:
        if v["verdict"] == "通过":
            decisions.append({"id": v["id"], "action": "保持", "diagnosis": "pass",
                              "reason": f"{v['metric']}={v['value']} 满足 {v['op']} {v['threshold']}"})
        elif (conv := [s for s in sweep if s["above_threshold"]]):
            decisions.append({"id": v["id"], "action": "改假设", "diagnosis": "test_design_defect",
                              "reason": f"{v['metric']} 在 N={conv[0]['n']} 起越过阈值"
                                        f"（{conv[0]['entropy_milli_bits']} 毫比特），是样本太小而非规格缺陷"})
        else:
            decisions.append({"id": v["id"], "action": "改规格", "diagnosis": "spec_defect",
                              "reason": f"{v['metric']} 在任何 N 下都不达阈值，属规格缺陷"})

    print("== 决策")
    for d in decisions:
        print(f"   {d['id']}  {d['action']:<4}（{d['diagnosis']}）  {d['reason']}")

    report = {"batch_n": batch["n"], "seed": batch["seed"], "measured": measured,
              "verdicts": verdicts, "sample_sweep": sweep, "decisions": decisions,
              "proxy": "所有被测指标都是结构量代理，只做相对比较；熵是分布量，样本量不足时估计偏低"}
    with open(os.path.join(cm.ROOT, "out", "nm_12_3_decision.json"), "w", encoding="utf-8") as fh:
        json.dump(report, fh, ensure_ascii=False, indent=2)
        fh.write("\n")

    n_pass = sum(1 for v in verdicts if v["verdict"] == "通过")
    print("wrote out/nm_12_3_decision.json")
    print(f"OK nm_12_3_decision：{n_pass}/{len(verdicts)} 条假设通过，"
          f"{len(verdicts) - n_pass} 条被证伪并已给出诊断与决策")
    return 0


if __name__ == "__main__":
    sys.exit(main())

批跑规模 N=24  seed=20261016
假设  指标                        实测值   判据      阈值   结论
  H1  coverage_permille            982  >=     850   通过
  H2  endings_reached                4  >=       4   通过
  H3  browser_python_match          24  >=      24   通过
  H4  ending_entropy_milli_bits   1351  >=    1500   被证伪
== 诊断：H4 被证伪，做样本量扫描（熵是否随 N 收敛到阈值之上）
   N=   24  熵  1351 毫比特  <  阈值 1500  结局 {"沉没": 5, "灯守": 1, "离港": 16, "缄默": 2}
   N=  100  熵  1567 毫比特  >= 阈值 1500  结局 {"沉没": 32, "灯守": 6, "离港": 53, "缄默": 9}
   N=  500  熵  1747 毫比特  >= 阈值 1500  结局 {"沉没": 143, "灯守": 32, "真相": 7, "离港": 250, "缄默": 68}
   N= 2000  熵  1721 毫比特  >= 阈值 1500  结局 {"沉没": 526, "灯守": 117, "真相": 21, "离港": 1032, "缄默": 304}
   N= 8000  熵  1718 毫比特  >= 阈值 1500  结局 {"沉没": 2166, "灯守": 417, "真相": 75, "离港": 4048, "缄默": 1294}
== 决策
   H1  保持  （pass）  coverage_permille=982 满足 >= 850
   H2  保持  （pass）  endings_reached=4 满足 >= 4
   H3  保持  （pass）  browser_python_match=24 满足 >= 24
   H4  改假设 （test_design_defect）  ending_entropy_milli_bits 在 N=100 起越过阈值（1567 毫比特），是样本太小而非规格缺陷
wrote out/nm_12_3_decision.json
OK nm_12_3_decision：3/4 条假设通过，1 条被证伪并已给出诊断与决策