Upload 43 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+ICLR[[:space:]]dataset/evaluation_queries_44416.jsonl filter=lfs diff=lfs merge=lfs -text

ICLR dataset/README.md

@@ -0,0 +1,216 @@
+# `dataset3/` —— Fact Knowledge Stability Benchmark
+
+按 [`../dataset/fact_knowledge_stability_dataset_reconstruction.md`](../dataset/fact_knowledge_stability_dataset_reconstruction.md)
+从 `../dataset/` 的数据重建。**不改动 `../dataset/` 和 `../dataset2/`。**
+
+与 `dataset2` 的根本区别在方法论，不在数字：
+
+> **基准集是固定的 2,592 条，对所有模型相同。** `K_m` 只是每个模型的正确性**标签**，
+> 绝不用来从基准集里删事实（spec §2.1）。模型答错、一直答错、拒答、
+> 在不同条件下答不同答案——事实都留在集合里。
+
+---
+
+## 目录
+
+```
+dataset3/
+├── configs/                     # 全部参数外置，脚本里不硬编码（spec §4.4, §18）
+│   ├── models.yaml              #   5 个过滤模型 + 评测模型 + 生成配置
+│   ├── relations.yaml           #   21 个基准关系 + 排除清单 + 两个开关
+│   ├── source_templates.yaml    #   原始来源、cloze 模板、别名资源
+│   └── eval_conditions.yaml     #   8 个条件的角色/目标槽/期望计数
+├── src/
+│   ├── common.py                    公共：配置/规范化/校验和/计数核对
+│   ├── build_candidate_known.py (I)   → candidate_known_8107.jsonl
+│   ├── enrich_facts.py         (II)   → enriched_facts_6180.jsonl
+│   ├── select_benchmark.py     (III)  → benchmark_facts_2592.jsonl
+│   ├── build_eval_bank.py      (IV)   → evaluation_queries_44418.jsonl
+│   ├── validate_facts.py              → validation_report.json  ← 硬门禁
+│   ├── build_stats.py                 → dataset_statistics.json
+│   ├── qualification_run.py    (V)    → qualification/<model>.jsonl   [GPU]
+│   ├── qualification_score.py  (V)    → known_labels.json
+│   ├── eval_run.py             (VI)   → evaluation/<model>.jsonl       [GPU]
+│   ├── eval_score.py           (VI)   → stability_report.json
+│   ├── filter_run.py                  阶段 I 首 token 过滤（重跑用）  [GPU]
+│   ├── scoring_full.py                五标签判分器
+│   ├── qual_templates.py              非基准关系的兜底问句
+│   └── test_scoring.py                31 条单元测试
+├── outputs/
+└── run_pipeline.sh              # build / gpu / score / report / all
+```
+
+---
+
+## 六个阶段
+
+### I. 候选召回 → 8,107（spec §4）
+
+```
+1,783,541 cloze prompt
+   → 5 模型首 token argmax 取交集 → 10,601
+   → 丢弃 T-REx / Wikidata5M 子集，补 PopQA 378 → 8,107
+```
+
+**GPU 未重跑。** 那 1,783,541 × 5 次前向的逐条判定向量已存于
+`dataset/filter/correct_<model>.npy`。[build_candidate_known.py](src/build_candidate_known.py)
+重新读取 prompt 表、**重新求交集**、重新施加来源丢弃规则，并把每个输入文件的
+校验和写进 `stage1_report.json`——数字是**验证出来的**，不是照抄。
+另外与 `dataset/filter/global_known_clean.jsonl` 做集合相等性核对。
+要从零重跑推理用 `src/filter_run.py`。
+
+### II. 事实增强 → 6,180（spec §5）
+
+- **实体感知分组**：优先用实体 ID，无 ID 才退回规范化文本；**跨来源合并**
+  （1,036 组同时出现在 CounterFact 和 LAMA-TREx）。8,107 行 → 6,185 组
+- **函数型冲突丢弃 5 条**：同名不同人（两个 "Michael Vincent" 生于 1964/1976）问题本身无解。
+  判据严格——**缺实体 ID 不算"同一实体"的证据**，所有成员必须都有 ID 且一致才保留
+- **别名扩展**：对别名资源做**单次过滤扫描**（spec §5.3），不全量载入
+- **挂 canonical 问句**，与评测扰动模板严格分离（spec §16）
+
+### III. 基准选择 → 2,592 / 21 关系（spec §6）
+
+```
+6,180 → core 来源（CounterFact + LAMA-TREx + PopQA）→ 3,705
+      → 函数型（单值）关系 → 2,592
+```
+
+### IV. 查询库 → 44,416（spec §8–§12）
+
+| 条件 | 查询 | 事实 | 角色 |
+|---|---:|---:|---|
+| anchor | 2,592 | 2,592 | main |
+| multilingual | 12,010 | 2,402 | main |
+| paraphrase | 10,053 | 2,592 | main |
+| format | 7,776 | 2,592 | main |
+| context | **6,829** | 2,591 | main |
+| reverse | 634 | 253 | **结构分析，单独报** |
+| recognition | 3,412 | 2,585 | 诊断 |
+| reverse_illposed | 1,110 | 1,110 | 诊断 |
+| **合计** | **44,416** | | main forward **39,260** |
+
+每条查询自带 `use_for_main_forward` / `use_for_reverse_analysis` /
+`use_for_recognition_analysis` 三个布尔量，**由 `eval_conditions.yaml` 派生**，
+下游聚合不需要硬编码哪个条件进哪个平均。校验器会检查每行的布尔量与注册表一致。
+
+### V. Anchor 资格认证 → `K_m` 标签（spec §7）⬜ 待跑
+
+纯补全 prompt（base 与 instruct 用**完全相同**的字符串，无 chat template）、
+贪婪解码 24 token、无候选无 few-shot。判分在 CPU，**五标签**：
+
+`correct` / `incorrect` / `ambiguous` / `abstain` / `unparseable`
+
+输出 `known_labels.json`：`{fact_id: {model: label}}`，覆盖全部 2,592 × 全部模型。
+
+### VI. 扰动评测 → 稳定性 ⬜ 待跑
+
+[eval_run.py](src/eval_run.py) 跑全部 44,416 条查询，
+**解码配置与 anchor 完全一致**（同一份 `configs/models.yaml:generation`）——
+否则 `max_new_tokens` 或 chat template 的差异会被误读成稳定性效应。
+anchor 也一起重跑，让所有条件走同一条代码路径。
+
+[eval_score.py](src/eval_score.py) 在 CPU 判分并出报表，三条规则写死在代码里而不是留给读者：
+
+1. **按查询自带的布尔量分组** —— `recognition` 和 `reverse_illposed` 永不进主平均，
+   `reverse` 因为换了目标槽而单独报（spec §2.3）
+2. **两个分母并排报**：`fixed`（固定 2,592，spec §2.1）与
+   `anchored`（限定在该模型的 `K_m` 内，即条件化保持率）
+3. **每个数字按 `answer_in_subject_surface` 再拆一次**（`·real` / `·copy`），
+   因为 28.9% 的事实靠复制就能答对、天然接近满分（见 F1）
+
+主指标 macro = paraphrase / format / context / multilingual 四者均值：
+anchor 是基线不计入，reverse 换了槽不计入，两个诊断条件不计入。
+
+---
+
+## 运行
+
+```bash
+cd /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset3
+bash run_pipeline.sh build     # 阶段 I-IV + 校验 + 统计，CPU 约 1 分钟（已跑完）
+bash run_pipeline.sh gpu       # 阶段 V+VI 生成，每个模型只加载一次权重
+bash run_pipeline.sh score     # 阶段 V 判分 → K_m 标签
+bash run_pipeline.sh report    # 阶段 VI 判分 → stability_report.json
+```
+
+`gpu` 把 anchor 和扰动两趟生成合在一起跑，权重只载入一次。
+两个生成阶段都幂等：anchor 已存在会跳过，`eval_run.py --resume` 会跳过已完成的查询。
+
+**顺序要求**：`score` 必须在 `report` 之前跑，否则没有 `known_labels.json`，
+`anchored` 那一列会缺失（脚本会警告并只报 `fixed`）。
+
+---
+
+## 当前状态
+
+| 阶段 | 状态 |
+|---|---|
+| I 候选召回 | ✅ 8,107，全部计数命中 |
+| II 事实增强 | ✅ 6,180，6,185 组 / 5 冲突 / 1,771 合并 / 1,036 跨来源，全中 |
+| III 基准选择 | ✅ 2,592 / 21 关系，全中 |
+| IV 查询库 | ✅ 44,416（见差异 D1） |
+| 校验 | ✅ **0 hard errors** |
+| 单元测试 | ✅ **31/31** |
+| V 资格认证 | ⬜ 待跑（判分逻辑已用合成数据演练通过） |
+| VI 扰动评测 | ⬜ 待跑（运行器 + 报表已用合成数据演练通过） |
+
+---
+
+## 与 spec 的差异（完整版见 [outputs/reconstruction_differences.md](outputs/reconstruction_differences.md)）
+
+除一处外全部精确复现。
+
+**D1 — context 6,831 → 6,829，总计 44,418 → 44,416。**
+旧数据里有 2 条 context 查询的干扰实体字面包含 gold：
+`"...confuse States Reorganisation Act with **Indian** Act..."` 而 gold 是 `India`。
+违反 spec §9.4 与 §13.9。按 spec §10「发现既有缺陷可改数」处理：
+在建库时加**规则化守卫**（主语提及剔除后 gold 仍出现即丢弃），不是硬编码例外。
+
+**C1 — spec §6.2 与要求的规模自相矛盾。**
+§6.2 点名 `developer of` / `manufacturer of` 不适合，但这两个关系共 **846 条**，
+去掉只剩 1,746 条 / 19 关系，达不到 §15 验收要求的 2,592 / 21。
+处理：保留并打 `spec_6_2_flag`，`relations.yaml` 提供 `drop_spec_6_2_flagged` 开关
+可一键产出 1,746 条的合规变体。
+
+**F1 — 28.9% 的基准事实可以靠复制字符串答对。**
+2,592 条里有 **750 条** object 字面包含在 subject 名字里：
+
+```
+Airbus A318  → manufacturer  Airbus      (该关系 87.8% 命中)
+Adobe Acrobat → developer    Adobe        (49.1%)
+Amazon Music  → owned by     Amazon       (58.4%)
+```
+
+其中 586 条来自 manufacturer 和 developer——**独立印证了 C1**。
+这类事实"稳定"的原因与知识无关，会抬高所有保持率、削弱要研究的效应。
+按 spec §16 不删，打 `answer_in_subject_surface` 标记，事实和查询两级都带。
+`qualification_score.py` 已经**默认分开报**这两个子集的准确率。
+
+**F2 — 8,107 里有 808 条完全重复的三元组**（唯一四元组只有 7,299）。分组阶段自然吸收，仅记录。
+
+**N1 — Stage I 未重跑 GPU**（见上）。
+**N2 — `capital_of` 方向未归一化**：spec §2.2 要求单一方向，但归一化会改变规模，故保留
+`direction: inverse` + `inverse_of: capital` 显式标注，开关在 `relations.yaml`。
+
+---
+
+## 两个必须记住的口径
+
+1. **分母永远是 2,592。** `K_m` 是标签不是筛子。加模型、换模型都不改任何已算出的数。
+2. **reverse 不进 main forward 平均。** 它换了目标槽（object → subject），
+   spec §2.3 要求单独报。`recognition` 和 `reverse_illposed` 同理，且校验器有硬检查。
+
+---
+
+## 报告用描述（spec §17）
+
+> We first use five-model first-token consensus to retrieve high-probability
+> factual candidates from large-scale knowledge resources. We then merge
+> duplicate facts, expand entity aliases, construct independent canonical
+> questions, remove ambiguous and multi-valued relations, and obtain a fixed
+> benchmark of 2,592 facts across 21 relations. Model-specific open-ended anchor
+> generation provides correctness labels but does not alter the benchmark
+> denominator. Based on the fixed fact set, we construct 44,416 queries covering
+> anchor, paraphrastic, format, contextual, cross-lingual, reverse, and
+> recognition conditions, while isolating ill-posed reverse queries as a
+> separate diagnostic set.

ICLR dataset/configs/eval_conditions.yaml

@@ -0,0 +1,162 @@
+# Evaluation condition registry (spec sections 2.3, 8, 9, 10).
+#
+# The per-query booleans use_for_main_forward / use_for_reverse_analysis /
+# use_for_recognition_analysis are DERIVED from this file, so a downstream
+# aggregation never has to hard-code which conditions belong in which average.
+#
+# Spec 2.3 / 16: recognition and reverse_illposed must never enter the main
+# forward aggregation, and reverse is reported separately because it changes
+# the target slot from object to subject.
+
+conditions:
+  anchor:
+    role: main
+    target_slot: object
+    is_assisted: false
+    is_well_posed: true
+    use_for_main_forward: true
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: false
+    expected_queries: 2592
+    expected_facts: 2592
+    description: >
+      The canonical qualification question itself. Shares the prompt string with
+      the anchor qualification run, so per-condition retention is measured
+      against a real measured baseline rather than an assumed 1.0.
+
+  paraphrase:
+    role: main
+    target_slot: object
+    is_assisted: false
+    is_well_posed: true
+    use_for_main_forward: true
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: false
+    expected_queries: 10053
+    expected_facts: 2592
+    migrated_from: queryA_canonical
+    description: >
+      Lexical and syntactic rewording, same fact and same target slot.
+
+  format:
+    role: main
+    target_slot: object
+    is_assisted: false
+    is_well_posed: true
+    use_for_main_forward: true
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: false
+    expected_queries: 7776
+    expected_facts: 2592
+    migrated_from: queryB_paraphrase
+    excludes: [mcq]
+    description: >
+      Question or response format changes with no candidates exposed. MCQ rows
+      from the same source file are routed to `recognition` instead (spec 9.3).
+
+  context:
+    role: main
+    target_slot: object
+    is_assisted: false
+    is_well_posed: true
+    use_for_main_forward: true
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: false
+    expected_queries: 6831
+    expected_facts: 2591
+    migrated_from: queryD_context
+    description: >
+      Irrelevant or misleading context prepended; the intended query stays
+      unambiguous and the correct answer is unchanged.
+
+  multilingual:
+    role: main
+    target_slot: object
+    is_assisted: false
+    is_well_posed: true
+    use_for_main_forward: true
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: false
+    expected_queries: 12010
+    expected_facts: 2402
+    migrated_from: queryE_multilingual
+    languages: [zh, fr, es, de, ru]
+    description: >
+      Same factual question in another language. Query language is stored in
+      the `language` field.
+
+  reverse:
+    role: structural            # reported separately, NOT in the main average
+    target_slot: subject
+    is_assisted: false
+    is_well_posed: true
+    use_for_main_forward: false
+    use_for_reverse_analysis: true
+    use_for_recognition_analysis: false
+    expected_queries: 634
+    expected_facts: 253
+    migrated_from: queryC_reverse
+    requires: is_inverse_well_posed
+    description: >
+      (o, r^-1) -> s. Only built where the inverse mapping is unique. Spec 2.3:
+      reported separately because the target slot changes.
+
+  recognition:
+    role: diagnostic
+    target_slot: object
+    is_assisted: true
+    is_well_posed: true
+    use_for_main_forward: false
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: true
+    expected_queries: 3412
+    expected_facts: 2585
+    migrated_from: queryB_paraphrase(fmt=mcq)
+    description: >
+      Multiple choice. Measures recognition, not unaided retrieval.
+
+  reverse_illposed:
+    role: diagnostic
+    target_slot: subject
+    is_assisted: false
+    is_well_posed: false
+    use_for_main_forward: false
+    use_for_reverse_analysis: false
+    use_for_recognition_analysis: false
+    expected_queries: 1110
+    expected_facts: 1110
+    migrated_from: queryC_reverse(not well_posed)
+    description: >
+      Reverse queries whose inverse mapping is one-to-many ("What was developed
+      by Apple?"). Diagnostic only; never scored in any headline number.
+
+totals:
+  expected_total_queries: 44418
+  # anchor 2592 + paraphrase 10053 + format 7776 + context 6831 + multilingual 12010
+  expected_main_forward_queries: 39262
+  expected_benchmark_facts: 2592
+  expected_relations: 21
+
+# Spec 11: a query is a duplicate when fact_id + normalized text + target slot +
+# condition family all coincide.
+deduplication:
+  key: [fact_id, normalized_query, target_slot, condition_family]
+  expected_removed_during_migration: 10323
+
+# Deviations from the spec counts that have been investigated and written up in
+# outputs/reconstruction_differences.md. Listing one here stops the build from
+# failing on it; an UNLISTED deviation still fails, so a new regression cannot
+# hide behind a documented one.
+accepted_deviations:
+  - check: context.queries
+    actual: 6829
+    expected: 6831
+    ref: D1
+  - check: total_queries
+    actual: 44416
+    expected: 44418
+    ref: D1
+  - check: main_forward_queries
+    actual: 39260
+    expected: 39262
+    ref: D1

ICLR dataset/configs/models.yaml

@@ -0,0 +1,178 @@
+# Model registry. Spec section 4.4: the filtering models must live in
+# configuration rather than being hard-coded.
+#
+# The evaluated set follows Model/MODEL_SELECTION_20.md: 5 families x 4 models,
+# four size tiers, and four clean base<->instruct pairs spread across four
+# different families.
+#
+# revision: "local" means the snapshot under Model/ is authoritative. Record the
+# real commit hash once weights are re-pulled from the hub.
+
+model_root: /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/Model
+
+# ---- Stage I: five-model first-token candidate recall -----------------------
+# FROZEN. These five defined the 8,107-fact candidate pool that everything
+# downstream rests on. Changing this list invalidates
+# candidate_known_8107.jsonl and every artefact derived from it, so it must stay
+# fixed even as the evaluated set grows.
+filter_models:
+  - {name: Gemma-2-2B-it,   path: Gemma-2-2B-it,   revision: local}
+  - {name: Qwen2.5-7B,      path: Qwen2.5-7B,      revision: local}
+  - {name: Mistral-7B-v0.3, path: Mistral-7B-v0.3, revision: local}
+  - {name: Llama-3.1-8B,    path: Llama-3.1-8B,    revision: local}
+  - {name: Gemma-2-9B-it,   path: Gemma-2-9B-it,   revision: local}
+
+# ---- Stage V/VI: the 20 evaluated models ------------------------------------
+# Spec 7.1: qualification produces K_m LABELS only. Adding or removing a model
+# here never changes the benchmark denominator (fixed at 2,592), so this list is
+# safe to extend at any time without invalidating earlier results.
+#
+# n_layers / d_model / jlens_window come from MODEL_SELECTION_20.md, where
+# window = number of layers with normalized depth >= 0.4.
+evaluated_models:
+  # ---------------- Llama-3.x ----------------
+  - {name: Llama-3.2-1B,  path: Llama-3.2-1B,  hf: meta-llama/Llama-3.2-1B,
+     family: llama-3.x, tier: 1-5B, params_b: 1.24, tuning: base,
+     n_layers: 16, d_model: 2048, jlens_window: 10, revision: main}
+  - {name: Llama-3.2-3B,  path: Llama-3.2-3B,  hf: meta-llama/Llama-3.2-3B,
+     family: llama-3.x, tier: 1-5B, params_b: 3.21, tuning: base,
+     n_layers: 28, d_model: 3072, jlens_window: 17, revision: main}
+  - {name: Llama-3.1-8B,  path: Llama-3.1-8B,  hf: meta-llama/Llama-3.1-8B,
+     family: llama-3.x, tier: 5-9B, params_b: 8.03, tuning: base,
+     n_layers: 32, d_model: 4096, jlens_window: 19, revision: local,
+     pair: llama_8b}
+  - {name: Llama-3.1-8B-Instruct, path: Llama-3.1-8B-Instruct,
+     hf: meta-llama/Llama-3.1-8B-Instruct,
+     family: llama-3.x, tier: 5-9B, params_b: 8.03, tuning: instruct,
+     n_layers: 32, d_model: 4096, jlens_window: 19, revision: main,
+     pair: llama_8b}
+
+  # ---------------- Qwen2.5 ----------------
+  - {name: Qwen2.5-3B, path: Qwen2.5-3B, hf: Qwen/Qwen2.5-3B,
+     family: qwen2.5, tier: 1-5B, params_b: 3.09, tuning: base,
+     n_layers: 36, d_model: 2048, jlens_window: 22, revision: main}
+  - {name: Qwen2.5-7B, path: Qwen2.5-7B, hf: Qwen/Qwen2.5-7B,
+     family: qwen2.5, tier: 5-9B, params_b: 7.62, tuning: base,
+     n_layers: 28, d_model: 3584, jlens_window: 17, revision: local,
+     pair: qwen_7b}
+  - {name: Qwen2.5-7B-Instruct, path: Qwen2.5-7B-Instruct,
+     hf: Qwen/Qwen2.5-7B-Instruct,
+     family: qwen2.5, tier: 5-9B, params_b: 7.62, tuning: instruct,
+     n_layers: 28, d_model: 3584, jlens_window: 17, revision: main,
+     pair: qwen_7b}
+  - {name: Qwen2.5-32B, path: Qwen2.5-32B, hf: Qwen/Qwen2.5-32B,
+     family: qwen2.5, tier: 20B+, params_b: 32.76, tuning: base,
+     n_layers: 64, d_model: 5120, jlens_window: 38, revision: local}
+
+  # ---------------- Mistral ----------------
+  - {name: Mistral-7B-v0.3, path: Mistral-7B-v0.3, hf: mistralai/Mistral-7B-v0.3,
+     family: mistral, tier: 5-9B, params_b: 7.25, tuning: base,
+     n_layers: 32, d_model: 4096, jlens_window: 19, revision: local,
+     pair: mistral_7b}
+  - {name: Mistral-7B-Instruct-v0.3, path: Mistral-7B-Instruct-v0.3,
+     hf: mistralai/Mistral-7B-Instruct-v0.3,
+     family: mistral, tier: 5-9B, params_b: 7.25, tuning: instruct,
+     n_layers: 32, d_model: 4096, jlens_window: 19, revision: main,
+     pair: mistral_7b}
+  - {name: Mistral-Nemo-Base-2407, path: Mistral-Nemo-Base-2407,
+     hf: mistralai/Mistral-Nemo-Base-2407,
+     family: mistral, tier: 9-20B, params_b: 12.25, tuning: base,
+     n_layers: 40, d_model: 5120, jlens_window: 24, revision: main}
+  - {name: Mistral-Small-24B-Base-2501, path: Mistral-Small-24B-Base-2501,
+     hf: mistralai/Mistral-Small-24B-Base-2501,
+     family: mistral, tier: 20B+, params_b: 23.57, tuning: base,
+     n_layers: 40, d_model: 5120, jlens_window: 24, revision: main}
+
+  # ---------------- Gemma-2 ----------------
+  # Gemma-2 and OLMo-2 publish fp32 safetensors only; they are loaded with
+  # dtype=bfloat16, so on-disk size is ~2x the bf16 figure.
+  - {name: gemma-2-2b, path: gemma-2-2b, hf: google/gemma-2-2b,
+     family: gemma-2, tier: 1-5B, params_b: 2.61, tuning: base,
+     n_layers: 26, d_model: 2304, jlens_window: 16, revision: main}
+  - {name: gemma-2-9b, path: gemma-2-9b, hf: google/gemma-2-9b,
+     family: gemma-2, tier: 9-20B, params_b: 9.24, tuning: base,
+     n_layers: 42, d_model: 3584, jlens_window: 25, revision: main,
+     pair: gemma_9b}
+  - {name: Gemma-2-9B-it, path: Gemma-2-9B-it, hf: google/gemma-2-9b-it,
+     family: gemma-2, tier: 9-20B, params_b: 9.24, tuning: instruct,
+     n_layers: 42, d_model: 3584, jlens_window: 25, revision: local,
+     pair: gemma_9b}
+  - {name: gemma-2-27b, path: gemma-2-27b, hf: google/gemma-2-27b,
+     family: gemma-2, tier: 20B+, params_b: 27.23, tuning: base,
+     n_layers: 46, d_model: 4608, jlens_window: 28, revision: main}
+
+  # ---------------- OLMo-2 ----------------
+  # The only family with all four tiers AND fully public pretraining data, which
+  # is what makes "the model never saw this fact" separable from "the model
+  # cannot retrieve it".
+  - {name: OLMo-2-0425-1B, path: OLMo-2-0425-1B, hf: allenai/OLMo-2-0425-1B,
+     family: olmo-2, tier: 1-5B, params_b: 1.48, tuning: base,
+     n_layers: 16, d_model: 2048, jlens_window: 10, revision: main}
+  - {name: OLMo-2-1124-7B, path: OLMo-2-1124-7B, hf: allenai/OLMo-2-1124-7B,
+     family: olmo-2, tier: 5-9B, params_b: 7.30, tuning: base,
+     n_layers: 32, d_model: 4096, jlens_window: 19, revision: main}
+  - {name: OLMo-2-1124-13B, path: OLMo-2-1124-13B, hf: allenai/OLMo-2-1124-13B,
+     family: olmo-2, tier: 9-20B, params_b: 13.72, tuning: base,
+     n_layers: 40, d_model: 5120, jlens_window: 24, revision: main}
+  - {name: OLMo-2-0325-32B, path: OLMo-2-0325-32B, hf: allenai/OLMo-2-0325-32B,
+     family: olmo-2, tier: 20B+, params_b: 32.23, tuning: base,
+     n_layers: 64, d_model: 5120, jlens_window: 38, revision: main}
+
+# ---- base <-> instruct pairs (MODEL_SELECTION_20.md section 4) --------------
+# Same weights lineage, same tokenizer, same size; only post-training differs.
+# If BES improves while ISS does not, instruction tuning stabilised EXPRESSION
+# rather than KNOWLEDGE.
+tuning_pairs:
+  llama_8b:   {base: Llama-3.1-8B,     instruct: Llama-3.1-8B-Instruct,     family: llama-3.x, tier: 5-9B}
+  qwen_7b:    {base: Qwen2.5-7B,       instruct: Qwen2.5-7B-Instruct,       family: qwen2.5,   tier: 5-9B}
+  mistral_7b: {base: Mistral-7B-v0.3,  instruct: Mistral-7B-Instruct-v0.3,  family: mistral,   tier: 5-9B}
+  gemma_9b:   {base: gemma-2-9b,       instruct: Gemma-2-9B-it,             family: gemma-2,   tier: 9-20B}
+
+# ---- models that do NOT occupy an evaluated slot ----------------------------
+auxiliary_models:
+  stage_a_calibration:
+    name: Qwen2.5-0.5B
+    path: Qwen2.5-0.5B
+    hf: Qwen/Qwen2.5-0.5B
+    params_b: 0.49
+    n_layers: 24
+    d_model: 896
+    reason: exact full-matrix reference for J-Lens (J-Lens spec section 5)
+  judge:
+    name: Qwen2.5-32B-Instruct
+    path: Qwen2.5-32B-Instruct
+    hf: Qwen/Qwen2.5-32B-Instruct
+    params_b: 32.76
+    n_layers: 64
+    d_model: 5120
+    reason: semantic clustering judge (evaluation protocol section 3)
+    # Must be instruct (structured JSON output) and multilingual-strong: 12,010
+    # of 44,416 queries are zh/fr/es/de/ru.
+    known_bias: >
+      shares pretraining lineage with the four evaluated Qwen models and may
+      systematically favour their phrasing. Mitigation: agreement check against
+      src/scoring_full.py on a stratified sample, and optionally a second judge
+      (gemma-2-27b-it) on a subsample. The judge is never itself evaluated.
+
+# ---- excluded, with reasons (MODEL_SELECTION_20.md section 9) ---------------
+excluded_models:
+  - {name: Llama-3.1-70B, reason: "bf16 weights 141 GB vs 143 GB H200; quantisation would alter hidden states and break ISS/KTS comparability"}
+  - {name: Qwen2.5-14B,   reason: "could fill 9-20B but dropped to keep families balanced at 4 each; that tier still has 3 base models. Weights remain under Model/ but are not evaluated."}
+  - {name: Llama-2-13B,   reason: "different generation from Llama-3; mixing would break the family axis"}
+  - {name: Phi-3/Phi-4,   reason: "heavily synthetic training data; atypical knowledge profile"}
+  - {name: Yi/InternLM/GLM, reason: "adds family breadth but no new scientific axis"}
+
+# ---- Stage V/VI generation configuration (spec section 7.3) -----------------
+generation:
+  do_sample: false
+  num_beams: 1
+  temperature: 0.0
+  max_new_tokens: 24
+  max_prompt_len: 96
+  batch_size: 96
+  dtype: bfloat16
+  # Spec 7.2: identical raw prompt string for base and instruct models, so no
+  # chat template is ever applied. This matters more with 4 instruct models in
+  # the set: giving only those a chat template would confound tuning with format.
+  use_chat_template: false
+  seed: 20260101

ICLR dataset/configs/relations.yaml

@@ -0,0 +1,256 @@
+# Relation registry for the benchmark (spec sections 2.2, 5.4, 6.2).
+#
+# Per relation:
+#   relation_id      canonical snake_case name used in outputs
+#   source_relations Wikidata property ids (or source-native names) that map here
+#   direction        forward = subject + relation -> object, matching spec 2.2.
+#                    inverse = the source stores the pair the other way round.
+#   is_functional    the object is single- or approximately single-valued
+#   is_inverse_well_posed  object determines subject uniquely -> reverse queries
+#                    are meaningful; false means reverse goes to reverse_illposed
+#   answer_type / answer_granularity   drive scoring and reporting breakdowns
+#   qualification    canonical anchor question, slot {s}. Verified NOT to collide
+#                    with any evaluation perturbation template (spec 16).
+#   spec_6_2_flag    set when spec section 6.2 names this relation as unsuitable
+#                    while the required count of 2,592 needs it. See
+#                    outputs/reconstruction_differences.md.
+
+# Global switches ------------------------------------------------------------
+options:
+  # Spec 2.2 forbids mixing triple directions. P1376 ("X is the capital of Y")
+  # is stored inverse to P36. Flipping it merges those facts into `capital` and
+  # changes the benchmark size, which spec 10 forbids doing silently. Default
+  # false reproduces 2,592; set true only together with a差异 entry.
+  normalize_inverse_direction: false
+  # Spec 6.2 lists developer/manufacturer as unsuitable, but excluding them
+  # cannot reach the required 2,592. Default false keeps them and flags them.
+  drop_spec_6_2_flagged: false
+
+relations:
+  - relation_id: native_language
+    source_relations: [P103]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: language
+    answer_granularity: entity
+    qualification: "Which language did {s} grow up speaking?"
+
+  - relation_id: manufacturer
+    source_relations: [P176]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: organization
+    answer_granularity: entity
+    qualification: "Which company builds {s}?"
+    spec_6_2_flag: unsuitable_named_in_spec
+
+  - relation_id: developer
+    source_relations: [P178]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: organization
+    answer_granularity: entity
+    qualification: "Which company or person created {s}?"
+    spec_6_2_flag: unsuitable_named_in_spec
+
+  - relation_id: country
+    source_relations: [P17]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: country
+    answer_granularity: entity
+    qualification: "Which country does {s} belong to?"
+
+  - relation_id: original_network
+    source_relations: [P449]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: organization
+    answer_granularity: entity
+    qualification: "Which network first broadcast {s}?"
+
+  - relation_id: headquarters_location
+    source_relations: [P159]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: city
+    answer_granularity: entity
+    qualification: "Which city hosts the main offices of {s}?"
+
+  - relation_id: capital
+    source_relations: [P36]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: true
+    answer_type: city
+    answer_granularity: entity
+    qualification: "Which city is the seat of government of {s}?"
+
+  - relation_id: capital_of
+    source_relations: [P1376]
+    direction: inverse          # stored as (city, capital_of, country)
+    inverse_of: capital
+    is_functional: true
+    is_inverse_well_posed: true
+    answer_type: country
+    answer_granularity: entity
+    qualification: "{s} is the capital city of which country?"
+
+  - relation_id: owned_by
+    source_relations: [P127]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: organization
+    answer_granularity: entity
+    qualification: "Who is the owner of {s}?"
+
+  - relation_id: sport
+    source_relations: [P641]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: sport
+    answer_granularity: entity
+    qualification: "Which sport is {s} associated with?"
+
+  - relation_id: continent
+    source_relations: [P30]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: place
+    answer_granularity: entity
+    qualification: "Which continent is {s} part of?"
+
+  - relation_id: religion
+    source_relations: [P140]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: religion
+    answer_granularity: entity
+    qualification: "Which faith does {s} follow?"
+
+  - relation_id: applies_to_jurisdiction
+    source_relations: [P1001]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: place
+    answer_granularity: entity
+    qualification: "Which jurisdiction does {s} have legal force in?"
+
+  - relation_id: location
+    source_relations: [P276]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: place
+    answer_granularity: entity
+    qualification: "At which location can {s} be found?"
+
+  - relation_id: country_of_origin
+    source_relations: [P495]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: country
+    answer_granularity: entity
+    qualification: "Which country did {s} originate from?"
+
+  - relation_id: place_of_death
+    source_relations: [P20]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: city
+    answer_granularity: entity
+    qualification: "At which place did {s} pass away?"
+
+  - relation_id: place_of_birth
+    source_relations: [P19]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: city
+    answer_granularity: entity
+    qualification: "In which place did {s} come into the world?"
+
+  - relation_id: located_in
+    source_relations: [P131]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: place
+    answer_granularity: entity
+    qualification: "Which administrative region contains {s}?"
+
+  - relation_id: position_played
+    source_relations: [P413]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: occupation
+    answer_granularity: entity
+    qualification: "On the field, which position is {s} assigned to?"
+
+  - relation_id: location_of_formation
+    source_relations: [P740]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: city
+    answer_granularity: entity
+    qualification: "{s} came into existence in which place?"
+
+  - relation_id: father
+    source_relations: [P22]
+    direction: forward
+    is_functional: true
+    is_inverse_well_posed: false
+    answer_type: person
+    answer_granularity: entity
+    qualification: "{s} is the child of which father?"
+
+# Relations present in the enriched pool but EXCLUDED from the benchmark because
+# the object is genuinely multi-valued, so an accepted-answer set can never be
+# exhaustive (spec 6.2). Kept here for auditability.
+excluded_multi_valued:
+  - {source_relations: [P37],   reason: official language}
+  - {source_relations: [P106],  reason: occupation}
+  - {source_relations: [P27],   reason: country of citizenship}
+  - {source_relations: [P31],   reason: instance of}
+  - {source_relations: [P279],  reason: subclass of}
+  - {source_relations: [P101],  reason: field of work}
+  - {source_relations: [P108],  reason: employer}
+  - {source_relations: [P463],  reason: member of}
+  - {source_relations: [P1303], reason: instrument}
+  - {source_relations: [P364],  reason: original language}
+  - {source_relations: [P407],  reason: language of work}
+  - {source_relations: [P1412], reason: language spoken}
+  - {source_relations: [P50, P57, P58, P86, P162], reason: creator roles}
+  - {source_relations: [P190],  reason: twinned city}
+  - {source_relations: [P47],   reason: shares border with}
+  - {source_relations: [P527],  reason: has part}
+  - {source_relations: [P264],  reason: record label}
+  - {source_relations: [P462],  reason: colour}
+  - {source_relations: [P937],  reason: work location}
+  - {source_relations: [P136],  reason: genre}
+  - {source_relations: [P25],   reason: mother}
+  - {source_relations: [IsA, UsedFor, AtLocation, HasA, HasProperty, CapableOf,
+                        PartOf, Causes, CausesDesire, Desires, NotDesires,
+                        HasSubevent, HasPrerequisite, MotivatedByGoal, MadeOf,
+                        ReceivesAction],
+     reason: ConceptNet open-world commonsense}
+
+# Relations excluded because they belong to non-core sources (spec 6.1)
+excluded_non_core:
+  - {source_relations: [date_of_birth, place_of_birth, place_of_death],
+     source: lama_googlere, reason: not a core source}

ICLR dataset/configs/source_templates.yaml

@@ -0,0 +1,117 @@
+# Raw source registry and Stage I cloze templates (spec sections 4.1 - 4.3).
+
+raw_root: /scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset
+
+sources:
+  counterfact:
+    path: counterfact/data/*.parquet
+    format: parquet
+    expected_triples: 21919
+    is_core: true
+    # spec 4.1: the TRUE object, never the counterfactual edit target
+    object_field: requested_rewrite.target_true.str
+    object_id_field: requested_rewrite.target_true.id
+    subject_field: requested_rewrite.subject
+    relation_field: requested_rewrite.relation_id
+    cloze: native            # the dataset ships its own prompt template
+
+  lama_trex:
+    path: lama/data/TREx/*.jsonl
+    format: jsonl
+    expected_triples: 34039
+    is_core: true
+    subject_field: sub_label
+    subject_id_field: sub_uri
+    relation_field: predicate_id
+    object_field: obj_label
+    object_id_field: obj_uri
+    cloze: relations_jsonl_template     # lama/data/relations.jsonl, cut at [Y]
+
+  lama_googlere:
+    path: lama/data/Google_RE/*.jsonl
+    format: jsonl
+    expected_triples: 5528
+    is_core: false
+    subject_field: sub_label
+    relation_field: pred            # last path segment
+    object_field: obj_label
+    alias_fields: [sub_aliases, obj_aliases]
+    cloze: handwritten
+    templates:
+      place_of_birth: "{s} was born in"
+      place_of_death: "{s} died in"
+      date_of_birth: "{s} was born in the year"
+
+  lama_conceptnet:
+    path: lama/data/ConceptNet/*.jsonl
+    format: jsonl
+    expected_triples: 28914
+    is_core: false
+    subject_field: sub_label
+    relation_field: pred
+    object_field: obj_label
+    cloze: masked_sentence          # masked_sentences[0], cut at [MASK]
+
+  t_rex:
+    path: trex/*.jsonl
+    format: jsonl
+    expected_triples: 1592952
+    is_core: false
+    subject_field: head
+    relation_field: relation        # natural-language template with brackets
+    object_field: tail
+    cloze: bracket_template
+    # spec 4.5: dropped after consensus filtering (pass rate 0.17%)
+    drop_after_consensus: true
+
+  wikidata5m:
+    path: wikidata5m/extracted/wikidata5m_all_triplet.txt
+    format: tsv
+    expected_triples: 21354359
+    is_core: false
+    cloze: generic                  # "{subject} {relation}"
+    # spec 4.3: strided down to ~100k prompts before model filtering
+    sample:
+      method: stride
+      target_prompts: 100000
+      actual_prompts: 100189
+    drop_after_consensus: true
+
+  popqa:
+    path: hf_cache/hub/datasets--akariasai--PopQA/snapshots/*/test.tsv
+    format: tsv
+    is_core: true
+    # spec 4.1 / 4.5: added AFTER the initial consensus stage, then run through
+    # the identical five-model first-token protocol
+    added_after_consensus: true
+    expected_prompts: 14149
+    expected_passed: 378
+    alias_fields: [s_aliases, o_aliases, possible_answers]
+
+# Aggregate expectations (spec section 1)
+expected:
+  raw_triples_total: 23038571
+  cloze_prompts: 1783541
+  five_model_consensus: 10601
+  candidate_known: 8107
+
+alias_resources:
+  wikidata_entity_aliases: wikidata5m/extracted/wikidata5m_alias/wikidata5m_entity.txt
+  # spec 5.3: scan once, keep only the QIDs the candidate set needs
+  scan_mode: filtered_single_pass
+  max_aliases_per_entity: 16
+  # crowd-sourced alias lists carry Wikipedia housekeeping titles and ISO codes
+  junk_patterns:
+    - "^list of "
+    - "^books?/"
+    - "^number of "
+    - "^category:"
+    - "^template:"
+    - "^wikipedia:"
+    - "^iso \\d"
+    - "^portal:"
+    - "^index of "
+    - "^outline of "
+    - "\\(disambiguation\\)"
+    - "/"
+  min_alias_chars: 2

ICLR dataset/evaluation_queries_44416.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e50fdc64b962a1f4a532f7b72e62a04f67d363ba80e58f000f4985dcdb1f1c8
+size 41495062

ICLR dataset/metrics/bcs_bes.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+"""BCS and BES from the judge's semantic clusters.   (protocol 4, 5, 6)
+
+    python src/bcs_bes.py --model Llama-3.2-1B
+
+Family-balanced, per protocol 4.1: the distribution over answer clusters is
+computed WITHIN each condition family first, then the families are averaged with
+equal weight. Counting raw queries instead would let paraphrase (10,053) and
+multilingual (12,010) drown out anchor (2,592), and the headline number would
+mostly measure how many variants we happened to write.
+
+    p(a) = mean over families of  (share of that family's queries in cluster a)
+    BCS  = max_a p(a)
+    BES  = 1 - H(p)/log A      (1 when only one cluster was observed)
+
+BCS deliberately does not consult correctness: a model that answers "Sydney" for
+every phrasing of Australia's capital scores BCS = 1. That is the point --
+protocol 6 then splits stable behaviour into Stable Correct and Stable Wrong
+using the judge's reference-aware pass.
+"""
+import os, sys, math, argparse, collections
+
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+
+
+def bcs_bes(assignments, families):
+    """assignments: [(condition_family, cluster_id)] for one fact."""
+    counts = collections.defaultdict(collections.Counter)
+    for fam, cid in assignments:
+        counts[fam][cid] += 1
+    valid = [t for t in families if counts[t]]
+    if not valid:
+        return None
+    clusters = {c for t in valid for c in counts[t]}
+    p = {c: sum(counts[t][c] / sum(counts[t].values()) for t in valid) / len(valid)
+         for c in clusters}
+    modal = max(p, key=p.get)
+    pos = [v for v in p.values() if v > 0]
+    if len(pos) == 1:
+        bes = 1.0
+    else:
+        H = -sum(v * math.log(v) for v in pos)
+        bes = 1.0 - H / math.log(len(pos))
+    return {"bcs": p[modal], "bes": bes, "modal_cluster": modal,
+            "cluster_distribution": p, "valid_families": valid}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
+    ap.add_argument("--sample", type=int, default=0,
+                    help="score only the same fixed subset judge_run.py sampled")
+    ap.add_argument("--sample-seed", type=int, default=20260101)
+    args = ap.parse_args()
+
+    C = mc.cfg()
+    mode = args.coverage or C["headline_coverage"]
+    fams = C["main_families"]
+    tau = C["behavior"]["tau_b"]
+    keep = set(mc.eval_fact_set(mode))
+    if args.sample:
+        # Reproduce judge_run.py's draw exactly. A judge file can hold extra
+        # facts -- a debug run, or a --resume over an earlier partial pass --
+        # and scoring whatever happens to be in the file would give different
+        # models different fact sets, which protocol 1.3 forbids.
+        allf = sorted(mc.facts())
+        rng = np.random.default_rng(args.sample_seed)
+        pick = set(np.array(allf)[rng.choice(len(allf), size=args.sample,
+                                             replace=False)].tolist())
+        keep &= pick
+    rel_of = mc.fact_relation()
+
+    jpath = mc.out("metrics", "judge", f"{args.model}.jsonl")
+    if not os.path.exists(jpath):
+        raise SystemExit(f"no judge output for {args.model}; run src/judge_run.py")
+
+    per_fact, groups = [], collections.Counter()
+    for rec in mc.read_jsonl(jpath):
+        fid = rec["fact_id"]
+        if fid not in keep:
+            continue
+        label = {c["cluster_id"]: c for c in rec["clusters"]}
+        res = bcs_bes([(a["condition_family"], a["cluster_id"])
+                       for a in rec["assignments"]], fams)
+        if res is None:
+            continue
+        modal = label.get(res["modal_cluster"], {})
+        correctness = modal.get("correctness", "REVIEW_REQUIRED")
+        status = modal.get("status", "ANSWER")
+        # Protocol 6: the four behaviour groups partition the fact set, so every
+        # fact lands in exactly one and the four rates sum to 1.
+        if res["bcs"] < tau:
+            grp = "Unstable"
+        elif status == "ABSTAIN" or correctness == "ABSTAIN":
+            grp = "Stable Abstention"
+        elif correctness == "CORRECT":
+            grp = "Stable Correct"
+        elif correctness == "INCORRECT":
+            grp = "Stable Wrong"
+        else:
+            grp = "Stable Unresolved"
+        groups[grp] += 1
+        per_fact.append({"model": args.model, "fact_id": fid, "relation": rel_of[fid],
+                         "bcs": res["bcs"], "bes": res["bes"],
+                         "modal_cluster": res["modal_cluster"],
+                         "modal_correctness": correctness, "behavior_group": grp,
+                         "valid_families": res["valid_families"]})
+
+    if not per_fact:
+        raise SystemExit(f"{args.model}: no facts scored")
+    mc.write_jsonl(mc.out("metrics", "behavioral", f"{args.model}.{mode}.per_fact.jsonl"),
+                   per_fact)
+
+    n = len(per_fact)
+    bs = C["bootstrap"]
+    boot_bcs = mc.relation_clustered_bootstrap(
+        {r["fact_id"]: r["bcs"] for r in per_fact}, rel_of,
+        bs["n_resamples"], bs["seed"], bs["ci"])
+    boot_bes = mc.relation_clustered_bootstrap(
+        {r["fact_id"]: r["bes"] for r in per_fact}, rel_of,
+        bs["n_resamples"], bs["seed"], bs["ci"])
+
+    # Protocol 6: threshold sensitivity, because tau_b = 0.8 is a choice.
+    sens = {}
+    for t in C["behavior"]["tau_sensitivity"]:
+        sens[str(t)] = {"stable_rate": float(np.mean([r["bcs"] >= t for r in per_fact])),
+                        "stable_correct": float(np.mean(
+                            [r["bcs"] >= t and r["modal_correctness"] == "CORRECT"
+                             for r in per_fact]))}
+
+    summary = {
+        "model": args.model, "coverage_mode": mode, "n_facts": n, "tau_b": tau,
+        "bcs": boot_bcs["mean"], "bcs_ci95": [boot_bcs["lo"], boot_bcs["hi"]],
+        "bes": boot_bes["mean"], "bes_ci95": [boot_bes["lo"], boot_bes["hi"]],
+        "stable_correct_rate": groups["Stable Correct"] / n,
+        "stable_wrong_rate": groups["Stable Wrong"] / n,
+        "stable_abstention_rate": groups["Stable Abstention"] / n,
+        "stable_unresolved_rate": groups["Stable Unresolved"] / n,
+        "unstable_rate": groups["Unstable"] / n,
+        "behavior_counts": dict(groups),
+        "tau_sensitivity": sens,
+    }
+    tot = sum(summary[k] for k in ("stable_correct_rate", "stable_wrong_rate",
+                                   "stable_abstention_rate", "stable_unresolved_rate",
+                                   "unstable_rate"))
+    if abs(tot - 1.0) > 1e-6:
+        raise SystemExit(f"behaviour rates sum to {tot}, not 1 (protocol 6)")
+    mc.write_json(mc.out("metrics", "behavioral", f"{args.model}.{mode}.summary.json"),
+                  summary)
+    print(f"[{args.model}] BCS={summary['bcs']:.4f} BES={summary['bes']:.4f} "
+          f"SC={summary['stable_correct_rate']:.3f} SW={summary['stable_wrong_rate']:.3f} "
+          f"SA={summary['stable_abstention_rate']:.3f} "
+          f"U={summary['unstable_rate']:.3f}  n={n}  BCSBES_DONE")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/extract_hidden.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+"""Query-end residual states for the main-forward queries.   [GPU]
+
+    python src/extract_hidden.py --model Llama-3.2-1B
+
+Protocol 2.4 fixes the probe position:
+
+    the last valid input token -- the model has read the question but has not
+    yet emitted an answer token
+
+which is exactly the prefill position that produces the first generated token
+in eval_run.py. The prompt string is therefore built by importing eval_run's own
+`build_prompt`, not by re-deriving it here: if the two ever diverged, ISS would
+be measured on a different question than BCS/BES, and nothing downstream would
+notice.
+
+Only decoder blocks inside the J-Lens analysis window (protocol 7.10,
+d_l = l/(L-1) >= 0.4) are stored. Layer `l` is the OUTPUT of block l, so the
+last stored layer, l = L-1, is the final residual stream that J-Lens transports
+into.
+
+Output, per model:
+
+    outputs/hidden/<model>/L###.npy    float16 [n_queries, d]
+    outputs/hidden/<model>/index.json  query order + layer list + checksums
+"""
+import os, sys, json, time, argparse, hashlib
+
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+
+# eval_run.py owns the prompt format; import it so there is exactly one copy.
+sys.path.insert(0, mc.ds3("src"))
+from eval_run import build_prompt          # noqa: E402
+
+
+def decoder_layers(model):
+    """The block list, across Llama / Qwen2 / Mistral / Gemma2 / OLMo2."""
+    for attr in ("model.layers", "model.decoder.layers", "transformer.h"):
+        obj = model
+        try:
+            for part in attr.split("."):
+                obj = getattr(obj, part)
+            if isinstance(obj, torch.nn.ModuleList) and len(obj):
+                return obj
+        except AttributeError:
+            continue
+    raise SystemExit(f"cannot locate decoder blocks on {type(model).__name__}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--batch", type=int, default=0)
+    ap.add_argument("--limit", type=int, default=0, help="debug: first N queries")
+    ap.add_argument("--force", action="store_true")
+    args = ap.parse_args()
+
+    conf = mc.cfg()["extraction"]
+    entry = mc.model_entry(args.model)
+    dest = mc.out("hidden", args.model)
+    os.makedirs(dest, exist_ok=True)
+    index_path = os.path.join(dest, "index.json")
+    if os.path.exists(index_path) and not args.force:
+        if json.load(open(index_path)).get("complete"):
+            print(f"[{args.model}] already extracted; --force to redo")
+            return
+
+    rows = mc.main_forward_queries()
+    if args.limit:
+        rows = rows[:args.limit]
+    N = len(rows)
+
+    path = mc.model_path(args.model)
+    tok = AutoTokenizer.from_pretrained(path)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    # Left padding is what makes position -1 the last REAL token for every row
+    # in a ragged batch; with right padding it would be a pad token.
+    tok.padding_side = "left"
+    tok.truncation_side = "left"
+    model = AutoModelForCausalLM.from_pretrained(
+        path, dtype=torch.bfloat16, device_map={"": 0}).eval()
+
+    blocks = decoder_layers(model)
+    L = len(blocks)
+    if L != entry.get("n_layers", L):
+        raise SystemExit(f"{args.model}: config.json has {L} layers but "
+                         f"models.yaml says {entry['n_layers']}")
+    d = int(model.config.hidden_size)
+    window = mc.layer_window(L)
+    if len(window) != entry.get("jlens_window", len(window)):
+        raise SystemExit(f"{args.model}: computed window {len(window)} layers "
+                         f"but models.yaml says {entry['jlens_window']}")
+    print(f"[{args.model}] L={L} d={d} window={window[0]}..{window[-1]} "
+          f"({len(window)} layers)  N={N}", flush=True)
+
+    stores = {l: np.lib.format.open_memmap(
+        os.path.join(dest, f"L{l:03d}.npy"), mode="w+",
+        dtype=np.float16, shape=(N, d)) for l in window}
+
+    grabbed = {}
+
+    def make_hook(l):
+        def hook(_module, _inp, output):
+            h = output[0] if isinstance(output, tuple) else output
+            # Detach immediately and keep only the probe position, otherwise the
+            # full [B, T, d] activation for every window layer stays alive.
+            grabbed[l] = h[:, -1, :].detach().float()
+        return hook
+
+    handles = [blocks[l].register_forward_hook(make_hook(l)) for l in window]
+
+    prompts = [build_prompt(r) for r in rows]
+    B = args.batch or conf["batch_size"]
+    max_len = conf["max_prompt_len"]
+    # Length-sorted batching keeps padding low; `order` maps back to row index.
+    order = sorted(range(N), key=lambda i: len(prompts[i]))
+    t0 = time.time()
+    with torch.no_grad():
+        for b in range(0, N, B):
+            idx = order[b:b + B]
+            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
+                      truncation=True, max_length=max_len).to(0)
+            grabbed.clear()
+            model(**enc, use_cache=False)
+            for l in window:
+                stores[l][idx] = grabbed[l].to(torch.float16).cpu().numpy()
+            if b % (B * 40) == 0:
+                done = b + len(idx)
+                print(f"  {done}/{N}  {done / max(time.time() - t0, 1e-9):.1f}/s",
+                      flush=True)
+    for h in handles:
+        h.remove()
+    for l in window:
+        stores[l].flush()
+
+    meta = {
+        "model": args.model,
+        "complete": True,
+        "n_queries": N,
+        "n_layers": L,
+        "d_model": d,
+        "window": window,
+        "window_depths": [round(l / max(L - 1, 1), 4) for l in window],
+        "late_window": mc.late_window(L),
+        "position": conf["position"],
+        "dtype": "float16",
+        "max_prompt_len": max_len,
+        "batch_size": B,
+        "seconds": round(time.time() - t0, 1),
+        # The query order is the contract between this file and every consumer;
+        # the hash lets a consumer prove it is reading the same ordering.
+        "query_ids": [r["query_id"] for r in rows],
+        "fact_ids": [r["fact_id"] for r in rows],
+        "families": [r["condition_family"] for r in rows],
+        "query_order_sha256": hashlib.sha256(
+            "\n".join(r["query_id"] for r in rows).encode()).hexdigest(),
+    }
+    mc.write_json(index_path, meta)
+    gb = N * len(window) * d * 2 / 1e9
+    print(f"[{args.model}] wrote {len(window)} layers x {N} x {d}  "
+          f"({gb:.1f} GB)  {meta['seconds']}s  EXTRACT_DONE", flush=True)
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/iss.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+"""ISS: Internal State Stability.   (protocol 7, J-Lens spec 10)
+
+    python src/iss.py --model Llama-3.2-1B --transport raw     # ablation
+    python src/iss.py --model Llama-3.2-1B --transport jlens   # official
+
+The state preparation (transport -> residualise -> whiten -> family centroid)
+lives in states.py so that ISS and KTS provably score the same vectors. What is
+here is only the ISS-specific part:
+
+    S+  same fact, across condition-family pairs
+    S-  same relation, different fact, symmetric in the family pair
+    ISS = (S+ - S-) / (1 - S- + eps)
+
+Raw-ISS is NOT the official metric (J-Lens spec 11). It exists to prove the
+data loading, family aggregation and negative sampling are right before the
+Jacobian transport is layered on top (spec 21, step 1).
+"""
+import os, sys, time, argparse
+
+import numpy as np
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+from states import StateLoader
+
+
+def iss_one_layer(V, mask, by_rel, negatives, eps):
+    """S+, S- and ISS for every fact at one layer."""
+    F, T, _ = V.shape
+    dev = V.device
+    s_pos = torch.zeros(F, device=dev)
+    s_neg = torch.zeros(F, device=dev)
+    n_pos = torch.zeros(F, device=dev)
+    n_neg = torch.zeros(F, device=dev)
+    zero = torch.zeros(F, device=dev)
+
+    for t in range(T):
+        for u in range(t + 1, T):
+            both = mask[:, t] & mask[:, u]
+            if not bool(both.any()):
+                continue
+            s_pos += torch.where(both, (V[:, t] * V[:, u]).sum(-1), zero)
+            n_pos += both.float()
+
+            # Protocol 7.8: same-relation background, symmetrised over the pair
+            # so a family that sits globally closer to everything cannot inflate
+            # the score. Done per relation to keep each similarity block small.
+            for members in by_rel.values():
+                idx = [i for i in members if bool(both[i])]
+                if len(idx) < 2:
+                    continue
+                ii = torch.tensor(idx, device=dev)
+                Sab = V[ii, t] @ V[ii, u].T
+                pos = {f: j for j, f in enumerate(idx)}
+                for f in idx:
+                    negs = [pos[g] for g in negatives[f] if g in pos]
+                    if not negs:
+                        continue
+                    jj = torch.tensor(negs, device=dev)
+                    j0 = pos[f]
+                    s_neg[f] += 0.5 * (Sab[j0, jj].mean() + Sab[jj, j0].mean())
+                    n_neg[f] += 1
+
+    sp = s_pos / n_pos.clamp_min(1)
+    sn = s_neg / n_neg.clamp_min(1)
+    return sp, sn, (sp - sn) / (1.0 - sn + eps), (n_pos > 0) & (n_neg > 0)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
+    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
+    ap.add_argument("--device", default="auto")
+    ap.add_argument("--shuffle-seed", type=int, default=None,
+                    help="protocol 18.1 control: destroy fact identity; ISS must collapse")
+    args = ap.parse_args()
+
+    C = mc.cfg()
+    icfg = C["iss"]
+    eps = float(icfg["eps"])
+    S = StateLoader(args.model, args.transport, args.coverage, args.device,
+                    shuffle_seed=args.shuffle_seed)
+
+    negatives = mc.negative_sample(S.keep_facts, S.rel_of,
+                                   icfg["max_negatives"], icfg["negative_seed"])
+    negatives = {S.fidx[f]: [S.fidx[g] for g in gs] for f, gs in negatives.items()}
+
+    F = S.n_facts
+    per_layer, t0 = {}, time.time()
+    for l in S.window:
+        V, mask = S.centroids(l)
+        sp, sn, iss, valid = iss_one_layer(V, mask, S.by_rel, negatives, eps)
+        per_layer[l] = {"s_pos": sp.cpu().numpy(), "s_neg": sn.cpu().numpy(),
+                        "iss": iss.cpu().numpy(), "valid": valid.cpu().numpy()}
+        print(f"  L{l:03d}  ISS={float(iss[valid].mean()):+.4f}  "
+              f"S+={float(sp[valid].mean()):.4f}  S-={float(sn[valid].mean()):.4f}",
+              flush=True)
+        del V, mask
+        if S.dev == "cuda":
+            torch.cuda.empty_cache()
+
+    # ---- protocol 7.10: window mean, peak, late
+    stack = np.stack([per_layer[l]["iss"] for l in S.window])
+    vmask = np.stack([per_layer[l]["valid"] for l in S.window])
+    stack = np.where(vmask, stack, np.nan)
+    late_rows = [i for i, l in enumerate(S.window) if l in S.late]
+    with np.errstate(invalid="ignore"):
+        iss_f = np.nanmean(stack, axis=0)
+        peak_f = np.nanmax(stack, axis=0)
+        late_f = np.nanmean(stack[late_rows], axis=0) if late_rows else np.full(F, np.nan)
+
+    rows = [{"model": args.model, "transport": args.transport, "fact_id": f,
+             "relation": S.rel_of[f], "iss": float(iss_f[i]),
+             "iss_peak": float(peak_f[i]), "iss_late": float(late_f[i]),
+             "layers_used": S.window}
+            for i, f in enumerate(S.keep_facts) if np.isfinite(iss_f[i])]
+
+    tag = f"{args.model}.{args.transport}.{S.mode}"
+    if args.shuffle_seed is not None:
+        tag += f".shuffled{args.shuffle_seed}"
+    mc.write_jsonl(mc.out("metrics", "iss", f"{tag}.per_fact.jsonl"), rows)
+    mc.write_jsonl(mc.out("metrics", "iss", f"{tag}.per_fact_layer.jsonl"),
+                   [{"model": args.model, "transport": args.transport,
+                     "fact_id": f, "layer": l,
+                     "iss": float(per_layer[l]["iss"][i]),
+                     "s_positive": float(per_layer[l]["s_pos"][i]),
+                     "s_background": float(per_layer[l]["s_neg"][i])}
+                    for l in S.window for i, f in enumerate(S.keep_facts)
+                    if per_layer[l]["valid"][i]])
+
+    vals = {r["fact_id"]: r["iss"] for r in rows}
+    boot = mc.relation_clustered_bootstrap(
+        vals, S.rel_of, C["bootstrap"]["n_resamples"], C["bootstrap"]["seed"],
+        C["bootstrap"]["ci"])
+    summary = {
+        "model": args.model, "transport": args.transport, "coverage_mode": S.mode,
+        "official": args.transport == "jlens" and args.shuffle_seed is None,
+        "shuffle_control": args.shuffle_seed is not None,
+        "n_facts": len(rows), "layers": S.window,
+        "iss": boot["mean"], "iss_ci95": [boot["lo"], boot["hi"]],
+        "iss_peak": float(np.nanmean(peak_f)), "iss_late": float(np.nanmean(late_f)),
+        "s_positive": float(np.nanmean([per_layer[l]["s_pos"] for l in S.window])),
+        "s_background": float(np.nanmean([per_layer[l]["s_neg"] for l in S.window])),
+        "per_layer_iss": {str(l): float(np.nanmean(np.where(
+            per_layer[l]["valid"], per_layer[l]["iss"], np.nan))) for l in S.window},
+        "seconds": round(time.time() - t0, 1),
+    }
+    mc.write_json(mc.out("metrics", "iss", f"{tag}.summary.json"), summary)
+    print(f"[{args.model}] {args.transport}-ISS = {boot['mean']:+.4f} "
+          f"[{boot['lo']:+.4f},{boot['hi']:+.4f}]  n={len(rows)}  ISS_DONE", flush=True)
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/jlens.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python
+"""J-Lens: randomized factorized estimate of the layer-to-final Jacobian.  [GPU]
+
+    python src/jlens.py --model Llama-3.2-1B --rank 256
+    python src/jlens.py --model Llama-3.2-1B --validate      # spec 7.1 action check
+
+Official transport (J-Lens spec 1):
+
+    z^l = J^l h^l,    J^l = E_{x~C}[ d h^L(x) / d h^l(x) ]
+
+with NO unembedding matrix -- the metric lives in the final-layer residual
+basis, not in vocabulary space.
+
+d x d is unaffordable at d = 5120, so spec 6 prescribes randomized range
+finding:
+
+    Y = J Omega   (JVPs)        Q = qr(Y)
+    B = Q^T J     (VJPs)        Jhat = Q B
+
+and spec 6.4 says to store only Q and B. Downstream we only ever take cosines,
+and Q is orthonormal, so cos(Q y1, Q y2) = cos(y1, y2) -- iss.py consumes
+y = B h directly in r dimensions.
+
+--- how the per-example Jacobian is taken -------------------------------------
+
+J_x is the Jacobian of the map
+
+    h^l at the last position  ->  h^L at the last position
+
+holding the prefix fixed. Attention is causal, so perturbing the last position's
+residual cannot change any earlier position: the prefix KV cache computed once
+is exactly right, and the map can be evaluated by a single-token decode step
+with a hook that substitutes h at block l. That costs one token through the
+blocks instead of a full re-prefill, and it goes through the stock HF decode
+path, so it stays correct for Llama / Qwen2 / Mistral / Gemma2 (sliding window,
+logit softcap) / OLMo2 alike without per-architecture code.
+
+Tangents are batched along the batch dimension: the map is block-diagonal across
+batch rows, so one jvp call returns J_x v_i for as many probe columns as fit.
+"""
+import os, sys, json, time, argparse, copy
+
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+from extract_hidden import decoder_layers
+
+
+# --------------------------------------------------------------- calibration
+def calibration_prompts(tok, n, seq_len, seed):
+    """Spec 13.1: general text, independent of the factual benchmark.
+
+    Every model sees the same document slice and the same token count, so the
+    corpus contributes no cross-model variation (spec 8.1: "same construction
+    rule for all models").
+    """
+    from datasets import load_dataset
+    ds = load_dataset("NeelNanda/pile-10k", split="train")
+    rng = np.random.default_rng(seed)
+    picks = rng.choice(len(ds), size=min(4 * n, len(ds)), replace=False)
+    out, used = [], []
+    for i in picks:
+        ids = tok(ds[int(i)]["text"], return_tensors="pt",
+                  truncation=True, max_length=seq_len)["input_ids"][0]
+        if ids.numel() < seq_len:
+            continue                       # fixed length only (spec 8.1)
+        out.append(ids[:seq_len])
+        used.append(int(i))
+        if len(out) == n:
+            break
+    if len(out) < n:
+        raise SystemExit(f"only {len(out)}/{n} calibration prompts reached {seq_len} tokens")
+    return torch.stack(out), used
+
+
+FP32_BUDGET_GB = 110.0     # of the 143 GB H200, leaving room for activations
+
+
+def pick_dtype(name, requested="auto"):
+    """float32 wherever the weights fit, bfloat16 only when they cannot.
+
+    Measured on Qwen2.5-0.5B, a bf16 JVP agrees with the fp32 one to
+    cos >= 0.996 but with 1-8% relative error, worst at early layers -- above
+    the 0.05 action-error threshold the J-Lens spec (7.3) sets for accepting an
+    estimator. Corpus averaging suppresses most of that, but it is cheaper to
+    avoid the noise than to argue about it, so fp32 is the default and the
+    fallback is recorded in metadata for the uncertainty report (spec 18).
+    """
+    if requested != "auto":
+        return getattr(torch, requested)
+    params_b = float(mc.model_entry(name).get("params_b", 0) or 0)
+    return torch.float32 if params_b * 4.0 < FP32_BUDGET_GB else torch.bfloat16
+
+
+def load_for_jacobian(name, dtype="auto"):
+    """Eager attention is mandatory here.
+
+    The fused SDPA/flash kernels have no double-backward rule, and the JVP below
+    is reverse-over-reverse. Eager attention is slower but it is the only
+    implementation that differentiates twice. Generation and hidden-state
+    extraction are unaffected -- they never take a second derivative.
+    """
+    dt = pick_dtype(name, dtype)
+    path = mc.model_path(name)
+    tok = AutoTokenizer.from_pretrained(path)
+    model = AutoModelForCausalLM.from_pretrained(
+        path, dtype=dt, device_map={"": 0}, attn_implementation="eager").eval()
+    for prm in model.parameters():
+        prm.requires_grad_(False)
+    return model, tok
+
+
+def _cache_tensors(cache):
+    """The K/V tensor slots of a Cache, across the layouts transformers uses."""
+    slots = []
+    if getattr(cache, "layers", None):
+        for lay in cache.layers:
+            for attr in ("keys", "values"):
+                if getattr(lay, attr, None) is not None:
+                    slots.append((lay, attr))
+    for attr in ("key_cache", "value_cache"):
+        seq = getattr(cache, attr, None)
+        if seq is not None:
+            for i in range(len(seq)):
+                slots.append((seq, i))
+    return slots
+
+
+def _expand_cache(cache, b):
+    """Replicate a batch-1 prefix cache to batch b without re-running the prefix."""
+    c = copy.deepcopy(cache)
+    for holder, key in _cache_tensors(c):
+        t = holder[key] if isinstance(key, int) else getattr(holder, key)
+        t = t.expand(b, *t.shape[1:]).contiguous()
+        if isinstance(key, int):
+            holder[key] = t
+        else:
+            setattr(holder, key, t)
+    return c
+
+
+class TailMap:
+    """h^l(last position) -> h^L(last position), prefix held fixed.
+
+    Causal attention is what makes this well defined: the last position cannot
+    influence earlier ones, so the prefix KV computed once is exactly correct
+    however h^l is perturbed.
+    """
+
+    def __init__(self, model, blocks, layer, ids):
+        self.model, self.blocks, self.layer = model, blocks, layer
+        self.n_layers = len(blocks)
+        self.sub = None          # tensor substituted at block `layer`
+        self.final = None
+        with torch.no_grad():
+            pre = model(input_ids=ids[:, :-1].to(model.device), use_cache=True)
+        self.prefix = pre.past_key_values
+        self.last = ids[:, -1:].to(model.device)
+        self._install()
+
+    def _install(self):
+        def sub_hook(_m, _i, output):
+            if self.sub is None:
+                return output
+            tup = isinstance(output, tuple)
+            h = output[0] if tup else output
+            # Rebuild rather than index-assign: the substituted row carries the
+            # autograd graph and an in-place write into a non-leaf bf16 buffer
+            # is both fragile and unnecessary here (sequence length is 1).
+            h = self.sub.to(h.dtype).unsqueeze(1)
+            return (h,) + tuple(output[1:]) if tup else h
+
+        def grab_hook(_m, _i, output):
+            h = output[0] if isinstance(output, tuple) else output
+            self.final = h[:, -1, :]
+
+        self.h1 = self.blocks[self.layer].register_forward_hook(sub_hook)
+        self.h2 = self.blocks[self.n_layers - 1].register_forward_hook(grab_hook)
+
+    def close(self):
+        self.h1.remove()
+        self.h2.remove()
+
+    def baseline(self):
+        """h^l at the last position, unperturbed -- the expansion point."""
+        got = {}
+
+        def hook(_m, _i, output):
+            h = output[0] if isinstance(output, tuple) else output
+            got["h"] = h[:, -1, :].detach().clone()
+        hd = self.blocks[self.layer].register_forward_hook(hook)
+        self.sub = None
+        with torch.no_grad():
+            self._decode(1)
+        hd.remove()
+        return got["h"]
+
+    def _decode(self, batch):
+        cache = _expand_cache(self.prefix, batch) if batch > 1 \
+            else copy.deepcopy(self.prefix)
+        self.model(input_ids=self.last.expand(batch, 1),
+                   past_key_values=cache, use_cache=True)
+        return self.final
+
+    def __call__(self, h):
+        """h: [b, d] -> [b, d]. Differentiable in reverse mode."""
+        self.sub = h
+        try:
+            return self._decode(h.shape[0])
+        finally:
+            self.sub = None
+
+
+def jvp(f, x, v):
+    """J v via double backward.
+
+    torch.func.jvp cannot be used here: forward-mode duals do not survive the
+    module hooks that substitute the residual, and the model runs in bfloat16.
+    The double-backward identity d/du (J^T u) . v = J v needs only reverse mode,
+    which the hooks handle natively.
+    """
+    x = x.detach().requires_grad_(True)
+    y = f(x)
+    u = torch.zeros_like(y, requires_grad=True)
+    (g,) = torch.autograd.grad(y, x, grad_outputs=u, create_graph=True)
+    (out,) = torch.autograd.grad(g, u, grad_outputs=v)
+    return out
+
+
+def probes(d, r, seed, device):
+    """Nested Gaussian probes: spec 5.3 requires rank k's directions to be a
+    prefix of rank 2k's, so a rank sweep is a genuine refinement rather than an
+    unrelated redraw."""
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    return torch.randn(d, r, generator=g).to(device)
+
+
+def estimate(model, blocks, layer, corpus, r, seed, chunk, device):
+    """Y = E_x[J_x Omega] then Q = qr(Y); B^T = E_x[J_x^T Q]."""
+    d = model.config.hidden_size
+    Om = probes(d, r, seed, device)
+    Y = torch.zeros(d, r, device=device, dtype=torch.float32)
+
+    maps = []
+    for ids in corpus:
+        tm = TailMap(model, blocks, layer, ids.unsqueeze(0))
+        maps.append(tm)
+
+    for tm in maps:
+        h0 = tm.baseline().float()
+        for s in range(0, r, chunk):
+            v = Om[:, s:s + chunk].T.contiguous()               # [b, d]
+            base = h0.expand(v.shape[0], d).contiguous()
+            Y[:, s:s + chunk] += jvp(lambda x: tm(x).float(), base, v).T.float()
+    Y /= len(maps)
+    Q, _ = torch.linalg.qr(Y.double())
+    Q = Q.float()                                               # [d, r]
+
+    Bt = torch.zeros(d, r, device=device, dtype=torch.float32)
+    for tm in maps:
+        h0 = tm.baseline().float()
+        for s in range(0, r, chunk):
+            w = Q[:, s:s + chunk].T.contiguous()
+            b = w.shape[0]
+            base = h0.expand(b, d).contiguous().requires_grad_(True)
+            outp = tm(base).float()
+            gr = torch.autograd.grad(outp, base, grad_outputs=w.float())[0]
+            Bt[:, s:s + chunk] += gr.T.float()
+    Bt /= len(maps)
+    for tm in maps:
+        tm.close()
+    return Q, Bt.T.contiguous()                                 # Q [d,r], B [r,d]
+
+
+def direct_action(model, blocks, layer, corpus, H, device):
+    """u_i = J h_i computed directly (spec 7.1) -- the validation reference.
+
+    Needs no d x d matrix: it is one JVP per held-out activation, averaged over
+    the same calibration corpus the estimator used.
+    """
+    d = model.config.hidden_size
+    U = torch.zeros(H.shape[0], d, device=device, dtype=torch.float32)
+    for ids in corpus:
+        tm = TailMap(model, blocks, layer, ids.unsqueeze(0))
+        h0 = tm.baseline().float()
+        for s in range(0, H.shape[0], 16):
+            v = H[s:s + 16].to(device).float()
+            base = h0.expand(v.shape[0], d).contiguous()
+            U[s:s + 16] += jvp(lambda x: tm(x).float(), base, v).float()
+        tm.close()
+    return U / len(corpus)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--rank", type=int, default=256)
+    ap.add_argument("--seed", type=int, default=None)
+    ap.add_argument("--layers", nargs="*", type=int, default=None)
+    ap.add_argument("--n-prompts", type=int, default=None)
+    ap.add_argument("--chunk", type=int, default=32, help="probe columns per jvp call")
+    ap.add_argument("--dtype", default="auto", choices=["auto", "float32", "bfloat16"])
+    ap.add_argument("--validate", action="store_true",
+                    help="spec 7.1 direct-action check on held-out activations")
+    args = ap.parse_args()
+
+    C = mc.cfg()["jlens"]
+    seed = args.seed if args.seed is not None else C["estimator"]["primary_seed"]
+    n_prompts = args.n_prompts or C["corpus"]["n_prompts"]
+    p = C["estimator"]["oversampling"]
+    r = args.rank + p
+    device = "cuda"
+
+    model, tok = load_for_jacobian(args.model, args.dtype)
+    compute_dtype = str(next(model.parameters()).dtype).replace("torch.", "")
+    blocks = decoder_layers(model)
+    L, d = len(blocks), int(model.config.hidden_size)
+    if r > d:
+        r = d
+    window = args.layers if args.layers else mc.layer_window(L)
+
+    corpus, used = calibration_prompts(tok, n_prompts, C["corpus"]["seq_len"],
+                                       C["corpus"]["seed"])
+    print(f"[{args.model}] d={d} L={L} rank={args.rank}+{p}={r} "
+          f"corpus={n_prompts}x{C['corpus']['seq_len']} layers={len(window)}", flush=True)
+
+    for l in window:
+        t0 = time.time()
+        Q, B = estimate(model, blocks, l, corpus, r, seed, args.chunk, device)
+        dest = mc.out("jlens", args.model, f"L{l:03d}")
+        np.save(os.path.join(dest, "Q.npy"), Q.cpu().numpy().astype(np.float32))
+        np.save(os.path.join(dest, "B.npy"), B.cpu().numpy().astype(np.float32))
+        meta = {"model": args.model, "layer": l, "hidden_dimension": d,
+                "rank": args.rank, "oversampling": p, "stored_rank": r,
+                "power_iterations": C["estimator"]["power_iterations"],
+                "calibration_corpus": C["corpus"]["name"],
+                "calibration_corpus_size": n_prompts,
+                "calibration_sequence_length": C["corpus"]["seq_len"],
+                "calibration_sample_ids": used, "random_seed": seed,
+                "compute_dtype": compute_dtype,
+                "seconds": round(time.time() - t0, 1), "validated": None}
+        mc.write_json(os.path.join(dest, "metadata.json"), meta)
+        print(f"  L{l:03d}  Q{tuple(Q.shape)} B{tuple(B.shape)}  "
+              f"{meta['seconds']}s", flush=True)
+    print(f"[{args.model}] JLENS_DONE", flush=True)
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/joint.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+"""Do internal and external stability move together?   (protocol 12, 13.2)
+
+    python src/joint.py --transport raw
+
+Three levels, because they can disagree and each answers a different question:
+
+  1. ACROSS MODELS   Does a model with higher BCS also have higher ISS?
+                     n = number of evaluated models, so this is suggestive at
+                     best -- it is the weakest of the three.
+
+  2. WITHIN MODEL, ACROSS FACTS   Are the SAME facts unstable behaviourally and
+                     internally? This is the real test. A model can sit at the
+                     group mean while the two measures disagree completely
+                     fact by fact, and only this level would reveal it.
+
+  3. BY BEHAVIOUR GROUP   Protocol 13.2: mean ISS for Stable Correct vs Stable
+                     Wrong vs Stable Abstention vs Unstable. This is the table
+                     the paper needs, and it also separates the two ways a fact
+                     can be "stable": stably right and stably wrong should both
+                     show high ISS if internal state drives behaviour.
+
+Protocol 12 lists cells such as "BCS high / ISS low" -- consistent answers
+reached through inconsistent internal states. Reporting only a single pooled
+correlation would hide exactly those cases, so the per-model breakdown is
+printed even when the pooled number looks tidy.
+"""
+import os, sys, glob, json, argparse, collections
+
+import numpy as np
+from scipy.stats import spearmanr, pearsonr
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+
+GROUPS = ["Stable Correct", "Stable Wrong", "Stable Abstention",
+          "Stable Unresolved", "Unstable"]
+
+
+def load_pairs(model, transport, mode):
+    ip = mc.out("metrics", "iss", f"{model}.{transport}.{mode}.per_fact.jsonl")
+    bp = mc.out("metrics", "behavioral", f"{model}.{mode}.per_fact.jsonl")
+    if not (os.path.exists(ip) and os.path.exists(bp)):
+        return None
+    iss = {r["fact_id"]: r for r in mc.read_jsonl(ip)}
+    beh = {r["fact_id"]: r for r in mc.read_jsonl(bp)}
+    common = sorted(set(iss) & set(beh))
+    if len(common) < 20:
+        return None
+    return [{"fact_id": f, "relation": iss[f]["relation"],
+             "iss": iss[f]["iss"], "iss_late": iss[f]["iss_late"],
+             "bcs": beh[f]["bcs"], "bes": beh[f]["bes"],
+             "group": beh[f]["behavior_group"]} for f in common]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
+    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
+    args = ap.parse_args()
+
+    mode = args.coverage or mc.cfg()["headline_coverage"]
+    names = [m["name"] for m in mc.models_cfg()["evaluated_models"]]
+
+    per_model, model_level = {}, []
+    for m in names:
+        rows = load_pairs(m, args.transport, mode)
+        if rows is None:
+            continue
+        per_model[m] = rows
+        isum = json.load(open(mc.out("metrics", "iss",
+                                     f"{m}.{args.transport}.{mode}.summary.json")))
+        bsum = json.load(open(mc.out("metrics", "behavioral",
+                                     f"{m}.{mode}.summary.json")))
+        kp = mc.out("metrics", "kts", f"{m}.{args.transport}.{mode}.summary.json")
+        ksum = json.load(open(kp)) if os.path.exists(kp) else {}
+        model_level.append({
+            "model": m, "family": mc.model_entry(m).get("family"),
+            "params_b": mc.model_entry(m).get("params_b"),
+            "tuning": mc.model_entry(m).get("tuning"),
+            "iss": isum["iss"], "bcs": bsum["bcs"], "bes": bsum["bes"],
+            "kts": ksum.get("kts"), "kts_id": ksum.get("kts_id"),
+            "unstable_rate": bsum["unstable_rate"],
+            "stable_correct_rate": bsum["stable_correct_rate"],
+            "n_joined": len(rows)})
+
+    if not model_level:
+        raise SystemExit("no model has BOTH ISS and BCS/BES yet")
+
+    out = {"transport": args.transport, "coverage_mode": mode,
+           "n_models": len(model_level), "model_level": model_level}
+
+    # ---- level 1: across models
+    def corr(a, b):
+        a, b = np.asarray(a, float), np.asarray(b, float)
+        ok = np.isfinite(a) & np.isfinite(b)
+        if ok.sum() < 3:
+            return None
+        return {"spearman": float(spearmanr(a[ok], b[ok]).statistic),
+                "pearson": float(pearsonr(a[ok], b[ok]).statistic), "n": int(ok.sum())}
+
+    across = {}
+    for x in ("bcs", "bes", "unstable_rate", "stable_correct_rate"):
+        for y in ("iss", "kts", "kts_id"):
+            c = corr([r[x] for r in model_level], [r[y] for r in model_level])
+            if c:
+                across[f"{x}__{y}"] = c
+    out["across_models"] = across
+
+    # ---- level 2: within model, across facts
+    within, pooled = {}, []
+    for m, rows in per_model.items():
+        within[m] = {
+            "n_facts": len(rows),
+            "iss_vs_bcs": corr([r["iss"] for r in rows], [r["bcs"] for r in rows]),
+            "iss_vs_bes": corr([r["iss"] for r in rows], [r["bes"] for r in rows]),
+        }
+        # Standardise inside each model before pooling, otherwise the pooled
+        # correlation would mostly reflect between-model level differences
+        # rather than the within-model fact-by-fact association we are after.
+        for key in ("iss", "bcs"):
+            v = np.array([r[key] for r in rows], float)
+            sd = v.std() or 1.0
+            for r, z in zip(rows, (v - v.mean()) / sd):
+                r[f"z_{key}"] = float(z)
+        pooled += rows
+    out["within_model"] = within
+    out["pooled_within_model"] = corr([r["z_iss"] for r in pooled],
+                                      [r["z_bcs"] for r in pooled])
+
+    # ---- level 3: behaviour groups (protocol 13.2)
+    by_group = collections.defaultdict(list)
+    for m, rows in per_model.items():
+        for r in rows:
+            by_group[r["group"]].append(r["iss"])
+    out["iss_by_behavior_group"] = {
+        g: {"n": len(by_group[g]), "iss_mean": float(np.mean(by_group[g])),
+            "iss_sd": float(np.std(by_group[g]))}
+        for g in GROUPS if by_group[g]}
+    out["iss_by_behavior_group_per_model"] = {
+        m: {g: float(np.mean([r["iss"] for r in rows if r["group"] == g]))
+            for g in GROUPS if any(r["group"] == g for r in rows)}
+        for m, rows in per_model.items()}
+
+    mc.write_json(mc.out("metrics", f"joint_internal_external.{args.transport}.{mode}.json"),
+                  out)
+
+    # ------------------------------------------------------------ report
+    print(f"\n=== 1. ACROSS MODELS (n={len(model_level)}) ===")
+    print(f"{'pair':34s} {'Spearman':>9s} {'Pearson':>9s}")
+    for k, v in across.items():
+        print(f"{k:34s} {v['spearman']:>9.3f} {v['pearson']:>9.3f}")
+
+    print(f"\n=== 2. WITHIN MODEL, ACROSS FACTS ===")
+    print(f"{'model':30s} {'n':>5s} {'ISSvBCS':>8s} {'ISSvBES':>8s}")
+    for m, v in within.items():
+        a = v["iss_vs_bcs"]["spearman"] if v["iss_vs_bcs"] else float("nan")
+        b = v["iss_vs_bes"]["spearman"] if v["iss_vs_bes"] else float("nan")
+        print(f"{m:30s} {v['n_facts']:>5d} {a:>8.3f} {b:>8.3f}")
+    p = out["pooled_within_model"]
+    if p:
+        print(f"{'POOLED (z-scored per model)':30s} {p['n']:>5d} {p['spearman']:>8.3f}")
+
+    print(f"\n=== 3. ISS BY BEHAVIOUR GROUP (protocol 13.2) ===")
+    print(f"{'group':22s} {'facts':>7s} {'ISS mean':>9s} {'sd':>7s}")
+    for g, v in out["iss_by_behavior_group"].items():
+        print(f"{g:22s} {v['n']:>7d} {v['iss_mean']:>9.3f} {v['iss_sd']:>7.3f}")
+    print()
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/judge_run.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python
+"""AI Judge: semantic answer clustering, then correctness.   [GPU]  (protocol 3)
+
+    python src/judge_run.py --model Llama-3.2-1B
+
+Two passes, in the order protocol 3 mandates:
+
+  Pass 1  REFERENCE-BLIND. The judge never sees the gold answer. It only groups
+          responses that assert the same thing -- "Paris", "The answer is
+          Paris.", "巴黎" -- and flags ABSTAIN / MULTIPLE / UNPARSEABLE.
+          This is what BCS and BES are built on, and keeping gold out of it is
+          what lets a confidently wrong model score BCS = 1.
+
+  Pass 2  REFERENCE-AWARE. Gold, aliases, answer type and granularity are
+          supplied, and each CLUSTER (not each response) is labelled. This only
+          separates Stable Correct from Stable Wrong; it never reshapes a
+          cluster.
+
+The unit of judgement is the (fact, model) pair, per protocol 3.1: judging pairs
+of responses independently would produce non-transitive verdicts, where a~b and
+b~c but a!~c, and no consistent cluster assignment exists.
+
+Cost control: responses are pre-grouped by normalised surface string before the
+judge sees them. Exact post-normalisation identity is a strict subset of
+semantic equivalence, so the judge can only ever merge those groups further,
+never split them -- the clustering is unchanged, but a typical fact sends 3-6
+distinct strings instead of 17 responses.
+"""
+import os, sys, json, time, argparse, re
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+sys.path.insert(0, mc.ds3("src"))
+from common import normalize                       # noqa: E402
+
+BLIND = """You are clustering short answers to one factual question. You are NOT told the correct answer and must not guess it.
+
+Question: {question}
+
+Candidate answers:
+{answers}
+
+Work in two steps, exactly as follows.
+
+Step 1. For each answer, extract ONLY the core entity or value it finally asserts. Strip restated question text, subject names, hedging, reasoning and trailing explanation. "Agriculture and Agri-Food Canada applies in Canada" asserts "Canada". "The answer is Paris." asserts "Paris".
+
+Step 2. Group the answers whose EXTRACTED core is the same entity or value. Ignore wording, language, punctuation and capitalisation; translations of one another belong together, and a bare entity belongs with a full sentence asserting that same entity. Two answers go in different groups only when they name genuinely different entities.
+
+Use these special groups where they apply:
+- ABSTAIN: refuses, or says it does not know
+- MULTIPLE: gives several conflicting answers without choosing
+- UNPARSEABLE: no answer can be extracted
+
+Reply with JSON only, where "meaning" is the extracted core from step 1:
+{{"clusters":[{{"ids":[0,2],"meaning":"Paris","status":"ANSWER"}},{{"ids":[1],"meaning":"","status":"ABSTAIN"}}]}}
+Every id from 0 to {last} must appear exactly once."""
+
+AWARE = """Judge whether each proposed answer is correct for this question.
+
+Question: {question}
+Correct answer: {gold}
+Also acceptable: {aliases}
+Answer type: {atype} ({gran})
+
+Proposed answers:
+{answers}
+
+Label each one:
+- CORRECT: same entity/value as the correct answer, any wording or language
+- INCORRECT: a different entity/value
+- ABSTAIN: a refusal or "I don't know"
+- AMBIGUOUS: could refer to the correct answer but is too vague to tell
+- REVIEW_REQUIRED: cannot decide
+
+Reply with JSON only: {{"labels":["CORRECT","INCORRECT"]}} with exactly {n} entries in order."""
+
+
+def parse_json(text):
+    """Judges emit prose around the JSON often enough that this must be robust."""
+    m = re.search(r"\{.*\}", text, re.S)
+    if not m:
+        return None
+    try:
+        return json.loads(m.group(0))
+    except json.JSONDecodeError:
+        try:
+            return json.loads(re.sub(r",\s*([}\]])", r"\1", m.group(0)))
+        except json.JSONDecodeError:
+            return None
+
+
+def generate(model, tok, prompts, max_new, batch):
+    outs = []
+    for i in range(0, len(prompts), batch):
+        chunk = prompts[i:i + batch]
+        texts = [tok.apply_chat_template([{"role": "user", "content": p}],
+                                         tokenize=False, add_generation_prompt=True)
+                 for p in chunk]
+        enc = tok(texts, return_tensors="pt", padding=True, truncation=True,
+                  max_length=2048).to(0)
+        with torch.no_grad():
+            g = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
+                               num_beams=1, pad_token_id=tok.pad_token_id)
+        outs += tok.batch_decode(g[:, enc["input_ids"].shape[1]:],
+                                 skip_special_tokens=True)
+    return outs
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True, help="the model being judged")
+    ap.add_argument("--judge", default=None)
+    ap.add_argument("--batch", type=int, default=32)
+    ap.add_argument("--limit", type=int, default=0, help="debug: first N facts")
+    ap.add_argument("--sample", type=int, default=0,
+                    help="judge a fixed random subset of facts instead of all 2,592")
+    ap.add_argument("--sample-seed", type=int, default=20260101)
+    ap.add_argument("--resume", action="store_true")
+    args = ap.parse_args()
+
+    judge_name = args.judge or mc.models_cfg()["auxiliary_models"]["judge"]["name"]
+    if judge_name == args.model:
+        raise SystemExit("the judge must not judge itself (MODEL_SELECTION_20 section 6)")
+
+    fams = set(mc.cfg()["main_families"])
+    gen_path = mc.ds3("outputs", "evaluation", f"{args.model}.jsonl")
+    if not os.path.exists(gen_path):
+        raise SystemExit(f"no generations for {args.model}: {gen_path}")
+
+    qmeta = {r["query_id"]: r for r in mc.main_forward_queries()}
+    by_fact = {}
+    for r in mc.read_jsonl(gen_path):
+        if r["condition_family"] not in fams or r["query_id"] not in qmeta:
+            continue
+        by_fact.setdefault(r["fact_id"], []).append(r)
+    fact_ids = sorted(by_fact)
+    if args.sample and args.sample < len(fact_ids):
+        # Drawn from the FULL benchmark fact list with a fixed seed, not from
+        # this model's own facts, so every model is judged on an identical
+        # subset. Sampling per model would make BCS/BES incomparable, which is
+        # exactly what protocol 1.3 forbids.
+        import numpy as np
+        allf = sorted(mc.facts())
+        rng = np.random.default_rng(args.sample_seed)
+        pick = set(np.array(allf)[rng.choice(len(allf), size=args.sample,
+                                             replace=False)].tolist())
+        fact_ids = [f for f in fact_ids if f in pick]
+    if args.limit:
+        fact_ids = fact_ids[:args.limit]
+
+    dest = mc.out("metrics", "judge", f"{args.model}.jsonl")
+    done = set()
+    if args.resume and os.path.exists(dest):
+        done = {r["fact_id"] for r in mc.read_jsonl(dest)}
+        fact_ids = [f for f in fact_ids if f not in done]
+    if not fact_ids:
+        print(f"[{args.model}] judge already complete")
+        return
+
+    facts = mc.facts()
+    # Pre-group by normalised surface: a strict subset of semantic equivalence,
+    # so this changes cost and not the clustering the judge can express.
+    tasks = []
+    for fid in fact_ids:
+        recs = by_fact[fid]
+        groups = {}
+        for r in recs:
+            key = normalize(r["raw_response"].strip().split("\n")[0][:120])
+            groups.setdefault(key, []).append(r["query_id"])
+        surfaces = list(groups)
+        display = [next(x["raw_response"].strip().split("\n")[0][:120]
+                        for x in recs if normalize(
+                            x["raw_response"].strip().split("\n")[0][:120]) == s) or "(empty)"
+                   for s in surfaces]
+        tasks.append({"fact_id": fid, "surfaces": surfaces, "display": display,
+                      "groups": [groups[s] for s in surfaces],
+                      "question": facts[fid]["qualification_question"]})
+
+    path = mc.model_path(judge_name)
+    tok = AutoTokenizer.from_pretrained(path)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    tok.padding_side = "left"
+    judge = AutoModelForCausalLM.from_pretrained(
+        path, dtype=torch.bfloat16, device_map={"": 0}).eval()
+
+    t0 = time.time()
+    out_f = open(dest, "a" if done else "w")
+    for i in range(0, len(tasks), args.batch):
+        chunk = tasks[i:i + args.batch]
+
+        p1 = [BLIND.format(question=t["question"], last=len(t["display"]) - 1,
+                           answers="\n".join(f"{j}. {d}" for j, d in enumerate(t["display"])))
+              for t in chunk]
+        r1 = generate(judge, tok, p1, 512, args.batch)
+
+        for t, raw in zip(chunk, r1):
+            js = parse_json(raw) or {}
+            clusters, seen = [], set()
+            for c in js.get("clusters", []):
+                ids = [int(x) for x in c.get("ids", [])
+                       if isinstance(x, (int, float)) and 0 <= int(x) < len(t["display"])
+                       and int(x) not in seen]
+                if not ids:
+                    continue
+                seen.update(ids)
+                clusters.append({"ids": ids, "meaning": str(c.get("meaning", ""))[:80],
+                                 "status": str(c.get("status", "ANSWER")).upper()})
+            # Anything the judge dropped or mangled stays its own cluster rather
+            # than vanishing: silently losing a response would change the BCS
+            # denominator for that fact.
+            for j in range(len(t["display"])):
+                if j not in seen:
+                    clusters.append({"ids": [j], "meaning": t["display"][j][:80],
+                                     "status": "ANSWER", "recovered": True})
+            t["clusters"] = clusters
+            t["judge_raw_blind"] = raw[:400]
+
+        p2, own = [], []
+        for t in chunk:
+            f = facts[t["fact_id"]]
+            answer = [c["meaning"] or t["display"][c["ids"][0]] for c in t["clusters"]]
+            p2.append(AWARE.format(
+                question=t["question"], gold=f["object"]["canonical"],
+                aliases=", ".join(f["object"]["aliases"][:10]),
+                atype=f.get("answer_type", "entity"),
+                gran=f.get("answer_granularity", "entity"),
+                answers="\n".join(f"{j}. {a}" for j, a in enumerate(answer)),
+                n=len(answer)))
+            own.append(t)
+        r2 = generate(judge, tok, p2, 256, args.batch)
+        for t, raw in zip(own, r2):
+            js = parse_json(raw) or {}
+            labels = [str(x).upper() for x in js.get("labels", [])]
+            for j, c in enumerate(t["clusters"]):
+                lab = labels[j] if j < len(labels) else "REVIEW_REQUIRED"
+                if c["status"] in ("ABSTAIN", "MULTIPLE", "UNPARSEABLE"):
+                    lab = c["status"] if c["status"] == "ABSTAIN" else "REVIEW_REQUIRED"
+                c["correctness"] = lab
+            t["judge_raw_aware"] = raw[:400]
+
+        for t in chunk:
+            rows = []
+            for k, c in enumerate(t["clusters"]):
+                cid = f"C{k}" if c["status"] == "ANSWER" else c["status"]
+                for j in c["ids"]:
+                    for qid in t["groups"][j]:
+                        rows.append({"query_id": qid,
+                                     "condition_family": qmeta[qid]["condition_family"],
+                                     "cluster_id": cid})
+            out_f.write(json.dumps({
+                "model": args.model, "judge": judge_name, "fact_id": t["fact_id"],
+                "clusters": [{"cluster_id": f"C{k}" if c["status"] == "ANSWER"
+                              else c["status"],
+                              "canonical_meaning": c["meaning"],
+                              "status": c["status"],
+                              "correctness": c.get("correctness", "REVIEW_REQUIRED")}
+                             for k, c in enumerate(t["clusters"])],
+                "assignments": rows}, ensure_ascii=False) + "\n")
+        out_f.flush()
+        d = i + len(chunk)
+        print(f"  {d}/{len(tasks)} facts  {d / max(time.time() - t0, 1e-9):.2f}/s",
+              flush=True)
+    out_f.close()
+    print(f"[{args.model}] judged {len(tasks)} facts with {judge_name}  JUDGE_DONE",
+          flush=True)
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/kts.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+"""KTS: Knowledge Topology Stability.   (protocol 8-11)
+
+    python src/kts.py --model Llama-3.2-1B --transport raw
+    python src/kts.py --model Llama-3.2-1B --transport jlens
+
+Two components, both computed per relation and then macro-averaged so that the
+largest relations cannot dominate (protocol 9.1):
+
+  KTS-Geo  Spearman correlation between the within-relation pairwise distance
+           matrices under the two condition families. Rotation, translation and
+           isotropic scaling are all invisible to it -- protocol 8.1 says that
+           is intended: different phrasings may use different internal
+           implementations as long as relative structure survives.
+
+  KTS-ID   Cross-condition nearest-neighbour retrieval of the fact itself,
+           among same-relation facts, both directions, chance-corrected.
+           Global geometry can look preserved while individual identities swap,
+           which is exactly what this catches.
+
+composite = harmonic mean of the two, so a model cannot buy a high KTS with one
+component alone (protocol 11).
+"""
+import os, sys, json, time, argparse, itertools
+
+import numpy as np
+import torch
+from scipy.stats import spearmanr
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+from states import StateLoader
+
+
+def geo_pair(Va, Vb, members, eps):
+    """Spearman between within-relation distance matrices (protocol 9.1-9.2)."""
+    idx = torch.tensor(members, device=Va.device)
+    A, B = Va[idx], Vb[idx]
+    Da = 1.0 - (A @ A.T)
+    Db = 1.0 - (B @ B.T)
+    iu = torch.triu_indices(len(members), len(members), offset=1)
+    da = Da[iu[0], iu[1]].cpu().numpy()
+    db = Db[iu[0], iu[1]].cpu().numpy()
+    if da.size < 2 or np.std(da) < eps or np.std(db) < eps:
+        return None
+    rho = spearmanr(da, db).statistic
+    return None if not np.isfinite(rho) else float(rho)
+
+
+def id_pair(Va, Vb, members):
+    """Symmetric chance-corrected top-1 identity, plus top-5 and MRR.
+
+    Retrieval is restricted to same-relation facts (protocol 10.1): matching
+    "the capital of France" against a manufacturer fact would be trivial and
+    would inflate the score.
+    """
+    idx = torch.tensor(members, device=Va.device)
+    A, B = Va[idx], Vb[idx]
+    n = len(members)
+    gold = torch.arange(n, device=A.device)
+
+    def side(X, Y):
+        S = X @ Y.T
+        rank = (S > S.gather(1, gold[:, None])).sum(1)      # 0 = correct is top
+        top1 = (rank == 0).float().mean().item()
+        top5 = (rank < 5).float().mean().item()
+        mrr = (1.0 / (rank.float() + 1)).mean().item()
+        return top1, top5, mrr
+
+    a = side(A, B)
+    b = side(B, A)
+    top1 = 0.5 * (a[0] + b[0])
+    chance = 1.0 / n
+    adj = (top1 - chance) / max(1.0 - chance, 1e-12)
+    return {"top1_symmetric": top1, "top5_symmetric": 0.5 * (a[1] + b[1]),
+            "mrr_symmetric": 0.5 * (a[2] + b[2]), "chance": chance,
+            "chance_corrected": float(np.clip(adj, 0.0, 1.0)), "n": n}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--transport", choices=["raw", "jlens"], default="raw")
+    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
+    ap.add_argument("--device", default="auto")
+    ap.add_argument("--shuffle-seed", type=int, default=None,
+                    help="protocol 18.1 control: KTS-ID must fall to chance, KTS-Geo to ~0")
+    args = ap.parse_args()
+
+    C = mc.cfg()
+    kcfg = C["kts"]
+    eps = float(kcfg["eps"])
+    min_facts = kcfg["min_facts_per_relation"]
+
+    S = StateLoader(args.model, args.transport, args.coverage, args.device,
+                    shuffle_seed=args.shuffle_seed)
+    fams = S.families
+    pairs = list(itertools.combinations(range(len(fams)), 2))
+
+    t0 = time.time()
+    per_layer_pair = []
+    for l in S.window:
+        V, mask = S.centroids(l)
+        for (a, b) in pairs:
+            both = mask[:, a] & mask[:, b]
+            geos, ids, shared = [], [], int(both.sum())
+            for rel, members in S.by_rel.items():
+                m = [i for i in members if bool(both[i])]
+                if len(m) < min_facts:          # protocol 9.1
+                    continue
+                g = geo_pair(V[:, a], V[:, b], m, eps)
+                if g is not None:
+                    geos.append(g)
+                ids.append(id_pair(V[:, a], V[:, b], m))
+            if not geos or not ids:
+                continue
+            geo = float(np.mean(geos))
+            geo01 = (geo + 1.0) / 2.0                       # protocol 9.3
+            idv = float(np.mean([x["chance_corrected"] for x in ids]))
+            per_layer_pair.append({
+                "model": args.model, "transport": args.transport, "layer": l,
+                "pair": f"{fams[a]}__{fams[b]}", "shared_facts": shared,
+                "relations_used": len(ids),
+                "kts_geo_raw": geo, "kts_geo": geo01, "kts_id": idv,
+                "kts": 2 * geo01 * idv / (geo01 + idv + eps),   # protocol 11
+                "top1": float(np.mean([x["top1_symmetric"] for x in ids])),
+                "top5": float(np.mean([x["top5_symmetric"] for x in ids])),
+                "mrr": float(np.mean([x["mrr_symmetric"] for x in ids])),
+            })
+        del V, mask
+        if S.dev == "cuda":
+            torch.cuda.empty_cache()
+        lay = [r for r in per_layer_pair if r["layer"] == l]
+        print(f"  L{l:03d}  geo={np.mean([r['kts_geo'] for r in lay]):.4f}  "
+              f"id={np.mean([r['kts_id'] for r in lay]):.4f}  "
+              f"kts={np.mean([r['kts'] for r in lay]):.4f}", flush=True)
+
+    tag = f"{args.model}.{args.transport}.{S.mode}"
+    if args.shuffle_seed is not None:
+        tag += f".shuffled{args.shuffle_seed}"
+    mc.write_jsonl(mc.out("metrics", "kts", f"{tag}.per_pair_layer.jsonl"), per_layer_pair)
+
+    # Protocol 11.1: every family pair counts equally. Weighting by shared facts
+    # would let the widest-coverage pairs decide the number.
+    def agg(rows, key):
+        by_layer = {}
+        for r in rows:
+            by_layer.setdefault(r["layer"], []).append(r[key])
+        return float(np.mean([np.mean(v) for v in by_layer.values()]))
+
+    pair_summary = {}
+    for p in sorted({r["pair"] for r in per_layer_pair}):
+        rows = [r for r in per_layer_pair if r["pair"] == p]
+        pair_summary[p] = {
+            "shared_facts": rows[0]["shared_facts"],
+            "kts_geo": float(np.mean([r["kts_geo"] for r in rows])),
+            "kts_geo_raw": float(np.mean([r["kts_geo_raw"] for r in rows])),
+            "kts_id": float(np.mean([r["kts_id"] for r in rows])),
+            "kts": float(np.mean([r["kts"] for r in rows])),
+            "top1": float(np.mean([r["top1"] for r in rows])),
+            "top5": float(np.mean([r["top5"] for r in rows])),
+            "mrr": float(np.mean([r["mrr"] for r in rows])),
+        }
+
+    summary = {
+        "model": args.model, "transport": args.transport,
+        "official": args.transport == "jlens" and args.shuffle_seed is None,
+        "shuffle_control": args.shuffle_seed is not None, "coverage_mode": S.mode,
+        "layers": S.window, "n_facts": S.n_facts,
+        "kts_geo": agg(per_layer_pair, "kts_geo"),
+        "kts_geo_raw_spearman": agg(per_layer_pair, "kts_geo_raw"),
+        "kts_id": agg(per_layer_pair, "kts_id"),
+        "kts": agg(per_layer_pair, "kts"),
+        "top1": agg(per_layer_pair, "top1"),
+        "top5": agg(per_layer_pair, "top5"),
+        "mrr": agg(per_layer_pair, "mrr"),
+        "family_pairs": pair_summary,
+        "per_layer_kts": {str(l): float(np.mean([r["kts"] for r in per_layer_pair
+                                                 if r["layer"] == l]))
+                          for l in S.window},
+        "seconds": round(time.time() - t0, 1),
+    }
+    mc.write_json(mc.out("metrics", "kts", f"{tag}.summary.json"), summary)
+    print(f"[{args.model}] {args.transport}  KTS-Geo={summary['kts_geo']:.4f}  "
+          f"KTS-ID={summary['kts_id']:.4f}  KTS={summary['kts']:.4f}  KTS_DONE",
+          flush=True)
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/make_table.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+"""The main results table: model x {BCS, BES, ISS, KTS}.   (protocol 13, 20)
+
+    python src/make_table.py                 # markdown to stdout + outputs/
+    python src/make_table.py --transport raw # the ablation table
+
+ISS is reported from the J-Lens transported states. Raw-ISS is an
+identity-transport ablation and is labelled as such (J-Lens spec 11); a model
+whose J-Lens estimator failed validation shows "--" for ISS rather than a raw
+number wearing the official name (spec 12).
+"""
+import os, sys, json, argparse
+
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import mcommon as mc
+
+
+def load(kind, name):
+    p = mc.out("metrics", kind, name)
+    return json.load(open(p)) if os.path.exists(p) else None
+
+
+def fmt(v, nd=3, pct=False):
+    if v is None or (isinstance(v, float) and not np.isfinite(v)):
+        return "--"
+    return f"{100 * v:.1f}" if pct else f"{v:.{nd}f}"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--transport", choices=["jlens", "raw"], default="jlens")
+    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
+    ap.add_argument("--models", nargs="*", default=None)
+    args = ap.parse_args()
+
+    C = mc.cfg()
+    mode = args.coverage or C["headline_coverage"]
+    names = args.models or [m["name"] for m in mc.models_cfg()["evaluated_models"]]
+
+    rows = []
+    for m in names:
+        beh = load("behavioral", f"{m}.{mode}.summary.json")
+        iss = load("iss", f"{m}.{args.transport}.{mode}.summary.json")
+        kts = load("kts", f"{m}.{args.transport}.{mode}.summary.json")
+        if not any([beh, iss, kts]):
+            continue
+        e = mc.model_entry(m)
+        rows.append({
+            "model": m, "family": e.get("family", ""), "tier": e.get("tier", ""),
+            "params_b": e.get("params_b"), "tuning": e.get("tuning", ""),
+            "bcs": beh and beh["bcs"], "bes": beh and beh["bes"],
+            "scr": beh and beh["stable_correct_rate"],
+            "swr": beh and beh["stable_wrong_rate"],
+            "sar": beh and beh["stable_abstention_rate"],
+            "ur": beh and beh["unstable_rate"],
+            "iss": iss and iss["iss"], "iss_ci": iss and iss["iss_ci95"],
+            "iss_peak": iss and iss["iss_peak"], "iss_late": iss and iss["iss_late"],
+            "kts_geo": kts and kts["kts_geo"], "kts_id": kts and kts["kts_id"],
+            "kts": kts and kts["kts"],
+            "n_facts": (beh or iss or kts).get("n_facts"),
+        })
+    if not rows:
+        raise SystemExit("nothing to tabulate yet")
+    rows.sort(key=lambda r: (r["family"], r["params_b"] or 0))
+
+    label = "ISS (J-Lens)" if args.transport == "jlens" else "Raw-ISS (ablation)"
+    L = []
+    L.append(f"# BCS / BES / ISS / KTS  ({mode}, transport={args.transport})\n")
+    L.append(f"Fact set: fixed benchmark, {rows[0]['n_facts']} facts scored per model. "
+             f"ISS column is **{label}**.\n")
+    L.append("| Model | Family | Tier | BCS | BES | " + label +
+             " | KTS-Geo | KTS-ID | KTS |")
+    L.append("|---|---|---|---:|---:|---:|---:|---:|---:|")
+    for r in rows:
+        L.append(f"| {r['model']} | {r['family']} | {r['tier']} | "
+                 f"{fmt(r['bcs'])} | {fmt(r['bes'])} | {fmt(r['iss'])} | "
+                 f"{fmt(r['kts_geo'])} | {fmt(r['kts_id'])} | {fmt(r['kts'])} |")
+
+    L.append("\n## Behaviour composition (protocol 6, %)\n")
+    L.append("| Model | Stable Correct | Stable Wrong | Stable Abstention | Unstable |")
+    L.append("|---|---:|---:|---:|---:|")
+    for r in rows:
+        L.append(f"| {r['model']} | {fmt(r['scr'], pct=True)} | {fmt(r['swr'], pct=True)} "
+                 f"| {fmt(r['sar'], pct=True)} | {fmt(r['ur'], pct=True)} |")
+
+    L.append("\n## ISS detail (protocol 7.10)\n")
+    L.append("| Model | ISS | 95% CI | Peak | Late |")
+    L.append("|---|---:|---|---:|---:|")
+    for r in rows:
+        ci = f"[{fmt(r['iss_ci'][0])}, {fmt(r['iss_ci'][1])}]" if r["iss_ci"] else "--"
+        L.append(f"| {r['model']} | {fmt(r['iss'])} | {ci} | "
+                 f"{fmt(r['iss_peak'])} | {fmt(r['iss_late'])} |")
+
+    md = "\n".join(L) + "\n"
+    dest = mc.out("metrics", f"main_table.{args.transport}.{mode}.md")
+    with open(dest, "w") as f:
+        f.write(md)
+    mc.write_json(mc.out("metrics", f"main_table.{args.transport}.{mode}.json"), rows)
+    print(md)
+    print(f"written -> {dest}")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/metrics/mcommon.py

@@ -0,0 +1,252 @@
+# -*- coding: utf-8 -*-
+"""Shared plumbing for the BCS/BES/ISS/KTS metric stack.
+
+Everything here is deliberately read-only with respect to dataset3/: the fact
+set and the query bank are frozen artefacts (protocol 2.1), and this package
+only consumes them.
+"""
+import os, json, math, functools
+
+import numpy as np
+import yaml
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+CONFIGS = os.path.join(ROOT, "configs")
+
+
+@functools.lru_cache(maxsize=None)
+def cfg():
+    with open(os.path.join(CONFIGS, "metrics.yaml")) as f:
+        return yaml.safe_load(f)
+
+
+@functools.lru_cache(maxsize=None)
+def models_cfg():
+    with open(os.path.join(cfg()["paths"]["dataset3"], "configs", "models.yaml")) as f:
+        return yaml.safe_load(f)
+
+
+def model_entry(name):
+    for m in models_cfg()["evaluated_models"]:
+        if m["name"] == name:
+            return m
+    aux = models_cfg().get("auxiliary_models", {})
+    for m in aux.values():
+        if m["name"] == name:
+            return m
+    raise KeyError(f"{name} is not in dataset3/configs/models.yaml")
+
+
+def model_path(name):
+    return os.path.join(models_cfg()["model_root"], model_entry(name)["path"])
+
+
+def ds3(*parts):
+    return os.path.join(cfg()["paths"]["dataset3"], *parts)
+
+
+def out(kind, *parts):
+    """kind in {hidden, jlens, metrics}."""
+    p = os.path.join(cfg()["paths"][f"{kind}_root"], *parts)
+    os.makedirs(os.path.dirname(p) if os.path.splitext(p)[1] else p, exist_ok=True)
+    return p
+
+
+def read_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def write_jsonl(path, rows):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    n = 0
+    with open(path, "w") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False, default=_jsonable) + "\n")
+            n += 1
+    return n
+
+
+def write_json(path, obj):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(obj, f, indent=2, ensure_ascii=False, default=_jsonable)
+
+
+def _jsonable(o):
+    if isinstance(o, (np.floating, np.integer)):
+        return o.item()
+    if isinstance(o, np.ndarray):
+        return o.tolist()
+    raise TypeError(type(o))
+
+
+# ------------------------------------------------------------------- queries
+QUERY_BANK = "evaluation_queries_44418.jsonl"   # 44,416 rows; see dataset3 D1
+
+
+@functools.lru_cache(maxsize=None)
+def main_forward_queries():
+    """The 39,260 queries that protocol 1.1 admits to the main analysis.
+
+    The filter reads each row's own `use_for_main_forward` flag rather than
+    testing `condition_family in main_families`: the flags are derived from
+    eval_conditions.yaml and are what dataset3's validator checks, so trusting
+    them keeps one definition of the split instead of two that can drift.
+    """
+    rows = []
+    for r in read_jsonl(ds3("outputs", QUERY_BANK)):
+        if r.get("use_for_main_forward"):
+            rows.append(r)
+    fams = set(cfg()["main_families"])
+    bad = {r["condition_family"] for r in rows} - fams
+    if bad:
+        raise SystemExit(f"main_forward rows carry unexpected families: {bad}")
+    return rows
+
+
+@functools.lru_cache(maxsize=None)
+def facts():
+    """fact_id -> record, plus the relation of each fact."""
+    return {r["fact_id"]: r for r in read_jsonl(ds3("outputs", "benchmark_facts_2592.jsonl"))}
+
+
+@functools.lru_cache(maxsize=None)
+def fact_relation():
+    return {fid: r["relation"]["relation_id"] for fid, r in facts().items()}
+
+
+@functools.lru_cache(maxsize=None)
+def coverage():
+    """fact_id -> set of main families that actually contain it.
+
+    Protocol 1.3: coverage is ragged (multilingual 2,402, context 2,591), and
+    the two reporting modes below are both mandatory.
+    """
+    cov = {}
+    for r in main_forward_queries():
+        cov.setdefault(r["fact_id"], set()).add(r["condition_family"])
+    return cov
+
+
+@functools.lru_cache(maxsize=None)
+def complete_family_facts():
+    """D_cap: the facts carrying all five main families (protocol 1.3).
+
+    This set is a property of the query bank, not of any model, so every model
+    is scored on exactly the same facts -- which is the point of protocol 1.3's
+    prohibition on per-model effective sets.
+    """
+    need = set(cfg()["main_families"])
+    return sorted(f for f, c in coverage().items() if c >= need)
+
+
+def eval_fact_set(mode):
+    if mode == "complete_family":
+        return complete_family_facts()
+    if mode == "full_set":
+        return sorted(coverage())
+    raise ValueError(mode)
+
+
+# -------------------------------------------------------------- layer window
+def layer_window(n_layers, min_depth=None):
+    """Protocol 7.10: {l : d_l >= min_depth}, d_l = l / (L - 1).
+
+    `l` indexes decoder blocks 0..L-1, so l = L-1 is the final residual stream
+    that J-Lens transports to. In HF terms the state is hidden_states[l+1],
+    because hidden_states[0] is the embedding output.
+    """
+    if min_depth is None:
+        min_depth = cfg()["extraction"]["window_min_depth"]
+    return [l for l in range(n_layers) if l / max(n_layers - 1, 1) >= min_depth - 1e-9]
+
+
+def late_window(n_layers):
+    return layer_window(n_layers, cfg()["extraction"]["late_min_depth"])
+
+
+# --------------------------------------------------------------- linear alg
+def l2_normalize(x, axis=-1, eps=1e-12):
+    n = np.linalg.norm(x, axis=axis, keepdims=True)
+    return x / np.maximum(n, eps)
+
+
+def pca_whiten(X, dim, shrinkage, eps=1e-12):
+    """Return the whitened matrix and the fitted transform.
+
+    Protocol 7.5 forbids fitting a separate transform per condition family, so
+    this is called once per (model, layer) on the pooled matrix and the same
+    components are then applied to every family.
+    """
+    mu = X.mean(axis=0, keepdims=True)
+    Xc = X - mu
+    # Economy SVD on the centred matrix is the covariance eigendecomposition
+    # without ever forming a d x d matrix -- d can be 5120 and n is ~39k.
+    k = min(dim, Xc.shape[0], Xc.shape[1])
+    U, S, Vt = np.linalg.svd(Xc, full_matrices=False)
+    U, S, Vt = U[:, :k], S[:k], Vt[:k]
+    var = (S ** 2) / max(Xc.shape[0] - 1, 1)
+    # lambda is expressed as a fraction of the mean retained variance so that
+    # one config value behaves the same across models with different scales.
+    lam = shrinkage * float(var.mean())
+    Z = (Xc @ Vt.T) / np.sqrt(var + lam + eps)
+    return Z.astype(np.float32), {"mean": mu, "components": Vt, "scale": np.sqrt(var + lam + eps)}
+
+
+# ------------------------------------------------------------------ negatives
+def negative_sample(fact_ids, relation_of, max_negatives, seed):
+    """Protocol 7.8: for each fact, up to `max_negatives` same-relation others.
+
+    Drawn ONCE from the fixed fact set and reused for every model. If each model
+    drew its own, a model could score well merely by having been handed more
+    distant negatives.
+    """
+    rng = np.random.default_rng(seed)
+    by_rel = {}
+    for f in fact_ids:
+        by_rel.setdefault(relation_of[f], []).append(f)
+    for r in by_rel:
+        by_rel[r].sort()
+    negs = {}
+    for f in fact_ids:
+        pool = [g for g in by_rel[relation_of[f]] if g != f]
+        if len(pool) > max_negatives:
+            idx = rng.choice(len(pool), size=max_negatives, replace=False)
+            pool = [pool[i] for i in sorted(idx)]
+        negs[f] = pool
+    return negs
+
+
+# ----------------------------------------------------------------- bootstrap
+def relation_clustered_bootstrap(values, relation_of, n_resamples, seed, ci=0.95):
+    """Protocol 14.1: resample relations, then facts within each drawn relation.
+
+    A plain per-fact bootstrap would understate the interval because the 21
+    relations are very unevenly sized and facts inside one relation are far from
+    independent.
+    """
+    fact_ids = [f for f in values if values[f] == values[f]]  # drop NaN
+    if not fact_ids:
+        return {"mean": float("nan"), "lo": float("nan"), "hi": float("nan"), "n": 0}
+    by_rel = {}
+    for f in fact_ids:
+        by_rel.setdefault(relation_of[f], []).append(f)
+    rels = sorted(by_rel)
+    arr = {r: np.array([values[f] for f in by_rel[r]], dtype=np.float64) for r in rels}
+    rng = np.random.default_rng(seed)
+    draws = np.empty(n_resamples, dtype=np.float64)
+    for b in range(n_resamples):
+        picked = rng.integers(0, len(rels), size=len(rels))
+        pool = []
+        for i in picked:
+            a = arr[rels[i]]
+            pool.append(a[rng.integers(0, len(a), size=len(a))])
+        draws[b] = np.concatenate(pool).mean()
+    lo, hi = np.percentile(draws, [(1 - ci) / 2 * 100, (1 + ci) / 2 * 100])
+    point = float(np.mean([values[f] for f in fact_ids]))
+    return {"mean": point, "lo": float(lo), "hi": float(hi), "n": len(fact_ids)}

ICLR dataset/metrics/states.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""Per-layer family centroids -- the single input both ISS and KTS consume.
+
+Protocol 7.4-7.6 and 8.2 describe one preparation, then branch. Keeping it in
+one place means ISS and KTS cannot silently disagree about what a fact's
+representation under a condition family IS, which would make the joint
+interpretation table (protocol 12) meaningless.
+
+    z    = transport(h)                 raw: identity;  jlens: y = B h
+    zbar = z - mu_r - mu_t + mu         relation and family main effects removed
+    zt   = L2(PCA-whiten(zbar))         one transform per (model, layer)
+    v    = L2(mean of zt within a family)          -> [F, T, D], plus a mask
+"""
+import os, json
+
+import numpy as np
+import torch
+
+import mcommon as mc
+
+
+def l2n(X, eps=1e-12):
+    return X / X.norm(dim=-1, keepdim=True).clamp_min(eps)
+
+
+def whiten(Z, dim, shrinkage, eps):
+    """PCA whitening fitted once on the pooled matrix (protocol 7.5).
+
+    Fitting per condition family is forbidden: it would absorb exactly the
+    cross-condition differences these metrics exist to detect.
+    """
+    mu = Z.mean(0, keepdim=True)
+    Zc = Z - mu
+    n, d = Zc.shape
+    k = min(dim, d)
+    # d <= 5120 while n ~ 39k, so the d x d covariance route is far cheaper
+    # than an SVD of the tall matrix and numerically equivalent.
+    C = (Zc.T @ Zc).double() / max(n - 1, 1)
+    evals, evecs = torch.linalg.eigh(C)
+    evals = evals.flip(0)[:k].clamp_min(0).float()
+    evecs = evecs.flip(1)[:, :k].float()
+    lam = shrinkage * float(evals.mean())
+    return (Zc @ evecs) / torch.sqrt(evals + lam + eps)
+
+
+class StateLoader:
+    """Streams (layer -> family centroids) for one model."""
+
+    def __init__(self, model, transport="raw", coverage=None, device="auto",
+                 shuffle_seed=None):
+        C = mc.cfg()
+        self.C = C
+        self.model = model
+        self.transport = transport
+        # Protocol 18.1: with fact identity destroyed, ISS must collapse,
+        # KTS-ID must fall to chance and KTS-Geo to ~0. If they do not, the
+        # metric is measuring something other than the fact.
+        self.shuffle_seed = shuffle_seed
+        self.mode = coverage or C["headline_coverage"]
+        self.dev = ("cuda" if torch.cuda.is_available() else "cpu") \
+            if device == "auto" else device
+
+        self.hdir = mc.out("hidden", model)
+        self.meta = json.load(open(os.path.join(self.hdir, "index.json")))
+        if not self.meta.get("complete"):
+            raise SystemExit(f"{model}: hidden states incomplete; run extract_hidden.py")
+
+        self.families = C["main_families"]
+        fam_id = {t: i for i, t in enumerate(self.families)}
+        self.keep_facts = mc.eval_fact_set(self.mode)
+        self.fidx = {f: i for i, f in enumerate(self.keep_facts)}
+        self.rel_of = mc.fact_relation()
+
+        self.sel = np.array([i for i, f in enumerate(self.meta["fact_ids"])
+                             if f in self.fidx], dtype=np.int64)
+        self.fact_idx = torch.tensor(
+            [self.fidx[self.meta["fact_ids"][i]] for i in self.sel], device=self.dev)
+        self.fam_idx = torch.tensor(
+            [fam_id[self.meta["families"][i]] for i in self.sel], device=self.dev)
+
+        self.by_rel = {}
+        for f in self.keep_facts:
+            self.by_rel.setdefault(self.rel_of[f], []).append(self.fidx[f])
+        rel_pos = {r: i for i, r in enumerate(self.by_rel)}
+        self.rel_idx = torch.tensor(
+            [rel_pos[self.rel_of[self.meta["fact_ids"][i]]] for i in self.sel],
+            device=self.dev)
+        self.n_rel = len(self.by_rel)
+
+        self.window = self.meta["window"]
+        self.late = set(self.meta["late_window"])
+        self.B = None
+        if transport == "jlens":
+            self.B = {}
+            for l in self.window:
+                p = mc.out("jlens", model, f"L{l:03d}", "B.npy")
+                if not os.path.exists(p):
+                    raise SystemExit(
+                        f"{model} L{l}: no J-Lens factor at {p}. Run src/jlens.py "
+                        "first, or use --transport raw for the ablation.")
+                self.B[l] = torch.from_numpy(np.load(p)).to(self.dev).float()
+
+    @property
+    def n_facts(self):
+        return len(self.keep_facts)
+
+    def centroids(self, layer):
+        """-> V [F, T, D] (zero where absent), mask [F, T]."""
+        icfg = self.C["iss"]
+        eps = float(icfg["eps"])
+        H = np.load(os.path.join(self.hdir, f"L{layer:03d}.npy"), mmap_mode="r")
+        Z = torch.from_numpy(np.ascontiguousarray(H[self.sel])).to(self.dev).float()
+        if self.B is not None:
+            Z = Z @ self.B[layer].T                # y = B h (J-Lens spec 6.4)
+
+        # ---- protocol 7.4 double residualisation
+        mu = Z.mean(0, keepdim=True)
+        D = Z.shape[1]
+        mu_r = torch.zeros(self.n_rel, D, device=self.dev)
+        cr = torch.zeros(self.n_rel, device=self.dev)
+        mu_r.index_add_(0, self.rel_idx, Z)
+        cr.index_add_(0, self.rel_idx, torch.ones_like(self.rel_idx, dtype=torch.float))
+        mu_r /= cr.clamp_min(1).unsqueeze(-1)
+        mu_t = torch.zeros(len(self.families), D, device=self.dev)
+        ct = torch.zeros(len(self.families), device=self.dev)
+        mu_t.index_add_(0, self.fam_idx, Z)
+        ct.index_add_(0, self.fam_idx, torch.ones_like(self.fam_idx, dtype=torch.float))
+        mu_t /= ct.clamp_min(1).unsqueeze(-1)
+        Z = Z - mu_r[self.rel_idx] - mu_t[self.fam_idx] + mu
+
+        Z = l2n(whiten(Z, icfg["pca_dim"], icfg["shrinkage"], eps))
+
+        # ---- protocol 7.6 family centroid: average inside the family FIRST, so
+        # paraphrase (10,053 queries) cannot outweigh anchor (2,592) in one fact
+        F, T, Dn = self.n_facts, len(self.families), Z.shape[1]
+        V = torch.zeros(F, T, Dn, device=self.dev)
+        cnt = torch.zeros(F, T, device=self.dev)
+        flat = self.fact_idx * T + self.fam_idx
+        V.view(-1, Dn).index_add_(0, flat, Z)
+        cnt.view(-1).index_add_(0, flat, torch.ones_like(flat, dtype=torch.float))
+        mask = cnt > 0
+        V = V / cnt.clamp_min(1).unsqueeze(-1)
+        V = l2n(V) * mask.unsqueeze(-1)
+
+        if self.shuffle_seed is not None:
+            # Permute the fact axis INDEPENDENTLY per family, and permute within
+            # a relation so the shuffled control keeps the same relation
+            # composition -- otherwise a drop could just mean facts got matched
+            # against a different relation, which is not the null being tested.
+            g = torch.Generator().manual_seed(self.shuffle_seed + 1000 * layer)
+            for t in range(T):
+                for members in self.by_rel.values():
+                    idx = torch.tensor(members)
+                    perm = idx[torch.randperm(len(members), generator=g)]
+                    V[idx, t] = V[perm.to(V.device), t].clone()
+                    mask[idx, t] = mask[perm.to(mask.device), t].clone()
+        return V, mask

ICLR dataset/protocol/bcs_bes_iss_kts_evaluation_protocol (1).md

@@ -0,0 +1,1604 @@
+# BCS、BES、ISS 与 KTS 评测规范
+
+## 0. 目的
+
+本规范用于在固定事实知识数据集上评测大语言模型的：
+
+1. **外部行为一致性**；
+2. **内部事实状态稳定性**；
+3. **整体知识拓扑稳定性**。
+
+最终报告四个核心指标：
+
+\[
+\boxed{
+\mathrm{BCS},\quad
+\mathrm{BES},\quad
+\mathrm{ISS},\quad
+\mathrm{KTS}
+}
+\]
+
+其中：
+
+| 指标 | 全称 | 分析层级 | 核心问题 |
+|---|---|---|---|
+| BCS | Behavioral Consistency Score | 单事实、外部行为 | 不同检索条件下是否主要表达同一个答案？ |
+| BES | Behavioral Entropy Stability | 单事实、外部行为 | 回答分布是否集中，还是分散到多个答案？ |
+| ISS | Internal State Stability | 单事实、内部表示 | 同一事实跨条件是否形成一致且可区分的内部状态？ |
+| KTS | Knowledge Topology Stability | 数据集、内部空间 | 不同条件下事实身份与整体知识几何是否保持？ |
+
+本规范默认使用固定主事实集：
+
+\[
+\mathcal D=\{f_1,\ldots,f_N\},\qquad N=2,592.
+\]
+
+所有被测模型使用完全相同的事实和 query bank。模型在 anchor 条件下是否回答正确，只作为标签，不改变评测分母。
+
+---
+
+# 1. 评测条件
+
+## 1.1 主前向检索条件
+
+以下条件保持检索目标为：
+
+\[
+(s,r)\rightarrow o.
+\]
+
+记主条件集合为：
+
+\[
+\mathcal T=
+\{
+\text{anchor},
+\text{paraphrase},
+\text{format},
+\text{context},
+\text{multilingual}
+\}.
+\]
+
+这些条件进入 BCS、BES、ISS 和 KTS 的主要计算。
+
+## 1.2 独立诊断条件
+
+以下条件不混入主指标：
+
+- `recognition`：正确答案已经出现在候选中，属于辅助识别；
+- `reverse`：检索目标从 object 改为 subject，单独报告 structural retrieval；
+- `reverse_illposed`：反向映射不唯一，只用于数据诊断。
+
+## 1.3 覆盖不完整时的处理
+
+当前数据中：
+
+- anchor：覆盖 2,592 条事实；
+- paraphrase：覆盖 2,592 条事实；
+- format：覆盖 2,592 条事实；
+- context：覆盖 2,591 条事实；
+- multilingual：覆盖 2,402 条事实。
+
+推荐优先补齐缺失条件。
+
+在未补齐前，应同时报告：
+
+### Complete-family 主结果
+
+仅使用具备全部五个主条件的事实集合：
+
+\[
+\mathcal D_{\cap}
+=
+\bigcap_{t\in\mathcal T}\mathcal D_t.
+\]
+
+这是最严格、最可比的主结果。
+
+### Full-set 补充结果
+
+对每条事实使用其实际存在的条件集合：
+
+\[
+\mathcal T_f
+=
+\{t\in\mathcal T:f\in\mathcal D_t\}.
+\]
+
+所有平均都按可用 condition family 等权计算，并报告每个指标的有效样本数。
+
+不能为缺失条件伪造零分，也不能把不同模型的有效事实集设为不同集合。
+
+---
+
+# 2. 必要输入
+
+## 2.1 Fact 文件
+
+每条事实至少包含：
+
+```json
+{
+  "fact_id": "fact_000001",
+  "subject": "France",
+  "relation": "capital",
+  "object": "Paris",
+  "gold_aliases": ["Paris", "City of Paris"],
+  "answer_type": "city",
+  "answer_granularity": "entity"
+}
+```
+
+## 2.2 Query 文件
+
+每条 query 至少包含：
+
+```json
+{
+  "query_id": "query_00000001",
+  "fact_id": "fact_000001",
+  "condition_family": "paraphrase",
+  "variant_id": "para_02",
+  "language": "en",
+  "query": "Which city serves as the capital of France?",
+  "target_slot": "object",
+  "use_for_main_forward": true
+}
+```
+
+## 2.3 模型输出文件
+
+```json
+{
+  "model": "model_name",
+  "query_id": "query_00000001",
+  "fact_id": "fact_000001",
+  "condition_family": "paraphrase",
+  "raw_response": "The answer is Paris.",
+  "generation_config": {
+    "do_sample": false,
+    "temperature": 0,
+    "max_new_tokens": 24
+  }
+}
+```
+
+## 2.4 内部表示文件
+
+ISS 和 KTS 需要在模型尚未生成第一个答案 token 时，提取问题末位位置的 residual state：
+
+```json
+{
+  "model": "model_name",
+  "query_id": "query_00000001",
+  "fact_id": "fact_000001",
+  "condition_family": "paraphrase",
+  "layer": 16,
+  "position": "query_end",
+  "hidden_state_path": "..."
+}
+```
+
+必须保证所有 query 使用同一种位置定义：
+
+> 输入 prompt 的最后一个有效 token，即模型读完问题但尚未开始生成答案的位置。
+
+---
+
+# 3. AI Judge 输出协议
+
+BCS 和 BES 不直接比较原始字符串，而基于 AI Judge 得到的语义答案 cluster。
+
+整个过程分为两步。
+
+## 3.1 Reference-blind 答案抽取与聚类
+
+Judge 不看 gold answer，只完成：
+
+1. 提取回答最终主张的核心答案；
+2. 忽略句式、语言、标点和解释性文字；
+3. 将语义等价答案归为同一 cluster；
+4. 标记拒答、多答案和无法解析输出。
+
+例如：
+
+```text
+Paris
+The answer is Paris.
+Paris, France.
+巴黎
+```
+
+应归入同一个语义 cluster。
+
+建议特殊 cluster：
+
+- `ABSTAIN`：拒答或明确表示不知道；
+- `MULTIPLE`：给出多个冲突答案且未选择；
+- `UNPARSEABLE`：无法提取明确答案；
+- 具��实体或命题 cluster，如 `ENTITY_Q90` 或 `SEMANTIC_PARIS`。
+
+Judge 输出：
+
+```json
+{
+  "query_id": "query_00000001",
+  "fact_id": "fact_000001",
+  "cluster_id": "ENTITY_Q90",
+  "canonical_meaning": "Paris",
+  "status": "ANSWER",
+  "confidence": 0.98
+}
+```
+
+同一事实的所有主条件输出应一次性或全局一致地聚类，避免两两判断产生非传递关系。
+
+## 3.2 Reference-aware 正确性判断
+
+第二步再向 Judge 提供：
+
+- gold answer；
+- accepted aliases；
+- answer type；
+- answer granularity。
+
+对每个语义 cluster 标记：
+
+- `CORRECT`；
+- `INCORRECT`；
+- `ABSTAIN`；
+- `AMBIGUOUS`；
+- `REVIEW_REQUIRED`。
+
+该步骤用于区分 Stable Correct 和 Stable Wrong，但不参与答案 cluster 的形成。
+
+---
+
+# 4. BCS：Behavioral Consistency Score
+
+## 4.1 为什么需要 family-balanced 计算
+
+不同 condition family 的 query 数量差异很大。例如：
+
+- paraphrase 可能有 3–5 个版本；
+- multilingual 可能有多个语言版本；
+- anchor 通常只有 1 条。
+
+如果直接按全部 query 计数，query 更多的 family 会支配结果。
+
+因此必须先在每个 family 内计算答案分布，再对 family 等权聚合。
+
+## 4.2 Family 内答案分布
+
+设事实 \(f\) 在 family \(t\) 下的 query 集为：
+
+\[
+Q_{f,t}.
+\]
+
+AI Judge 给 query \(q\) 分配语义 cluster：
+
+\[
+\kappa_{m,f,q}.
+\]
+
+对于答案 cluster \(a\)，定义：
+
+\[
+p_{m,f,t}(a)
+=
+\frac{1}{|Q_{f,t}|}
+\sum_{q\in Q_{f,t}}
+\mathbb I[
+\kappa_{m,f,q}=a
+].
+\]
+
+每个 family 的总概率满足：
+
+\[
+\sum_a p_{m,f,t}(a)=1.
+\]
+
+## 4.3 跨 family 等权聚合
+
+对事实 \(f\) 的有效主条件集合 \(\mathcal T_f\)，定义：
+
+\[
+p_{m,f}(a)
+=
+\frac{1}{|\mathcal T_f|}
+\sum_{t\in\mathcal T_f}
+p_{m,f,t}(a).
+\]
+
+这样每个 condition family 权重相同，不受该 family 中 query 数量影响。
+
+## 4.4 BCS 定义
+
+\[
+\boxed{
+\mathrm{BCS}_{m,f}
+=
+\max_a p_{m,f}(a)
+}
+\]
+
+取最大概率的 cluster：
+
+\[
+a^*_{m,f}
+=
+\arg\max_a p_{m,f}(a).
+\]
+
+解释：
+
+- \(\mathrm{BCS}=1\)：所有有效条件都只支持同一个语义答案；
+- \(\mathrm{BCS}=0.8\)：主要答案获得 80% 的 family-balanced 概率；
+- BCS 较低：输出分散到多个答案。
+
+BCS 不判断主答案是否正确。
+
+例如，gold 是 `Canberra`，但所有条件都回答 `Sydney`：
+
+\[
+\mathrm{BCS}=1.
+\]
+
+这是高度稳定但错误的行为。
+
+## 4.5 模型级 BCS
+
+\[
+\boxed{
+\mathrm{BCS}_m
+=
+\frac{1}{|\mathcal D_{\mathrm{eval}}|}
+\sum_{f\in\mathcal D_{\mathrm{eval}}}
+\mathrm{BCS}_{m,f}
+}
+\]
+
+其中：
+
+- 主结果使用 \(\mathcal D_{\cap}\)；
+- 补充结果可使用完整可用集合。
+
+---
+
+# 5. BES：Behavioral Entropy Stability
+
+BCS 只关注最大答案 cluster，可能忽略剩余概率如何分布。
+
+例如以下两种情况的 BCS 都是 0.6：
+
+```text
+A: 0.6, B: 0.4
+```
+
+和：
+
+```text
+A: 0.6, B: 0.1, C: 0.1, D: 0.1, E: 0.1
+```
+
+第二种回答明显更加分散，因此需要 BES。
+
+## 5.1 答案熵
+
+基于 family-balanced 分布 \(p_{m,f}(a)\)，定义：
+
+\[
+H_{m,f}
+=
+-\sum_{a:p_{m,f}(a)>0}
+p_{m,f}(a)\log p_{m,f}(a).
+\]
+
+设实际观察到的非零答案 cluster 数为：
+
+\[
+A_{m,f}
+=
+\left|
+\{a:p_{m,f}(a)>0\}
+\right|.
+\]
+
+## 5.2 BES 定义
+
+当 \(A_{m,f}=1\) 时：
+
+\[
+\mathrm{BES}_{m,f}=1.
+\]
+
+当 \(A_{m,f}>1\) 时：
+
+\[
+\boxed{
+\mathrm{BES}_{m,f}
+=
+1-
+\frac{H_{m,f}}{\log A_{m,f}}
+}
+\]
+
+解释：
+
+- \(\mathrm{BES}=1\)：回答完全集中于一个 cluster；
+- \(\mathrm{BES}=0\)：回答在所有已观察 cluster 上均匀分布；
+- 值越高，回答分布越集中。
+
+BCS 和 BES 的区别：
+
+- BCS 衡量最大 cluster 的占比；
+- BES 衡量完整答案分布的集中程度。
+
+建议将 BCS 作为主外部稳定性指标，BES 作为补充指标。
+
+## 5.3 模型级 BES
+
+\[
+\boxed{
+\mathrm{BES}_m
+=
+\frac{1}{|\mathcal D_{\mathrm{eval}}|}
+\sum_{f\in\mathcal D_{\mathrm{eval}}}
+\mathrm{BES}_{m,f}
+}
+\]
+
+---
+
+# 6. 外部行为类型
+
+设置预注册的行为稳定阈值：
+
+\[
+\tau_B=0.8.
+\]
+
+根据主答案 cluster \(a^*_{m,f}\) 的正确性，将事实划分为：
+
+## 6.1 Stable Correct
+
+\[
+\mathrm{BCS}_{m,f}\ge \tau_B
+\]
+
+且：
+
+\[
+a^*_{m,f}\text{ 被 Judge 标记为 CORRECT}.
+\]
+
+## 6.2 Stable Wrong
+
+\[
+\mathrm{BCS}_{m,f}\ge \tau_B
+\]
+
+且主 cluster 是明确的错误答案。
+
+## 6.3 Stable Abstention
+
+\[
+\mathrm{BCS}_{m,f}\ge \tau_B
+\]
+
+且：
+
+\[
+a^*_{m,f}=\mathrm{ABSTAIN}.
+\]
+
+## 6.4 Unstable
+
+\[
+\mathrm{BCS}_{m,f}<\tau_B.
+\]
+
+建议额外做阈值敏感性分析：
+
+\[
+\tau_B\in\{0.7,0.8,0.9\}.
+\]
+
+模型级比例：
+
+\[
+\mathrm{SCR}_m
+=
+\frac{\#\text{Stable Correct}}{|\mathcal D_{\mathrm{eval}}|},
+\]
+
+\[
+\mathrm{SWR}_m
+=
+\frac{\#\text{Stable Wrong}}{|\mathcal D_{\mathrm{eval}}|},
+\]
+
+\[
+\mathrm{SAR}_m
+=
+\frac{\#\text{Stable Abstention}}{|\mathcal D_{\mathrm{eval}}|},
+\]
+
+\[
+\mathrm{UR}_m
+=
+\frac{\#\text{Unstable}}{|\mathcal D_{\mathrm{eval}}|}.
+\]
+
+四者应满足：
+
+\[
+\mathrm{SCR}_m+
+\mathrm{SWR}_m+
+\mathrm{SAR}_m+
+\mathrm{UR}_m
+=1.
+\]
+
+---
+
+# 7. ISS：Internal State Stability
+
+## 7.1 测量目标
+
+ISS 衡量：
+
+> 同一事实在不同主检索条件下，是否形成一致且具有事实区分性的内部状态。
+
+ISS 不依赖模型最终答案是否正确，也不依赖 gold answer 是单 token 还是多 token。
+
+## 7.2 Query-end hidden state
+
+对于模型 \(m\)、事实 \(f\)、query \(q\) 和层 \(\ell\)，提取：
+
+\[
+h^\ell_{m,f,q}\in\mathbb R^{d_m}.
+\]
+
+位置固定为 query 最后一个有效输入 token。
+
+## 7.3 J-Lens Jacobian transport
+
+对每一层估计平均 Jacobian transport：
+
+\[
+J^\ell_m
+=
+\mathbb E_x
+\left[
+\frac{\partial h^L_m}{\partial h^\ell_m}
+\right].
+\]
+
+将第 \(\ell\) 层状态运输到 final-layer residual basis：
+
+\[
+\boxed{
+z^\ell_{m,f,q}
+=
+J^\ell_m h^\ell_{m,f,q}
+}
+\]
+
+这里只使用运输后的 hidden representation，不乘 unembedding matrix，因此不进入 vocabulary space。
+
+如果暂时无法实现 Jacobian transport，可以用 raw hidden state 计算一个 `Raw-ISS` 作为消融，但主指标应使用 transported state。
+
+## 7.4 去除 relation 和 condition family 主效应
+
+对每个模型和层计算：
+
+\[
+\mu^\ell_m
+=
+\mathbb E_{f,q}[z^\ell_{m,f,q}],
+\]
+
+\[
+\mu^\ell_{m,r}
+=
+\mathbb E_{f,q:r_f=r}[z^\ell_{m,f,q}],
+\]
+
+\[
+\mu^\ell_{m,t}
+=
+\mathbb E_{f,q:t(q)=t}[z^\ell_{m,f,q}].
+\]
+
+双重残差化：
+
+\[
+\bar z^\ell_{m,f,q}
+=
+z^\ell_{m,f,q}
+-
+\mu^\ell_{m,r_f}
+-
+\mu^\ell_{m,t(q)}
++
+\mu^\ell_m.
+\]
+
+该步骤用于减少：
+
+- relation 类型共有方向；
+- query 格式共有方向；
+- 语言 family 共有方向；
+- residual stream 公共均值。
+
+## 7.5 正则化白化
+
+估计协方差：
+
+\[
+\Sigma^\ell_m
+=
+\operatorname{Cov}
+\left(
+\bar z^\ell_{m,f,q}
+\right).
+\]
+
+定义：
+
+\[
+\tilde z^\ell_{m,f,q}
+=
+\left(
+\Sigma^\ell_m+\lambda I
+\right)^{-1/2}
+\bar z^\ell_{m,f,q}.
+\]
+
+实践建议：
+
+- 使用 shrinkage covariance；
+- 或使用 PCA whitening；
+- PCA 维度固定为 \(\min(512,d_m)\)；
+- 所有 query 使用同一个模型、同一层的变换；
+- 不允许为不同 condition family 单独拟合白化矩阵。
+
+随后进行 L2 归一化：
+
+\[
+\hat z^\ell_{m,f,q}
+=
+\frac{\tilde z^\ell_{m,f,q}}
+{\|\tilde z^\ell_{m,f,q}\|_2+\epsilon}.
+\]
+
+## 7.6 Family centroid
+
+一个 family 内可能有多个 query。为了避免 query 数量多的 family 获得更高权重，先计算 family centroid：
+
+\[
+v^\ell_{m,f,t}
+=
+\operatorname{Normalize}
+\left(
+\frac{1}{|Q_{f,t}|}
+\sum_{q\in Q_{f,t}}
+\hat z^\ell_{m,f,q}
+\right).
+\]
+
+每条事实在每个 condition family 下只保留一个表示。
+
+## 7.7 同事实跨 family 相似度
+
+设事实 \(f\) 的有效 family pair 集为：
+
+\[
+\mathcal P_f
+=
+\{(t,t'):t,t'\in\mathcal T_f,\ t<t'\}.
+\]
+
+定义正样本相似度：
+
+\[
+S^+_{m,f,\ell}
+=
+\frac{1}{|\mathcal P_f|}
+\sum_{(t,t')\in\mathcal P_f}
+\cos
+\left(
+v^\ell_{m,f,t},
+v^\ell_{m,f,t'}
+\right).
+\]
+
+## 7.8 同 relation 背景相似度
+
+为每个事实选择同 relation、不同事实的负样本集合：
+
+\[
+\mathcal N_f
+=
+\{g:g\neq f,\ r_g=r_f\}.
+\]
+
+对于每个 family pair，使用对称背景：
+
+\[
+B_{m,f,\ell}(t,t')
+=
+\frac{1}{2|\mathcal N_f|}
+\sum_{g\in\mathcal N_f}
+\left[
+\cos(v^\ell_{m,f,t},v^\ell_{m,g,t'})
++
+\cos(v^\ell_{m,f,t'},v^\ell_{m,g,t})
+\right].
+\]
+
+再定义：
+
+\[
+S^-_{m,f,\ell}
+=
+\frac{1}{|\mathcal P_f|}
+\sum_{(t,t')\in\mathcal P_f}
+B_{m,f,\ell}(t,t').
+\]
+
+如果同 relation 事实过多，可以固定随机采样最多 100 个负事实，并对所有模型使用同一采样列表。
+
+## 7.9 ISS 定义
+
+\[
+\boxed{
+\mathrm{ISS}_{m,f,\ell}
+=
+\frac{
+S^+_{m,f,\ell}
+-
+S^-_{m,f,\ell}
+}{
+1-S^-_{m,f,\ell}+\epsilon
+}
+}
+\]
+
+解释：
+
+- 接近 1：同一事实跨条件高度一致；
+- 接近 0：同一事实的相似性不高于同 relation 背景；
+- 小于 0：跨条件表示比其他事实背景还不一致。
+
+该值理论上可能小于 \(-1\)。统计分析应保留原始值；如果用于图表展示，可额外报告裁剪版本：
+
+\[
+\mathrm{ISS}^{\mathrm{clip}}
+=
+\operatorname{clip}(\mathrm{ISS},-1,1).
+\]
+
+不要用裁剪值替代原始统计值。
+
+## 7.10 跨层 ISS
+
+将相对层深定义为：
+
+\[
+d_\ell
+=
+\frac{\ell}{L_m-1}.
+\]
+
+预注册主分析窗口：
+
+\[
+\mathcal W_m
+=
+\{\ell:0.4\le d_\ell\le1.0\}.
+\]
+
+单事实 ISS：
+
+\[
+\boxed{
+\mathrm{ISS}_{m,f}
+=
+\frac{1}{|\mathcal W_m|}
+\sum_{\ell\in\mathcal W_m}
+\mathrm{ISS}_{m,f,\ell}
+}
+\]
+
+模型级 ISS：
+
+\[
+\boxed{
+\mathrm{ISS}_m
+=
+\frac{1}{|\mathcal D_{\mathrm{eval}}|}
+\sum_{f\in\mathcal D_{\mathrm{eval}}}
+\mathrm{ISS}_{m,f}
+}
+\]
+
+同时建议报告：
+
+### Peak ISS
+
+\[
+\mathrm{ISS}^{\mathrm{peak}}_{m,f}
+=
+\max_{\ell\in\mathcal W_m}
+\mathrm{ISS}_{m,f,\ell}.
+\]
+
+表示模型是否曾形成过一致事实状态。
+
+### Late ISS
+
+\[
+\mathrm{ISS}^{\mathrm{late}}_{m,f}
+=
+\frac{1}{|\mathcal W^{\mathrm{late}}_m|}
+\sum_{\ell:d_\ell\ge0.8}
+\mathrm{ISS}_{m,f,\ell}.
+\]
+
+表示一致状态是否保持到靠近输出的阶段。
+
+---
+
+# 8. KTS：Knowledge Topology Stability
+
+## 8.1 测量目标
+
+KTS 衡量：
+
+> 不同 condition family 下，整个事实表示空间的相对几何和事实身份是否保持。
+
+KTS 不要求不同问法触发相同的计算路径。
+
+它允许：
+
+- 整体空间旋转；
+- 平移；
+- 各向同性缩放；
+- 不同语言使用不同内部实现。
+
+只要事实间相对结构和事实身份仍可保持，KTS 就可以较高。
+
+## 8.2 Condition-specific knowledge space
+
+对 condition family \(t\)、层 \(\ell\)，将所有有效事实的 family centroid 组成：
+
+\[
+V^\ell_{m,t}
+=
+\begin{bmatrix}
+v^\ell_{m,1,t}\\
+v^\ell_{m,2,t}\\
+\vdots\\
+v^\ell_{m,N_t,t}
+\end{bmatrix}.
+\]
+
+对 family pair \((t,t')\)，只使用共同覆盖事实：
+
+\[
+\mathcal D_{t,t'}
+=
+\mathcal D_t\cap\mathcal D_{t'}.
+\]
+
+不同模型必须使用完全相同的 \(\mathcal D_{t,t'}\)。
+
+---
+
+# 9. KTS-Geo：全局几何稳定性
+
+## 9.1 Relation 内距离矩阵
+
+为减少 relation 不平衡和 relation 间宏观差异的支配作用，KTS-Geo 按 relation 计算后再宏平均。
+
+对于 relation \(r\)，定义：
+
+\[
+\mathcal D_{r,t,t'}
+=
+\{f\in\mathcal D_{t,t'}:r_f=r\}.
+\]
+
+仅保留至少包含 5 条事实的 relation。
+
+在 family \(t\) 下构造 relation 内距离：
+
+\[
+D^\ell_{m,t,r}(f,g)
+=
+1-
+\cos
+\left(
+v^\ell_{m,f,t},
+v^\ell_{m,g,t}
+\right).
+\]
+
+在 family \(t'\) 下类似构造：
+
+\[
+D^\ell_{m,t',r}(f,g).
+\]
+
+## 9.2 Relation 内几何相关性
+
+\[
+\rho^\ell_{m,r}(t,t')
+=
+\operatorname{Spearman}
+\left(
+\operatorname{vec}_{f<g}D^\ell_{m,t,r},
+\operatorname{vec}_{f<g}D^\ell_{m,t',r}
+\right).
+\]
+
+## 9.3 Relation-macro KTS-Geo
+
+\[
+\boxed{
+\mathrm{KTS}^{\mathrm{geo}}_{m,\ell}(t,t')
+=
+\frac{1}{|\mathcal R_{t,t'}|}
+\sum_{r\in\mathcal R_{t,t'}}
+\rho^\ell_{m,r}(t,t')
+}
+\]
+
+该值范围为：
+
+\[
+[-1,1].
+\]
+
+解释：
+
+- 1：事实距离排序完全保持；
+- 0：两个条件下的事实几何无显著对应；
+- 负值：事实距离结构发生反向重排。
+
+为了与 KTS-ID 合成，需要映射到 \([0,1]\)：
+
+\[
+\widetilde{\mathrm{KTS}}^{\mathrm{geo}}
+=
+\frac{
+\mathrm{KTS}^{\mathrm{geo}}+1
+}{2}.
+\]
+
+---
+
+# 10. KTS-ID：事实身份稳定性
+
+全局距离结构可能看起来类似，但局部事实身份仍可能交换，因此需要 cross-condition fact identification。
+
+## 10.1 跨条件最近邻检索
+
+对于事实 \(f\) 在 family \(t\) 下的表示，在 family \(t'\) 的同 relation 事实中检索最近邻：
+
+\[
+\hat f_{t\rightarrow t'}
+=
+\arg\max_{
+g\in\mathcal D_{r_f,t,t'}
+}
+\cos
+\left(
+v^\ell_{m,f,t},
+v^\ell_{m,g,t'}
+\right).
+\]
+
+反向同样计算：
+
+\[
+\hat f_{t'\rightarrow t}.
+\]
+
+## 10.2 Relation 内 Top-1 身份准确率
+
+\[
+\mathrm{ID}_{m,\ell,r}(t\rightarrow t')
+=
+\frac{1}{|\mathcal D_{r,t,t'}|}
+\sum_{f\in\mathcal D_{r,t,t'}}
+\mathbb I[
+\hat f_{t\rightarrow t'}=f
+].
+\]
+
+进行双向平均：
+
+\[
+\mathrm{ID}^{\mathrm{sym}}_{m,\ell,r}(t,t')
+=
+\frac{
+\mathrm{ID}_{m,\ell,r}(t\rightarrow t')
++
+\mathrm{ID}_{m,\ell,r}(t'\rightarrow t)
+}{2}.
+\]
+
+## 10.3 Chance correction
+
+若 relation \(r\) 有 \(n_r\) 条事实，随机 Top-1 命中的概率为：
+
+\[
+b_r=\frac{1}{n_r}.
+\]
+
+定义 chance-corrected identity：
+
+\[
+\mathrm{ID}^{\mathrm{adj}}_{m,\ell,r}
+=
+\frac{
+\mathrm{ID}^{\mathrm{sym}}_{m,\ell,r}-b_r
+}{
+1-b_r+\epsilon
+}.
+\]
+
+用于合成时裁剪到：
+
+\[
+[0,1].
+\]
+
+## 10.4 Relation-macro KTS-ID
+
+\[
+\boxed{
+\mathrm{KTS}^{\mathrm{id}}_{m,\ell}(t,t')
+=
+\frac{1}{|\mathcal R_{t,t'}|}
+\sum_{r\in\mathcal R_{t,t'}}
+\operatorname{clip}
+\left(
+\mathrm{ID}^{\mathrm{adj}}_{m,\ell,r},
+0,1
+\right)
+}
+\]
+
+建议同时报告原始：
+
+- Top-1 accuracy；
+- Top-5 accuracy；
+- mean reciprocal rank；
+- chance-corrected Top-1。
+
+主 KTS 使用 chance-corrected Top-1。
+
+---
+
+# 11. KTS 合成
+
+对于 family pair \((t,t')\) 和层 \(\ell\)，定义：
+
+\[
+g
+=
+\widetilde{\mathrm{KTS}}^{\mathrm{geo}}_{m,\ell}(t,t'),
+\]
+
+\[
+i
+=
+\mathrm{KTS}^{\mathrm{id}}_{m,\ell}(t,t').
+\]
+
+使用调和平均：
+
+\[
+\boxed{
+\mathrm{KTS}_{m,\ell}(t,t')
+=
+\frac{
+2gi
+}{
+g+i+\epsilon
+}
+}
+\]
+
+使用调和平均的原因是：
+
+- 只有几何稳定但事实身份无法匹配，不应获得高 KTS；
+- 只有身份匹配但整体邻域结构严重扭曲，也不应获得高 KTS。
+
+## 11.1 跨 family pair 平均
+
+主 family pair 集：
+
+\[
+\mathcal P_{\mathcal T}
+=
+\{(t,t'):t,t'\in\mathcal T,\ t<t'\}.
+\]
+
+每个 pair 等权：
+
+\[
+\mathrm{KTS}_{m,\ell}
+=
+\frac{1}{|\mathcal P_{\mathcal T}|}
+\sum_{(t,t')\in\mathcal P_{\mathcal T}}
+\mathrm{KTS}_{m,\ell}(t,t').
+\]
+
+不能按 pair 中 query 数或事实数加权，否则覆盖更大的 family 会支配结果。
+
+## 11.2 跨层 KTS
+
+\[
+\boxed{
+\mathrm{KTS}_m
+=
+\frac{1}{|\mathcal W_m|}
+\sum_{\ell\in\mathcal W_m}
+\mathrm{KTS}_{m,\ell}
+}
+\]
+
+建议主表同时展示：
+
+- KTS-Geo；
+- KTS-ID；
+- KTS composite。
+
+不要只报告 composite 而隐藏两个组成部分。
+
+---
+
+# 12. 四个指标的联合解释
+
+| BCS/BES | ISS | KTS | 解释 |
+|---|---:|---:|---|
+| 高 | 高 | 高 | 输出、单事实状态和整体知识结构均稳定 |
+| 高 | 低 | 低 | 表面答案一致，但内部状态和知识组织不稳定 |
+| 高 | 高 | 低 | 单事实局部状态一致，但整体空间可能坍缩或重排 |
+| 低 | 高 | 高 | 内部知识较稳定，失败更可能发生在后期选择或表达 |
+| 低 | 低 | 高 | 不同条件引起统一坐标变化，但知识拓扑仍保持 |
+| 低 | 低 | 低 | 外部行为、单事实状态和知识空间均不稳定 |
+
+对于 Stable Wrong：
+
+- BCS/BES 高；
+- 主 cluster 被判为错误；
+- ISS 和 KTS 高；
+
+表示模型可能稳定形成并组织了一个错误事实关联。
+
+这不应称为“正确知识稳定”，而应称为：
+
+> stable internal misalignment 或 stable wrong association。
+
+---
+
+# 13. 推荐主结果表
+
+## 13.1 模型总体结果
+
+| Model | Anchor Acc. | BCS | BES | Stable Correct | Stable Wrong | Stable Abstention | ISS | KTS-Geo | KTS-ID | KTS |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| Model A |  |  |  |  |  |  |  |  |  |  |
+| Model B |  |  |  |  |  |  |  |  |  |  |
+
+## 13.2 按行为类型分析内部稳定性
+
+| Behavior group | Facts | ISS | KTS-Geo | KTS-ID | KTS |
+|---|---:|---:|---:|---:|---:|
+| Stable Correct |  |  |  |  |  |
+| Stable Wrong |  |  |  |  |  |
+| Stable Abstention |  |  |  |  |  |
+| Unstable |  |  |  |  |  |
+
+## 13.3 按 condition pair 报告 KTS
+
+| Pair | Shared facts | KTS-Geo | KTS-ID | KTS |
+|---|---:|---:|---:|---:|
+| Anchor–Paraphrase |  |  |  |  |
+| Anchor–Format |  |  |  |  |
+| Anchor–Context |  |  |  |  |
+| Anchor–Multilingual |  |  |  |  |
+| Paraphrase–Format |  |  |  |  |
+| ... |  |  |  |  |
+
+---
+
+# 14. 推荐统计协议
+
+## 14.1 Relation-clustered bootstrap
+
+由于 21 个 relation 的事实数量不均衡，不能只对所有事实进行普通独立 bootstrap。
+
+推荐：
+
+1. 有放回采样 relation；
+2. 在每个采样 relation 内有放回采样事实；
+3. 重复 1,000 次；
+4. 报告 95% percentile confidence interval。
+
+对 KTS-Geo 和 KTS-ID，应在每次 bootstrap 内重新计算关系宏平均。
+
+## 14.2 模型间比较
+
+比较模型 A 和 B 时使用 paired bootstrap：
+
+- 每次使用相同的 relation 和 fact 重采样；
+- 计算指标差：
+  \[
+  \Delta=\mathrm{Metric}_A-\mathrm{Metric}_B;
+  \]
+- 报告 \(\Delta\) 的 95% CI。
+
+## 14.3 随机性控制
+
+必须固定：
+
+- 模型 revision；
+- tokenizer revision；
+- generation 参数；
+- Judge 模型和 revision；
+- Judge temperature；
+- negative fact sampling；
+- PCA 或 randomized SVD seed；
+- bootstrap seed。
+
+---
+
+# 15. 评测流程
+
+```text
+固定 2,592 条事实和 query bank
+          |
+          v
+对每个模型运行全部 query 的贪婪生成
+          |
+          v
+Reference-blind AI Judge 抽取与语义聚类
+          |
+          +--> Reference-aware Judge 标记正确性
+          |
+          +--> 计算 BCS、BES 和行为类别
+          |
+          v
+提取主前向 query 的 query-end hidden states
+          |
+          v
+计算 J-Lens Jacobian transport
+          |
+          v
+relation/condition 残差化 + whitening
+          |
+          v
+构造每个 fact-family 的 centroid
+          |
+          +--> 计算 ISS
+          |
+          +--> 构建 condition-specific knowledge spaces
+                    |
+                    +--> KTS-Geo
+                    +--> KTS-ID
+                    +--> KTS composite
+```
+
+---
+
+# 16. Python 风格伪代码
+
+## 16.1 BCS 和 BES
+
+```python
+from collections import defaultdict
+import math
+
+
+def compute_bcs_bes(records, main_families):
+    family_cluster_counts = defaultdict(lambda: defaultdict(int))
+    family_totals = defaultdict(int)
+
+    for item in records:
+        family = item["condition_family"]
+        if family not in main_families:
+            continue
+        cluster = item["cluster_id"]
+        family_cluster_counts[family][cluster] += 1
+        family_totals[family] += 1
+
+    valid_families = sorted(family_totals)
+    if not valid_families:
+        raise ValueError("No valid main-family queries.")
+
+    clusters = {
+        cluster
+        for family in valid_families
+        for cluster in family_cluster_counts[family]
+    }
+
+    p = {}
+    for cluster in clusters:
+        p[cluster] = sum(
+            family_cluster_counts[family].get(cluster, 0)
+            / family_totals[family]
+            for family in valid_families
+        ) / len(valid_families)
+
+    modal_cluster = max(p, key=p.get)
+    bcs = p[modal_cluster]
+
+    positive_probs = [value for value in p.values() if value > 0]
+    if len(positive_probs) == 1:
+        bes = 1.0
+    else:
+        entropy = -sum(value * math.log(value) for value in positive_probs)
+        bes = 1.0 - entropy / math.log(len(positive_probs))
+
+    return {
+        "bcs": bcs,
+        "bes": bes,
+        "modal_cluster": modal_cluster,
+        "cluster_distribution": p,
+        "valid_families": valid_families,
+    }
+```
+
+## 16.2 Family centroid
+
+```python
+import numpy as np
+
+
+def l2_normalize(x, eps=1e-12):
+    return x / max(np.linalg.norm(x), eps)
+
+
+def family_centroid(query_vectors):
+    normalized = [l2_normalize(x) for x in query_vectors]
+    return l2_normalize(np.mean(normalized, axis=0))
+```
+
+## 16.3 单层 ISS
+
+```python
+def compute_iss_for_fact(
+    family_vectors,
+    same_relation_fact_vectors,
+    eps=1e-12,
+):
+    families = sorted(family_vectors)
+    positive = []
+    negative = []
+
+    for i, family_a in enumerate(families):
+        for family_b in families[i + 1:]:
+            va = family_vectors[family_a]
+            vb = family_vectors[family_b]
+            positive.append(float(np.dot(va, vb)))
+
+            pair_negatives = []
+            for other in same_relation_fact_vectors:
+                if family_a not in other or family_b not in other:
+                    continue
+                pair_negatives.append(
+                    0.5 * (
+                        float(np.dot(va, other[family_b]))
+                        + float(np.dot(vb, other[family_a]))
+                    )
+                )
+            if pair_negatives:
+                negative.append(float(np.mean(pair_negatives)))
+
+    s_pos = float(np.mean(positive))
+    s_neg = float(np.mean(negative))
+    iss = (s_pos - s_neg) / (1.0 - s_neg + eps)
+
+    return {
+        "s_positive": s_pos,
+        "s_background": s_neg,
+        "iss": iss,
+    }
+```
+
+## 16.4 KTS-ID
+
+```python
+def cross_condition_top1(vectors_a, vectors_b, fact_ids):
+    vectors_a = np.asarray([l2_normalize(x) for x in vectors_a])
+    vectors_b = np.asarray([l2_normalize(x) for x in vectors_b])
+
+    sim_ab = vectors_a @ vectors_b.T
+    sim_ba = vectors_b @ vectors_a.T
+
+    pred_ab = np.argmax(sim_ab, axis=1)
+    pred_ba = np.argmax(sim_ba, axis=1)
+    gold = np.arange(len(fact_ids))
+
+    acc_ab = np.mean(pred_ab == gold)
+    acc_ba = np.mean(pred_ba == gold)
+    acc_sym = 0.5 * (acc_ab + acc_ba)
+
+    chance = 1.0 / len(fact_ids)
+    adjusted = (acc_sym - chance) / max(1.0 - chance, 1e-12)
+
+    return {
+        "top1_symmetric": acc_sym,
+        "chance": chance,
+        "chance_corrected": float(np.clip(adjusted, 0.0, 1.0)),
+    }
+```
+
+---
+
+# 17. 输出文件建议
+
+```text
+metrics/
+├── behavioral_per_query.jsonl
+├── behavioral_per_fact.jsonl
+├── behavioral_model_summary.json
+├── hidden_family_centroids/
+├── iss_per_fact_layer.jsonl
+├── iss_per_fact.jsonl
+├── iss_model_summary.json
+├── kts_per_pair_layer.jsonl
+├── kts_model_summary.json
+├── bootstrap_intervals.json
+└── evaluation_manifest.json
+```
+
+## 17.1 behavioral_per_fact.jsonl
+
+```json
+{
+  "model": "model_name",
+  "fact_id": "fact_000001",
+  "bcs": 0.95,
+  "bes": 0.82,
+  "modal_cluster": "ENTITY_Q90",
+  "modal_correctness": "CORRECT",
+  "behavior_group": "Stable Correct",
+  "valid_families": [
+    "anchor",
+    "paraphrase",
+    "format",
+    "context",
+    "multilingual"
+  ]
+}
+```
+
+## 17.2 iss_per_fact.jsonl
+
+```json
+{
+  "model": "model_name",
+  "fact_id": "fact_000001",
+  "relation": "capital",
+  "iss": 0.61,
+  "iss_peak": 0.79,
+  "iss_late": 0.65,
+  "layers_used": [12, 13, 14, 15, 16]
+}
+```
+
+## 17.3 kts_model_summary.json
+
+```json
+{
+  "model": "model_name",
+  "kts_geo": 0.54,
+  "kts_id": 0.68,
+  "kts": 0.60,
+  "family_pairs": {
+    "anchor__paraphrase": {
+      "shared_facts": 2592,
+      "kts_geo": 0.62,
+      "kts_id": 0.76,
+      "kts": 0.68
+    }
+  }
+}
+```
+
+---
+
+# 18. 必做 sanity checks
+
+## 18.1 Query shuffle test
+
+随机打乱 fact_id 与 hidden representation 的对应关系后：
+
+- ISS 应明显下降；
+- KTS-ID 应接近 chance；
+- KTS-Geo 应接近 0。
+
+## 18.2 Duplicate-query test
+
+同一个 query 与自身比较时：
+
+- hidden cosine 应接近 1；
+- ISS 正样本部分应达到上界附近。
+
+## 18.3 Condition-label shuffle
+
+随机打乱 condition family 标签后，family residualization 和 family centroid 不应产生虚假的高稳定性。
+
+## 18.4 Relation-matched negative test
+
+使用同 relation negatives 得到的 ISS 应比随机跨 relation negatives 更严格。主结果必须使用同 relation negatives。
+
+## 18.5 Raw versus transported ablation
+
+报告：
+
+- Raw-ISS；
+- J-transported ISS。
+
+如果两者完全相同，需要检查 Jacobian transport 是否实际生效。
+
+## 18.6 Judge consistency
+
+对至少 300–500 条回答进行人工校验，报告：
+
+- answer extraction accuracy���
+- cluster equivalence accuracy；
+- correctness accuracy；
+- Cohen's \(\kappa\) 或 Krippendorff's \(\alpha\)。
+
+---
+
+# 19. 推荐论文定义
+
+可以在论文中将四个指标概括为：
+
+> **Behavioral Consistency Score (BCS)** measures the family-balanced mass assigned to a model's modal semantic answer across retrieval conditions. **Behavioral Entropy Stability (BES)** measures the concentration of the complete semantic answer distribution. **Internal State Stability (ISS)** measures whether the same fact forms a consistent and fact-discriminative Jacobian-transported representation across retrieval conditions. **Knowledge Topology Stability (KTS)** measures whether fact identity and the relative geometry of the overall knowledge representation space are preserved across conditions.
+
+中文：
+
+> BCS 衡量不同检索条件下主语义答案所占的等条件权重；BES 衡量完整答案分布的集中程度；ISS 衡量同一事实是否跨条件形成一致且具有事实区分性的 Jacobian 运输表示；KTS 衡量不同条件下事实身份及整体知识空间相对几何是否保持。
+
+---
+
+# 20. 最终最小报告集合
+
+每个模型至少报告：
+
+```text
+Anchor Accuracy
+BCS
+BES
+Stable Correct Rate
+Stable Wrong Rate
+Stable Abstention Rate
+Unstable Rate
+ISS
+KTS-Geo
+KTS-ID
+KTS
+```
+
+同时提供：
+
+- 按 relation 的 macro 结果；
+- 按 behavior group 的 ISS/KTS；
+- 按 condition pair 的 KTS；
+- 95% relation-clustered bootstrap confidence intervals；
+- complete-family 和 full-set 两种覆盖口径。

ICLR dataset/protocol/jacobian_transported_iss_engineering_spec (1).md

@@ -0,0 +1,953 @@
+# Engineering Specification for Jacobian-Transported ISS
+
+## 0. Purpose
+
+This document specifies how to implement the official Internal State Stability metric, abbreviated as ISS, using Jacobian-transported hidden states.
+
+The formal metric remains:
+
+\[
+z^\ell_{m,f,q}=J^\ell_m h^\ell_{m,f,q},
+\]
+
+where no vocabulary unembedding matrix is applied. The implementation may approximate \(J^\ell_m\), but the approximation must be independently validated and its numerical error must be reported.
+
+Raw-ISS is retained only for debugging and ablation. It is not the official metric.
+
+---
+
+# 1. Official Definition
+
+For model \(m\), fact \(f\), query \(q\), and source layer \(\ell\), extract the query-end residual state:
+
+\[
+h^\ell_{m,f,q}\in\mathbb R^{d_m}.
+\]
+
+Define the corpus-averaged input-output Jacobian:
+
+\[
+J^\ell_m
+=
+\mathbb E_{x\sim\mathcal C}
+\left[
+\frac{\partial h^L_m(x)}{\partial h^\ell_m(x)}
+\right],
+\]
+
+where \(\mathcal C\) is an independent calibration corpus.
+
+The transported representation is:
+
+\[
+\boxed{z^\ell_{m,f,q}=J^\ell_m h^\ell_{m,f,q}}
+\]
+
+Do **not** compute:
+
+\[
+W_UJ^\ell_m h^\ell_{m,f,q}.
+\]
+
+The official ISS therefore operates in the final-layer residual basis rather than vocabulary-logit space.
+
+---
+
+# 2. Formal Metric Versus Practical Estimator
+
+The formal metric uses the exact population average \(J^\ell_m\). The practical implementation uses a finite-corpus, finite-rank estimator:
+
+\[
+\widehat J^{\ell,(n,k)}_m.
+\]
+
+The practical transported state is:
+
+\[
+\widehat z^\ell_{m,f,q}
+=
+\widehat J^{\ell,(n,k)}_m h^\ell_{m,f,q}.
+\]
+
+The paper should distinguish:
+
+- \(\operatorname{ISS}\): the formal metric;
+- \(\widehat{\operatorname{ISS}}_{n,k}\): the empirical estimator.
+
+The approximation is acceptable only if it satisfies the validation criteria below.
+
+---
+
+# 3. Why Full Jacobians Are Not the General Solution
+
+For hidden dimension \(d\):
+
+\[
+J^\ell_m\in\mathbb R^{d\times d}.
+\]
+
+Materializing this matrix is feasible only for small models. For large models with \(d=4096\), \(5120\), or more, exact recovery across many layers and calibration prompts is prohibitively expensive.
+
+Therefore:
+
+1. full Jacobians are used only for small-model calibration;
+2. large models use a randomized factorized estimator;
+3. approximation quality must be validated for every model rather than inferred from a small model.
+
+---
+
+# 4. Overall Engineering Pipeline
+
+```text
+Stage A: Full-matrix calibration on a small model
+    |
+    v
+Stage B: Per-model approximation validation
+    |
+    v
+Stage C: Freeze estimator settings
+    |
+    v
+Stage D: Official ISS evaluation
+```
+
+The final test set must not be used to choose estimator hyperparameters.
+
+---
+
+# 5. Stage A: Small-Model Full-Matrix Calibration
+
+Use Qwen2.5-0.5B as the primary exact-reference model.
+
+## 5.1 Exact finite-corpus reference
+
+For a fixed calibration corpus of \(n\) prompts, compute:
+
+\[
+J^{\ell,(n)}_{\mathrm{full}}
+=
+\frac{1}{n}
+\sum_{i=1}^{n}J^\ell_{x_i}.
+\]
+
+This is an exact empirical Jacobian for that finite corpus.
+
+Do not call it the exact population Jacobian or universal ground truth. Use one of the following terms:
+
+- full empirical Jacobian reference;
+- exact finite-corpus Jacobian.
+
+## 5.2 Layer coverage
+
+At minimum, compute full references for:
+
+- one early layer;
+- one middle layer;
+- one late layer.
+
+If feasible on Qwen2.5-0.5B, compute every layer.
+
+## 5.3 Candidate ranks
+
+Evaluate:
+
+\[
+k\in\{32,64,128,256,512,768\},
+\]
+
+subject to \(k<d\).
+
+Use nested random probes so that larger ranks contain the directions used at smaller ranks.
+
+## 5.4 Required validation statistics
+
+### Matrix approximation error
+
+\[
+E_F(k)
+=
+\frac{\|J_{\mathrm{full}}-\widehat J_k\|_F}
+{\|J_{\mathrm{full}}\|_F}.
+\]
+
+### Transported-vector relative error
+
+For held-out activation vectors \(h_i\):
+
+\[
+E_{\mathrm{vec}}(k)
+=
+\frac{1}{M}
+\sum_{i=1}^{M}
+\frac{\|J_{\mathrm{full}}h_i-\widehat J_kh_i\|_2}
+{\|J_{\mathrm{full}}h_i\|_2+\epsilon}.
+\]
+
+### Transported-vector cosine agreement
+
+\[
+C_{\mathrm{vec}}(k)
+=
+\frac{1}{M}
+\sum_{i=1}^{M}
+\cos(J_{\mathrm{full}}h_i,\widehat J_kh_i).
+\]
+
+### ISS absolute error
+
+\[
+E_{\mathrm{ISS}}(k)
+=
+\left|
+\operatorname{ISS}_{\mathrm{full}}
+-
+\widehat{\operatorname{ISS}}_k
+\right|.
+\]
+
+### Per-fact ISS rank agreement
+
+\[
+\rho_{\mathrm{fact}}(k)
+=
+\operatorname{Spearman}
+\left(
+\{\operatorname{ISS}^{\mathrm{full}}_f\},
+\{\widehat{\operatorname{ISS}}^{(k)}_f\}
+\right).
+\]
+
+A low Frobenius error is not sufficient. The transported vectors and the final ISS must also be stable.
+
+---
+
+# 6. Randomized Factorized Jacobian Estimator
+
+The estimator must define a linear operator that can be applied to arbitrary hidden states. Computing only \(J\Omega\) is not enough.
+
+Use randomized range finding with a two-sided operator estimate.
+
+## 6.1 Random probe matrix
+
+For target rank \(k\), draw:
+
+\[
+\Omega\in\mathbb R^{d\times(k+p)},
+\]
+
+where:
+
+- \(p\) is an oversampling dimension;
+- recommended \(p\in\{32,64\}\);
+- \(\Omega\) uses Gaussian or Rademacher entries;
+- all random seeds are fixed and recorded.
+
+## 6.2 Estimate the Jacobian output range
+
+Compute:
+
+\[
+Y
+=
+J^\ell\Omega
+=
+\mathbb E_x[J^\ell_x\Omega].
+\]
+
+Use batched Jacobian-vector products.
+
+Then compute:
+
+\[
+Q=\operatorname{qr}(Y),
+\]
+
+with:
+
+\[
+Q\in\mathbb R^{d\times(k+p)}.
+\]
+
+## 6.3 Estimate the reduced operator
+
+Compute:
+
+\[
+B=Q^\top J^\ell.
+\]
+
+Equivalently:
+
+\[
+B^\top=J^{\ell\top}Q.
+\]
+
+Use batched vector-Jacobian products.
+
+The final estimator is:
+
+\[
+\boxed{\widehat J^\ell=QB}
+\]
+
+and:
+
+\[
+\widehat J^\ell h=Q(Bh).
+\]
+
+## 6.4 Storage
+
+Store only:
+
+\[
+Q\in\mathbb R^{d\times r},
+\qquad
+B\in\mathbb R^{r\times d},
+\]
+
+where \(r=k+p\).
+
+Do not reconstruct and store the complete \(d\times d\) matrix.
+
+Since \(Q\) has orthonormal columns:
+
+\[
+\cos(Qy_1,Qy_2)=\cos(y_1,y_2).
+\]
+
+Therefore downstream cosine computations may use:
+
+\[
+y^\ell=Bh
+\]
+
+directly. Residualization and whitening must then be performed consistently in that reduced coordinate space.
+
+---
+
+# 7. Per-Model Validation Is Mandatory
+
+A rank that works for Qwen2.5-0.5B must not be assumed to work for larger models.
+
+Different models can have different:
+
+- hidden dimensions;
+- Jacobian singular-value decay;
+- effective rank;
+- depth;
+- normalization;
+- architecture;
+- post-training behavior.
+
+The small-model experiment validates the estimator implementation. It does not determine one universal rank.
+
+## 7.1 Direct action validation
+
+For every evaluated model, select representative:
+
+- early layers;
+- middle layers;
+- late layers.
+
+For held-out activation vectors \(h_i\), directly compute:
+
+\[
+u_i=J^\ell h_i
+=
+\frac1n\sum_{x\in\mathcal C}J^\ell_xh_i.
+\]
+
+This does not require materializing the full Jacobian.
+
+Compare with:
+
+\[
+\widehat u_i=\widehat J^\ell_kh_i.
+\]
+
+## 7.2 Validation activation set
+
+Use a calibration activation set independent of the final ISS test set.
+
+Recommended:
+
+- 64–128 activation vectors per representative layer;
+- multiple prompt types if benchmark-like prompts are used;
+- or a separate set of held-out natural questions.
+
+## 7.3 Rank candidates
+
+Use a nested grid such as:
+
+\[
+k\in\{64,128,256,512,1024\},
+\]
+
+bounded by model dimension and compute resources.
+
+Choose the smallest \(k_{m,\ell}\) that satisfies the fixed validation criteria.
+
+Recommended initial criteria:
+
+\[
+\operatorname{median}_i\cos(u_i,\widehat u_i)\ge0.99,
+\]
+
+\[
+\operatorname{median}_i
+\frac{\|u_i-\widehat u_i\|_2}
+{\|u_i\|_2+\epsilon}
+\le0.05,
+\]
+
+and:
+
+\[
+\left|
+\widehat{\operatorname{ISS}}_{2k}
+-
+\widehat{\operatorname{ISS}}_k
+\right|
+\le0.01.
+\]
+
+The exact numeric thresholds may be adjusted after Stage A, but they must be frozen before final evaluation.
+
+## 7.4 Model-specific rank is allowed
+
+Different models and layers may use different ranks:
+
+\[
+k_{m,\ell}.
+\]
+
+This is methodologically acceptable because all models use the same approximation-quality standard.
+
+Always report:
+
+- \(k_{m,\ell}\);
+- \(k_{m,\ell}/d_m\);
+- validation cosine;
+- validation relative error;
+- rank-stability error.
+
+---
+
+# 8. Calibration Corpus Size
+
+Rank error and corpus-sampling error are separate.
+
+The empirical Jacobian is:
+
+\[
+J^{\ell,(n)}
+=
+\frac1n\sum_{i=1}^{n}J^\ell_{x_i}.
+\]
+
+A large \(k\) does not compensate for insufficient corpus size \(n\).
+
+## 8.1 Corpus requirements
+
+The Jacobian corpus must:
+
+- be independent of the factual benchmark;
+- contain general pretraining-style or natural text;
+- use the same construction rule for all models;
+- use a fixed sequence-length and position convention;
+- record all sample IDs and random seeds.
+
+## 8.2 Corpus-size convergence
+
+On representative models, compare:
+
+\[
+n\in\{32,64,128,256,512\}.
+\]
+
+Measure:
+
+\[
+\cos(\widehat J^{(n)}h,\widehat J^{(2n)}h),
+\]
+
+and:
+
+\[
+\left|
+\widehat{\operatorname{ISS}}_n
+-
+\widehat{\operatorname{ISS}}_{2n}
+\right|.
+\]
+
+Select \(n\) using a fixed convergence rule. Do not select \(n\) based on preferred final benchmark conclusions.
+
+---
+
+# 9. Random-Seed Stability
+
+For representative model-layer-rank settings, use at least three sketch seeds.
+
+Report mean and standard deviation for:
+
+- transported-vector cosine;
+- transported-vector relative error;
+- ISS;
+- KTS if KTS uses the same transported states.
+
+A rank is not considered stable if results vary materially across seeds.
+
+Preferred final reporting:
+
+- average the result across three validated seeds; or
+- use one preregistered seed after proving seed variance is negligible.
+
+Never choose the seed that gives the preferred scientific result.
+
+---
+
+# 10. Official ISS Computation
+
+After freezing the estimator, compute:
+
+\[
+\widehat z^\ell_{m,f,q}
+=
+\widehat J^\ell_m h^\ell_{m,f,q}.
+\]
+
+Then run the standard ISS pipeline.
+
+## 10.1 Relation and condition residualization
+
+\[
+\bar z^\ell_{m,f,q}
+=
+z^\ell_{m,f,q}
+-
+\mu^\ell_{m,r_f}
+-
+\mu^\ell_{m,t(q)}
++
+\mu^\ell_m.
+\]
+
+## 10.2 Regularized whitening
+
+\[
+\tilde z^\ell_{m,f,q}
+=
+(\Sigma^\ell_m+\lambda I)^{-1/2}
+\bar z^\ell_{m,f,q}.
+\]
+
+If the reduced coordinate \(y=Bh\) is used directly, estimate \(\Sigma\) in that coordinate system.
+
+Do not fit a separate whitening transform for each condition family.
+
+## 10.3 Family centroid
+
+\[
+v^\ell_{m,f,t}
+=
+\operatorname{Normalize}
+\left(
+\frac1{|Q_{f,t}|}
+\sum_{q\in Q_{f,t}}
+\tilde z^\ell_{m,f,q}
+\right).
+\]
+
+## 10.4 Same-fact cross-condition similarity
+
+\[
+S^+_{m,f,\ell}
+=
+\frac1{|\mathcal P_f|}
+\sum_{(t,t')\in\mathcal P_f}
+\cos(v^\ell_{m,f,t},v^\ell_{m,f,t'}).
+\]
+
+## 10.5 Relation-matched background
+
+\[
+S^-_{m,f,\ell}
+=
+\mathbb E_{\substack{g\neq f,\ r_g=r_f\\t\neq t'}}
+\cos(v^\ell_{m,f,t},v^\ell_{m,g,t'}).
+\]
+
+## 10.6 Official ISS estimator
+
+\[
+\boxed{
+\widehat{\operatorname{ISS}}_{m,f,\ell}
+=
+\frac{S^+_{m,f,\ell}-S^-_{m,f,\ell}}
+{1-S^-_{m,f,\ell}+\epsilon}
+}
+\]
+
+Average over the preregistered layer window:
+
+\[
+\widehat{\operatorname{ISS}}_{m,f}
+=
+\frac1{|\mathcal W_m|}
+\sum_{\ell\in\mathcal W_m}
+\widehat{\operatorname{ISS}}_{m,f,\ell}.
+\]
+
+Then average over the fixed fact set:
+
+\[
+\widehat{\operatorname{ISS}}_m
+=
+\frac1{|\mathcal D|}
+\sum_{f\in\mathcal D}
+\widehat{\operatorname{ISS}}_{m,f}.
+\]
+
+---
+
+# 11. Raw-ISS
+
+Raw-ISS uses:
+
+\[
+z^\ell_{m,f,q}=h^\ell_{m,f,q}.
+\]
+
+It should be computed because it is inexpensive and useful for:
+
+- debugging hidden-state extraction;
+- validating family aggregation;
+- validating negative sampling;
+- checking whitening and residualization;
+- ablation;
+- testing whether Jacobian transport changes the conclusion.
+
+However:
+
+\[
+\boxed{\text{Raw-ISS is not the official ISS result.}}
+\]
+
+Recommended table terminology:
+
+| Metric | Representation | Role |
+|---|---|---|
+| Raw-ISS | \(h^\ell\) | Identity-transport ablation |
+| ISS | \(\widehat J^\ell h^\ell\) | Official metric |
+| Token readout | \(W_U\widehat J^\ell h^\ell\) | Not used |
+
+---
+
+# 12. Failure Policy
+
+Do not silently report an unvalidated approximation.
+
+A model-layer estimator fails validation if:
+
+- rank convergence is not achieved;
+- action-vector cosine remains below threshold;
+- relative action error remains above threshold;
+- ISS changes materially across ranks;
+- ISS changes materially across random seeds.
+
+## 12.1 Allowed responses
+
+In order:
+
+1. increase \(k\);
+2. increase oversampling \(p\);
+3. increase corpus size \(n\);
+4. add power iterations;
+5. restrict official ISS to validated layers;
+6. mark the model-layer estimator as unresolved.
+
+Raw-ISS may still be reported as an ablation, but it must not be relabeled as official ISS.
+
+## 12.2 Optional fallback estimator
+
+If low-rank reconstruction consistently fails, consider a geometry-preserving output sketch:
+
+\[
+RJ^\ell h,
+\]
+
+where:
+
+\[
+R\in\mathbb R^{k\times d}.
+\]
+
+This avoids assuming that \(J^\ell\) itself is low rank. However, it is a different estimator and must be separately validated against the full small-model reference.
+
+Do not switch to this estimator silently.
+
+---
+
+# 13. Data Separation
+
+Use three disjoint resources.
+
+## 13.1 Jacobian corpus
+
+Used to estimate \(J^\ell_m\). It must contain independent general text.
+
+## 13.2 Estimator calibration set
+
+Used to select:
+
+- corpus size \(n\);
+- rank \(k\);
+- sketch seed;
+- oversampling;
+- power iterations;
+- approximation thresholds.
+
+It must not overlap with the final benchmark evaluation facts.
+
+## 13.3 Final ISS benchmark
+
+Used only after all estimator settings are frozen.
+
+Do not tune \(n\), \(k\), seeds, layer windows, or whitening choices on the final benchmark.
+
+---
+
+# 14. Required Output Files
+
+```text
+jacobian_iss/
+├── configs/
+│   ├── corpus_config.yaml
+│   ├── estimator_config.yaml
+│   ├── validation_thresholds.yaml
+│   └── layer_windows.yaml
+├── full_reference/
+│   └── qwen2.5_0.5b/
+├── low_rank_factors/
+│   └── {model}/{layer}/
+│       ├── Q.pt
+│       ├── B.pt
+│       └── metadata.json
+├── validation/
+│   ├── small_model_full_comparison.json
+│   ├── per_model_action_validation.jsonl
+│   ├── rank_convergence.jsonl
+│   ├── corpus_convergence.jsonl
+│   └── seed_stability.jsonl
+├── transported_states/
+├── iss_per_fact_layer.jsonl
+├── iss_per_fact.jsonl
+├── iss_model_summary.json
+└── raw_iss_ablation.json
+```
+
+---
+
+# 15. Required Metadata
+
+For every estimator, store:
+
+```json
+{
+  "model": "model_name",
+  "model_revision": "revision",
+  "tokenizer_revision": "revision",
+  "layer": 16,
+  "hidden_dimension": 4096,
+  "rank": 512,
+  "oversampling": 64,
+  "power_iterations": 0,
+  "calibration_corpus_size": 256,
+  "calibration_sequence_length": 128,
+  "random_seed": 42,
+  "validation_cosine_median": 0.993,
+  "validation_relative_error_median": 0.041,
+  "iss_rank_difference": 0.006,
+  "validated": true
+}
+```
+
+---
+
+# 16. Minimum Required Experiments
+
+## Experiment A: Full-reference calibration
+
+Model:
+
+```text
+Qwen2.5-0.5B
+```
+
+Compare:
+
+```text
+full empirical Jacobian
+vs.
+rank 32/64/128/256/512/768 approximations
+```
+
+Report:
+
+- Frobenius error;
+- transported-vector error;
+- transported-vector cosine;
+- ISS absolute error;
+- per-fact ISS Spearman correlation.
+
+## Experiment B: Medium-scale transfer check
+
+Use at least one medium-sized model.
+
+At representative layers:
+
+- compute high-accuracy direct \(Jh\) actions;
+- validate rank behavior;
+- confirm that the small-model rank does not automatically transfer.
+
+## Experiment C: Per-model validation
+
+For every evaluated model:
+
+- representative early, middle, and late layers;
+- 64–128 held-out activation vectors;
+- nested candidate ranks;
+- fixed validation thresholds;
+- at least three random seeds on representative settings.
+
+## Experiment D: Official evaluation
+
+Only after freezing all estimator choices:
+
+- compute transported states;
+- compute official ISS;
+- compute Raw-ISS;
+- compare trends;
+- report approximation uncertainty.
+
+---
+
+# 17. Recommended Decision Rule
+
+Do not use:
+
+```text
+k = 512 for every model
+```
+
+Use:
+
+```text
+Choose the smallest k for each model-layer that satisfies
+one fixed approximation-quality standard.
+```
+
+Recommended initial rule:
+
+```text
+median action cosine >= 0.99
+median relative action error <= 0.05
+|ISS(2k) - ISS(k)| <= 0.01
+seed standard deviation of ISS <= 0.005
+```
+
+The exact thresholds may be refined after the small-model calibration, but they must be frozen before final evaluation.
+
+---
+
+# 18. Uncertainty Reporting
+
+Separate the following sources of uncertainty:
+
+1. finite Jacobian-corpus error;
+2. low-rank approximation error;
+3. random-sketch error;
+4. benchmark sampling uncertainty;
+5. relation-level heterogeneity.
+
+At minimum, report:
+
+- rank sensitivity;
+- corpus-size sensitivity;
+- random-seed sensitivity;
+- per-model action validation;
+- relation-clustered bootstrap confidence intervals for final ISS.
+
+Do not present one confidence interval that silently mixes all uncertainty sources.
+
+---
+
+# 19. Paper-Ready Method Description
+
+> We define Internal State Stability on Jacobian-transported residual states \(z^\ell=J^\ell h^\ell\), where \(J^\ell\) is the corpus-averaged input-output Jacobian from layer \(\ell\) to the final residual stream. We do not apply the vocabulary unembedding matrix, thereby retaining a continuous hidden representation compatible with multi-token and multilingual answers. Since explicitly materializing \(J^\ell\in\mathbb R^{d\times d}\) is prohibitive for large models, we estimate it using randomized range finding, yielding a factorized operator \(\widehat J^\ell=Q^\ell B^\ell\). We validate this approximation against full empirical Jacobians on Qwen2.5-0.5B and against directly computed Jacobian-vector products on held-out activations for every evaluated model. The sketch rank is selected independently for each model and layer using a fixed preregistered approximation-error tolerance rather than a universal rank or final benchmark performance.
+
+Continuation:
+
+> We separately evaluate calibration-corpus convergence, rank convergence, and random-seed stability. Raw hidden-state ISS is reported only as an identity-transport ablation.
+
+---
+
+# 20. Final Engineering Decisions
+
+```text
+Official ISS:
+    Jacobian-transported hidden-state ISS
+
+Transport:
+    z = J h
+
+Unembedding:
+    Do not multiply by W_U
+
+Small-model full Jacobian:
+    Finite-corpus exact reference only
+
+Large-model implementation:
+    Randomized factorized operator estimate
+
+Rank selection:
+    Per model and per layer
+
+Rank criterion:
+    Shared fixed approximation-quality threshold
+
+Validation:
+    Full matrix comparison on Qwen2.5-0.5B
+    Direct J h comparison on every evaluated model
+
+Raw-ISS:
+    Debugging and ablation only
+
+Final test set:
+    Never used to tune n, k, seeds, layers, or estimator settings
+
+Failure:
+    Do not report unvalidated Jacobian ISS
+```
+
+---
+
+# 21. Immediate Implementation Order for Claude
+
+1. Finish Raw-ISS to validate data loading and metric aggregation.
+2. Implement exact finite-corpus Jacobian recovery on Qwen2.5-0.5B.
+3. Implement the randomized factorized estimator \(\widehat J=QB\).
+4. Compare candidate ranks against the full small-model reference.
+5. Measure matrix, vector-action, ISS-value, and fact-ranking errors.
+6. Freeze approximation-quality thresholds.
+7. Implement direct \(Jh\) validation for large models.
+8. Select \(k_{m,\ell}\) using the fixed thresholds.
+9. Run corpus-size and seed-stability checks.
+10. Freeze all estimator configurations.
+11. Compute official ISS on the final benchmark.
+12. Report Raw-ISS only as an ablation.
+13. Save all factors, configurations, validation logs, and checksums.
+
+The objective is not to recover every Jacobian entry exactly. The objective is to guarantee that the transported representations and the resulting ISS remain within a preregistered numerical tolerance.

ICLR dataset/protocol/reconstruction_differences.md

@@ -0,0 +1,218 @@
+# Reconstruction differences
+
+Required by spec section 10: every deviation from the expected counts, and every
+internal contradiction found in the specification itself, is recorded here
+rather than silently absorbed.
+
+Build: `dataset3/`, sources read from `ICLR27/dataset/`.
+
+---
+
+## Summary
+
+| Stage | Expected | Actual | Status |
+|---|---:|---:|---|
+| Raw cloze prompts | 1,783,541 | 1,783,541 | match |
+| Five-model consensus | 10,601 | 10,601 | match |
+| Candidate-Known Facts | 8,107 | 8,107 | match |
+| Grouped (subject, relation) | 6,185 | 6,185 | match |
+| Functional conflicts removed | 5 | 5 | match |
+| Enriched Facts | 6,180 | 6,180 | match |
+| Core-source facts | 3,705 | 3,705 | match |
+| Benchmark facts | 2,592 | 2,592 | match |
+| Benchmark relations | 21 | 21 | match |
+| Migration duplicates removed | 10,323 | 10,323 | match |
+| Evaluation queries | 44,418 | **44,416** | **deviation D1** |
+| — context | 6,831 | **6,829** | **deviation D1** |
+| — all other conditions | as specified | as specified | match |
+
+Everything except D1 reproduces exactly.
+
+---
+
+## D1 — Two context queries expose the gold answer (defect in the source data)
+
+**Deviation:** context 6,831 → 6,829; total 44,418 → 44,416.
+
+Spec 9.4 requires that context "must not introduce a second valid target", and
+spec 13.9 that "no gold answer is exposed in open-ended main conditions". Two
+queries migrated from `eval_dataset/queryD_context.jsonl` violate both, because
+the legacy distractor sampler picked an entity whose surface form contains the
+gold answer:
+
+```
+Some people confuse States Reorganisation Act with Indian Act.
+In which jurisdiction does States Reorganisation Act apply?
+   gold = India          <- exposed by the distractor "Indian Act"
+
+Taiwan (ROC) Resident Certificate is a legal term in Taiwan.
+Indian Act is a legal term in Canada.
+In which jurisdiction does Permanent account number apply?
+   gold = India          <- same cause
+```
+
+Spec 10 allows a count change when "the implementation discovers a documented
+defect in the old data". This is such a defect.
+
+**Action taken.** `src/build_eval_bank.py` applies a general rule rather than a
+hard-coded exception: for every open-ended main-forward query, the normalized
+gold must not appear in the query text after removing all mentions of the
+subject. Queries failing the rule are dropped and counted in
+`stage4_report.json` as `dropped_gold_exposed`.
+
+**To restore 44,418** exactly, delete that guard — but the two queries are
+unanswerable-by-design artefacts and any model scores them correct by copying.
+
+---
+
+## C1 — Spec 6.2 contradicts the required benchmark size (unresolved by design)
+
+**Not a count deviation. An internal contradiction in the specification.**
+
+Spec 6.2 lists relations "generally unsuitable" for the main benchmark, naming
+among them **developer of** and **manufacturer of**. Spec 1, 6.2 and 15
+simultaneously require exactly **2,592 facts across 21 relations**.
+
+Those two relations contribute:
+
+| Relation | Facts |
+|---|---:|
+| manufacturer (P176) | 441 |
+| developer (P178) | 405 |
+| **total** | **846** |
+
+Excluding them yields **1,746 facts across 19 relations**, which fails the
+acceptance criteria in spec 15. Keeping them satisfies the counts but contradicts
+spec 6.2's guidance.
+
+**Action taken.** The counts win, because spec 15 states them as acceptance
+criteria and spec 10 forbids silent changes. Both relations are retained and
+tagged:
+
+```json
+"spec_6_2_flag": "unsuitable_named_in_spec"
+```
+
+`configs/relations.yaml` exposes `options.drop_spec_6_2_flagged`. Setting it to
+`true` reproduces the spec-6.2-compliant 1,746-fact variant; the selection script
+then reports the resulting size instead of failing.
+
+**Recommendation.** Report the headline number on all 2,592 and a robustness
+number on the 1,746 subset. See F1, which gives an independent empirical reason
+to distrust exactly these relations.
+
+---
+
+## F1 — 28.9% of benchmark facts are answerable by string copying
+
+**Finding, not a deviation. No counts changed.**
+
+For 750 of 2,592 benchmark facts (28.9%) the object string is literally contained
+in the subject name, so the query can be answered by copying a substring instead
+of retrieving knowledge:
+
+```
+Airbus A318            -> manufacturer  Airbus
+Adobe Acrobat          -> developer     Adobe
+Amazon Music           -> owned by      Amazon
+Agriculture and Agri-Food Canada -> jurisdiction  Canada
+```
+
+Concentration by relation:
+
+| Relation | Flagged | Total | Share |
+|---|---:|---:|---:|
+| manufacturer | 387 | 441 | 87.8% |
+| developer | 199 | 405 | 49.1% |
+| owned_by | 52 | 89 | 58.4% |
+| applies_to_jurisdiction | 31 | 54 | 57.4% |
+| sport | 17 | 81 | 21.0% |
+| country | 17 | 263 | 6.5% |
+| headquarters_location | 15 | 132 | 11.4% |
+| (10 further relations) | 32 | — | <34% |
+
+586 of the 750 come from `manufacturer` and `developer` — the two relations spec
+6.2 already called unsuitable. F1 is therefore independent empirical support for
+C1's recommendation.
+
+**Why this matters.** A stability benchmark measures whether a *retrieved* fact
+survives rephrasing. A fact answerable by copying is stable for a reason that has
+nothing to do with knowledge, so it inflates every retention number and dampens
+the very effect the study is about.
+
+**Action taken.** Spec 16 forbids silently dropping facts, so all 750 are kept
+and flagged on both the fact and the query record:
+
+```json
+"answer_in_subject_surface": true
+```
+
+Downstream analysis should report retention with and without them.
+
+---
+
+## F2 — 808 of the 8,107 candidate rows are exact duplicates
+
+**Finding, not a deviation.**
+
+The 8,107 Candidate-Known Facts contain only 7,299 distinct
+`(subject, relation, object, source)` tuples; 808 rows are exact repeats, e.g.
+`("BMW 3 Series", P176, "BMW", counterfact)` appears twice. This is inherited
+from `dataset/filter/prompts.jsonl`.
+
+No action needed: spec 5.1 grouping absorbs them, which is part of why 8,107 rows
+become 6,185 groups. Recorded so the 8,107 figure is not mistaken for 8,107
+distinct facts.
+
+---
+
+## N1 — Stage I GPU passes were not re-executed
+
+The five-model first-token forward passes (1,783,541 prompts x 5 models) were
+run previously; their per-prompt verdict vectors are stored as
+`dataset/filter/correct_<model>.npy`.
+
+`src/build_candidate_known.py` re-derives the candidate set from those vectors:
+it re-reads the prompt table, re-computes the intersection, re-applies the
+source-drop rule, and checksums every input into `stage1_report.json`. It does
+not re-run inference.
+
+The counts are verified, not assumed — 1,783,541 / 10,601 / 8,107 all reproduce,
+and the result is checked for set equality against
+`dataset/filter/global_known_clean.jsonl`.
+
+`src/filter_run.py` regenerates the vectors from scratch when required.
+
+---
+
+## N2 — Triple direction is not normalized for `capital_of`
+
+Spec 2.2 requires a single triple direction, forward being
+`subject + relation -> object`. The relation `capital_of` (P1376) is stored the
+other way round: subject = city, object = country.
+
+Normalizing it would fold those 125 facts into `capital`, changing both the
+benchmark size and the relation count, which spec 10 forbids doing silently.
+
+**Action taken.** `capital_of` keeps `"direction": "inverse"` and
+`"inverse_of": "capital"` in its record, so any analysis can group or separate
+the two directions explicitly. `configs/relations.yaml` exposes
+`options.normalize_inverse_direction` for the alternative build.
+
+---
+
+## Coverage gaps (spec 12, expected and unchanged)
+
+Main-forward families do not cover every fact:
+
+| Condition | Facts covered | Missing |
+|---|---:|---:|
+| anchor | 2,592 | 0 |
+| paraphrase | 2,592 | 0 |
+| format | 2,592 | 0 |
+| context | 2,591 | 1 |
+| multilingual | 2,402 | 190 |
+
+Missing fact ids are listed in `outputs/coverage_report.json`. No query was
+imputed. Downstream analyses that compare conditions per fact should use the
+explicit valid intersection.

ICLR dataset/runner/build_candidate_known.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+"""Stage I -> outputs/candidate_known_8107.jsonl  (spec sections 4.1 - 4.5)
+
+Stage I is the expensive part of the pipeline: 1,783,541 cloze prompts x 5
+models of GPU forward passes. Those passes were already run and their outputs
+live under dataset/filter/ as `correct_<model>.npy` vectors aligned to
+`prompts.jsonl`. This script therefore RECONSTRUCTS the candidate set from
+those stored per-model verdicts rather than re-running the GPU, while
+re-deriving every count from raw data so the numbers are verified, not assumed:
+
+  * prompts.jsonl and prompts_popqa.jsonl are re-read and counted;
+  * the five per-model vectors are re-intersected here, not taken on trust;
+  * the source-drop rule (spec 4.5) is re-applied;
+  * every input file is checksummed into the output header.
+
+Re-running the GPU stage from scratch is `src/filter_run.py`, which is kept
+byte-compatible with the stored vectors; use --verify_only to check that this
+reconstruction still matches dataset/filter/global_known_clean.jsonl.
+"""
+import os, sys, json, argparse, collections
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import (DATASET, load_config, out_path, read_jsonl, write_jsonl,
+                    sha256, Expect)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--verify_only", action="store_true")
+    args = ap.parse_args()
+
+    src_cfg = load_config("source_templates.yaml")
+    mdl_cfg = load_config("models.yaml")
+    filter_models = [m["name"] for m in mdl_cfg["filter_models"]]
+    exp = Expect()
+
+    fdir = os.path.join(DATASET, "filter")
+    prompts_path = os.path.join(fdir, "prompts.jsonl")
+    popqa_path = os.path.join(fdir, "prompts_popqa.jsonl")
+
+    # ---- 1. cloze prompt table (spec 4.3) ----
+    print("[1/4] reading cloze prompt table ...", flush=True)
+    prompts = list(read_jsonl(prompts_path))
+    exp.check("cloze_prompts", len(prompts), src_cfg["expected"]["cloze_prompts"])
+
+    by_source = collections.Counter(p["source"] for p in prompts)
+    for name, s in src_cfg["sources"].items():
+        if s.get("added_after_consensus"):
+            continue
+        key = {"t_rex": "trex"}.get(name, name)
+        if key in by_source and "expected_triples" in s:
+            exp.check(f"prompts[{name}]", by_source[key], None)
+
+    # ---- 2. five-model consensus (spec 4.4) ----
+    print(f"[2/4] intersecting {len(filter_models)} first-token verdict vectors ...",
+          flush=True)
+    inter = np.ones(len(prompts), dtype=bool)
+    per_model = {}
+    for m in filter_models:
+        v = np.load(os.path.join(fdir, f"correct_{m}.npy")).astype(bool)
+        if len(v) != len(prompts):
+            raise SystemExit(f"correct_{m}.npy has {len(v)} rows, "
+                             f"prompts.jsonl has {len(prompts)}")
+        per_model[m] = float(v.mean())
+        inter &= v
+    exp.check("five_model_consensus", int(inter.sum()),
+              src_cfg["expected"]["five_model_consensus"])
+
+    # ---- 3. source filtering (spec 4.5) ----
+    drop = {name for name, s in src_cfg["sources"].items()
+            if s.get("drop_after_consensus")}
+    drop |= {"trex"} if "t_rex" in drop else set()
+    print(f"[3/4] dropping post-consensus sources: {sorted(drop)}", flush=True)
+
+    rows = []
+    for i, p in enumerate(prompts):
+        if not inter[i]:
+            continue
+        if p["source"] in drop:
+            continue
+        rows.append({
+            "raw_id": p["id"],
+            "prompt_id": f"p{i:07d}",
+            "source": p["source"],
+            "subject": p["subject"],
+            "relation": p["relation"],
+            "object": p["object"],
+            "cloze_prompt": p["prompt"],
+            "consensus": {"models": filter_models, "n_passed": len(filter_models)},
+            "legacy_ref": {"file": "prompts.jsonl", "row": i},
+        })
+
+    # ---- 4. PopQA supplement, same protocol (spec 4.5) ----
+    n_popqa = 0
+    if os.path.exists(popqa_path):
+        pq = list(read_jsonl(popqa_path))
+        exp.check("popqa_prompts", len(pq),
+                  src_cfg["sources"]["popqa"].get("expected_prompts"))
+        pinter = np.ones(len(pq), dtype=bool)
+        for m in filter_models:
+            v = np.load(os.path.join(fdir, f"popqa_correct_{m}.npy")).astype(bool)
+            pinter &= v
+        for i, p in enumerate(pq):
+            if not pinter[i]:
+                continue
+            rows.append({
+                "raw_id": p["id"],
+                "prompt_id": f"q{i:07d}",
+                "source": "popqa",
+                "subject": p["subject"],
+                "relation": p["relation"],
+                "object": p["object"],
+                "cloze_prompt": p["prompt"],
+                "consensus": {"models": filter_models, "n_passed": len(filter_models)},
+                "legacy_ref": {"file": "prompts_popqa.jsonl", "row": i},
+            })
+            n_popqa += 1
+        exp.check("popqa_passed", n_popqa,
+                  src_cfg["sources"]["popqa"].get("expected_passed"))
+
+    exp.check("candidate_known", len(rows), src_cfg["expected"]["candidate_known"])
+
+    # ---- cross-check against the legacy file ----
+    legacy = os.path.join(fdir, "global_known_clean.jsonl")
+    if os.path.exists(legacy):
+        want = {(d["subject"], d["relation"], d["object"], d["source"])
+                for d in read_jsonl(legacy)}
+        got = {(r["subject"], r["relation"], r["object"], r["source"]) for r in rows}
+        exp.check("matches_legacy_clean_set", len(got & want), len(want),
+                  note="set equality against dataset/filter/global_known_clean.jsonl")
+        if got != want:
+            print(f"  only-in-new: {len(got - want)}  only-in-legacy: {len(want - got)}")
+
+    exp.report("Stage I counts")
+    if args.verify_only:
+        return 1 if exp.deviations else 0
+
+    path = out_path("candidate_known_8107.jsonl")
+    write_jsonl(path, rows)
+
+    meta = {
+        "stage": "I_candidate_recall",
+        "n_candidate_known": len(rows),
+        "per_source": dict(collections.Counter(r["source"] for r in rows)),
+        "filter_models": filter_models,
+        "filter_model_first_token_accuracy": per_model,
+        "dropped_sources_after_consensus": sorted(drop),
+        "checks": exp.rows,
+        "inputs": {
+            "prompts.jsonl": sha256(prompts_path, limit_mb=64),
+            "prompts_popqa.jsonl": sha256(popqa_path) if os.path.exists(popqa_path) else None,
+            **{f"correct_{m}.npy": sha256(os.path.join(fdir, f"correct_{m}.npy"))
+               for m in filter_models},
+        },
+        "note": "GPU forward passes were not re-run; the stored per-model "
+                "first-token verdict vectors were re-intersected here. Use "
+                "src/filter_run.py to regenerate them from scratch.",
+    }
+    json.dump(meta, open(out_path("stage1_report.json"), "w"),
+              indent=2, ensure_ascii=False)
+    print(f"\nwrote {len(rows)} candidate facts -> {path}")
+    print(f"  per source: {meta['per_source']}")
+    return 1 if exp.deviations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ICLR dataset/runner/build_eval_bank.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python
+"""Stage IV -> outputs/evaluation_queries_44418.jsonl  (spec sections 8 - 12)
+
+Builds the query bank on the FIXED 2,592-fact benchmark. Sources:
+  * anchor        the qualification question itself
+  * everything else migrated from eval_dataset/query{A..E}_*.jsonl
+
+Migration rules (spec 11):
+  * old `kid` -> `fact_id`, joined entity-aware; original ids preserved in
+    `legacy_query_refs`
+  * duplicates removed on (fact_id, normalized query, target slot, family)
+  * single-string gold replaced by an alias set from the enriched fact
+  * MCQ rows routed to `recognition`, never to `format`
+  * reverse rows with a non-unique inverse routed to `reverse_illposed`
+
+Condition family names follow configs/eval_conditions.yaml rather than the old
+file names, because those are a known trap: `queryA_canonical` holds surface
+rewrites and was reported as paraphrase, `queryB_paraphrase` holds format
+variants and was reported as format.
+"""
+import os, sys, json, glob, argparse, collections
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import (load_config, out_path, read_jsonl, write_jsonl,
+                    normalize, norm_key, Expect)
+
+EVAL_LEGACY = "/scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/eval_dataset"
+FILE_FAMILY = {"queryA_canonical": "paraphrase", "queryB_paraphrase": "format",
+               "queryC_reverse": "reverse", "queryD_context": "context",
+               "queryE_multilingual": "multilingual"}
+ORDER = ["anchor", "paraphrase", "format", "context", "multilingual",
+         "reverse", "recognition", "reverse_illposed"]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
+    args = ap.parse_args()
+
+    cond_cfg = load_config("eval_conditions.yaml")
+    CONDS = cond_cfg["conditions"]
+    exp = Expect()
+
+    facts = list(read_jsonl(args.facts))
+    by_id = {f["fact_id"]: f for f in facts}
+    exp.check("benchmark_facts", len(facts), cond_cfg["totals"]["expected_benchmark_facts"])
+
+    # ---- kid -> fact_id, joined on (subject identity, source relation) ----
+    key2fid = {}
+    for f in facts:
+        for pid in f["relation"]["source_relations"]:
+            key2fid[(norm_key(f["subject"]["canonical"]), pid)] = f["fact_id"]
+        if f["subject"].get("entity_id"):
+            for pid in f["relation"]["source_relations"]:
+                key2fid[(f["subject"]["entity_id"], pid)] = f["fact_id"]
+
+    kid2fid, unmapped = {}, []
+    for b in read_jsonl(f"{EVAL_LEGACY}/base.jsonl"):
+        fid = key2fid.get((norm_key(b["subject"]), b["relation_id"]))
+        if fid:
+            kid2fid[b["kid"]] = fid
+        else:
+            unmapped.append(b["kid"])
+    print(f"kid -> fact_id: {len(kid2fid)} mapped onto {len(set(kid2fid.values()))} "
+          f"benchmark facts ({len(unmapped)} legacy kids fall outside the benchmark)")
+
+    def emit(fid, family, text, variant_id, language="en", template_id=None,
+             legacy=None, extra=None):
+        f = by_id[fid]
+        c = CONDS[family]
+        slot = c["target_slot"]
+        node = f["subject"] if slot == "subject" else f["object"]
+        rec = {
+            "query_id": None,                      # assigned after ordering
+            "fact_id": fid,
+            "relation": f["relation"]["relation_id"],
+            "condition_family": family,
+            "variant_id": variant_id,
+            "language": language,
+            "query": text,
+            "target_slot": slot,
+            "gold_canonical": node["canonical"],
+            "gold_aliases": node["aliases"],
+            "answer_type": f["answer_type"],
+            "answer_granularity": f["answer_granularity"],
+            "is_assisted": bool(c["is_assisted"]),
+            "is_well_posed": bool(c["is_well_posed"]),
+            "use_for_main_forward": bool(c["use_for_main_forward"]),
+            "use_for_reverse_analysis": bool(c["use_for_reverse_analysis"]),
+            "use_for_recognition_analysis": bool(c["use_for_recognition_analysis"]),
+            "source_template_id": template_id,
+            "legacy_query_refs": legacy or [],
+            # propagated from the fact: the gold string is part of the subject
+            # name, so the query text contains it for reasons that have nothing
+            # to do with answer leakage introduced by the template
+            "answer_in_subject_surface": bool(f.get("answer_in_subject_surface")),
+        }
+        if extra:
+            rec.update(extra)
+        return rec
+
+    rows = collections.defaultdict(list)
+    seen = set()                       # spec 11 dedup key
+    stats = collections.Counter()
+
+    # ---- anchor (spec 9.1) ----
+    for f in facts:
+        rows["anchor"].append(
+            emit(f["fact_id"], "anchor", f["qualification_question"], "anchor",
+                 template_id=f"{f['relation']['relation_id']}_anchor"))
+        seen.add((f["fact_id"], normalize(f["qualification_question"]),
+                  "object", "anchor"))
+
+    # ---- migrated conditions ----
+    for path in sorted(glob.glob(f"{EVAL_LEGACY}/query*.jsonl")):
+        stem = os.path.basename(path)[:-len(".jsonl")]
+        base_family = FILE_FAMILY.get(stem)
+        if base_family is None:
+            continue
+        for q in read_jsonl(path):
+            stats["read"] += 1
+            fid = kid2fid.get(q["kid"])
+            if fid is None:
+                stats["out_of_benchmark"] += 1
+                continue
+            family = base_family
+            if q.get("fmt") == "mcq":
+                family = "recognition"                       # spec 9.3 / 9.7
+            elif family == "reverse" and not q.get("reverse_well_posed"):
+                family = "reverse_illposed"                  # spec 9.8
+
+            key = (fid, normalize(q["prompt"]), CONDS[family]["target_slot"], family)
+            if key in seen:
+                stats["duplicates_removed"] += 1
+                continue
+
+            # spec 9.4 / 13.9: an open-ended main query must not expose the gold.
+            # Two context queries in the legacy bank sampled a distractor entity
+            # that literally contains the answer ("... confuse X with Indian Act
+            # ..." where the gold is India). A gold occurrence that lies inside
+            # the SUBJECT mention is inherent to the fact and stays; anything
+            # surviving removal of the subject is a defect and is dropped.
+            if CONDS[family]["use_for_main_forward"] and not CONDS[family]["is_assisted"]:
+                f = by_id[fid]
+                nq = normalize(q["prompt"])
+                gold = normalize(f["object"]["canonical"])
+                subj = normalize(f["subject"]["canonical"])
+                if gold and gold in (nq.replace(subj, " ") if subj else nq):
+                    stats["dropped_gold_exposed"] += 1
+                    continue
+
+            seen.add(key)
+
+            extra = {}
+            if family == "recognition":
+                extra["options"] = q.get("options")
+                extra["correct_option"] = q.get("correct_option")
+            if q.get("dkind"):
+                extra["context_kind"] = q["dkind"]
+            rows[family].append(
+                emit(fid, family, q["prompt"],
+                     variant_id=(q.get("qid") or "").split("_")[-1] or "01",
+                     language=q.get("lang", "en"),
+                     template_id=q.get("template_id"),
+                     legacy=[{"kid": q["kid"], "qid": q.get("qid"), "file": stem}],
+                     extra=extra))
+            stats["kept"] += 1
+
+    # ---- assign ids, write ----
+    flat = []
+    per_cond = {}
+    for fam in ORDER:
+        rs = rows.get(fam, [])
+        per_cond[fam] = {"queries": len(rs), "facts": len({r["fact_id"] for r in rs})}
+        flat += rs
+    for i, r in enumerate(flat, 1):
+        r["query_id"] = f"query_{i:08d}"
+
+    path = out_path("evaluation_queries_44418.jsonl")
+    write_jsonl(path, flat)
+
+    # ---- expected-count checks (spec 10) ----
+    for fam in ORDER:
+        c = CONDS[fam]
+        exp.check(f"{fam}.queries", per_cond[fam]["queries"], c["expected_queries"])
+        exp.check(f"{fam}.facts", per_cond[fam]["facts"], c["expected_facts"])
+    exp.check("total_queries", len(flat), cond_cfg["totals"]["expected_total_queries"])
+    main_n = sum(per_cond[f]["queries"] for f in ORDER
+                 if CONDS[f]["use_for_main_forward"])
+    exp.check("main_forward_queries", main_n,
+              cond_cfg["totals"]["expected_main_forward_queries"])
+    exp.check("duplicates_removed", stats["duplicates_removed"],
+              cond_cfg["deduplication"]["expected_removed_during_migration"])
+
+    # ---- coverage report (spec 12) ----
+    all_ids = set(by_id)
+    coverage, missing = {}, {}
+    for fam in ORDER:
+        covered = {r["fact_id"] for r in rows.get(fam, [])}
+        coverage[fam] = len(covered)
+        if CONDS[fam]["use_for_main_forward"]:
+            miss = sorted(all_ids - covered)
+            if miss:
+                missing[fam] = miss
+    json.dump({"benchmark_facts": len(facts), **coverage,
+               "missing_by_condition": missing,
+               "note": "main-forward families should ideally cover all facts; "
+                       "missing ids are listed rather than imputed (spec 12)"},
+              open(out_path("coverage_report.json"), "w"),
+              indent=2, ensure_ascii=False)
+
+    exp.report("Stage IV counts")
+    print(f"\n{'condition':20s} {'queries':>9s} {'facts':>7s} {'role':>12s}")
+    print("-" * 52)
+    for fam in ORDER:
+        print(f"{fam:20s} {per_cond[fam]['queries']:9d} "
+              f"{per_cond[fam]['facts']:7d} {CONDS[fam]['role']:>12s}")
+    print("-" * 52)
+    print(f"{'TOTAL':20s} {len(flat):9d}")
+    print(f"{'main forward':20s} {main_n:9d}")
+    print(f"\nmigration: {dict(stats)}")
+    print(f"wrote -> {path}")
+
+    # A deviation listed in configs/eval_conditions.yaml:accepted_deviations has
+    # been investigated and written up in reconstruction_differences.md, so it
+    # must not abort the pipeline. Anything NOT listed still fails, which keeps a
+    # fresh regression from hiding behind a documented one.
+    accepted = {(d["check"], d["actual"], d["expected"]): d.get("ref")
+                for d in cond_cfg.get("accepted_deviations", [])}
+    unexpected = [d for d in exp.deviations
+                  if (d["name"], d["actual"], d["expected"]) not in accepted]
+    for d in exp.deviations:
+        ref = accepted.get((d["name"], d["actual"], d["expected"]))
+        if ref:
+            print(f"  accepted deviation [{ref}]: {d['name']} "
+                  f"{d['actual']} vs {d['expected']}")
+    if unexpected:
+        print(f"\nUNDOCUMENTED deviations: {[d['name'] for d in unexpected]}")
+        print("Investigate, then add them to configs/eval_conditions.yaml:"
+              "accepted_deviations and outputs/reconstruction_differences.md")
+
+    json.dump({"stage": "IV_query_bank", "per_condition": per_cond,
+               "total": len(flat), "main_forward": main_n,
+               "migration": dict(stats), "checks": exp.rows,
+               "accepted_deviations": [d for d in exp.deviations
+                                       if (d["name"], d["actual"], d["expected"]) in accepted],
+               "undocumented_deviations": unexpected},
+              open(out_path("stage4_report.json"), "w"), indent=2, ensure_ascii=False)
+    return 1 if unexpected else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ICLR dataset/runner/build_stats.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+"""outputs/dataset_statistics.json  (spec section 14.1)
+
+Aggregates every stage report plus the fact and query files into the single
+statistics document the specification asks for.
+"""
+import os, sys, json, glob, collections, statistics
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl, normalize
+
+
+def load_report(name):
+    p = out_path(name)
+    return json.load(open(p)) if os.path.exists(p) else {}
+
+
+def main():
+    facts = list(read_jsonl(out_path("benchmark_facts_2592.jsonl")))
+    enriched = list(read_jsonl(out_path("enriched_facts_6180.jsonl")))
+    cands = list(read_jsonl(out_path("candidate_known_8107.jsonl")))
+    queries = list(read_jsonl(out_path("evaluation_queries_44418.jsonl")))
+    cond_cfg = load_config("eval_conditions.yaml")
+    mdl_cfg = load_config("models.yaml")
+
+    by_id = {f["fact_id"]: f for f in facts}
+    per_fact_q = collections.Counter(q["fact_id"] for q in queries)
+    alias_counts = [len(f["object"]["aliases"]) for f in facts]
+    sub_alias_counts = [len(f["subject"]["aliases"]) for f in facts]
+
+    fam = collections.defaultdict(lambda: {"queries": 0, "facts": set()})
+    for q in queries:
+        fam[q["condition_family"]]["queries"] += 1
+        fam[q["condition_family"]]["facts"].add(q["fact_id"])
+
+    # recognition distractor statistics (spec 14.1)
+    rec = [q for q in queries if q["condition_family"] == "recognition"]
+    opt_sizes = collections.Counter(len(q.get("options") or []) for q in rec)
+    pos = collections.Counter(q.get("correct_option") for q in rec)
+
+    ml = [q for q in queries if q["condition_family"] == "multilingual"]
+
+    stats = {
+        "pipeline": {
+            "candidate_known": len(cands),
+            "enriched_facts": len(enriched),
+            "benchmark_facts": len(facts),
+            "evaluation_queries": len(queries),
+            "relations": len({f["relation"]["relation_id"] for f in facts}),
+        },
+        "counts_by_source": {
+            "candidates": dict(collections.Counter(c["source"] for c in cands)),
+            "enriched": dict(collections.Counter(e["sources"][0] for e in enriched)),
+            "benchmark": dict(collections.Counter(f["sources"][0] for f in facts)),
+        },
+        "counts_by_relation": dict(collections.Counter(
+            f["relation"]["relation_id"] for f in facts).most_common()),
+        "counts_by_answer_type": dict(collections.Counter(
+            f["answer_type"] for f in facts).most_common()),
+        "counts_by_condition_family": {
+            k: {"queries": v["queries"], "facts": len(v["facts"]),
+                "role": cond_cfg["conditions"][k]["role"]}
+            for k, v in sorted(fam.items())},
+        "query_variants_per_fact": {
+            "min": min(per_fact_q.values()), "max": max(per_fact_q.values()),
+            "median": statistics.median(per_fact_q.values()),
+            "mean": round(statistics.mean(per_fact_q.values()), 2)},
+        "alias_counts": {
+            "object": {"total": sum(alias_counts),
+                       "median": statistics.median(alias_counts),
+                       "mean": round(statistics.mean(alias_counts), 2),
+                       "facts_with_one_alias": sum(1 for a in alias_counts if a == 1)},
+            "subject": {"total": sum(sub_alias_counts),
+                        "median": statistics.median(sub_alias_counts)}},
+        "duplicates": {
+            "candidate_rows_that_are_exact_duplicates":
+                len(cands) - len({(c["subject"], c["relation"], c["object"], c["source"])
+                                  for c in cands}),
+            "groups_merged_during_enrichment":
+                load_report("stage2_report.json").get("merged_groups"),
+            "cross_source_groups":
+                load_report("stage2_report.json").get("cross_source_groups"),
+            "queries_removed_during_migration":
+                load_report("stage4_report.json").get("migration", {})
+                .get("duplicates_removed")},
+        "conflicts": {
+            "functional_conflicts_removed":
+                load_report("stage2_report.json").get("conflicts_removed", {}),
+            "queries_dropped_gold_exposed":
+                load_report("stage4_report.json").get("migration", {})
+                .get("dropped_gold_exposed", 0)},
+        "coverage": json.load(open(out_path("coverage_report.json")))
+            if os.path.exists(out_path("coverage_report.json")) else {},
+        "reverse": {
+            "well_posed_queries": fam["reverse"]["queries"],
+            "well_posed_facts": len(fam["reverse"]["facts"]),
+            "ill_posed_queries": fam["reverse_illposed"]["queries"],
+            "ill_posed_facts": len(fam["reverse_illposed"]["facts"]),
+            "benchmark_facts_flagged_inverse_well_posed":
+                sum(1 for f in facts if f["is_inverse_well_posed"])},
+        "recognition_distractors": {
+            "queries": len(rec),
+            "option_count_distribution": {str(k): v for k, v in opt_sizes.items()},
+            "correct_option_position": {str(k): v for k, v in sorted(pos.items())}},
+        "multilingual": {
+            "queries": len(ml),
+            "by_language": dict(collections.Counter(q["language"] for q in ml))},
+        "validity_flags": {
+            "answer_in_subject_surface": {
+                "facts": sum(1 for f in facts if f.get("answer_in_subject_surface")),
+                "share": round(sum(1 for f in facts
+                                   if f.get("answer_in_subject_surface")) / len(facts), 4),
+                "by_relation": dict(collections.Counter(
+                    f["relation"]["relation_id"] for f in facts
+                    if f.get("answer_in_subject_surface")).most_common()),
+                "note": "object string is literally contained in the subject name, "
+                        "so the query can be answered by copying rather than by "
+                        "retrieval; kept in the benchmark but flagged"},
+            "spec_6_2_flagged": {
+                "facts": sum(1 for f in facts if f.get("spec_6_2_flag")),
+                "by_relation": dict(collections.Counter(
+                    f["relation"]["relation_id"] for f in facts
+                    if f.get("spec_6_2_flag")).most_common())}},
+        "configuration": {
+            "filter_models": [m["name"] for m in mdl_cfg["filter_models"]],
+            "evaluated_models": [m["name"] for m in mdl_cfg["evaluated_models"]],
+            "generation": mdl_cfg["generation"]},
+        "stage_reports": {n: load_report(f"stage{n}_report.json")
+                          for n in ["1", "2", "3", "4"]},
+    }
+
+    json.dump(stats, open(out_path("dataset_statistics.json"), "w"),
+              indent=2, ensure_ascii=False)
+    print(json.dumps(stats["pipeline"], indent=2))
+    print("\nvalidity flags:")
+    print(json.dumps(stats["validity_flags"]["answer_in_subject_surface"],
+                     indent=2, ensure_ascii=False)[:600])
+    print(f"\nwrote -> {out_path('dataset_statistics.json')}")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/runner/common.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+"""Shared helpers: config loading, paths, normalization, checksums.
+
+Spec section 18 requires deterministic reruns through configuration files and
+checksums, so every stage loads its parameters from configs/ rather than from
+module-level constants.
+"""
+import os, re, json, glob, hashlib, unicodedata
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CONFIGS = os.path.join(ROOT, "configs")
+OUTPUTS = os.path.join(ROOT, "outputs")
+DATASET = "/scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/dataset"
+
+SEED = 20260101
+
+
+def load_config(name):
+    import yaml
+    with open(os.path.join(CONFIGS, name)) as f:
+        return yaml.safe_load(f)
+
+
+def out_path(*parts):
+    p = os.path.join(OUTPUTS, *parts)
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    return p
+
+
+def read_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def write_jsonl(path, rows):
+    n = 0
+    with open(path, "w") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+            n += 1
+    return n
+
+
+def sha256(path, limit_mb=None):
+    """Checksum for auditability (spec 18). limit_mb hashes only a prefix, which
+    keeps multi-GB source files cheap while still detecting substitution."""
+    h = hashlib.sha256()
+    cap = None if limit_mb is None else limit_mb * 1024 * 1024
+    read = 0
+    with open(path, "rb") as f:
+        while True:
+            b = f.read(1 << 20)
+            if not b:
+                break
+            h.update(b)
+            read += len(b)
+            if cap and read >= cap:
+                break
+    return f"sha256:{h.hexdigest()}" + ("" if cap is None else f"(first{limit_mb}MB)")
+
+
+# ------------------------------------------------------------- normalization
+_QUOTES = "\"'`‘’“”«»"
+_DASHES = "‐‑‒–—―"
+_ARTICLES = re.compile(r"\b(the|a|an)\b")
+
+
+def normalize(text, drop_articles=True):
+    """Comparison form: NFKC, lowercase, punctuation to space, articles dropped.
+
+    Punctuation is replaced INTERNALLY so that token-boundary matching still
+    finds an entity that is followed by a comma. Aliases and generations go
+    through the identical function.
+    """
+    if not text:
+        return ""
+    t = unicodedata.normalize("NFKC", str(text))
+    t = "".join("-" if c in _DASHES else ("'" if c in _QUOTES else c) for c in t)
+    t = t.lower()
+    t = re.sub(r"[^\w\s]", " ", t, flags=re.UNICODE)
+    t = re.sub(r"\s+", " ", t).strip()
+    if drop_articles:
+        t = _ARTICLES.sub(" ", t)
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def norm_key(text):
+    """Identity key for grouping (no article stripping, so 'The Who' stays)."""
+    return normalize(text, drop_articles=False)
+
+
+def dedup_aliases(seq, junk_re=None, min_chars=2, cap=16):
+    """Deduplicate case-insensitively, preserving order.
+
+    The first element is the canonical label and is always kept. Later entries
+    are dropped when they normalize to fewer than `min_chars` characters or hit
+    a junk pattern: crowd-sourced Wikidata alias lists contain single letters,
+    emoji and Wikipedia housekeeping titles, and a one-or-two character alias
+    would match almost any generation under containment scoring.
+    """
+    seen, out = set(), []
+    for i, a in enumerate(seq):
+        if a is None:
+            continue
+        a = str(a).strip()
+        if not a:
+            continue
+        k = a.lower()
+        if k in seen:
+            continue
+        if i > 0 or out:
+            if len(normalize(a)) < min_chars:
+                continue
+            if junk_re is not None and junk_re.search(a):
+                continue
+        seen.add(k)
+        out.append(a)
+        if len(out) >= cap:
+            break
+    return out
+
+
+def compile_junk(patterns):
+    return re.compile("|".join(f"(?:{p})" for p in patterns), re.I) if patterns else None
+
+
+# ---------------------------------------------------------------- reporting
+class Expect:
+    """Collects expected-vs-actual counts. Spec section 10 forbids silently
+    changing counts, so every deviation is recorded and surfaced."""
+
+    def __init__(self):
+        self.rows = []
+
+    def check(self, name, actual, expected, note=""):
+        ok = (expected is None) or (actual == expected)
+        self.rows.append({"name": name, "actual": actual, "expected": expected,
+                          "match": ok, "note": note})
+        return ok
+
+    @property
+    def deviations(self):
+        return [r for r in self.rows if not r["match"]]
+
+    def report(self, title="counts"):
+        print(f"\n{title}")
+        print(f"{'check':38s} {'actual':>10s} {'expected':>10s}  ok")
+        print("-" * 66)
+        for r in self.rows:
+            e = "-" if r["expected"] is None else r["expected"]
+            print(f"{r['name']:38s} {r['actual']:>10} {e:>10}  "
+                  f"{'yes' if r['match'] else 'NO'}")
+        if self.deviations:
+            print(f"\n{len(self.deviations)} deviation(s); "
+                  f"record them in outputs/reconstruction_differences.md")
+        return self.rows

ICLR dataset/runner/enrich_facts.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python
+"""Stage II -> outputs/enriched_facts_6180.jsonl  (spec section 5)
+
+  8,107 candidate rows
+     -> group by entity-aware (subject identity, relation)      spec 5.1
+     -> merge object identities, discard functional conflicts    spec 5.2
+     -> expand accepted-answer aliases                           spec 5.3
+     -> attach a canonical qualification question                spec 5.4
+     -> emit the nested enriched schema                          spec 5.5
+
+Grouping is deliberately CROSS-SOURCE: 1,036 (subject, relation) pairs appear in
+both CounterFact and LAMA-TREx. Kept apart they would put the identical
+qualification question into the benchmark twice, double-counting the fact and
+breaking sample independence.
+"""
+import os, re, sys, json, glob, argparse, collections
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import (DATASET, load_config, out_path, read_jsonl, write_jsonl,
+                    normalize, norm_key, dedup_aliases, compile_junk, Expect)
+import qual_templates as QT
+
+try:
+    import pandas as pd
+except ImportError:
+    pd = None
+
+EXPECTED_GROUPS = 6185
+EXPECTED_CONFLICTS = 5
+EXPECTED_ENRICHED = 6180
+
+
+# ------------------------------------------------------- source metadata maps
+def load_source_metadata(allow_missing_parquet=False):
+    """Entity ids and native alias lists, keyed by (source, subject, rel, object)."""
+    print("[1/5] loading entity ids and source-native aliases ...", flush=True)
+    obj_qid, sub_qid = {}, {}
+    gre_obj, gre_sub, pq_meta = {}, {}, {}
+    degraded = False
+
+    if pd is None:
+        if not allow_missing_parquet:
+            raise SystemExit(
+                "pandas is required to read the CounterFact parquet files "
+                "(spec 5.3 needs target_true.id). Activate the project venv.")
+        print("      WARNING: pandas missing -> CounterFact entity ids SKIPPED",
+              flush=True)
+        degraded = True
+    else:
+        for p in glob.glob(f"{DATASET}/counterfact/data/*.parquet"):
+            for rr in pd.read_parquet(p, columns=["requested_rewrite"])["requested_rewrite"]:
+                k = ("counterfact", rr["subject"], rr["relation_id"],
+                     rr["target_true"]["str"])
+                obj_qid[k] = rr["target_true"]["id"]
+
+    for f in glob.glob(f"{DATASET}/lama/data/TREx/*.jsonl"):
+        for d in read_jsonl(f):
+            k = ("lama_trex", d.get("sub_label"), d.get("predicate_id"),
+                 d.get("obj_label"))
+            obj_qid[k] = d.get("obj_uri")
+            sub_qid[k] = d.get("sub_uri")
+
+    for f in glob.glob(f"{DATASET}/lama/data/Google_RE/*.jsonl"):
+        for d in read_jsonl(f):
+            rid = (d.get("pred") or "").rstrip("/").split("/")[-1]
+            k = (d.get("sub_label") or d.get("sub"), rid,
+                 d.get("obj_label") or d.get("obj"))
+            gre_obj[k] = d.get("obj_aliases") or []
+            gre_sub[k] = d.get("sub_aliases") or []
+
+    p = f"{DATASET}/filter/popqa_meta.jsonl"
+    if os.path.exists(p):
+        for d in read_jsonl(p):
+            pq_meta[(d["subject"], d["relation"], d["object"])] = d
+
+    return obj_qid, sub_qid, gre_obj, gre_sub, pq_meta, degraded
+
+
+def load_wikidata_aliases(needed, path, cap):
+    """Spec 5.3: single filtered pass over the alias resource, never a full load."""
+    print(f"[2/5] single-pass scan of the alias resource for {len(needed)} qids ...",
+          flush=True)
+    out = {}
+    with open(path) as f:
+        for line in f:
+            i = line.find("\t")
+            if i < 0:
+                continue
+            q = line[:i]
+            if q in needed:
+                out[q] = line[i + 1:].rstrip("\n").split("\t")[:cap]
+    print(f"      resolved {len(out)}/{len(needed)}", flush=True)
+    return out
+
+
+# -------------------------------------------------------------------- main
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--candidates", default=out_path("candidate_known_8107.jsonl"))
+    ap.add_argument("--allow_missing_parquet", action="store_true")
+    args = ap.parse_args()
+
+    rel_cfg = load_config("relations.yaml")
+    src_cfg = load_config("source_templates.yaml")
+    alias_cfg = src_cfg["alias_resources"]
+    junk_re = compile_junk(alias_cfg.get("junk_patterns"))
+    cap = alias_cfg.get("max_aliases_per_entity", 16)
+    min_chars = alias_cfg.get("min_alias_chars", 2)
+
+    # relation metadata: relations.yaml is authoritative for benchmark relations,
+    # qual_templates.py supplies the rest so that every enriched fact has a
+    # question (spec 5.4)
+    rel_meta = {}
+    for r in rel_cfg["relations"]:
+        for pid in r["source_relations"]:
+            rel_meta[pid] = r
+    exp = Expect()
+
+    obj_qid, sub_qid, gre_obj, gre_sub, pq_meta, degraded = \
+        load_source_metadata(args.allow_missing_parquet)
+
+    rows = list(read_jsonl(args.candidates))
+    needed = set()
+    for d in rows:
+        k = (d["source"], d["subject"], d["relation"], d["object"])
+        for m in (obj_qid, sub_qid):
+            if m.get(k):
+                needed.add(m[k])
+    qid_alias = load_wikidata_aliases(
+        needed, os.path.join(DATASET, alias_cfg["wikidata_entity_aliases"]), cap)
+
+    def obj_alias_raw(d):
+        src, s, rid, o = d["source"], d["subject"], d["relation"], d["object"]
+        al = [o]
+        if src == "lama_googlere":
+            al += gre_obj.get((s, rid, o), [])
+        elif src == "popqa":
+            m = pq_meta.get((s, rid, o), {})
+            al += m.get("possible_answers", []) + m.get("o_aliases", [])
+        q = obj_qid.get((src, s, rid, o))
+        if q:
+            al += qid_alias.get(q, [])
+        return al
+
+    def sub_alias_raw(d):
+        src, s, rid, o = d["source"], d["subject"], d["relation"], d["object"]
+        al = [s]
+        if src == "lama_googlere":
+            al += gre_sub.get((s, rid, o), [])
+        elif src == "popqa":
+            al += pq_meta.get((s, rid, o), {}).get("s_aliases", [])
+        q = sub_qid.get((src, s, rid, o))
+        if q:
+            al += qid_alias.get(q, [])
+        return al
+
+    # ---- spec 5.1: entity-aware grouping ----
+    print("[3/5] grouping by (subject identity, relation) across sources ...",
+          flush=True)
+    groups = collections.OrderedDict()
+    for d in rows:
+        # prefer the entity id when the source provides one, else normalized text
+        sq = sub_qid.get((d["source"], d["subject"], d["relation"], d["object"]))
+        ident = sq or norm_key(d["subject"])
+        groups.setdefault((ident, d["relation"]), []).append(d)
+    # a subject with an id in one source and no id in another must not split into
+    # two groups: fold text-keyed groups into the id-keyed one where possible
+    text_to_id = {}
+    for (ident, rid), members in groups.items():
+        if str(ident).startswith("Q"):
+            for m in members:
+                text_to_id[(norm_key(m["subject"]), rid)] = (ident, rid)
+    merged = collections.OrderedDict()
+    for key, members in groups.items():
+        ident, rid = key
+        if not str(ident).startswith("Q"):
+            key = text_to_id.get((ident, rid), key)
+        merged.setdefault(key, []).extend(members)
+    groups = merged
+    exp.check("grouped_facts", len(groups), EXPECTED_GROUPS)
+
+    # ---- spec 5.2 / 5.3 / 5.4 ----
+    print("[4/5] merging objects, expanding aliases, attaching questions ...",
+          flush=True)
+    SRC_PRIORITY = ["lama_trex", "counterfact", "popqa",
+                    "lama_googlere", "lama_conceptnet"]
+    rep = {"conflicts": collections.Counter(), "no_template": collections.Counter(),
+           "cross_source_groups": 0, "merged_groups": 0}
+
+    facts = []
+    for (ident, rid), members in groups.items():
+        cfg = rel_meta.get(rid)
+        spec = QT.resolve(rid)
+        if cfg is None and spec is None:
+            rep["no_template"][rid] += len(members)
+            continue
+
+        is_functional = bool(cfg["is_functional"]) if cfg else (not spec["multi"])
+        srcs = sorted({m["source"] for m in members},
+                      key=lambda s: SRC_PRIORITY.index(s) if s in SRC_PRIORITY else 99)
+        primary = next(m for m in members if m["source"] == srcs[0])
+
+        objects, obj_ids = [], []
+        seen_o = set()
+        for m in members:
+            k = norm_key(m["object"])
+            if k not in seen_o:
+                seen_o.add(k)
+                objects.append(m["object"])
+                obj_ids.append(obj_qid.get((m["source"], m["subject"], rid, m["object"])))
+
+        # spec 5.2: a functional group holding incompatible object identities is
+        # an unanswerable question (two people sharing a name, or a historical vs
+        # modern referent). A MISSING entity id is not evidence of sameness, so
+        # every member must carry an id and all ids must agree to survive.
+        if is_functional and len(objects) > 1:
+            ids = set(obj_ids)
+            if None in ids or len(ids) != 1:
+                rep["conflicts"][rid] += 1
+                continue
+
+        if len(members) > 1:
+            rep["merged_groups"] += 1
+        if len(srcs) > 1:
+            rep["cross_source_groups"] += 1
+
+        obj_aliases = dedup_aliases(
+            [a for m in members for a in obj_alias_raw(m)], junk_re, min_chars, cap)
+        sub_aliases = dedup_aliases(
+            [a for m in members for a in sub_alias_raw(m)], junk_re, min_chars, cap)
+
+        question = (cfg["qualification"] if cfg else spec["q"]).format(
+            s=primary["subject"])
+        facts.append({
+            "_sort": (rid, norm_key(primary["subject"])),
+            "subject": {"canonical": primary["subject"],
+                        "entity_id": ident if str(ident).startswith("Q") else None,
+                        "aliases": sub_aliases},
+            "relation": {"relation_id": cfg["relation_id"] if cfg else rid,
+                         "canonical_name": cfg["relation_id"] if cfg else rid,
+                         "source_relations": [rid],
+                         "direction": cfg.get("direction", "forward") if cfg else "forward"},
+            "object": {"canonical": objects[0],
+                       "entity_id": obj_ids[0],
+                       "aliases": obj_aliases,
+                       "variant_surface_forms": objects},
+            "qualification_question": question,
+            "sources": srcs,
+            "source_records": [m["raw_id"] for m in members],
+            "legacy_refs": [m["legacy_ref"] for m in members],
+            "is_functional": is_functional,
+            "is_inverse_well_posed": bool(cfg["is_inverse_well_posed"]) if cfg else False,
+            "answer_type": cfg["answer_type"] if cfg else spec["type"],
+            "answer_granularity": (cfg["answer_granularity"] if cfg
+                                   else (spec["gran"] or "entity")),
+            "is_core_source": bool({"counterfact", "lama_trex", "popqa"} & set(srcs)),
+            "is_benchmark_relation": cfg is not None,
+            "spec_6_2_flag": (cfg or {}).get("spec_6_2_flag"),
+            # The object string is literally contained in the subject name
+            # ("Airbus A318" -> "Airbus"). Such a fact is answerable by copying a
+            # substring of the question, so it measures string manipulation
+            # rather than knowledge retrieval. Not dropped here -- spec 16
+            # forbids silently removing facts -- but flagged so every downstream
+            # analysis can report with and without them.
+            "answer_in_subject_surface": bool(
+                normalize(objects[0]) and
+                normalize(objects[0]) in normalize(primary["subject"])),
+        })
+
+    exp.check("functional_conflicts_removed", sum(rep["conflicts"].values()),
+              EXPECTED_CONFLICTS)
+    exp.check("enriched_facts", len(facts), EXPECTED_ENRICHED)
+    exp.check("merged_groups", rep["merged_groups"], 1771)
+    exp.check("cross_source_groups", rep["cross_source_groups"], 1036)
+
+    # ---- stable, deterministic fact ids (spec 6.3) ----
+    print("[5/5] assigning deterministic fact ids ...", flush=True)
+    facts.sort(key=lambda f: f.pop("_sort"))
+    for i, f in enumerate(facts, 1):
+        f["fact_id"] = f"fact_{i:06d}"
+    facts = [{"fact_id": f.pop("fact_id"), **f} for f in facts]
+
+    path = out_path("enriched_facts_6180.jsonl")
+    write_jsonl(path, facts)
+
+    exp.report("Stage II counts")
+    meta = {"stage": "II_enrichment",
+            "n_enriched": len(facts),
+            "grouped": len(groups),
+            "conflicts_removed": dict(rep["conflicts"]),
+            "no_template": dict(rep["no_template"]),
+            "merged_groups": rep["merged_groups"],
+            "cross_source_groups": rep["cross_source_groups"],
+            "per_source": dict(collections.Counter(f["sources"][0] for f in facts)),
+            "counterfact_entity_ids_skipped": degraded,
+            "checks": exp.rows}
+    json.dump(meta, open(out_path("stage2_report.json"), "w"),
+              indent=2, ensure_ascii=False)
+    print(f"\nwrote {len(facts)} enriched facts -> {path}")
+    print(f"  conflicts removed: {dict(rep['conflicts'])}")
+    return 1 if exp.deviations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ICLR dataset/runner/eval_run.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+"""Stage VI -> outputs/evaluation/<model>.jsonl   [GPU]
+
+Runs the full evaluation query bank for ONE model. Same decoding configuration
+as anchor qualification (configs/models.yaml:generation) so that anchor and
+perturbation numbers are directly comparable -- a different max_new_tokens or a
+chat template on one side would turn a protocol difference into a fake
+stability effect.
+
+Anchor queries live in the bank too (condition_family == "anchor") and share
+their prompt string with qualification_run.py. They are regenerated here rather
+than copied so that every condition passes through one identical code path.
+
+Scoring is NOT done here: eval_score.py reads these generations on CPU, so the
+scorer can be revised without paying for GPU again.
+"""
+import os, sys, json, time, argparse, collections
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl
+
+PROMPT = "Question: {q}\nAnswer with only the shortest correct answer.\nAnswer:"
+
+
+def build_prompt(row):
+    """Anchor and the open-ended conditions get the standard instruction wrapper.
+
+    The perturbation queries carry their own surface form -- that IS the
+    perturbation -- so wrapping them in the anchor template would erase the
+    manipulation. They are passed through with a bare "Answer:" cue so the model
+    still knows a short answer is wanted.
+    """
+    fam = row["condition_family"]
+    if fam == "anchor":
+        return PROMPT.format(q=row["query"])
+    if fam == "recognition":
+        # candidates are already inside the query text
+        return f"{row['query']}\nAnswer:"
+    return f"{row['query']}\nAnswer:"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
+    ap.add_argument("--queries", default=out_path("evaluation_queries_44418.jsonl"))
+    ap.add_argument("--conditions", nargs="*", default=None,
+                    help="restrict to these condition families (default: all)")
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--batch", type=int, default=0, help="0 = value from config")
+    ap.add_argument("--resume", action="store_true",
+                    help="skip queries already present in the output file")
+    args = ap.parse_args()
+
+    cfg = load_config("models.yaml")
+    entry = next((m for m in cfg["evaluated_models"] if m["name"] == args.model), None)
+    if entry is None:
+        raise SystemExit(f"{args.model} is not in configs/models.yaml:evaluated_models")
+    gen_cfg = cfg["generation"]
+    if gen_cfg.get("use_chat_template"):
+        raise SystemExit("spec 7.2: base and instruct models must share the raw "
+                         "prompt string; chat templates are not applied")
+
+    rows = list(read_jsonl(args.queries))
+    if args.conditions:
+        rows = [r for r in rows if r["condition_family"] in args.conditions]
+    if args.limit:
+        rows = rows[:args.limit]
+
+    dest = out_path("evaluation", f"{args.model}.jsonl")
+    done = set()
+    if args.resume and os.path.exists(dest):
+        done = {r["query_id"] for r in read_jsonl(dest)}
+        rows = [r for r in rows if r["query_id"] not in done]
+        print(f"[{args.model}] resuming: {len(done)} already done", flush=True)
+    if not rows:
+        print(f"[{args.model}] nothing to do")
+        return
+
+    N = len(rows)
+    fam_counts = collections.Counter(r["condition_family"] for r in rows)
+    print(f"[{args.model}] N={N}  {dict(fam_counts)}", flush=True)
+
+    path = os.path.join(cfg["model_root"], entry["path"])
+    torch.manual_seed(gen_cfg.get("seed", 0))
+    tok = AutoTokenizer.from_pretrained(path)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    tok.padding_side = "left"
+    tok.truncation_side = "left"
+    model = AutoModelForCausalLM.from_pretrained(
+        path, dtype=getattr(torch, gen_cfg.get("dtype", "bfloat16")),
+        device_map={"": 0}).eval()
+
+    prompts = [build_prompt(r) for r in rows]
+    # context queries prepend distractor sentences, so they are much longer than
+    # the anchor; a single global max_len would silently truncate them
+    max_len = max(gen_cfg.get("max_prompt_len", 96), 192)
+    B = args.batch or gen_cfg.get("batch_size", 96)
+
+    out = [None] * N
+    order = sorted(range(N), key=lambda i: len(prompts[i]))
+    t0 = time.time()
+    with torch.no_grad():
+        for b in range(0, N, B):
+            idx = order[b:b + B]
+            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
+                      truncation=True, max_length=max_len).to(0)
+            plen = enc["input_ids"].shape[1]
+            gen = model.generate(**enc,
+                                 max_new_tokens=gen_cfg.get("max_new_tokens", 24),
+                                 do_sample=gen_cfg.get("do_sample", False),
+                                 num_beams=gen_cfg.get("num_beams", 1),
+                                 pad_token_id=tok.pad_token_id)
+            new_ids = gen[:, plen:]
+            texts = tok.batch_decode(new_ids, skip_special_tokens=True)
+            for j, i in enumerate(idx):
+                ids = new_ids[j].tolist()
+                n_tok, fin = len(ids), "length"
+                for k, t in enumerate(ids):
+                    if t == tok.eos_token_id:
+                        n_tok, fin = k, "eos"
+                        break
+                out[i] = {"query_id": rows[i]["query_id"],
+                          "fact_id": rows[i]["fact_id"],
+                          "condition_family": rows[i]["condition_family"],
+                          "model": args.model,
+                          "prompt": prompts[i],
+                          "raw_response": texts[j],
+                          "generated_tokens": int(n_tok),
+                          "finish_reason": fin}
+            if b % (B * 20) == 0:
+                d = b + len(idx)
+                print(f"  {d}/{N}  {d / max(time.time() - t0, 1e-9):.1f}/s", flush=True)
+
+    mode = "a" if (args.resume and done) else "w"
+    with open(dest, mode) as f:
+        for r in out:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    json.dump({"model": args.model, "n_generated": N, "resumed_from": len(done),
+               "generation": gen_cfg, "max_prompt_len": max_len,
+               "model_entry": entry, "seconds": round(time.time() - t0, 1),
+               "by_condition": dict(fam_counts)},
+              open(out_path("evaluation", f"{args.model}.meta.json"), "w"),
+              indent=2, ensure_ascii=False)
+    print(f"[{args.model}] wrote {N} -> {dest}  ({time.time() - t0:.0f}s)  EVAL_DONE")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/runner/eval_score.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python
+"""Stage VI scoring -> outputs/evaluation/<model>.scored.jsonl
+                       outputs/stability_report.json
+
+Reads the stored generations on CPU and produces the stability numbers.
+
+Three reporting rules, all enforced here rather than left to the reader:
+
+  * conditions are grouped by the booleans carried on each query, which come
+    from configs/eval_conditions.yaml. `recognition` and `reverse_illposed`
+    never enter a main-forward average, and `reverse` is reported separately
+    because it changes the target slot (spec 2.3 / 16).
+
+  * two denominators are always reported side by side:
+        fixed     all 2,592 benchmark facts            (spec 2.1)
+        anchored  restricted to K_m for that model     conditional retention
+    The fixed one is the benchmark score; the anchored one answers "of the
+    facts this model demonstrably knows, how many survive the perturbation".
+
+  * every number is split by `answer_in_subject_surface`, because 28.9% of the
+    benchmark can be answered by copying a substring of the question and those
+    facts are near-ceiling stable for reasons unrelated to knowledge
+    (outputs/reconstruction_differences.md F1).
+"""
+import os, sys, json, glob, argparse, collections
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl, write_jsonl, normalize
+from scoring_full import score, needs_manual_review
+
+import re
+MCQ_LETTER = re.compile(r"^\s*[\(\[]?([A-Da-d])[\)\]\.:,\s]")
+
+
+def score_recognition(raw, row):
+    """MCQ: accept either the option letter or the option text."""
+    m = MCQ_LETTER.match((raw or "") + " ")
+    if m and row.get("correct_option"):
+        ok = m.group(1).upper() == str(row["correct_option"]).upper()
+        return {"label": "correct" if ok else "incorrect",
+                "matched_alias": m.group(1).upper(), "scorer": "mcq_letter",
+                "span": (raw or "").strip()[:40], "flags": []}
+    return score(raw, row["gold_aliases"], answer_type=row["answer_type"],
+                 granularity=row.get("answer_granularity"))
+
+
+def bootstrap_ci(values, groups, n_boot=2000, seed=0, alpha=0.05):
+    """Cluster bootstrap over relations; the relation mix is heavily skewed."""
+    rng = np.random.default_rng(seed)
+    by = collections.defaultdict(list)
+    for v, g in zip(values, groups):
+        by[g].append(v)
+    keys = list(by)
+    if not keys:
+        return (float("nan"), float("nan"))
+    arrs = [np.asarray(by[k], dtype=float) for k in keys]
+    st = np.empty(n_boot)
+    for b in range(n_boot):
+        pick = rng.integers(0, len(keys), len(keys))
+        st[b] = np.concatenate([arrs[i] for i in pick]).mean()
+    return float(np.quantile(st, alpha / 2)), float(np.quantile(st, 1 - alpha / 2))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--queries", default=out_path("evaluation_queries_44418.jsonl"))
+    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
+    ap.add_argument("--models", nargs="*", default=None)
+    args = ap.parse_args()
+
+    cond_cfg = load_config("eval_conditions.yaml")["conditions"]
+    queries = {q["query_id"]: q for q in read_jsonl(args.queries)}
+    facts = {f["fact_id"]: f for f in read_jsonl(args.facts)}
+
+    known_path = out_path("known_labels.json")
+    known = json.load(open(known_path))["labels"] if os.path.exists(known_path) else {}
+    if not known:
+        print("WARNING: outputs/known_labels.json missing -> anchored (K_m) "
+              "numbers will be omitted. Run qualification_score.py first.")
+
+    edir = os.path.dirname(out_path("evaluation", "x"))
+    paths = sorted(p for p in glob.glob(os.path.join(edir, "*.jsonl"))
+                   if not p.endswith(".scored.jsonl"))
+    if args.models:
+        paths = [p for p in paths
+                 if os.path.basename(p)[:-len(".jsonl")] in args.models]
+    if not paths:
+        raise SystemExit(f"no generation files in {edir}; run eval_run.py first")
+
+    report = {"models": {}, "denominators": {
+        "fixed": "all benchmark facts (spec 2.1)",
+        "anchored": "facts whose anchor label is `correct` for that model (K_m)"}}
+
+    for p in paths:
+        model = os.path.basename(p)[:-len(".jsonl")]
+        km = {fid for fid, lab in known.items() if lab.get(model) == "correct"}
+        scored = []
+        # cond -> bucket -> list of (correct, relation)
+        acc = collections.defaultdict(lambda: collections.defaultdict(list))
+        labels = collections.defaultdict(collections.Counter)
+
+        for g in read_jsonl(p):
+            q = queries.get(g["query_id"])
+            if q is None:
+                raise SystemExit(f"{model}: generation for unknown query "
+                                 f"{g['query_id']}")
+            fam = q["condition_family"]
+            r = (score_recognition(g["raw_response"], q) if fam == "recognition"
+                 else score(g["raw_response"], q["gold_aliases"],
+                            answer_type=q["answer_type"],
+                            granularity=q.get("answer_granularity")))
+            ok = 1.0 if r["label"] == "correct" else 0.0
+            copy_flag = bool(q.get("answer_in_subject_surface"))
+            rel = q["relation"]
+
+            rec = {"query_id": q["query_id"], "fact_id": q["fact_id"],
+                   "model": model, "condition_family": fam,
+                   "language": q.get("language", "en"),
+                   "target_slot": q["target_slot"],
+                   "raw_response": g["raw_response"],
+                   "extracted_answer": r["span"], "label": r["label"],
+                   "matched_alias": r["matched_alias"], "scorer": r["scorer"],
+                   "relation": rel, "answer_type": q["answer_type"],
+                   "answer_in_subject_surface": copy_flag,
+                   "in_K_m": q["fact_id"] in km,
+                   "use_for_main_forward": q["use_for_main_forward"],
+                   "manual_review": needs_manual_review(r)}
+            scored.append(rec)
+            labels[fam][r["label"]] += 1
+
+            acc[fam]["fixed"].append((ok, rel))
+            acc[fam]["fixed_copy" if copy_flag else "fixed_real"].append((ok, rel))
+            if q["fact_id"] in km:
+                acc[fam]["anchored"].append((ok, rel))
+                acc[fam]["anchored_copy" if copy_flag else "anchored_real"].append((ok, rel))
+
+        write_jsonl(os.path.join(edir, f"{model}.scored.jsonl"), scored)
+
+        def stat(pairs):
+            if not pairs:
+                return None
+            v = [x for x, _ in pairs]
+            g = [r for _, r in pairs]
+            lo, hi = bootstrap_ci(v, g)
+            return {"acc": round(float(np.mean(v)), 4), "n": len(v),
+                    "ci95_relation_clustered": [round(lo, 4), round(hi, 4)]}
+
+        per_cond = {}
+        for fam, buckets in acc.items():
+            per_cond[fam] = {
+                "role": cond_cfg[fam]["role"],
+                "use_for_main_forward": cond_cfg[fam]["use_for_main_forward"],
+                "labels": dict(labels[fam]),
+                **{b: stat(v) for b, v in buckets.items()}}
+
+        main_fams = [f for f in per_cond if cond_cfg[f]["use_for_main_forward"]
+                     and f != "anchor"]
+        def macro(bucket):
+            vals = [per_cond[f][bucket]["acc"] for f in main_fams
+                    if per_cond[f].get(bucket)]
+            return round(float(np.mean(vals)), 4) if vals else None
+
+        report["models"][model] = {
+            "K_m": len(km),
+            "per_condition": per_cond,
+            "main_forward_macro": {
+                "fixed": macro("fixed"), "anchored": macro("anchored"),
+                "anchored_real": macro("anchored_real"),
+                "anchored_copy": macro("anchored_copy"),
+                "note": "mean over paraphrase/format/context/multilingual; "
+                        "anchor excluded (it is the baseline), reverse excluded "
+                        "(different target slot), recognition and "
+                        "reverse_illposed excluded (diagnostics)"},
+            "n_manual_review": sum(1 for r in scored if r["manual_review"]),
+        }
+
+    json.dump(report, open(out_path("stability_report.json"), "w"),
+              indent=2, ensure_ascii=False)
+
+    # ---------------------------------------------------------------- console
+    order = ["anchor", "paraphrase", "format", "context", "multilingual",
+             "reverse", "recognition", "reverse_illposed"]
+    for model, m in report["models"].items():
+        print(f"\n=== {model}   K_m={m['K_m']} ===")
+        print(f"{'condition':18s} {'fixed':>7s} {'anchored':>9s} "
+              f"{'  ·real':>8s} {'  ·copy':>8s} {'n':>7s}  role")
+        print("-" * 70)
+        for fam in order:
+            c = m["per_condition"].get(fam)
+            if not c:
+                continue
+            def g(b):
+                return f"{c[b]['acc']:.3f}" if c.get(b) else "    -"
+            print(f"{fam:18s} {g('fixed'):>7s} {g('anchored'):>9s} "
+                  f"{g('anchored_real'):>8s} {g('anchored_copy'):>8s} "
+                  f"{c['fixed']['n']:7d}  {c['role']}")
+        mm = m["main_forward_macro"]
+        print(f"{'MAIN macro':18s} {str(mm['fixed']):>7s} {str(mm['anchored']):>9s} "
+              f"{str(mm['anchored_real']):>8s} {str(mm['anchored_copy']):>8s}")
+    print("\n·real / ·copy split the anchored numbers by whether the answer is "
+          "contained in the subject name (see reconstruction_differences.md F1)")
+    print(f"\nwrote -> {out_path('stability_report.json')}")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/runner/filter_run.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+"""Stage I first-token candidate filtering for ONE model (spec section 4.4) [GPU]
+
+Regenerates the per-prompt verdict vector that build_candidate_known.py consumes.
+The stored vectors under dataset/filter/ were produced by an equivalent script;
+this one is config-driven per spec 4.4 and writes the richer per-prompt record
+the specification asks for.
+
+Protocol, unchanged from the original run so the vectors stay comparable:
+  1. tokenize the cloze prompt
+  2. take the logits at the final prompt position
+  3. take the argmax token
+  4. compare with the first token of " " + object
+  5. record pass / fail
+
+This is candidate RECALL only. Spec 4.4: a pass here is not a correctness
+judgment, and spec 16 forbids treating first-token correctness as full-answer
+correctness.
+"""
+import os, sys, json, time, argparse
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import DATASET, load_config, out_path, read_jsonl
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
+    ap.add_argument("--prompts", default=os.path.join(DATASET, "filter/prompts.jsonl"))
+    ap.add_argument("--out_dir", default=None)
+    ap.add_argument("--batch", type=int, default=384)
+    ap.add_argument("--max_len", type=int, default=64)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--save_records", action="store_true",
+                    help="also write the per-prompt JSONL of spec 4.4; large")
+    args = ap.parse_args()
+
+    cfg = load_config("models.yaml")
+    entry = next((m for m in cfg["filter_models"] if m["name"] == args.model), None)
+    if entry is None:
+        raise SystemExit(f"{args.model} is not in configs/models.yaml:filter_models")
+    path = os.path.join(cfg["model_root"], entry["path"])
+    out_dir = args.out_dir or out_path("filter_outputs", "x")[:-1]
+    os.makedirs(out_dir, exist_ok=True)
+
+    prompts, objects = [], []
+    ids = []
+    for d in read_jsonl(args.prompts):
+        prompts.append(d["prompt"])
+        objects.append(d["object"])
+        ids.append(d["id"])
+        if args.limit and len(prompts) >= args.limit:
+            break
+    N = len(prompts)
+    print(f"[{args.model}] N={N}", flush=True)
+
+    tok = AutoTokenizer.from_pretrained(path)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    tok.padding_side = "left"
+    tok.truncation_side = "left"      # keep the END of the prompt, the cloze cue
+    model = AutoModelForCausalLM.from_pretrained(
+        path, dtype=torch.bfloat16, device_map={"": 0}).eval()
+
+    gold_first = np.empty(N, dtype=np.int64)
+    for i, o in enumerate(objects):
+        t = tok(" " + o, add_special_tokens=False).input_ids
+        gold_first[i] = t[0] if t else -1
+
+    passed = np.zeros(N, dtype=np.uint8)
+    pred_ids = np.zeros(N, dtype=np.int64)
+    order = sorted(range(N), key=lambda i: len(prompts[i]))
+    t0 = time.time()
+    with torch.no_grad():
+        for b in range(0, N, args.batch):
+            idx = order[b:b + args.batch]
+            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
+                      truncation=True, max_length=args.max_len).to(0)
+            pred = model(**enc).logits[:, -1, :].argmax(-1).cpu().numpy()
+            for j, i in enumerate(idx):
+                pred_ids[i] = pred[j]
+                passed[i] = int(pred[j] == gold_first[i])
+            if b % (args.batch * 200) == 0:
+                done = b + len(idx)
+                el = max(time.time() - t0, 1e-9)
+                print(f"  {done}/{N}  {done / el:.0f} ex/s  "
+                      f"pass={passed[:done].mean():.4f}", flush=True)
+
+    np.save(os.path.join(out_dir, f"correct_{args.model}.npy"), passed)
+    if args.save_records:
+        with open(os.path.join(out_dir, f"records_{args.model}.jsonl"), "w") as f:
+            for i in range(N):
+                f.write(json.dumps({
+                    "prompt_id": ids[i], "model": args.model,
+                    "predicted_token_id": int(pred_ids[i]),
+                    "predicted_token_text": tok.decode([int(pred_ids[i])]),
+                    "gold_token_id": int(gold_first[i]),
+                    "gold_token_text": tok.decode([int(gold_first[i])])
+                                       if gold_first[i] >= 0 else "",
+                    "passed": bool(passed[i])}, ensure_ascii=False) + "\n")
+    print(f"[{args.model}] pass rate={passed.mean():.4f}  "
+          f"({time.time() - t0:.0f}s)  FILTER_DONE", flush=True)
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/runner/qual_templates.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+"""Qualification-only question templates.
+
+DELIBERATELY SEPARATE from dataset/filter/rel_templates.py: the qualification
+question must not be one of the eval-condition paraphrases, otherwise a fact
+qualifies on exactly the phrasing that is later scored as a "perturbation" and
+the stability measurement leaks.  Every `q` below is checked against the eval
+canonical/paraphrase set by validate_facts.py.
+
+Per relation:
+  q      qualification question, slot {s}; answer = object
+  type   answer_type (drives the scorer and the per-type reporting breakdown)
+  gran   answer_granularity, only meaningful for date/number types
+  multi  relation is inherently multi-answer (an entity can have several
+         equally correct objects) -> facts get is_multi_answer=True even when
+         the candidate pool happens to contain only one object
+"""
+
+# answer_type vocabulary (keep closed; validate_facts.py enforces it)
+TYPES = {"person", "place", "city", "country", "language", "organization",
+         "occupation", "sport", "instrument", "genre", "religion", "color",
+         "year", "date", "entity", "concept", "action", "property"}
+
+QUAL = {
+ # ---- language ----
+ "P103":  dict(q="Which language did {s} grow up speaking?",            type="language", multi=False),
+ "P1412": dict(q="Which language is {s} able to speak?",                type="language", multi=True),
+ "P37":   dict(q="Which language has official status in {s}?",          type="language", multi=True),
+ "P364":  dict(q="In which language was {s} originally produced?",      type="language", multi=True),
+ "P407":  dict(q="Which language is {s} written in?",                   type="language", multi=True),
+ # ---- geography ----
+ "P36":   dict(q="Which city is the seat of government of {s}?",        type="city",     multi=False),
+ "P1376": dict(q="{s} is the capital city of which country?",           type="country",  multi=False),
+ "P17":   dict(q="Which country does {s} belong to?",                   type="country",  multi=False),
+ "P27":   dict(q="Which country holds {s}'s citizenship?",              type="country",  multi=True),
+ "P30":   dict(q="Which continent is {s} part of?",                     type="place",    multi=False),
+ "P131":  dict(q="Which administrative region contains {s}?",           type="place",    multi=False),
+ "P276":  dict(q="At which location can {s} be found?",                 type="place",    multi=False),
+ "P19":   dict(q="In which place did {s} come into the world?",         type="city",     multi=False),
+ "P20":   dict(q="At which place did {s} pass away?",                   type="city",     multi=False),
+ "P159":  dict(q="Which city hosts the main offices of {s}?",                 type="city",     multi=False),
+ "P190":  dict(q="{s} maintains a twin-town relationship with which city?",                     type="city",     multi=True),
+ "P47":   dict(q="Which territory lies adjacent to {s}?",               type="place",    multi=True),
+ "P495":  dict(q="Which country did {s} originate from?",               type="country",  multi=False),
+ "P740":  dict(q="{s} came into existence in which place?",                     type="city",     multi=False),
+ "P937":  dict(q="In which place did {s} carry out their work?",        type="city",     multi=True),
+ "P1001": dict(q="Which jurisdiction does {s} have legal force in?",    type="place",    multi=False),
+ # ---- people / organizations ----
+ "P178":  dict(q="Which company or person created {s}?",                type="organization", multi=False),
+ "P176":  dict(q="Which company builds {s}?",                           type="organization", multi=False),
+ "P127":  dict(q="Who is the owner of {s}?",                            type="organization", multi=False),
+ "P108":  dict(q="For which organization does {s} work?",               type="organization", multi=True),
+ "P463":  dict(q="{s} holds membership in which organization?",         type="organization", multi=True),
+ "P449":  dict(q="Which network first broadcast {s}?",                  type="organization", multi=False),
+ "P264":  dict(q="Under which record label is {s} signed?",             type="organization", multi=True),
+ "P22":   dict(q="{s} is the child of which father?",                   type="person",   multi=False),
+ "P25":   dict(q="{s} is the child of which mother?",                   type="person",   multi=False),
+ "P50":   dict(q="Which writer wrote {s}?",                             type="person",   multi=True),
+ "P57":   dict(q="Which filmmaker directed {s}?",                       type="person",   multi=True),
+ "P58":   dict(q="Which writer wrote the screenplay for {s}?",          type="person",   multi=True),
+ "P86":   dict(q="Which composer wrote the music for {s}?",             type="person",   multi=True),
+ "P162":  dict(q="Which person produced {s}?",                          type="person",   multi=True),
+ # ---- attributes ----
+ "P106":  dict(q="Which profession is {s} known for?",                      type="occupation", multi=True),
+ "P101":  dict(q="Which subject area is {s} known for working on?",     type="concept",  multi=True),
+ "P641":  dict(q="Which sport is {s} associated with?",                 type="sport",    multi=False),
+ "P413":  dict(q="On the field, which position is {s} assigned to?",    type="occupation", multi=False),
+ "P1303": dict(q="Which musical instrument does {s} perform on?",       type="instrument", multi=True),
+ "P136":  dict(q="Which genre does {s} fall under?",                    type="genre",    multi=True),
+ "P140":  dict(q="Which faith does {s} follow?",                        type="religion", multi=False),
+ "P462":  dict(q="Which colour does {s} have?",                         type="color",    multi=True),
+ "P31":   dict(q="{s} is an example of what kind of thing?",            type="concept",  multi=True),
+ "P279":  dict(q="{s} is a more specific kind of what?",                type="concept",  multi=True),
+ "P527":  dict(q="Which component does {s} contain?",                   type="entity",   multi=True),
+
+ # ---- Google_RE (extension set) ----
+ "date_of_birth":  dict(q="In which year was {s} born?",                type="year",  gran="year",  multi=False),
+ "place_of_birth": dict(q="In which place did {s} come into the world?", type="city",  multi=False),
+ "place_of_death": dict(q="At which place did {s} pass away?",          type="city",  multi=False),
+
+ # ---- ConceptNet (open-ended extension set; all inherently multi-answer) ----
+ "IsA":             dict(q="Which category does {s} belong to?",                     type="concept",  multi=True),
+ "UsedFor":         dict(q="People use {s} in order to do what?",                          type="action",   multi=True),
+ "AtLocation":      dict(q="In what sort of place does {s} normally sit?",            type="place",    multi=True),
+ "HasA":            dict(q="Which part does {s} come with?",                            type="entity",   multi=True),
+ "HasProperty":     dict(q="Which characteristic applies to {s}?",                   type="property", multi=True),
+ "CapableOf":       dict(q="What is {s} able to do?",                        type="action",   multi=True),
+ "PartOf":          dict(q="Which larger whole includes {s}?",                         type="entity",   multi=True),
+ "Causes":          dict(q="Which outcome follows from {s}?",                           type="action",   multi=True),
+ "CausesDesire":    dict(q="After {s}, what urge follows?",             type="action",   multi=True),
+ "Desires":         dict(q="Which thing does {s} wish for?",                            type="action",   multi=True),
+ "NotDesires":      dict(q="Which thing would {s} rather avoid?",                        type="action",   multi=True),
+ "HasSubevent":     dict(q="What happens as part of {s}?",                   type="action",   multi=True),
+ "HasPrerequisite": dict(q="What has to happen before {s}?",                 type="action",   multi=True),
+ "MotivatedByGoal": dict(q="Why would someone do {s}?",                      type="action",   multi=True),
+ "MadeOf":          dict(q="What material is {s} made of?",                  type="entity",   multi=True),
+ "ReceivesAction":  dict(q="Which action is commonly performed on {s}?",                       type="action",   multi=True),
+}
+
+# instruction appended to every qualification prompt (no candidates shown, so
+# this stays free generation; it only suppresses explanatory prose)
+INSTRUCTION = "Answer with only the shortest correct answer."
+
+
+def resolve(rid):
+    """Spec for a relation id, or None when the relation has no template.
+
+    No generic fallback on purpose: a fact whose relation lacks a hand-written
+    natural question would get an awkward auto-verbalization, and a wrong
+    qualification question silently shrinks the Known Set. Such facts are
+    dropped by enrich_facts.py and counted in the report.
+    """
+    spec = QUAL.get(rid)
+    if spec is None:
+        return None
+    return {"q": spec["q"], "type": spec["type"],
+            "gran": spec.get("gran"), "multi": spec.get("multi", False)}
+
+
+def build_prompt(question, instruction=INSTRUCTION):
+    """Plain-completion qualification prompt (see README for why not chat)."""
+    return f"Question: {question}\n{instruction}\nAnswer:"

ICLR dataset/runner/qualification_run.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+"""Stage V -> outputs/qualification/<model>.jsonl  (spec section 7) [GPU]
+
+Anchor qualification: does this model answer the canonical question correctly?
+
+Spec 7.1: the result is a LABEL. It never removes a fact from the benchmark, so
+the denominator stays at 2,592 for every model and adding a model later cannot
+change any previously computed number.
+
+Spec 7.2: identical raw prompt string for base and instruction-tuned models, no
+chat template, no candidates, no few-shot.
+Spec 7.3: greedy decoding, max_new_tokens 24, everything stored.
+"""
+import os, sys, json, time, argparse
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl
+
+PROMPT = "Question: {q}\nAnswer with only the shortest correct answer.\nAnswer:"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
+    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--save_logprob", action="store_true",
+                    help="one extra teacher-forced pass for the gold sequence score")
+    args = ap.parse_args()
+
+    cfg = load_config("models.yaml")
+    entry = next((m for m in cfg["evaluated_models"] if m["name"] == args.model), None)
+    if entry is None:
+        raise SystemExit(f"{args.model} is not in configs/models.yaml:evaluated_models")
+    gen_cfg = cfg["generation"]
+    if gen_cfg.get("use_chat_template"):
+        raise SystemExit("spec 7.2 forbids a chat template in anchor qualification")
+
+    path = os.path.join(cfg["model_root"], entry["path"])
+    facts = list(read_jsonl(args.facts))
+    if args.limit:
+        facts = facts[:args.limit]
+    N = len(facts)
+    print(f"[{args.model}] N={N}  revision={entry.get('revision')}", flush=True)
+
+    torch.manual_seed(gen_cfg.get("seed", 0))
+    tok = AutoTokenizer.from_pretrained(path)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    tok.padding_side = "left"
+    tok.truncation_side = "left"
+    model = AutoModelForCausalLM.from_pretrained(
+        path, dtype=getattr(torch, gen_cfg.get("dtype", "bfloat16")),
+        device_map={"": 0}).eval()
+
+    prompts = [PROMPT.format(q=f["qualification_question"]) for f in facts]
+    golds = [f["object"]["canonical"] for f in facts]
+    gold_ids = [tok(" " + g, add_special_tokens=False).input_ids for g in golds]
+
+    out = [None] * N
+    order = sorted(range(N), key=lambda i: len(prompts[i]))
+    B = gen_cfg.get("batch_size", 96)
+    t0 = time.time()
+
+    with torch.no_grad():
+        for b in range(0, N, B):
+            idx = order[b:b + B]
+            enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True,
+                      truncation=True, max_length=gen_cfg.get("max_prompt_len", 96)).to(0)
+            plen = enc["input_ids"].shape[1]
+            gen = model.generate(**enc,
+                                 max_new_tokens=gen_cfg.get("max_new_tokens", 24),
+                                 do_sample=gen_cfg.get("do_sample", False),
+                                 num_beams=gen_cfg.get("num_beams", 1),
+                                 pad_token_id=tok.pad_token_id)
+            new_ids = gen[:, plen:]
+            texts = tok.batch_decode(new_ids, skip_special_tokens=True)
+            for j, i in enumerate(idx):
+                ids = new_ids[j].tolist()
+                n_tok, fin = len(ids), "length"
+                for k, t in enumerate(ids):
+                    if t == tok.eos_token_id:
+                        n_tok, fin = k, "eos"
+                        break
+                out[i] = {"fact_id": facts[i]["fact_id"], "model": args.model,
+                          "prompt": prompts[i],
+                          "raw_response": texts[j],
+                          "generated_token_ids": ids[:n_tok],
+                          "generated_tokens": int(n_tok),
+                          "finish_reason": fin,
+                          "gold_token_len": len(gold_ids[i])}
+
+            if args.save_logprob:
+                full = [prompts[i] + " " + golds[i] for i in idx]
+                enc2 = tok(full, return_tensors="pt", padding=True, truncation=True,
+                           max_length=gen_cfg.get("max_prompt_len", 96) + 32).to(0)
+                lp = torch.log_softmax(model(**enc2).logits.float(), dim=-1)
+                for j, i in enumerate(idx):
+                    g = gold_ids[i]
+                    if not g:
+                        continue
+                    seq = enc2["input_ids"][j]
+                    end = seq.shape[0]
+                    start = end - len(g)
+                    L = int(enc2["attention_mask"][j].sum().item())
+                    if start - 1 < end - L:
+                        continue
+                    vals = [lp[j, t - 1, seq[t]].item() for t in range(start, end)]
+                    row = lp[j, start - 1]
+                    out[i]["gold_sequence_logprob"] = float(sum(vals) / len(vals))
+                    out[i]["gold_first_token_logprob"] = float(row[g[0]].item())
+                    out[i]["gold_first_token_rank"] = int((row > row[g[0]]).sum().item()) + 1
+                    out[i]["first_token_argmax_correct"] = bool(
+                        int(row.argmax().item()) == g[0])
+
+            if b % (B * 20) == 0:
+                done = b + len(idx)
+                print(f"  {done}/{N}  {done / max(time.time() - t0, 1e-9):.1f}/s",
+                      flush=True)
+
+    dest = out_path("qualification", f"{args.model}.jsonl")
+    with open(dest, "w") as f:
+        for r in out:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    json.dump({"model": args.model, "n": N, "generation": gen_cfg,
+               "model_entry": entry, "seconds": round(time.time() - t0, 1)},
+              open(out_path("qualification", f"{args.model}.meta.json"), "w"),
+              indent=2, ensure_ascii=False)
+    print(f"[{args.model}] wrote {N} -> {dest}  ({time.time() - t0:.0f}s)  GEN_DONE")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/runner/qualification_score.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+"""Stage V scoring -> outputs/qualification/<model>.scored.jsonl + K_m labels.
+
+Spec 7.4: CPU-side, modular, five labels. Spec 7.1 / 16: K_m is a label set and
+must never be used to redefine the benchmark denominator, so this script writes
+a per-fact label table covering ALL 2,592 facts for every model rather than a
+filtered subset.
+
+Also emits outputs/known_labels.json:
+    {fact_id: {model: label}}
+which downstream analysis joins against the query bank.
+"""
+import os, sys, json, glob, argparse, collections
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl, write_jsonl
+from scoring_full import score, needs_manual_review
+
+LABELS = ["correct", "incorrect", "ambiguous", "abstain", "unparseable"]
+
+
+def bootstrap_ci(values, groups, n_boot=2000, seed=0, alpha=0.05):
+    """Cluster bootstrap over RELATIONS: the relation mix is heavily skewed
+    (manufacturer + developer + native_language are a third of the benchmark),
+    so treating facts as independent would understate the interval."""
+    rng = np.random.default_rng(seed)
+    by = collections.defaultdict(list)
+    for v, g in zip(values, groups):
+        by[g].append(v)
+    keys = list(by)
+    if not keys:
+        return (float("nan"), float("nan"))
+    arrs = [np.asarray(by[k], dtype=float) for k in keys]
+    stats = np.empty(n_boot)
+    for b in range(n_boot):
+        pick = rng.integers(0, len(keys), len(keys))
+        stats[b] = np.concatenate([arrs[i] for i in pick]).mean()
+    return float(np.quantile(stats, alpha / 2)), float(np.quantile(stats, 1 - alpha / 2))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--models", nargs="*", default=None)
+    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
+    args = ap.parse_args()
+
+    facts = {f["fact_id"]: f for f in read_jsonl(args.facts)}
+    qdir = os.path.join(out_path("qualification", "x")[:-1])
+    paths = sorted(p for p in glob.glob(os.path.join(qdir, "*.jsonl"))
+                   if not p.endswith(".scored.jsonl"))
+    if args.models:
+        paths = [p for p in paths
+                 if os.path.basename(p)[:-len(".jsonl")] in args.models]
+    if not paths:
+        raise SystemExit(f"no generation files in {qdir}; run qualification_run.py first")
+
+    known = collections.defaultdict(dict)
+    summary = {}
+    for p in paths:
+        model = os.path.basename(p)[:-len(".jsonl")]
+        rows, counts = [], collections.Counter()
+        by_rel = collections.defaultdict(collections.Counter)
+        by_flag = collections.defaultdict(collections.Counter)
+        for g in read_jsonl(p):
+            f = facts.get(g["fact_id"])
+            if f is None:
+                raise SystemExit(f"{model}: generation for unknown fact {g['fact_id']}")
+            r = score(g["raw_response"], f["object"]["aliases"],
+                      answer_type=f["answer_type"],
+                      granularity=f["answer_granularity"])
+            rec = {"fact_id": g["fact_id"], "model": model,
+                   "prompt": g["prompt"], "raw_response": g["raw_response"],
+                   "extracted_answer": r["span"], "label": r["label"],
+                   "matched_alias": r["matched_alias"], "scorer": r["scorer"],
+                   "flags": r["flags"],
+                   "relation": f["relation"]["relation_id"],
+                   "answer_type": f["answer_type"],
+                   "answer_in_subject_surface": bool(f.get("answer_in_subject_surface")),
+                   "spec_6_2_flag": f.get("spec_6_2_flag"),
+                   "manual_review": needs_manual_review(r)}
+            for k in ("gold_sequence_logprob", "gold_first_token_rank",
+                      "first_token_argmax_correct"):
+                if k in g:
+                    rec[k] = g[k]
+            rows.append(rec)
+            counts[r["label"]] += 1
+            by_rel[f["relation"]["relation_id"]][r["label"]] += 1
+            by_flag[bool(f.get("answer_in_subject_surface"))][r["label"]] += 1
+            known[g["fact_id"]][model] = r["label"]
+
+        write_jsonl(os.path.join(qdir, f"{model}.scored.jsonl"), rows)
+
+        n = len(rows)
+        vals = [1.0 if r["label"] == "correct" else 0.0 for r in rows]
+        rels = [r["relation"] for r in rows]
+        lo, hi = bootstrap_ci(vals, rels)
+        rel_macro = collections.defaultdict(list)
+        for v, rl in zip(vals, rels):
+            rel_macro[rl].append(v)
+        summary[model] = {
+            "n_facts": n,
+            "labels": {k: counts[k] for k in LABELS},
+            "label_rates": {k: round(counts[k] / n, 4) for k in LABELS},
+            "K_m": counts["correct"],
+            "anchor_accuracy_micro": round(counts["correct"] / n, 4),
+            "anchor_accuracy_relation_macro":
+                round(float(np.mean([np.mean(v) for v in rel_macro.values()])), 4),
+            "ci95_relation_clustered": [round(lo, 4), round(hi, 4)],
+            # the copy-shortcut split from reconstruction_differences.md F1
+            "accuracy_answer_in_subject":
+                round(by_flag[True]["correct"] / max(sum(by_flag[True].values()), 1), 4),
+            "accuracy_answer_not_in_subject":
+                round(by_flag[False]["correct"] / max(sum(by_flag[False].values()), 1), 4),
+            "n_manual_review": sum(1 for r in rows if r["manual_review"]),
+            "by_relation": {k: {"n": sum(v.values()), "correct": v["correct"]}
+                            for k, v in sorted(by_rel.items())},
+        }
+
+    # spec 7.1: labels for every fact x model, benchmark denominator untouched
+    json.dump({"n_facts": len(facts), "models": sorted(summary),
+               "note": "K_m is a label set; the benchmark denominator stays 2,592 "
+                       "for every model (spec 2.1 / 7.1)",
+               "labels": known},
+              open(out_path("known_labels.json"), "w"), ensure_ascii=False)
+    json.dump(summary, open(out_path("qualification_summary.json"), "w"),
+              indent=2, ensure_ascii=False)
+
+    print(f"{'model':22s} {'K_m':>6s} {'micro':>7s} {'macro':>7s} "
+          f"{'CI95':>16s} {'abst':>6s} {'ambig':>6s} {'copy':>6s} {'real':>6s}")
+    print("-" * 92)
+    for m, s in summary.items():
+        ci = s["ci95_relation_clustered"]
+        print(f"{m[:21]:22s} {s['K_m']:6d} {s['anchor_accuracy_micro']:7.3f} "
+              f"{s['anchor_accuracy_relation_macro']:7.3f} "
+              f"[{ci[0]:.3f},{ci[1]:.3f}] {s['label_rates']['abstain']:6.3f} "
+              f"{s['label_rates']['ambiguous']:6.3f} "
+              f"{s['accuracy_answer_in_subject']:6.3f} "
+              f"{s['accuracy_answer_not_in_subject']:6.3f}")
+    print("\ncopy = facts whose answer is inside the subject name; "
+          "real = the rest (see reconstruction_differences.md F1)")
+
+
+if __name__ == "__main__":
+    main()

ICLR dataset/runner/scoring_full.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+"""Answer-span extraction and full-answer scoring (spec section 7.4).
+
+Five labels, unlike the three-way scheme it replaces:
+    correct       an accepted alias is asserted
+    incorrect     a different answer is asserted
+    ambiguous     several incompatible answers, hedging, or a granularity miss
+    abstain       the model declines or says it does not know
+    unparseable   nothing answer-shaped survives extraction
+
+Scoring is a pure function of the stored generation, so rules can be revised
+and everything re-scored without touching the GPU.
+"""
+import re
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import normalize
+
+MAX_SPAN_TOKENS = 10
+STRICT_SPAN_TOKENS = 6
+
+# Containment only fires for aliases at least this long. Crowd-sourced Wikidata
+# alias lists include ISO codes that are ordinary English words -- "can" is an
+# alias of Canada, "ja" of Japanese -- and without a floor a generation like
+# "It can be Germany" would contain " can " and score as a correct Canada
+# answer. Short aliases still count, but only through exact match.
+MIN_CONTAINMENT_ALIAS_CHARS = 4
+ALIAS_STOPWORDS = {"can", "may", "will", "was", "are", "one", "two", "new",
+                   "the", "and", "for", "his", "her", "its", "not", "all"}
+
+_LEADIN = re.compile(
+    r"^(?:the\s+answer\s+is|answer\s*:|it\s+is|it\s+was|it's|that\s+would\s+be|"
+    r"that\s+is|this\s+is|he\s+is|she\s+is|they\s+are|he\s+was|she\s+was|"
+    r"they\s+were)\b[\s:,-]*", re.I)
+_NEGATION = re.compile(r"\b(not|no|never|isn't|wasn't|aren't|weren't|doesn't|"
+                       r"didn't|don't|cannot|can't)\b", re.I)
+_HEDGE = re.compile(r"\b(but|however|although|though|actually|maybe|perhaps|"
+                    r"probably|possibly|might|unclear|some\s+sources|depends|"
+                    r"either)\b", re.I)
+_ABSTAIN = re.compile(
+    r"\b(i\s+(?:do\s+not|don't)\s+know|i'm\s+not\s+sure|i\s+am\s+not\s+sure|"
+    r"unknown|not\s+sure|no\s+idea|cannot\s+answer|can't\s+answer|"
+    r"unable\s+to\s+(?:answer|determine)|insufficient\s+information|"
+    r"as\s+an\s+ai)\b", re.I)
+_SENT_END = re.compile(r"[.!?\n]")
+_LIST_SEP = re.compile(r"\s*(?:,|;|\bor\b|\band\b|/|\|)\s*", re.I)
+_YEAR = re.compile(r"\b(1[0-9]{3}|20[0-9]{2})\b")
+
+
+def _tokens(t):
+    return [w for w in re.split(r"[^\w]+", t) if w]
+
+
+def extract_span(raw):
+    """First answer-bearing clause. Returns (span, flags)."""
+    flags = set()
+    if raw is None:
+        return "", {"empty"}
+    text = raw.strip()
+    if not text:
+        return "", {"empty"}
+    lines = [l for l in text.split("\n") if l.strip()]
+    if not lines:
+        return "", {"empty"}
+    if len(lines) > 1:
+        flags.add("multi_clause")
+    first = lines[0].strip()
+    m = _SENT_END.search(first)
+    if m and first[m.start():].strip(" .!?"):
+        flags.add("multi_clause")
+    first = first[:m.start()] if m else first
+
+    if _ABSTAIN.search(first):
+        flags.add("abstain")
+    if _NEGATION.search(first):
+        flags.add("negation")
+    if _HEDGE.search(first):
+        flags.add("hedge")
+
+    span = _LEADIN.sub("", first).strip()
+    if len(_tokens(span)) > MAX_SPAN_TOKENS:
+        flags.add("truncated")
+        span = " ".join(span.split()[:MAX_SPAN_TOKENS])
+    if not span:
+        flags.add("empty")
+    return span, flags
+
+
+def split_candidates(span):
+    parts = [p.strip() for p in _LIST_SEP.split(span) if p.strip()]
+    return parts or ([span] if span else [])
+
+
+def _match_year(span, golds, gran):
+    got = set(_YEAR.findall(span))
+    want = set()
+    for g in golds:
+        want.update(_YEAR.findall(str(g)))
+    if not got or not want:
+        return None
+    if len(got) > 1:
+        return ("ambiguous", None, "year_multiple")
+    y = got.pop()
+    if y not in want:
+        return ("incorrect", None, "year_mismatch")
+    if gran == "date" and not re.search(r"\b\d{1,2}\b", span.replace(y, "")):
+        return ("ambiguous", y, "year_granularity_short")
+    return ("correct", y, "year_parser")
+
+
+def score(raw_generation, gold_aliases, answer_type="entity", granularity=None):
+    """Label one generation. Returns dict(label, matched_alias, scorer, span, flags)."""
+    span, flags = extract_span(raw_generation)
+    out = {"span": span, "flags": sorted(flags)}
+
+    if "abstain" in flags:
+        return {**out, "label": "abstain", "matched_alias": None, "scorer": "abstain"}
+    if "empty" in flags:
+        return {**out, "label": "unparseable", "matched_alias": None, "scorer": "empty_span"}
+    if "negation" in flags:
+        return {**out, "label": "ambiguous", "matched_alias": None, "scorer": "negation"}
+
+    n_span = normalize(span)
+    if not n_span:
+        return {**out, "label": "unparseable", "matched_alias": None,
+                "scorer": "span_normalizes_to_empty"}
+
+    norm_golds = {}
+    for a in gold_aliases:
+        na = normalize(a)
+        if na:
+            norm_golds.setdefault(na, a)
+
+    if n_span in norm_golds:
+        return {**out, "label": "correct", "matched_alias": norm_golds[n_span],
+                "scorer": "exact_alias_after_normalization"}
+
+    if answer_type in ("year", "date"):
+        r = _match_year(span, gold_aliases, granularity or answer_type)
+        if r:
+            lbl, matched, scorer = r
+            return {**out, "label": lbl, "matched_alias": matched, "scorer": scorer}
+
+    cands = split_candidates(span)
+    if len(cands) > 1:
+        hits = [normalize(c) for c in cands if normalize(c) in norm_golds]
+        distinct = set(hits)
+        if len(distinct) == 1 and len(cands) == len(hits):
+            h = distinct.pop()
+            return {**out, "label": "correct", "matched_alias": norm_golds[h],
+                    "scorer": "alias_list_all_accepted"}
+        if hits:
+            return {**out, "label": "ambiguous", "matched_alias": norm_golds[hits[0]],
+                    "scorer": "conflicting_candidates"}
+
+    if "hedge" not in flags and len(_tokens(n_span)) <= STRICT_SPAN_TOKENS:
+        padded = f" {n_span} "
+        for na, orig in norm_golds.items():
+            if len(na) < MIN_CONTAINMENT_ALIAS_CHARS or na in ALIAS_STOPWORDS:
+                continue
+            if f" {na} " in padded:
+                return {**out, "label": "correct", "matched_alias": orig,
+                        "scorer": "alias_substring_short_span"}
+
+    if flags & {"hedge", "truncated", "multi_clause"}:
+        for na, orig in norm_golds.items():
+            if len(na) < MIN_CONTAINMENT_ALIAS_CHARS or na in ALIAS_STOPWORDS:
+                continue
+            if f" {na} " in f" {n_span} ":
+                return {**out, "label": "ambiguous", "matched_alias": orig,
+                        "scorer": "gold_inside_unresolvable_prose"}
+
+    return {**out, "label": "incorrect", "matched_alias": None, "scorer": "no_match"}
+
+
+def needs_manual_review(result):
+    return result["label"] in ("ambiguous", "unparseable") or \
+        result["scorer"] in ("alias_substring_short_span", "year_granularity_short")

ICLR dataset/runner/select_benchmark.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python
+"""Stage III -> outputs/benchmark_facts_2592.jsonl  (spec section 6)
+
+Two filters, both driven by configs/relations.yaml:
+  6.1  core sources only: CounterFact, LAMA-TREx, PopQA          -> 3,705
+  6.2  functional (single-valued) relations only                 -> 2,592
+
+Spec 6.2 additionally NAMES `developer of` and `manufacturer of` as unsuitable,
+yet the required benchmark size of 2,592 across 21 relations can only be reached
+with them included. That contradiction is inside the specification itself, so
+the default keeps them, tags them with `spec_6_2_flag`, and records the conflict
+in outputs/reconstruction_differences.md. Set
+`options.drop_spec_6_2_flagged: true` in relations.yaml to exclude them; the
+script then reports the resulting size instead of failing.
+"""
+import os, sys, json, argparse, collections
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl, write_jsonl, Expect
+
+EXPECTED_CORE = 3705
+EXPECTED_BENCHMARK = 2592
+EXPECTED_RELATIONS = 21
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--enriched", default=out_path("enriched_facts_6180.jsonl"))
+    args = ap.parse_args()
+
+    cfg = load_config("relations.yaml")
+    opts = cfg.get("options", {})
+    drop_flagged = bool(opts.get("drop_spec_6_2_flagged", False))
+    exp = Expect()
+
+    facts = list(read_jsonl(args.enriched))
+    exp.check("enriched_input", len(facts), 6180)
+
+    core = [f for f in facts if f["is_core_source"]]
+    exp.check("core_source_facts", len(core), EXPECTED_CORE)
+
+    bench, dropped = [], collections.Counter()
+    for f in core:
+        if not f["is_benchmark_relation"]:
+            dropped["not_a_benchmark_relation"] += 1
+            continue
+        if not f["is_functional"]:
+            dropped["non_functional_relation"] += 1
+            continue
+        if drop_flagged and f.get("spec_6_2_flag"):
+            dropped["spec_6_2_flagged"] += 1
+            continue
+        bench.append(f)
+
+    rel_counts = collections.Counter(f["relation"]["relation_id"] for f in bench)
+    exp.check("benchmark_facts", len(bench),
+              None if drop_flagged else EXPECTED_BENCHMARK,
+              note="drop_spec_6_2_flagged=true" if drop_flagged else "")
+    exp.check("benchmark_relations", len(rel_counts),
+              None if drop_flagged else EXPECTED_RELATIONS)
+
+    flagged = sum(1 for f in bench if f.get("spec_6_2_flag"))
+
+    path = out_path("benchmark_facts_2592.jsonl")
+    write_jsonl(path, bench)
+
+    exp.report("Stage III counts")
+    meta = {
+        "stage": "III_benchmark_selection",
+        "n_enriched": len(facts),
+        "n_core_source": len(core),
+        "n_benchmark": len(bench),
+        "n_relations": len(rel_counts),
+        "per_relation": dict(rel_counts.most_common()),
+        "per_source": dict(collections.Counter(f["sources"][0] for f in bench)),
+        "per_answer_type": dict(collections.Counter(f["answer_type"] for f in bench)),
+        "dropped": dict(dropped),
+        "spec_6_2_flagged_kept": flagged,
+        "drop_spec_6_2_flagged": drop_flagged,
+        "inverse_well_posed_facts": sum(1 for f in bench if f["is_inverse_well_posed"]),
+        "checks": exp.rows,
+    }
+    json.dump(meta, open(out_path("stage3_report.json"), "w"),
+              indent=2, ensure_ascii=False)
+
+    print(f"\nwrote {len(bench)} benchmark facts -> {path}")
+    print(f"  relations: {len(rel_counts)}")
+    print(f"  dropped:   {dict(dropped)}")
+    if flagged:
+        print(f"  NOTE: {flagged} facts come from relations spec 6.2 calls "
+              f"unsuitable (manufacturer/developer); required to reach 2,592. "
+              f"See outputs/reconstruction_differences.md")
+    return 1 if exp.deviations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ICLR dataset/runner/test_scoring.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+"""Unit tests for scoring_full.py. Run before trusting any K_m."""
+import os, sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from scoring_full import score
+
+CANBERRA = ["Canberra", "Canberra, ACT"]
+DUTCH = ["Dutch", "Nederlands", "dutch language"]
+YEAR = ["1987"]
+# "can" is a real Wikidata alias of Canada, carried by 67 facts in this pool
+CANADA = ["Canada", "can", "CAN", "Dominion of Canada"]
+
+CASES = [
+    (" Canberra",               CANBERRA, "city", None, "correct", "bare answer"),
+    (" Canberra.",              CANBERRA, "city", None, "correct", "trailing period"),
+    ("The answer is Canberra.", CANBERRA, "city", None, "correct", "lead-in"),
+    ("  canberra  ",            CANBERRA, "city", None, "correct", "case/space"),
+    ("Canberra, ACT",           CANBERRA, "city", None, "correct", "alias with comma"),
+    ("Sydney",                  CANBERRA, "city", None, "incorrect", "wrong entity"),
+    ("It is not Canberra.",     CANBERRA, "city", None, "ambiguous", "negation"),
+    ("Canberra or Sydney",      CANBERRA, "city", None, "ambiguous", "conflicting list"),
+    ("Some sources say Canberra, but the answer is Melbourne.",
+                                CANBERRA, "city", None, "ambiguous", "self-correction"),
+    ("",                        CANBERRA, "city", None, "unparseable", "empty"),
+    ("\n\n",                    CANBERRA, "city", None, "unparseable", "whitespace only"),
+    ("...",                     CANBERRA, "city", None, "unparseable", "punctuation only"),
+
+    ("I don't know.",           CANBERRA, "city", None, "abstain", "explicit refusal"),
+    ("I'm not sure, maybe Sydney.", CANBERRA, "city", None, "abstain", "hedged refusal"),
+    ("Unknown",                 CANBERRA, "city", None, "abstain", "unknown"),
+
+    (" Dutch",                  DUTCH, "language", None, "correct", "primary alias"),
+    (" Nederlands",             DUTCH, "language", None, "correct", "non-primary alias"),
+    ("The Dutch language",      DUTCH, "language", None, "correct", "article + alias"),
+    ("German",                  DUTCH, "language", None, "incorrect", "wrong language"),
+    ("Amsterdam, which is in the Netherlands, where people speak Dutch and",
+                                DUTCH, "language", None, "ambiguous",
+                                "gold buried in prose is NOT a silent correct"),
+
+    ("1987",                    YEAR, "year", "year", "correct", "exact year"),
+    ("He was born in 1987",     YEAR, "year", "year", "correct", "year in short prose"),
+    ("12 March 1987",           YEAR, "year", "year", "correct", "full date, year gold"),
+    ("1988",                    YEAR, "year", "year", "incorrect", "wrong year"),
+    ("1987 or 1988",            YEAR, "year", "year", "ambiguous", "two years"),
+    ("1987",       ["12 March 1987"], "date", "date", "ambiguous", "gold wants full date"),
+    ("12 March 1987", ["12 March 1987"], "date", "date", "correct", "full date matches"),
+
+    ("It can be Germany",       CANADA, "country", None, "incorrect",
+     "stopword alias must not match by containment"),
+    ("Canada",                  CANADA, "country", None, "correct", "primary alias"),
+    ("CAN",                     CANADA, "country", None, "correct", "short alias, EXACT only"),
+    ("the Dominion of Canada is", CANADA, "country", None, "correct",
+     "long alias still matches by containment"),
+]
+
+
+def main():
+    bad = 0
+    for gen, al, at, gran, want, note in CASES:
+        got = score(gen, al, answer_type=at, granularity=gran)
+        ok = got["label"] == want
+        bad += 0 if ok else 1
+        print(f"{'ok ' if ok else 'FAIL'} {want:12s} got={got['label']:12s} "
+              f"{got['scorer']:34s} {note}")
+    print(f"\n{len(CASES) - bad}/{len(CASES)} passed")
+    return 1 if bad else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ICLR dataset/runner/validate_facts.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python
+"""Fact- and query-level validation -> outputs/validation_report.json
+
+Spec 6.3 lists the fact-level gates, spec 13 the query-level ones, spec 14.2 the
+report shape. Exits non-zero on any hard error so a broken build can never reach
+a GPU run.
+"""
+import os, re, sys, json, glob, argparse, collections
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from common import load_config, out_path, read_jsonl, normalize
+
+EVAL_LEGACY = "/scratch/rds-fei-rsfm-rw/cshi0459/ICLR27/eval_dataset"
+
+
+def load_perturbation_prompts():
+    """Normalized text of every evaluation perturbation prompt, for the spec 16
+    check that a qualification template is never reused as an eval template."""
+    out = set()
+    for p in glob.glob(f"{EVAL_LEGACY}/query*.jsonl"):
+        for d in read_jsonl(p):
+            out.add(normalize(d.get("prompt", "")))
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--facts", default=out_path("benchmark_facts_2592.jsonl"))
+    ap.add_argument("--queries", default=out_path("evaluation_queries_44418.jsonl"))
+    ap.add_argument("--skip_leakage", action="store_true")
+    args = ap.parse_args()
+
+    cond_cfg = load_config("eval_conditions.yaml")
+    errors = collections.Counter()
+    warnings = collections.Counter()
+    examples = collections.defaultdict(list)
+
+    def err(tag, ref, detail=""):
+        errors[tag] += 1
+        if len(examples[tag]) < 5:
+            examples[tag].append(f"{ref} {detail}".strip())
+
+    def warn(tag, ref, detail=""):
+        warnings[tag] += 1
+        if len(examples[tag]) < 5:
+            examples[tag].append(f"{ref} {detail}".strip())
+
+    # =================================================== fact level (spec 6.3)
+    facts = list(read_jsonl(args.facts))
+    seen_ids, seen_norm = set(), collections.Counter()
+    for f in facts:
+        fid = f.get("fact_id")
+        s, r, o = f.get("subject", {}), f.get("relation", {}), f.get("object", {})
+        if not fid:
+            err("missing_fact_id", "?")
+        elif fid in seen_ids:
+            err("duplicate_fact_id", fid)
+        seen_ids.add(fid)
+
+        if not (s.get("canonical") or "").strip():
+            err("empty_subject", fid)
+        if not (r.get("relation_id") or "").strip():
+            err("empty_relation", fid)
+        if not (o.get("canonical") or "").strip():
+            err("empty_object", fid)
+
+        q = f.get("qualification_question") or ""
+        if not q.strip():
+            err("empty_qualification_question", fid)
+        elif normalize(s.get("canonical", "")) and \
+                normalize(s["canonical"]) not in normalize(q):
+            warn("subject_not_in_question", fid, q)
+
+        al = o.get("aliases") or []
+        if not al:
+            err("no_object_alias", fid)
+        elif normalize(o["canonical"]) not in {normalize(a) for a in al}:
+            err("canonical_object_not_in_aliases", fid, o.get("canonical", ""))
+
+        if not f.get("answer_type"):
+            err("missing_answer_type", fid)
+        if not f.get("answer_granularity"):
+            err("missing_answer_granularity", fid)
+        if not f.get("sources"):
+            err("missing_source_metadata", fid)
+        if not f.get("is_functional"):
+            err("main_relation_not_functional", fid, r.get("relation_id", ""))
+        if len(o.get("variant_surface_forms") or []) > 1 and f["is_functional"]:
+            # survived 5.2 only if all variants share one entity id
+            if not o.get("entity_id"):
+                err("unresolved_functional_conflict", fid)
+        if not (s.get("aliases") or []):
+            warn("no_subject_alias", fid)
+        seen_norm[(normalize(s.get("canonical", "")),
+                   r.get("relation_id"),
+                   normalize(o.get("canonical", "")))] += 1
+
+    dup_norm = {k: v for k, v in seen_norm.items() if v > 1}
+    if dup_norm:
+        errors["duplicate_normalized_fact"] = len(dup_norm)
+        examples["duplicate_normalized_fact"] = [str(k) for k in list(dup_norm)[:5]]
+
+    # spec 16: qualification template must not be an evaluation template
+    if not args.skip_leakage and os.path.isdir(EVAL_LEGACY):
+        pert = load_perturbation_prompts()
+        for f in facts:
+            if normalize(f["qualification_question"]) in pert:
+                err("qualification_question_reused_as_eval_template",
+                    f["fact_id"], f["qualification_question"])
+
+    # ================================================== query level (spec 13)
+    facts_by_id = {f["fact_id"]: f for f in facts}
+    queries = []
+    if os.path.exists(args.queries):
+        queries = list(read_jsonl(args.queries))
+        fact_ids = seen_ids
+        seen_q = set()
+        main_families = {c for c, v in cond_cfg["conditions"].items()
+                         if v["use_for_main_forward"]}
+        for q in queries:
+            qid = q.get("query_id")
+            if not qid:
+                err("missing_query_id", "?")
+            elif qid in seen_q:
+                err("duplicate_query_id", qid)
+            seen_q.add(qid)
+
+            if q.get("fact_id") not in fact_ids:
+                err("query_references_unknown_fact", qid, str(q.get("fact_id")))
+            if not (q.get("gold_aliases") or []):
+                err("missing_gold_aliases", qid)
+            if not q.get("query", "").strip():
+                err("empty_query_text", qid)
+
+            fam = q.get("condition_family")
+            spec_c = cond_cfg["conditions"].get(fam)
+            if spec_c is None:
+                err("unknown_condition_family", qid, str(fam))
+                continue
+            # booleans must agree with the registry, otherwise an aggregation
+            # that trusts the row would silently mix families
+            for flag in ("use_for_main_forward", "use_for_reverse_analysis",
+                         "use_for_recognition_analysis", "is_assisted"):
+                if bool(q.get(flag)) != bool(spec_c[flag]):
+                    err(f"flag_mismatch_{flag}", qid, fam)
+            if q.get("target_slot") != spec_c["target_slot"]:
+                err("target_slot_mismatch", qid, fam)
+
+            # spec 2.3 / 16 hard prohibitions
+            if fam == "recognition" and q.get("use_for_main_forward"):
+                err("recognition_in_main_forward", qid)
+            if fam == "reverse_illposed" and q.get("use_for_main_forward"):
+                err("reverse_illposed_in_main_forward", qid)
+            if fam in main_families and q.get("target_slot") != "object":
+                err("invalid_main_target_slot", qid, str(q.get("target_slot")))
+            # spec 13.9: an open-ended main query must not expose the answer.
+            # A gold string that is part of the SUBJECT name ("Airbus A318" ->
+            # "Airbus") is inherent to the fact, not leakage introduced by the
+            # template, so it is a warning carrying the count rather than a hard
+            # error. Only an occurrence that survives removing every subject
+            # mention is a genuine template leak.
+            if fam in main_families and not q.get("is_assisted"):
+                nq = normalize(q["query"])
+                gold = normalize(q.get("gold_canonical", ""))
+                if gold and gold in nq:
+                    subj = normalize(
+                        facts_by_id[q["fact_id"]]["subject"]["canonical"]
+                    ) if q["fact_id"] in facts_by_id else ""
+                    residual = nq.replace(subj, " ") if subj else nq
+                    if gold in residual:
+                        err("gold_exposed_by_template", qid, q["query"][:70])
+                    else:
+                        warn("gold_inside_subject_name", qid, q["query"][:70])
+
+    # ============================================================== report
+    report = {
+        "hard_errors": int(sum(errors.values())),
+        "warnings": [{"type": k, "count": v, "examples": examples[k][:3]}
+                     for k, v in warnings.most_common()],
+        "errors": [{"type": k, "count": v, "examples": examples[k][:3]}
+                   for k, v in errors.most_common()],
+        "fact_count": len(facts),
+        "query_count": len(queries),
+        "relation_count": len({f["relation"]["relation_id"] for f in facts}),
+        "duplicate_fact_ids": int(errors.get("duplicate_fact_id", 0)),
+        "duplicate_query_ids": int(errors.get("duplicate_query_id", 0)),
+        "missing_gold_aliases": int(errors.get("missing_gold_aliases", 0)),
+        "invalid_main_target_slots": int(errors.get("invalid_main_target_slot", 0)),
+        "recognition_in_main_forward": int(errors.get("recognition_in_main_forward", 0)),
+        "reverse_illposed_in_main_forward":
+            int(errors.get("reverse_illposed_in_main_forward", 0)),
+    }
+    json.dump(report, open(out_path("validation_report.json"), "w"),
+              indent=2, ensure_ascii=False)
+
+    print(f"facts={len(facts)}  queries={len(queries)}  "
+          f"relations={report['relation_count']}")
+    print(f"\nHARD ERRORS: {report['hard_errors']}")
+    for k, v in errors.most_common():
+        print(f"  {k:46s} {v:6d}  e.g. {examples[k][:1]}")
+    print(f"\nWARNINGS: {sum(warnings.values())}")
+    for k, v in warnings.most_common():
+        print(f"  {k:46s} {v:6d}  e.g. {examples[k][:1]}")
+    return 1 if report["hard_errors"] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())