Upload 30 files

.gitattributes

@@ -59,3 +59,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.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
+dataset_upload/data/evaluation_queries_44416.jsonl filter=lfs diff=lfs merge=lfs -text

dataset_upload/.gitattributes

@@ -0,0 +1 @@
+*.jsonl filter=lfs diff=lfs merge=lfs -text

dataset_upload/.gitignore

@@ -0,0 +1,4 @@
+outputs/
+work/
+__pycache__/
+*.pyc

dataset_upload/LICENSE

@@ -0,0 +1,38 @@
+Fact Knowledge Stability Benchmark
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+You are free to share and adapt this material for any purpose, including
+commercially, provided you give appropriate credit, link to the licence, and
+indicate if changes were made.
+
+Full text: https://creativecommons.org/licenses/by/4.0/legalcode
+
+
+UPSTREAM SOURCES AND THEIR TERMS
+--------------------------------
+
+The facts in this benchmark are derived from the datasets below. Their terms
+continue to apply to the derived material; CC BY 4.0 was chosen because it is
+compatible with all of them. Please cite the original datasets alongside this
+one.
+
+  CounterFact              MIT License
+    Meng et al., "Locating and Editing Factual Associations in GPT" (2022)
+
+  LAMA / T-REx             CC BY 4.0
+    Petroni et al., "Language Models as Knowledge Bases?" (2019)
+    ElSahar et al., "T-REx: A Large Scale Alignment of Natural Language with
+    Knowledge Base Triples" (2018)
+
+  LAMA / Google-RE         CC BY 4.0 (per the LAMA distribution)
+  LAMA / ConceptNet        CC BY-SA 4.0 (ConceptNet 5)
+
+  PopQA                    MIT License
+    Mallen et al., "When Not to Trust Language Models" (2023)
+
+  Wikidata                 CC0 1.0 (entity identifiers and aliases)
+
+The T-REx and Wikidata5M subsets present in the candidate pool were dropped
+before benchmark selection and are not represented in the distributed files.
+
+The code under runner/ and metrics/ is released under the MIT License.

dataset_upload/OUTPUT_SCHEMA.md

@@ -0,0 +1,110 @@
+# Output schema
+
+What your model must emit for the shipped scorer and metrics to accept it. If
+you use `runner/eval_run.py` you get this for free; this document exists so you
+can plug in your own inference stack (vLLM, an API, a custom harness) instead.
+
+## Generations — `outputs/evaluation/<model>.jsonl`
+
+One JSON object per line, **44,416 lines**, one per `query_id`.
+
+```json
+{
+  "query_id": "query_00000001",
+  "fact_id": "fact_000602",
+  "condition_family": "anchor",
+  "model": "my-model",
+  "prompt": "Question: Which jurisdiction does Agriculture and Agri-Food Canada have legal force in?\nAnswer with only the shortest correct answer.\nAnswer:",
+  "raw_response": " Canada\nExplanation: Agriculture and Agri-Food Canada (AAFC) is a federal department of the Government of Canada",
+  "generated_tokens": 24,
+  "finish_reason": "length"
+}
+```
+
+| field | required | notes |
+|---|---|---|
+| `query_id` | **yes** | the join key; must match the query bank exactly |
+| `raw_response` | **yes** | continuation only, *not* including the prompt. Do not strip, lowercase, or truncate it — the scorer needs the raw span, and `finish_reason: "length"` mid-sentence output is normal and handled |
+| `fact_id`, `condition_family` | recommended | `judge_run.py` groups by these; it can recover them from the query bank but the files are easier to audit with them present |
+| `model` | recommended | copied onto scored rows |
+| `prompt` | recommended | keeps each file self-documenting about the template used — the cheapest way for a reader to catch a protocol mismatch |
+| `generated_tokens`, `finish_reason` | optional | diagnostics |
+
+Order does not matter; the scorer joins on `query_id`. Extra fields are ignored.
+
+### Prompt construction
+
+Reproduce `runner/eval_run.py:build_prompt` exactly:
+
+```python
+PROMPT = "Question: {q}\nAnswer with only the shortest correct answer.\nAnswer:"
+
+def build_prompt(row):
+    if row["condition_family"] == "anchor":
+        return PROMPT.format(q=row["query"])
+    return f"{row['query']}\nAnswer:"
+```
+
+Anchor is the canonical question and gets the instruction wrapper. Every other
+family already carries its own surface form — that *is* the perturbation — so
+wrapping it would erase the manipulation; it gets only a bare `Answer:` cue.
+
+**No chat template, for base and instruct models alike.** See the README.
+
+### Decoding
+
+Greedy, `num_beams=1`, `temperature=0.0`, `max_new_tokens=24`,
+`max_prompt_len=192` (left truncation, left padding), `dtype=bfloat16`,
+`seed=20260101`. From `configs/models.yaml:generation`.
+
+## Scored output — `<model>.scored.jsonl`
+
+Produced by `runner/scoring_full.py`. One line per generation:
+
+```json
+{
+  "query_id": "query_00000001",
+  "model": "my-model",
+  "fact_id": "fact_000602",
+  "relation": "applies_to_jurisdiction",
+  "condition_family": "anchor",
+  "language": "en",
+  "target_slot": "object",
+  "answer_type": "place",
+  "answer_granularity": "entity",
+  "answer_in_subject_surface": true,
+  "use_for_main_forward": true,
+  "use_for_reverse_analysis": false,
+  "use_for_recognition_analysis": false,
+  "raw_response": " Canada\nExplanation: ...",
+  "span": "Canada",
+  "flags": [],
+  "label": "correct",
+  "matched_alias": "Canada",
+  "scorer": "exact_alias",
+  "needs_manual_review": false
+}
+```
+
+`label` is one of `correct` / `incorrect` / `ambiguous` / `abstain` /
+`unparseable`. `scorer` names the rule that fired, which is what you inspect
+when a label looks wrong. The per-query booleans are carried through so metric
+code can filter without rejoining the query bank.
+
+## Hidden states — `outputs/hidden/<model>/`
+
+Only needed for ISS and KTS. Produced by `metrics/extract_hidden.py`.
+
+```
+L018.npy … L045.npy    float16 [n_main_forward_queries, d_model]
+index.json             query order, layer list, checksums, `complete` flag
+```
+
+Rows are in the order given by `index.json`, aligned with the 39,260 queries
+carrying `use_for_main_forward`. Layers stored are `{l : l/(L−1) ≥ 0.4}`, where
+`l` indexes decoder blocks and the stored state is the **output** of block `l`
+(`hidden_states[l+1]` in HuggingFace terms).
+
+The probe position is the **last valid input token** — the model has read the
+question but has not emitted an answer token. With left padding this is
+position `-1` for every row in a batch.

dataset_upload/README.md

@@ -0,0 +1,297 @@
+---
+license: cc-by-4.0
+task_categories:
+  - question-answering
+  - text-generation
+language:
+  - en
+  - zh
+  - fr
+  - es
+  - de
+  - ru
+size_categories:
+  - 10K<n<100K
+pretty_name: Fact Knowledge Stability Benchmark
+tags:
+  - factual-knowledge
+  - robustness
+  - consistency
+  - interpretability
+  - multilingual
+configs:
+  - config_name: queries
+    default: true
+    data_files: data/evaluation_queries_44416.jsonl
+  - config_name: facts
+    data_files: data/benchmark_facts_2592.jsonl
+---
+
+# Fact Knowledge Stability Benchmark
+
+**2,592 facts × 44,416 queries.** Does a model that knows a fact still know it
+when you rephrase the question, change the answer format, add distracting
+context, or ask in another language?
+
+The benchmark pairs **behavioural** stability (what the model *says* across
+perturbations) with **internal** stability (what its residual stream *does*
+across the same perturbations), so the two can be compared on identical inputs.
+
+```python
+from datasets import load_dataset
+
+queries = load_dataset("LucasLoading/stable", "queries", split="train")
+facts   = load_dataset("LucasLoading/stable", "facts",   split="train")
+```
+
+---
+
+## Read this before you report a number
+
+Four properties of this benchmark will silently distort results if you do not
+account for them. They are design decisions, not defects, and each is flagged
+per-row in the data.
+
+**1. The facts were selected to be easy.** Candidates were kept only if **all
+five** filter models (Gemma-2-2B-it, Qwen2.5-7B, Mistral-7B-v0.3, Llama-3.1-8B,
+Gemma-2-9B-it) produced the correct first token. That is **10,601 of 1,783,541
+cloze prompts — 0.59%**. This is deliberate: to attribute instability to
+*expression* rather than to *ignorance*, the model has to know the fact in the
+first place. The consequence is that absolute stability scores run high, and
+that the four filter models present in a comparison enjoy a selection advantage
+over models that had no say in what was kept.
+
+**2. 750 of 2,592 facts (28.9%) are answerable by copying the subject string.**
+`Airbus A318 → manufacturer → Airbus`. Every fact and every query carries
+`answer_in_subject_surface`; report those two subsets separately.
+
+**3. Only four of the eight condition families belong in the main average.**
+Use each row's own boolean, never a hard-coded family list:
+
+| flag | rows | meaning |
+|---|---:|---|
+| `use_for_main_forward` | 39,260 | anchor + paraphrase + format + context + multilingual |
+| `use_for_reverse_analysis` | 634 | target slot is the **subject**; report separately |
+| `use_for_recognition_analysis` | 3,412 | diagnostic only |
+| *(none of the above)* | 1,110 | `reverse_illposed`; diagnostic only |
+
+**4. `anchor` is the unperturbed baseline, and it holds exactly one query per
+fact.** Its within-family agreement is therefore 1.0 by construction. Including
+it as a fifth equally-weighted family puts a floor under any family-balanced
+consistency score. `configs/metrics.yaml:main_families` controls this; drop
+`anchor` from that list to score the four perturbation families only.
+
+---
+
+## Contents
+
+```
+data/
+  benchmark_facts_2592.jsonl        2,592 facts / 21 relations
+  evaluation_queries_44416.jsonl    44,416 queries / 8 condition families / 6 languages
+configs/
+  metrics.yaml         metric hyper-parameters — layer window, whitening, tau_b, bootstrap
+  models.yaml          the 20 evaluated models + decoding config + judge
+  relations.yaml       21 relations, with the two optional exclusion switches
+  eval_conditions.yaml condition registry the three booleans are derived from
+protocol/
+  evaluation_protocol.md          BCS/BES (§4-6), ISS (§7), KTS (§8-11)   [Chinese]
+  jlens_spec.md                   Jacobian-transported ISS                [Chinese]
+  dataset_construction.md         how the benchmark was built (archival)  [Chinese]
+  reconstruction_differences.md   documented deviations D1, C1, F1, F2, N1, N2
+runner/
+  eval_run.py          generation  -> outputs/evaluation/<model>.jsonl
+  scoring_full.py      five-label scorer (correct/incorrect/ambiguous/abstain/unparseable)
+  test_scoring.py      31 unit tests for the scorer
+  common.py
+metrics/
+  extract_hidden.py    query-end residual states -> outputs/hidden/<model>/
+  iss.py               Internal State Stability
+  kts.py               Knowledge Topology Stability (KTS-Geo + KTS-ID)
+  judge_run.py         semantic clustering of answers (needs a judge model)
+  bcs_bes.py           BCS / BES / behaviour classification
+  joint.py             internal x external correlation
+  make_table.py        main table
+  jlens.py states.py mcommon.py
+OUTPUT_SCHEMA.md       what your model must emit to be scorable
+```
+
+**Not included:** the upstream corpora, the dataset build scripts, and the
+hidden-state tensors (1.6–15 GB per model, regenerate with `extract_hidden.py`).
+
+---
+
+## Condition families
+
+| family | queries | facts | role |
+|---|---:|---:|---|
+| anchor | 2,592 | 2,592 | unperturbed baseline (1 per fact) |
+| paraphrase | 10,053 | 2,592 | main |
+| format | 7,776 | 2,592 | main |
+| context | 6,829 | 2,591 | main |
+| multilingual | 12,010 | 2,402 | main (zh/fr/es/de/ru) |
+| reverse | 634 | 253 | subject slot; reported separately |
+| recognition | 3,412 | 2,585 | diagnostic |
+| reverse_illposed | 1,110 | 1,110 | diagnostic |
+
+Coverage is ragged on purpose — multilingual covers 2,402 facts, context 2,591 —
+so both readings are mandatory (`coverage_modes` in `configs/metrics.yaml`):
+`complete_family` (facts carrying all five) and `full_set` (each fact averaged
+over the families it actually has).
+
+---
+
+## Evaluating your own model
+
+Everything below is CPU-only except `eval_run.py`, `extract_hidden.py` and
+`judge_run.py`.
+
+```bash
+pip install -r requirements.txt
+
+# optional: keep large outputs off the checkout
+export FKS_OUTPUTS=/path/to/large/disk/fks_work
+
+# 1. generate  (44,416 queries)
+python runner/eval_run.py --model my-model --model-path org/my-model
+
+# 2. score to five labels  ->  outputs/evaluation/my-model.scored.jsonl
+python runner/scoring_full.py --gen outputs/evaluation/my-model.jsonl
+
+# 3. your own metrics on top of the labels, or the ones shipped here:
+python metrics/judge_run.py    --model my-model      # semantic clustering [GPU]
+python metrics/bcs_bes.py      --model my-model      # BCS / BES / behaviour
+python metrics/extract_hidden.py --model my-model    # residual states     [GPU]
+python metrics/iss.py          --model my-model --transport raw --device cpu
+python metrics/kts.py          --model my-model --transport raw --device cpu
+```
+
+A model not listed in `configs/models.yaml` needs either an entry there or
+`--model-path`; `metrics/*.py` read `n_layers`/`d_model` from that file, so add
+an entry before running the internal metrics.
+
+### The decoding protocol is part of the benchmark
+
+Numbers are not comparable unless generation matches
+`configs/models.yaml:generation` exactly:
+
+```yaml
+do_sample: false          # greedy
+num_beams: 1
+temperature: 0.0
+max_new_tokens: 24
+max_prompt_len: 192       # effective value; the 96 in models.yaml is raised by eval_run.py
+dtype: bfloat16
+use_chat_template: false  # <-- base and instruct get the IDENTICAL raw string
+seed: 20260101
+```
+
+`use_chat_template: false` is not an oversight. Four of the twenty models are
+instruction-tuned; applying a chat template to only those would confound
+post-training with prompt format. The prompt itself is built by
+`runner/eval_run.py:build_prompt` — anchor gets the instruction wrapper,
+perturbed queries carry their own surface form (that *is* the perturbation) and
+receive only a bare `Answer:` cue. `extract_hidden.py` imports that same
+function rather than re-deriving it, so ISS and BCS are always measured on the
+identical prompt.
+
+### Share the scorer, not just the data
+
+`runner/scoring_full.py` is shipped so that label boundaries — negation
+handling, year granularity, alias matching — are identical across submissions.
+Re-implementing the five-label extractor makes numbers incomparable in ways that
+are very hard to see. Run `python runner/test_scoring.py` (31 tests) to confirm
+it behaves the same on your machine.
+
+---
+
+## Metrics
+
+**External** (from `runner/` + `metrics/judge_run.py` + `metrics/bcs_bes.py`):
+
+- **BCS** — family-balanced maximum probability over answer clusters. Graded,
+  and note it has a high floor: a model choosing at random between two answers
+  scores ≈0.61, not 0.5.
+- **BES** — entropy-based, `1 - H(p)/log A`. Chance floor ≈0.06.
+- **Behaviour classes** — Stable Correct / Stable Wrong / Stable Abstention /
+  Unstable, at a pre-registered `tau_b = 0.8` with 0.7/0.9 sensitivity reported.
+
+**Internal** (from `metrics/extract_hidden.py` + `iss.py` + `kts.py`):
+
+- **ISS** — same-fact cross-condition similarity, corrected against
+  same-relation background: `(S⁺ − S⁻)/(1 − S⁻)`. 0 means "no better than
+  background".
+- **KTS-Geo** — Spearman between within-relation pairwise distance matrices
+  under two conditions; invariant to rotation, translation and isotropic
+  scaling. Reported as `(ρ+1)/2` in the summary files, so **its floor is 0.5** —
+  use the `kts_geo_raw_spearman` field for anything scale-sensitive.
+- **KTS-ID** — chance-corrected cross-condition nearest-neighbour retrieval of
+  the fact itself among same-relation facts.
+
+Layer window: `{l : l/(L−1) ≥ 0.4}` (protocol §7.10). Layer `l` is the *output*
+of decoder block `l`, i.e. `hidden_states[l+1]` in HuggingFace indexing. The
+`jlens_window` integers in `models.yaml` are a redundant assertion checked at
+extraction time, not the definition.
+
+`metrics/judge_run.py` clusters answers with an instruction-tuned judge
+(default `Qwen/Qwen2.5-32B-Instruct`, ~65 GB). It shares pretraining lineage
+with the four Qwen models in the evaluated set and may favour their phrasing;
+`configs/models.yaml:auxiliary_models.judge.known_bias` records the mitigation.
+The judge is never itself evaluated.
+
+---
+
+## Data schema
+
+`benchmark_facts_2592.jsonl`
+
+| field | type | notes |
+|---|---|---|
+| `fact_id` | str | `fact_000602` |
+| `subject`, `object` | obj | `canonical`, `entity_id` (Wikidata Q-id), `aliases[]` |
+| `relation` | obj | `relation_id`, `source_relations[]`, `direction` |
+| `qualification_question` | str | canonical question; identical to the anchor query |
+| `sources`, `source_records` | list | provenance |
+| `is_functional` | bool | single-valued; true for all benchmark facts |
+| `answer_type`, `answer_granularity` | str | drives the scorer's year/entity handling |
+| `answer_in_subject_surface` | bool | **750 true** — see caveat 2 |
+| `spec_6_2_flag` | bool | 846 true (`developer of` / `manufacturer of`) |
+
+`evaluation_queries_44416.jsonl`
+
+| field | type | notes |
+|---|---|---|
+| `query_id`, `fact_id`, `relation` | str | |
+| `condition_family`, `variant_id`, `language` | str | |
+| `query` | str | the surface form actually shown to the model |
+| `target_slot` | str | `object`, or `subject` for reverse |
+| `gold_canonical`, `gold_aliases[]` | str/list | what the scorer accepts |
+| `is_assisted`, `is_well_posed` | bool | |
+| `use_for_main_forward` / `_reverse_analysis` / `_recognition_analysis` | bool | see caveat 3 |
+| `answer_in_subject_surface` | bool | inherited from the fact |
+
+---
+
+## Known deviations
+
+Recorded in full in `protocol/reconstruction_differences.md`:
+
+- **D1** — two `context` queries whose distractor literally contained the gold
+  string were removed by a rule-based guard: 44,418 → **44,416**. The spec
+  counts in `configs/eval_conditions.yaml` still read 44,418 and are reconciled
+  in that file's `accepted_deviations` block.
+- **C1** — `developer of` / `manufacturer of` (846 facts) are flagged rather
+  than dropped; `relations.yaml:drop_spec_6_2_flagged` produces the compliant
+  1,746-fact / 19-relation variant.
+- **F1** — the 28.9% copy-answerable subset (caveat 2).
+- **F2** — 808 exactly duplicated triples among the 8,107 candidates, absorbed
+  during entity-aware grouping.
+- **N2** — `capital_of` direction is not normalised; annotated explicitly with
+  `direction: inverse` + `inverse_of: capital`.
+
+## Licence and attribution
+
+Released under **CC BY 4.0**, inheriting the terms of its sources. Facts derive
+from **CounterFact** (MIT), **LAMA / T-REx** (CC BY 4.0), **LAMA / Google-RE**,
+**LAMA / ConceptNet**, and **PopQA** (MIT); entity ids and aliases come from
+**Wikidata** (CC0). Please cite the original datasets alongside this one.

dataset_upload/configs/eval_conditions.yaml

@@ -0,0 +1,165 @@
+# 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.
+
+# These are the SPEC's counts, not the shipped file's. Two context queries were
+# dropped by a rule-based guard (see accepted_deviations below and protocol
+# reference D1), so evaluation_queries_44416.jsonl really holds 44,416 rows.
+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

dataset_upload/configs/metrics.yaml

@@ -0,0 +1,103 @@
+# BCS / BES / ISS / KTS configuration.
+#
+# Protocol: protocol/evaluation_protocol.md
+# J-Lens:   protocol/jlens_spec.md
+#
+# Everything that a reviewer could accuse us of tuning post hoc lives here and
+# is frozen before the final evaluation (J-Lens spec 13.3).
+
+paths:
+  # Relative entries resolve against the repository root; absolute ones are
+  # used as-is. Both can be overridden without editing this file:
+  #
+  #   FKS_DATA     benchmark_facts_2592.jsonl + evaluation_queries_44416.jsonl
+  #   FKS_OUTPUTS  everything written by the runner and the metrics
+  #   FKS_MODELS   local directory holding model weights (optional, see below)
+  #
+  # Hidden states are large (~1.6-15 GB per model), so point FKS_OUTPUTS at a
+  # scratch volume rather than the repository checkout.
+  data: data
+  outputs: outputs
+
+# ---- condition families -----------------------------------------------------
+# Protocol 1.1. anchor is in T: it is one of the five main retrieval conditions
+# for BCS/BES/ISS/KTS. (The construction-time retention report excluded it,
+# because there it served as the denominator baseline -- a different role.)
+#
+# NOTE. anchor holds exactly one query per fact, so its within-family agreement
+# is 1.0 by construction and it contributes a fixed 1/|T_f| to BCS. Drop it here
+# to score the four perturbation families only; see protocol 4.3.
+main_families: [anchor, paraphrase, format, context, multilingual]
+
+# Protocol 1.3. Coverage is not identical across families (multilingual 2,402,
+# context 2,591), so both readings are reported and neither is the silent
+# default. complete_family = the 2,4xx facts carrying all five; full_set = each
+# fact averaged over the families it actually has.
+coverage_modes: [complete_family, full_set]
+headline_coverage: complete_family
+
+# ---- hidden state extraction ------------------------------------------------
+extraction:
+  # Protocol 2.4: last valid input token, i.e. the model has read the question
+  # but has not emitted an answer token. Tokenizers use left padding so this is
+  # position -1 for every row in a batch.
+  position: query_end
+  dtype: float16          # storage only; the forward runs in bfloat16
+  batch_size: 64
+  max_prompt_len: 192     # same value eval_run.py uses, so prompts are identical
+  # Protocol 7.10: window = {l : d_l >= 0.4} with d_l = l/(L-1). Layer l means
+  # the OUTPUT of decoder block l, i.e. hidden_states[l+1] in HF indexing.
+  window_min_depth: 0.4
+  late_min_depth: 0.8     # protocol 7.10 "Late ISS"
+
+# ---- ISS --------------------------------------------------------------------
+iss:
+  whitening: pca          # protocol 7.5
+  pca_dim: 512            # min(512, d_m)
+  shrinkage: 0.05         # lambda in (Sigma + lambda I)^-1/2, as a fraction of tr(Sigma)/d
+  eps: 1.0e-12
+  # Protocol 7.8: negatives are same-relation, different-fact. Sampling is fixed
+  # once and REUSED for every model, otherwise a model could look stable purely
+  # because it drew easier negatives.
+  max_negatives: 100
+  negative_seed: 20260101
+
+# ---- KTS --------------------------------------------------------------------
+kts:
+  min_facts_per_relation: 5   # protocol 9.1
+  eps: 1.0e-12
+
+# ---- behavioural ------------------------------------------------------------
+behavior:
+  tau_b: 0.8                       # protocol 6, pre-registered
+  tau_sensitivity: [0.7, 0.8, 0.9] # protocol 6
+
+# ---- statistics -------------------------------------------------------------
+bootstrap:
+  n_resamples: 1000     # protocol 14.1
+  ci: 0.95
+  seed: 20260101
+
+# ---- J-Lens estimator (spec 6, 7, 8) ---------------------------------------
+jlens:
+  corpus:
+    name: NeelNanda/pile-10k    # spec 13.1: general text, disjoint from the benchmark
+    n_prompts: 128              # spec 8.2 sweeps {32,64,128,256,512}; frozen after the sweep
+    seq_len: 128
+    seed: 20260101
+  estimator:
+    oversampling: 64            # spec 6.1 recommends p in {32,64}
+    power_iterations: 0
+    rank_grid: [64, 128, 256, 512, 1024]   # spec 7.3, nested probes
+    seeds: [20260101, 20260102, 20260103]  # spec 9: >= 3 sketch seeds
+    primary_seed: 20260101
+  # spec 7.3 / 17. Frozen BEFORE the final benchmark run; a model-layer that
+  # fails these is reported as unresolved rather than silently approximated.
+  thresholds:
+    action_cosine_median_min: 0.99
+    action_relative_error_median_max: 0.05
+    iss_rank_stability_max: 0.01
+    iss_seed_std_max: 0.005
+  validation:
+    n_held_out_activations: 128   # spec 7.2
+    layer_probe: [early, middle, late]

dataset_upload/configs/models.yaml

@@ -0,0 +1,185 @@
+# Model registry. Spec section 4.4: the filtering models must live in
+# configuration rather than being hard-coded.
+#
+# The evaluated set is 5 families x 4 models: four size tiers, and four clean
+# base<->instruct pairs spread across four different families.
+#
+# WEIGHTS. Each entry carries an `hf:` hub id, which is what the runner uses by
+# default. To evaluate a model that is not listed here, either add an entry or
+# pass `--model-path <dir or hub id>` to runner/eval_run.py. To use a local
+# mirror of the listed models, set FKS_MODELS to a directory whose subdirectory
+# names match each entry's `path:`, or uncomment `model_root` below.
+#
+#   model_root: /path/to/your/weights
+#
+# `n_layers`, `d_model` and `jlens_window` are recorded for cross-model
+# analysis; jlens_window is a redundant assertion checked at extraction time
+# against layer_window() -- the binding definition is d_l = l/(L-1) >= 0.4
+# (protocol 7.10), not this number.
+
+# ---- 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: main}
+  - {name: Qwen2.5-7B,      path: Qwen2.5-7B,      revision: main}
+  - {name: Mistral-7B-v0.3, path: Mistral-7B-v0.3, revision: main}
+  - {name: Llama-3.1-8B,    path: Llama-3.1-8B,    revision: main}
+  - {name: Gemma-2-9B-it,   path: Gemma-2-9B-it,   revision: main}
+
+# ---- 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: main,
+     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: main,
+     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: main}
+
+  # ---------------- 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: main,
+     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: main,
+     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

dataset_upload/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}

dataset_upload/data/evaluation_queries_44416.jsonl

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

dataset_upload/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()

dataset_upload/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.runner_dir())
+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()

dataset_upload/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()

dataset_upload/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()

dataset_upload/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()

dataset_upload/metrics/judge_run.py

@@ -0,0 +1,275 @@
+#!/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.runner_dir())
+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.generations(args.model)
+    if not os.path.exists(gen_path):
+        raise SystemExit(
+            f"no generations for {args.model}: {gen_path}\n"
+            f"run  python runner/eval_run.py --model {args.model}  first")
+
+    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()

dataset_upload/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()

dataset_upload/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()

dataset_upload/metrics/mcommon.py

@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+"""Shared plumbing for the BCS/BES/ISS/KTS metric stack.
+
+Everything here is deliberately read-only with respect to data/: the fact set
+and the query bank are frozen artefacts (protocol 2.1), and this package only
+consumes them.
+
+Path resolution has one rule: entries under `paths:` in configs/metrics.yaml
+are taken relative to the repository root unless they are absolute, and each is
+overridable by an environment variable so nobody has to edit a tracked config
+to run on their own filesystem.
+"""
+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)
+
+
+def _root(key, env):
+    p = os.environ.get(env) or cfg()["paths"][key]
+    return p if os.path.isabs(p) else os.path.join(ROOT, p)
+
+
+def data_file(name):
+    """A frozen input artefact: the fact set or the query bank."""
+    return os.path.join(_root("data", "FKS_DATA"), name)
+
+
+def runner_dir():
+    """Where eval_run.py lives; imported so the prompt format has one owner."""
+    return os.path.join(ROOT, "runner")
+
+
+@functools.lru_cache(maxsize=None)
+def models_cfg():
+    with open(os.path.join(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 configs/models.yaml")
+
+
+def model_path(name):
+    """Local weights if we have them, otherwise the hub id.
+
+    Resolution order: $FKS_MODELS/<path>, then configs/models.yaml:model_root
+    (absent by default), then the entry's `hf` id, which transformers resolves
+    against the hub. A model that is in neither the config nor the hub has to be
+    passed explicitly by the caller.
+    """
+    entry = model_entry(name)
+    root = os.environ.get("FKS_MODELS") or models_cfg().get("model_root")
+    if root:
+        local = os.path.join(root, entry.get("path", name))
+        if os.path.isdir(local):
+            return local
+    if entry.get("hf"):
+        return entry["hf"]
+    raise SystemExit(
+        f"cannot locate weights for {name}: set FKS_MODELS to a directory "
+        f"containing '{entry.get('path', name)}', or add an `hf:` id to "
+        f"configs/models.yaml")
+
+
+def out(kind, *parts):
+    """kind in {evaluation, hidden, jlens, metrics}."""
+    p = os.path.join(_root("outputs", "FKS_OUTPUTS"), kind, *parts)
+    os.makedirs(os.path.dirname(p) if os.path.splitext(p)[1] else p, exist_ok=True)
+    return p
+
+
+def generations(model):
+    """Where eval_run.py put this model's raw generations."""
+    return out("evaluation", f"{model}.jsonl")
+
+
+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_44416.jsonl"
+
+
+@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 the build-time validator checks, so trusting
+    them keeps one definition of the split instead of two that can drift.
+    """
+    rows = []
+    for r in read_jsonl(data_file(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(data_file("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)}

dataset_upload/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

dataset_upload/protocol/dataset_construction.md

@@ -0,0 +1,217 @@
+# Construction log —— Fact Knowledge Stability Benchmark
+
+> **ARCHIVAL DOCUMENT.** This records how `benchmark_facts_2592.jsonl` and
+> `evaluation_queries_44416.jsonl` were built, for provenance and auditability.
+> It is **not** a usage guide — see the repository README for that, and
+> `evaluation_protocol.md` for the metric definitions.
+>
+> The build scripts themselves and the upstream corpora (CounterFact, LAMA,
+> PopQA) are not distributed here; the two frozen artefacts above are. Paths and
+> sibling-directory references below refer to the original working tree.
+>
+> Two facts in here matter for anyone *using* the benchmark, and are repeated in
+> the README: the **0.59% selection rate** in Stage I (facts were kept only if
+> all five filter models answered them correctly, so the benchmark is
+> deliberately easy), and **F1** (750 of 2,592 facts can be answered by copying
+> the subject string).
+
+方法论要点：
+
+> **基准集是固定的 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 换了槽不计入，两个诊断条件不计入。
+
+---
+
+## 运行（原工作树，此处不分发）
+
+阶段 I–IV 是建库，产物就是本仓库 `data/` 下的两个文件，不需要重跑。
+阶段 V–VI 的**生成**部分在本仓库里对应 `runner/eval_run.py`，用法见 README。
+
+---
+
+## 当前状态
+
+| 阶段 | 状态 |
+|---|---|
+| 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.

dataset_upload/protocol/evaluation_protocol.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 两种覆盖口径。

dataset_upload/protocol/jlens_spec.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.

dataset_upload/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.

dataset_upload/requirements.txt

@@ -0,0 +1,9 @@
+# Scoring and the CPU metric passes need only these three.
+numpy>=1.24
+scipy>=1.10
+PyYAML>=6.0
+
+# Generation and hidden-state extraction additionally need:
+torch>=2.1
+transformers>=4.45      # >=4.45 for Gemma-2 / OLMo-2 architectures
+accelerate>=0.30

dataset_upload/runner/common.py

@@ -0,0 +1,175 @@
+# -*- 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")
+
+
+def _root(env, default):
+    """$env if set, else `default` under the repository root.
+
+    metrics/mcommon.py resolves the same two variables the same way, so the
+    runner writes generations exactly where the metric stack looks for them.
+    """
+    p = os.environ.get(env) or default
+    return p if os.path.isabs(p) else os.path.join(ROOT, p)
+
+
+DATA = _root("FKS_DATA", "data")
+OUTPUTS = _root("FKS_OUTPUTS", "outputs")
+
+SEED = 20260101
+
+
+def load_config(name):
+    import yaml
+    with open(os.path.join(CONFIGS, name)) as f:
+        return yaml.safe_load(f)
+
+
+def data_path(name):
+    return os.path.join(DATA, name)
+
+
+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

dataset_upload/runner/eval_run.py

@@ -0,0 +1,175 @@
+#!/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, data_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 resolve_weights(explicit, cfg, entry):
+    """--model-path, then $FKS_MODELS/<path>, then models.yaml:model_root, then the hub id.
+
+    Only the hub id travels between machines, so it is the documented default;
+    the two local options exist so an offline cluster does not have to edit a
+    tracked config.
+    """
+    if explicit:
+        return explicit
+    root = os.environ.get("FKS_MODELS") or cfg.get("model_root")
+    if root:
+        local = os.path.join(root, entry.get("path", entry["name"]))
+        if os.path.isdir(local):
+            return local
+    if entry.get("hf"):
+        return entry["hf"]
+    raise SystemExit(
+        f"cannot locate weights for {entry['name']}: pass --model-path, set "
+        f"FKS_MODELS, or add an `hf:` id to configs/models.yaml")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True, help="name from configs/models.yaml")
+    ap.add_argument("--model-path", default=None,
+                    help="local weights directory or hub id; overrides models.yaml")
+    ap.add_argument("--queries", default=data_path("evaluation_queries_44416.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 = resolve_weights(args.model_path, cfg, entry)
+    print(f"[{args.model}] weights: {path}", 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 = [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()

dataset_upload/runner/scoring_full.py

@@ -0,0 +1,236 @@
+# -*- 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")
+
+
+# --------------------------------------------------------------------- CLI
+def main():
+    """Label a generations file.
+
+        python runner/scoring_full.py --gen outputs/evaluation/my-model.jsonl
+
+    Pure CPU. The per-query booleans are copied onto every scored row so that
+    downstream metric code can filter (`use_for_main_forward`,
+    `answer_in_subject_surface`, ...) without joining back to the query bank.
+    """
+    import json, argparse, collections
+    from common import data_path, out_path, read_jsonl
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--gen", required=True, help="outputs/evaluation/<model>.jsonl")
+    ap.add_argument("--queries", default=data_path("evaluation_queries_44416.jsonl"))
+    ap.add_argument("--out", default=None, help="default: <gen>.scored.jsonl")
+    args = ap.parse_args()
+
+    dest = args.out or args.gen.replace(".jsonl", "") + ".scored.jsonl"
+    carry = ("fact_id", "relation", "condition_family", "language", "target_slot",
+             "answer_type", "answer_granularity", "answer_in_subject_surface",
+             "use_for_main_forward", "use_for_reverse_analysis",
+             "use_for_recognition_analysis")
+    q = {r["query_id"]: r for r in read_jsonl(args.queries)}
+
+    counts, n, missing = collections.Counter(), 0, 0
+    with open(dest, "w") as f:
+        for g in read_jsonl(args.gen):
+            row = q.get(g["query_id"])
+            if row is None:
+                missing += 1
+                continue
+            res = score(g["raw_response"], row["gold_aliases"],
+                        answer_type=row["answer_type"],
+                        granularity=row.get("answer_granularity"))
+            rec = {"query_id": g["query_id"], "model": g.get("model"),
+                   **{k: row.get(k) for k in carry},
+                   "raw_response": g["raw_response"], **res,
+                   "needs_manual_review": needs_manual_review(res)}
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+            counts[res["label"]] += 1
+            n += 1
+
+    if missing:
+        print(f"WARNING: {missing} generations had no matching query_id")
+    total = max(n, 1)
+    print(f"scored {n} -> {dest}")
+    for label in ("correct", "incorrect", "ambiguous", "abstain", "unparseable"):
+        print(f"  {label:12s} {counts[label]:6d}  {100*counts[label]/total:5.1f}%")
+
+
+if __name__ == "__main__":
+    main()

dataset_upload/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())