--- license: cc-by-4.0 language: - en tags: - temporal-reasoning - knowledge-graph - question-answering - benchmark - retrieval-augmented-generation pretty_name: TempBench — Temporal KGQA benchmark with per-question gold subgraphs size_categories: - 1K Guendalina Caldarini. 2026. *TempBench: A Temporal Knowledge-Graph QA Benchmark > with Per-Question Gold Subgraphs and Retrieval-Quality Metrics.* In Proceedings > of the 35th ACM International Conference on Information and Knowledge Management > (CIKM '26), November 07–11, 2026, Rome, Italy. > https://doi.org/10.1145/3799682.3840181 ## What makes it different Most temporal KGQA corpora ship answer strings only, so they can score whether a system was *right* but not whether it retrieved evidence that was **valid at the query time**. TempBench ships, per question: - `S*` — the gold supporting subgraph - `S_dist` — a **distractor**: same `(s,r)`, wrong object - `S_stale` — a **stale fact**: same `(s,r,o)`, wrong time so a system that reaches the right answer through a stale-but-coincidentally-correct fact is visibly distinguishable from one that retrieved correctly. Negatives are *functional* (genuinely differ from `S*`) for 71.5% / 81.3% of questions; the interval × stale cell is structurally absent (8.1%), since interval answers are years and a same-`(s,r,o)`-other-time variant is ill-defined. **Per-question flags ship in `benchmark/functional_negatives.jsonl`** — restrict negative-dependent evaluation to the functional subset. ## Composition Counts by temporal operator and hop complexity, over the full 8,710 questions (the 70/10/20 train/dev/test split is stratified by complexity): | Operator | 1-hop | 2-hop | 3+-hop | Total | | --- | ---: | ---: | ---: | ---: | | Point-in-time | 1,349 | 1,259 | 274 | 2,882 | | Before/after | 1,135 | 1,065 | 131 | 2,331 | | Interval | 403 | 435 | 26 | 864 | | Sequence | 1,113 | 1,241 | 279 | 2,633 | | **Total** | **4,000** | **4,000** | **710** | **8,710** | The 3+-hop column is structurally capped, not undersampled. `tkgl-smallpedia` is point-in-time, so a *k*-hop chain needs every hop valid in the same year, and Wikidata's year-density around an anchor entity is 0–3 facts/year — long chains that also satisfy answer-uniqueness are simply rare. Validity-window TKGs (YAGO3, ICEWS) would lift this. ## Quickstart Three steps, standard library only, no install. Scoring your own retriever against TempBench does **not** require the reference system. **1. Load.** Each line of `benchmark/benchmark_labelled.jsonl` is one question carrying its gold subgraph `S*` and its two typed negatives: ```python import json test = [json.loads(l) for l in open('benchmark/benchmark_labelled.jsonl', encoding='utf-8')] test = [q for q in test if q['split'] == 'test'] # 1,743 questions q = test[0] q['question'] # 'In 1994, what was ... ?' q['t_query'] # 1994.0 -- the time the question is asked about q['S_star'] # [{'s':..., 'r':..., 'o':..., 't_start':..., 't_end':...}, ...] q['S_dist'] # same (s,r), wrong object q['S_stale'] # same (s,r,o), wrong time ``` **2. Retrieve** with your own system. Return an iterable of triples per question — dicts with `s`/`r`/`o`/`t_start`/`t_end`, or 5-tuples in that order. Truncate to your own `k`; TRP is a precision quantity and is not truncated for you. **3. Score** with `code/tempbench_eval.py`: ```python from tempbench_eval import score_question, aggregate rows = [score_question(q, my_retriever(q['question'], q['t_query'])) for q in test] print(aggregate(rows)) # {'n_questions': 1743, 'coverage': ..., 'TRP_macro': ..., 'CCR': ..., # 'by_complexity': {...}, 'by_operator': {...}} ``` `python code/tempbench_eval.py` runs a self-check on synthetic data and needs no files. ### What the two metrics mean Both are **answer-independent** — they score retrieved evidence, not the generated string, which is the whole point of the resource. A system can emit the right answer from a stale fact, and exact-match cannot see it. - **TRP** — of the triples you retrieved, the fraction that are in `S*` *and* valid at `t_query`. Macro-averaged over questions that retrieved anything. - **CCR** — 1 if you retrieved *every* triple of `S*`, all time-valid; else 0. Averaged over all questions, empty retrievals included. A triple is time-valid when `t_start <= t_query <= t_end`. TRP scores against 1–3-triple gold chains, so its absolute value is low by construction: read the gap between systems and the per-complexity profile, not the raw number. The two are not redundant — the reference retriever scores TRP 0.203 against CCR 0.014 at 3+-hop, meaning partial evidence arrives routinely and the full chain almost never. Always report `coverage` alongside them. A system that returns nothing on hard questions inflates its own TRP, since undefined TRP is excluded rather than scored zero. ### The one trap **Restrict negative-dependent analysis to the functional subset.** Not every question's negatives genuinely differ from its gold. Scoring the stale subgraph directly on the 1-hop test slice returns TRP 0.141 — which looks like a time-aware retriever leaking, and is not: ```python flags = {json.loads(l)['id']: json.loads(l) for l in open('benchmark/functional_negatives.jsonl', encoding='utf-8')} sub = [q for q in test if flags[q['id']]['stale_functional']] ``` Restricted to functional negatives, the same measurement returns **TRP 0.000 / CCR 0.000**, as the construction implies. The 0.141 was entirely non-functional negatives. Read `v1.0.1-addendum.md` before evaluating: interval questions leak their answer under the original prompt protocol. ## Contents | path | what | | --- | --- | | `benchmark/benchmark_labelled.jsonl` | the benchmark, human-readable labels | | `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 | | `code/tempbench_eval.py` | **the TRP and CCR scorers** — score your own retriever without re-implementing the definitions. Stdlib only; `python tempbench_eval.py` self-checks | | `annotation/` | the annotation protocol (EN governing, IT translation) and validation-sample provenance | | `annotation/pilot_low_confidence.jsonl` | per-question **low-confidence flags** for the 500-question IAA pilot: 452 consensus, 48 flagged, with which judgment was disputed | | `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 | | `v1.0.1-addendum.md` | **known issues and evaluation protocol — read this before evaluating** | ### Reference baselines `baselines/` carries the evaluation outputs behind the paper's empirical claims, so each is reproducible without re-running anything: - `bm25-anchor*.json` — BM25 retrieval with and without the temporal filter - `bm25-rag-qwen3*.json` — vanilla BM25-RAG end-task baseline, including at matched decode budget - `v2-grpo-10000.json` — a **no-retrieval** system; this is the file behind the interval answer-leakage finding (overall EM 0.364, interval EM 1.000) - `v3-sft-{baseline,3hop}*.extracted.json` — 2-hop vs 3-hop reference-generator outputs and their seed replicas, behind the 3+-hop comparison (3-seed mean +0.051 ± 0.083 EM, item-level 95% CI [−0.040, +0.138]) ## Known issues **Interval questions leak their answer under the submitted evaluation protocol.** Every interval question sets `t_query` to the gold answer year (864/864 interval items), and prompts that render `` therefore make the interval slice answerable by copying the timestamp. Interval is 9.92% of the benchmark. The gold subgraphs are unaffected — this is a protocol defect, not an annotation defect. **Do not render the time tag on interval questions, and do not read interval EM = 1.000 as a capability result.** Full detail, scope per split, and the corrected protocol are in `v1.0.1-addendum.md`. **Naturalness ratings are not reliable between annotators** and should not be used as a quality signal; see the paper's Human Validation section. **Only the test split is human-validated.** Validation covers the 500-question pilot plus a 120-item blind round (116 scored) drawn from the test split. The 6,096-question training split carries automatically generated labels that no human has checked. This is defensible for the benchmark's intended use — every number in the paper is computed on test, and none of the reference baselines trains on the released split — but if you fine-tune on `train`, you are training on unaudited labels. Treat the pipeline's construction guarantees, not human review, as what backs that split. **Question surface forms come from nine templates** — three for point-in-time, two each for before/after, interval and sequence — parameterised over anchor entity, relation chain and reference year. Linguistic diversity is therefore low by construction, and TempBench measures temporal *retrieval*, not robustness to paraphrase. Do not read a score here as evidence about natural-language variation. (Full template inventory and parameters in `code/benchmark-design-decisions.md`.) **The source KG is point-in-time, so `valid_at` reduces to exact-year equality.** `tkgl-smallpedia` carries discrete-timestamp facts (`t_start == t_end`), which means the composability operator ⊕ is exercised here in its degenerate case: checking that each hop is valid at the query year. The operator is defined for interval facts and admits chains that a plain interval intersection rejects, but **the released benchmark does not test that generality** — a validity-window TKG (YAGO3, ICEWS) would. Treat results here as evidence about time-valid retrieval on point-in-time graphs, and not yet as evidence about general temporal-chain reasoning. ## Open questions this release does not answer Stated plainly, because they bound what a number on TempBench means. **Whether the benchmark discriminates across retriever families is not yet established.** Every system evaluated in the paper is a variant of one BFS + BM25 retriever — the same graph-traversal family used to *construct* `S*` by shortest-path retrieval under temporal constraints. High CCR may therefore partly reflect that methodological alignment rather than retrieval quality, and no heterogeneous system has been run: no dense retriever, no published temporal-RAG system, no parametric-LLM baseline. This is the most important open question about the resource, and it is squarely future work. The metrics ship here (`code/tempbench_eval.py`) specifically so that anyone can run a system from a different family and report TRP/CCR without going through the reference implementation — which is the cheapest path to settling it. Results from an unrelated architecture are more informative about the benchmark than anything the reference retriever can produce, and contributions are welcome. **A validity-window edition (v2).** Extending construction to interval-fact TKGs would exercise ⊕ in its general form and test whether the retrieval findings survive outside exact-year matching. When porting, check the source data's closed-interval convention against `valid_at`'s semantics first — the two do not always agree. ## Provenance and licence Built from `tkgl-smallpedia` in [TGB 2.0](https://arxiv.org/abs/2406.09639) (Gastinger et al., NeurIPS 2024 Datasets and Benchmarks), which is derived from Wikidata. Questions are generated algorithmically by an extended [TimelineKGQA](https://arxiv.org/abs/2501.04343) generator; gold, distractor and stale-fact subgraphs are built by deterministic graph procedures and then human-validated. **TempBench is released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).** Attribution is the only condition: cite the paper below. What TempBench draws from upstream is Wikidata **structured data** — triples and entity labels — which is CC0, so nothing upstream imposes share-alike here. (TGB 2.0's Appendix B lists `tkgl-smallpedia` under the "Wikidata License": CC0 for the property and lexeme namespaces, CC BY-SA for other text; TempBench uses the former. TGB's `tkgl-icews`, which carries a research/education-only licence, is **not** used here.) The question generation, subgraph construction, functional-negative flags and annotation protocol are this work's own contribution and are what CC BY 4.0 covers. This matches the paper itself, which is published open access under CC BY. ## Citation ```bibtex @inproceedings{caldarini2026tempbench, title = {{TempBench}: A Temporal Knowledge-Graph QA Benchmark with Per-Question Gold Subgraphs and Retrieval-Quality Metrics}, author = {Caldarini, Guendalina}, booktitle = {Proceedings of the 35th ACM International Conference on Information and Knowledge Management (CIKM '26)}, year = {2026}, doi = {10.1145/3799682.3840181} } ``` Dataset DOI: [`10.57967/hf/10071`](https://doi.org/10.57967/hf/10071) (revision `ad8ea76`).