Blame for server/phase2/src/normalize_results.py

"""Validate exact certificate fields before generating display-only summaries."""
import argparse
from fractions import Fraction
import json
from pathlib import Path


def number(field):
    return float(Fraction(field["rational"]))


def main(folder):
    search=json.loads((folder/"search_results.json").read_text())
    raw=json.loads((folder/"witnesses.json").read_text())
    verified=json.loads((folder/"certificates.json").read_text())
    assert search["status"]=="complete" and not search["errors"]
    assert verified["self_test"]["passed"]
    original_ids=[w["id"] for w in raw["witnesses"]]
    certified_ids=[w["id"] for w in verified["witnesses"]]
    assert original_ids and len(original_ids)==len(set(original_ids))
    assert len(certified_ids)==len(set(certified_ids))
    assert set(certified_ids)==set(original_ids)
    selected_ids=search["selected_ids"]
    assert len(selected_ids)==len(set(selected_ids))
    assert set(selected_ids)==set(original_ids)
    expected_rounds=set(search["config"]["evaluation_K"])
    assert len(expected_rounds)==len(search["config"]["evaluation_K"])
    expected_tau=Fraction(search["config"]["tau"])
    expected_budgets={Fraction(b) for b in search["config"]["budgets"]}
    witnesses={w["id"]:w for w in raw["witnesses"]}
    rows=[]
    for w in verified["witnesses"]:
        original=witnesses[w["id"]]
        model=w["model"]
        assert model["kl_budget_certified"] is True
        assert model["head_bound_certified"] is True
        assert w["n"]==original["n"] and w["n"] in search["config"]["n_values"]
        assert Fraction(w["tau"])==Fraction(original["tau"])==expected_tau
        assert list(map(Fraction,w["weights"]))==list(map(Fraction,original["weights"]))
        assert list(map(Fraction,w["probabilities"]))==list(map(Fraction,original["probabilities"]))
        budget=Fraction(original["budget"])
        head_bound=Fraction(original["head_bound"])
        assert budget in expected_budgets
        assert Fraction(model["kl_budget"]["rational"])==budget
        assert Fraction(model["head_bound"]["rational"])==head_bound
        assert head_bound==Fraction(search["config"]["head_bound"])
        kl_lower=Fraction(model["kl_lower"]["rational"])
        kl_upper=Fraction(model["kl_upper"]["rational"])
        assert 0<=kl_lower<=kl_upper<=budget
        assert Fraction(model["kl_enclosure_width"]["rational"])==kl_upper-kl_lower
        assert 0<=Fraction(model["all_context_head_error_exact"]["rational"])<=head_bound
        original_rounds=[c["K"] for c in original["cases"]]
        certified_rounds=[c["K"] for c in w["cases"]]
        assert len(original_rounds)==len(set(original_rounds))
        assert len(certified_rounds)==len(set(certified_rounds))
        assert set(original_rounds)==set(certified_rounds)==expected_rounds
        cases=[]
        for c in w["cases"]:
            L=Fraction(c["tv_lower_certified"]["rational"])
            U=Fraction(c["tv_upper_certified"]["rational"])
            model_tv=Fraction(model["model_tv_exact"]["rational"])
            G=Fraction(c["execution_gap_lower_certified"]["rational"])
            assert 0<=model_tv<=1
            assert 0<=L<=U<=1
            assert G==L-model_tv
            assert Fraction(c["optimality_gap_upper_certified"]["rational"])==U-L
            cases.append({"K":c["K"],"L":float(L),"U":float(U),
                "gap_lower":float(G),"width":float(U-L),
                "bellman_actions":c["bellman_action_count"],
                "fallback_states":c["visited_fallback_states"]})
        rows.append({"id":w["id"],"n":w["n"],"budget":float(budget),
            # Compatibility alias: this is an enclosure endpoint, not exact KL.
            "actual_kl":float(kl_upper),"actual_kl_kind":"certified_upper_bound",
            "kl_lower":float(kl_lower),"kl_upper":float(kl_upper),
            "kl_enclosure_width":float(kl_upper-kl_lower),
            "model_tv":number(model["model_tv_exact"]),
            "max_head_error":number(model["all_context_head_error_exact"]),
            "family":original["spec"]["family"],"spec":original["spec"],
            "budget_matched":original["kl_budget_matched"],"cases":cases})
    assert len(rows)==len(witnesses)
    candidates=[{"id":c["id"],"n":c["n"],"family":c["spec"]["family"],
                 "actual_kl":c["actual_joint_kl_P_to_R"],"gap":c["screening_gap"],
                 "actual_kl_kind":"floating_point_estimate",
                 "budget_matched":c["kl_budget_matched"]} for c in search["candidates"]]
    result={"rows":rows,"candidates":candidates,"all_constraints_certified":True,
        "certified_cases":sum(len(r["cases"]) for r in rows),
        "max_optimality_interval_width":max(c["width"] for r in rows for c in r["cases"]),
        "screening_candidate_count":len(candidates),
        "candidate_scope":"Floating-point screening; only selected witnesses independently certified; no outer-optimum claim",
        "scope":"Finite selected rational witnesses; independent integer/Fraction verification; not formal-kernel verification or an outer minimax optimum"}
    (folder/"plot_data.json").write_text(json.dumps(result,indent=2,allow_nan=False)+"\n")
    lines=["# 第二轮实验：有限维 all-policy 执行代价\n",
        "本轮代码、结果和图独立保存；未修改论文或投稿文件。\n",
        f"筛选 {len(candidates)} 个候选，冻结 {len(rows)} 个模型；独立认证 {result['certified_cases']} 个固定模型/轮数组合。所有入选模型的实际 KL 和全部条件 head 误差约束均通过精确算术检查。\n",
        "下表的 L、U 分别是所有合法策略的 TV 下界和一个明确合法策略的 TV 上界。G=L-TV(P,R) 是相对模型本身误差的额外执行代价下界。显示小数仅为方便阅读，完整有理数端点见 certificates.json。\n",
        "KL 列显示实际 KL 的认证区间上端点，经四舍五入展示；不将该端点当作精确 KL 值。plot_data.json 中保留 actual_kl 兼容字段，并用 actual_kl_kind=certified_upper_bound 明确其含义。\n",
        "| n | KL 预算 | 入选模型 | 认证 KL 上界 | 模型 TV | K=3 下界 L | 上界 U | 执行代价下界 G |",
        "|---:|---:|---|---:|---:|---:|---:|---:|"]
    for r in sorted(rows,key=lambda x:(x["n"],x["budget"])):
        c=next(c for c in r["cases"] if c["K"]==3)
        lines.append(f"| {r['n']} | {r['budget']:.2f} | {r['family']} | {r['actual_kl']:.8f} | {r['model_tv']:.8f} | {c['L']:.8f} | {c['U']:.8f} | {c['gap_lower']:.8f} |")
    lines += ["\n## 同一模型下改变轮数\n",
        "以下每个模型均按 K=3 的执行代价筛选，再固定参数比较 K=2,3,4；没有为不同 K 更换模型。\n",
        "| n | 预算 | K | L | U | G |",
        "|---:|---:|---:|---:|---:|---:|"]
    for r in sorted(rows,key=lambda x:(x["n"],x["budget"])):
        for c in sorted(r["cases"],key=lambda x:x["K"]):
            lines.append(f"| {r['n']} | {r['budget']:.2f} | {c['K']} | {c['L']:.8f} | {c['U']:.8f} | {c['gap_lower']:.8f} |")
    lines += ["\n## 核验与范围\n",
        f"最大的认证最优值区间宽度为 {result['max_optimality_interval_width']:.3g}。这不是蒙特卡洛置信区间，而是整数向下舍入和精确有理数计算产生的确定性包络。\n",
        "独立 verifier 使用完整合法动作集合的 Bellman 递推、精确条件分布、带余项上界的对数级数，以及恢复策略的向下舍入概率流。它不依赖浮点 LP 对偶可行性来保证下界。小维度完整逐坐标递推、随机化回归和对数区间检查已通过。\n",
        "这些是针对有限实例和论文规定接口的计算证书，不是 Lean/formal-kernel 验证，不代表不存在程序错误，也不替代渐近定理的解析证明。\n",
        "外层只搜索预先规定的有限候选，不保证找到了最难模型。较大 n 只继承 n=8 选出的 relaxed spacing，因此不能用这三个 n 点拟合 sharp 指数。\n",
        "单分量和 relaxed two-level 的权重上限为 1/2；它们满足一般交换模型类与统一 head 误差约束，但未必属于有限梯子定理的 w<=1/8 显式构造。Theorem ladder 对照保留原参数约束。\n",
        "某些候选因权重上限无法用满预算，原始记录中标为 kl_budget_matched=false；候选比较图以实际 KL 为横轴，不把这些点当成精确预算匹配。\n",
        "Sequential 原始-head 执行能生成 R，所以模型 TV 是一个可行串行基线；不声称它等于无限轮数最优误差。G<0 只表示本下界未证得正的额外代价。\n",
        "\n## 图片\n",
        "figures/certified_depth_cost.pdf：固定模型的轮数-误差关系，阴影只表示认证的正额外执行代价。\n",
        "figures/certified_execution_gap.pdf：不同预算和 n 下入选见证的 K=3 执行代价下界。\n",
        "figures/candidate_search_diagnostics.pdf：所有筛选候选的浮点 LP 诊断；仅入选见证另行独立认证，不声称外层最优。\n",
        "配色参考 https://github.com/ChenLiu-1996/figures4papers/ 。坐标标题22pt、图例和刻度18pt；无平滑拟合或装饰性误差带。\n"]
    (folder/"RESULTS_PHASE2.md").write_text("\n".join(lines)+"\n")
    print(json.dumps({k:v for k,v in result.items() if k!="candidates"},indent=2),flush=True)


if __name__=="__main__":
    ap=argparse.ArgumentParser()
    ap.add_argument("--run-dir",type=Path,required=True)
    main(ap.parse_args().run_dir)