附录 A 品类参数表、机制距离矩阵与数据集索引

#!/usr/bin/env python3
# file: sim/gd_proto_appendix_a.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/gd_proto_appendix_a.py
"""卷三 附录 A 聚合内核：品类参数表 / 机制距离矩阵 / 数据集索引。只读、只打印，不写新产物。
距离、支配缺失度等都是**代理指标（proxy）**，只做相对比较，禁绝对化。无浮点、无 random。
"""
from __future__ import annotations
import json, os, re
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
OUT = os.path.join(ROOT, "out")
NAMES = {"play_spec.json": "deckbuilder", "gd_proto_06_td.json": "tower-defense",
         "gd_proto_07_m3.json": "match3", "gd_proto_08_platformer.json": "platformer",
         "gd_proto_09_ab.json": "autobattler", "gd_proto_10_idle.json": "idle"}
SCAN = [("config/", r"^gd_proto_.*\.json$"), ("sim/", r"^gd_proto_.*\.py$"),
        ("core/test/", r"^gd_proto_.*\.test\.ts$"), ("core/genre/", r"^.*\.ts$"),
        ("web/", r"^build_proto.*\.mjs$"), ("out/", r"^gd_proto_.*\.(json|csv|svg)$"),
        ("out/", r"^proto.*\.(html|json)$"), ("out/shots/", r"^proto.*\.png$")]
CHAP = re.compile(r"(?:gd_proto_|proto|gd-proto-)(\d\d)")


def leaves(o, acc):
    if isinstance(o, (dict, list)):
        for v in (o.values() if isinstance(o, dict) else o): leaves(v, acc)
    else: acc.append(o)
    return acc


def main() -> int:
    parts = []
    for fn, key in NAMES.items():
        cfg = json.load(open(os.path.join(ROOT, "config", fn), encoding="utf-8"))
        c = lambda s: len([v for v in leaves(cfg.get(s, {}), []) if type(v) is int])
        segs = [s for s in ("rules", "params") if s in cfg] or ["cards", "goals", "params"]
        parts.append(key + "[" + " ".join(f"{s}={c(s)}" for s in segs) + "]")
    print("=== 一、品类参数表（rules / params 的整数叶子数）===")
    print("  " + " ".join(parts))
    sc = json.load(open(os.path.join(OUT, "gd_proto_13_schema.json"), encoding="utf-8"))
    print(f"  同构契约 skeleton={sc['skeleton']} namingSlots={sc['namingSlotCount']} invariant非空={sc['invariantAllNonEmpty']}")
    mat = json.load(open(os.path.join(OUT, "gd_proto_14_matrix.json"), encoding="utf-8"))
    print("\n=== 二、机制距离矩阵（L1，代理指标 proxy，只做相对比较）===")
    print("  " + "".ljust(13) + "".join(g.rjust(14) for g in mat["genres"]))
    for g, row in zip(mat["genres"], mat["l1"]):
        print("  " + g.ljust(13) + "".join(str(x).rjust(14) for x in row))
    ck, cl, fa = mat["checks"], mat["closest"][0], mat["farthest"][-1]
    print(f"  对称={ck['symmetric']} 三角={ck['triangle']} minNonZero={ck['minNonZero']} 两两不同={ck['distinct']} maxL1={mat['maxL1']}")
    print(f"  最近对 {cl['pair'][0]}↔{cl['pair'][1]} {cl['l1']}/{cl['permille']}‰；最远对 {fa['pair'][0]}↔{fa['pair'][1]} {fa['l1']}/{fa['permille']}‰")
    by = {}
    for sub, pat in SCAN:
        for n in sorted(os.listdir(os.path.join(ROOT, sub))):
            if re.match(pat, n):
                m = CHAP.search(n)
                by.setdefault(m.group(1) if m else "内核", []).append(n)
    print("\n=== 三、数据集索引（实扫工作区，只读）===")
    print("  各章条目数: " + " ".join(f"ch{c}={len(by[c])}" for c in sorted(by) if c != "内核") + f" 内核/附录={len(by.get('内核', []))}")
    print(f"  扫描条目总数 = {sum(len(v) for v in by.values())}")
    print("（全部代理指标口径，只做相对比较，禁绝对化；本脚本只打印，不写新产物）")
    return 0

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

=== 一、品类参数表（rules / params 的整数叶子数）===
  deckbuilder[params=8] tower-defense[rules=23 params=8] match3[rules=9 params=2] platformer[rules=15 params=2] autobattler[rules=41 params=5] idle[rules=22 params=4]
  同构契约 skeleton=id|naming|state|rules|params|invariant namingSlots=8 invariant非空=True

=== 二、机制距离矩阵（L1，代理指标 proxy，只做相对比较）===
                  deckbuilder  towerdefense        match3    platformer   autobattler          idle
  deckbuilder               0          2357          3080          4958          3808          5508
  towerdefense           2357             0          1811          3501          1743          4811
  match3                 3080          1811             0          3576          2996          5386
  platformer             4958          3501          3576             0          5186          4520
  autobattler            3808          1743          2996          5186             0          6496
  idle                   5508          4811          5386          4520          6496             0
  对称=True 三角=True minNonZero=1743 两两不同=True maxL1=6496
  最近对 塔防↔自走棋 1743/268‰；最远对 自走棋↔放置 6496/1000‰

=== 三、数据集索引（实扫工作区，只读）===
  各章条目数: ch01=11 ch02=16 ch03=10 ch04=12 ch05=7 ch06=10 ch07=13 ch08=9 ch09=10 ch10=10 ch11=13 ch12=7 ch13=19 ch14=11 ch15=24 ch16=18 内核/附录=9
  扫描条目总数 = 209
（全部代理指标口径，只做相对比较，禁绝对化；本脚本只打印，不写新产物）

// file: core/test/gd_proto_appendix_a.test.ts
// tier: P
// verify: node --test 'core/test/gd_proto_appendix_a.test.ts'
// 附录 A 自检：从 6×10 特征向量重算归一化 / L1 / 千分比，与落盘矩阵逐位比对，验证对称 / 三角 / 可区分。只读 out/ 下的 JSON，全整数、无浮点、无 Math.random。
import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
const load = (p: string) => JSON.parse(readFileSync(join(ROOT, p), "utf8"));
const feat = load("out/gd_proto_14_features.json");
const mat = load("out/gd_proto_14_matrix.json");
const l1 = (a: number[], b: number[]) => a.reduce((s, x, i) => s + Math.abs(x - b[i]), 0);

test("重算归一化 / L1 / 千分比，与落盘矩阵逐位一致", () => {
  const norm = feat.vectors.map((v: number[]) => feat.dims.map((_: string, j: number) => {
    const col = feat.vectors.map((r: number[]) => r[j]);
    const lo = Math.min(...col), hi = Math.max(...col);
    return hi === lo ? 0 : ((1000 * (v[j] - lo)) / (hi - lo)) | 0;
  }));
  assert.deepEqual(norm, mat.normalized);
  assert.deepEqual(norm.map((a: number[]) => norm.map((b: number[]) => l1(a, b))), mat.l1);
  const maxL1 = Math.max(...mat.l1.flat());
  assert.equal(maxL1, mat.maxL1);
  assert.deepEqual(mat.l1.map((r: number[]) => r.map((x: number) => ((1000 * x) / maxL1) | 0)),
    mat.distPermille);
});

test("三条验证：对称 / 三角不等式 / 可区分", () => {
  const n = mat.l1.length;
  for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) {
    assert.equal(mat.l1[i][j], mat.l1[j][i]);
    for (let k = 0; k < n; k++) assert.ok(mat.l1[i][j] <= mat.l1[i][k] + mat.l1[k][j]);
  }
  const nz = mat.l1.flat().filter((x: number) => x > 0);
  assert.equal(Math.min(...nz), 1743);
  assert.equal(new Set(nz).size, 15);
  console.log(`  对称=${mat.checks.symmetric} 三角=${mat.checks.triangle} minNonZero=${Math.min(...nz)}`
    + ` 两两不同=${mat.checks.distinct} 最近对=${mat.closest[0].pair.join("↔")}`
    + `(${mat.closest[0].l1}/${mat.closest[0].permille}‰)`);
});

  对称=true 三角=true minNonZero=1743 两两不同=true 最近对=塔防↔自走棋(1743/268‰)
✔ 重算归一化 / L1 / 千分比，与落盘矩阵逐位一致 (1.1465ms)
✔ 三条验证：对称 / 三角不等式 / 可区分 (0.580625ms)
ℹ tests 2
ℹ pass 2
ℹ fail 0

# snippet: shell 的 for 循环逐个执行，避免只跑第一个文件
cd "$HOME/.gdbook/ashdeck"
for f in sim/gd_proto_*.py; do /opt/homebrew/bin/python3 "$f" || exit 1; done

# snippet: node --test 接收 glob 而非目录，必须加引号让 node 自己展开
cd "$HOME/.gdbook/ashdeck"
node --test 'core/test/gd_proto_*.test.ts'

# snippet: 复用全局 Playwright 必须经 createRequire；verify 产出截图并断言 canvas 已绘制
cd "$HOME/.gdbook/ashdeck"
node web/build_proto16.mjs
NODE_PATH=/opt/homebrew/lib/node_modules node web/verify_mech.mjs --page out/proto16.html --shot out/shots/proto16.png