Datasets:

Guen
/

tempbench

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:

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.

TempBench dataset card — v1.0.1 addendum