README.md

---

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<n<10K
---


# TempBench

A multi-hop temporal knowledge-graph question-answering benchmark built so that
**retrieval quality is measurable independently of answer accuracy**.

8,710 questions over a Wikidata-derived temporal knowledge graph. Every question
ships a gold supporting subgraph and two typed negatives, across a 4×3
temporal-operator × hop-complexity matrix.

Accompanies:

> 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 `<t={t_query}>` 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`).