Add the deterministic construction pipeline

MANIFEST.json

@@ -1,117 +1,142 @@
 [
- {
-  "path": "benchmark/benchmark_labelled.jsonl",
-  "bytes": 10395550,
-  "why": "the benchmark: 8,710 questions with S*/S_dist/S_stale"
- },
- {
-  "path": "benchmark/benchmark.jsonl",
-  "bytes": 5688514,
-  "why": "pre-label-resolution form (raw QIDs/PIDs)"
- },
- {
-  "path": "benchmark/functional_negatives.jsonl",
-  "bytes": 1244471,
-  "why": "per-question functional-negative flags"
- },
- {
-  "path": "benchmark/labels.tsv",
-  "bytes": 302669,
-  "why": "Wikidata QID/PID -> label dump"
- },
- {
-  "path": "benchmark/ids.txt",
-  "bytes": 78703,
-  "why": "entity/relation ids used"
- },
- {
-  "path": "annotation/annotation-guidelines.md",
-  "bytes": 36022,
-  "why": "annotation protocol (EN, governing)"
- },
- {
-  "path": "annotation/annotation-guidelines-IT.md",
-  "bytes": 41924,
-  "why": "annotation protocol (IT translation)"
- },
- {
-  "path": "annotation/SAMPLE_MANIFEST.md",
-  "bytes": 1432,
-  "why": "validation sample provenance"
- },
- {
-  "path": "paper-supplement/appendices-removed-2026-08-20.tex",
-  "bytes": 3534,
-  "why": "composability proof + construction detail (cut from the 4pp camera-ready)"
- },
- {
-  "path": "paper-supplement/tab-by-operator-removed-2026-08-20.tex",
-  "bytes": 1505,
-  "why": "per-operator CCR table (cut for space)"
- },
- {
-  "path": "paper-supplement/tab-rank-metrics-removed-2026-08-20.tex",
-  "bytes": 837,
-  "why": "rank-aware metrics table (cut for space)"
- },
- {
-  "path": "baselines/bm25-anchor.json",
-  "bytes": 2035818,
-  "why": "BM25 retrieval baseline, no temporal filter"
- },
- {
-  "path": "baselines/bm25-anchor-tfilter.json",
-  "bytes": 1500755,
-  "why": "BM25 retrieval baseline, temporally filtered"
- },
- {
-  "path": "baselines/bm25-rag-qwen3.json",
-  "bytes": 2214656,
-  "why": "vanilla BM25-RAG end-task baseline"
- },
- {
-  "path": "baselines/bm25-rag-qwen3-matched.json",
-  "bytes": 3103444,
-  "why": "BM25-RAG at matched decode budget"
- },
- {
-  "path": "baselines/v2-grpo-10000.json",
-  "bytes": 562510,
-  "why": "NO-RETRIEVAL system -- backs the interval-leak proof (overall EM 0.364, interval EM 1.000)"
- },
- {
-  "path": "baselines/v3-sft-baseline.extracted.json",
-  "bytes": 706508,
-  "why": "2-hop reference generator -- backs the 3+-hop comparison"
- },
- {
-  "path": "baselines/v3-sft-3hop.extracted.json",
-  "bytes": 710446,
-  "why": "3-hop reference generator -- backs the 3+-hop comparison"
- },
- {
-  "path": "baselines/v3-sft-3hop-seed1337.extracted.json",
-  "bytes": 874163,
-  "why": "seed replica (3-seed mean +0.051 +- 0.083)"
- },
- {
-  "path": "baselines/v3-sft-3hop-seed7.extracted.json",
-  "bytes": 880864,
-  "why": "seed replica"
- },
- {
-  "path": "baselines/v3-sft-seed1337.extracted.json",
-  "bytes": 703367,
-  "why": "seed replica"
- },
- {
-  "path": "baselines/v3-sft-seed7.extracted.json",
-  "bytes": 704595,
-  "why": "seed replica"
- },
- {
-  "path": "v1.0.1-addendum.md",
-  "bytes": 5252,
-  "why": "known issues + evaluation protocol; the interval-leak fix the paper cites"
- }
-]
+  {
+    "path": "benchmark/benchmark_labelled.jsonl",
+    "bytes": 10395550,
+    "why": "the benchmark: 8,710 questions with S*/S_dist/S_stale"
+  },
+  {
+    "path": "benchmark/benchmark.jsonl",
+    "bytes": 5688514,
+    "why": "pre-label-resolution form (raw QIDs/PIDs)"
+  },
+  {
+    "path": "benchmark/functional_negatives.jsonl",
+    "bytes": 1244471,
+    "why": "per-question functional-negative flags"
+  },
+  {
+    "path": "benchmark/labels.tsv",
+    "bytes": 302669,
+    "why": "Wikidata QID/PID -> label dump"
+  },
+  {
+    "path": "benchmark/ids.txt",
+    "bytes": 78703,
+    "why": "entity/relation ids used"
+  },
+  {
+    "path": "annotation/annotation-guidelines.md",
+    "bytes": 36022,
+    "why": "annotation protocol (EN, governing)"
+  },
+  {
+    "path": "annotation/annotation-guidelines-IT.md",
+    "bytes": 41924,
+    "why": "annotation protocol (IT translation)"
+  },
+  {
+    "path": "annotation/SAMPLE_MANIFEST.md",
+    "bytes": 1432,
+    "why": "validation sample provenance"
+  },
+  {
+    "path": "paper-supplement/appendices-removed-2026-08-20.tex",
+    "bytes": 3534,
+    "why": "composability proof + construction detail (cut from the 4pp camera-ready)"
+  },
+  {
+    "path": "paper-supplement/tab-by-operator-removed-2026-08-20.tex",
+    "bytes": 1505,
+    "why": "per-operator CCR table (cut for space)"
+  },
+  {
+    "path": "paper-supplement/tab-rank-metrics-removed-2026-08-20.tex",
+    "bytes": 837,
+    "why": "rank-aware metrics table (cut for space)"
+  },
+  {
+    "path": "code/README.md",
+    "bytes": 3104,
+    "why": "how to run the pipeline; what is and is not included"
+  },
+  {
+    "path": "code/benchmark-design-decisions.md",
+    "bytes": 12976,
+    "why": "formal operator semantics and design rationale not in the paper"
+  },
+  {
+    "path": "code/build_benchmark.py",
+    "bytes": 41785,
+    "why": "the 6-stage deterministic construction pipeline"
+  },
+  {
+    "path": "code/indexer.py",
+    "bytes": 17603,
+    "why": "Triple / ValidityWindow / TemporalKGIndexer -- the foundation every stage imports"
+  },
+  {
+    "path": "code/resolve_labels.py",
+    "bytes": 15074,
+    "why": "Wikidata QID/PID -> human-readable label resolution"
+  },
+  {
+    "path": "baselines/bm25-anchor.json",
+    "bytes": 2035818,
+    "why": "BM25 retrieval baseline, no temporal filter"
+  },
+  {
+    "path": "baselines/bm25-anchor-tfilter.json",
+    "bytes": 1500755,
+    "why": "BM25 retrieval baseline, temporally filtered"
+  },
+  {
+    "path": "baselines/bm25-rag-qwen3.json",
+    "bytes": 2214656,
+    "why": "vanilla BM25-RAG end-task baseline"
+  },
+  {
+    "path": "baselines/bm25-rag-qwen3-matched.json",
+    "bytes": 3103444,
+    "why": "BM25-RAG at matched decode budget"
+  },
+  {
+    "path": "baselines/v2-grpo-10000.json",
+    "bytes": 562510,
+    "why": "NO-RETRIEVAL system -- backs the interval-leak proof (overall EM 0.364, interval EM 1.000)"
+  },
+  {
+    "path": "baselines/v3-sft-baseline.extracted.json",
+    "bytes": 706508,
+    "why": "2-hop reference generator -- backs the 3+-hop comparison"
+  },
+  {
+    "path": "baselines/v3-sft-3hop.extracted.json",
+    "bytes": 710446,
+    "why": "3-hop reference generator -- backs the 3+-hop comparison"
+  },
+  {
+    "path": "baselines/v3-sft-3hop-seed1337.extracted.json",
+    "bytes": 874163,
+    "why": "seed replica (3-seed mean +0.051 +- 0.083)"
+  },
+  {
+    "path": "baselines/v3-sft-3hop-seed7.extracted.json",
+    "bytes": 880864,
+    "why": "seed replica"
+  },
+  {
+    "path": "baselines/v3-sft-seed1337.extracted.json",
+    "bytes": 703367,
+    "why": "seed replica"
+  },
+  {
+    "path": "baselines/v3-sft-seed7.extracted.json",
+    "bytes": 704595,
+    "why": "seed replica"
+  },
+  {
+    "path": "v1.0.1-addendum.md",
+    "bytes": 5252,
+    "why": "known issues + evaluation protocol; the interval-leak fix the paper cites"
+  }
+]

README.md

@@ -57,6 +57,7 @@ negative-dependent evaluation to the functional subset.
 | `benchmark/benchmark.jsonl` | same, pre-label-resolution (raw QIDs/PIDs) |
 | `benchmark/functional_negatives.jsonl` | per-question functional-negative flags |
 | `benchmark/labels.tsv`, `ids.txt` | Wikidata label dump and id list |
+| `code/` | the **deterministic construction pipeline** — indexer, 6-stage benchmark builder, label resolver, and the design-decisions document. Stdlib only; `python build_benchmark.py --smoke_test` verifies it |
 | `annotation/` | the annotation protocol (EN governing, IT translation) and validation-sample provenance |
 | `baselines/` | reference-baseline evaluation outputs (see below) |
 | `paper-supplement/` | material cut from the 4-page camera-ready: the composability closed-form proof, construction details, and two tables |
@@ -127,6 +128,5 @@ This matches the paper itself, which is published open access under CC BY.
 }
 ```
 
-Dataset DOI: `DOI-TODO` — request one from the repository Settings after the first
-push, then update this line, the paper's `tempbench-data` bib entry, and the
-`v1.0.1-addendum.md` header, which still names the old DOI.
+Dataset DOI: [`10.57967/hf/10071`](https://doi.org/10.57967/hf/10071)
+(revision `ad8ea76`).

code/README.md

@@ -0,0 +1,70 @@
+# TempBench construction pipeline
+
+The deterministic pipeline that builds TempBench from a temporal knowledge graph.
+This is the code behind the paper's claim that construction is *algorithmic and
+reproducible*, not LLM-generated: given the same source KG and the same seed, it
+reproduces the released benchmark.
+
+## Contents
+
+| file | what it does |
+| --- | --- |
+| `indexer.py` | The foundation. `Triple`, `ValidityWindow`, and `TemporalKGIndexer` (entity index + interval tree). Every other file imports it. Loads the TGB 2.0 `tkgl-smallpedia` CSV format. |
+| `build_benchmark.py` | The 6-stage construction pipeline: chain sampling → operator expansion → composability filter → answer-uniqueness filter → MinHash dedup → stratified split, then gold/distractor/stale subgraph construction. |
+| `resolve_labels.py` | Rewrites Wikidata QIDs/PIDs into human-readable labels. Two modes: API (rate-limited) and offline dump. |
+| `benchmark-design-decisions.md` | The formal operator semantics and the design choices the paper does not have room to state. Read this before extending the generator. |
+
+## What is *not* here
+
+This directory is the **construction pipeline only**. The reference-baseline
+systems evaluated in the paper are not included; their evaluation outputs ship
+in `../baselines/` and every number in the paper is re-derivable from those.
+
+The source KG is **not redistributed**. `tkgl-smallpedia` comes from
+[TGB 2.0](https://arxiv.org/abs/2406.09639) — download
+`tkgl-smallpedia_edgelist.csv` from TGB and point `--kg_path` at it. (550,376
+quadruples, 47,433 entities, 283 relations, 1900–2024.)
+
+## Running it
+
+No dependencies beyond the Python standard library. Tested on Python 3.11+.
+
+Verify the install with the built-in smoke test, which runs on a synthetic
+5-triple graph and needs no data:
+
+```bash
+python build_benchmark.py --smoke_test
+```
+
+Then build the benchmark:
+
+```bash
+# 1. Construct. target_n is the pre-filter target; the composability,
+#    uniqueness and dedup stages reduce 10,000 -> the released 8,710.
+python build_benchmark.py \
+    --kg_path /path/to/tkgl-smallpedia_edgelist.csv \
+    --output_dir ./out/ \
+    --target_n 10000 --seed 42
+
+# 2. Resolve QIDs/PIDs to labels. Dump mode is offline and preferred;
+#    the fetch step is the only part that needs network access.
+python resolve_labels.py --collect_ids ./out/benchmark.jsonl \
+    --id_output ./out/ids.txt
+python resolve_labels.py --fetch_dump ./out/ids.txt \
+    --dump_output ./out/labels.tsv
+python resolve_labels.py --input ./out/benchmark.jsonl \
+    --label_dump ./out/labels.tsv \
+    --output ./out/benchmark_labelled.jsonl
+```
+
+Step 2 is optional — the benchmark is usable on raw QIDs, which is what you want
+if you are running air-gapped.
+
+`--seed 42` is the released configuration. The pipeline is deterministic: the
+only nondeterminism is the seed, and label resolution depends on the Wikidata
+dump you fetch (we ship ours as `../benchmark/labels.tsv`, so use that for an
+exact match).
+
+## Licence
+
+CC BY 4.0, same as the rest of TempBench. See the top-level `README.md`.

code/benchmark-design-decisions.md

@@ -0,0 +1,142 @@
+# TempBench — Benchmark Generator Design Decisions
+
+This document records the design choices made while implementing `build_benchmark.py` where the TempBench paper leaves the spec open.
+
+Treat this as the source of truth for §5 formal semantics. Anything the paper states verbatim wins; everything below fills gaps.
+
+## 1. Operator semantics
+
+The paper commits to four operator types from the TimelineKGQA taxonomy and gives one natural-language example per operator. It does not give formal semantics, a template grammar, or answer-type definitions. Concrete choices:
+
+### 1.1 Point-in-time (PIT)
+
+- Paper example: *"Who held role X at time T?"*
+- **Formal semantics**: Given an anchor entity `e_0`, a relation path `(r_1, r_2, ..., r_n)`, and a query time `t_q`, the answer is the terminal object `o_n` reached by walking the chain where each hop is valid at `t_q`.
+- **Template surface**: `"In {year}, what was the {r_n} of {e_0}'s {r_1}'s ... 's {r_{n-1}}?"` (and two surface variants rotating the `{year}` position).
+- **Answer type**: entity.
+- **Complexity**: supports 1-hop, 2-hop, 3+-hop.
+
+### 1.2 Before/after (BA)
+
+- Paper example: *"Which entity held role X before entity Y did?"*
+- **Formal semantics**: Same compositional chain as PIT, but the temporal anchor is *not* `t_q` — it is a **sibling fact** elsewhere in the KG. Given chain `C` ending at `o_n` at time `t_a`, a valid BA candidate requires a sibling triple `(penultimate_entity, r_n, sibling_entity, t_ref)` with `t_ref ≠ t_a`. The question asks for `o_n` positioned relative to `sibling_entity`.
+- **Template surface**: `"Who was the {r_n} of {e_0}'s {r_1}'s ... before/after {sibling_entity}?"`. `"before"` when `t_a < t_ref`, `"after"` when `t_a > t_ref`.
+- **Answer type**: entity.
+- **Complexity**: supports 1-hop, 2-hop, 3+-hop. Yield will be lower than PIT — requires a sibling to exist.
+- **Divergence from paper example**: paper's example is 1-hop; we extend to multi-hop by keeping the composition intact and attaching the temporal qualifier to the terminal hop.
+
+### 1.3 Interval (INT)
+
+- Paper example: *"During which period did X hold role Y?"*
+- **Known limitation**: `tkgl-smallpedia` is a point-in-time TKG — 100% of triples have `t_start == t_end`. True *period* questions are not expressible.
+- **Operational redefinition**: Ask for the **year** at which a composed chain resolves to a specified terminal. Equivalent to a "when did this hold?" question on a point-in-time KG.
+- **Template surface**: `"In what year was the {r_n} of {e_0}'s {r_1}'s ... equal to {terminal}?"`.
+- **Answer type**: integer year.
+- **Complexity**: supports 1-hop, 2-hop, 3+-hop.
+- **Divergence**: the paper's §5.1 wording ("During which period") has been softened to "In what year did X hold role Y?" to match the benchmark's point-in-time answer type. Resolved 2026-04-23; a footnote at §5.1 now explains the reason for deviating from TimelineKGQA's original phrasing.
+
+### 1.4 Sequence (SEQ)
+
+- Paper example: *"What happened to X after event Y?"*
+- §6.5 case study: *"Who led the organisation that acquired [Company X] after [Company X]'s CEO resigned?"*
+- **Formal semantics**: Composed chain ending at `o_n` at time `t_a`, paired with a **reference triple** `(s_ref, r_ref, o_ref, t_ref)` elsewhere in the KG where `t_ref < t_a` (for "after") or `t_ref > t_a` (for "before" phrasing — included under SEQ when the qualifier is an event, versus BA when the qualifier is a sibling entity).
+- **Template surface**: `"After {s_ref} {r_ref} {o_ref}, what was the {r_n} of {e_0}'s {r_1}'s ...?"`.
+- **Answer type**: entity.
+- **Complexity**: supports 1-hop, 2-hop, 3+-hop. Requires a reference triple to exist at an earlier time.
+- **Difference from BA**: BA's temporal anchor is an **entity** (another holder of the same terminal relation); SEQ's is a **triple** (an arbitrary earlier event). Mechanically they are siblings in the code.
+
+## 2. 12-cell distribution
+
+Paper §5.2 commits to "all 12 combinations of complexity level × operator type" but gives counts only at the complexity level (`4,000 / 4,000 / 2,000`). Per-cell counts are unspecified.
+
+**Chosen distribution** (target):
+
+| Operator | 1-hop | 2-hop | 3+-hop |
+|---|---|---|---|
+| Point-in-time | 1,000 | 1,000 | 500 |
+| Before/after | 1,000 | 1,000 | 500 |
+| Interval | 1,000 | 1,000 | 500 |
+| Sequence | 1,000 | 1,000 | 500 |
+| **Total** | **4,000** | **4,000** | **2,000** |
+
+Even allocation by operator within each complexity bucket. If any cell under-yields (BA and SEQ depend on sibling/reference availability), we top up with PIT in that complexity bucket — 10K total takes priority over perfect operator balance.
+
+## 3. Answer uniqueness
+
+Paper §5.2 Step 4: *"filtered by answer uniqueness (removing ambiguous questions with multiple valid answers at `t_q`)"*. Scope is unspecified.
+
+- **Chosen semantics**: Uniqueness applies to the **terminal answer only**. A candidate is retained iff, given the specific `e_0` and the first `n-1` hops of the gold chain, the final `(penultimate_entity, r_n)` pair has exactly one valid object at `t_q`.
+- Intermediate-hop fan-out is **permitted**: if `e_0` has multiple valid `r_1` edges, those still enter the pool as separate chains, and each is independently checked for terminal uniqueness.
+- **For INT questions**: uniqueness means the composed chain holds at exactly one discrete year in the KG. If the same terminal appears at two or more years via the same chain, the candidate is dropped.
+
+## 4. Subgraph construction
+
+Paper §5.2 Step 5 provides only loose descriptions; the critical terms ("semantically similar", `Δt`) are not formalised.
+
+- **`S_star`**: the gold chain itself, serialised as a list of triples in hop order. Unambiguous.
+- **`S_dist`** ("semantically similar but incorrect"): one hop replaced by a triple sharing the same `(subject, relation)` but a different object, at **any** validity window. Rationale: this produces a factually-wrong-for-`t_q` alternative that would be indistinguishable from the gold triple without temporal reasoning — i.e., the exact failure mode the paper is trying to diagnose.
+- **`S_stale`** ("temporally adjacent version"): one hop replaced by a triple with the **same** `(subject, relation, object)` but a different `t_start` that is not valid at `t_q`. The nearest such neighbour by `|t - t_q|` is preferred when multiple exist; no explicit `Δt` threshold is enforced.
+- **Failure mode**: for ~25–45% of multi-hop candidates, no `S_dist` alternative exists in the KG (the `(s, r)` pair has exactly one object across all time). Those questions ship with `S_dist == S_star`; annotation guidelines should flag them as "distractor not available".
+
+## 5. Chain generation guards
+
+Not spec'd in the paper; chosen to keep questions non-degenerate.
+
+- **Forward-only chain walk**: each hop must have `triple.subject == current_entity`. The `entity_index` in [code/indexer.py](code/indexer.py) is double-keyed by subject and object, so without this guard the walk becomes an undirected traversal and produces non-chains.
+- **Cycle guard**: no intermediate entity may be revisited within a single chain. This is stricter than the minimum needed (only cycles that return to the anchor produce tautological questions) but keeps all chain entities distinct, which simplifies the subgraph semantics.
+- **Adjacent-relation guard**: two *adjacent* hops may not share a relation. This is the relaxed form of the earlier "no repeated relation anywhere" rule — non-adjacent repeats (e.g. `r_1, r_2, r_1`) are legitimate compositional patterns and are kept.
+
+## 6. Known deviations from paper wording
+
+Recorded here so the `.tex` can be aligned in a single pass before submission.
+
+1. ~~§5.1 says *"During which period did X hold role Y?"* for interval. The benchmark produces year-level answers, not periods. Suggested rewording: *"In what year did X hold role Y?"*.~~ **Resolved 2026-04-23.** Step-9 section draft updated; a footnote at §5.1 explains the deviation from TimelineKGQA's original phrasing. The `.tex` operator list does not include example phrasings, so no `.tex` edit was needed.
+2. §5.1 examples are 1-hop for all four operators. The benchmark extends each operator to 1/2/3+hop; the paper should add a sentence: *"Each operator is generated across all three complexity levels via compositional extension (§5.2)."*.
+3. The paper's abstract and §1 advertise "10,000 questions"; the current run lands close but not exactly on 10,000 due to yield variability. The exact count should be taken from the shipped `benchmark.jsonl` and written into the `.tex` at camera-ready.
+
+## 7. Revisiting these choices
+
+Any of the decisions in §1–§5 can be overridden by:
+- A firmer commitment in a new paper revision (then adjust code to match).
+- A discovered inconsistency with the TimelineKGQA original (then take TimelineKGQA's exact wording).
+
+Sections 6.1 and 6.2 are the most likely to change at reviewer request.
+
+## 8. As-built distribution (run of 2026-04-19)
+
+Running `build_benchmark.py` at `target_n=10000, seed=42` against [code/data/tkgl-smallpedia_edgelist.csv](code/data/tkgl-smallpedia_edgelist.csv) yields 8,710 questions:
+
+| Complexity | PIT | BA | INT | SEQ | Row total | Paper target |
+|---|---|---|---|---|---|---|
+| 1hop  | 1,349 | 1,135 | 403 | 1,113 | **4,000** | 4,000 ✓ |
+| 2hop  | 1,259 | 1,065 | 435 | 1,241 | **4,000** | 4,000 ✓ |
+| 3plus |   274 |   131 |  26 |   279 |   **710** | 2,000 ✗ |
+| **Column** | 2,882 | 2,331 | 864 | 2,633 | **8,710** | 10,000 |
+
+Quality: 100% correct chain structure, 0.1% answer-in-question (noise-level), 71.5% of multi-hop candidates have a constructed `S_dist`, 81.3% have `S_stale`. Wikidata label coverage 99.4% (53 QIDs unresolved, fall back to raw IDs).
+
+### Why 3+hop falls short
+
+tkgl-smallpedia is 100% point-in-time — every triple has `t_start == t_end`. A 3+hop chain requires every hop to be valid at the same exact year, not merely overlap a window. Year-density of related facts around a given anchor entity is typically 0–3 per year, so 3-hop and 4-hop chains that also pass uniqueness and adjacent-relation filters are genuinely rare. Additional attempt-budget does not help beyond ~710; the structural cap is roughly the count of shortest year-constrained 3-paths that share an anchor.
+
+### Options for closing the 3+hop gap
+
+1. **Edit §5.1/Table tab:bench-stats to 710 (or omit the 2,000 target)**. Honest, simple; reduces the paper's multi-hop headline claim.
+2. **Switch KG to one with interval or open-ended facts** (ICEWS, YAGO3, the temporal slice of Freebase). Breaks the tkgl-smallpedia commitment in §3 and requires re-running the indexer against a new schema.
+3. **Allow multi-year windowing for 3+hop chains** (e.g. each hop must be valid at `t_query ± 2 years`). Would ~10× the yield but weakens the temporal semantics — each hop is then only approximately at `t_query`, which the paper's §4 ⊕ operator doesn't formally permit.
+4. **Accept the 710 count, spend the delta on 1hop/2hop** (paper stays at 10K headline, 3+hop is a smaller evaluation slice). The stratified trim already does this implicitly — 1hop and 2hop are at target, 3+hop is at its ceiling.
+
+### Decision (2026-04-23): Option 1, reframed as a finding
+
+**Chosen:** Option 1 with the 3+hop shortfall framed as a structural property of point-in-time multi-hop QA on Wikidata rather than a pipeline failure. New §5.4 "Structural Yield of Point-in-Time Multi-Hop QA" in the `.tex` reports ~710 as the structural ceiling.
+
+**Why Option 1, not 2/3/4:**
+- Option 2 (switch KG) was not feasible in the time remaining.
+- Option 3 (multi-year windowing) would weaken the paper's core theoretical contribution — the ⊕ operator's strict timestamp-consistency semantics.
+- Option 4 (inflate 1hop/2hop to hit 10K) looks like gaming the target; asymmetric inflation to hit a round number is exactly what reviewers catch.
+
+**Bonus fix rolled into the same pass.** The shipped jsonl has **zero** `implicit` question_type entries — the code in `build_benchmark.py` labels `point_in_time → explicit` and BA/INT/SEQ all as `ordinal`, so the paper's old "3.5K / 3.5K / 3K" question-type row was always misrepresenting reality. The three-way question-type split was dropped entirely from Table 2 in favour of the operator × complexity matrix the paper's §4 is actually built on. This simultaneously resolves Deviation #1 and the question_type mislabelling.
+
+**Deviation #2 (§5.1 examples being 1-hop only) resolution:** the rewritten §5.1 spanning sentence now names "the 12-cell operator × complexity matrix reported in Table~\ref{tab:bench-stats}", which makes the multi-hop extension explicit without needing separate worked examples per operator × complexity cell.
+
+**Deviation #3 resolution:** all instances of "10K" / "10,000" in abstract, contributions list, §5.2 Step 4, Table 3 row, and appendix pointer now read "8,710" or "8.7K".

code/build_benchmark.py

@@ -0,0 +1,1151 @@
+"""
+TempBench Builder
+==========================
+Constructs a 10K-question multi-hop temporal QA benchmark (see the TempBench paper).
+
+Implements the full 6-stage pipeline:
+  1. Question generation from KG triples and templates
+  2. Composability filtering (validate temporal consistency)
+  3. Answer uniqueness filtering (discard ambiguous questions)
+  4. MinHash deduplication (Jaccard similarity threshold)
+  5. Subgraph construction (S_star, S_dist, S_stale)
+  6. Train/dev/test split (stratified by complexity)
+
+Output: JSONL benchmark with one question per line, including supporting subgraphs.
+
+Usage:
+    python build_benchmark.py --kg_path kg.json --output_dir ./benchmark/ --target_n 10000
+
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import random
+import sys
+from collections import defaultdict
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+from indexer import (
+    TemporalKGIndexer,
+    Triple,
+    ValidityWindow,
+)
+
+# ---------------------------------------------------------------------------
+# Question generation templates
+# ---------------------------------------------------------------------------
+
+QUESTION_TEMPLATES = {
+    # The TempBench paper cites the TimelineKGQA taxonomy for four operator types.
+    # Each operator takes a compositional chain "path" (= anchor + hop
+    # relations, joined by "'s") and attaches an operator-specific temporal
+    # qualifier. See benchmark-design-decisions.md §1 for semantics.
+    "point_in_time": [
+        "In {year}, what was the {final_relation} of {path}?",
+        "What was the {final_relation} of {path} in {year}?",
+        "{path}'s {final_relation} in {year} was?",
+    ],
+    "before_after": [
+        "Who was the {final_relation} of {path} {qualifier} {sibling}?",
+        "{qualifier_cap} {sibling}, who was the {final_relation} of {path}?",
+    ],
+    "interval": [
+        "In what year was the {final_relation} of {path} equal to {terminal}?",
+        "When was {terminal} the {final_relation} of {path}?",
+    ],
+    "sequence": [
+        "After {ref_subject} {ref_relation} {ref_object}, what was the {final_relation} of {path}?",
+        "What was the {final_relation} of {path} after {ref_subject} {ref_relation} {ref_object}?",
+    ],
+}
+
+
+def _render_composition_path(anchor: str, relations: List[str]) -> str:
+    """
+    Render the nested possessive prefix for compositional multi-hop questions.
+
+    Example:
+        anchor = "Obama", relations = ["spouse", "country"]
+        returns: "Obama's spouse's country"
+    Used as the {path} placeholder for the last-but-one hop; the final
+    relation becomes the {final_relation} placeholder.
+    """
+    parts = [anchor] + relations
+    return "'s ".join(parts)
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Candidate:
+    """An intermediate candidate question before filtering."""
+    id: str
+    question: str
+    t_query: float
+    answer: str
+    complexity: str  # "1hop", "2hop", "3plus"
+    operator_type: str  # "point_in_time", "before_after", "interval", "sequence"
+    question_type: str  # "explicit", "implicit", "ordinal"
+    gold_chain: List[Triple]
+
+
+@dataclass
+class BenchmarkQuestion:
+    """A final, fully-validated benchmark question."""
+    id: str
+    question: str
+    t_query: float
+    answer: str
+    complexity: str
+    operator_type: str
+    question_type: str
+    S_star: List[Dict]  # Gold chain
+    S_dist: List[Dict]  # Distractor chain
+    S_stale: List[Dict]  # Stale-fact chain
+    split: str  # "train", "dev", "test"
+
+    def to_jsonl_dict(self) -> Dict:
+        """Convert to dict for JSONL serialization."""
+        return {
+            "id": self.id,
+            "question": self.question,
+            "t_query": self.t_query,
+            "answer": self.answer,
+            "complexity": self.complexity,
+            "operator_type": self.operator_type,
+            "question_type": self.question_type,
+            "S_star": self.S_star,
+            "S_dist": self.S_dist,
+            "S_stale": self.S_stale,
+            "split": self.split,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Stage 1: Question generation (fallback mode)
+# ---------------------------------------------------------------------------
+
+class QuestionGenerator:
+    """
+    Generates candidate questions from KG triples using templates.
+    Fallback mode when TimelineKGQA is not available.
+    """
+
+    def __init__(self, indexer: TemporalKGIndexer, seed: int = 42):
+        self.indexer = indexer
+        self.rng = random.Random(seed)
+        self.triples = indexer._all_triples
+        self.candidate_id_counter = 0
+        # Collect all actual timestamps for point-in-time TKGs (t_start == t_end)
+        self._timestamps: List[float] = sorted(
+            {t.t_start for t in self.triples}
+        )
+        # tkgl-smallpedia is 100% point-in-time; multi-hop chains need every
+        # hop at exactly the same year. Pre-index (subject, year) → triples
+        # so the 2-hop and 3+-hop samplers can forward-chain in O(bucket_size)
+        # instead of O(entity_degree across all years).
+        self._subject_year: Dict[str, Dict[float, List[Triple]]] = defaultdict(
+            lambda: defaultdict(list)
+        )
+        for t in self.triples:
+            self._subject_year[t.subject][t.t_start].append(t)
+        self._subjects_with_outgoing: List[str] = list(self._subject_year.keys())
+
+    # --- Public entry point ---------------------------------------------
+
+    def generate_candidates(
+        self,
+        target_candidates: int = 40000,
+        min_depth: int = 1,
+        max_depth: int = 4,
+    ) -> List[Candidate]:
+        """
+        Generate candidates across the 12-cell matrix (3 complexity levels ×
+        4 temporal operator types). Target per cell is an even split of the
+        per-complexity budget (4K/4K/2K per the TempBench paper).
+
+        Implementation: sample chains per complexity, and for each chain try
+        each of the four operator builders. PIT and INT succeed for almost
+        every chain; BA requires a sibling fact and SEQ requires an earlier
+        reference triple, so those buckets yield less per chain.
+        """
+        # The TempBench paper commits to 4000 / 4000 / 2000 at target_n = 10000.
+        # Scale proportionally to target_candidates (= 4 × target_n from the
+        # BenchmarkBuilder).
+        per_complexity = {
+            "1hop": target_candidates // 10,    # 40% of target_n
+            "2hop": target_candidates // 10,    # 40% of target_n
+            "3plus": target_candidates // 20,   # 20% of target_n
+        }
+        # 3× oversample to absorb Stage 3/4 attrition (uniqueness + dedup).
+        pool_per_complexity = {k: v * 3 for k, v in per_complexity.items()}
+        operators = ["point_in_time", "before_after", "interval", "sequence"]
+
+        candidates: List[Candidate] = []
+        for complexity, pool_target in pool_per_complexity.items():
+            sampler = {
+                "1hop": lambda n: self._sample_1hop_chains(n),
+                "2hop": lambda n: self._sample_2hop_chains(n),
+                "3plus": lambda n: self._sample_3plus_chains(n, max_depth),
+            }[complexity]
+            # Each chain can produce up to len(operators) candidates, so we
+            # only need pool_target / len(operators) chains — but many
+            # BA/SEQ attempts fail, so keep a healthy buffer.
+            chains = sampler(pool_target // 2)
+            for chain, t_query in chains:
+                for op in operators:
+                    cand = self._build_operator_candidate(
+                        op, chain, t_query, complexity
+                    )
+                    if cand is not None:
+                        candidates.append(cand)
+
+        self.rng.shuffle(candidates)
+        return candidates
+
+    # --- Chain samplers (return chain + t_query, no templating) ---------
+
+    def _sample_1hop_chains(
+        self, target_count: int
+    ) -> List[Tuple[List[Triple], float]]:
+        chains = []
+        sampled = self.rng.sample(
+            self.triples, min(len(self.triples), target_count)
+        )
+        for t in sampled:
+            chains.append(([t], t.t_start))
+        return chains
+
+    def _sample_2hop_chains(
+        self, target_count: int
+    ) -> List[Tuple[List[Triple], float]]:
+        """
+        Year-first 2-hop sampler. Pick an anchor subject that has outgoing
+        facts, pick a year from that subject, then find a second hop from the
+        pivot at the same year. Much higher success rate than sampling t1
+        first and hoping for a matching t2.
+        """
+        chains = []
+        attempts = 0
+        max_attempts = target_count * 8
+        while len(chains) < target_count and attempts < max_attempts:
+            attempts += 1
+            anchor = self.rng.choice(self._subjects_with_outgoing)
+            year_index = self._subject_year[anchor]
+            year = self.rng.choice(list(year_index.keys()))
+            t1_candidates = year_index[year]
+            t1 = self.rng.choice(t1_candidates)
+
+            pivot_year_index = self._subject_year.get(t1.obj)
+            if pivot_year_index is None:
+                continue
+            t2_candidates = [
+                t for t in pivot_year_index.get(year, [])
+                if t.relation != t1.relation
+                and t.obj != t1.subject  # cycle guard
+            ]
+            if not t2_candidates:
+                continue
+            t2 = self.rng.choice(t2_candidates)
+
+            chains.append(([t1, t2], year))
+        return chains
+
+    def _sample_3plus_chains(
+        self, target_count: int, max_depth: int
+    ) -> List[Tuple[List[Triple], float]]:
+        """
+        Year-first 3+-hop sampler. Pick an anchor subject, pick a year that
+        subject has outgoing facts, walk forward through hops at that year.
+        Uses the pre-built (subject, year) index for fast forward-chaining.
+        """
+        chains = []
+        attempts = 0
+        max_attempts = target_count * 15
+        while len(chains) < target_count and attempts < max_attempts:
+            attempts += 1
+            anchor = self.rng.choice(self._subjects_with_outgoing)
+            year_index = self._subject_year[anchor]
+            year = self.rng.choice(list(year_index.keys()))
+            depth = self.rng.randint(3, min(max_depth, 4))
+
+            chain: List[Triple] = []
+            current = anchor
+            visited = {current}
+            for _ in range(depth):
+                hops = [
+                    t for t in self._subject_year.get(current, {}).get(year, [])
+                    if t.obj not in visited
+                ]
+                if not hops:
+                    break
+                hop = self.rng.choice(hops)
+                chain.append(hop)
+                current = hop.obj
+                visited.add(current)
+
+            if len(chain) < 3:
+                continue
+
+            if any(
+                chain[i].relation == chain[i - 1].relation
+                for i in range(1, len(chain))
+            ):
+                continue
+
+            window = ValidityWindow.full()
+            valid = True
+            for triple in chain:
+                window = TemporalKGIndexer.compose(window, triple, year)
+                if window is None or window.is_empty():
+                    valid = False
+                    break
+            if not valid:
+                continue
+
+            chains.append((chain, year))
+        return chains
+
+    # --- Operator builders ----------------------------------------------
+
+    def _build_operator_candidate(
+        self,
+        operator: str,
+        chain: List[Triple],
+        t_query: float,
+        complexity: str,
+    ) -> Optional[Candidate]:
+        """Dispatch to the right operator builder."""
+        dispatch = {
+            "point_in_time": self._build_pit,
+            "before_after": self._build_ba,
+            "interval": self._build_interval,
+            "sequence": self._build_sequence,
+        }
+        return dispatch[operator](chain, t_query, complexity)
+
+    def _build_pit(
+        self, chain: List[Triple], t_query: float, complexity: str
+    ) -> Optional[Candidate]:
+        """Point-in-time: "In {year}, what was {path}'s {r_n}?"."""
+        path = _render_composition_path(
+            chain[0].subject, [h.relation for h in chain[:-1]]
+        )
+        template = self.rng.choice(QUESTION_TEMPLATES["point_in_time"])
+        question = template.format(
+            path=path,
+            final_relation=chain[-1].relation,
+            year=int(t_query),
+        )
+        return self._make_candidate(
+            question, t_query, chain[-1].obj, chain, complexity,
+            "point_in_time", "explicit",
+        )
+
+    def _build_ba(
+        self, chain: List[Triple], t_query: float, complexity: str
+    ) -> Optional[Candidate]:
+        """
+        Before/after: same chain as PIT, but the temporal anchor is a sibling
+        fact (another holder of the terminal relation at a different time).
+        The candidate is dropped if no such sibling exists.
+        """
+        terminal = chain[-1]
+        siblings = [
+            t for t in self.indexer.entity_index.get(terminal.subject, [])
+            if t.subject == terminal.subject
+            and t.relation == terminal.relation
+            and t.obj != terminal.obj
+            and t.t_start != t_query
+        ]
+        if not siblings:
+            return None
+        sibling = self.rng.choice(siblings)
+        # Qualifier: answer came *before* sibling if t_query < sibling.t_start.
+        if sibling.t_start > t_query:
+            qualifier, qualifier_cap = "before", "Before"
+        else:
+            qualifier, qualifier_cap = "after", "After"
+
+        path = _render_composition_path(
+            chain[0].subject, [h.relation for h in chain[:-1]]
+        )
+        template = self.rng.choice(QUESTION_TEMPLATES["before_after"])
+        question = template.format(
+            path=path,
+            final_relation=terminal.relation,
+            qualifier=qualifier,
+            qualifier_cap=qualifier_cap,
+            sibling=sibling.obj,
+        )
+        return self._make_candidate(
+            question, t_query, terminal.obj, chain, complexity,
+            "before_after", "ordinal",
+        )
+
+    def _build_interval(
+        self, chain: List[Triple], t_query: float, complexity: str
+    ) -> Optional[Candidate]:
+        """
+        Interval (temporal pinpoint): "In what year was {path}'s {r_n} equal
+        to {terminal}?". Answer is the query year. Uniqueness of the year
+        is enforced by a custom check in Stage 3 (AnswerUniquenessFilter).
+        """
+        path = _render_composition_path(
+            chain[0].subject, [h.relation for h in chain[:-1]]
+        )
+        terminal = chain[-1]
+        template = self.rng.choice(QUESTION_TEMPLATES["interval"])
+        question = template.format(
+            path=path,
+            final_relation=terminal.relation,
+            terminal=terminal.obj,
+        )
+        return self._make_candidate(
+            question, t_query, str(int(t_query)), chain, complexity,
+            "interval", "ordinal",
+        )
+
+    def _build_sequence(
+        self, chain: List[Triple], t_query: float, complexity: str
+    ) -> Optional[Candidate]:
+        """
+        Sequence: "After {ref_subject} {ref_rel} {ref_obj}, what was {path}'s
+        {r_n}?". Reference triple is an earlier fact involving any entity in
+        the chain (makes the anchor event contextually relevant).
+        """
+        chain_entities = {h.subject for h in chain} | {h.obj for h in chain}
+        chain_ids = {(h.subject, h.relation, h.obj) for h in chain}
+        answer_entity = chain[-1].obj
+        refs = []
+        for e in chain_entities:
+            for t in self.indexer.entity_index.get(e, []):
+                if (
+                    t.t_start < t_query
+                    and (t.subject, t.relation, t.obj) not in chain_ids
+                    # The reference must not contain the answer anywhere —
+                    # otherwise the question literally names its own answer.
+                    and t.subject != answer_entity
+                    and t.obj != answer_entity
+                ):
+                    refs.append(t)
+        if not refs:
+            return None
+        ref = self.rng.choice(refs)
+        path = _render_composition_path(
+            chain[0].subject, [h.relation for h in chain[:-1]]
+        )
+        template = self.rng.choice(QUESTION_TEMPLATES["sequence"])
+        question = template.format(
+            path=path,
+            final_relation=chain[-1].relation,
+            ref_subject=ref.subject,
+            ref_relation=ref.relation,
+            ref_object=ref.obj,
+        )
+        return self._make_candidate(
+            question, t_query, chain[-1].obj, chain, complexity,
+            "sequence", "ordinal",
+        )
+
+    def _make_candidate(
+        self,
+        question: str,
+        t_query: float,
+        answer: str,
+        chain: List[Triple],
+        complexity: str,
+        operator_type: str,
+        question_type: str,
+    ) -> Candidate:
+        cand = Candidate(
+            id=f"cand_{self.candidate_id_counter}",
+            question=question,
+            t_query=t_query,
+            answer=answer,
+            complexity=complexity,
+            operator_type=operator_type,
+            question_type=question_type,
+            gold_chain=chain,
+        )
+        self.candidate_id_counter += 1
+        return cand
+
+
+# ---------------------------------------------------------------------------
+# Stage 2: Composability filter
+# ---------------------------------------------------------------------------
+
+class ComposabilityFilter:
+    """Validates temporal consistency of candidate chains."""
+
+    @staticmethod
+    def filter_candidates(candidates: List[Candidate]) -> List[Candidate]:
+        """
+        Discard candidates whose gold chain has empty composed validity window.
+        Uses the ⊕ operator from ValidityWindow.intersect().
+        """
+        valid = []
+
+        for cand in candidates:
+            # Compose all triples in the chain
+            window = ValidityWindow.full()
+            is_valid = True
+
+            for triple in cand.gold_chain:
+                window = TemporalKGIndexer.compose(window, triple, cand.t_query)
+                if window is None or window.is_empty():
+                    is_valid = False
+                    break
+
+            if is_valid:
+                valid.append(cand)
+
+        return valid
+
+
+# ---------------------------------------------------------------------------
+# Stage 3: Answer uniqueness filter
+# ---------------------------------------------------------------------------
+
+class AnswerUniquenessFilter:
+    """Discards ambiguous questions with multiple valid answers at t_query."""
+
+    def __init__(self, indexer: TemporalKGIndexer):
+        self.indexer = indexer
+
+    def filter_candidates(self, candidates: List[Candidate]) -> List[Candidate]:
+        valid = [c for c in candidates if self._answer_is_unique(c)]
+        return valid
+
+    def _answer_is_unique(self, cand: Candidate) -> bool:
+        """
+        Construction pipeline, Step 4: "removing ambiguous questions with multiple valid
+        answers at t_q". Scope is terminal-answer only — intermediate fan-out
+        along the chain is permitted.
+
+        Entity-valued operators (PIT, BA, SEQ): the final hop's (subject,
+        relation) must have exactly one valid object at t_q, and that object
+        must equal the recorded answer.
+
+        Year-valued operator (INT): the specific terminal triple (subject,
+        relation, object) must be valid at exactly one distinct t in the KG.
+        Otherwise the year-answer is ambiguous.
+
+        See benchmark-design-decisions.md §3 for the full rationale.
+        """
+        if not cand.gold_chain:
+            return False
+
+        terminal = cand.gold_chain[-1]
+
+        if cand.operator_type == "interval":
+            # Year answer: the specific (s, r, o) triple must be unique in time.
+            matches = [
+                t for t in self.indexer.entity_index.get(terminal.subject, [])
+                if t.subject == terminal.subject
+                and t.relation == terminal.relation
+                and t.obj == terminal.obj
+            ]
+            distinct_years = {t.t_start for t in matches}
+            return len(distinct_years) == 1
+
+        # Entity-valued operators: terminal (s, r) must have a single valid
+        # object at t_q.
+        terminal_objs = {
+            t.obj
+            for t in self.indexer.entity_index.get(terminal.subject, [])
+            if t.subject == terminal.subject
+            and t.relation == terminal.relation
+            and t.valid_at(cand.t_query)
+        }
+        return len(terminal_objs) == 1 and cand.answer in terminal_objs
+
+
+# ---------------------------------------------------------------------------
+# Stage 4: MinHash deduplication
+# ---------------------------------------------------------------------------
+
+class MinHasher:
+    """
+    MinHash with Jaccard similarity for deduplicating near-duplicate questions.
+    Uses character 3-grams and 128 hash functions.
+    """
+
+    def __init__(self, num_hashes: int = 128, gram_size: int = 3, seed: int = 42):
+        self.num_hashes = num_hashes
+        self.gram_size = gram_size
+        self.seed = seed
+
+    @staticmethod
+    def _get_grams(text: str, gram_size: int) -> Set[str]:
+        """Extract character n-grams from text."""
+        text = text.lower()
+        return {text[i : i + gram_size] for i in range(len(text) - gram_size + 1)}
+
+    def _hash_gram(self, gram: str, hash_idx: int) -> int:
+        """Compute hash value for a gram and hash function index."""
+        seed_str = f"{self.seed}_{hash_idx}_{gram}"
+        h = hashlib.sha256(seed_str.encode()).hexdigest()
+        return int(h, 16)
+
+    def signature(self, text: str) -> List[int]:
+        """Compute MinHash signature for a text."""
+        grams = self._get_grams(text, self.gram_size)
+
+        if not grams:
+            return [0] * self.num_hashes
+
+        sig = []
+        for hash_idx in range(self.num_hashes):
+            min_hash = float("inf")
+            for gram in grams:
+                h = self._hash_gram(gram, hash_idx)
+                min_hash = min(min_hash, h)
+            sig.append(min_hash)
+
+        return sig
+
+    @staticmethod
+    def jaccard_similarity(sig_a: List[int], sig_b: List[int]) -> float:
+        """Estimate Jaccard similarity from MinHash signatures."""
+        if len(sig_a) == 0 or len(sig_b) == 0:
+            return 0.0
+        matches = sum(1 for a, b in zip(sig_a, sig_b) if a == b)
+        return matches / len(sig_a)
+
+
+class MinHashDeduplicator:
+    """Deduplicates candidates using MinHash with Jaccard threshold."""
+
+    def __init__(self, similarity_threshold: float = 0.8, seed: int = 42):
+        self.threshold = similarity_threshold
+        self.hasher = MinHasher(num_hashes=128, seed=seed)
+
+    def deduplicate(self, candidates: List[Candidate]) -> List[Candidate]:
+        """
+        Remove near-duplicate questions (Jaccard > threshold).
+        Keep the first occurrence of each group.
+        """
+        if not candidates:
+            return []
+
+        # Compute signatures
+        sigs = [(c, self.hasher.signature(c.question)) for c in candidates]
+
+        # Greedy clustering: each candidate either starts a cluster or is merged
+        clusters = []
+        used = set()
+
+        for i, (cand_i, sig_i) in enumerate(sigs):
+            if i in used:
+                continue
+
+            cluster = [cand_i]
+            used.add(i)
+
+            for j in range(i + 1, len(sigs)):
+                if j in used:
+                    continue
+
+                cand_j, sig_j = sigs[j]
+                sim = self.hasher.jaccard_similarity(sig_i, sig_j)
+
+                if sim > self.threshold:
+                    used.add(j)
+
+            clusters.append(cluster[0])  # Keep first of each cluster
+
+        return clusters
+
+
+# ---------------------------------------------------------------------------
+# Stage 5: Subgraph construction
+# ---------------------------------------------------------------------------
+
+class SubgraphConstructor:
+    """
+    Builds three subgraphs for each question:
+      - S_star: ground truth chain
+      - S_dist: distractor (one wrong hop, same relation, different object)
+      - S_stale: stale-fact (one hop replaced by temporally adjacent version)
+    """
+
+    def __init__(self, indexer: TemporalKGIndexer, seed: int = 42):
+        self.indexer = indexer
+        self.rng = random.Random(seed)
+
+    def construct(
+        self,
+        candidate: Candidate,
+    ) -> Tuple[List[Dict], List[Dict], List[Dict]]:
+        """
+        Build S_star, S_dist, S_stale for a candidate.
+        Returns (S_star, S_dist, S_stale) as list of triple dicts.
+        """
+        # S_star: the gold chain
+        S_star = [t.to_dict() for t in candidate.gold_chain]
+
+        # S_dist: replace one hop with a distractor (same relation, different object, valid at t_query)
+        S_dist = self._build_distractor(candidate)
+
+        # S_stale: replace one hop with a temporally adjacent version
+        S_stale = self._build_stale(candidate)
+
+        return S_star, S_dist, S_stale
+
+    def _build_distractor(self, candidate: Candidate) -> List[Dict]:
+        """
+        Replace one random hop with a semantically similar but wrong triple.
+        Same subject, same relation, different object, valid at t_query.
+        """
+        if not candidate.gold_chain:
+            return [t.to_dict() for t in candidate.gold_chain]
+
+        S_dist = [t.to_dict() for t in candidate.gold_chain]
+        hop_to_replace = self.rng.randint(0, len(candidate.gold_chain) - 1)
+        replaced_triple = candidate.gold_chain[hop_to_replace]
+
+        # Find alternative triples with same (s, r) but different object AT ANY TIME.
+        # We can't require valid_at(t_query) — the answer-uniqueness filter has
+        # already guaranteed no such alternatives exist, so that constraint would
+        # always return an empty list. Taking any alternative object across time
+        # gives a semantically plausible but factually wrong distractor (e.g. a
+        # former CEO when the question asks about a later year).
+        alternatives = [
+            t for t in self.indexer.entity_index.get(replaced_triple.subject, [])
+            if (t.subject == replaced_triple.subject and
+                t.relation == replaced_triple.relation and
+                t.obj != replaced_triple.obj)
+        ]
+
+        if alternatives:
+            distractor = self.rng.choice(alternatives)
+            S_dist[hop_to_replace] = distractor.to_dict()
+
+        return S_dist
+
+    def _build_stale(self, candidate: Candidate) -> List[Dict]:
+        """
+        Replace one hop with a temporally adjacent version
+        (same s, r, o but different validity window that does NOT contain t_query).
+        """
+        if not candidate.gold_chain:
+            return [t.to_dict() for t in candidate.gold_chain]
+
+        S_stale = [t.to_dict() for t in candidate.gold_chain]
+        hop_to_replace = self.rng.randint(0, len(candidate.gold_chain) - 1)
+        replaced_triple = candidate.gold_chain[hop_to_replace]
+
+        # Find temporally adjacent versions of the same triple
+        adjacent = [
+            t for t in self.indexer._all_triples
+            if (t.subject == replaced_triple.subject and
+                t.relation == replaced_triple.relation and
+                t.obj == replaced_triple.obj and
+                t.t_start != replaced_triple.t_start and
+                not t.valid_at(candidate.t_query))
+        ]
+
+        if adjacent:
+            stale_triple = self.rng.choice(adjacent)
+            S_stale[hop_to_replace] = stale_triple.to_dict()
+
+        return S_stale
+
+
+# ---------------------------------------------------------------------------
+# Stage 6: Train/dev/test split
+# ---------------------------------------------------------------------------
+
+class DatasetSplitter:
+    """Stratified split by complexity level."""
+
+    def __init__(self, seed: int = 42):
+        self.rng = random.Random(seed)
+
+    def split(
+        self,
+        questions: List[BenchmarkQuestion],
+        train_frac: float = 0.7,
+        dev_frac: float = 0.1,
+        test_frac: float = 0.2,
+    ) -> List[BenchmarkQuestion]:
+        """
+        Stratified split by complexity.
+        Target: 1-hop: 4K (2.8K train), 2-hop: 4K (2.8K train), 3+-hop: 2K (1.4K train)
+        """
+        # Group by complexity
+        by_complexity: Dict[str, List[BenchmarkQuestion]] = defaultdict(list)
+        for q in questions:
+            by_complexity[q.complexity].append(q)
+
+        # Split each group
+        result = []
+        for complexity, qs in by_complexity.items():
+            self.rng.shuffle(qs)
+
+            n = len(qs)
+            train_end = int(n * train_frac)
+            dev_end = train_end + int(n * dev_frac)
+
+            for i, q in enumerate(qs):
+                if i < train_end:
+                    q.split = "train"
+                elif i < dev_end:
+                    q.split = "dev"
+                else:
+                    q.split = "test"
+
+            result.extend(qs)
+
+        return result
+
+
+# ---------------------------------------------------------------------------
+# Main builder
+# ---------------------------------------------------------------------------
+
+class BenchmarkBuilder:
+    """Orchestrates all six pipeline stages."""
+
+    def __init__(
+        self,
+        kg_path: str,
+        output_dir: str = "./benchmark/",
+        target_n: int = 10000,
+        seed: int = 42,
+        min_depth: int = 1,
+        max_depth: int = 4,
+    ):
+        self.kg_path = kg_path
+        self.output_dir = Path(output_dir)
+        self.target_n = target_n
+        self.seed = seed
+        self.min_depth = min_depth
+        self.max_depth = max_depth
+        self.rng = random.Random(seed)
+
+        # Build or load indexer
+        self.indexer = TemporalKGIndexer()
+        if kg_path.endswith(".json"):
+            self.indexer.load_from_json(kg_path)
+        else:
+            self.indexer.load_tkgl_smallpedia(kg_path)
+
+    def build(self) -> List[BenchmarkQuestion]:
+        """Run the full 6-stage pipeline."""
+        print("[Benchmark Builder] Starting pipeline...")
+        print(f"[Indexer] {self.indexer}")
+
+        # Stage 1: Generate candidates
+        print("\n[Stage 1] Question generation...")
+        gen = QuestionGenerator(self.indexer, seed=self.seed)
+        target_candidates = int(self.target_n * 4)  # 40K to yield 10K
+        candidates = gen.generate_candidates(
+            target_candidates=target_candidates,
+            min_depth=self.min_depth,
+            max_depth=self.max_depth,
+        )
+        print(f"  Generated {len(candidates):,} candidates")
+
+        # Stage 2: Composability filter
+        print("\n[Stage 2] Composability filtering...")
+        comp_filter = ComposabilityFilter()
+        candidates = comp_filter.filter_candidates(candidates)
+        print(f"  Passed composability check: {len(candidates):,}")
+
+        # Stage 3: Answer uniqueness filter
+        print("\n[Stage 3] Answer uniqueness filtering...")
+        uniq_filter = AnswerUniquenessFilter(self.indexer)
+        candidates = uniq_filter.filter_candidates(candidates)
+        print(f"  Passed uniqueness check: {len(candidates):,}")
+
+        # Stage 4: MinHash deduplication
+        print("\n[Stage 4] MinHash deduplication...")
+        deduplicator = MinHashDeduplicator(similarity_threshold=0.8, seed=self.seed)
+        candidates = deduplicator.deduplicate(candidates)
+        print(f"  After deduplication: {len(candidates):,}")
+
+        # Stratified trim: hit the paper's per-complexity targets
+        # (4K / 4K / 2K at target_n = 10K) and, within each complexity, spread
+        # across the four operator types. Under-yield in an operator cell
+        # is topped up with point-in-time from the same complexity, because
+        # PIT is the most reliable operator and degrades the benchmark least
+        # if it fills in for a short cell.
+        candidates = self._stratified_trim(candidates)
+        print(f"  Trimmed to target: {len(candidates):,}")
+
+        # Stage 5: Subgraph construction
+        print("\n[Stage 5] Subgraph construction...")
+        sg_constructor = SubgraphConstructor(self.indexer, seed=self.seed)
+        questions = []
+
+        for i, cand in enumerate(candidates):
+            S_star, S_dist, S_stale = sg_constructor.construct(cand)
+
+            q = BenchmarkQuestion(
+                id=f"q_{i:06d}",
+                question=cand.question,
+                t_query=cand.t_query,
+                answer=cand.answer,
+                complexity=cand.complexity,
+                operator_type=cand.operator_type,
+                question_type=cand.question_type,
+                S_star=S_star,
+                S_dist=S_dist,
+                S_stale=S_stale,
+                split="",  # Will be set in Stage 6
+            )
+            questions.append(q)
+
+        print(f"  Subgraphs constructed: {len(questions):,}")
+
+        # Stage 6: Train/dev/test split
+        print("\n[Stage 6] Train/dev/test split (stratified)...")
+        splitter = DatasetSplitter(seed=self.seed)
+        questions = splitter.split(questions)
+
+        # Print split statistics
+        splits = defaultdict(lambda: defaultdict(int))
+        for q in questions:
+            splits[q.complexity][q.split] += 1
+
+        print("  Split distribution:")
+        for complexity in ["1hop", "2hop", "3plus"]:
+            if complexity in splits:
+                train = splits[complexity]["train"]
+                dev = splits[complexity]["dev"]
+                test = splits[complexity]["test"]
+                total = train + dev + test
+                print(f"    {complexity:8s}: {total:5d} ({train:4d} train, {dev:3d} dev, {test:3d} test)")
+
+        return questions
+
+    def _stratified_trim(self, candidates: List[Candidate]) -> List[Candidate]:
+        """
+        Reduce candidates to per-complexity/per-operator quotas matching paper
+        the TempBench paper (4K 1-hop, 4K 2-hop, 2K 3+-hop at target_n = 10K), with each
+        complexity split evenly across four operators. Cells that under-yield
+        are topped up from PIT in the same complexity.
+        """
+        per_complexity_target = {
+            "1hop":  self.target_n * 4 // 10,   # 40%
+            "2hop":  self.target_n * 4 // 10,   # 40%
+            "3plus": self.target_n * 2 // 10,   # 20%
+        }
+        operators = ("point_in_time", "before_after", "interval", "sequence")
+
+        # Bucket candidates by (complexity, operator)
+        buckets: Dict[Tuple[str, str], List[Candidate]] = defaultdict(list)
+        for c in candidates:
+            buckets[(c.complexity, c.operator_type)].append(c)
+        for bucket in buckets.values():
+            self.rng.shuffle(bucket)
+
+        trimmed: List[Candidate] = []
+        for complexity, cx_target in per_complexity_target.items():
+            per_op_target = cx_target // len(operators)
+            cx_kept: List[Candidate] = []
+            # First pass: take up to per_op_target from each operator cell.
+            for op in operators:
+                cell = buckets.get((complexity, op), [])
+                cx_kept.extend(cell[:per_op_target])
+            # Top up shortfall with PIT first, then anything available.
+            shortfall = cx_target - len(cx_kept)
+            if shortfall > 0:
+                topup_pool: List[Candidate] = []
+                for op in ("point_in_time", "sequence", "before_after", "interval"):
+                    cell = buckets.get((complexity, op), [])
+                    if len(cell) > per_op_target:
+                        topup_pool.extend(cell[per_op_target:])
+                self.rng.shuffle(topup_pool)
+                cx_kept.extend(topup_pool[:shortfall])
+            trimmed.extend(cx_kept)
+
+        self.rng.shuffle(trimmed)
+        return trimmed
+
+    def save(self, questions: List[BenchmarkQuestion]) -> None:
+        """Write benchmark to JSONL file."""
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        output_path = self.output_dir / "benchmark.jsonl"
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            for q in questions:
+                f.write(json.dumps(q.to_jsonl_dict()) + "\n")
+
+        print(f"\n[Output] Benchmark saved to {output_path}")
+        print(f"  {len(questions):,} questions written")
+
+
+# ---------------------------------------------------------------------------
+# Smoke test
+# ---------------------------------------------------------------------------
+
+def smoke_test():
+    """Run on synthetic Deutsche Bank KG (same 5 triples as indexer.py tests)."""
+    print("=" * 70)
+    print("SMOKE TEST: TempBench Builder")
+    print("=" * 70)
+
+    # Create a temporary indexer with synthetic data
+    indexer = TemporalKGIndexer()
+    indexer.build([
+        ("Deutsche_Bank", "has_CFO", "John_Cryan", 2015.0, 2018.0),
+        ("Deutsche_Bank", "has_CFO", "Christian_Sewing", 2018.0, math.inf),
+        ("Deutsche_Bank", "settled", "LIBOR_Case", 2015.25, 2015.25),
+        ("John_Cryan", "member_of", "Deutsche_Bank", 2015.0, 2018.0),
+        ("Christian_Sewing", "member_of", "Deutsche_Bank", 2018.0, math.inf),
+    ])
+
+    print(f"\nIndexer: {indexer}\n")
+
+    # Generate candidates
+    gen = QuestionGenerator(indexer, seed=42)
+    candidates = gen.generate_candidates(
+        target_candidates=100,
+        min_depth=1,
+        max_depth=3,
+    )
+    print(f"Generated {len(candidates)} candidates")
+
+    # Filter by composability
+    comp_filter = ComposabilityFilter()
+    candidates = comp_filter.filter_candidates(candidates)
+    print(f"Passed composability: {len(candidates)}")
+
+    # Filter by uniqueness
+    uniq_filter = AnswerUniquenessFilter(indexer)
+    candidates = uniq_filter.filter_candidates(candidates)
+    print(f"Passed uniqueness: {len(candidates)}")
+
+    # Deduplicate
+    deduplicator = MinHashDeduplicator(similarity_threshold=0.8, seed=42)
+    candidates = deduplicator.deduplicate(candidates)
+    print(f"After deduplication: {len(candidates)}")
+
+    # Build subgraphs
+    sg_constructor = SubgraphConstructor(indexer, seed=42)
+    questions = []
+
+    for i, cand in enumerate(candidates[:min(5, len(candidates))]):
+        S_star, S_dist, S_stale = sg_constructor.construct(cand)
+
+        q = BenchmarkQuestion(
+            id=f"q_{i:06d}",
+            question=cand.question,
+            t_query=cand.t_query,
+            answer=cand.answer,
+            complexity=cand.complexity,
+            operator_type=cand.operator_type,
+            question_type=cand.question_type,
+            S_star=S_star,
+            S_dist=S_dist,
+            S_stale=S_stale,
+            split="train",
+        )
+        questions.append(q)
+
+    print(f"Built {len(questions)} benchmark questions\n")
+
+    # Print sample
+    print("Sample questions:")
+    for q in questions[:3]:
+        print(f"\n  ID: {q.id}")
+        print(f"  Question: {q.question}")
+        print(f"  Complexity: {q.complexity}")
+        print(f"  Answer: {q.answer}")
+        print(f"  t_query: {q.t_query}")
+        print(f"  Operator: {q.operator_type}")
+        print(f"  S_star: {len(q.S_star)} triples")
+        print(f"  S_dist: {len(q.S_dist)} triples")
+        print(f"  S_stale: {len(q.S_stale)} triples")
+
+    print("\n" + "=" * 70)
+    print("SMOKE TEST PASSED")
+    print("=" * 70)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Build TempBench: 10K-question temporal QA benchmark"
+    )
+    parser.add_argument(
+        "--kg_path",
+        type=str,
+        default=None,
+        help="Path to KG file (JSON or TKGL CSV)",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="./benchmark/",
+        help="Output directory for benchmark JSONL",
+    )
+    parser.add_argument(
+        "--target_n",
+        type=int,
+        default=10000,
+        help="Target number of benchmark questions (default 10000)",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed (default 42)",
+    )
+    parser.add_argument(
+        "--min_depth",
+        type=int,
+        default=1,
+        help="Minimum chain depth (default 1)",
+    )
+    parser.add_argument(
+        "--max_depth",
+        type=int,
+        default=4,
+        help="Maximum chain depth (default 4)",
+    )
+    parser.add_argument(
+        "--smoke_test",
+        action="store_true",
+        help="Run smoke test on synthetic data",
+    )
+
+    args = parser.parse_args()
+
+    if args.smoke_test:
+        smoke_test()
+        sys.exit(0)
+
+    if not args.kg_path:
+        print("Error: --kg_path required (or use --smoke_test)")
+        sys.exit(1)
+
+    builder = BenchmarkBuilder(
+        kg_path=args.kg_path,
+        output_dir=args.output_dir,
+        target_n=args.target_n,
+        seed=args.seed,
+        min_depth=args.min_depth,
+        max_depth=args.max_depth,
+    )
+
+    questions = builder.build()
+    builder.save(questions)
+
+
+if __name__ == "__main__":
+    main()

code/indexer.py

@@ -0,0 +1,446 @@
+"""
+TempBench — Temporal KG Indexer
+===================================
+Implements the dual-index structure (entity index + interval tree temporal index)
+described in the TempBench paper.
+
+Usage:
+    from indexer import TemporalKGIndexer
+
+    indexer = TemporalKGIndexer()
+    indexer.load_tkgl_smallpedia("path/to/tkgl-smallpedia.csv")
+    # or from a list of quadruples:
+    indexer.build(quadruples)
+
+    # Query: all triples valid at a given timestamp
+    valid_triples = indexer.query_valid_at(entity="Q1234", t=2015.5)
+
+    # Query: temporally-filtered 1-hop neighbourhood for an anchor entity
+    neighbourhood = indexer.neighbourhood(entity="Q1234", t_query=2015.5)
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import math
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Iterator, List, Optional, Tuple
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class Triple:
+    """A single timestamped KG quadruple."""
+    subject:    str
+    relation:   str
+    obj:        str
+    t_start:    float   # year as float, e.g. 2015.0 or 2015.583 (Aug)
+    t_end:      float   # math.inf for currently-valid facts
+
+    def valid_at(self, t: float) -> bool:
+        return self.t_start <= t <= self.t_end
+
+    def to_dict(self) -> dict:
+        return {
+            "s": self.subject,
+            "r": self.relation,
+            "o": self.obj,
+            "t_start": self.t_start,
+            "t_end": self.t_end if not math.isinf(self.t_end) else None,
+        }
+
+
+@dataclass
+class ValidityWindow:
+    t_start: float
+    t_end:   float
+
+    def intersect(self, other: "ValidityWindow", t_query: float) -> Optional["ValidityWindow"]:
+        """
+        Validity-window intersection clamped to (-inf, t_query], or None if empty.
+        This is a building block used by benchmark construction; it is NOT the
+        forward-propagating composability operator (that is defined in the
+        TempBench paper).
+        """
+        new_start = max(self.t_start, other.t_start)
+        new_end   = min(self.t_end, other.t_end, t_query)
+        if new_start <= new_end:
+            return ValidityWindow(new_start, new_end)
+        return None
+
+    @classmethod
+    def full(cls) -> "ValidityWindow":
+        return cls(t_start=-math.inf, t_end=math.inf)
+
+    def is_empty(self) -> bool:
+        return self.t_start > self.t_end
+
+
+# ---------------------------------------------------------------------------
+# Interval tree node (simple augmented BST)
+# ---------------------------------------------------------------------------
+
+class _IntervalNode:
+    """Node in an augmented interval tree for O(log n) stabbing queries."""
+
+    def __init__(self, triple: Triple):
+        self.triple   = triple
+        self.max_end  = triple.t_end
+        self.left:  Optional[_IntervalNode] = None
+        self.right: Optional[_IntervalNode] = None
+
+    def update_max(self):
+        self.max_end = self.triple.t_end
+        if self.left:
+            self.max_end = max(self.max_end, self.left.max_end)
+        if self.right:
+            self.max_end = max(self.max_end, self.right.max_end)
+
+
+class IntervalTree:
+    """
+    Temporal index over triple validity windows using a sorted flat array + bisect.
+    Handles 500K+ records without recursion limits.
+
+    For point-in-time TKGs (t_start == t_end, e.g. tkgl-smallpedia), uses a
+    timestamp bucket dict for O(1) exact-match lookup.
+    For interval TKGs, uses bisect over sorted t_start array + t_end filter.
+
+    Stabbing query: 'all triples whose [t_start, t_end] contains t'.
+    """
+
+    def __init__(self):
+        self._triples: List[Triple] = []          # all triples, unsorted until finalised
+        self._sorted_starts: List[float] = []     # sorted t_start values (parallel to _sorted)
+        self._sorted: List[Triple] = []           # triples sorted by t_start
+        self._buckets: defaultdict[float, List[Triple]] = defaultdict(list)  # for point-in-time
+        self._finalised = False
+        self._size = 0
+
+    def __len__(self) -> int:
+        return self._size
+
+    def insert(self, triple: Triple) -> None:
+        self._triples.append(triple)
+        self._buckets[triple.t_start].append(triple)
+        self._size += 1
+        self._finalised = False
+
+    def _finalise(self) -> None:
+        """Sort triples by t_start for bisect queries. Called lazily before first stab."""
+        self._sorted = sorted(self._triples, key=lambda t: t.t_start)
+        self._sorted_starts = [t.t_start for t in self._sorted]
+        self._finalised = True
+
+    def stab(self, t: float) -> List[Triple]:
+        """Return all triples valid at time t (i.e. t_start <= t <= t_end)."""
+        if not self._finalised:
+            self._finalise()
+
+        import bisect
+        # All triples with t_start <= t
+        right_idx = bisect.bisect_right(self._sorted_starts, t)
+        # Filter for t_end >= t
+        return [tr for tr in self._sorted[:right_idx] if tr.t_end >= t]
+
+
+# ---------------------------------------------------------------------------
+# Main indexer
+# ---------------------------------------------------------------------------
+
+class TemporalKGIndexer:
+    """
+    Dual-index structure over a temporal knowledge graph.
+
+    Attributes
+    ----------
+    entity_index : dict[str, list[Triple]]
+        Maps each entity (subject or object) to all its triples.
+    temporal_index : IntervalTree
+        Interval tree over all triples for O(log n) temporal filtering.
+    """
+
+    def __init__(self):
+        self.entity_index: defaultdict[str, List[Triple]] = defaultdict(list)
+        self.temporal_index: IntervalTree = IntervalTree()
+        self._all_triples: List[Triple] = []
+
+    # ------------------------------------------------------------------
+    # Loading
+    # ------------------------------------------------------------------
+
+    def build(self, quadruples: List[Tuple[str, str, str, float, float]]) -> None:
+        """
+        Build index from a list of (subject, relation, object, t_start, t_end) tuples.
+        t_end = None or math.inf means currently valid.
+        """
+        for s, r, o, t_start, t_end in quadruples:
+            t_end = t_end if (t_end is not None and not math.isnan(t_end)) else math.inf
+            triple = Triple(subject=s, relation=r, obj=o, t_start=t_start, t_end=t_end)
+            self._index_triple(triple)
+
+    def load_tkgl_smallpedia(self, path: str, delimiter: str = ",") -> None:
+        """
+        Load tkgl-smallpedia from TGB 2.0 edge file.
+        Handles the actual TGB 2.0 format: ts,head,tail,relation_type
+        where ts is a point-in-time year (event-based TKG).
+        Each event is normalised to interval [ts, ts].
+        """
+        count = 0
+        with open(path, "r", encoding="utf-8") as f:
+            reader = csv.DictReader(f, delimiter=delimiter)
+            for row in reader:
+                # TGB 2.0 tkgl-smallpedia format: ts, head, tail, relation_type
+                if "ts" in row:
+                    t = float(row["ts"])
+                    triple = Triple(
+                        subject=row["head"],
+                        relation=row["relation_type"],
+                        obj=row["tail"],
+                        t_start=t,
+                        t_end=t,   # point-in-time event normalised to [t, t]
+                    )
+                # Fallback: generic interval format
+                else:
+                    t_start = float(row.get("start_time", row.get("t_start", 0)))
+                    raw_end = row.get("end_time", row.get("t_end", None))
+                    t_end   = float(raw_end) if raw_end and raw_end.strip() not in ("", "None", "nan") else math.inf
+                    triple  = Triple(
+                        subject=row.get("subject", row.get("head", "")),
+                        relation=row.get("relation", row.get("relation_type", "")),
+                        obj=row.get("object", row.get("tail", "")),
+                        t_start=t_start,
+                        t_end=t_end,
+                    )
+                self._index_triple(triple)
+                count += 1
+        print(f"[Indexer] Loaded {count:,} triples from {path}")
+
+    def load_from_json(self, path: str) -> None:
+        """Load from a JSON list of {s, r, o, t_start, t_end?} dicts."""
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        for item in data:
+            t_end = item.get("t_end", None)
+            triple = Triple(
+                subject=item["s"],
+                relation=item["r"],
+                obj=item["o"],
+                t_start=float(item["t_start"]),
+                t_end=float(t_end) if t_end is not None else math.inf,
+            )
+            self._index_triple(triple)
+        print(f"[Indexer] Loaded {len(self._all_triples):,} triples from {path}")
+
+    def _index_triple(self, triple: Triple) -> None:
+        self._all_triples.append(triple)
+        self.entity_index[triple.subject].append(triple)
+        self.entity_index[triple.obj].append(triple)
+        self.temporal_index.insert(triple)
+
+    # ------------------------------------------------------------------
+    # Event-based normalisation (ICEWS-style)
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def normalise_event(s: str, r: str, o: str, t: float) -> Triple:
+        """Convert a point-in-time event (s, r, o, t) to interval form [t, t]."""
+        return Triple(subject=s, relation=r, obj=o, t_start=t, t_end=t)
+
+    # ------------------------------------------------------------------
+    # Query interface
+    # ------------------------------------------------------------------
+
+    def neighbourhood(self, entity: str, t_query: float) -> List[Triple]:
+        """
+        Return the temporally-filtered 1-hop neighbourhood of `entity` at `t_query`.
+        i.e., all triples (entity, r, o, τ) or (s, r, entity, τ) where t_query ∈ τ.
+        O(degree(entity)) — filtered from entity index.
+        """
+        return [t for t in self.entity_index.get(entity, []) if t.valid_at(t_query)]
+
+    def query_valid_at(self, t: float) -> List[Triple]:
+        """
+        Return all triples in the graph valid at time t.
+        Uses interval tree for O(log n + k) performance.
+        """
+        return self.temporal_index.stab(t)
+
+    def entities_for_query(self, t_query: float, mention: str) -> List[str]:
+        """
+        Simple entity linking: return all entities containing `mention` as substring.
+        Replace with a proper entity linker (e.g. ELQ, BLINK) in production.
+        """
+        return [e for e in self.entity_index if mention.lower() in e.lower()]
+
+    # ------------------------------------------------------------------
+    # Chain validity-window intersection (benchmark/SFT construction only)
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def compose(window: ValidityWindow, triple: Triple, t_query: float) -> Optional[ValidityWindow]:
+        """
+        Extend `window` by `triple` via validity-window intersection clamped to
+        t_query. Used only in benchmark/SFT-data construction, not at inference
+        (the retriever uses the per-hop valid_at(t_q) filter via neighbourhood()).
+        Returns None if the composed window is empty.
+        """
+        hop_window = ValidityWindow(triple.t_start, triple.t_end)
+        return window.intersect(hop_window, t_query)
+
+    # ------------------------------------------------------------------
+    # Sinusoidal temporal encoding
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def temporal_encoding(t: float, dim: int = 64) -> List[float]:
+        """
+        Sinusoidal temporal positional encoding (following POSTRA, N04).
+        Encodes a year float into a `dim`-dimensional vector.
+        """
+        encoding = []
+        for i in range(0, dim, 2):
+            freq = 1.0 / (10000 ** (i / dim))
+            encoding.append(math.sin(t * freq))
+            encoding.append(math.cos(t * freq))
+        return encoding[:dim]
+
+    # ------------------------------------------------------------------
+    # Statistics
+    # ------------------------------------------------------------------
+
+    def stats(self) -> dict:
+        n_triples    = len(self._all_triples)
+        n_entities   = len(self.entity_index)
+        n_relations  = len({t.relation for t in self._all_triples})
+        n_open_ended = sum(1 for t in self._all_triples if math.isinf(t.t_end))
+        n_inferred   = 0  # populated during annotation phase; update after tagger runs
+        return {
+            "n_triples":       n_triples,
+            "n_entities":      n_entities,
+            "n_relations":     n_relations,
+            "n_currently_valid": n_open_ended,
+            "n_inferred_windows": n_inferred,
+            "pct_timestamped": round(100 * (n_triples - n_inferred) / max(n_triples, 1), 1),
+        }
+
+    def __repr__(self) -> str:
+        s = self.stats()
+        return (
+            f"TemporalKGIndexer("
+            f"{s['n_triples']:,} triples, "
+            f"{s['n_entities']:,} entities, "
+            f"{s['n_relations']:,} relations, "
+            f"{s['pct_timestamped']}% explicitly timestamped)"
+        )
+
+
+# ---------------------------------------------------------------------------
+# LLM timestamp tagger scaffold
+# ---------------------------------------------------------------------------
+
+class LLMTimestampTagger:
+    """
+    Scaffold for the LLM-based temporal tagger used when KG metadata lacks
+    explicit timestamps (validity-window annotation).
+
+    Replace `_call_llm` with your actual LLM API call.
+    """
+
+    PROMPT_TEMPLATE = """
+You are a temporal fact extractor. Given a knowledge graph triple and its associated text,
+extract the validity period of the fact as a start year and end year.
+
+Triple: ({subject}, {relation}, {object})
+Associated text: {text}
+
+Respond in JSON:
+{{"t_start": <year as float or null>, "t_end": <year as float or null, null if currently valid>}}
+
+If no temporal information is available, respond with {{"t_start": null, "t_end": null}}.
+""".strip()
+
+    def __init__(self, llm_client=None, default_window_width: float = 50.0):
+        """
+        Args:
+            llm_client: any object with a .complete(prompt: str) -> str method.
+            default_window_width: fallback window width (years) for triples
+                                  where the tagger returns null (low confidence).
+        """
+        self.llm_client = llm_client
+        self.default_window_width = default_window_width
+
+    def infer_window(self, triple: Triple, associated_text: str = "") -> Tuple[float, float]:
+        """
+        Infer a validity window for a triple lacking explicit timestamps.
+        Returns (t_start, t_end); t_end = math.inf if currently valid.
+        """
+        if self.llm_client is None:
+            # Fallback: return a wide default window centred on 1990
+            return (1900.0, math.inf)
+
+        prompt = self.PROMPT_TEMPLATE.format(
+            subject=triple.subject,
+            relation=triple.relation,
+            object=triple.obj,
+            text=associated_text,
+        )
+        try:
+            response = self._call_llm(prompt)
+            data = json.loads(response)
+            t_start = float(data["t_start"]) if data.get("t_start") is not None else 1900.0
+            t_end   = float(data["t_end"])   if data.get("t_end")   is not None else math.inf
+            return (t_start, t_end)
+        except Exception:
+            return (1900.0, math.inf)
+
+    def _call_llm(self, prompt: str) -> str:
+        """Override this with your actual LLM API call."""
+        return self.llm_client.complete(prompt)
+
+
+# ---------------------------------------------------------------------------
+# Quick test
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Smoke test with synthetic quadruples
+    indexer = TemporalKGIndexer()
+    indexer.build([
+        ("Deutsche_Bank", "has_CFO",    "John_Cryan",     2015.0, 2018.0),
+        ("Deutsche_Bank", "has_CFO",    "Christian_Sewing", 2018.0, math.inf),
+        ("Deutsche_Bank", "settled",    "LIBOR_Case",     2015.25, 2015.25),
+        ("John_Cryan",    "member_of",  "Deutsche_Bank",  2015.0, 2018.0),
+        ("Christian_Sewing", "member_of", "Deutsche_Bank", 2018.0, math.inf),
+    ])
+
+    print(indexer)
+    print()
+
+    # Test 1: neighbourhood at query time 2015
+    nbrs = indexer.neighbourhood("Deutsche_Bank", t_query=2015.5)
+    print(f"Deutsche_Bank neighbourhood at 2015.5: {len(nbrs)} triples")
+    for t in nbrs:
+        print(f"  ({t.subject}, {t.relation}, {t.obj}) [{t.t_start}–{t.t_end}]")
+
+    print()
+
+    # Test 2: composability operator
+    w = ValidityWindow.full()
+    for triple in nbrs[:2]:
+        composed = TemporalKGIndexer.compose(w, triple, t_query=2015.5)
+        if composed:
+            print(f"Composed window after ({triple.relation}): [{composed.t_start}, {composed.t_end}]")
+            w = composed
+        else:
+            print(f"Chain broken at ({triple.relation}) — temporally inconsistent")
+
+    print()
+
+    # Test 3: temporal encoding
+    enc = TemporalKGIndexer.temporal_encoding(2015.5, dim=8)
+    print(f"Temporal encoding for 2015.5 (dim=8): {[round(x, 4) for x in enc]}")

code/resolve_labels.py

@@ -0,0 +1,411 @@
+"""
+TempBench — Wikidata Label Resolver
+=======================================
+Converts Wikidata QIDs and PIDs in benchmark JSONL files into human-readable
+English labels, turning machine-generated questions like:
+
+    "Q230104's P17 in 1929 was?"
+
+into:
+
+    "What country was Poland in 1929?"  (after full template rewrite)
+    or at minimum: "Danzig's country in 1929 was?"
+
+Two modes:
+  1. API mode (default): fetches labels from Wikidata REST API in batches of 50.
+     Requires internet access; rate-limited politely (~1 req/s).
+  2. Dump mode (--label_dump): reads from a pre-downloaded TSV label file
+     (format: QID<TAB>label<TAB>description, one per line).
+     Faster and offline — use this for production runs.
+
+Label dump can be produced via:
+    python resolve_labels.py --collect_ids benchmark.jsonl --id_output ids.txt
+    # then on a machine with internet:
+    python resolve_labels.py --fetch_dump ids.txt --dump_output labels.tsv
+    # then resolve:
+    python resolve_labels.py --input benchmark.jsonl --label_dump labels.tsv --output benchmark_labelled.jsonl
+
+Usage (quick / API mode):
+    python resolve_labels.py --input benchmark.jsonl --output benchmark_labelled.jsonl
+
+Usage (offline / dump mode):
+    python resolve_labels.py --input benchmark.jsonl --label_dump labels.tsv --output benchmark_labelled.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+try:
+    import urllib.request
+    import urllib.error
+except ImportError:
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Wikidata API label fetcher
+# ---------------------------------------------------------------------------
+
+WIKIDATA_API = "https://www.wikidata.org/w/api.php"
+BATCH_SIZE   = 50       # Wikidata allows up to 50 IDs per wbgetentities call
+RETRY_LIMIT  = 3
+SLEEP_BETWEEN_BATCHES = 0.5  # seconds — polite rate limiting
+
+
+def fetch_labels_api(ids: List[str], lang: str = "en") -> Dict[str, str]:
+    """
+    Fetch English labels for a list of Wikidata IDs (Q-IDs and P-IDs) via API.
+    Returns a dict {id: label}. Missing IDs get empty string.
+    """
+    labels: Dict[str, str] = {}
+
+    for i in range(0, len(ids), BATCH_SIZE):
+        batch = ids[i : i + BATCH_SIZE]
+        ids_str = "|".join(batch)
+
+        url = (
+            f"{WIKIDATA_API}?action=wbgetentities"
+            f"&ids={ids_str}"
+            f"&props=labels"
+            f"&languages={lang}"
+            f"&format=json"
+        )
+
+        for attempt in range(RETRY_LIMIT):
+            try:
+                req = urllib.request.Request(
+                    url,
+                    headers={"User-Agent": "TempBench/1.0 (research; label resolver)"},
+                )
+                with urllib.request.urlopen(req, timeout=15) as resp:
+                    data = json.loads(resp.read().decode("utf-8"))
+
+                for qid, entity in data.get("entities", {}).items():
+                    lab = entity.get("labels", {}).get(lang, {}).get("value", "")
+                    labels[qid] = lab
+
+                break  # success
+
+            except Exception as e:
+                if attempt < RETRY_LIMIT - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    print(f"[Warning] API fetch failed for batch {i//BATCH_SIZE}: {e}", file=sys.stderr)
+
+        time.sleep(SLEEP_BETWEEN_BATCHES)
+        print(f"  Fetched {min(i + BATCH_SIZE, len(ids))}/{len(ids)} labels...", end="\r", flush=True)
+
+    print()
+    return labels
+
+
+# ---------------------------------------------------------------------------
+# Dump-based label loader (offline mode)
+# ---------------------------------------------------------------------------
+
+def load_label_dump(dump_path: str) -> Dict[str, str]:
+    """
+    Load a TSV label dump: QID<TAB>label  (one entity per line).
+    Lines starting with # are comments.
+    """
+    labels: Dict[str, str] = {}
+    with open(dump_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            parts = line.split("\t", 2)
+            if len(parts) >= 2:
+                labels[parts[0]] = parts[1]
+    print(f"[LabelDump] Loaded {len(labels):,} labels from {dump_path}")
+    return labels
+
+
+def save_label_dump(labels: Dict[str, str], output_path: str) -> None:
+    """Save fetched labels to a TSV dump for offline re-use."""
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("# Wikidata label dump for TempBench\n")
+        f.write("# Format: QID<TAB>label\n")
+        for qid, label in sorted(labels.items()):
+            f.write(f"{qid}\t{label}\n")
+    print(f"[LabelDump] Saved {len(labels):,} labels to {output_path}")
+
+
+# ---------------------------------------------------------------------------
+# ID extraction
+# ---------------------------------------------------------------------------
+
+QID_PATTERN = re.compile(r'\b(Q\d+|P\d+)\b')
+
+
+def extract_ids_from_jsonl(path: str) -> Set[str]:
+    """Extract all unique Wikidata QIDs and PIDs from a benchmark JSONL."""
+    ids: Set[str] = set()
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            ids.update(QID_PATTERN.findall(line))
+    return ids
+
+
+# ---------------------------------------------------------------------------
+# Question rewriter
+# ---------------------------------------------------------------------------
+
+RELATION_TEMPLATES: Dict[str, str] = {
+    # Standard Wikidata properties → natural language verbs/phrases
+    "P17":    "country",
+    "P19":    "place of birth",
+    "P20":    "place of death",
+    "P21":    "sex or gender",
+    "P22":    "father",
+    "P25":    "mother",
+    "P26":    "spouse",
+    "P27":    "country of citizenship",
+    "P39":    "position held",
+    "P40":    "child",
+    "P50":    "author",
+    "P57":    "director",
+    "P131":   "located in",
+    "P136":   "genre",
+    "P155":   "follows",
+    "P156":   "followed by",
+    "P159":   "headquarters",
+    "P166":   "award received",
+    "P175":   "performer",
+    "P176":   "manufacturer",
+    "P178":   "developer",
+    "P184":   "doctoral advisor",
+    "P185":   "doctoral student",
+    "P190":   "twinned with",
+    "P276":   "location",
+    "P286":   "head coach",
+    "P355":   "subsidiary",
+    "P361":   "part of",
+    "P413":   "position played",
+    "P452":   "industry",
+    "P488":   "chairperson",
+    "P495":   "country of origin",
+    "P527":   "has part",
+    "P571":   "inception",
+    "P576":   "dissolved",
+    "P577":   "publication date",
+    "P580":   "start time",
+    "P582":   "end time",
+    "P598":   "commander",
+    "P607":   "conflict",
+    "P664":   "organizer",
+    "P710":   "participant",
+    "P737":   "influenced by",
+    "P749":   "parent organization",
+    "P800":   "notable work",
+    "P921":   "main subject",
+    "P1037":  "manager",
+    "P1308":  "officeholder",
+    "P2632":  "point in time",
+    "P3342":  "significant person",
+}
+
+
+class LabelApplier:
+    """
+    Applies resolved labels to benchmark questions and subgraphs.
+    Replaces QIDs/PIDs in-place and rewrites question text.
+    """
+
+    def __init__(self, labels: Dict[str, str]):
+        self.labels = labels
+
+    def resolve(self, qid: str) -> str:
+        """Return human-readable label for a QID/PID, falling back to the raw ID."""
+        label = self.labels.get(qid, "")
+        return label if label else qid
+
+    def resolve_relation(self, pid: str) -> str:
+        """Return a natural-language relation phrase, using RELATION_TEMPLATES first."""
+        if pid in RELATION_TEMPLATES:
+            return RELATION_TEMPLATES[pid]
+        # Fallback to fetched label
+        label = self.labels.get(pid, "")
+        return label if label else pid
+
+    def rewrite_question(self, question: str, t_query: float) -> str:
+        """
+        Rewrite a machine-generated question by substituting labels for QIDs/PIDs.
+        Also rewrites common template patterns for naturalness.
+        """
+        # Step 1: find all QIDs/PIDs in the question
+        qids = QID_PATTERN.findall(question)
+        substituted = question
+        for qid in qids:
+            if re.match(r'^P\d+$', qid):
+                substituted = substituted.replace(qid, self.resolve_relation(qid))
+            else:
+                substituted = substituted.replace(qid, self.resolve(qid))
+
+        # Step 2: rewrite common template patterns
+        # Pattern: "X's RELATION in YEAR was?"  →  "What was X's RELATION in YEAR?"
+        m = re.match(r"^(.+)'s (.+) in (\d{4}) was\?$", substituted)
+        if m:
+            subj, rel, year = m.group(1), m.group(2), m.group(3)
+            substituted = f"What was {subj}'s {rel} in {year}?"
+
+        # Pattern: "Who was the RELATION of ENTITY in YEAR?"  →  keep as-is (already natural)
+        # Pattern: "Who was the RELATION of ENTITY before OTHER?"  →  keep as-is
+
+        return substituted
+
+    def rewrite_triple(self, triple: dict) -> dict:
+        """Apply labels to a single triple dict {s, r, o, t_start, t_end}."""
+        return {
+            **triple,
+            "s":        self.resolve(triple["s"]),
+            "s_id":     triple["s"],
+            "r":        self.resolve_relation(triple["r"]),
+            "r_id":     triple["r"],
+            "o":        self.resolve(triple["o"]),
+            "o_id":     triple["o"],
+        }
+
+    def rewrite_question_record(self, record: dict) -> dict:
+        """Apply labels to all fields of a benchmark question record."""
+        out = dict(record)
+
+        out["answer_raw"]   = record["answer"]
+        out["answer"]       = self.resolve(record["answer"])
+        out["question_raw"] = record["question"]
+        out["question"]     = self.rewrite_question(record["question"], record["t_query"])
+
+        for field in ("S_star", "S_dist", "S_stale"):
+            if field in record and record[field]:
+                out[field] = [self.rewrite_triple(t) for t in record[field]]
+
+        return out
+
+
+# ---------------------------------------------------------------------------
+# Main pipeline
+# ---------------------------------------------------------------------------
+
+def resolve_benchmark(
+    input_path: str,
+    output_path: str,
+    label_dump: Optional[str] = None,
+    lang: str = "en",
+    save_dump: Optional[str] = None,
+) -> None:
+    """
+    Full label resolution pipeline for a benchmark JSONL file.
+    """
+    print(f"[Resolver] Input: {input_path}")
+
+    # Step 1: extract all IDs
+    print("[Step 1] Extracting Wikidata IDs...")
+    ids = extract_ids_from_jsonl(input_path)
+    print(f"  Found {len(ids):,} unique IDs (Q-IDs + P-IDs)")
+
+    # Step 2: load or fetch labels
+    if label_dump and Path(label_dump).exists():
+        labels = load_label_dump(label_dump)
+        # Fetch any IDs missing from the dump
+        missing = [qid for qid in ids if qid not in labels]
+        if missing:
+            print(f"[Step 2] Fetching {len(missing):,} labels missing from dump via API...")
+            fetched = fetch_labels_api(missing, lang=lang)
+            labels.update(fetched)
+    else:
+        print(f"[Step 2] Fetching {len(ids):,} labels from Wikidata API...")
+        labels = fetch_labels_api(sorted(ids), lang=lang)
+
+    if save_dump:
+        save_label_dump(labels, save_dump)
+
+    # Coverage report
+    resolved   = sum(1 for qid in ids if labels.get(qid, ""))
+    unresolved = [qid for qid in ids if not labels.get(qid, "")]
+    print(f"  Label coverage: {resolved}/{len(ids)} ({100*resolved/max(len(ids),1):.1f}%)")
+    if unresolved:
+        print(f"  Unresolved IDs (using raw): {unresolved[:10]}{'...' if len(unresolved)>10 else ''}")
+
+    # Step 3: apply labels to all records
+    print("[Step 3] Applying labels to benchmark records...")
+    applier = LabelApplier(labels)
+    out_path = Path(output_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    n_written = 0
+    with open(input_path, "r", encoding="utf-8") as fin, \
+         open(output_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            record = json.loads(line)
+            resolved_record = applier.rewrite_question_record(record)
+            fout.write(json.dumps(resolved_record, ensure_ascii=False) + "\n")
+            n_written += 1
+
+    print(f"[Resolver] Done — {n_written:,} records written to {output_path}")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Resolve Wikidata QIDs/PIDs in TempBench benchmark JSONL to human-readable labels."
+    )
+    parser.add_argument("--input",        required=False, help="Input benchmark JSONL path")
+    parser.add_argument("--output",       required=False, help="Output labelled JSONL path")
+    parser.add_argument("--label_dump",   default=None,  help="Path to pre-fetched TSV label dump (QID<TAB>label)")
+    parser.add_argument("--save_dump",    default=None,  help="Save fetched labels to this TSV file for reuse")
+    parser.add_argument("--lang",         default="en",  help="Wikidata label language (default: en)")
+    parser.add_argument("--collect_ids",  default=None,  help="Only collect IDs from JSONL and write to --id_output")
+    parser.add_argument("--id_output",    default="ids.txt", help="Output file for collected IDs")
+    parser.add_argument("--fetch_dump",   default=None,  help="Fetch labels for IDs in this file and save to --dump_output")
+    parser.add_argument("--dump_output",  default="labels.tsv", help="Output file for fetched label dump")
+
+    args = parser.parse_args()
+
+    # Mode 1: just collect IDs
+    if args.collect_ids:
+        ids = extract_ids_from_jsonl(args.collect_ids)
+        with open(args.id_output, "w") as f:
+            for qid in sorted(ids):
+                f.write(qid + "\n")
+        print(f"[ID Collector] {len(ids):,} unique IDs written to {args.id_output}")
+        return
+
+    # Mode 2: fetch dump from ID list
+    if args.fetch_dump:
+        with open(args.fetch_dump) as f:
+            ids = [line.strip() for line in f if line.strip() and not line.startswith("#")]
+        print(f"[DumpFetcher] Fetching labels for {len(ids):,} IDs...")
+        labels = fetch_labels_api(ids, lang=args.lang)
+        save_label_dump(labels, args.dump_output)
+        return
+
+    # Mode 3: full resolution
+    if not args.input or not args.output:
+        parser.error("--input and --output are required for label resolution")
+
+    resolve_benchmark(
+        input_path=args.input,
+        output_path=args.output,
+        label_dump=args.label_dump,
+        lang=args.lang,
+        save_dump=args.save_dump,
+    )
+
+
+if __name__ == "__main__":
+    main()

v1.0.1-addendum.md

@@ -1,101 +1,101 @@
-# TempBench dataset card — v1.0.1 addendum
-
-Ready-to-paste section for the TempBench dataset card (DOI `10.57967/hf/8930`).
-Append under a "Known issues and evaluation protocol (v1.0.1)" heading. All
-numbers below were computed directly from the released artifacts
-(`benchmark_labelled.jsonl` and the reference-baseline evaluation outputs);
-regeneration commands are listed at the end.
-
----
-
-## Known issues and evaluation protocol (v1.0.1)
-
-### 1. Interval-operator answer leakage through `t_query`
-
-**Mechanism.** Every `interval` question's answer is a year, and the
-construction pipeline sets the question's `t_query` field exactly equal to that
-gold answer year. This holds for 864/864 (100.0%) of interval questions and for
-0.0% of every other operator. Any evaluation protocol that exposes `t_query` to
-the system — in particular, prompt templates that render a `<t={t_query}>`
-prefix — makes the interval slice answerable by copying the timestamp out of
-the prompt, with no retrieval and no reasoning.
-
-**Affected fraction (exact, per split).**
-
-| Split | questions | interval | share |
-|---|---:|---:|---:|
-| train | 6,096 | 601 | 9.86% |
-| dev | 871 | 100 | 11.48% |
-| test | 1,743 | 163 | 9.35% |
-| **all** | **8,710** | **864** | **9.92%** |
-
-**Evidence that the leak is exploited, not merely exploitable.** Reference
-systems with no retrieval at all (prompt is `<t={t_query}> {question}\nAnswer:`)
-score at or near 1.0 on the interval slice: a no-retrieval T-GRPO policy scores
-overall EM 0.364 but interval EM 1.000; a no-retrieval SFT baseline scores
-0.305 overall but 0.994 on interval. On retrieval-conditioned reference
-systems, excluding the interval slice moves overall test EM from 0.865 to 0.851
-(CoT), 0.896 to 0.885 (terse), and 0.138 to 0.113 (BM25 vanilla RAG). The
-interval slice also posts the highest values on every retrieval-quality slice
-(TRP 0.376, CCR 0.920, and stale-blind CCR 0.773 where all other operators fall
-to 0.03–0.08), so per-operator retrieval comparisons involving interval are
-contaminated as well.
-
-**Evaluation-protocol fix.** Do not render `<t={t_query}>` (or otherwise expose
-`t_query`) for interval questions. Interval questions are self-contained: the
-reference event is stated in the question text, and the query year appears in
-the question text for only 2/864 interval items. When comparing against the
-reference-baseline numbers shipped with v1.0, either apply the same protocol or
-report EM with the interval slice excluded alongside overall EM. Do not report
-interval-slice accuracy obtained under a `t_query`-exposing protocol as a
-capability result.
-
-**What is not affected.** The gold supporting subgraphs (`S_star`), distractor
-subgraphs (`S_dist`), and stale subgraphs (`S_stale`) of interval questions are
-correct as released; the leak is a property of the evaluation-prompt protocol,
-not of the graph annotations. Question text, answers, and all non-interval
-operators are unaffected.
-
-### 2. Stale negatives: construction property and intended use
-
-`S_stale` replaces one gold hop with the same `(s, r, o)` at a time invalid at
-`t_query`. Two properties of this construction should inform how the negatives
-are used:
-
-- **Excluded by a correct temporal filter, by definition.** The source KG is
-  point-in-time (`t_start == t_end`), so validity at `t_query` reduces to
-  exact-year equality, and a stale negative — required at construction to be
-  invalid at `t_query` — is removed by any correctly implemented temporal
-  filter. Empirically, 0 of the 1,429 functional stale negatives in the test
-  split are valid at `t_query`, and the temporally-filtered reference retriever
-  retrieves 0 of them (stale negative-hit-rate 0.000). This is a structural
-  consequence, not a measured difficulty. Stale negatives should not be
-  described as hard negatives for temporally-aware systems.
-- **100% BM25-tied: invisible to lexical ranking.** A stale negative and the
-  gold hop it replaces differ only in the validity window, which is not a
-  lexical feature. Under BM25 over `label(s) label(r) label(o)` documents,
-  1,429/1,429 (100.0%) of functional stale pairs score as exact ties.
-
-**Intended use.** The stale negatives are a diagnostic instrument for
-time-blind retrieval: a system that ignores temporal validity admits wrong-time
-evidence of the gold fact's type into 85.9% of retrievals (the exact released
-stale triple into 8.7%), while a temporally-filtered system admits none. They
-measure whether a retriever applies temporal filtering at all, not how well it
-ranks under temporal ambiguity. Per-question functional-negative flags ship
-with the release; stale-dependent evaluation should be restricted to the
-functional subset (1,429/1,743 test questions), and the interval × stale cell
-(n=12 functional) is too small to support slice-level claims.
-
----
-
-## Regeneration
-
-From the code release, `code/` directory, CPU-only:
-
-```
-python camera_ready_tables.py --leak    # leak mechanism + EM with/without interval
-python camera_ready_tables.py --neg     # negative-hit-rate + BM25-tie analysis
-python eval_negatives_ranking.py        # rebuilds the negatives-ranking artifact (~4 min)
-```
-
-Split counts derive from the `split` field of `benchmark_labelled.jsonl`.
+# TempBench dataset card — v1.0.1 addendum
+
+Ready-to-paste section for the TempBench dataset card (DOI `10.57967/hf/10071`).
+Append under a "Known issues and evaluation protocol (v1.0.1)" heading. All
+numbers below were computed directly from the released artifacts
+(`benchmark_labelled.jsonl` and the reference-baseline evaluation outputs);
+regeneration commands are listed at the end.
+
+---
+
+## Known issues and evaluation protocol (v1.0.1)
+
+### 1. Interval-operator answer leakage through `t_query`
+
+**Mechanism.** Every `interval` question's answer is a year, and the
+construction pipeline sets the question's `t_query` field exactly equal to that
+gold answer year. This holds for 864/864 (100.0%) of interval questions and for
+0.0% of every other operator. Any evaluation protocol that exposes `t_query` to
+the system — in particular, prompt templates that render a `<t={t_query}>`
+prefix — makes the interval slice answerable by copying the timestamp out of
+the prompt, with no retrieval and no reasoning.
+
+**Affected fraction (exact, per split).**
+
+| Split | questions | interval | share |
+|---|---:|---:|---:|
+| train | 6,096 | 601 | 9.86% |
+| dev | 871 | 100 | 11.48% |
+| test | 1,743 | 163 | 9.35% |
+| **all** | **8,710** | **864** | **9.92%** |
+
+**Evidence that the leak is exploited, not merely exploitable.** Reference
+systems with no retrieval at all (prompt is `<t={t_query}> {question}\nAnswer:`)
+score at or near 1.0 on the interval slice: a no-retrieval T-GRPO policy scores
+overall EM 0.364 but interval EM 1.000; a no-retrieval SFT baseline scores
+0.305 overall but 0.994 on interval. On retrieval-conditioned reference
+systems, excluding the interval slice moves overall test EM from 0.865 to 0.851
+(CoT), 0.896 to 0.885 (terse), and 0.138 to 0.113 (BM25 vanilla RAG). The
+interval slice also posts the highest values on every retrieval-quality slice
+(TRP 0.376, CCR 0.920, and stale-blind CCR 0.773 where all other operators fall
+to 0.03–0.08), so per-operator retrieval comparisons involving interval are
+contaminated as well.
+
+**Evaluation-protocol fix.** Do not render `<t={t_query}>` (or otherwise expose
+`t_query`) for interval questions. Interval questions are self-contained: the
+reference event is stated in the question text, and the query year appears in
+the question text for only 2/864 interval items. When comparing against the
+reference-baseline numbers shipped with v1.0, either apply the same protocol or
+report EM with the interval slice excluded alongside overall EM. Do not report
+interval-slice accuracy obtained under a `t_query`-exposing protocol as a
+capability result.
+
+**What is not affected.** The gold supporting subgraphs (`S_star`), distractor
+subgraphs (`S_dist`), and stale subgraphs (`S_stale`) of interval questions are
+correct as released; the leak is a property of the evaluation-prompt protocol,
+not of the graph annotations. Question text, answers, and all non-interval
+operators are unaffected.
+
+### 2. Stale negatives: construction property and intended use
+
+`S_stale` replaces one gold hop with the same `(s, r, o)` at a time invalid at
+`t_query`. Two properties of this construction should inform how the negatives
+are used:
+
+- **Excluded by a correct temporal filter, by definition.** The source KG is
+  point-in-time (`t_start == t_end`), so validity at `t_query` reduces to
+  exact-year equality, and a stale negative — required at construction to be
+  invalid at `t_query` — is removed by any correctly implemented temporal
+  filter. Empirically, 0 of the 1,429 functional stale negatives in the test
+  split are valid at `t_query`, and the temporally-filtered reference retriever
+  retrieves 0 of them (stale negative-hit-rate 0.000). This is a structural
+  consequence, not a measured difficulty. Stale negatives should not be
+  described as hard negatives for temporally-aware systems.
+- **100% BM25-tied: invisible to lexical ranking.** A stale negative and the
+  gold hop it replaces differ only in the validity window, which is not a
+  lexical feature. Under BM25 over `label(s) label(r) label(o)` documents,
+  1,429/1,429 (100.0%) of functional stale pairs score as exact ties.
+
+**Intended use.** The stale negatives are a diagnostic instrument for
+time-blind retrieval: a system that ignores temporal validity admits wrong-time
+evidence of the gold fact's type into 85.9% of retrievals (the exact released
+stale triple into 8.7%), while a temporally-filtered system admits none. They
+measure whether a retriever applies temporal filtering at all, not how well it
+ranks under temporal ambiguity. Per-question functional-negative flags ship
+with the release; stale-dependent evaluation should be restricted to the
+functional subset (1,429/1,743 test questions), and the interval × stale cell
+(n=12 functional) is too small to support slice-level claims.
+
+---
+
+## Regeneration
+
+From the code release, `code/` directory, CPU-only:
+
+```
+python camera_ready_tables.py --leak    # leak mechanism + EM with/without interval
+python camera_ready_tables.py --neg     # negative-hit-rate + BM25-tie analysis
+python eval_negatives_ranking.py        # rebuilds the negatives-ranking artifact (~4 min)
+```
+
+Split counts derive from the `split` field of `benchmark_labelled.jsonl`.