v1.0.1-addendum.md

# 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 RL-tuned policy
scores interval EM 1.000 against 0.364 overall, and a no-retrieval supervised
baseline 0.994 against 0.305. On retrieval-conditioned reference systems,
excluding the interval slice moves overall test EM by −0.014 and −0.011, and
BM25 vanilla RAG from 0.138 to 0.113. 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.

### 2b. Distractor negatives: lexically hard, temporally easy

`S_dist` swaps the object of one gold hop, keeping `(s, r)`. The two axes come
apart, and both matter when reporting on this benchmark.

- **Lexical ranking cannot separate them.** On the 1,237 functional distractor
  pairs in the test split, BM25 over `label(s) label(r) label(o)` scores gold
  above the released distractor in 489 cases (39.5%), *below* it in 472
  (38.2%), and exactly tied in 276 (22.3%). Excluding ties, gold wins 489 of
  961 — **50.9%, which is chance.** A purely lexical retriever has no signal
  here at all.
- **A temporal filter removes most of them anyway.** 96.4% of released
  distractors are invalid at `t_query` and are dropped by the per-hop filter;
  only 3.6% survive it. This is a **side effect of construction** —
  `_build_distractor` relaxes the `valid_at` constraint when selecting the
  substitute object — not a designed temporal challenge. For the
  temporally-filtered reference retriever, typed distractor negative-hit-rate
  is 0.138.

**Intended use.** Distractors are the residual difficulty for a time-aware
system, and the honest framing is narrow: they show that answer-string identity
is not evidence identity, and they defeat lexical retrieval outright. Do not
describe them as temporally hard — the temporal filter disposes of 96.4% of
them — and do not read the 3.6% that survive as a designed property. As with
stale, restrict distractor-dependent evaluation to the functional subset using
the shipped flags.

---

### 3. Reference retriever: full specification

A reviewer noted that the BFS+BM25 reference retriever is underspecified on
indexing and ranking. The paper has no room for it, so the complete spec is
here. This describes the *reference baseline* whose outputs ship in
`baselines/` — it is not part of the benchmark, and nothing in the benchmark
depends on it.

**Indexing.** One BM25 document per KG quadruple (550,376 documents). Document
text is `label(s) label(r) label(o)`, lowercased and `\w+`-tokenised;
unresolvable QIDs fall back to the raw QID string. **The validity window is
never indexed** — time enters only through the graph filter, which is why a
stale variant and its gold counterpart are lexically identical (§2).

**BM25.** Okapi, `k1 = 1.5`, `b = 0.75`, with Lucene-style smoothed IDF
`log(1 + (N - df + 0.5) / (df + 0.5))`, `N = 550,376`. Query terms are
deduplicated (no query-term-frequency / `k3` component). `avgdl` is computed
over the same corpus.

**Candidate generation (BFS).** The anchor is the gold first-hop subject
(oracle); the non-oracle variant uses a deliberately simple longest-substring
linker over entity labels, 60.2% anchor recall. Expansion is undirected via the
entity index, with a per-hop temporal filter `valid_at(t_query)` — exact-year
equality, since the source KG is point-in-time. Per-hop caps are 60 / 200 / 400
for hops 1 / 2 / 3, applied in CSV load order **before** BM25 re-ranking. The
pool is deduplicated on `(s, r, o)`, keeping the first time-version.

**Ranking.** BM25 re-ranks the surviving pool. Candidates are grouped by
`(s, r, o)`, rendered as one evidence line each, sorted by score descending, and
truncated to `k = 15` (`k = 25` for the 3-hop ablation). The stale-blind
ablation is the identical architecture with the temporal filter off.

---

### 4. Retrieval determinism: two rules a reimplementation must match

Neither of these changes any published number, but both are load-bearing if you
rebuild the reference retriever and expect to reproduce our figures.

- **Tie-breaking is decided by rule, not by score.** As §2 records, 1,429/1,429
  (100.0%) of functional stale pairs are *exact* BM25 ties, because the validity
  window is not a lexical feature. The tie-break rule therefore decides every
  stale-versus-gold ordering on its own. Ours breaks ties
  **reverse-lexicographically on the rendered evidence line**, everywhere. An
  earlier version of the metric scripts instead used a stable sort that preserved
  candidate-pool (CSV) load order; the two paths were reconciled to the deployed
  behaviour, and the reverse-lexicographic rule is what produced every number in
  the paper and in `baselines/`.

- **The non-oracle anchor linker is deterministic.** The simple
  longest-substring linker over KG entity labels (gold-anchor recall 60.2%) was
  previously sensitive to `PYTHONHASHSEED` through set-iteration order. It is now
  deterministic. The published non-oracle 2-hop 3+-hop CCR moves **0.077 →
  0.070** as a result. This is the same method made reproducible, **not** a
  correction to a result: no claim, comparison or conclusion depends on it.

---

## Regeneration

**The benchmark itself is fully regenerable** from the code release (`code/`,
stdlib-only, CPU-only). See `code/README.md`; you will need
`tkgl-smallpedia_edgelist.csv` from TGB 2.0, which we do not redistribute.

```
python build_benchmark.py --kg_path <tgb-csv> --output_dir ./out/ \
    --target_n 10000 --seed 42
```

**The interval leak (§1) is checkable directly from the shipped data**, with no
retriever and no extra scripts — for every interval question, `t_query` equals
the gold answer year:

```python
import json
rows = [json.loads(l) for l in open("benchmark/benchmark_labelled.jsonl", encoding="utf-8")]
iv = [r for r in rows if r["operator_type"] == "interval"]
print(len(iv), sum(str(r["t_query"]).startswith(str(r["answer"])) for r in iv))
```

**The retrieval-side numbers (§2–§4, and the paper's tables) are *not*
regenerable from this release.** They require the reference retriever and
generator, which are not included here. They are instead shipped as *outputs*:
every figure behind those claims is in `baselines/`, so each is checkable
without re-running anything. Split counts derive from the `split` field of
`benchmark_labelled.jsonl`.