TCC-RAG: Temporal Causal Chain-Guided RAG for Temporal Knowledge Graph Question Answering

Vector (PDF)

Introduction

Large Language Models (LLMs), such as GPT-4 [1] and the LLaMA series [2], have brought a paradigm shift to artificial intelligence by demonstrating strong capabilities in semantic understanding, reasoning, and generalization across a wide range of tasks [3, 4, 5, 6, 7, 8]. These advances have made LLMs increasingly attractive for question answering (QA), where models are expected to understand natural language queries and produce accurate, knowledge-grounded responses [4]. To improve factual reliability, Retrieval-Augmented Generation (RAG) [9, 10, 11] has become a widely adopted paradigm for QA systems. By retrieving relevant knowledge from external sources and incorporating it into the LLM context, RAG effectively supplements LLMs and improves factual grounding, particularly in knowledge-intensive reasoning tasks.

Temporal Knowledge Graph Question Answering (TKGQA) is an important QA task that requires reasoning over knowledge that evolves over time [12, 13]. Early TKGQA methods primarily relied on embedding-based approaches [14, 15, 16], which learn representations of temporal entities and relations to support inference over temporal knowledge graphs. More recently, with the rapid development of LLMs, researchers have begun to explore LLM-based TKGQA frameworks that leverage the reasoning ability of LLMs together with external temporal knowledge [17]. Most of these methods adopt semantic retrieval-augmented generation, where temporally relevant facts are retrieved based on semantic similarity and provided to the LLM for reasoning [18, 19, 20, 21, 22]. However, such semantic RAG pipelines struggle to support complex multi-step temporal reasoning, where answering a query requires reconstructing temporally ordered reasoning chains across multiple events. In particular, existing methods suffer from two fundamental limitations in complex temporal reasoning scenarios, as illustrated in Figure 1(a).

❶ Missing Causal Facts. Semantic-based RAG methods treat knowledge as isolated and unordered text units, ignoring the temporal evolution inherent in the data. Complex multi-step reasoning questions usually require multi-hop causal knowledge to reconstruct the correct temporal reasoning process. However, multi-hop causal knowledge that is causally essential but only partially relevant to the query semantics may be overlooked, preventing LLMs from capturing the true temporal causal chain in multi-step temporal reasoning scenarios. As illustrated in Figure 1(a), for the multi-step temporal reasoning question “After the Danish Ministry of Defence and Security, who was the first to visit Iraq?”, semantic-based retrieval fails to retrieve the causally necessary fact “Jack Straw made a visit to Iraq on 2006-01-06” as it has limited semantic overlap with the query despite being causally essential for multi-step temporal reasoning.

❷ Introducing Noise Facts. Semantic-based RAG methods retrieve a large number of knowledge units through similarity matching, most of which are redundant, while only a small portion is truly causally relevant to the query. The presence of enormous noisy knowledge can lead LLMs to follow spurious reasoning chains, which may ultimately induce incorrect answers. As illustrated in Figure 1(a), semantic-based RAG methods return facts that are semantically related but causally irrelevant, such as “Iraq hosted a visit by Barack Obama on 2006-01-07” and “Barack Obama made a visit to Iraq on 2006-01-08”. The presence of these two causally irrelevant facts about Barack Obama may cause the LLM to follow spurious reasoning chains based on Barack Obama’s visits when performing temporal reasoning, leading to incorrect responses.

Our Solution: TCC-RAG. To address the aforementioned limitations, we propose Temporal Causal Chain–guided Retrieval-Augmented Generation (TCC-RAG), a novel framework that retrieves a concise yet sufficient set of causal knowledge to support complex temporal reasoning. Specifically, we reformulate temporal knowledge facts into a multi-view causal cue graph, where temporal evolution is explicitly encoded as causal cues across one event graph and two trie-structured indices. This transformation exposes temporal evolution as explicit causal logic between events, capturing structural dynamics that plain text semantics cannot. Moreover, we introduce a temporal causal chain-guided retrieval strategy that progressively parses queries and retrieves only the causally relevant facts along the routed view of the causal cue graph. This design enables the retrieval process to focus on a concise yet sufficient causal knowledge, effectively avoiding the introduction of redundant knowledge that misleads LLMs into incorrect reasoning paths. Finally, to further ensure the causal consistency of the retrieved knowledge, we propose a causal evidence filter that distills the retrieved evidence into a minimal causally sufficient subset through two deterministic steps: equivalence-class deduplication and sufficiency-driven selection. The filter yields a purified evidence set that provides more faithful support for temporal reasoning.

We conduct a comprehensive evaluation of TCC-RAG on two widely used TKGQA benchmarks against over 10 baselines, covering diverse temporal reasoning scenarios. TCC-RAG consistently outperforms all baselines, achieving overall improvements of 10.72% and 8.40% in Hits@1, respectively. Notably, it yields a substantial improvement of 62.97% on complex multi-step temporal reasoning, demonstrating its strong capability in complex temporal reasoning. Ablation studies and case studies further validate the effectiveness of each component and the quality of the retrieved causal evidence. Efficiency analysis shows that TCC-RAG reduces token consumption by over 57% compared with the strongest baseline, confirming its practical efficiency and scalability.

The main contributions of this work are as follows:

• We identify the limitations of existing semantic-based RAG methods for TKGQA, including the absence of causal facts and the introduction of enormous noisy facts, which hinder complex multi-step temporal reasoning.

• We propose TCC-RAG, which organizes temporal knowledge into a multi-view causal cue graph to explicitly encode temporal evolution dynamics as structured causal cues.

• We design a temporal causal chain-guided retrieval strategy with a causal evidence filter to retrieve and distill relevant facts into causal evidence for complex temporal reasoning.

Related Work

Retrieval-Augmented Generation. Retrieval-Augmented Generation (RAG) enhances large language models by retrieving external knowledge to support reasoning and generation [9, 10, 11, 23]. A typical RAG framework consists of a retriever that identifies relevant documents or facts and a generator that produces answers conditioned on the retrieved evidence. For instance, [24] conduct a comprehensive benchmark of LLMs in RAG settings, revealing that retrieval noise and context length are key bottlenecks for faithful generation. HippoRAG [25] draws inspiration from human memory consolidation to build a long-term associative memory structure, enabling multi-hop retrieval by linking retrieved passages through a hippocampal-like index. These works highlight that the quality and structure of retrieved evidence are critical to downstream reasoning performance.

GraphRAG has attracted increasing attention due to its ability to model structured knowledge and capture multi-hop contextual dependencies [26, 27, 28, 29]. Instead of retrieving independent text chunks, GraphRAG methods organize knowledge as graphs and perform structure-aware retrieval. For example, Think-on-Graph (ToG) [27] iteratively explores knowledge graph paths via LLM-guided beam search, retrieving multi-hop reasoning chains in a depth-first manner. GNN-RAG [28] combines graph neural networks with RAG by first extracting candidate answer entities through GNN reasoning and then retrieving shortest paths as evidence for LLM generation. Existing GraphRAG approaches can generally be categorized into subgraph retrieval methods [30] and path-based reasoning methods [31], both of which aim to leverage graph structure to improve reasoning quality. However, how GraphRAG can effectively support complex temporal reasoning, especially multi-step temporal reasoning, remains largely underexplored.

Temporal Knowledge Graph Question Answering. Temporal Knowledge Graph Question Answering, a crucial paradigm for modeling evolving knowledge, has recently garnered significant research attention [12, 13]. Existing TKGQA methods can be broadly categorized into embedding-based approaches and LLM-based approaches [17].

Embedding-based methods typically learn representations of temporal entities and relations and perform reasoning in the embedding space. CronQA [32] encodes temporal constraints directly into entity and relation embeddings via a time-aware scoring function, enabling the model to answer questions anchored to specific timestamps. TempoQR [16] extends this by grounding question representations into the temporal knowledge graph through entity and time mention linking, achieving stronger alignment between query semantics and temporal facts. Other approaches rely on graph neural networks to model temporal relational structures [33, 34, 35] [36], capturing local and global structural dependencies within the knowledge graph. While effective on simpler temporal queries, these embedding-based methods generally struggle to generalize to complex multi-step temporal reasoning scenarios.

More recently, LLM-based TKGQA methods have emerged as a flexible alternative [17]. TimeR4 [18] proposes a time-aware retrieval strategy that incorporates temporal signals into the retrieval process, providing LLMs with temporally filtered evidence for question answering. RTQA [19] introduces a recursive thinking mechanism that decomposes complex temporal questions into sub-questions and iteratively retrieves supporting facts, improving multi-step reasoning performance. Despite these advances, most existing LLM-based methods still rely on semantic similarity-based retrieval [18, 19, 21], which fails to capture the multi-hop causal knowledge required for complex temporal reasoning, motivating our causal chain-guided approach.

Preliminaries

Temporal Knowledge Graph. A temporal knowledge graph (TKG) is defined as a structured knowledge base that represents relational facts evolving over time. Formally, a TKG is denoted as: $\mathcal{G} = (\mathcal{E}, \mathcal{R}, \mathcal{T}, \mathcal{F})$, where $\mathcal{E}$ denotes the entity set, $\mathcal{R}$ the relation set, $\mathcal{T}$ the temporal domain, and $\mathcal{F}$ the complete temporal fact set. Each temporal fact is represented as a quadruple $(h,r,t,\tau) \in\mathcal{F}$, where $h,t \in\mathcal{E}$ are the head and tail entities, $r \in\mathcal{R}$ is the relation type, and $\tau\in\mathcal{T}$ denotes the temporal annotation indicating when the relation holds. The temporal annotation $\tau$ can be a discrete timestamp, a time interval, or an ordered temporal index.

Temporal Knowledge Graph Question Answering. Given a temporal knowledge graph $\mathcal{G}$ and a natural language question $Q$, the goal of temporal knowledge graph question answering (TKGQA) is to infer the correct answer $\mathcal{A}$ grounded in $\mathcal{G}$ while respecting temporal constraints and event evolution patterns. Formally, the task is to learn a mapping: $f:(\mathcal{Q},\mathcal{G}) \rightarrow\mathcal{A}$, where $\mathcal{A} \in\mathcal{E}$, $\mathcal{A} \in\mathcal{T}$, or $\mathcal{A} \in\mathcal{E} \times\mathcal{T}$, depending on the question type.

Complex Temporal Reasoning. Unlike static KGQA, TKGQA often requires multi-step reasoning over time. Specifically, the answer $a$ may depend on a sequence of temporally ordered facts: $\pi= (h_1,r_1,t_1,\tau_1),\ldots,(h_n,r_n,t_n,\tau_n)$, where the timestamps satisfy temporal ordering constraints: $\tau_1 \prec\tau_2 \prec\cdots\prec\tau_n$, and collectively provide sufficient evidence to derive the answer: $\pi\models a \mid Q$.

Temporal Causal Cue. A causal cue is a query-conditioned temporal dependency signal that constrains how query-relevant events are ordered or selected. We distinguish two types of cues. The first type is the ordering cue $c \in\{\text{before},\text{after},\text{same}\}$, which constrains the temporal relation between an event and a boundary timestamp $\tau_b$. Given a query $Q$ with ordering cue $\hat{c}$, an event $e=(h,r,t,\tau)$ is cue-consistent with $Q$ if its timestamp $\tau$ satisfies the constraint imposed by $\hat{c}$ relative to $\tau_b$:

The second type is the selection cue $c \in\{\text{first},\text{last}\}$, which selects the boundary event from a temporally ordered set of cue-consistent events. Specifically, first selects the earliest event and last selects the latest one. Selection cues are typically composed with ordering cues in multi-step queries, for example “Before Mexico, which country did China visit last?”, where before first restricts the candidate events and last then selects the answer among them.

In this work, the term causal is used in an operational sense for temporal question answering rather than in the intervention-based sense of causal inference. We regard temporally ordered event dependencies that are relevant to a query as causal signals for reasoning.

Methodology

TCC-RAG consists of three core components. First, we construct a multi-view causal cue graph to explicitly encode temporal causal relations among events, transforming implicit temporal information into structured causal cues organized over a graph and two indices. Second, we design a query-aware temporal causal chain retrieval module that progressively parses the query and traces causally relevant evidence over the routed view, ensuring that only essential causal facts are retrieved. Finally, we introduce a causal evidence filter that refines the retrieved evidence into a minimal causally sufficient subset through equivalence-class deduplication and sufficiency-driven selection. Together, these components form a unified, training-free, and plug-and-play framework that effectively enhances LLM-based complex temporal reasoning. The overall architecture of TCC-RAG is shown in Figure 2. The model dynamically routes each query to the most suitable view based on the role of its grounded entities, achieving both precision and efficiency across diverse query patterns.

Vector (PDF)

Multi-View Causal Cue Graph Construction

Different temporal queries exhibit heterogeneous logical structures and require varying reasoning depths. Simple queries that involve a known entity pair only require direct event lookup, while complex multi-step queries anchored on a single entity demand traversal across temporally ordered events. A single monolithic structure cannot serve both efficiently. To this end, we design the causal cue graph as three complementary views: a Temporal Event Graph (TEG) for paired-entity queries, a Subject Causal Cue Index (SCCI) for subject-anchored multi-step queries, and an Object Causal Cue Index (OCCI) for object-anchored multi-step queries. The model dynamically routes each query to the most suitable view based on the role of its grounded entities, achieving both precision and efficiency across diverse query patterns.

Temporal Event Graph. TEG targets paired-entity queries that ask for events directly connecting two known entities, e.g., “When did China negotiate with Iraq?”. For such queries, retrieval reduces to a direct edge lookup between two nodes, which is naturally captured by a graph. Formally, we construct TEG as a multi-relational temporal graph: $\mathcal{G}^{t} = (\mathcal{E}, \mathcal{F})$, where $\mathcal{E}$ is the entity node set (as defined in Section III), and each edge $(h,r,t,\tau) \in\mathcal{F}$ encodes a temporal fact linking head $h$ to tail $t$ via relation $r$ at timestamp $\tau$. Given the grounded subject–object pair $(\hat{e}_{s}, \hat{e}_{o})$, retrieval scans directed edges from $\hat{e}_{s}$ to $\hat{e}_{o}$ and retains those matching the query relation, costing $\mathcal{O}(\deg(\hat{e}_{s},\hat{e}_{o}))$, where deg counts these directed edges.

Subject Causal Cue Index. A more challenging case arises in multi-step queries anchored on a subject entity, such as “After Mexico, which country did China visit?”. The answer requires traversing all events initiated by the subject under the same relation, ordered along the temporal dimension. A naive solution is to materialize a causal cue edge between every pair of temporally related events sharing the same $(subject, relation)$ key. However, this incurs $\mathcal{O}(d^{2})$ storage cost per key, where $d$ denotes the number of events per (subject, relation) pair, becoming prohibitive in dense entity neighborhoods.

We observe that traversing along causal cue edges is functionally equivalent to scanning a list of events sorted by timestamp. Causal cues encode the relative temporal order between events, and this order is fully recoverable from the position of each event in the sorted list. Building on this insight, we design SCCI as an inverted index that encodes causal cues implicitly through temporal ordering, rather than as physically materialized edges. Concretely, SCCI is a hash map keyed by (subject, relation) pairs, with each value storing a temporally ordered posting list:

The causal cues among events in the posting list are recovered on-the-fly: if $\tau_{e_i}<\tau_{e_j}$, then $\operatorname{before}(e_i,e_j)$ and $\operatorname{after}(e_j,e_i)$ hold. If $\tau_{e_i}=\tau_{e_j}$, only $\operatorname{same}(e_i,e_j)$ holds. Each predicate describes its first event relative to its second. List position alone does not imply strict temporal precedence. This implicit encoding preserves the full causal cue semantics defined in § 3, while reducing storage from $\mathcal{O}(d^{2})$ to $\mathcal{O}(d)$ per key.

The SCCI design delivers two efficiency benefits over a fully materialized causal cue graph. First, storage is reduced from $\mathcal{O}(d^{2})$ to $\mathcal{O}(d)$ per key, yielding $\mathcal{O}(|\mathcal{F}|)$ total. Second, a hash lookup locates the posting list, binary search locates the temporal range, and a scan returns its $k$ cue-consistent events, costing $\mathcal{O}(\log d_{\max}+k)$. Crucially, this efficiency comes without sacrificing causal cue semantics: every retrieval result reachable via materialized edges remains reachable via posting list scan.

Object Causal Cue Index. Symmetric to SCCI, OCCI handles multi-step queries anchored on an object entity, e.g., “Before the United States, who visited Iraq?”. Following the same design rationale, we construct OCCI as a hash map keyed by (relation, object) pairs:

The causal cue semantics, storage cost $\mathcal{O}(|\mathcal{F}|)$, and per-query retrieval cost $\mathcal{O}(\log d_{\max}+k)$ are identical to those of SCCI, providing the same efficiency guarantees on the object-anchored side.

Summary. We denote the multi-view structure by $\mathcal{S}=(\mathcal{G}^{t},\mathcal{D}^{s},\mathcal{D}^{o})$, distinct from the original TKG $\mathcal{G}$. Construction populates the three views in one pass over $\mathcal{F}$ and then sorts the posting lists, taking $\mathcal{O}(|\mathcal{F}|\log d_{\max})$ time and $\mathcal{O}(|\mathcal{F}|)$ storage. Table I summarizes the view-specific retrieval costs. Together, the views preserve causal cue semantics through direct edges and implicit temporal ordering.

Temporal Causal Chain-Guided Retrieval

Given the multi-view causal cue graph, the central challenge is to ground a natural-language query $\mathcal{Q}$ into the appropriate index keys and extract the events that participate in the underlying temporal causal chain. We address this challenge through a progressive query parsing pipeline that decomposes parsing into three stages of decreasing difficulty: hybrid entity grounding, context-aware relation and cue parsing, and dynamic query routing. Each stage takes the signals resolved by the previous one as additional context, so that the search space narrows along the pipeline and progressively lighter machinery suffices for the remaining decisions. The structured output is finally resolved into a temporal causal chain by a chain construction procedure over the routed view.

Hybrid Entity Grounding. Entity grounding is the most challenging stage of parsing because it operates on the raw query with no prior context. Real-world temporal queries frequently

Require: Query $\mathcal{Q}$, views $\mathcal{S}=(\mathcal{G}^{t},\mathcal{D}^{s},\mathcal{D}^{o})$, KG vocabulary $\mathbf{E}_{\mathrm{cand}}$, relations $\mathcal{R}$.

Ensure: Evidence $\mathcal{F}^{c}$ for answer generation.

1. // Hybrid Entity Grounding

2. $\mathcal{M}_{\mathrm{ner}}\leftarrow\operatorname{NER}(\mathcal{Q})$

3. $\mathcal{M}_{\mathrm{llm}}\leftarrow\operatorname{LLM}(\mathcal{Q};\mathrm{prompt}_{\mathrm{ent}})$

4. Match both mention sets to $\mathbf{E}_{\mathrm{cand}}$ using Eq. (4)

5. Obtain $\hat{\mathbf{E}}$ by agreement or arbitration in Eq. (5)

6. // Relation, Cue, and Role Parsing

7. $\hat{c}\leftarrow\operatorname{RuleMatch}(\mathcal{Q};\mathcal{P})$

8. $(\hat{r},\mathrm{role},z_{\mathrm{ref}})\leftarrow\operatorname{LLM}(\mathcal{Q},\hat{\mathbf{E}};\mathrm{prompt}_{\mathrm{rel}})$

9. $r^{*}\leftarrow\arg\max_{r\in\mathcal{R}}\cos(\phi(r^{*}),\phi(r))$

10. Infer $\operatorname{ans}(\mathcal{Q})$ and filled slots from $\mathcal{Q}$ and role

11. Resolve $\tau_b$ from $\mathcal{Q}$ and $z_{\mathrm{ref}}$, using $\bot$ if absent or unresolved

12. // Route to One View and Construct the Chain

13. $\mathcal{F}_{\mathcal{Q}}\leftarrow\varnothing$

14. if $\operatorname{pair}(\mathcal{Q})$ then

15. $\mathcal{F}_{\mathcal{Q}}\leftarrow\operatorname{DirectedEdges}(\mathcal{G}^{t},\hat{e}_{s},r^{*},\hat{e}_{o})$

16. else if $\operatorname{role}(\hat{e})=\mathrm{subject}$ and $\operatorname{ans}(\mathcal{Q})=\mathrm{object}$ then

17. $\mathcal{F}_{\mathcal{Q}}\leftarrow\mathcal{D}^{s}[(\hat{e},r^{*})]$

18. else if $\operatorname{role}(\hat{e})=\mathrm{object}$ and $\operatorname{ans}(\mathcal{Q})=\mathrm{subject}$ then

19. $\mathcal{F}_{\mathcal{Q}}\leftarrow\mathcal{D}^{o}[(r^{*},\hat{e})]$

20. end if

21. $\mathcal{F}_{\mathcal{Q}}\leftarrow\operatorname{TemporalSelect}(\mathcal{F}_{\mathcal{Q}},\hat{c},\tau_b)$

22. if $\mathcal{F}_{\mathcal{Q}}=\varnothing$ then

23. $\mathcal{F}_{\mathcal{Q}}\leftarrow\operatorname{SemanticRetrieve}(\mathcal{Q})$

24. end if

25. Order $\mathcal{F}_{\mathcal{Q}}$ by ascending timestamp

26. $\mathcal{F}^{c}\leftarrow\operatorname{CEF}(\mathcal{F}_{\mathcal{Q}},\mathcal{Q})$ § 4-C

27. return $\mathcal{F}^{c}$

involve aliases, composite references, and role descriptors, all of which may map to canonical KG entities in non-obvious ways. A single extractor, whether a NER model or an LLM, may fail to handle such surface-form variability reliably. To address this, we adopt a dual-path extraction design with mutual consistency verification.

For query $Q$, NER and the LLM independently extract mention sets $M_{\mathrm{ner}}$ and $M_{\mathrm{llm}}$. Both are matched against the KG entity vocabulary $\mathbf{E}_{\mathrm{cand}} = \mathcal{E}$, not a query-derived candidate set:

Here $\mathbf{E}_{\mathrm{ner}}$ and $\mathbf{E}_{\mathrm{llm}}$ contain matched KG entities, and $\mathcal{M}(\cdot)$ is a hybrid matching function. For each extracted mention, $\mathcal{M}(\cdot)$ first applies semantic matching via cosine similarity in a pretrained embedding space. If the maximum similarity exceeds threshold $\theta_1$, the semantic result is adopted. Otherwise, it falls back to string-based fuzzy matching.

We then apply a consistency check to produce the final grounded entity set $\hat{\mathbf{E}}$:

When the two paths agree, the shared result is directly adopted. When they disagree, the LLM is prompted with both candidates and the original query to resolve the conflict and select the correct entity set. This dual-path design enables self-correction without labeled data or fine-tuning, improving grounding robustness across diverse and linguistically complex temporal queries.

Context-Aware Relation and Cue Parsing. With entities grounded, the second stage extracts two predicate-level signals, the temporal cue $\hat{c}$ and the canonical relation $r^{*}$, which together determine the target posting list within $\mathcal{D}^{s}$ or $\mathcal{D}^{o}$, or the target edge within $\mathcal{G}^{t}$. Because cues and relations exhibit different parsing complexities, we adopt different extraction strategies for the two.

For temporal cues, we observe that nearly all temporal queries express their cue through a small closed set of operator words such as before, after, first, and last, often in regular surface patterns. We therefore extract $\hat{c}$ via deterministic pattern matching on the query surface:

where $\mathcal{P}$ is a small set of cue-pattern rules.

For relations, we leverage the LLM’s predicate-parsing capability conditioned on the grounded entities $\hat{\mathbf{E}}$. The LLM extracts a relation phrase $\tilde{r}$, subject/object role assignments, and a temporal reference $z_{\mathrm{ref}}$ when present:

where $\operatorname{prompt}_{\mathrm{rel}}$ denotes the relation-extraction template. The extracted phrase $\tilde{r}$ is then grounded to a canonical KG relation via embedding similarity over the relation set $\mathcal{R}$:

The answer slot $\operatorname{ans}(Q)$ follows from the interrogative and missing argument in the parsed subject–relation–object structure. For entity answers, the filled subject or object serves as the traversal anchor $\hat{e}$. An entity or date associated with the temporal cue provides the temporal reference $z_{\mathrm{ref}}$. For time answers, $\hat{e}_{s}$ and $\hat{e}_{o}$ denote the filled subject and object. These roles, together with $r^{*}$ and $\hat{c}$, determine routing and temporal selection.

Dynamic Query Routing. With the parsed signals in hand, the third stage dynamically maps each query to the appropriate causal cue graph view based on the query structure. In particular, a multi-step subject-anchored or object-anchored query may still contain two grounded entities: one serves as the traversal anchor, while the other only provides the temporal reference point that determines $\tau_b$. We therefore route by the filled argument slot and the answer slot. Let $\operatorname{ans}(Q) \in\{\text{subject},\text{object},\text{time}\}$ denote the slot being asked, and let $\operatorname{pair}(Q)$ indicate that both subject and object slots are filled and the query asks for a direct temporal fact. The routing function $\rho: Q \mapsto\{\mathcal{G}^{t},\mathcal{D}^{s},\mathcal{D}^{o}\}$ is defined as

For example, in the query “Before Mexico, which country did China visit last?”, both China and Mexico are grounded. However, China is the subject anchor and Mexico only determines the boundary timestamp, so the query is routed to the SCCI dictionary $\mathcal{D}^{s}$ rather than to TEG. The three branches are mutually exclusive for the supported query patterns. Reference-event lookup supplies a boundary, not a second answer traversal. The executor does not perform arbitrary cross-view, multi-relation joins.

Causal Chain Construction. After routing, we construct the temporal causal chain by retrieving cue-consistent events from the routed view. The construction proceeds along two paths corresponding to the structural property of the view, followed by a unified temporal selection step.

If the query is routed to TEG, retrieval uses the known subject $\hat{e}_{s}$ and object $\hat{e}_{o}$. The query-specific candidate set $F_{Q}$ contains directed edges matching $r^{*}$:

For SCCI or OCCI, we locate the posting list $L$ keyed by $(\hat{e},r^{*})$ or $(r^{*},\hat{e})$, respectively. An explicit date directly supplies $\tau_b$. Otherwise, TEG retrieves the reference event connecting the anchor and reference entity under $r^{*}$. Its timestamp supplies $\tau_b$. With the boundary resolved, binary search followed by a range scan selects cue-consistent events:

where $\preceq_{\hat{c}}$ is defined in Section III. We use $\tau_b = \bot$ when the boundary is absent or unresolved. Without an ordering constraint, the full list is eligible for selection. A missing key or an unresolved required boundary yields $F_Q = \varnothing$.

The unified TEMPORALSELECT operation applies these temporal constraints, then retains the earliest or latest event(s) for first/last, if requested. Thus, compound cues such as before-last first restrict the range and then select its temporal extreme. Queries without temporal restrictions retain all relation-matched candidates. The selected events in $F_Q$ are arranged in temporal order to form the temporal causal chain

which serves as the structured causal evidence for downstream answer generation.

Parsing uses two LLM calls (mention extraction and predicate parsing), plus one arbitration call only when the grounding paths disagree. When structured retrieval returns $F_Q = \varnothing$, the retrieval pipeline falls back to semantic similarity search to obtain alternative candidates. Grounding errors, relation mismatches, or missing facts can cause such empty results. Routing alone does not trigger fallback. Candidates from either retrieval path are passed to CEF before answer generation, as summarized in Algorithm 1.

Causal Evidence Filter

Retrieved evidence can contain redundant or temporally irrelevant facts. CEF processes the query-specific candidates $F_Q$ from either structured retrieval or semantic fallback in two deterministic steps, producing deduplicated evidence $F^d$ and final filtered evidence $F^c$. Already concise, cue-consistent evidence can pass through unchanged, while redundant or cue-inconsistent candidates are refined before answer generation.

Causal-Equivalent Deduplication. The first kind of noise comes from facts that are structurally distinct yet carry identical causal information under the query. We capture this via a query-conditioned causal signature:

where $\kappa(\tau,\hat{c},\tau_b)$ maps the timestamp $\tau$ to a discrete causal token. Let $c_\kappa$ be the ordering component of $\hat{c}$ if present, otherwise its selection component (or $\bot$ if neither exists). Compound cues use the ordering component for normalization and retain the selection component for sufficiency selection. Let $D_b(\tau)$ be $(\tau-\tau_b)$ .days for a resolved boundary, or $\tau$.toordinal() otherwise. Then

where $\delta$ is the temporal bucket width (set to 1 day, aligned with the finest granularity of MULTIQ), and $\operatorname{rank}(\tau;c_\kappa)$ is the ordinal position within the $(h,r,t)$ group, sorted ascending for first or descending for last. Thus, range cues use day buckets, while same and absent cues preserve day-level identity. Two facts are causally equivalent under $Q$ if and only if they share the same signature $\sigma$. We partition $F_Q$ into equivalence classes under $\sigma$ and retain the earliest-timestamp fact as the canonical representative of each class, yielding the deduplicated set $F^d$. This stage runs in $O(|F_Q|)$ via hash-based grouping and is information-lossless: every fact in $F_Q$ has an equivalent representative in $F^d$.

Causal Sufficiency Selection. The second kind of noise comes from facts that fail to participate in the causal chain required by the query. Eligible facts satisfy the ordering component when $\tau_b$ is resolved. When it is unresolved, CEF skips boundary-dependent tests to avoid unsupported pruning of fallback evidence. We select a minimal subset $F^c \subseteq F^d$ by a greedy procedure that enforces three conditions in order:

(i) Boundary preservation. For a first/last selection component, including compound cues, the algorithm seeds $F^c$ with the earliest/latest eligible fact in $F^d$. For same with a resolved $\tau_b$, it retains all facts on the anchor day. This ensures that the pivotal boundary event anchoring the causal chain is always retained.

(ii) Cue coverage. The algorithm adds the canonical representative of each eligible class in $F^d$, using the ordering component of $\hat{c}$ when present (i.e., $\tau< \tau_b$ for before, $\tau> \tau_b$ for after, or the same day for same, with a resolved $\tau_b$). Classes that are cue-inconsistent are discarded. This step ensures that every distinct causal pattern satisfying the query’s temporal constraint is represented in $F^c$.

(iii) Chain connectivity. With $F^c$ ordered by ascending timestamp, the algorithm verifies that consecutive facts share the grounded relation $r^{*}$ and respect the temporal direction implied by $\hat{c}$ (i.e., timestamps are non-decreasing). If this condition is violated, indicating that the selected facts do not form a coherent causal chain, the algorithm safely falls back to $F^{d}$ to avoid over-pruning.

Preserving the chronological order supplied by chain construction, selection and connectivity checks take $O(\lvert F^{d}\rvert)$ time. Together with hash-based deduplication, CEF takes $O(\lvert F_{Q}\rvert)$ time and produces filtered evidence $F^{c}$.

Causal Chain-Guided Reasoning

With the evidence set $F^{c}$ in hand, we prompt the LLM to perform temporal reasoning and generate the final answer. Specifically, $F^{c}$ is serialized as a structured fact list and provided to the LLM alongside the original query $Q$, enabling it to follow the temporal causal chain to derive the answer. The prompt template used for answer generation is shown in Figure 3. Compared with semantic-based RAG methods, which feed a large number of loosely relevant facts into the LLM, TCC-RAG supplies a concise yet causally sufficient evidence set. This precision reduces reasoning noise and allows the LLM to focus on the true causal chain, yielding more accurate answers with substantially fewer facts.

Complexity Analysis

Time Complexity. Offline construction costs $O(\lvert F\rvert\log d_{\max})$, dominated by posting-list sorting. Query parsing uses two LLM calls, plus one optional grounding-arbitration call. Answer generation adds one further call. Entity and relation matching depend on their vocabulary sizes and are separate from index retrieval. With grounded keys and a resolved boundary, TEG lookup costs $O(\deg(\hat{e}_{s},\hat{e}_{o}))$, while SCCI/OCCI range retrieval costs $O(\log d_{\max}+k)$. A reference-event boundary additionally requires a TEG edge lookup. Ordering initially unsorted candidates costs $O(\lvert F_{Q}\rvert\log\lvert F_{Q}\rvert)$. Posting-list results already inherit temporal order. CEF then costs $O(\lvert F_{Q}\rvert)$. Table I reports index retrieval alone, excluding parsing, evidence filtering, generation, and the semantic backend used only for fallback. Thus, structured retrieval accesses query-relevant neighborhoods rather than scanning all $\lvert F\rvert$ facts.

Structure	Storage	Construction	Per-query
TEG ($\mathcal{G}^{t}$)	$\mathcal{O}(|\mathcal{F}|)$	$\mathcal{O}(|\mathcal{F}|)$	$\mathcal{O}(\mathrm{deg})$
SCCI ($\mathcal{D}^{s}$)	$\mathcal{O}(|\mathcal{F}|)$	$\mathcal{O}(|\mathcal{F}|\log d_{\max})$	$\mathcal{O}(\log d_{\max}+k)$
OCCI ($\mathcal{D}^{o}$)	$\mathcal{O}(|\mathcal{F}|)$	$\mathcal{O}(|\mathcal{F}|\log d_{\max})$	$\mathcal{O}(\log d_{\max}+k)$

Space Complexity. The three structured views require $O(\lvert F\rvert)$ storage: each fact appears once in TEG and once in each of SCCI and OCCI. These views require no fact-level dense vectors. Entity/relation embedding caches and the semantic fallback backend are additional storage, separate from this structural bound.

Limitations

Entity Grounding and Query Parsing Noise. Ambiguous entity mentions or misaligned relations can produce empty or incorrect structured evidence even when the query is routed to a view. Semantic retrieval provides a safety net when the structured result is empty, but does not guarantee detection of nonempty, incorrect evidence. Robust grounding and relation disambiguation remain important challenges.

Sparse Knowledge Graph. The SCCI/OCCI indices gain efficiency when multiple facts share the same $(\mathit{subject},\mathit{relation})$ or $(\mathit{relation},\mathit{object})$ key. On sparse KGs, most posting lists contain a single entry. In such cases, multi-step causal chain retrieval degenerates to a single fact lookup, and the multi-view design provides limited benefit. Adapting TCC-RAG to sparse KG settings is left to future work.

Experiments

Experimental Setup

Datasets. We evaluate the effectiveness of TCC-RAG on two widely used TKGQA benchmarks: MULTITQ [13] and TimeQuestions [36], as summarized in Table II and Table III. MULTITQ is a large-scale TKGQA dataset containing over 500K questions with diverse temporal granularities. The questions span multiple temporal reasoning patterns, requiring varying numbers of reasoning steps over temporal knowledge graphs. Its scale and diversity make it particularly suitable for evaluating both retrieval accuracy and reasoning robustness under complex temporal settings. TimeQuestions is a complementary benchmark consisting of approximately 16K questions, categorized into four distinct temporal reasoning types. Across both datasets, different question types inherently require different levels of temporal reasoning, ranging from single-step temporal lookup to multi-step causal chain reasoning, making them well aligned with our evaluation objectives.

Category	Train	Dev	Test
Single
Equal	135,890	18,983	17,311
Before/After	75,340	11,655	11,073
First/Last	72,252	11,097	10,480
Multiple
Equal Multi	16,893	3,213	3,207
After First	43,305	6,499	6,266
Before Last	43,107	6,532	6,247
Total	386,787	57,979	54,584

Category	Train	Dev	Test
Explicit	2,724	1,302	1,311
Implicit	651	291	292
Temporal	2,657	1,073	1,067
Ordinal	938	570	567
Total	6,970	3,236	3,237

Baselines. We compare TCC-RAG with a diverse set of baselines covering pretrained language models, embedding-based QA methods, and large language model (LLM)-based approaches. On the MULTITQ dataset, we evaluate against the following methods:

• Pretrained Language Models: BERT [14], DistilBERT [37], and ALBERT [15], which fine-tune pretrained transformers for temporal QA.

• Embedding-based Methods: EmbedKGQA [38], CronKGQA [32], and MultiQA [13], which rely on learned knowledge graph embeddings for temporal reasoning.

• LLM-based Methods: LLaMA 3.1 8B [39], GPT-4o-mini [1], and DeepSeek-Chat [40] answer questions through prompt-based inference. ARI [21], TimeR⁴ [18], and RTQA [19] augment LLMs with semantic RAG pipelines.

On the TimeQuestions dataset, we compare against the following categories of baselines:

• KGQA Methods: PullNet [41], GRAFTNet [42], and Uniqorn [43], which perform reasoning over static or hybrid knowledge graphs. TKGQA-specific methods include CronKGQA [32], TempoQR [16], EXAQT [44], LGQA [34], and TwiRGCN [36].

• LLM-based Methods: LLaMA2 7B [2], ChatGPT [1], GenTKGQA [20], TimeR⁴ [18], and RTQA [19], which leverage large language models with varying retrieval strategies.

These baselines collectively cover a wide spectrum of paradigms, enabling a comprehensive evaluation of TCC-RAG across different temporal reasoning and retrieval settings.

Implementation Details

• LLM & Model Configuration. For the progressive query parsing module (Section IV-B), we use a locally hosted LLaMA 3.1 8B [39] for both entity extraction and relation extraction. The NER component adopts roberta-large-ner-english [45] as the surface-form recognition model, and multi-qa-MiniLM-L6-cos-v1 [46], [47] for cosine similarity computation between entity mentions and KG entities. For final answer generation, we evaluate TCC-RAG with three LLM backbones: DeepSeek-Chat v3.1-20250922 [40], GPT-4o-mini [1], and LLaMA 3.1 8B [39]. On TimeQuestions, TCC-RAG is evaluated using DeepSeek-Chat v3.1-20250922 as the generator. The entity-grounding similarity threshold is set to $\theta_1 = 0.85$. Candidates below this threshold fall back to fuzzy string matching. The temporal-bucket width $\delta$ in the causal signature $\kappa(\tau,\hat{c},\tau_b)$ is set to 1 day for range cues (before, after). For same, first, and last, $\kappa$ uses exact-timestamp or ordinal-rank encoding without bucketing.

• Baseline Setup. On MULTITQ, results for non-LLM baselines (BERT/DistilBERT/ALBERT, EmbedKGQA, CronKGQA, MultiQA) and ARI/RTQA are taken directly from RTQA [19]. TimeR⁴ is evaluated using its publicly released checkpoint with its original pretrained LLaMA backbone. TCC-RAG uses DeepSeek-Chat, GPT-4o-mini, and LLaMA 3.1 8B through public APIs. On TimeQuestions, results for non-LLM baselines (PullNet, Uniqorn, GRAFT-Net, CronKGQA, TempoQR, EXAQT, TwiRGCN, LGQA) are taken directly from TimeR⁴ [18]. For LLM-based RAG baselines (TimeR⁴ and RTQA), we re-run them with the same frozen DeepSeek-Chat v3.1-20250922 generator as TCC-RAG, rather than using their originally reported numbers. This is because the TimeQuestions training and test splits have partial overlap, which can cause data leakage when a fine-tuned backbone is used, inflating reported scores. By replacing all LLM generators with the same frozen DeepSeek-Chat v3.1-20250922, we eliminate backbone confounds and ensure a fair comparison that isolates each method’s retrieval and reasoning strategy.

• Hardware & Decoding. All experiments are conducted on a server equipped with an NVIDIA A6000 GPU and an Intel Xeon Gold 6330 CPU @ 2.00GHz. All LLM calls use deterministic decoding with temperature = 0 and top-

$p = 0.9$ to ensure reproducibility.

Overall Performance

Results on MULTITQ. Table IV reports the experimental results on the MULTITQ dataset. Overall, TCC-RAG consistently outperforms all baseline methods across evaluation metrics. In particular, compared with the state-of-the-art RTQA, TCC-RAG achieves relative improvements of 10.72% and 14.06% on Hits@1 and Hits@10, respectively. A closer inspection reveals that the performance gains are primarily driven by the Multiple question category, where TCC-RAG achieves improvements of 62.97% on Hits@1 and 74.71% on Hits@10. This category exclusively consists of complex temporal questions requiring multi-step reasoning, such as Before_Last, After_First, and Equal Multi. Existing semantic-based RAG methods struggle in this setting, as they are unable to retrieve coherent multi-hop causal evidence and often introduce redundant or irrelevant facts. In contrast, TCC-RAG explicitly leverages causal cue-guided traversal to retrieve multi-hop causal knowledge. By following temporal causal chains while suppressing redundant information, the proposed method is able to recover causally consistent evidence paths, leading to substantial improvements under complex multi-step temporal reasoning scenarios.

Model	Hits@1 Overall	Hits@1 Multiple	Hits@1 Single	Hits@1 Entity	Hits@1 Time	Hits@10 Overall	Hits@10 Multiple	Hits@10 Single	Hits@10 Entity	Hits@10 Time
BERT	0.083	0.061	0.092	0.101	0.040	0.441	0.392	0.461	0.531	0.222
DistilBERT	0.083	0.074	0.087	0.102	0.037	0.482	0.426	0.505	0.591	0.216
ALBERT	0.108	0.086	0.116	0.139	0.032	0.484	0.415	0.512	0.589	0.228
EmbedKGQA	0.206	0.134	0.235	0.290	0.001	0.459	0.439	0.467	0.648	0.001
CronKGQA	0.279	0.134	0.337	0.328	0.156	0.608	0.453	0.671	0.696	0.392
MultiQA	0.293	0.159	0.347	0.349	0.157	0.635	0.519	0.682	0.733	0.396
LLaMA 3.1 8B	0.032	0.008	0.041	0.037	0.019	0.056	0.015	0.071	0.064	0.039
GPT-4o mini	0.064	0.019	0.081	0.071	0.048	0.094	0.030	0.118	0.115	0.048
DeepSeek-Chat	0.104	0.034	0.129	0.115	0.081	0.153	0.049	0.191	0.181	0.090
ARI	0.380	0.210	0.680	0.394	0.344	-	-	-	-	-
TimeR⁴	0.728	0.335	0.887	0.639	0.945	-	-	-	-	-
RTQA	0.765	0.424	0.902	0.692	0.942	0.768	0.427	0.907	0.697	0.942
TCC-RAG LLaMA 3.1 8B	0.762	0.580	0.836	0.715	0.876	0.823	0.648	0.894	0.789	0.901
TCC-RAG GPT-4o mini	0.817	0.646	0.879	0.767	0.923	0.857	0.709	0.911	0.821	0.936
TCC-RAG DeepSeek-Chat	0.847	0.691	0.911	0.801	0.959	0.876	0.746	0.928	0.839	0.961
Imp (%)	10.72	62.97	1.00	15.75	1.48	14.06	43.74	2.32	14.46	2.02

In addition, we further evaluate TCC-RAG with different LLM backbones. Notably, TCC-RAG equipped with LLaMA 3.1 8B achieves comparable Hits@1 performance to RTQA using DeepSeek-Chat, while surpassing it by 7.16% on Hits@10. This result demonstrates that even with a lightweight backbone, TCC-RAG is able to compensate for limited reasoning capacity through effective causal retrieval. When equipped with GPT-4o-mini, TCC-RAG further establishes clear advantages over RTQA, achieving improvements of 6.80% and 11.58% on Hits@1 and Hits@10, respectively. These consistent gains across different backbone capacities indicate that the performance improvements of TCC-RAG are not solely attributed to stronger language models, but rather stem from its superior ability to retrieve and organize temporally coherent causal knowledge. By explicitly capturing intrinsic temporal causal structures through causal-guided retrieval, TCC-RAG effectively mitigates the reasoning limitations of smaller-scale LLMs and amplifies the strengths of more capable backbones, enabling it to outperform LLM-based baselines across model sizes consistently.

Results on TimeQuestions. The experimental results on the TimeQuestions dataset are reported in Table V. As shown, TCC-RAG consistently achieves the best performance across all question types. Overall, TCC-RAG outperforms the best-performing baseline RTQA by 8.40%, demonstrating its strong generalization ability on diverse temporal reasoning tasks. Similar to the observations on MULTITQ, the performance gains on TimeQuestions are primarily attributed to question types that require multi-step temporal reasoning. In particular, on the Implicit question category, TCC-RAG achieves a notable improvement of 13.58% over the best baseline

Model	Overall	Question Type		Answer Type
		Explicit	Implicit	Temporal	Ordinal
PullNet	0.105	0.022	0.081	0.234	0.029
Uni-?	0.331	0.318	0.316	0.392	0.202
GRAFT-Net	0.452	0.445	0.428	0.515	0.322
CronK-GQA	0.462	0.466	0.445	0.511	0.369
TempoQR	0.416	0.465	0.036	0.400	0.349
EXAQT	0.572	0.568	0.512	0.642	0.420
TWiRG-CN	0.605	0.602	0.586	0.641	0.518
LGQA	0.529	0.532	0.506	0.605	0.402
LLaMA2 7B	0.271	0.268	0.325	0.279	0.234
ChatGPT	0.459	0.433	0.511	0.465	0.481
GenTGKQA	0.584	0.596	0.611	0.563	0.578
TimeR⁴	0.617	0.609	0.512	0.754	0.426
RTQA	0.655	0.648	0.601	0.762	0.503
TCC-RAG	0.710	0.711	0.694	0.781	0.597
Imp (%)	8.40	9.72	13.58	2.49	3.29

and 35.54% over semantic-based RAG methods such as TimeR⁴. Such questions require inferring multi-hop temporal and causal dependencies that are not explicitly stated in the query or directly retrievable via semantic similarity. These results further indicate that TCC-RAG is able to enhance the reasoning capability of LLMs by explicitly retrieving multi-step temporal causal chains. By capturing structured causal knowledge rather than isolated facts, TCC-RAG effectively supports complex temporal reasoning, consistently validating its causal knowledge mining ability across different datasets and reasoning settings.

Ablation Study

We conduct ablation studies on MULTITQ to evaluate the effectiveness of each component in TCC-RAG. The results are reported in Table VI. Specifically, w/o CCG removes the Causal Cue Graph and relies solely on semantic retrieval, w/o PQP disables the progressive query parsing pipeline and uses a single-shot LLM call to extract all signals (entities, relation, cue, role) at once, and w/o CEF removes the causal evidence filter.

Model	Overall	Multiple	Single	Entity	Time
w/o CCG	0.647	0.127	0.837	0.517	0.933
w/o PQP	0.778	0.653	0.824	0.759	0.821
w/o CEF	0.841	0.664	0.910	0.791	0.958
TCC-RAG	0.847	0.691	0.911	0.801	0.959

Effect of Causal Cue Graph. Removing the Causal Cue Graph results in a substantial performance degradation across all metrics. In particular, the overall performance drops by 23.61%, with the most significant decline observed in the *Mul-

tiple question category, where the score decreases by 81.62%. The Entity-type answers also suffer a notable drop of 35.45%, while the performance degradation on Single and Time-type questions is relatively minor (8.12% and 2.71%, respectively). This phenomenon is expected, as Multiple questions exclusively consist of complex multi-step temporal reasoning tasks. Similarly, Entity-type answers tend to involve more multi-hop temporal dependencies than Time-type answers. These results demonstrate that the causal cue graph is critical for modeling complex temporal causal structures, and its removal severely impairs the model’s ability to perform multi-step temporal reasoning.

Effect of Progressive Query Parsing. Disabling progressive query parsing and relying on a single-shot LLM call leads to consistent performance degradation across all categories, with an overall drop of 8.14%. This degradation is particularly evident in Multiple (5.49%) and Time-type (14.3%) questions. The results indicate that time-sensitive queries exhibit high linguistic and structural diversity, making accurate entity and relation extraction challenging when all signals are produced in a single LLM pass. Without the staged decomposition into entity grounding, context-aware relation parsing, and rule-based cue extraction, errors accumulate and prevent effective grounding of queries onto the causal cue graph. Consequently, the model fails to fully exploit the structured causal retrieval mechanism, resulting in reduced performance.

Effect of Causal Evidence Filter. Removing the causal evidence filter also leads to performance degradation, particularly on Multiple and Entity-type questions, where the scores drop by 3.90% and 1.24%, respectively. These observations suggest that the filter primarily contributes to refining causal evidence in complex temporal reasoning scenarios, where retrieval may still introduce redundant or noisy facts due to data noise. The relatively small overall performance drop (0.71%) is expected, as the filter operates as a structural refinement layer on top of an already concise retrieval output. Since most queries can already retrieve minimal and precise causal knowledge through the causal cue graph, only a small portion of queries require further refinement by the filter.

Semantic Fallback Analysis. Semantic retrieval is invoked when structured retrieval returns no facts.

Table VII reports coverage on the complete test sets and conditional Hits@1 within each retrieval path. On MULTITQ, structured retrieval handles 46,102 of 54,584 queries, while fallback handles the remaining 8,482. On TimeQuestions, structured coverage reaches 91.82%. With fallback disabled, uncovered queries receive no prediction, and overall Hits@1 is 0.770/0.678 on MULTITQ/TimeQuestions, still exceeding RTQA’s 0.765/0.655. Thus, causal-cue retrieval is effective independently, while semantic fallback improves coverage.

Dataset	Path	Coverage	Hits@1
MULTITQ	Structured	84.46%	0.912
MULTITQ	Fallback	15.54%	0.492
TimeQuestions	Structured	91.82%	0.738
TimeQuestions	Fallback	8.18%	0.398

Insights and Case Study

Results for Multi-Granularity Time. To evaluate the effectiveness of TCC-RAG under different temporal resolutions, we conduct experiments across multiple time granularities, including day, month, and year. The results are shown in Figure 5. Overall, TCC-RAG achieves the best performance across most temporal granularities and question types, demonstrating its robustness in handling temporal reasoning under different time resolutions. In particular, consistent improvements are observed in the Before/After and Equal Multi categories, indicating that temporal causal chain-guided retrieval is effective for capturing causal temporal dependencies across events at different granularities. We note that RTQA slightly outperforms TCC-RAG in the Equal-Month and Equal-Multi-Month settings. These cases mainly involve direct temporal alignment at a single reasoning step, where semantic retrieval is often sufficient. Nevertheless, TCC-RAG maintains stable performance across coarse to fine-grained temporal reasoning tasks, confirming the general effectiveness of the proposed causal retrieval framework.

Vector (PDF)

Case Study. To verify whether TCC-RAG can retrieve truly causal knowledge, we conduct a retrieval case study comparing TCC-RAG with semantic-based methods. The results are illustrated in Figure 4. TimeR4 employs rewrite-and-rerank strategies, while RTQA utilizes question decomposition. However, both methods fail to retrieve the key causal facts required for multi-step temporal reasoning and introduce a large number of redundant facts, which ultimately prevents the model from producing the completely correct answer. TCC-RAG leverages the causal cue graph to retrieve only the most relevant facts. With merely four retrieved facts, the model can construct a complete temporal causal chain and successfully perform multi-step reasoning. This demonstrates that TCC-RAG is capable of mining concise yet sufficient causal knowledge. Furthermore, this example reveals an implicit temporal ambiguity. Although the ground-truth answer is *Citizen (North Korea, multiple events, including South Korea and Envoy (United States), occur on the same day. TCC-RAG accurately captures this temporal coincidence through causal cue-guided retrieval and returns all temporally consistent answers. This observation further demonstrates that TCC-RAG can uncover latent causal structures within the temporal knowledge store rather than relying solely on surface-level semantic matching.

Vector (PDF)

Efficiency Analysis

Figure 6 presents a detailed comparison of token cost and inference time between TCC-RAG and RTQA on MULTITQ, highlighting the efficiency advantages of TCC-RAG.

Token Consumption. We compare the average input token consumption of RTQA and TCC-RAG on the MULTITQ dataset, where both methods are deployed using DeepSeek-Chat. In RTQA, token usage mainly comes from the recursive question decomposition process and the subsequent answer aggregation for each sub-question. In contrast, TCC-RAG consumes tokens primarily during query parsing and final answer generation. Experimental results show that RTQA consumes an average of 1,403.8 tokens per question, whereas TCC-RAG only uses 604.8 tokens per question on average, reducing token consumption by over 57%. This substantial reduction is mainly attributed to the concise yet sufficiently informative set of causal facts retrieved by TCC-RAG, which yields a much smaller evidence context for the LLM. These results demonstrate that causal-chain-guided retrieval not only improves reasoning accuracy but also significantly reduces token consumption compared with decomposition-based RAG pipelines.

Inference Time. We further compare the average end-to-end processing time per query. TCC-RAG takes 2.11s per query on average, slightly higher than the 1.82s of RTQA. This minor gap mainly stems from the entity grounding stage, where TCC-RAG invokes both a NER model and an LLM for dual-path extraction and consistency verification, introducing a small additional cost. Nevertheless, this overhead is well justified by the substantial accuracy gains, and remains acceptable in practice. Since all LLM components are accessed through asynchronous API calls, multiple queries can be processed concurrently, allowing TCC-RAG to deliver answers efficiently at scale despite the slightly higher per-query latency.

Conclusion

In this paper, we propose TCC-RAG, a novel RAG framework for TKGQA. To overcome the limitations of existing semantic-based RAG methods, which suffer from missing causally relevant facts and introducing noisy evidence, we introduce a multi-view causal cue graph that explicitly encodes temporal causal relations. Built on this structure, we design a progressive causal chain-guided retrieval strategy that traces causally relevant evidence along the routed graph view, paired with a causal evidence filter that distills the retrieved set into a minimal causally sufficient subset. Extensive experiments on two widely used TKGQA benchmarks demonstrate that TCC-RAG consistently outperforms state-of-the-art methods, with especially significant improvements on complex multi-step temporal reasoning. Ablation studies verify the effectiveness of each component, while a case study further demonstrates the ability of TCC-RAG to retrieve concise yet sufficient causal evidence. Moreover, efficiency analysis confirms the practical efficiency and scalability of the proposed framework.

Acknowledgments

This work was sponsored by the National Natural Science Foundation of China (No.62472327, 62572361), CCF-Tencent Rhino-Bird Open Research Fund (CCF-Tencent RAGR20260132), and the Sichuan Clinical Research Center for Imaging Medicine (XYXX2402).

AI-Generated Content Acknowledgments

AI tools (ChatGPT and Claude) were used for language polishing and to suggest improvements to the visual presentation of selected figures, including colors and formatting. AI was not used for research conception, method design, or experiments.

References