Harnessing Temporal Databases for Systematic Evaluation of Factual Time-Sensitive Question-Answering in LLMs
Authors: Soyeon Kim
Jindong Wang
Xing Xie
Steven Euijong Whang
Venue: ICLR 2026 Poster (2026)
Keywords: Large Language Models Benchmarking and Evaluation
Time-Sensitive Question-Answering
Primary area: datasets and benchmarks

Abstract: Facts change over time, making it essential for Large Language Models (LLMs) to handle time-sensitive factual knowledge accurately and reliably. Although factual Time-Sensitive Question-Answering (TSQA) tasks have been widely developed, existing benchmarks often face manual bottlenecks that limit scalable and comprehensive TSQA evaluation. To address this issue, we propose TDBench, a new benchmark that systematically constructs TSQA pairs by harnessing temporal databases and database techniques, such as temporal functional dependencies, temporal SQL, and temporal joins. We also introduce a new evaluation metric called time accuracy, which assesses the validity of time references in model explanations alongside traditional answer accuracy for a more fine-grained TSQA evaluation. Extensive experiments on contemporary LLMs show how TDBench enables scalable and comprehensive TSQA evaluation while reducing the reliance on human labor, complementing current TSQA evaluation approaches that largely center on Wikipedia/Wikidata by enabling LLM evaluation on application-specific data.

Published as a conference paper at ICLR 2026
HARNESSING TEMPORAL DATABASES FOR SYSTEMATIC EVALUATION OF FACTUAL TIME- SNSSTIIVE QUESTION- ANSWERING IN LLMS
Soyeon Kim!*, Jindong Wang", Xing Xie and Steven Euijong Whang'
1 KAIST, (purplehibird, swhang) ) @kaast.ac...
2 William & Mary, jdw@ wm. edu
3 Microsoft Research Asia, xing x e@mi crosoft. com
ABSTRACT
Facts change over time, making it essential for Large Language Models (LLMs) handle time-sensitive factual knowledge accurately and reliably. Although factual Time-Sensitive Question-Answering (TSQA) tasks have been widely developed, existing benchmarks often face manual bottlenecks that limit scalable and com- prehensive TSQA evaluation. To address this issue, we propose TDBench, a new benchmark that systematically constructs TSQA pairs by harnessing temporal databases and database techniques, such as temporal functional dependencies, tem- poral SQL,, and temporal joins. We also introduce a new evaluation metric called time accuracy, which assesses the validity of time references in model explanations alongside traditional answer accuracy for more fine-graines TSQA evaluation. Extensive experiments on contemporary LLMs show how TDBench enables scal- able and comprehensive TSQA evaluation while reducing the reliance human labor, complementing current TSQA evaluation approaches that largely center on Wikiipedia/Wikidtaa by enabling L.LM evaluation application-specifcc data.
INTRODUCTION
Facts are not static they evolve over time (Jensen et al. 1996). As Large Language Models (LLMs) increasingly integrated into real-world applications (Jiao al. 2024), their abilities manage time-sensitive factual knowledge have become crucial for ensuring both accuracy and reliability (Yuan) al. 2024). For example, when asked, "Who is the current president of the U.S.?", an LLM must accurately distinguish between past and present presidents to avoid providing outdated or incorrect responses, which can mislead users and undermine trust (Huang et 2024).
To assess LLMs' abilities to handle time-sensiie sensitiee factual knowledge, many Time-Sensitive Question Answering (TSQA) benchmarks have been developed (Chen al. [022]] Dhingra al.) 2022. Kasai et al. 2023 Tan et al. [2033] Vu et al.] 2023 Kim et al.) 2024 Zhao et al. [024]] 7hu et al.) 2025). These benchmarks primarily assess two LLM capabilities: (1) temporal reasoning, the ability to understand various temporal contexts within questions (e.g.. "before 2019", "during the 5th Winter Olympics") and (2) temporal alignment, the ability to provide answers that reflect current factual knowledge in the real world (e.g., being aware of the current president).
However, existing factual TSQA benchmarks often lack a systematic design, relying heavily on manual efforts for benchmark construction and maintenance. Assessing temporal reasoning ability re- quires creating diverse temporal contexts such as "before 2019" or "during the 5th Winter Olympics",
which typically relies human writers (Kasai al. 2023 Wei al. 2023 Vu et al. 2023). Using predefined question templates can automate part of this process (c.g., "before [YEAR] "), but it still requires human efforts design templates and often uses small, fixed set that compromises diversity (c.g., 9 templates used in Dhingra el al. (2022), 16 used in Margatina et al. (2023); see more details in Sec. 5). In addition, the evolving nature time-sensitive knowledge requires continual updates of TSQA benchmarks, posing a benchmark maintenance challenge. For instance, Real Time@A (Kasai)
ct al. 2023) manually curated weekly news (e.g., CNN) to incorporate new world facts, but updates have recently ceased due to the high costs of manual curation (Uddin et al. 2024).
WWrk done during internship Microsoft Research Asia.

---

Published as a conference paper at ICLR 2026
TSQA Construction
! Knowledge Selection for TSQA pairs
(2 Temporal SQL Query Generation
3 Conversion to
Natural Language
Schema
commiry, rale nome
SELECT
SQL Query
country
Temporal
FROM My08
role gender
Functional
WHERE country- 'Sedenn'
SQL-to-text text via LLM
Dependency
AND "Monahh
Question
Temporal Database
start
<country>, <role> determines <hames
(NOM() BETWEEN
start AND end}
Run query to database
TSQA Pairs
Answer
end
Encode temporal context
time point
TSQA Evaluation
Question:
Who is currently serving as the monarch of Sweden??
Gold Answer: (country: 'Sweden', name: 'Carl XVI Gustaf, start: '1973-9915 ...)
("as of 2025)
LLM Response ("actual response of Gemms2-278):
Since June 2016, Carl XVI Gustaf has been the current monarch of Sweden.
Answer:
Time: X
Figure 1: Overview of TDBench framework. TDBench systematically constructs Time-Sensitive
QA (TSQA) pairs by (1) selecting factual knowledge via temporal functional dependencies, (2) generating temporal SQL queries with diverse temporal contexts, and (3) converting queries into natural language QA pairs using an LLM and the database. During evaluation, TDBench automatically verifies both the final answer and time references in LLM responses, capturing cases where the model hallucinates in the explanation despite providing the correct answer. TDBench supports diverse TSQA scenarios, including temporal alignment, temporal reasoning. and implicit multi-hop questions.
To tackle these manual bottlenecks, propose TDBench, benchmarking framework designed for a more systematic TSQA evaluation. Unlike existing TSQA benchmarks, TDBench eliminates the need for human labor in designing temporal contexts question templates. Instead, TSQA pairs are automatically generated from an input data source, namely, temporal databases extensions of conventional databases that are well-established for managing time-sensitive knowledge (Jensen et al. 1996). These temporal databases can be user-defined or sourced from general platforms like Wikipedia, allowing users to flexibly construct TSQA benchmarks based on their own interests.
Our key idea is to utilize database techniques for automatic TSQA construction, namely, Temporal Functional Dependencies (TFDs), temporal SQL, and temporal joins. Fig. Dillustrates TDBench's 'ss 3-step process: (1) selecting factual knowledge suitable for TSQA tasks by leveraging TFDs, which pinpoint attributes whose values can be uniquely determined at any timepoint (e.g., a country's president at a given time); (2) generating temporal SQL queries to encode diverse temporal contexts, leveraging Allen's 's interval algebra (Allen) 1983) to cover 13 mutually exclusive and exhaustive temporal relations via rich temporal SQL operators (e.g., BETWEEN, DATEDIFF); and (3) translating SQL queries into natural language QA pairs using an LLM and the database. Through these steps, TDBench simplifies TSQA construction and maintenance; updating the database content with temporal changes (e.g., new presidents) automatically refreshes the corresponding QA pairs. We also show how temporal joins increase TSQA complexity by generating implicit temporal contexts (e.g.. "during the 5th Winter Olympics"), which can test LLMs' advanced reasoning abilities such as event-event reasoning (Tan et al. 2023) without typically required manual curation [Tan et 2023).
Alongside the QA construction, we introduce a new metric called time accuracy to support a more fine-grained TSQA evaluation. During QA tasks, LLMs can often hallucinate in explanations while providing correct answers (Ji et al. 2023 Oh et al. (024)). We find this phenomenon manifests in TSQA tasks inaceurate time references, as illustrated in Fig. [T] model correctly identifies the current monarch of Sweden, but hallucinates his start date. Since traditional answer-only evaluations cannot capture such errors, we use time accuracy to verify the validity of time references as well as final answers, enabling automatic verification with SQL-based temporal constraints.
Extensive experiments demonstrate how TDBench enables a scalable and comprehensive TSQA evaluation while reducing human labor. We assess several popular LLMs GPT-3.5 (OpenAl 2022), GPT-4 (OpenAl 2023), GPT-4o (OpenAl 2024). Llama3.1-70B (Dubey et al. 2024). Mixtral- 8x7B (Jiang et al., 2024), 2em7 (Team al. 2024), Qwen2-728 (Bai et al.) 2023). and Granite3. I-BB (Granite Team 2024) across various TSQA tasks, including temporal alignment, temporal reasoning, and multi-hop settings with implicit temporal contexts.
2

---

Published as a conference paper at ICLR 2026
Our benchmark offers several key distinctions and findings. First, TDBench moves beyond previous Sikipedii/Wikidatt--cooo TSQA evaluation by leveraging domain domain-specific databases (c.g., medical, legal) not covered by public platforms. Second, time accuracy metric reveals that LLMs largely hallucinate time references despite providing correct answers (on average 21.7% in our experiments), uncovering a reliability issue of L.LMs in TSQA. Third, TDBench's SQL-generated temporal contexts encompass 13 diverse constraint types compared to 4-6 in other TSQA benchmarks, identifying LLMs' temporal blind spots that are not clearly captured by existing benchmarks. Code and data are publicly available at: https://github.c wttp://oo//o///////ooooooo
Summary of Contributions (I) We propose TDBench, a new TSQA benchmark that systematically constructs QA pairs without human labor by hamnessing temporal databases and database techniques. (2) We introduce a time accuracy metric to assess the validity of temporal references in model explanations, enabling more reliable TSQA evaluation beyond answer correctness alone. (3) Extensive experiments demonstrate that TDBench provides comprehensive TSQA evaluation through diverse SQL-generated temporal questions and complements prior Wikkiedia/Wikidttt-eenttte benchmarks.
BACKGROUNDS
Temporal Database Temporal databases (Jensen & Snodgrass 2018) extend conventional relational databases with the concept of time. Both types of databases store structured data, where information organized into a fixed schema with predefined attributes (i.e., columns) and corresponding values (i.e., rows or tuples). While conventional relational databases typically retain only the latest state of each entity, temporal databases specifically designed to capture time-narying information by storing historical states with associated timestamp attributes. In this work, we focus temporal databases following the uni-temporal data model, which stores the validity interval of each row using two timestamp attributes (e.g., start and end in Table D. These temporal databases are widespread across many critical domains (see Sec. [A.I] and we show how the structured nature of these data enables systematic TSQA benchmarking.
Table 1: An example temporal database Leader(country, role, gender, name, start, end).
country
role
gender
name start
end
USA
President
M
Bush 2001 2009
USA
President
M
Obama
2009 2017
U.K.
Monarch
F
Elizabeth 1952 2022
Temporal Functional Dependency and Join Temporal databases possess two unique properties:
1) temporal functional dependencies (TFDs) and 2) temporal joins. TFDs adapts the notion of Functional Dependencies (FDs) from conventional databases to the time dimension] While an FD X + Y requires the values of X to uniquely determine the values of Y across the entire relation,
TFD X S Y requires this dependency to hold whenever tuples are simultancously valid in time, i.c., when their validity intervals overlap (Jensen et al. 1996). For example, the dependency country, role In name in Table ensures that, during any time period, a given role within country is held by at most one individual, while allowing the role-holder to change over time. In contrast, a standard FD would require the same role and country to always map to the same person, disallowing any change over time. This highlights how TFDs generalize FDs by capturing temporal variation. Similarly, temporal joins incorporate time when combining two more tables. We mainly focus temporal natural joins, which only join tuples with overlapping validity intervals. In the following sections, we leverage these properties to automatically construct QA pairs without manual effort. Formal definitions of both properties are presented in Sec. A.2
3 TDBENCH
We introduce TDBench, a new benchmarking framework for systematic evaluation of Question Answering (TSQA). We first describe the automatic construction of TSQA pairs from temporal databases, which greatly reduces reliance on manual effort in constructing and updating QA pairs (Sec. 3. We then outline an evaluation protocol that moves beyond answer-only evaluation and assesses models' temporal reasoning and explanations (Sec. 3.2 Finally, we discuss an extension that increases TSQA difficulty by incorporating implicit temporal contexts (Sec. 3.3).
Both FDs and TFDs are defined hy the datahase owner. These properties are typically imposed in databases detect data inconsistencies and enforce data integrity (Jensen al. 1996).
3

---

Published as a conference paper at ICLR 2026
Table 2: Examples of temporal context generation using Allen's interval algebra. Interval relations (e.g.. before, meet, overlap) are implemented with SQL. conditions to generate temporal contexts, where is tuple's validity interval (e.g., president's term) and b is a randomly sampled time interval (e.g. 1'2000-0--20', '2001-03-20") to generate diverse temporal contexts. The overlap relation has two implementations: one for general temporal reasoning and one for modeling the "current" condition used in the temporal alignment task. See Table Table[[0ffr all 13 temporal relations.
Relation
Interval Diagram
SQL Condition
Example Temporal Context
A president who ends
before
a.end b.start
b
before September 20, 2000
president who ends exactly half year before March 20, 2001
mmeet
a.end b.end b.length
a
president who starts before September 20, 2000 and ends between September 20, 2000 and March 20, 2001
a.start < b.start A b.start < a.end < b.end
a overlap b b
a.start < b.start A a.end IS NULL
A president who currently serving
3.1 SYSTEMATIC QA CONSTRUCTION
Our key idea is to harness temporal database techniques to systematize the QA construction process. As shown in Fig. T TDBench proceeds in the following three steps, yielding several benefits.
① Knowledge Selection via TFDs Given temporal database, we TFDs (Sec.2) 2 automatically
select attribute sets for constructing TSQA pairs. Given TFD X 2, Y satisfied in a database relation r, we specify r.X values in the question and use the corresponding r.Y values as the answers, since X
values determine Y values at any time by the TFD definition. For example, country, role 3 name leads to the question "Who is the [role] of the country [country]"? with the answer [name]. where [role], [country], and [name] are placeholders for attribute values. As TFDs are part of the design theory of temporal databases, this FD-based logic generalizes to arbitrary schemas of temporal databases, enabling systematic knowledge selection. While TFDs are commonly defined in temporal databases, we discuss how to handle cases where TFDs are missing, unknown, or invalid in Sec. B.3
2 Temporal SQL Query Generation Using the TFD-selected attributes, we generate temporal SQL queries cover diverse temporal questions. SQL stands for Structured Query Language. which is used to interact with databases to manage and query data. Rather than directly generating natural language questions, generating questions via temporal SQL queries allows us utilize expressive built-in temporal operators, reducing the manual effort to design temporal contexts.
We design Genquerin ries algorithm to automatically generate SQL queries. Genqueries first (1) builds base query using the TFDDselected attributes and then (2) adds temporal constraints, as shown in Fig. [ For (1), the X attributes are used in the WHERE clause for the question, and the attributes used in the SELECT clause for the answer (e.g., country, role S name yields SELECT name WHERE country= 'USA' AND role- 'presi pressident) dentt). ), For (2), SQL conditions are generated based on Allen's interval algebra (Allen 1983), well-defined framework from the database literature that specifies 13 mutually exclusive and exhaustive temporal relations: before, after, meet, met-by, overlap, overlapped-by equal, start, started-by finish, finished-by, during, and contain. For example, Table 2 shows the temporal SQL condition and the temporal context corresponding to the meet relation, where a time interval a ends exactly when a time interval starts. The resulting temporal condition is appended to the base query as temporal constraint. We present the pseudocode of Genqueries and the full set of SQL conditions in Sec. B.I and Sec. B.2 respectively.
Conversion to Natural Language QA Pairs We convert the generated queries into natural language QA pairs by using an LLM and the underlying database. For questions, we use GPT-4o Ope- nAl 2024) as an SQL-to-text translator via system prompts, which we observe to achieve 9 91.5% % accuracy in setup based on LLMs' strong zero-shot performance in SQL-to-text tasks Zhang ct al. 20244) - see detailed setups (e.g., actual prompt and temperature) and error analyses in Sec. B.4
For answers, simply the generated SQL queries on the database. In this way, obtain
4

---

Published as a conference paper at ICLR 2026
Table 3: QA pair generation from an SQL query. Each query is translated to multiple natural language questions with the same answer. To evaluate both answer and time accuracy. the query also outputs celatioon-spciffie time reference (c.g,, end for the mees relation), defined in Table I0
SQL Query (relation='meet))
Generated QA
SELECT nane, end FROM Leader WHERE Country= 'Brazil' Brazzil AND Pressdddt AND date (cnd) = date ( 22019-05-01',
[Questions] "Who was the president of Brazil whose term ended exactly four months before May 1, 2019?", "Can you provide the president of Brazil who finished their term four months prior to May 1, 2019?"...
'-4 month')
[Answer] Michel Temer [Timm reference) 2019-01-01 (end)
[Model Response] The answer is Michel Temer (answer), whose term ended in January 1, 2019 (time reference).
linguistically diverse questions from an LLM while ensuring that the answers follow the underlying database, as shown in Table We show more examples of generated QA pairs in Sec. [.4
Benefits Compared to prior approaches. TDBench offers many benefits by harnessing both database techniques and LLMs for QA construction: (1) convenient and generalizable benchmarking. TFDs eliminates the need for manual data processes to identify time-related attributes (Gupta et al. 2023] Zhao et al. (024) while generalizing to any temporal databases; (2) automatic QA construction with rich temporal constraints. Temporal SQL eliminates the need for customized, human- written templates while expanding temporal constraints to 13 types, instead of the typically used 4-6 types (mainly 'in', 'from-to', 'before', , and 'after' (Chen et al. 202T: Dhingra et al. [2022); (3) better accuracy and cost efficiency compared to LLM-only approaches. By grounding answers in the database, we demonstrate TDBench achieves lower QA pair error rates and reduces LLM inference costs compared relying only LLMs for QA construction (Kim al. 2024 (Sec. D.8
3.2 EVALUATION OF BOTH ANSWERS AND TIME REFERENCES
Using the generated QA pairs, TDBench evaluates not only final answers, but also explanations for a more reliable TSQA evaluation. To this end, we propose time accuracy metric and explain its definition and verification process, along with the evaluation scenarios supported by TDBench.
Definition of Time Accuracy We define time accuracy as the correctness of time references specifically the start and end dates in our setup - that serve as rationales for temporal reasoning required in time-sensitive question. For example, the questions in Table require reasoning over the president's ss end date, where the model should mention "Jamuary 1, 2019 in the explanation given the constraint "four months before May 1, 2019". If question requires both a start and an end date, but the model gets only one correct, the time accuracy is 50%. See the formal definition in Sec. B.5
Verification of Time Accuracy TDBench supports automatic verification of time accuracy by utilizing the SQL-generated temporal constraints, which explicitly encode the temporal reasoning logic (e.g.. "date(end) = date( 2209--05-1'), -4 month" in Table 3 indicates that the end date is required for reasoning). We thus define reletion-specific criteria that specifies which time references to verify: start date for 'aster', 'met-by', 'started-by', end both dates for the remaining seven relations, as summarized in Table To facilitate evaluation, we prompt target LLMs to explicitly state time references used in their reasoning during the TSQA task. Since model responses may include unrelated time information (c.g.. "As of 2025, the answer is... "), we employ an LLM-based judge rather than exact matching to verify time references, achieving 91.1% accuracy under manual inspection - see more details and error analyses Sec. B.6] We also demonstrate how the time accuracy metric can be supported in other TSQA benchmarks in Sec. 4.1
end date for 'before', 'meet', 'finished-by' and
Evaluation Scenarios TDBench supports various TSQA evaluation scenarios: (1) temporal alignment evaluation, which tests whether the L.M up-to-date with current world knowledge. As this scenario grounds questions to specific temporal constraint "current", we use the 'overlap' relation to generate the "current" constraint (Sec. ) (2) temporal reasoning evaluation, which assesses the LLM's understanding of diverse temporal contexts, where we can use all 13 types of temporal constraints generated by Genqueries; (3) ppen-boold/losed boook evaluation, which differs by the presence of additional context that can aid the QA task. In the open-book setting, append both relevant and irrelevant rows from the database to the question, whereas such context removed in the closed-book setting (see Sec. B.7 for an example QA in each setting). We note
5

---

Published as a conference paper at ICLR 2026
that these scenarios enabled by the expressiveness of temporal SQL, which also allows natural extensions to broader scenarios see how to extend Genquerie ies to incorporate non-temporal data attributes, semi-structured data, and other temporal tasks such as event-counting in Sec. B.1
3.3 EXTENSION WITH IMPLICIT TEMPORAL. CONTEXTS
To properly evaluate ever inervviig LLMs, we can further increase question complexity by generating implicit temporal questions that require reasoning between multiple events. Consider the question q: "Who was the president of the host country during the 1988 Summer Olympics?". The temporal constraint here is implicit, expressed as "during the 1988 Summer Olympics" rather than explicit dates. These questions require an advanced temporal reasoning ability (Tan et al. 2023), where the model must correctly identify two temporally overlapping events.
TDBench generates such implicit questions like q by performing temporal joins (Sec. 2 of tables Soympic(countryy within the SQL. queries. For example, joiiing Leaders(country) role, gender, name, start, end) on the common column 'country' pairs Olympic host countries with their national leaders at that time. By combining information from both events through this join, the resulting table contains tuples suitable for generating questions that span multiple events (like q) and their corresponding answers. To automatically generate QA pairs, Genquer rie uses TFDs from this joined table which can be derived via standard FD and TFD inference rules (Jensen et al., 1996) while skipping the explicit temporal constraint generation process to create implicit constraints instead. For instance, game__diiiion - country (in Olympic) and
city, game_ cone_edition, start, end) and
country, role 5 name (in Leaders) yield game_ tame___diionn role 3 name, which Genqueries converts to "Who was the [role] of the host country during the [game edition]?" The model response evaluation process remains the same for questions with explicit temporal constraints.
4
EXPERIMENTS
We perform extensive experiments demonstrate how TDBench enables diverse and fine-grained temporal evaluation of LLMs. More detailed settings (e.g., system prompts) are provided in Sec. C
LLMs Compared
We compare GPT-3.5 (OpenAl 2022), GPT-4 (OpenAl 2023). J. GPT-4o (OpenAl
2024 Llama3.1-70B (Dubey et al. 2024). Mixtral-8x7B (Tiang et al.] 2024),
Gemma2-27B (Team
et al. 2024), Qwen2-72B (Bai et al. 2023), and Granite3.1-81 (Granite Team 2024). We set all the
temperature parameters to zero exclude randomness in the LLM responses.
Datasets We use temporal databases from two types of sources: (I) Wikipedia covering domains such as Countries, Athletes, Organizations, and Olympics, which are commonly addressed in existing TSQA benchmarks (Chen et al., 2021 Dhingra et al. 2022. Mousavi et al. 2024), generating 6,177 questions; and (2) other platforms such as Kaggle, covering areas including same-sex marriage laws, carbon taxation, UNESCO heritage, and Netflix shows to model domain-specific scenarios Legal, Envirommental, Cultural, and Social contexts, generating 1,704 questions. More details on datasets, including schemas, used TFDs, and subcategories of questions, are provided in Sec.
Performance Measures We mainly use the following three performance evaluation metrics.
Answer accuracy (A): Portion of responses with correct answers.
Time accuracy (T): Portion of responses with correct time references, evaluated using relation- specific criteria (T). If two time references are expected (e.g.. start and end dates), partial credit (50%) is given when only one is correct. Granularity (e.g., year, month) varies by dataset. Answer-Time accuracy (AT): Portion of responses with both correct answers and time references. Here, we do not give partial credit when assessing time references (i.e., only consider 100%), providing strict metric for more rigorous analysis.
4.1 EVALUATION OF TEMPORAL ALIGNMENT
We evaluate the temporal alignment of LLMs, assessing the ability answer up-to-date questions that reflect current world knowledge (Dhingra et al.) 2022 Kasai et al. 2023 Mousavi et al. 2024).
Performance Variations when Accounting for Time Accuracy Table shows notable performance variations across domains under two evaluation settings: A (answer-only) and AT (answer and time).

---

Published as a conference paper at ICLR 2026
Table 4: Performance evaluation of eight LLMs on the temporal alignment TSQA task. We report the proportion of correct responses under two evaluation settings: answer-only (A) and answer and time (AT), along with their difference (A A ATA Wikipedia results are reported in aggregate, and domain-specific results are broken down by subdomain. Best results are shown in bold.
Wikipedia
Law
Carbon Tax
Heritage
Netflix
Model
AT
A
A
AT
AT
A
AT
A
AT
GPT-3.5
47.5
22.4
25.1
84.3
39.9
44.3
19.9
8,4
11.4
62.7
26.5
36,2
29.3
19.1
10.1
GPT-4
44.5
29.6
14.9
82.4
52.3
30.0
32.0
23.9
8.1
74.5
44.5
30.0
32.4
26.4
6.1
GPT-4o
73.9
48.8
25.1
84.3
54.0
30.3
72.1
43.1
29.0
72.5
53.3
19.2
32.9
25.9
7.0
11ama3.1-70R
64.6
56.7
7.9
84.6
44.9
39.7
57.6
39.7
17.8
75.5
39.7
35.8
35.6
28.6
7.0
Mixtral-8x7B
42.9
30.9
12.0
74.1
42.2
32.0
28.3
16.5
11.8
35.6
18.1
17.5
20.7
17.1
3.6
Gemma2-277
69.3
32.8
36.5
84.3
29.8
54.6
73.1
25.2
47.8
69.2
22.0
47.2
36.0
27.7
8.3
Qwen2-72B
62.7
34.1
28.6
84,0
34.2
49.9
57.2
27.6
29,6
53.5
20.2
33.3
22.5
19,4
3.1
Granite3.1-8P
49.6
26.1
23.5
90.1
28.6
61.4
45.1
0.0
45.1
42.0
4.5
37.5
19.6
14.9
4.7
Average
56.9
35.2
21.7
83.5
40.7
48.2
23.1
25.1
60.7
28.6
32.1
28.6
22.4
6.2
While the models generally achieve high A by retrieving correct up-to-date answers, they often fail to generate accurate time references, resulting in 21.7% average performance drop in AT on the Wikipedia dataset. This gap reveals the limitation of traditional answer-only evaluation, indicating that large portion of factually inconsistent responses with incorrect time references can be overlooked- - see actual cases in Sec. D.I We also observe domain-specific LLM performances; GPT-40 performs best in domains such as law, carbon tax, and UNESCO heritage, while Llama3.1 1-70B excels in the Netflix domain demonstrating TDBench's 's applicability beyond Wikipedia- based data.
Integrating Time Accuracy into Existing Benchmarks We show how the proposed time accuracy metric can be beneficial when integrated into existing temporal alignment TSQA benchmarks (Dhin- gra et al. 2022 Margatina et al. 2023 Mousavi et al. 2024), enabling more fine-graid greingrined evaluation. These benchmarks use open-ended QA templates (e.g.. "The president of Italy is _") and solely evaluate the final answer. To integrate T and assess model explanation as well, we simply modify the system prompt elicit start date references from the model, without altering the original benchmark. In Sec. D.2, we provide detailed case study with Dyknow (Mousavi et al. (2024), where we extend the benchmark with T and observe an Fl-score of 0.96 for temporally aligned responses (i.e., both answer and time reference are correct), improving benchmark correctness against human verifications.
4.2 BREAKDOWN OF TEMPORAL REASONING PERFORMANCE
We now evaluate the temporal reasoning ability of LLMs to understand diverse temporal conditions, analyzing performance by answer cardinality, temporal constraint type, and temporal span.
Performance by Answer Cardinality We evaluate LLM performances across different answer set sizes, expanding the traditional setup with single answer. Depending the generated temporal context, TDBench can yield multiple-answer or no-answer questions as well as single-answer questions. For example, no-answer question might ask, "Which president of the U.S. ended their term exactly half a year before January 20, 2001?". where no such president exists. Table shows that models like GPT-4o perform robustly across question types, whereas models like Mixtral and GPT-3.5 show notable gaps, particularly underperforming on no-answer questions. For example, a model incorrectly answers "Bill Clinton" (term ended on January 20, 2001), likely due to matching the string "January 20, 2001" in the question rather than reasoning over "exactly half year.", indicating that models may rely more on surface cues than true temporal reasoning.
Performance by Temporal Constraint Type We assess how well the LLMS handle different types of temporal constraints using the 13 distinct temporal relations. Fig. 2 shows that LLMs perform best on 'equal' relation-based constraints (e.g.. "in 2025")- - likely due to their prevalence training data - while struggling with 'contain' and 'overlap', which require precise temporal reasoning over both start and end dates (e.g., started before January 1, 1985, and ended after December 30. 1992 for 'contain') ). Interestingly. LLMs tend to comprehend start constraints (e.g.. 'start', 'started-by') more accurately than end constraints (c.g.. 'finish, 'finished-by') ) which may stem from the autoregressive nature of LLMs that prioritizes earlier tokens in generation.
7

---

Published as a conference paper at ICLR 2026
Table 5: LLM performances by answer cardinality. Performances are reported across multiple., unique-, and no-answer ("None") question types, evaluated on the Wikipedia dataset in the open-book setting. Only A is reported for the None type questions, as no time refer- ence is expected in no-answer cases.
equal
80
start
70
finish
finishe-bby
during
50
after before
over leppsppel-by
Multiple
Unique
None
30
Model
A
AT
T
AT
A
met by
20
GPT-4
GPT-3.5
34.4
60.3
77.8
41.9
49.8
20.1
61.7
43.3
67.8
82.9
36.8
49.9
45.0
17.9
GPT-3.5
GPT
GPT
Liama3
Muttrll
Cemmar
Ouen?
Graniee
GPT-40
58.1
67.8
68.7
62.4
1lama3.1-70p
48.6
45.7
69.1
51.8
44.2
Figure 2: LLM performances 13 tem-
Mixtral-&x7B
36.2
57.6
49.9
78.1
36.6
7.8
Gemma2-27B
49.7
56.1
29.1
61.9
63.6
41.7
20.0
poral relations in the open-bood book setting.
Qwen2- 72B
48.3
62.5
37.7
63.4
86.4
57.0
49.1
The heatmap displays AT for each tempo-
Granite3. 3.1-8B
22.5
41.9
14.8
46.9
51.2
25.8
25.1
ral relation, as defined Table 10
GPT-3.5
GPT-4o
Mixcral Gemma?
Owen2 Granine3
Table 6: LLM Performances on im- plicit, multi-hop questions (Sec. (33 H; denotes the hallucination
GPT4
Iaaaa
80
at the (i + 1)-th hop given the correct i-th hop. Full results with 2-hop questions are shown in 29
Answer Accuracy (%g
70
50
40
3-hop
30
20
Model
A
AT
H.
II,
10
GPT-335
33.8
33.8
8,5
7.6
1985-1990
1990-1985
1995 1995-2000
2000-2005
2005-2010
2010-2015
2015-2020
2020-2025
GPT-4
57.1
52.5
10.8
0.5
GPT-4o
90.4
87.9
26.3
0.0
Llama3. 1-700
82.8
80.8
38.2
4.5
Figure LLM performances across different time spans (1985-2025) in single domain (Countries) under the closed-book setting. Additional results aggregated over multiple domains are presented in Sec. D.3
Mixtral-8x7B
60.1
49.0
19.5
10.6
Gemma2-270 2-BB
48.0
43.9
26.5
24.7
Qwen2-722 72B
68.2
59.1
35.1
5.6
Granite3. 1.tiee...-BB. 1-8B
11.1
11.1
10.3
77.8
Performance by Temporal Span We evaluate LLM performance across different temporal spans under the closed-book setting, assessing how well LLMs utilize internal time-sensitive factual knowledge without external context. Fig. shows Big.ws the results for single domain (Countries) (see Sec. D33 for aggregated results across multiple domains) where we observe a gradual performance increase from 1985 to 2010, with notable jump in the 1990-1995 interval. As this trend appears consistently across all models, we suggest it reflects shared characteristics of training data rather than model-speeific behavior, where the 1990-1995 period may be better represented in the training data.
Sec.D.3
4.3 EVALUATION OF IMPLICIT, MULTI-HOP QUESTIONS
We assess LLM performance on multi-hop questions. described in Sec. 3.3 these questions have implicit temporal contexts generated via temporal joins, and we construct 2-hop and 3-hop questions by joining the Olympic and Country datasets. For the 2-hop setting, we use the TFD came_edition, role T name, where models should infer (1) the host country and time from given Olympic game edition (e.g., 1988 Summer Olympics), and (2) the leader of the host country (e.g., president) that time. For the 3-hop setting, we use name_round gruuddrooe role T name, where models should infer (1) the Olympic game edition from the round number (c.g.. 24th Summer Olympics), (2) the host country and time, and (3) the leader at that time. An example QA is shown Sec. B.4
Performance by Reasoning Hops To effectively assess the reasoning process, we introduce H, which measures the conditional probability of hallucination where a model answers the i-th hop correctly, but hallucinates the (i+1)-st hop. Alongside the overall performances captured by A and AT, o the step-wise performances captured by H,, revealing the most challenging hop for each model. For example, GPT-4o and I J.ama3.11170
hallucinate more at the first hop (i.e.,
8

---

Published as a conference paper at ICLR 2026
higher H1), while Cranite3.1-80 hallucinates at the second hop (i.e., higher H2) in the 3-hop setting. These model- model-specific challenges highlight the value of TDBench's 's multi-hop generation capability, which enables fine ine-ggained diagnosis of intermediate reasoning failures.
Impact Performance Improvement Techniques To mitigate reasoning errors in multi-hop settings, we evaluate the effectiveness of prompting strategies known to support model reasoning. Specifically, we compare RAG (Lewis et al. (020), which augments prompts with retrieved Wikipedia passages; Chain- of-Thought (CoT) (Wei et al. 2022), which guides models generate intermediate reasoning steps; and & Hu 2024), a recent CoT variant designed for temporal reasoning- see CoT and Time- CoT prompts in Sec. Sec.D.4) As shown in Table 7 CoT and Time-CoT generally outperform RAG, which often retrieves relevant yet temporally misaligned contexts (see a case study in Sec. Scc. Between CoT
Table 7: Performance comparison on multi- hop questions when applying RAG, CoT, and Time-CoT. Best- and second-bess per- forming methods for each model are high- lighted in bold and underline, respectively.
Model
Original RAG CoT Time-CoT
GPT-3.5
63.1
71.2
39.4
15.2
(Yin Time-CoT
GPT-4
67.2
35.4
92.4
93.9
GPT-4o
79.3
89,9
92.9
95.5
Ilama3.
83.8
73.2
92.9
91.9
Mixtral-xx7B
72.7
60.1
67.2
71.2
Gemma2-27B
77.8
40.9
83,8
78.8
Qwen2-72B
65.2
78.8
77.8
85.4
Granite3.1
50.5
54.5
70.2
72.2
and Time-Col Co'T, no single method consistently outperforms the other; see results with single-hop questions and additional analysis of RAG's underperformance in Sec.
4.4 CORRECTNESS OF TDBENCH
We evaluate the correctness of TDBench across three task types (Sec.[4.) | Sec. 4.3) We compare TDBench's 's evaluation results with manual verificttion on 125 randomly sampled responses per task, using precision (P), recall (R), and F1-score (F1); see De5. for metric definitions and details of manual verifica- tion. As shown in T TDBench achieves high agreement with manual verification, demonstrating the effectiveness of database- driven techniques for LLM benchmarking.
Table 8: Correctness of TDBench against manual verification. Fine- grained results are in Table 24
Methods
R
F1
Temporal alignment
0.98 0.96 0.97
Temporal reasoning Multi-hop
0.87 0.91 0.88
0,95 0.87 0.91
4.5
MORE ANALYSES
To further evaluate the applicability and robustness of TDBench, we conduct additional analyses: (1) evaluation on synthetic medical data, demonstrating how TDBench can be applied beyond real-world facts (Sec. D.6:: (2) evaluation of task-specific TSQA methods, which underperform relative to the general-purpont purpose models in the main experiments (Sec. (Scc.D.7): : (3) comparison with LLM-based TSQA methods, which generate TSQA pairs by directly feeding raw data into LLMs, but can be more susceptible hallucination and incur higher inference costs when processing the raw data (Sec. D and (4) Pross-translati similarity analysis, which examines the impact of different SQL-to-text translators on question phrasing (Sec. D.9).
RELATED WORK
Factual Time-Sensitive Question-Ansserrim TDBench differs from prior factual TSQA bench-
Table 9: Comparison with TDBench against template-based factual TSQA benchmarks. We cover 13 temporal relations (Op #), without relying on the fixed set of templates (Temp #) while verifying both answers (A) and time references (T) during evaluation (Eval).
marks in three main aspects: data source, QA con-
struction, and evaluation methodology. Prior TSQA
studies heavily centers on Wikidata (Jia et al. 20188
Chen al. 2021] Dhingra et al.) [222]] Margatina
et 20033 Tan et al. 2023 Mousavi et al.] [002]]
Method
Op# #
Temp #
Eval
Luo al. [2025] /Zhu et al. 2025 Islakoglu & Kalo 2025) or Wikipedia (Jang et al.; 2022 Kim et al.
Dhingra et al.
2022
I (Equal)
9
A
Margatina ci al. 2023
I (Equal)
16
A
2024 Wu et al. 2024] Xiong et al., 2024] Gruber
Tan ct al. 2023
6
23
A
al. 2025). While some recent work target tabular
Mousavi el al. 2024 1 (Equal
27
A
data (Gupta et al. 2023 Zhao et al. 2024), they re-
TDBench (Ours)
13
(Unlimited)
A, T
main limited to Wikipedia tables and often require
additional Wikipedia page content for QA construction, restricting generalization beyond Wikipedia.
In contrast, TDBench is not constrained by WikiiataaWiikipedia domains, enabling generalization

---

Published as a conference paper at ICLR 2026
to arbitrary temporal databases by building database design principles such TFDs. In terms of QA construction, existing benchmarks often rely on mamually curated (Zhang & Choi 2021
Chen et al., [02I]] Wei et al., 2023 Kasai et al.] 2023 Gupta et al. 2023 Vu et al. [023] Jia et al. 2024) or template-hon based QA (Table 9 which often covers limited temporal relations. In contrast,
TDBench does not rely on manual construction a fixed set of templates, while covering richer set of temporal relations via temporal SQL. There are also LLM-based methods that generate TSQA
pairs by processing raw databases via natural language prompting (Kim et al. 2024 Zhao al. 2024 Chen et al. 2025), but TDBench enables more controlled and precise data processing by employing SQL-based data querying. Lastly, to our knowledge, we are the first to address the automatic evaluation of invalid model explanations in TSQA tasks.
Using SQL for QA Systems In QA systems, Text-to-SQL. has been a primary research area Qin
et al. 2022 Hong et al. 2024), with the goal of (1) translating natural language questions into SQL
queries and (2) retrieving answers from databases that serve as knowledge sources, thereby improving
QA performance (Pasupat & Liang 2015 Zhong et al.) 2017 7 Yu et al. 2018 Rajkumar et al. 2022
Liu et al. [022] Gao et al. (023). In contrast, our methodology adopts SQL-io-Ted approach (Xu
ct |ll] [0118] Cámara et al. 2024 Zhang et al. 2024b; Park et al. (026), which translates SQL queries
into natural language questions using translator models such as graph-to- trrah-too-equeet sequence models tailored to
the SQL. query structure (Xu et al. 2018) or general LLMs (Cámara et al., 2024 Park et al. (026). Unlike the TexI-to-SQL task, which derives SQL queries improve LLMs' QA performance via SQL-based retrieval, we use the SQL-to-Teas task to derive natural language QA pairs for benchmark construction. Furthermore, our key distinction from existing SQL-to-Text approaches is the use of temporal SQL to generate time-sensitive questions tailored to TSQA tasks, leveraging expressive built-in temporal operators to automatically produce diverse temporal contexts.
CONCLUSION
We proposed TDBench. which utilizes temporal databases and database techniques for systematic evaluation of factual TSQA. By leveraging database techniques, TDBench reduces the manual effort traditionally required in benchmark construction and maintenance, such as designing temporal contexts or updating QA pairs with new world knowledge. We also introduced a new metric called time accuracy for fine-grained TSQA evaluation, designing TDBench to automatically verify both the final answers and the time references by using SQL-based temporal constraints. Experiments revealed that a large portion factually inconsistent responses with invalid time references can be overlooked in the answer-only evaluation setting, while uncovering model-specins weaknesses across constraint types, answer cardinality, and reasoning hops. We believe TDBench offers a new direction for TSQA evaluation by moving beyond Wikipedia/Wikideee /itikiaaaa and enabling domain-specific benchmarking.
LIMITATION
The correctness of the generated QA pairs in TDBench can be affected by the underlying data quality, which is an inherent aspect of data-centric benchmarking approaches (Jia et al.] 2018 Jang et al.
2022; Gupta et al., 2023: Kim et al.) 2024 Wu et al., 2024). For example, data quality issues like factual inconsistencies and domain-specific anomalies (Wang & Strong 1996) can lead to noisy QA
pairs. While there extensive work on enhancing data quality (Batini al. 2009 Chu al. 2016
Rekatsinas et al.] 2017). our study assumes the underlying quality is reasonable and rather focus on an orthogonal goal: enhancing the downstream pipeline to best leverage the available data. Thus, while TDBench provides clear benefits in this context, providing generalizable and effective tool for converting one's data into a TSQA benchmark, integration with existing data cleaning techniques (Chu) cet al. 22066] Rekatsinas al. 2017) would further strengthen the framework. Similarly, discuss how invalid TFDs affect TDBench in Sec. B.I while TDBench can exhibit robustness due to its SQL-based grounding.
10

---

Published as a conference paper at ICLR 2026
ETHICS STATEMENT
We believe our research addresses an important aspect of Trustworthy Al by evaluating the accuracy and reliability of LLMs under time-sensitive factual scenarios. In particular, we surface the issue of LLM hallucination in both final answers and time references, which can mislead users and undermine trust. By providing a systematic benchmarking framework to detect such cases, TDBench contributes toward building more reliable and transparent LLMs. As dynamic framework, the choice of the database in TDBench inherently determines the benchmark content. We assume that is the user's responsibility to ensure their chosen databases meet ethical standards and exclude harmful private material. All datasets used in this study are publicly available and free of sensitive or harmful content.
REPRODUCIBILITY STATEMENT
To ensure the reproducibility of our results, provide the details of experimental setups in the supplementary material, including the proposed TDBench algorithm, system prompts, LLM hyperpa- rameters (e.g., temperature), and details of datasets used in our study. In addition, will release the GitHub repository for the TDBench framework, containing code and scripts for reproducing our results and documentation for extending the benchmark to new datasets.
THE USE OF LARGE LANGUAGE MODELS
LLMs were mainly utilized as evaluation targets in this work. We also used LLMs to assist in the writing process (e.g., refining phrasing, enhancing clarity), but did employ LLMs for generating core research ideas or technical content.
ACKNOWLEDGMENTS
This research was supported by the MSIi(Ministry of Science ICT), Korea, under the Global Research Support Program in the Digital Field (mgrram/RS-2224-00446666
supervised by the (ITP(Ins Information Communications Technology Planning Evaluation). This project is supported by Microsoft Research Asia. This work was also supported by the NYU-KAIST Partnership and by the IITP with a grant funded by the Ministry of Science and ICT (MSIT) of the Republic of Korea in connection with the Global AI Frontier Lab International Collaborative Research, (No. RS-2024-00469882 & RS-20244005092588, This work was also supported by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (No. RS-2022-NR0701221,
REFERENCES
Ziawasch Abedjan, Patrick Schulze, and Felix Naumann. Did: Efficient functional dependency discovery. In Proceedings the 23rd ACM International Conference Conference on Information and Knowledge Management, pp. 949-958, 2014.
Rakesh Agrawal, Tomasz Imieliński, and Arun Swami. Mining association rules between sets of items in large databases. In Proceedings of the 1993 ACM SIGMOD international conference on Management of data, pp. 207-216, 1993.
James F Allen. Maintaining knowledge about temporal intervals. Communications of the ACM, 26 (11):832-843, 1983.
Mohamed-Amin Baazizi, Dario Colazzo, Giorgio Ghelli, and Carlo Sartiani. Parametric schema inference for massive json datasets. The VLDB Journal, 28(4):497-521, 2019.
Jinze Bai, Shuai Bai, Yunfei Chu, Zeyu Cui, Kai Dang, Xiaodong Deng, Yang Fan, Wenbin Ge, Yu Han, Fei Huang, et al. Qwen technical report. arXiv preprint arXiv:2309. 2023.
Carlo Batini, Cinzia Cappiello, Chiara Francalanci, and Andrea Maurino. Methodologies for data quality assessment and improvement. ACM computing surveys (CSUR), 41-:1:1-5,, 2009.
11

---

Published as a conference paper at ICLR 2026
Matt Buranosky, Elmar Stellnberger. Emily Pfaff, David Diaz-Sanchin and Cavin Hard-Caviness. Fdtool: a python application to mine for functional dependencies and candidate keys in tabular data. F1000Research, 7:1667, 2019.
Vanessa Câmara, Rayol Mendonca-Nee Neto, André Silva, and Luiz Cordovil. A large language model ap- proach to sql-to-texi generation. In 2024 IEEE International Conference on Consumer Electronics (ICCE), pp. 1-4, IEEE, 2024.
Wenhu Chen, Xinyi Wang, and William Yang Wang. dataset for answering time-sensitive questions. arXiv preprint arXiv:2108.066 2021.
Ziyang Chen, Erxue Min. Xiang Zhao, Yunxin Li, Xin Jia, Jinzhi Liao. Jichao Li, Shuaiqiang Wang, Baotian Hu, and Dawei Yin. A question answering dataset for temporal-sensitive retrieval- augmented generation. arXiv preprint arXiv:2508. 12282, 2025.
Xu Chu, Ihab F lyaa, Sanjay Krishnan, and Jiannan Wang. Data cleaning: Overview and emerging challenges. In Proceedings of the 2016 international conference on management of data, pp- 2201-2206, 2016.
Bhuwan Dhingra, Jeremy R Cole, Julian Martin Eisenschlos, Daniel Gillick, Jacob Eisenstein, and William W Cohen. Time- aware language models as temporal knowledge bases. Transactions of the Association for Computational Linguistics, 10:257-273. 2022.
Michael DiScala and Daniel Abadi. Automatic generation of normalized relational schemas from nested key-value data. In Proceedings of the 2016 International Conference on Management of Dala, pp. 295-310, 2016.
Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21788 2024.
Dawei Gao, Haibin Wang. Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. Text-to-sql empowered by large language models: A benchmark evaluation. arXiv preprint arXiv:2308. 15363, 2023.
IBM Granite Team. Granite 3.0 language models, October 2024. URL https::/githubb com/ ibm gwwnite/graniteeeeeeee.eee 3.0 language-modelss!
Raphael Gruber, Abdelrahman Abdallah, Michael Färber, and Adam Jatowt. Complextempqa: A 100m dataset for complex temporal question answering. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 9111-9123, 2025.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprini arXiv:2501. 2025.
Vivek Gupta, Pranshu Kandoi, Mahek Bhavesh Vora, Shuo Zhang, Yujie He, Ridho Reinanda, and Vivek Srikumar. Temptabqa: Temporal question answering for semi-structured tables. arXiv preprint arXiv:2311.08 1.000000022222. 2023.
Zijin Hong. Zheng Yuan, Qinggang Zhang, Hao Chen, Junnan Dong, Feiran Huang, and Xiao Huang. next-generation database interfaces: A survey of llmebased text-to-sql. arXiv preprint arXiv:2406.0844 08426. 2024.
Yue Huang, Lichao Sun, Haoran Wang, Siyuan Wu, Qihui Zhang, Yuan Li, Chujie Gao, Yixin Huang, Wenhan Lyu, Yixuan Zhang, et al. Trustllm: Trustworthiness in large language models. arXiv preprint S00.v::20010055611 2024.
Duygu Sezen Islakoglu and Jan-Chin Christoph Kalo. Chronosense: Exploring temporal understanding in large language models with time intervals of events. arXiv preprint arXiv:2501. 000000 2025.
Joel Jang, Sconghyeon Ye, Changho Lee, Sohee Yang, Joongbo Shin, Janghoon Han, Gyconghun Kim, and Minjoon Seo. Temporalwiki: A lifelong benchmark for training and evaluating ever-evolving language models. arXiv preprint arXiv:2204. 142/ 2022.
12

---

Published as a conference paper at ICLR 2026
Christian S Jensen and Richard T Snodgrass. Temporal database., 2018.
Christian S Jensen, Richard T Snodgrass, and Michael D Soo. Extending existing dependency theory to temporal databases. IEEE Transactions on Knowledge and Data Engineering, 8(4):563-582 1996.
Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Ye Jin Bang. Andrea Madotto, and Pascale Fung. Survey of hallucination in natural language generation. ACM computing surveys, 55(12):1-38, 2023.
Zhen Jia, Abdalghani Abujabal, Rishiraj Saha Roy, Jannik Strötgen, and Gerhard Weikum. Tem- pquestions: A benchmark for temporal question answering. Companion Proceedings of the The Web Conference 2018, pp. 1057-1062, 2018.
Zhen Jia. Philipp Christmann, and Gerhard Weikum. Tiq: answering with implicit time constraints. In Companion Proceedings of the ACM Web Conference 2024, pp. 1394-1399, 2024.
A benchmark for temporal question
Albert Q Jiang, Alexandre Sablayrolles, Antoine Roux, Arthur Mensch, Blanche Savary, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Emma Bou Hanna, Florian Bressand, et al. Mixtral of experts. arXiv preprint arXiv:2401.04088. 2024.
Junfeng Jiao, Saleh Afroogh, Yiming Xu, and Connor Phillips. Navigating 1lm ethics: Advancements, challenges, and future directions, 2024. URL
Alistair EW Johnson, Tom J Pollard, Lu Shen, Li-wei H Lehman, Mengling Feng. Mohammad Ghassemi, Benjamin Moody, Peter Szolovits, Leo Anthony Celi, and Roger G Mark. Mimic-iii, a freely accessible critical care database. Scientific data, 3(1):1-9, 2016.
Jungo Kasai, Keisuke Sakaguchi, yoichi takahashi, Ronan Le Bras, Akari Asai, Xinyan Velocity Yu, Dragomir Radev, Noah A. Smith, Yejin Choi, and Kentaro Inui. Realtime QA: What's the answer right now? In sevethh Conference on Neural Information Processing Systems Datasets and Benchmarks Track, 2023. httttttss///peeeeeeeee
net forum ieforumiid-aae H
Yujin Kim, Jaehong Yoon, Seonghyeon Ye, Sangmin Bae, Namgyu Ho, Sung Ju Hwang, and Se- Young Yun. Carpe diem: On the evaluation of world knowledge in lifelong language models. In Kevin Duh, Helena Gomez, and Steven Bethard (eds.). Proceedings of the 2024 Confer- ence of the North American Chapter of the Association for Computatioonal Linguistics: Human Language Technologies (Volume 1: Long Papers), pp. 5401-5415, Mexico City, Mexico, June 2024. Association for Computational Linguistics. doi: wwwp:/yyyrrgg/22// www.nnaallllnoo 302/
URL
Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, al. Retrieval-augmente genera- tion for wwwledge-intensivg nlp tasks. Advances in Neural Information Processing Systems, 33: 9459 9474, 2020.
Chin-Yew Lin. Rouge: A package for automatic evaluation of summaries. In Text summarization branches out, pp. 74-81, 2004.
Stephanie Lin, Jacob Hilton, and Owain Evans. Truthfulqa: Measuring how models mimic human falsehoods. arXiv preprint arXiv:2109.07958 2021.
Qian Liu, Bei Chen, Jiaqi Guo, Morteza Ziyadi, Zeqi Lin, Weizhu Chen, and Jian-Guang Lou. Tapex: Table pre-training via learning a neural sql executor. In The Tenth International Conference on Learning Representations, 2022.
Stéphane Lopes, Jean-Mare Petit, and Lotfi Lakhal. Efficient discovery of functional dependencies and armstrong relations. In International Conference on Extending Database Technology. pp. 350-364. Springer, 2000.
13

---

Published as a conference paper at ICLR 2026
Sigang Luo, Yinan Liu, Dongying Lin, Yingying Zhai, Bin Wang, Xiaochun Yang, and Junpeng Liu. Etrqa: A comprehensive benchmark for evaluating event temporal reasoning abilities of large language models. In Findings of the Association for Computational Linguistics: ACL 2025, pp.
23321-23339, 2025.
Alex Mallen, Akari Asai, Victor Zhong, Rajarshi Das, Daniel Khashabi, and Hannaneh Hajishirzi. When not to trust language models: Investigating effectiveness of parametric and non-parametric memories. In Anna Rogers, Jordan Boyd-Graber, and Naoaki Okazaki (eds.), Proceedings of the sl Annual Meeting of the Association for Compulational Linguistics (Volume I: Long Papers), pp. 9802-9822, Toronto, Canada, July 2023. Association for Computational Linguistics. doi: 10. 10.18663/v1/20233 acc.aall.-ooo.444 URL 546/
Katerina Margatina, Shuai Wang, Yogarshi Vyas, Neha Anna John, Yassine Benajiba, and Miguel Ballesteros. Dynamic benchmarking of masked language models on temporal concept drift with multiple views. In Andreas Vlachos and Isabelle Augenstein (eds.), Proceedings of the 17th Conference of the European Chapter of the Association for Computational Linguistics, pp. 2881- 2898, Dubrovnik, Croatia, May 2023. Association for Computational Linguistics. doi: 10.18653/ v1/2023 1..002..eccl-mae macl-mmin.2111 httpa///....tttp////aaatttttttoa hwgp 2023 eacll -mainn 211/
URL http:: https://aalaatthoooogoooo
Seyed Mahed Mousavi, Simone Alghisi, and Giuseppe Riccardi. DyKnow: Dynamically verify- ing time-sensitive factual knowledge in LLMs. In Yaser Al-Onaizan, Mohit Bansal, and Yun- Nung Chen (eds.), Findings of the Association for Computational Linguistics: EMNLP 2024, pp. Miami, Florida, USA, November 2024. Association for Computational Linguistics. 1/2022.findinggs---em
doi: 10. 18.18863/v 112.2///////222...2////
URL https: https////acaaathloo..oooooeo or0/2220
Findings emn 1p. 471/
Jio Oh, Soyeon Kim, Junseok Seo, Jindong Wang. Ruochen Xu, Xing Xie, and Steven Euijong Whang. Erbench: An entity-relationship based automatically verifiable hallucination benchmark for large language models. arXiv preprint arXiv:2403.05266, 2024.
OpenAI. Chatgpt.
openat com 2022.
OpenAL. Gpt-4 technical report, 2023.
OpenAl. Gpt-4o system card. arXiv preprint arXiv:2410.2127.. 2024.
Sungho Park, Jueun Kim, and Wook-Shin Han. Sparta: Scalable and principled benchmark of tree-structured multi-hop qa over text and tables. In The Fourteenth International Conference on Learning Representations, 2026.
Panupong Pasupat and Percy Liang. Compositional semantic parsing semi-structured tables. arXiv preprint 1rXiv:1508 00305, 2015.
Bhawna Piryani, Abdelrahman Abdullah, Jamshid Mozafari, Avishek Anand, and Adam Jatowt. It's high time: A survey of temporal information retrieval and question answering. arXiv preprint 2rXiv22505.20243, 2025.
Tom Pollard, Alistair EW Johnson, Jesse Raffa, Leo A Celi, Roger G Mark, and Omar Badawi. The eicu collaborative research database, a freely available multi-center database for critical care research. Scientific data, 5(1):1-13, 2018.
Bowen Qin, Binyuan Hui, Lihan Wang, Min Yang, Jinyang Li, Binhua Li, Ruiying Geng, Rongyu Cao, Jian Sun, Luo Si, al. A survey text-to-sql parsing: Concepts, methods, and future directions. arXiv preprint arXiv:2208. /3629, 2022.
Nitarshan Rajkumar, Raymond Li, and Dzmitry Bahdanau. Evaluating the text-to-sql capabilities of large language models. arXiv preprint arXiv:2204.. 00498, 2022.
Nils Reimers and Iryna Gurevych. Sentence-bert: Sentence embeddings using siamese bert-networks. arXiv preprint arXiv: 10084, 2019.
Theodoros Rekatsinas, Xu Chu, Ihab F Ilyas, and Christopher Ré. Holoclean: Holistic data repairs with probabilistic inference. arXiv preprint arXiv:1702.0088: 2017.
14

---

Published as a conference paper at ICLR 2026
Kai Sun, Yifan Ethan Xu, Hanwen Zha, Yue Liu, and Xin Luna Dong. Head-to-tail how knowledge- able are large language models (Ilms)? aka will Ilms replace knowledge graphs? arXiv preprint PrXii:2308.10166 2023.
Qingyu Tan, Hwee Tou Ng, and Lidong Bing. Towards benchmarking and improving the temporal reasoning capability of large language models. arXiv preprint arXiv:2306.0899 2023.
Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. Gemma 2: Improving open language models at practical size. arXiv preprint arXiv:2408.00118, 2024.
Md Nayem Uddin, Amir Saeidi, Divij Handa, Agastya Seth, Tran Cao Son, Eduardo Blanco, Steven R Corman, and Chitta Baral. Unseentimega: Time-sensitive question-answering beyond Ilms' memorization. arXiv preprint arXiv:2407.035255 2024.
Tu Vu, Mohit lyyer, Xuezhi Wang. Noah Constant, Jerry Wei, Jason Wei, Chris Tar, Yun-Hsuan Sung, Denny Zhou, Quoe Le, et al. Freshllms: Refreshing large language models with search engine augmentation. arXiv preprini arXiv:2310.03211 2023.
Cunxiang Wang, Xiaoze Liu, Yuanhao Yue, Xiangru Tang, Tianhang Zhang, Cheng Jiayang, Yunzhi Yao, Wenyang Gao, Xuming Hu, Zehan Qi, et al. Survey on factuality in large language models: Knowledge, retrieval and domain-specifficty. arXiv preprint 1rXiv:2310.07521, 2023.
Richard Y Wang and Diane M Strong. Beyond accuracy: What data quality means data consumers. Journal of management information systems, 12(4):5-33, 1996.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824-24837, 2022.
Yifan Wei, Yisong Su, Huanhuan Ma, Xiaoyan Yu, Fangyu Lei, Yuanzhe Zhang, Jun Zhao, and Kang Liu. Menatqa: A new dataset for testing the temporal comprehension and reasoning abilities of large language models. arXiv preprint arXiv:2310.05157, 2023.
Xiaobao Wu, Liangming Pan, Yuxi Xie, Ruiwen Zhou, Shuai Zhao, Yubo Ma, Mingzhe Du, Rui Mao, Anh Tuan Luu, and William Yang Wang. Antileak- Preventing data contamination by automatically constructing benchmarks with updated real-world knowledge. arXiv preprint arXiv:2412.1367 2024.
Siheng Xiong, Ali Payani, Ramana Kompella, and Faramarz Fekri. Large language models can learn temporal reasoning. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 10452-10470, Bangkok, Thailand, August 2024. Association for Computational Linguistics. doi: 10. 10.118665 2024 acl-lcllonnn 563/
URL https: htttp:://aclantoolory.. org/
Kun Xu, Lingfei Wu, Zhiguo Wang, Yansong Feng, and Vadim Sheinin. Sql-to-text generation with graph-to-sequence model. arXiv preprint 180.005500 2018.
Reda Yacouby and Dustin Axman. Probabilistic extension of precision, recall, and score for more thorough evaluation of classification models. In Proceedings of the first workshop on evaluation and comparison of NLP systems, pp. 79-91, 2020.
Baosheng Yin and Naiyu Hu. Time-cot for enhancing time reasoning factual question answering in large language models. In 2024 International Joint Conference on Neural Networks (IJCNN), pp. 1-8. JEEE, 2024.
Tao Yu, Rui Zhang. Kai Yang. Michihiro Yasunaga, Dongxu Wang, Zifan Li, James Ma, Irene Li, Qingning Yao, Shanelle Roman, et al. Spider: A large-scale and cross-domain semantic parsing and text-to-sql task. arXiv preprint arXiv: 008808887. 2018.
dataset for complex
15

---

Published as a conference paper at ICLR 2026
Chenhan Yuan, Qianqian Xie, Jimin Huang, and Sophia Ananiadou. Back to the future: Towards explainable temporal reasoning with large language models. In Proceedings of the ACM on Web Conference 2024, pp. 1963-1974, 2024.
Bin Zhang, Yuxiao Ye, Guoqing Du, Xiaoru Hu, Zhishuai Li, Sun Yang, Chi Harold Liu, Rui Zhao, Ziyue Li, and Hangyu Mao. Benchmarking the text-to-sql capability of large language models: A comprehensive evaluation. arXiv preprint arXiv:2403.0299: 2024a.
Bin Zhang, Yuxiao Ye, Guoqing Du, Xiaoru Hu, Zhishuai Li, Sun Yang, Chi Harold Liu, Rui Zhao, Ziyue Li, and Hangyu Mao. Benchmarking the text-to-sql capability of large language models: A comprehensive evaluation, 2024b. URL httph:ttst//atttit org. htrgg/ab//2403.. 02951
Michael Zhang and Eunsol Choi. SituatedQA: Incorporating extra-linguistic contexts into QA. In Marie-Francine Moens, Xuanjing Huang. Lucia Specia, and Scott Wen-tau Yih (eds.), Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pp. 7371-7388 Online and Punta Cana, Dominican Republic, November 2021. Association for Computational Linguistics. doi: 10. 1001866611/222..cmm 2021. emnlp-main 5867
URL /
Bowen Zhao, Zander Brumbaugh, Yizhong Wang, Hannaneh Hajishirzi, and Noah A Smith. Set the clock: Temporal alignment of pretrained language models. arXiv preprint arX1v:200..16797, 2024.
Xinyi Zheng, Douglas Burdick, Lucian Popa, Xu Zhong, and Nancy Xin Ru Wang. Global table extractor (gte): framework for joint table identification and cell structure recognition using visual context. In Proceedings of the IEEE/CVF winter conference on applications of computer vision, pp. 697-706, 2021.
Victor Zhong, Caiming Xiong, and Richard Socher. Seq2sql: Generating structured queries from natural language using reinforcement learning, 2017.
00103 03
Fengbin Zhu, Wenqiang Lei, Youcheng Huang, Chao Wang, Shuo Zhang, Jiancheng Lv, Fuli Feng, and Tat-Seng Chua. Tat-qa: A question answering benchmark hybrid of tabular and textual content in finance. arXiv preprint 20Xiv2210S.0662, 2021.
Zhiyuan Zhu, Yusheng Liao, Zhe Chen, Yuhao Wang, Yunfeng Guan, Yanfeng Wang, and Yu Wang. Evolvebench: A comprehensive benchmark for assessing temporal awareness in 1lms on evolving knowledge. In Proceedings of the 63rd Anmual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 16173 16188, 2025.
16

---

Published as a conference paper at ICLR 2026
A
APPENDIX - MORE DETAILS ON TEMPORAL DATABASES
A.1
TEMPORAL DATABASES ACROSS DIVERSE DOMAINS
Continuing from Sec. we introduce examples of temporal databases, widespread across many
critical domains:
Healthcare: Electronic Health Records (EHRs), patient timelines, treatment records (Johnson et al.] 2016) Pollard et al. (018))
Finance: Trading records, transaction histories, regulatory data (Zheng et al. 202T)
2021 Zhu et al.
Enterprise: Supply chain, Customer Relationship Management (CRM), Human Resources (HR)
databases (Jensen & Snodgrass 2018
Public platforms like Kaggle and government data portals also provide readily accessible datasets across diverse domains, as demonstrated in experiments in Sec. 4 with Legal, Environmental, Cultural, and Social domains. Despite this prevalence, current TSQA research is highly centered in few data platorms like Wikipedia and Wikidata (Sec. 5). which motivates to enable the use of these widespread, yet unexplored data for TSQA benchmarking.
A.2 FORMAL DEFINITIONS OF FDs AND TFDS
Continuing from Sec. 2 we show formal definitions on temporal functional dependencies (TFDs) and temporal joins, the two properties of temporal databases used in our framework.
Notations We begin by introducing the notations used throughout this section. Let R and S be temporal relation schemas, each associated with two timestamps T, and T. denoting the start and end of tuple validity, respectively:
R = (A1..... An.
Ck. Te) S = L=B....... Bmy CI....., ..... C2 Te).
For an effective illustration, let {A.)- and {B:} denote the unique attributes of schemas R and S, respectively, and let (C represent the common attributes shared by both relations and S.
Definition of Temporal functional dependencies (TFDs) TFDs are defined following Jensen et al. (1996). Definition A. formalizes that, over any time interval 12). tuples that agree on X must also agree on Y.
Definition A.1 (Temporal functional dependencies). Let X and be sets of non-timestamp attributes of a temporal relation schema R, and let t1 and t2 be arbitrary times, with t1 not exceeding the current time. temporal functional dependency, denoted as Ig Y, exists on R for all meaningful instances of R that is, database states that valid, consistent, and free of contradictions the following holds:
V1,12, Vun, u2 TTy (pr, (r)), [i = uu] = un [ (2[Y)
where Pt₂ (r) selects tuples valid at E,, and Te2() further restricts the result tuples visible at l2.
Temporal Joins Temporal natural joins are defined following Jensen & Snodgrass (2018). In- tuitively, temporal natural join combines tuples from two relations that agree on their common attributes and are simultancously valid in time (i.c., have overlapping validity intervals).
Definition A.2 (Temporal natural join). Let and be instances of R and S, respectively. The temporal natural join of r and s, denoted as ba 8, is defined as:
r T s == [z| Du E r, Du E (u[C1, Ck] = u(C,, Ckl
a[A Anl w/A Anl A [ BI,..., Bm] BiB,,... Bm] A 2(C1, Cil viCI, CaJA [T] = wwweiaa(llTT........ooo. Tel, t (T,, T.)) xTT,, Te] + 0))
where Z represents the result tuple, and overlap(u T.], v TT T.]) computes the intersection of the validity intervals from and u.
17

---

Published as a conference paper at ICLR 2026
Algorithm 1 The proposed Genqueries algorithm
Input: Temporal database relation s with schema list of temporal functional dependencies (TFDs;
Sec. 2 F = (X1 Y..... X, - } where X; and Y, denote sets of attributes in the schema S for i E n, list of temporal relations R {before, after contain) shown Table 10
Output: List of generated temporal SQL queries G
1: g 0
do 2: for each tuple
3:
for each TFD f: :X; Y
4:
# Phase 1: Generate base query using TFD 9b 5- SELECT Y, FROM s WHERE X, = u.X,
5:
6: # Phase 2: Add temporal constraints for each operation r E R do
7:
8:
Sample random time interval b (t.,
9:
4b + r(u, b) according to Table 10 G g {g+)
11: end for
end for
13:
end for
14:
return
In Definition A.2 the first two lines ensure that tuples and match on the shared attributes {C:) (1)==1
and concatenate the unique attributes (A,)²= and (B; } along with a single copy of (C,) The third line means the join operation is performed only on tuples with overlapping validity intervals.
B APPENDIX MORE DETAILS ON TDBENCH FRAMEWORK
Continuing from Sec. and Sec. we provide more details on the proposed TDBench framework.
B.1 MORE DETAILS ON GENQUERIES ALGORITHM
Continuing from Sec. 3.1 and Sec. 3.2 we provide more details on the proposed Genquer ries algorithm (Alg. M. which systematically generates temporal SQL queries from an input temporal database. We provide the pseudocode and the potential extension to more diverse temporal scenarios.
Algorithm Procedure of Genqueries We explain the Genqueries algorithm (Alg. D line by line. Genqueries es begins by initializing an empty list of queries (Line 1). For each tuple in construct base SQL query by
the database and each TFD defined in the database (Lines 2-3), selecting the Y, attributes conditioned on the X, attributes of the tuple (Line 4). We then add temporal conditions to this base query (Line 5) by iterating over set of predefined temporal operations, such as "before", "after", or "overlap" (Line 6), using the relation-SQL. condition mapping in Table TO) For each operation, we sample random time interval (Line 7), adding the temporal constraint to the base query (Line 8), and append the resulting query to the output list (Line 9). After processing all tuples and TFDs, Genqueri es returns the complete set of generated temporal SQL. queries (Line 10).
Extending Genqueries We can further extend Genqueries to incorporate more diverse data attributes, data types, and TSQA evaluation scenarios.
Auributes beyond TFD-selected altributes: where users can manually specify alternative sets of question and answer attributes. For exam- ple, given the relation Leader( role. name, gender, start, end) (Table [ and the TFD country, role T name, one can extend the answer to include both name and gender, while still using country, role the question. Although this extension requires manual input specify attribute sets, Genqueri rinurriiess ies still greatly simplifies the QA construction process compared to manual construction template creation.
Genqueries also supports user-defined extensions
remi-strutured data: Although not our primary focus, Genqueries can be readily applied some stri-structured data by transforming this data into structured formats. For example, techniques like schema inference and normalization (DiScala & Abadi 2016 Baazizi et al. 2019) be utilized during the data preprocessing stage.
18

---

start, end Published as a conference paper at ICLR 2026
Other temporal QA tasks: In addition, SQL's expressiveness allows flexible extensions to richer question types. For example, aggregation operators (e.g.. GROUP BY, HAVING) enable event- counting questions like "Which president has been elected for the third time?". which can be generated from the condition "GROUP BY... HAVING COUNT (+)= =3" and require the model to count specific events throughout history.
B.2 GENERATED SQL CONDITIONS AND TIME ACCURACY CRITERIA
Continuing from Sec. 3 and Sec. we present the complete set of SQL conditions used in TDBench, derived from Allen's 's interval algebra (Allen 1983). Table [0] summarizes each temporal relation, its corresponding SQL implementation, an example temporal context, and the criteria used for time accuracy evaluation (Sec. 3.2).
Table 10: The complete set of SQL conditions for temporal context generation using Allen's interval algebra. Each interval relation is implemented contexts. We use a as the validity interval of a tuple (such as a president's term), while b is randomly sampled to generate various contexts according to the interval relation. The overlap relation has two implementations: one for the temporal reasoning task and the another for the "current" condition in the temporal alignment task (see more details in Sec. B.2). We also show ceaation-speiffi evaluation
SQL condition to create temporal
criteria for evaluating time accuracy.
Relation
Interval Diagram
SQL Condition
Example Temporal Context
Criteria
A president who ends hefore Septemher 20, 2000
before b
a.end b.start
end
A president who starts after March 20, 200!
o after b
o.start b.end
start
A president who ends
a meet
o.end = b.end - b.length
exactly half a year
end
before March 20, 2001
A president who starts exactly half a year after September 20, 2000
o mctt-by&
b
o.start b.start b.length
start
A president who starts before September 20, 2000 and
a.start < b.start A b.start a.end b.end
ends between September 20, 2000 start, end
overlapp b
and March 20, 2001
a.start < b.start A a.end IS NULL
A president who is currently serving
start
A president who starts between September 20, 2000 and March 20, 2001 and
a.end > b.end A b.start < o.start < b.nnd
a overlapped-hy
ends after March 20, 2001
A president who starts in
a.start b.start a.end = b.end
a equal &
September; 2000 and
start, end
ends in March, 2001
president who starts in September, 2000 and ends before March, 2001
a.start = b.start A a.end < b.nnd
o start
start, end
a.start = b.start A a.end > bennd
A president who starts in September, 2000
a started-hy
start
president who starts after September 20, 2000 and ends in March, 2007
a.start > b.start A a.end = b.end
finish b
start, end
a.start < h.start A a.end < b.end
A president who ends in March, 200!
finished-by 6
end
A president who starts after September 20, 2000 and ends before March 20, 2001
a.start > b.start A a.end < bennd
during b
start, end
A president who starts before September 20, 2000 and ends after March 20, 2001
a.start < h.start a.end > h.end
contain b
start, end
19

---

Published as a conference paper at ICLR 2026
Handling Time Constraint of "Current" In Table 10 note that the overlap relation is modeled with two separate SQL implementations to support both temporal alignment and temporal reasoning task scenarios. For temporal alignment, which evaluates whether LLMs provide up-to-date knowledge, is necessary to represent the "current" time condition. Depending on the data format, the "current" condition can be encoded by setting the end date a special value, such maximum date 99-99-99 or NULL. We adopt the NULL format because it produces more readable SQL predicates (c.g.. end IS NULL) and simplifies the next step of SQL-to-text conversion process (Fig. DD. With this approach, the "current" condition is treated as special case of the overlap relation, where the interval starts before the present and has no defined end. This dual implementation allows to flexibly generate both current (temporal alignment) and general (temporal reasoning) temporal contexts.
B.3 HANDLING MISSING, UNKNOWN, OR INVALID TFDS
Continuing from Sec. 3. we discuss how to handle cases where TFDs missing, unknown, or invalid in the input temporal database of TDBench framework.
Missing TFDs If TFDs are not present in the database schema, users can manually specify which attribute sets to use for question and answer generation. While this approach allows TDBench to be flexibly applied even without explicit TFDs, it introduces additional manual cost.
Unknown TFDs When TFDs are not known in advance. users employ automated FD/TFD discovery tools (c.g., Dep-Miner (Lopes et al.] 2000), FastFDs (Agrawal et al.] 1993). DFD (Abedjan let al. 2014), and the Python library FDTooo (Buranosky et al. (2099) to infer candidate dependencies from the data. This is particularly useful for large or complex schemas, or when users are unfamiliar with the database structure.
Invalid TFDs a TFD does not strictly hold due data anomalies noise, the generated QA pairs still reflect the actual database contents. This is because, as illustrated in Table 3 TDBench utilizes SQL-based grounding when constructing QA pairs, so all answers are consistent with the underlying database. However, in such cases, the answer set may include multiple valid answers, which may compromise the original intent of unique-answer questions. settings, the lack of valid TFDs can lead incorrect QA construction. To prevent such cases, users are encouraged to clean the data and validate TFDs in advance. Our official implementation provides Python code for automatic TFD validation to help users detect and address these issues.
more complex multi-hop
B.4 MORE DETAILS ON NATURAL LANGUAGE QA CONVERSION
Continuing from Sec. we provide more details on the natural language conversion step, where we use GPT-4o (OpenAl 2024) as an SQL-to-text translator.
System Prompt for SQL-to-text The following prompt is example system prompt used in zero-shot setting for SQL-to-text conversion. We set the temperature parameter of GPT-4o to 0.3 to promote diverse paraphrasing. The prompt instructs the model to convert SQL queries into natural language questions based on the given schema and generate three different phrasings per query, where more than three questions be generated if desired by modifying the prompt accordingly.
The following SQL query is about relaticnal database Leader (country, role, name, start, end), where start and end represent date information. Convert the provided SQL query into a natural language question. Generate three different questions, each starting with Q: Only return the generated questions.
Accuracy of SQL-to-text We assess the accuracy of SQL-to-text conversion in the above setup by randomly sampling 130 generated questions during the conversion and manually verifying whether the questions correspond to the underlying query. We observe 91.5% accuracy, consistent with recent findings that modern LLMS have strong zero-shot performance on SQL-to-text tasks (Zhang et al. 2024a). We analyze error cases as follows:
20

---

Published as a conference paper at ICLR 2026
Prime ministers of Japan Japanese prime minister: Although a prime minister of a country may not necessarily be a citizen, the model often assumes nationality based on the position, making this the most common eπror type.
November 1st + November: In some cases, specific dates (c.g.. November 1st) are generalized to the corresponding month (e.g., November), introducing potential ambiguity.
Calculation error: When processing temporal operations like DATE((2006017) 2006-07-17 00:00:00", '-2 months") ) in the query, the model occasionally makes date calculation enrors. However, such emrors are relatively rare, occurring in fewer than 1% of cases.
Examples Generated QA pairs addition to the example QA pairs shown in the main text (Table B) generated from the "meet" relation, present additional examples across temporal relations. Table [T] and Table show QA pairs derived from the "contains" and "overlap" relations, respectively, which are examples of temporal relations rarely covered in prior TSQA benchmarks. Table [3ble(T]aar shows QA pairs from an additional SQL. condition for the "overlap" relation, specifically designed to target current data (see Sec. B.2 for more details). Table [4 shows multi-hop QA pairs generated by using temporal joins (Sec. A.2
Table 11: QA pair generation from an SQL query ('contain' relation). The query is translated to multiple natural language questions with the same answer. To evaluate both answer and time accuracy, the query also outputs a relation-specific time reference (e.g., start and end for the "contain' relation), defined in Table I0
SQL Query (relation="containn)
Generated QA
SELECT name, start, end FROM Leader WHERE Country= 'Japan' AND Role= 'Emperor' AND Start 22019-10-011 AND End > 22024-08-22
[Questions] "Who was the Emperor of Japan whose term started before October 1, 2019, and ended after August 26, 20247", "What the name the Emperor of Japan who began their role before October 1, 2019, and ended it after August 26, 2024?"...
[Answer] Akihito [Time reference] 1989-01-07 (start), 2019-05-01 (end)
[Model Response (Gemma2-27B3) Akihito. He reigned from 1989-01-00 2019-05-01.
Table 12: QA pair generation from an SQL query ('overlap" relation that models basic temporal reasoning). The query translated multiple natural language questions with the same answer. To evaluate both answer and time accuracy, the query also outputs a relation-specife time reference (e.g.. start and end for the 'overlap' relation), defined in Table T0
SQL Query "overl""=""verlapp))
Generated QA
SELECT name, start, end FROM Leader WHERE country='Gernane Role= 'President' AND Start '2003-09-30' AND End BETWERN -2003-09-30' and 12007-06-30
[Questions] "Who was the president of Germany who started their term before September 30, 2003, and ended their term between September 30, 2003, and June 30, 2007?", "Can you the names of the presidents Germany whose terms hegan before Septemher 30, 2003, and ended hetween September 30, 2003, and June 30, 2007?"...
AND
[Answer] Johannes Rau [Time reference] 1999-07-01 (start), 2004-06-30 (end)
[Model Response (Qwen2-72B)) Johannes Rau, who started his term on July 1999, and ended it June
30, 2004.
B.5 FORMAL DEFINITION OF TIME ACCURACY
Continuing from Sec. 3.2
present the formal definition of the proposed time accuracy metric.
We begin by defining the set of time references T, which captures the time references to be verified in LLM responses. Since we primarily generate questions asking about real world events each grounded with a start date and end date- we set T {t., J, where t, and t, denote the start and end dates, respectively.
21

---

Published as a conference paper at ICLR 2026
Table 13: QA pair generation from an SQL query ('overlap' relation that models the temporal constraint of "current"). The query is translated to multiple natural language questions with the same answer. To evaluate both answer and time accuracy, the query also outputs a elation-specifie time reference (e.g., start), defined in Table T0)
SQL Query (relation=""verraa"))
Generated QA
SELECT name, start
[Questions] "Who currendy serving as the King Netherlands?", "What is the name individual who the reigning King in the Netherlands?"...
FROM Leader WHERE
Ccuntry- 'Netherlanda' AND
Rcle- 'King' AND End 1S NULL
[Answer] Willem-Alexander
[Time reference] 2013-04-30 (start)
[Model Response (Llama3.1-70B) King Willem-Alexance since April 2013.
Table 14: QA pair generation from an SQL query (for a joined table). The query translated to multiple natural language questions with the same answer. To evaluate both answer and time accuracy, the query also outputs timestamp attributes (c.g., start, end). x² denote the temporal join operator, which only joins tuples with overlapping validity intervals sce formal definition of temporal join in Sec. A.2
SQL Query (temporal
Generated QA
SELECT name, start, end FROM Leader x" Olympic WHERE game come_edition-11 77h Winter' AND "residenn
[Questions] "Who the president of the host country for the 7th Winter Olympic Games?", "Can you provide the name of the president the host country during the 7th edition of the Winter Olympics?"..
[Answer] Giovanni Gronchi
[Time reference] 1955-05-11 (star), 1962-05-11 (end)
[Model Response (GPT-4o)] The 7th Winter Olympic Games were held in Cortina d' Ampezzo, Italy in February 1956. The President of Italy that time Giovanni Gronchi, who served from May 1955 to May 1962.
We then define the question-reference function f - T, which maps question to the time references to be verified. This function can be flexibly designed based on the temporal contexts expressed in the question. In our setup, the underlying SQL queries explicitly specify which time reference are relevant to answer selection process (e.g., an SQL condition such as "start January 2001" implies reliance start date t.). Accordingly. we define f with respect to the temporal relation used in the SQL query, as summarized in Table I0
We finally define the time accuracy T given question follows:
(t E f(g) t E model response)| x 100(%).
T(g)
(1)
[(())
Note that for temporal relation types requiring multiple time references (e.g., 'contain' in Table 11 partial credit is given when only a subset is correctly included in the model response.
B.6 TIME ACCURACY EVALUATION WITH LLM-
Continuing from Sec. 3.2
we provide more details on time accuracy evaluation, where we use Deepseek-R1-14B (uuo al. 2025) as an LLM-judge.
System Prompt for LLM-Judge The following system prompt shows the instruction for time
accuracy evaluation, consistent with the formal definition in Eq. [ As shown in the prompt, we opt to
LLM-Judge capture various expressions of time references (e.g.. "26 Jan 2025". "2025/01/26",, which may be missed by exact-match methods that directly compares gold time reference strings Deentity_date against the evaluated model response ( (response)).
22

---

Published as a conference paper at ICLR 2026
You are given reference **start date** and **end date... Check whether the response correctly includes both dates, even if they are expressed in a different but equivalent format (e.g., '26 Jan 2025', *January 26, 2025', '2025/01/26', etc.).
If **both** of the two dates is are correctly mentioned with the intended meaning (i.e., the start date is described as the start date, and the end date as the end date), respend with "Yes"****
If **ne** of the two dates is correctly mentioned with the intended meaning, respond with **"Half***.
If **eithhrr* date is correctly menticned with the correct meaning, respond with ***N.*.. Your answer must be one of: "Yes', 'Half', or 'No'. Be concise.
(entity_date)
**Rosponso:** (response)
**Answer:
Accuracy of LLM-Judge in Time Accuracy Evaluation Similarly to the manual verification setup in Sec. B.4 we assess the effectiveness of LLM-Judge in time accuracy evaluation by randomly sampling 130 responses and manually verifying whether the evaluation aligns with the instruction above. We observe 91.1% % accuracy, with most errors arising from instruction misinterpretation (e.g.. assessing end dates when only assessing start dates is required) and date match failures (e.g., failing match the gold time reference of "1993-04-28" and "April 1993" in the model response).
We note that using stronger LLMs can further enhance evaluation correctness; for instance, we observe that using GPT-4o under the same setup yields higher accuracy (95.5%). However, we opt not to use GPT-4o in our main experiments, as it is one of the evaluated models and may incur potential bias during evaluation if used judge.
Extending Time Accuracy to Non-standard Temporal Units While TDBench does not consider non-standard temporal units (e.g., partial months, fiscal quarters) first-class representations, TDBench is highly extensible as follows:
Open intervals using null formats (e.g., (2025-11-14, NULL)), as utilized in generating temporal alignment questions (Sec. B..2p.
Granularities beyond date using a mapping to a set of time ranges. For example, mapping FY2020 Q1 = 12020-01-01, 2020-03-31,, FY2020 Q2 = [2020-04-01, 2020-06-30 for fiscal quarters, and "early June 2020" = [2020-06-01, 2020-06-10] for partial months. Finer-grained time representation using built-in database data types (e.g., 2020-01-01
13:10:01 via TIMESTAMP type).
In addition, updating the benchmark to incorporate such granularities is easy for TDBench, where only database-level preprocessing is required, and TDBench will automatically regenerate the benchmark. Extending to more nuanced temporal information such as uncertain intervals remains as valuable future direction.
B.7 ADDITIONAL CONTEXT CONSTRUCTION
Continuing from Sec. 3.2 we provide more details on context construction used in the open-book setting. As illustrated in Fig 4 we append both relevant rows and irrelevant rows from the table with the gold answer effectively evaluate LLMs' temporal reasoning abilities given time-sensitive question. Relevant rows are retrieved by (1) removing the temporal condition from the underlying SQL query of the question and (2) executing the modified query the database, returning entities across different periods (c.g.. all U.S. presidents when the question asks about the U.S. president in 2019). We randomly sample the irrelevant rows in the table.
23

---

Published as a conference paper at ICLR 2026
Country
Role
Name
Start
End
Open-book QA
-
-
- ---_= --1
President Sharma 1992-07-25
1997-07-25
Relevant
India President Kovind 2017-07-25
2022-07-25
India President | Narayanan 1997-07-25 2002-07-25
rows
France President Chirac 1995-05-17 2007-05-16
Egypt| Prime Minister Madboulyy | 2018-06-14 nan
Irreevant
Austria
Chancellor Bierlein 2019-06-03 2020-01-07
rows
Q: Who was the President of India that started his term after May 31.
1996, ended his term between July 2002, and July 31, 2002?
Closed-book QA
Figure 4: Open-book Closed-book QA in TDBench. The open- bpen-book setting provides table rows as additional context, while the closed-bool setting provides only the question.
C APPENDIX MORE DETAILS ON EXPERIMENTAL SETUPS
Continuing from Sec. we provide more details on the experimental settings and datasets used.
C.I EXPERIMENTAL SETUPS AND SYSTEM PROMPTS
Experiment Settings We use the following LLM versions: GPT-3.5 (2024--0-001prreview)) GPT-4 -002-01-01-previeew), GPT-4o (2024-02-01), Llama3.1-708 (2024-07-23), Mixtral-8x7B (2023-12- 11), Gemma2-278 (2024-06-27), Qwen2-72B (2023-08-33) and Granite3. 11-a (2024-12-18). All experiments are conducted on NVIDIA Quadro RTX 8000 GPUs.
System Prompts for TSQA Tasks We use the following system prompts for the TSQA tasks: the upper prompt is used for the temporal alignment task (Sec. I. and the lower prompt is used for the temporal reasoning task (Sec. 4.2). As the prompts explicitly require time information in the rationale, responses that omit such references
marked incorrect in the time accuracy evaluation. This policy applied uniformly across all models to ensure consistent and fair TSQA benchmarking. reflecting goal of evaluating both final answers and explanations.
Answer the following question. Provide the short direct includes both the factual answer and the date information (month and year) of the fact, prefixed with the word 'since'. say 'unsure' if you don't know. Be concise.
that
Answer the following question. Provide the short direct answer that includes both the factual answer and raticnale with the date information of the fact. If there is no valid answer, respond with 'No answer'. Is there is one correct answer, return it as a short sentence. Is there are multiple valid answers, present them clearly as bullet points. If you unsure, respond with 'unsure', Be concise.
C.2 MORE DETAILS ON DATASETS
Continuing from Sec. we provide more details on the temporal databases used our experiments. Table 15 summarizes the schema, selected TFDs, and the number of questions generated from each dataset. Table 16 presents example questions generated by converting TFDs. Using these datasets, construct 2.079 temporal alignment, 6,756 temporal reasoning, and 396 multi-hop questions, with additional questions readily generable if needed.
Wikipedia We select domains following the conventional TSQA benchmarking literature (Dhingra)
al. 2022 Margatina al. 2023 Tan al. 2023 Mousavi et al. 2024), including Country, Athlete, Organization, and Olympic datasets. We also follow the entity selection step of Mousavi et al. (2024), which select entities likely appear in most LLM training corpora to reduce performance variance caused by entity frequency when retrieving facts (Mallen et al. 2023 Sun et al. 2023). All datasets were retrieved on 02 January 2025.
24

---

Published as a conference paper at ICLR 2026
Table 15: Details of the temporal databases used in our experiments (Sec.
Data Source
Question
Schema
TFD
Countyycconntry role, name, start, end)
country, role 3 name
Athlete(name. team, sport, start, end)
name, sport 3 team
Wikipedia
6,177
Organization(ors_aana type, role, name, start, end)
name, rype, role 2 name
Olympici gage_eooudddaaaoaeeeeeeo game game_edition, city country, season,
game_round. role 3, name (joined) game_edition, role 3 name (joined)
start, end)
Lawtcountry, law law_ legality, start, end)
country, law sype 2 legality
Carbon Taxfjurisdictio, tax tax_type, instru- ment name, status, start, end)
jurisdiction, type Tn status
Domain-specific 1,704
Heritage(heritage. eleeeet, member_stae heritage element status status, region, start, end)
Netflix(title, director, cast, release yelease_year, year, popularity, start, end)
nite 2 director
Medical(name, gender, blood type medication, doctor, hospital, insurance provvidr, billing ammount)
name, gender, blood_rye 2 doctor name, gender, blood_rype medication
Synthetic
1,350
Table 16: Examples of base questions generated from TFDs across datasets. The proposed
Genqueries algorithm (Alg. [ converts the TFDs listed in Table 15 into these base questions and augments them with diverse temporal constraints.
Data Source
Example Questions Generated From TFDs
Country: Who is serving as the president of Italy?
Athlete: What team Stephen Curry play in basketball?
Organization: Which person began their tenure as general secretary at the United Nations organization?
Wikipedia
Olympic:
Can provide the name of the president of the host country during the 7th edition of the Winter Olympics?
Law: Is joint adoption by same-sex couples legal illegal in Argentina?
Carbon Tax: the carbon tax mechanism Finland active?
Domain-
Heritage: Is the heritage element "Cheoyongmu" inscribed or proclaimed?
Netffix: Who directed the most recent release of the movie titled "Attack on Titan"?
Who was the doctor for Jerry Martin, male patient with blood type A+? Which medication given to Kenneth Jacobs, a female patient with AB+ blood type?
Synthetic
Domain-specific To demonstrate the applicability of TDBench beyond Wikipedia-based datasets, we model domain-specific TSQA scenarios across four contexts: Legal, Environmental, Cultural, and Social. These domains are represented by datasets on same-sex marriage laws sourced from the ILGA World database global knowledge base on legal frameworks and human right bodies, retrieved on 02 January 2025; carbon taxation data sourced from the World Bank Group's 's "State and Trends of Carbon Pricing Dashboard") retrieved on 17 October 2024; UNESCO heritage elements sourced from the official UNESCO website retrieved on 17 October 2024; and Netflix TV shows data sourced from k retrieved on 05 May 2025. For the Netflix dataset, only consider TV series that share the same title, but have been remade over time with different directors.
http://databbseelg..orrr////////
25

---

Published as a conference paper at ICLR 2026
Synthetic We also show how TDBench can be applied synthetic datasets by using the Medical dataset, which contains synthetic patient records sourced from Kaggle retrieved on 05 May 2025.
D APPENDIX MORE EXPERIMENTAL RESULTS
Continuing from Sec. we provide more details experimental results.
D.1 ERROR ANALYSIS ON TEMPORAL ALIGNMENT EVALUATION
Continuing from Sec. present example error cases in the temporal alignment task, where LLMs often hallucinate time references while providing correct answers. Table 17 and Table show such responses from the Heritage and Netflix datasets, respectively, where LLMs generate inaccurate time references (e.g.. "December 201 1" and "Jamuary 2020") alongside correct answers (e.g.. "Inscribed" and "Mehmet Ada Öztekin"). These cases indicates that L.Ms struggle accurately align the time references with the factual answers, highlighting that capturing temporal misalignment in model explanations can be critical yet overlooked issue in the current temporal alignment task.
Table 17: Example LLM responses on the temporal alignment task using the Heritage dataset. The time granularity used for time accuracy is year.
[Question] Is the UNESCO heritage element "Cheoyongmu" currently inscribed or proclaimed? [Answer] Inscribed
[Time reference] November 2009 istart)
[Model Response]
GPT-3.5: Since Inscribed (7) December 2011
GPT-4: Inscribed (v) since November 2009 (V).
GPT-4o: Inscribed (V) since November 2009 (V).
Llama3. 1-BB: Inscribed (v) since November 2009 (V).
Mixtral 8x7B; Proclaimed (X) since December 2017 (o.
Gemma2-27B: Inseribed (/) since November 2022 (9.
Qwen2-72B: "Cheoyongmu" has been inscribed (V) on UNESCO's list since 2015 (X).
Granite3.1 1 188B Inscrihed (v) since 2019 (X)
Table 18: Example LLM responses on the temporal alignment task using the Netflix dataset. The time granularity used for time accuracy is year.
[Question] Which director was involved in the most recent version of "Miracle in Cell No. 7 [Answer] Mehmet Ada Öztekin
[Time reference] October 2019 (start)
[Model Response]
GPT-3.5: Since January 2020 (X), director of latest release of "Miracle in Cell No.
Mchmet Ada Öztekin (v).
GPT-4: Since March 2020 the director of the most recently released movie "Miracle in Cell No. 7" is
Mehmet Ada Öztekin (V).
GPT-4o: Since October 2023 (0), the director of the most recent "Miracle in Cell No. 7" movie is
Mehmet Ada Öztekin (V).
Jlama3.1-70B: Lee Hwan- twann-kyng (0, since January 2019 (/).
Mixtral-8x7B: Sure, since January 2019 (V), the director of the latest release of "Miracle in Cell No. 7" is
Mehmet Ada Öztekin (V).
Gemma2-27B: Since August 2023 (9), the director of the latest release of "Miracle in Cell No. 7"
Lee Hwan-kyumg (X).
Qwen2-72B: The original film was released in 2013 and a Chinese remake directed by Zhang Lüi (0)
was released in January 2021 (X).
Granite3. 1-BB: The most recent version of ""Miracle in Cell No. 7" was directed by Lee Jae-gon (8).
since 2019 (7).
26

---

Published as a conference paper at ICLR 2026
D.2 INTEGRATING TIME ACCURACY EXISTING TSQA BENCHMARKS
Continuing from Sec. 4.] we provide a detailed case study with Dyknow (Mousavi et al. 2024). one of the TSQA benchmarks that employs open-ended QA templates (e.g., "The president of Italy is _"" (Dhingra et al. 2022; Margatina et al., 2023) to assess whether LLMs are temporally aligned with the current world.
While Dyknow evaluates LLM responses as correct (Cor.), outdated (Out.), or incorrect (Inc.) based on the parsed answer, we modify their system prompt to explicitly generate start date references to incorporate time accuracy. We then assess the correctness of each evaluation method (i.e., with and without time accuracy) against manual verification on 125 randomly sampled responses per model, where we recruit five graduate student annotators and distribute total 1,000 responses from eight LLMs, ensuring that each response is evaluated by at least two annotators. We measure the correctness with precision (P), recall (R), and Fl-score (FI), standard metrics for classification (Ycoobyy & Axman 2020) with definitions provided below.
Precision: The proportion examples labeled as a given class (e.g., correct, outdated, and incorrect) by the evaluation method that also judged as the same class by human annotators.
True Positives
Precision True Positives False Positives
Recall: The proportion examples judged to a given class (e.g.. correct, outdated, and incorrect)
by human annotators that also labeled as the same class by the evaluation method.
True Positives
Recall
True Positives + False Negatives
Fl Score: The harmonic mean of precision and recall, providing balanced measure of alignment with human judgment.
Precision Recall
Fl Score X
Precision + Recall
As shown in Table 19 integrating T consistently improves all metrics over the original method, leading to higher evaluation correctness. These results demonstrate the value of time accuracy as a complementary evaluation criterion to traditional answer accuracy. We note that the integration straightforward for other TSQA benchmarks that employ open-ended question formats similar to Margatina et al. 2023), requiring only minimal prompt modifications.
Dyknow (Dhingra et al. 2022
Table 19: QA Evaluation correctness of DyKnow (Mousavi et al. 2024,, with and without time accuracy metrie (T), Human evaluation correctness used as the ground truth.
Methods
P
R
FI
Human 1.00
1.00
1.00
Correct (1)
Dyknow
0.67
0.92
0.77
Dyknow
0.98
0.95
0.96
Human
1.00
1.00
1.00
Outdated (L)
Dyknow
0.69
0.78
0.73
Dyknow +
0.95
0.88
0.91
Human
1.00
1.00
1.00
Incorrect (L)
Dyknow
0.32
0.60
0.39
Dyknow
0.58
0.84
0.64
D.3 TEMPORAL SPAN ANALYSIS AGGREGATED ACROSS MULTIPLE DOMAIN
Continuing from Sec. 4.2 we provide more results temporal span analysis. In addition to Fig. 3 that shows LLM performances by temporal span evaluated on a single domain, we show aggregated results in Fig. elevllaee multiple domains: Country, Athletes, and Organizations. Compared to the single domain results, LLM performances diverge more clearly, suggesting that domain -spccffcc fluctuations smoothed out and model-specifie behaviors become evident when multiple
27

---

Published as a conference paper at ICLR 2026
domains considered. General trends notable performance drops in recent years (2020-2025) while having performance peaks in 2010-2015 are still observed, which are consistent with recent
findings (Dhingra et al. 2022 Mousavi et al. 2024
Zhao et al. 2024).
GPT-3.5
GPT-4o
Mixtral Gemma2
Qwen2
GPT4
Liama3
Granite3
90
Answer Accuracy (%)
80
70
60
1985-1990
1990-1995
1995-2000
2000
2000-2005
2010
2010-2015
2015
2015-2020
2020
2020-2025
2005
2015
Figure 5: LLM performances across different time spans (1985-2025) in the closed-book setting, evaluated on multiple domains: Country, Athletes, and Organizations.
D.4 MORE DETAILS ON EXPERIMENTS WITH PERFORMANCE IMPROVEMENT TECHNIQUES
Continuing from Sec, 4.3 we provide more details on experiments with performance improvement
techniques: RAG (Lewis al. 2020), CoT (Wei et al. 2022), and Time-CoT Yin & Hu 2024).
CoT and Time-CoT Prompts The upper and lower prompts are used for the CoT and Time-CoT settings, respectively. As illustrated, Time-CoT prompts provide more detailed intermediate steps for temporal reasoning. such as presenting relevant historical timelines (c.g., sequences of presidential terms) when compared to standard COT.
Q: who was the vice president Olympic Games?
host country for the 31th Surmer
A: Michel Temer. The 31th Summer 0lympic Games were held in August 2016 in Rio. The host country Brazil. The Vice President of Brazil in August 2016 was Michel Temer. The answer Michel Temer.
Q: Can you provice the name of the governor-general of the host country during the 27th edition of the Summer olympics? A: william Deane. The 27th edition of the Surmer 01ympics were held September 2000 Sydney. The Governor-General of Australia in September 2000 was william Deane. The answer is William Deane.
host country was Australia.
0: Can you identify the president of the hest country for the Secul 1988 Olympics?
A: Roh Tac-woo. The Sccul 1988 Olympics were held in september 1988. The host country was South Korea. The president of South Korca in September 1988 was Roh Tae-woo. The answer is Roh Tae-woo.
Q: Who held the position of general secretary in the host country during the 1980 Olympic Games in Moscow?
A: Leonid Brezhnev. The Moscow 1980 Olympics were held in July 1980. The host country Soviet Union. The general secretary of Soviet Union July 1980 Lecnid Brezhnev. The answer leonid Brezhnev.
Q: Can you identify the president the hest country for the Scoul 1988 Olympics?
A: Let's think step by step. First, Secul 1988 Olympic Games were held in September 1988, South Korea. Then, we need to find out who was the president of South Korea according to timeline. 1989-1993: Rah
28

---

Published as a conference paper at ICLR 2026
Tae-woo, 1993-1998::in saung-sam. Then, need to focus the time 1988. so we can chtain the answer Rch Tae-woo, Therefore, the answer is Roh Tаc-woo.
Q: Who held the pesition of general secretary in the host country during the 1980 Olympic Games in Moscow?
A: Let's think step by step. First, Moscew 1980 Olympic Games were held in July 1980, Soviet Union. Then, we need to find out who was the general secretary of Soviet Union according to timeline. 1964-1982: Leonid Brezhnev, 1982-1984: Yuri Andropov. Then, need to focus on the time 1980. we can obtain the answer leonid Brezhnev. Therefore, the answer is Leonid Brezhnev.
Q: What is the name of the monarch of the host country for the Oslo 1952 Olympic Games?
A: Let's think step by step. First, Oslc 1952 Clympic Games were held in February 1952, Norway. Then, we need to find out who was the monarch of Norway according to timeline. 1905-1957: Haakon VII, 1957-1991: Clav V. Then, need to focus the time 1952. So can obtain the answer Haakon VII. Therefore, the answer is Haakon VII.
Q: which emperor was in charge of the hest country during the Sapporo 1972 Olympic Games?
A: Let's think step by step. First, Sappore 1972 Olympic Games held in February 1972, Japan. Then, we need to find out wno was the president of Japan according to timeline. 1926-1989: showa, 1989-2019: Akihito. Then, we need to focus on the time -- 1972. So we can obtain the answer is Showa. Therefore, the answer is Showa.
Case Study of Temporally Misaligned RAG to account for temporal cues embedded in the question. Table 20 and Table 21 present illustrative examples of such temporal misalignments, where retrieved documents from Wikipedia describe the Olympics from incorrect time periods provide generic explanations of the Olympics.
We observe that standard RAG methods often fail
Table 20: Retrieved Wikipedia passage describing the 1964 Winter Olympics, given the question asking about the 7th Winter Olympies (held in 1956).
[Question] Who was the president of the host country for the 7th Winter Olympic Games?
[Retrieved Document] The 1964 Winter Olympics, officially known as the IX Olympic Winter Games (German: IX. Olympische Winterspicle) and commonly known as Innsbruck 1964 (Austro-Bavee Bavarian: Innschbruck 1964), were winter multi-sport event which was celebrated Innsbruck, Austria, from January 29 to February 9, 1964.
Table 21: Retrieved Wikipedia passage describing generic information about the Olympics, given the question asking about the 4th Summer Olympics.
[Question] Who was the Prime Minister of the host country during the 4th edition of the Summer Olympic Games?
[Retrieved Document] The modern Olympic Games (Olympics: French: Jeux olympiques) are the world's lcading international sporting events. They feature summer and winter sports competitions which thousands of athletes from around the world participate in a variety of competitions. The Olympic Games considered the world's 's foremost sports competition, with more than 200 teams, representing sovereign states and territories, participating...
Robustness analysis of RAG across Temporal Constraint Type Motivated by the underperfor- mance of RAG observed in Table 7 we conduct more ine-grained performance analysis, evaluating the robustness RAG across different temporal constraint types. We measure RAG's success rate in retrieving gold documents (those containing the answer).
29

---

Published as a conference paper at ICLR 2026
Table 22: RAG's success rate across 13 temporal relations, as defined in Table 10,
Performance Level
Temporal Relation (Success rate)
High (> 0.45)
after (0.67), equal (0.50)
Medium (0.45-0.25)
contain (0.33), started-by by (0.33), overlapped-by (0.31),
start (0.31), finished-by (0.27)
Low (< 0.25)
before (0.20), met-by (0.17), meet (0.17), finish (0.15),
during (0.14), overlap (0.14)
Table shows two key insights: (I) Robustness gap across temporal expressions, where RAG shows 2-4x lower success rates nuanced operations (e.g., 'overlap': 0.14, 'meer': 0.17) compared to common operations (e.g.. 'equal': 0.50, 'after': 0.67); (2) Performance asymmetry between inverse operations, where performance vary dramatically for semantically opposite pairs 'before' (0.20) underperforms "after' (0.67) by 3.3x, while some other pairs like 'start' (0.31) and 'started-by' (0.33) remain comparable. We believe this kind of analysis can be further applied to diagnose recently developed Temporal RAG strategies (Piryani et al. 2025), such as temporal re-ram re-ranking, time-filtered retrieval, or query rewriting.
Impact of Performance Improvement Techniques on the Single-hop Setting In addition to the multi-hop setting presented in the main text (Table[7, we provide more results on single-hop questions. Specifically, apply the same performance improvement techniques the questions used the temporal reasoning task (Sec. (42) under the closed- book setting to examine the effectiveness of each technique RAG for providing up-to-date knowledge, and Co'T and Time-CoT for improving temporal reasoning and report the results in Table 23 Interestingly, all techniques greatly improve performances on None-type questions, where we observe that models tend respond with "no answer" more frequently, possibly rejecting to respond if they are uncertain for their reasoning. In addition, when the additional contexts retrieved via RAG do contain the gold answer due the temporal misalignment issue discussed above we also observe that models tend to respond with "no answer" rather than relying on their own knowledge, which degrades performances on Multiple- and Unique-type questions while improving performance on None-type questions. As with the multi-hop results, we observe similar performance between CoT and Time-CoT the single-hop setting.
Table 23: LLM performances with different performance improvement techniques (RAG, CoT, and Time-CoT) on single-hop questions. We report performances across question types categorized by answer cardinality: Multiple, Unique, and None, evaluated on the Wikipedia dataset under the closed-book setting. The results are compared with the original setting (Orig.). We report AT for Multiple and Unique type questions, and A for the None-type questions, no time reference is expected in no-answer cases.
Multiple
Unique
None
Model
Orig.
RAG CoT Time-CoT
Orig.
RAG
CoT Time-CoT Orig.
RAG
CoT Time-CoT
GPT-3.5
12.4
14.2
9.0
0.4
38.7
26.6
26.6
12.7
56.8
54.2
83.9
97.1
GPT-4
20.2
25.1
21.0
30.0
61.3
54.3
65.9
57.3
19.0
39.6
51.6
74.7
GPT-4o
34.5
30.7
24.3
32.6
65.1
59.2
62.9
62.9
37.4
43.2
60.4
50.2
Llama3.1-70B
20.6
8.6
16.5
19.9
59.4
34.5
68.9
48.7
22.0
54.9
25.3
33.3
Mixtral-8x7D
10.9
9.7
8.6
15.4
40.6
30.3
50.9
48.7
28.9
16.5
30.8
26.7
Gemma2-27B
24.3
13.9
19.9
21.3
59.4
45.7
62.2
62.5
6.2
16.8
10.6
12.1
Qwen2-72B
19.1
17.2
13.5
12.7
$7.5
51.7
59.2
59.9
20.1
32.6
38.8
39.6
Granite3.1
6.7
4.9
4.9
7.1
34.1
15.7
22.8
20.6
20.9
43.6
76.9
60.1
D.5 MORE DETAILS ON CORRECTNESS ANALYSIS
we provide a more fine-grained correctness analysis result. Similarly to the manual verification setup in Sec. D.2 manually verify 125 randomly sampled responses per task and measure the correctness using precision, recall, and Fl score. As shown Table 24 TDBench exhibits high agreement with manual verification, achieving higher precision than recall.
Continuing from Sec. 4.4g
30

---

Published as a conference paper at ICLR 2026
This result indicates that TDBench effectively capture responses with both correct answers and valid temporal reasoning, while some incorrect explanations -partiullrly those unrelated to temporal references remain challenging to detect.
Table 24: Correctness of TDBench against manual verification across question subeategories. We Precision, Recall, and Fl score metric definitions in Sec. D.2
Task
Temporal alignment (Average)
0.98
0.96
0.97
Temporal reasoning (Multiple)
0.85
0.88
0.86
Temporal reasoning (Unique)
0.81
0.87 0.83
Temporal reasoning (None)
0.89 0.90
Temporal reasoning (Average)
0.87
0,91 0.88
Multi-hop (Average)
0.95
0.87 0.91
D.6 EVALUATION ON SYNTHETIC MEDICAL DATA
demonstrate how TDBench can be applied to synthetic datasets, as long as the underlying tables used in TDBench have TFDs satisfied. We use synthetic medical dataset consisting of synthetic records of patients at hospital, and ask questions about doctors and medication by using TFDs name, gender, blood _opped__peeP______ f doctor and name, gender, blood_typ + medication see example questions in Sec.
Continuing from Sec. 4.5
Table 25 shows improved LLMs performances compared to the performances on real-world factual questions, particularly for Multiple- and None-type questions. We hypothesize that this improvement may stem from reduced interference by the model's internal knowledge. As the data is synthetic and unfamiliar, models are more likely to focus on the explicit temporal context provided in the prompt, potentially leading more accurate temporal reasoning.
Table 25: LLM performances by answer cardinality evaluated on the synthetic Medical dataset. Performances are reported across multiple, unique-, and no-answer ("None"") question types under the open-book setting. Only A is reported for the None type questions, as no time reference is expected in no-answer cases.
Multiple
Unique
None
Model
A
T
AT
A
T
AT
A
GPT-3.5
97.5
50.4
61.9
35.4
93.6
33.0
100.0
GPT-4
98.8
77.9
77.7
44.4
98.6
43.9
91.0
GPT-4o
97.5
78.6
78.5
59.8
97.2
58.4
100.0
Llama3.1-700
95.8
68.6
85.8
57.9
76.6
56.4
98.8
Mixtral-8x
97.1
55.7
60.8
24.9
90.6
22.9
27.1
Gemma2-278
94.8
52.1
78.3
48.3
89.8
47.0
100.0
Qwen2-72B
93.5
68.9
66.2
53.5
95.1
52.2
100.0
Granite3.1-93
88.3
44.8
41.5
17.6
93.5
17.1
100.0
D.7 EVALUATION TASK-SPECIHC TSQA METHODS
Continuing from Sec. 4.5 we provide an additional analysis with task-specific TSQA methods. While the primary goal of our study is to assess the accuracy and reliability of general-purposs purpose models those expected to possess "accurate knowledge" and widely adopted in many tasks as GPT-Judges
for handling factual knowledge (Lin et al. 2021| Sun et al. 2023] Wang et al. 2023) performance analysis on task-specific models such as TG-LLM (Xiong et al.) 2024) and TempT5 (Tan et al.) 2023) can offer insights in different perspectives. Specifically, we aim to explore (1) performance
differences compared to seneral-purposs models and (2) the effectiveness of their training methods when measured with other TSQA pairs beyond the original benchmarks used for their training
(TGQA (Xiong et al. 2024) and TempREASON (Tan et al. 2023) for TG-LLM and TempT5, respectively). which follow different QA styles.
31

---

Published as a conference paper at ICLR 2026
Table 26: Performance comparison of task-specific TSQA methods. Only A is reported for TempT5 and T5 due to their answer-only format.
Model
A
AT
Llama3.1-708
58.4
54.2
Mixtral-8x7B
42.9
30,9
Gemma2-27B
69.3
32.8
TG-LLM
41.0
34.0
Llama2-133 13B (buse model of TG-LLM)
37.0
27.0
TempT'S
4.2
T5-buse (base model of TempT55
0.0
As shown in Table 26 TG-LLM demonstrates notable performance improvement over its base model (i.e., Llama2-13B) 13B) and performs comparably to the general purpose model Gemma2-2785 however, the performance still lags behind the larger Llama family model used in our experiments (i.e., Llama3. 1-70BB. contrast to the good generalization ability shown TG-LLM, TempTS greatly struggles with TDBench's 's QA pairs, resulting in low performance, likely due to the limited capacity of its underlying architecture (i.c., TS-base).
D.8 COMPARISON WITH LLM-ONLY TSQA METHODS
Continuing from Sec. 3.1 and Sec. 4.5 we provide comparative study between TDBench and LLM-only TSQA methods. While TDßench leverages both database techniques and an LLM for TSQA construction, one possible approach is to solely use LLMs to directly generate QA pairs from an input data source (Kim et al., 2024 Zhao et al., 2024). We demonstrate how this LLM-only approach can (1) be more prone to hallucinations and (2) incur higher inference costs when processing the raw data.
Anlaysis on Hallucination We demonstrate with Zhao et al. (2024), using their system prompt, shown below. To better reflect realistic multi-attribute reasoning scenarios, relax constraint in the original prompt: each question should contain only one column's 's information.
Below is a table in CSV format separated with commas ',' Based on this table's information along with its description and abstracts, please raise up to ten questions that the answers are different 2010, 2019, and 2023. After raising the question, please get answers for those time points from the table. Please make sure the answers should be totally different without overlapping, Please only raise questions regarding the latest status of those time points instead of the history, while alse da not explicitly mention the time information the question to make them more natural. Do not ask questions cannot be answered based on the information provided in the table. Make sure the full and explicit names of related entities are used in the question based the description in the prompt and not pronouns.
We use the same LLM (GPT-4) as in their study and provide 50 rows from the Country dataset. The generated QA pairs follows:
Q1: What name was associated with the role of the Prime Minister of Australia?
Aj: Anthony Albanese
Qg: Who was the Prime Minister of Denmark in 2010?
Ag: Lars Løkke Rasmussen
Q3: Who was the Prime Minister of Denmark in 2019?
Aş: Lars Løkke Rasmussen
Q4: Who serving as the President of Nigeria in the year when Goodluck Jonathan started his
term?
A4: Goodluck Jonathan
32

---

Published as a conference paper at ICLR 2026
Qs: Who was serving the Prime Minister of Denmark when Mette Frederiksen began her term?
As: Mette Frederiksen
While the model correctly identifies the Lime-sensitive column based on the table schema (e.g., the name of the role-holder), the generated QA pairs do not fully adhere to the instructions. For instance, (Q2, A2) and (Qs, A3) explicitly mention temporal information, violating the guideline to avoid doing so; (Q2, A2) and (Qs, A3) makes it easy to infer answers from the questions themselves, compromising the question quality.
This study indicates that LLM-based QA generation can result in less controlled QA generation, being vulnerable to hallucinations even when the provided data source is relatively in small-scale (i.e., 50 rows). In contrast, SQL-based data processing employed in TDBench can ensure more controlled QA generation, even at scale, thereby reducing the manual effort often required in LLM-based methods to identify and eliminate hallucinated responses (Kim et al. 2024
Wu et al. 2024).
Analysis Inference Cost More importantly, SQL-based processing can be more cost-effective. TDBench only uses the necessary attributes for generating questions via TFDs and discards the rest, whereas LLM-only approach typically ingests entire row. We compare TDBench with an LLM-only baseline on five datasets used in our experiments (Sec. 4 As a result, Table xx shows that TDBench uses significantly fewer input tokens while achieving comparable inference time as that of the LLM-only baseline. We also observe greater cost benefits in larger, real-world datasets like the Netflix dataset compared smaller, well-processed datasets like the Leaders dataset, demonstrating the scalability of TDBench.
Table 27: Comparison of inference time (Time (s) and input size (Tokens) across datasets. #col
denotes the column count of each dataset. Bold indicates the lower (better) value.
Leaders (Acol: 5)
Olympic (Bool: 7)
Environ (Acol: 10)
Medical (#col: 15)
Netflix (#col: 18)
Model
Time (s)
Tokens
Time (s)
Tokens
Time (s)
Tokens
Time (s)
Tokens
Time (s)
Tokens
LLM-only
1.79
206
1.89
316
1.47
376
1.81
542
1.91
1,288
TDBench
1.62
161
2.57
177
1.93
169
3.32
299
1.73
138
D.9 TROSS-TRA SIMILARITY ANALYSIS
Continuing from Sec. the translator model used in the QA construction process. When using an LLM as a SQL-to-text translator, the generated questions may implicitly reflect biases such as question-style familiarity, which can affect evaluation when the same model is also an evaluation target-for example, we use GPT-4o the SQL-to-text translator, and GPT-4o is also one of the models being evaluated. However, we emphasize that, rather than relying on free-form prompting, all questions are generated from the same underlying SQL queries, which constrains the generation across translator models and limits the potential bias introduced by the translator.
provide cross-translator similarity analysis to assess the impact of
To validate that different translators produce similar questions, we additionally conducted cross- generator similarity analysis. We compared questions generated from different translator models with UPT-4o-generater questions by inputting 100 randomly sampled SQL queries used in TDBench. We measurie similarities in two complementary dimensions via widely-adopted metrics: (1) semantic similarity using sentence embeddings (Reimers & Gurevych, 2019) (all-mpnet-base--e captures whether questions convey equivalent meaning regardless of exact wording; and (2) lexical similarity using ROUGE-1 Fl score (Lin) 2004). which measures surface-level unigram overlap.
which
The results shown in Table 28 demonstrate very high similarity across translators (semantic similarity > 0.85, ROUGE-1 F1 > 0.65), indicating that SQL constraints dominate generation and suggest minimal impact from the translator model dual role. However, users should note that these metrics may not capture all subtle biases in question formulation and can freely choose the translator model based on their own constraints and evaluation targets.
33

---

Published as a conference paper at ICLR 2026
Table 28: Cross-gemerator similarity analysis across different SQL-to-text franslator models.
Metric
Llama3. 1-70B
Mixtral-8x7B
Qwen2-72B
Gemma2-278
Semantic Similarity
0.942 0.042
0.921
0.052
0.945 + 0.035
0.930 0.051
ROUGE-I
0.781 0.147
0.673 + 0.080
0.810 + 0.094
0.717 0.113
D.10 FULL EXPERIMENTAL RESULTS
Continuing from Sec. 4.3 we provide full results on the multi-hop setting. Table 29 shows that Llama3.1 1-70B outperforms GPT-4o in the 2-hop setting, whereas GPT-4o outperforms 1 in the 3-hop setting. Interestingly, GPT-4o shows an extremely low hallucination rate (i.e.. H1) ) in the 2-hop setting which requires identifying the role-holder of the host country of given Olympic games indicating that once the model get the correct host country and time, the model is mostly able to retrieve the correct ool-holder for that time.
Table 29: Full results for performance comparison on implicit, multi-hop questions. H; denotes the hallucination rate the 1)-st hop given that the i-th hop correct.
2-hop
3-hop
Model
A
AT
H1
A
AT
H1
H2
GPT-3.5
66.7
63.1
9.1
33.8
33.8
8,5
7.6
GPT-4
88.4
67.2
4.5
57.1
52.5
10.8
0.5
GPT-4o
86.9
79.3
0.0
90.4
87.9
26.3
0.0
Ilama3.1 1-70B
91.9
83.8
68.8
82.8
80.8
38.2
4.5
Mixtral-8x7B
80.8
72.7
45.9
60.1
49.0
19.5
10.6
Gemma2-211 27B
79.8
77.8
35.1
48.0
43.9
26.5
24.7
Qwen2-72B
78.3
65.2
50.0
68.2
59.1
35.1
Granite3. 1-8B
73.7
50.5
80.4
11.1
11.1
10.3
77.8
34


Reviews:
[{"review_id": "LUWrG568MS", "reviewer": "Reviewer_fr2Z", "summary": "The paper introduces TDBench, a framework that auto-constructs time-sensitive QA (TSQA) benchmarks from temporal databases using temporal functional dependencies (TFDs), temporal SQL over the full set of 13 temporal relations, and SQL-to-text generation, then evaluates models on both answer accuracy and a proposed time-accuracy metric that checks the correctness of referenced timestamps in explanations. The pipeline (knowledge selection via TFDs → temporal SQL query generation → SQL-to-text question conversion) yields scalable benchmarks spanning Wikipedia-like and domain-specific datasets (e.g., law, carbon tax, UNESCO, Netflix). Experiments on 8 LLMs show a sizable gap between answer-only and answer-plus-time evaluation, and analyses cover relation types, answer cardinality (multiple/unique/none), temporal spans, and multi-hop (via temporal joins). The authors report high agreement with manual verification and argue TDBench generalizes beyond Wikidata/Wikipedia and reduces manual curation burden.", "questions": "Please address all questions raised in the weaknesses section.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 4, "contribution": 3, "strengths": "* The paper is well-positioned relative to prior work. It offers clear contrast to template-based and Wikidata-constrained temporal QA benchmarks by covering a wider range of relations and incorporating explanation evaluation, an element often absent from earlier efforts.\n\n* The proposed framework is clear and modular. It employs TFDs for target selection, leverages temporal SQL to ensure comprehensive coverage of 13 Allen relations, and uses SQL-to-text conversion to generate natural questions. This approach is both principled and generalizable across data schemas.\n\n* The evaluation extends meaningfully beyond answer accuracy. The introduction of a time-accuracy metric enables explanation-level verification, revealing cases where models identify correct entities but hallucinate timestamps, which results in a notable 21.7% average performance drop.\n\n* The empirical analysis is comprehensive. The authors examine relation-wise performance (e.g., strong on equal, weaker on contain or overlap), answer cardinality (including “none”), temporal span effects, and multi-hop reasoning with hop-wise hallucination (H1/H2), providing fine-grained diagnostic insights.", "weaknesses": "* The paper lacks clarity in how “current” time is grounded. Temporal-alignment questions depend on explicit date references (e.g., “as of 2025”), yet it remains unclear how “now” is defined, stored, and exposed across datasets to ensure reproducibility and longitudinal comparability. Clearer date-pinning and versioning protocols would strengthen the methodology.\n\n* The paper makes strong assumptions about the validity of TFDs and data quality. The proposed approach presumes clean temporal tables with unique, non-overlapping records, but real-world data often violate these constraints (e.g., acting roles, contested tenures). Robustness tests under noisy or violated TFDs, along with explicit mismatch-handling mechanisms, are needed.\n\n* The proposed framework demonstrates limited generalization beyond structured tables. Although the SQL-based design is very elegant for relational temporal data, many time-sensitive facts originate from semi-structured or textual sources. Extending TDBench to hybrid settings that integrate temporal tables with text provenance would broaden its practical relevance.\n\n* The analysis of RAG underperformance is insufficiently developed. While the paper notes that RAG often retrieves temporally misaligned passages (Lines 1401-1403), a more detailed investigation, such as experiments with retrieval time-filtering, temporal re-ranking, or query rewriting, could provide actionable insights for practitioners.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "kUfmnmiVz2", "reviewer": "Reviewer_AktZ", "summary": "This paper proposes TDBench, a benchmark for time-sensitive factual question answering. The benchmark leverages three database techniques to construct questions directly from temporal databases: using Temporal Functional Dependencies to select answerable facts, employing temporal SQL to encode diverse temporal contexts, and utilizing temporal joins to create multi-hop event-event reasoning items. Additionally, the paper introduces a new evaluation metric, \"time accuracy,\" which verifies whether a model's explanation cites correct temporal evidence in addition to providing the correct answer. Experiments on multiple large language models reveal a significant gap between answer accuracy and answer-plus-time accuracy.", "questions": "None", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The use of Temporal Functional Dependencies  for knowledge selection and temporal SQL based on all 13 Allen relations to generate questions is rigorous, systematic, and scalable. This enables the creation of more diverse and complex temporal reasoning questions than those commonly found in existing benchmarks.\n\n2. The introduction of the \"time accuracy\" concept correctly emphasizes that in TSQA, the rationale is as important as the answer itself.\n\n3. By building on fundamental database principles, TDBench is not tied to specific knowledge sources. The authors demonstrate this advantage by evaluating LLMs on domain-specific datasets, revealing performance variations overlooked by Wikipedia-centric benchmarks. This makes the framework highly valuable for creating application-specific evaluations.", "weaknesses": "1. The accuracy of LLM generation and evaluation is relatively low, with known misjudgment issues. This may introduce label noise and lead to benchmark bias. It is recommended to incorporate more automated verification or manual validation mechanisms.\n\n2. Temporal information in many scenarios includes open/uncertain intervals or requires granularities beyond dates (e.g., partial months, fiscal quarters). The current time accuracy standard, which only validates the start/end fields of each relation, is relatively limited in many contexts.\n\n3. The same provider's model (GPT-4o) is used in the pipeline (SQL-to-text) and is also an evaluation target. Although the authors avoid using GPT-4o as a judge to reduce bias, this dual role still requires further analysis.\n\n4. Many existing studies on TSQA dataset construction are not effectively cited or analyzed. Beyond template-based approaches, other methods such as manual construction and LLM-automated construction [1][2][3] should be included and discussed in the related work section.\n\n[1] A Question Answering Dataset for Temporal-Sensitive Retrieval-Augmented Generation\n\n[2] SituatedQA: Incorporating Extra-Linguistic Contexts into QA\n\n[3] ComplexTempQA: A 100m Dataset for Complex Temporal Question Answering", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "oITLEssc3O", "reviewer": "Reviewer_YGnM", "summary": "This paper presents the TDBench framework to evaluate LLMs on time-sensitive QA tasks. The framework addresses manual bottlenecks in existing TSQA benchmarks by automating both the construction and evaluation processes. TDBench uses Temporal Functional Dependencies (TFDs) to automatically identify valid QA attribute pairs. Temporal SQLs are generated attributes identified and 13 temporal relations. These SQLs are now translated into Natural Language Questions using GPT-4o, and the ground-truth answer is obtained by executing the query against the database. A new metric, \"Time Accuracy\", is also introduced, which evaluates the correctness of the temporal references in a generated answer.", "questions": "1. Can you provide guidance or tools for automatically discovering TFDs from existing databases?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. Automated and Scalable QA construction. Unlike prior works, which use manual curation or templates, TDBench automates this process with TFDs.\n2. TDBench can be extended to any database with temporal data.", "weaknesses": "1. The paper argues that it eliminates the manual bottleneck of benchmark creation. Well-structured temporal databases with defined TFDs for many domains may not exist, and it's not an easy task to automate their creation.\n2. In many real-world databases, schemas are updated with time as well. Even in Wikipedia, many infobox keys & values are constantly being updated. This is a major limitation for TDBench like tasks.\n3. While the time accuracy metric is good, it's not anything new.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "9gUtJ1Af8p", "reviewer": "Reviewer_wK6u", "summary": "This paper tackles a key problem: creating benchmarks for time-sensitive QA is slow and manual. The proposedTDBench uses temporal databases and SQL to automatically generate diverse and reliable QA pairs, bypassing the usual human effort. A key contribution is the *Time Accuracy* metric, which goes beyond checking the final answer to also verify the dates in the model's explanation. This provides a much deeper look into model factuality and hallucination.", "questions": "The framework elegantly shifts the manual effort from question design to database design. How do you see TDBench being applied in settings where the source data is semi-structured or messy (e.g., tables scraped from the web)? Does the automation promise hold if a significant data curation phase is required first?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The core idea of using temporal database theory to systematically generate a benchmark is highly innovative and effective. It is a bridge between two fields.\n- TDBench automates a tedious, expensive process. This makes it highly practical for both academic research and industry applications where up-to-date, domain-specific evaluation is needed.\n- Time accuracy reveals a critical layer of hallucination—correct answers with faulty temporal reasoning—that is otherwise missed by standard benchmarks.\n- The framework's use of 13 temporal relations ensures a much broader and more rigorous test of LLM capabilities than existing template-based methods.", "weaknesses": "- The framework's success hinges on having a well-structured temporal database. This shifts the manual effort from question creation to data modeling and curation, which can be a significant bottleneck in itself.\n- The paper notes a ~9% error rate in the SQL-to-text step. This introduces a small but non-negligible risk that models are being evaluated on slightly flawed or ambiguous questions.\n- The need to explicitly prompt models for date information to measure *Time Accuracy*, while necessary, creates a test condition that may not fully reflect natural user interaction.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)