Datasets:

Guen
/

tempbench

EN / IT — this packet is bilingual. An Italian translation is included as annotation-guidelines-IT.md. Work from whichever you prefer — both raters receive both. In case of any discrepancy, this English version governs, and the label values (VALID, INVALID, AMB, NO_DATE, …) stay in English in both, because they are typed verbatim into the spreadsheet.

Questo pacchetto è bilingue: la traduzione italiana è in annotation-guidelines-IT.md. In caso di discrepanza prevale la versione inglese.

1. Introduction and Task Overview

What is TempBench?

TempBench is a benchmark dataset for evaluating temporal multi-hop reasoning over evolving knowledge graphs. The full benchmark holds 8,710 questions built from Wikidata (the tkgl-smallpedia subset), stratified by reasoning complexity — 1-hop (single relation), 2-hop (two-relation chain) and 3+-hop (three or more) — and split 70/10/20 into train/dev/test.

You are annotating a 120-question sample of the test split, not the whole benchmark. The sample is stratified across complexity levels and the four temporal-operator types, and it deliberately excludes every question used in an earlier validation round.

Each question is grounded in a specific temporal query point (t_query), requiring systems to retrieve the correct answer as it existed at that precise moment in time. This differs from static QA benchmarks by demanding both multi-hop reasoning capability and temporal validity awareness.

Your Annotation Task

You are being asked to quality-check the benchmark questions, not to create them. Your role is to verify that each question is well-formed, answerable, and correctly labeled. Specifically, you will make two independent judgments for each question:

Question Validity — Is this a clear, unambiguous question with a verifiable correct answer?
Temporal Validity — Is the temporal query point (t_query) correct and consistent with the question?

This quality-checking step is critical. Even small errors in the benchmark (ambiguous questions, incorrect timestamps, or mislabeled hop counts) can introduce noise that degrades both baseline performance and downstream analysis. Your 120 judgments, compared against the other rater's, are what let the paper report an honest reliability estimate for the benchmark's labels.

Time Estimates and Workload

Scope of this round: 120 questions. (An earlier version of this document described a 1,500-question / ~125-hour programme. That was the original plan and it is not what you are being asked to do.)

Your file contains 120 questions: 50 one-hop, 50 two-hop, 20 three-or-more-hop.

Annotation time varies by complexity:

1-hop questions: ~2–3 minutes each → 50 items ≈ 2 hours
2-hop questions: ~4–5 minutes each → 50 items ≈ 4 hours
3+-hop questions: ~7–10 minutes each → 20 items ≈ 3 hours

Total: roughly 9 hours of annotation, plus about an hour to read this document — call it 10 hours. It splits comfortably into two or three sittings; there is no requirement to do it in one pass, and rushing it defeats the point.

Payment: this is unpaid. There is no per-question rate and no agreement-linked bonus — deliberately, since paying for agreement would bias exactly the number we are trying to measure.

What you receive instead: a named acknowledgement in the paper (CIKM 2026, Rome). To be direct about why it is an acknowledgement rather than authorship — the conference has frozen the author list at the accepted version and no additions are permitted at camera-ready, so authorship is not something we are able to offer, whatever the merits. If you would rather not be named, say so and we will thank you anonymously instead.

How your work is used: the two raters' labels are compared to produce an inter-annotator agreement statistic (Cohen's κ). The paper will state plainly that both raters are non-authors, that the passes were blind and independent, and that the work was uncompensated.

2. Annotation Interface

There is no web portal — you work in a spreadsheet. You have been sent one workbook, rater_A_validation_120.xlsx or rater_B_validation_120.xlsx (120 rows; the two files contain the same items in the same order).

Open it in Excel, LibreOffice or Google Sheets, fill one row per question, and return it as .xlsx — please keep the workbook format rather than exporting to CSV or pasting into another tool. The judgment columns are dropdowns, and saving to CSV throws them away; the labels then come back free-typed and have to be normalised by hand before they can be compared.

⚠️ Fill in the Annotation sheet, not the Instructions sheet. The workbook has two tabs; the second one is the data. Grey columns are given — please leave them as they are. Yellow columns are yours. The judgment columns are dropdowns, so pick from the list rather than typing, which keeps the labels machine-readable.

Work independently. The two raters have identical files on purpose: the whole point of this round is to measure how far two people agree without conferring. Please do not discuss items with the other rater, and do not compare files, until both are returned.

Each row arrives with these fields pre-populated:

Column	Content
`row`	1–120, your working order
`question_id`	Unique identifier, e.g. `q_004664`
`question`	The natural-language question — this is what you evaluate
`t_query`	The temporal reference point the question is asked "as of"
`stated_answer`	The answer the benchmark records — you judge whether it is right
`stated_hops`	The hop count the benchmark claims: `1`, `2` or `3+`. This is what you check for `WRONG_HOP` — count the relations the question actually requires and compare
`supporting_chain`	The gold evidence chain, one line per hop, as `subject -[relation]-> object (years)`. This is what the answer is supposed to follow from — use it to verify `stated_answer` and to count hops

Two notes on reading the worked examples in §4.
They print the chain in a compact one-line notation (a:REL→b:REL→c) because they were written before the spreadsheet existed. Your file shows the same information one hop per line, with validity years. A 1-hop cell looks like this:
Daniel Kahneman -[employer]-> University of British Columbia (1983)
and a 2-hop cell like this — two lines in the one cell, the object of the first hop becoming the subject of the second:
Leo Königsberger -[doctoral student]-> Karl Bopp (1902)
Karl Bopp -[doctoral advisor]-> Moritz Cantor (1902)
Count the lines to check stated_hops. If a cell looks like one line when you expect more, widen the row — Excel hides the rest.
The examples also show a "Supporting Facts" row of explanatory prose. Your file does not have one — the chain is your evidence. Wherever these guidelines say to check something "against the supporting facts", read it as against supporting_chain.

Columns you fill in:

judgment_A_validity — VALID or INVALID
error_code_if_invalid — if INVALID: AMB, UNANS, WRONG_HOP, UNNATURAL, or WRONG_ANS
judgment_B_temporal — CORRECT, WRONG_DATE, or NO_DATE

naturalness_1_to_5 — how much the question reads like something a person would actually write. Judge the wording only, never whether the answer is right. All five points are anchored:


1	Barely parseable; you had to re-read it to work out what is being asked
2	Understandable but clearly machine-made — stacked possessives, robotic template phrasing
3	Awkward but usable; a person might write this in a hurry
4	Reads naturally, with a small stiffness or oddity
5	Indistinguishable from a question a person would ask

Long is not the same as unnatural: a genuinely complex 3-hop question can be a 4 or 5 if the phrasing is clean.

low_confidence — put y if unsure, leave blank otherwise
notes — optional free text for edge cases

Unsure about an item? Mark low_confidence = y, add a note, and move on. Do not agonise — flagged items are reviewed separately, and a fast honest "unsure" is more useful than a slow guess.

2a. No AI assistance — please read, this one matters

Do not use ChatGPT, Claude, Copilot, Gemini, or any other AI assistant to produce or check these labels. Not for the judgments, not for looking up whether a fact is true, not for drafting notes.

This is not a general policy preference. This benchmark exists to measure whether AI systems retrieve time-valid evidence correctly. If AI output is used to validate it, the validation measures the same system it is meant to check, and the result is worthless — the paper would be reporting a machine agreeing with itself. A human judgment that is uncertain is far more valuable here than a confident machine one.

Searching Wikipedia or Wikidata directly is fine and encouraged. Using a search engine is fine. Asking a chatbot is not.

Please confirm in your reply when you return the file:

"I completed this annotation without using AI assistants, and the judgments are my own."

Two practical notes so this is not just an honour system:

A small number of items in your file are known-bad questions included deliberately as attention checks. They are there to confirm the task was engaged with, not to catch you out.
Please note roughly when you start and finish each working session (a line in your reply is enough — "Tue evening, ~1h, rows 1–40"). Per-item timing helps distinguish careful work from fast work, and protects you as much as it protects the data.

3. Core Annotation Task

Your annotation task involves two independent but complementary judgments. Complete them in this order for each question.

Judgment A: Question Validity

Ask yourself: Is this a well-formed, answerable question that requires the stated number of hops and has a unique, verifiable correct answer at t_query?

VALID — Select this if:

The question is grammatically clear and unambiguous
The question asks for a single, well-defined answer (not multiple possible answers)
The stated hop count matches the complexity of the reasoning required
The gold answer is correct given the supporting KG chain at the stated t_query
The question does not rely on present-day information that was not true at t_query

INVALID — Select one of these error codes if the question fails any of the above criteria:

Error Code	Definition	Example
AMB	Ambiguous — Multiple valid answers exist at t_query	"Who was the leader of Germany in 2010?" (could be Merkel but her title varied; too vague)
UNANS	Unanswerable — No answer exists in Wikidata at t_query	"What was the stock price of Company X on 1980-01-01?" (historical price data not reliably in Wikidata)
WRONG_HOP	Incorrect hop count label — The actual reasoning required differs from the stated label	Question labeled "2-hop" but only requires 1 hop to answer
UNNATURAL	Grammatically unnatural or incomprehensible — The question is difficult to parse or uses awkward phrasing	"What did person X have entity Y relation-wise in 2005?" (unclear, ungrammatical)
WRONG_ANS	Gold answer is incorrect — The provided answer does not match the KG chain or does not satisfy the question	Question asks "Who won?" but gold answer lists the runner-up

For each question, select the primary error code — the most significant issue. (A question may have multiple problems; flag the most critical one.)

Judgment B: Temporal Validity

Ask yourself: Is the stated t_query correct and consistent with what the question is asking?

CORRECT — Select this if:

The t_query timestamp matches the temporal anchor in the question (e.g., "in 2008" → t_query = 2008-XX-XX is reasonable)
For questions without an explicit year but asking about a state or role (e.g., "Who was CEO in the year X?"), the t_query is set to a valid date in that year
For "stale facts" (facts that remain valid at present, like "was born in"), the t_query is set appropriately and the answer is correctly retrieved at that point

WRONG_DATE — Select this if:

The t_query does not align with the question's temporal anchor (e.g., question says "in 2015" but t_query = 2010-01-01)
The timestamp is off by a significant amount (days matter for time-sensitive events, but one month off in historical queries is typically acceptable; use judgment)
The t_query is set after a fact became invalid (e.g., asking about someone's role as CEO at a date after they left office)

NO_DATE — Select this if:

The question has no temporal anchor at all and should not be in a temporal benchmark (e.g., "Who founded Company X?" with no time reference)
The t_query is missing or unpopulated (data entry error)

4. Worked Examples

The following six detailed examples (two per complexity level) illustrate correct and incorrect annotations.

Example 1a: 1-Hop VALID

Field	Value
Question ID	tgb-001-1hop-001
Question	Who was the mayor of Paris in 2010?
t_query	2010-06-15
Stated Hop Count	1
Gold Answer	Bertrand Delanoë
Supporting KG Chain	paris:MAYOR→bertrand_delanoë (2001-2014)
Supporting Facts	Bertrand Delanoë served as Mayor of Paris from 2001 to 2014.

Annotation Decision:

Judgment A (Validity): VALID
- The question is clear and unambiguous.
- It asks for a single entity (the mayor) at a specific time.
- The hop count is correct: 1 hop (paris → mayor → person).
- The gold answer (Bertrand Delanoë) is correct at t_query.
- The question is natural and answerable.
Judgment B (Temporal Validity): CORRECT
- The question specifies 2010; t_query is set to June 2010.
- Bertrand Delanoë was mayor throughout 2010 (served 2001–2014).
- The timestamp is within the valid range.

Example 1b: 1-Hop INVALID

Field	Value
Question ID	tgb-001-1hop-002
Question	Who is the current mayor of Paris?
t_query	2020-01-15
Stated Hop Count	1
Gold Answer	Anne Hidalgo
Supporting KG Chain	paris:MAYOR→anne_hidalgo (2014-present)
Supporting Facts	Anne Hidalgo became Mayor of Paris in 2014 and is the current mayor.

Annotation Decision:

Judgment A (Validity): INVALID — Error Code: AMB
- The question uses "is the current mayor," a relative temporal anchor — it points at "now", not at a fixed historical point.
- Which "now"? Read against t_query (2020) the answer is Anne Hidalgo; read as "today" it is whoever holds the office when the question is asked. The question admits more than one defensible answer, which is exactly the AMB criterion.
- Note the code carefully. This is not UNNATURAL: the sentence is perfectly grammatical and reads like something a person would say. UNNATURAL is for wording a fluent speaker would not produce. Judge the two separately — a question can be fluent and ambiguous at once, and this one is.
- Fix: Reword as "Who was the mayor of Paris in 2020?" to pin the temporal reference.
Judgment B (Temporal Validity): CORRECT
- t_query = 2020 is a valid date and Anne Hidalgo was indeed mayor then, so the timestamp is right.
- The two judgments are independent. A question can fail Judgment A and still pass Judgment B — record what you actually see in each, and do not let one verdict drag the other along.

Example 2a: 2-Hop VALID

Field	Value
Question ID	tgb-002-2hop-001
Question	Who was the spouse of the CEO of Microsoft in 1998?
t_query	1998-06-15
Stated Hop Count	2
Gold Answer	Melinda Gates
Supporting KG Chain	microsoft:HAS_CEO→bill_gates:SPOUSE→melinda_gates
Supporting Facts	Bill Gates was CEO of Microsoft from 1975 to 2000. Bill Gates married Melinda French in 1994 and remained married through 1998.

Annotation Decision:

Judgment A (Validity): VALID
- The question is clear and asks for a single, well-defined answer.
- Hop count is correct: 2 hops.
- Gold answer is correct: Melinda Gates was married to Bill Gates, who was CEO in 1998.
Judgment B (Temporal Validity): CORRECT
- t_query=1998-06-15 aligns with the question's "in 1998."
- Bill Gates was CEO at this time, and Melinda was his spouse.

Example 2b: 2-Hop INVALID

Field	Value
Question ID	tgb-002-2hop-002
Question	What country was the birthplace of the spouse of the CEO of Apple in 2005?
t_query	2005-06-15
Stated Hop Count	2
Gold Answer	United States
Supporting KG Chain	apple:HAS_CEO→steve_jobs:SPOUSE→laurene_powell:BIRTHPLACE→united_states
Supporting Facts	Steve Jobs was CEO of Apple in 2005. Steve Jobs married Laurene Powell in 1991. Laurene Powell was born in the United States.

Annotation Decision:

Judgment A (Validity): INVALID — Error Code: WRONG_HOP
- The question asks for the birthplace of Steve Jobs' spouse.
- The chain is: Apple → CEO (Steve Jobs) → Spouse (Laurene Powell) → Birthplace (US).
- This is actually 3 hops, not 2 hops as labeled.
- The stated hop count is incorrect.
Judgment B (Temporal Validity): CORRECT
- t_query=2005-06-15 aligns with the question's temporal anchor (2005).
- Steve Jobs was CEO at this time.

Example 3a: 3+-Hop VALID

Field	Value
Question ID	tgb-003-3hop-001
Question	In what year was the employer of the winner of the 1992 Nobel Prize in Physics founded?
t_query	1992-12-10
Stated Hop Count	3+
Gold Answer	1954
Supporting KG Chain	nobel_physics_1992:AWARDED_TO→georges_charpak:EMPLOYER→cern:INCEPTION→1954
Supporting Facts	Georges Charpak was the sole recipient of the 1992 Nobel Prize in Physics. He worked at CERN. CERN was founded in 1954.

Annotation Decision:

Judgment A (Validity): VALID
- The question is long but grammatically sensible and asks for one well-defined answer (a year).
- The chain answers the question that was actually asked. Trace it: prize → laureate → employer → founding year. Each hop is one the question requires, and the endpoint (1954) is the gold answer.
- stated_answer (1954) is exactly where the chain ends. Check this every time — if the stated answer and supporting_chain disagree, the code is WRONG_ANS, however plausible the answer looks on its own.
- The laureate is unambiguous: 1992 Physics was a sole award. Had the prize been shared, "the winner" would admit more than one referent and the question would be AMB.
- Hop count 3+ is right: three relations are traversed.
Judgment B (Temporal Validity): CORRECT
- t_query = 1992-12-10 matches the question's anchor (1992).
- Note the anchor fixes which laureate is being asked about, not the founding year — CERN's founding date does not change with t_query.

Example 3b: 3+-Hop INVALID

Field	Value
Question ID	tgb-003-3hop-002
Question	What is the nationality of the child of the colleague of the mentor of the researcher who published a paper on topic X in 2015?
t_query	2015-06-15
Stated Hop Count	3+
Gold Answer	[Not clearly specified]
Supporting KG Chain	[Complex, unclear chain with multiple undefined relations]
Supporting Facts	A researcher published on topic X in 2015... [details vague]

Annotation Decision:

Judgment A (Validity): INVALID — Error Code: UNNATURAL
- The question is extremely convoluted and difficult to parse.
- The relations are not well-defined (what counts as a "colleague"? how many levels of mentorship?).
- The gold answer is vague or unclear.
- While technically there might be a chain of reasoning, the question is not naturally answerable without significant clarification.
Judgment B (Temporal Validity): CORRECT (but moot given the INVALID judgment)
- t_query aligns with the question's year (2015), but this is a secondary concern.

5. Edge Cases and Decision Rules

This section codifies rules for specific edge cases you are likely to encounter.

Entity Aliases

Situation: A question refers to an entity by one name (e.g., "Deutsche Bank") but the KG uses a different alias (e.g., "Deutsche Bank AG").

Rule: Treat these as the same entity. Do not mark as INVALID for this reason. Aliases are normal in Wikidata and knowledge graphs. If the supporting chain clearly refers to the same entity, the question is valid.

Example:

Question: "Who was the CEO of Deutsche Bank in 2010?"
KG Chain uses: "Deutsche Bank AG"
Judgment: VALID — the names refer to the same organization.

Implicit Timestamps

Situation: A question includes a temporal reference that is not a specific date (e.g., "during the financial crisis," "after the Cold War," "in the 1990s").

Rule: Check whether the t_query is reasonable and consistent with the implicit temporal anchor.

If t_query falls clearly within the historical period referenced, mark as CORRECT.
If t_query is before or well after the period, mark as WRONG_DATE.
If the implicit anchor is too vague to pin to a specific date (e.g., "in recent times"), mark as NO_DATE.

Example:

Question: "Who was the CEO of Lehman Brothers at the onset of the financial crisis?"
t_query: 2008-08-15
The financial crisis began in earnest in September 2008, so August 15 is slightly early but reasonable (the crisis had been building). Mark as CORRECT.

Currently-Valid Facts (Stale Facts)

Situation: A fact that remains valid "up to the present" (e.g., "Barack Obama was born in 1961"). The KG marks this with t_end = present or t_end = null.

Rule: Such facts are valid for any t_query up to the knowledge cutoff of the source graph, which is 2024 (the benchmark is built from a Wikidata snapshot covering 1900–2024). These are "stale facts" — once true, always true (e.g. birth dates, historical events).

If t_query is at or before 2024 and the fact is recorded as ongoing, mark CORRECT.
If t_query is after 2024, the graph cannot vouch for the fact — mark WRONG_DATE.

A note on the term. "Stale fact" here means permanently valid — an unfortunate name, and elsewhere in this project the same phrase means the opposite (a fact that was true but is out of date at the query time). In this document it always means the permanent kind.

Example:

Question: "In what year was Malala Yousafzai born?"
t_query: 2015-01-01 (or any past date)
Gold answer: 1997
KG fact: born 1997-07-12 (marked as permanent/unchanging)
Judgment: VALID and CORRECT — birth is a stale fact, valid at any t_query.

Multiple Roles Simultaneously

Situation: A person held multiple roles at the same time (e.g., "person X was both CEO and Chairman in 2008"). The question asks about one role, and the answer satisfies it.

Rule: Mark as VALID if the answer correctly satisfies the question, even if other roles also applied.

Example:

Question: "Who was the CEO of Company X in 2008?"
KG shows: person Y was CEO and Chairman in 2008.
Gold answer: person Y
Judgment: VALID — person Y was indeed CEO in 2008, even though they also held another title.

Successor Relationships and Constraints

Situation: A question includes a constraint like "before X became Y" or "after Z left position W". The t_query and answer must respect this temporal ordering.

Rule: Verify that the t_query does not violate the temporal constraint. If it does, mark as WRONG_DATE.

Example:

Question: "Who was the CEO of Microsoft before Steve Ballmer became CEO?"
Constraint: t_query must be before Ballmer's start date (which was January 2000).
If t_query = 1999-06-15 and gold answer = Bill Gates, this is CORRECT.
If t_query = 2005-06-15 (after Ballmer took over), this is WRONG_DATE.

Event-Based vs. State-Based Questions

Situation: Some questions ask about events ("When did X win the election?") while others ask about states ("Who was in office in year Y?"). These require different answer types.

Rule: Both types are valid. Distinguish between them, but do not penalize a state-based question for being state-based, or vice versa.

Example:

Question A: "When did John Smith become mayor of Boston?" (event)
- Answer type: date
- This is asking for a specific transition point.
Question B: "Who was the mayor of Boston in 1990?" (state)
- Answer type: person name
- This is asking for a snapshot at a point in time.

Both are valid for a temporal QA benchmark.

Retroactive Facts and Posthumous Awards

Situation: A fact is assigned retroactively (e.g., an award given posthumously, a historical reassignment of a role).

Rule: These are edge cases. Mark the question as VALID but use the free-text notes to flag the retroactive nature. This helps downstream analysis understand why the chain might appear unusual.

Example:

Question: "Who won the 2005 Fields Medal?" (not a real Fields Medal year, but for illustration)
Gold answer: mathematician Z (who passed away in 2010)
This is valid because the answer was determinable at t_query=2005, even if a later commemoration or official recognition occurred posthumously.
Judgment: VALID, and add note: "Retroactive award (if applicable)."

Questions with No Determinable Answer in Wikidata

Situation: The question is well-formed and clear, but Wikidata simply does not contain the information needed to answer it at t_query.

Rule: Mark as INVALID with error code UNANS (Unanswerable).

Example:

Question: "What was the closing stock price of Microsoft on January 1, 1990?"
Wikidata does not reliably contain historical stock price data.
Judgment: INVALID — UNANS. The question is natural and clear, but the data doesn't exist in the KG.

6. Quality Standards and Agreement

What the agreement number is for

Your labels and the other rater's are compared to produce an inter-annotator agreement statistic, which the paper reports as its evidence that the benchmark's labels are reliable.

Deliberately not stated here: the agreement level we hope for. Knowing the target would give you a reason, however unconscious, to guess at what the other rater would say rather than record what you actually think — which is precisely what the statistic is supposed to measure. A genuine disagreement between two careful readers is a useful result; an agreement manufactured by both of you aiming at a number is not.

So: judge each item on its own terms, flag uncertainty honestly, and let the number be whatever it is.

Double-Annotation Protocol

Every question in this round is double-annotated. Both raters receive the identical 120 items, and the comparison between the two label sets is the inter-annotator agreement the paper reports. There is no hidden subset and nothing is singled out for special scrutiny — the whole file is the measurement.

Work at your normal standard throughout. The one thing that matters is that the judgments are yours: please do not discuss items with the other rater or compare files until both are returned.

Handling Uncertainty

If you are unsure about a judgment, do not guess. Instead:

Put y in the low_confidence column.
Write a brief note in the notes column explaining what is unclear (e.g., "The supporting chain seems to have two possible endpoints; unclear which is primary").
Proceed to the next question.

Uncertain flags are helpful for identifying questions that may need clarification or rewriting. They are not penalized; uncertainty is better than confident errors.

Escalation and Questions

If you encounter a question that you believe has a fundamental error, or if you need clarification on the guidelines, do not spend excessive time on it. Put y in low_confidence, say what is wrong in notes, and move on. Flagged rows are reviewed separately.

For questions during annotation: reply to the email that sent you this document. ⚠️ Please note I am away 11–17 August with no computer, so messages in that window will not get an answer until the 18th. That is exactly why the rule above matters: if something is unclear, mark it low_confidence = y, add a note, and move on rather than waiting on a reply. Flagged items are reviewed separately and nothing is lost by flagging.

7. Annotator Checklist

Use this checklist for each question before submitting your annotation.

Pre-Annotation Checklist

I have read the question text carefully.
I understand what the question is asking (entity type, relation, temporal anchor).
I have read stated_answer and supporting_chain.
I have checked whether supporting_chain actually leads to stated_answer.

Judgment A: Validity — Checklist

The question is grammatically clear and natural.
The question asks for a single, well-defined answer (not multiple possible answers).
The stated hop count matches the complexity of the reasoning.
stated_answer is correct according to supporting_chain.
The question does not depend on present-day information unknown at t_query.
If I'm marking INVALID, I've selected the single most significant error code.

Judgment B: Temporal Validity — Checklist

The t_query is populated (not missing or null).
The t_query matches the temporal anchor in the question.
The gold answer is true/valid at t_query (not before or after).
For implicit temporal references (e.g., "during the crisis"), I've verified t_query is reasonable.
I've selected one of: CORRECT, WRONG_DATE, or NO_DATE.

Confidence and Notes Checklist

If I was unsure, I put y in low_confidence (leave blank when confident — there is no middle setting).
If I flagged low_confidence, I added a note saying what was unclear.
If I hit an edge case (retroactive facts, aliases, multiple roles), I documented it in notes.

Per-Question Checklist

judgment_A_validity filled, plus error_code_if_invalid if the verdict was INVALID.
judgment_B_temporal filled.
naturalness_1_to_5 filled.

Before You Return the File

All 120 rows have Judgment A, Judgment B and a naturalness score.
I worked on the Annotation sheet, not the Instructions sheet.
I did not confer with the other rater.
My reply includes the no-AI confirmation sentence (§2a) and a rough note of when I worked.

8. Glossary

This section defines key terms used throughout the guidelines.

Anchor Entity The initial entity in a multi-hop question from which relations are traversed. In "Who was the spouse of the CEO of Microsoft in 1998?", the anchor entity is Microsoft.

Composability The property that each hop in a multi-hop chain builds on the previous result. A 3-hop question is composable if each intermediate result (1-hop, 2-hop) is a valid and retrievable entity.

Gold Answer — in your spreadsheet this is the column stated_answer. The two terms mean the same thing; "gold answer" is the phrase these guidelines use in prose, stated_answer is the column header. Note the column name says stated, not correct: judging whether it is correct is your task.

The correct, ground-truth answer to a question, as verified by the KG chain. For example, if the question is "Who was the CEO of Apple in 2010?", the gold answer is "Steve Jobs."

Hop Count The number of relations traversed in the KG to answer a question. A 1-hop question requires traversing one edge. A 2-hop question requires two edges. Multi-hop reasoning chains are more complex and require composing multiple steps.

Inter-Annotator Agreement (IAA) A statistical measure of how often two independent annotators make the same judgment. Higher agreement indicates the benchmark's labels are clear and unambiguous.

Multi-Hop Chain A sequence of relations in the knowledge graph that together answer a question. For example: Apple → (HAS_CEO) → Steve Jobs → (HAS_SPOUSE) → Laurene Powell is a 2-hop chain ending in the spouse's name.

Stale Fact A fact that, once established, does not change over time — birth dates, founding dates, historical events. Valid for any t_query after the fact occurred and at or before the graph's 2024 cutoff (see §5, which also explains why the name is misleading: here it means permanently valid, the opposite of what "stale" means elsewhere in this project).

Supporting Chain The path through the knowledge graph (Wikidata) that justifies the gold answer. This is shown to you for verification and should match the question and t_query.

Supporting Facts Explanatory prose that appears in the §4 worked examples only. It is not a column in your file — your evidence is supporting_chain. Where these guidelines say "supporting facts", read supporting_chain.

t_query The temporal query point — a specific timestamp (e.g., 2008-06-15) at which the question asks for the answer. This is the "slice in time" being queried.

Temporal Knowledge Graph A knowledge graph where facts are associated with temporal validity windows (t_start, t_end). Unlike static KGs, temporal KGs explicitly track when facts are true, enabling time-aware reasoning.

Temporal Validity Window The time range during which a fact is true. For example, "Steve Jobs was CEO of Apple" has a temporal window from 1997 to 2011 (approximately). Answers must be checked against this window.

Unambiguous Answer A single, well-defined answer to a question that does not have competing alternatives at t_query. For example, "Who was the only mayor of Boston in 1995?" should have a unique answer (or clearly none, if there was an interregnum).

Validity The property that a question is well-formed, clear, answerable, and grounded in the benchmark KG. Valid questions have unambiguous answers and correct hop counts.

Wikidata A large, multilingual, community-edited knowledge base containing structured facts about entities (people, organizations, events, etc.) and their relationships. TempBench is constructed from a subset called tkgl-smallpedia.

Conclusion

Thank you for carefully annotating these questions. Your work is essential to creating a high-quality benchmark that will be used to evaluate temporal reasoning systems for years to come. Please work systematically, flag uncertainties, and do not hesitate to reach out if you have questions.

Good luck, and thank you for your diligence!

Document Version: 1.1 | Last Updated: 10 August 2026