Paper · 2026-10-28 · cs.CL
TCC-RAG: Temporal Causal Chain-Guided RAG for Temporal Knowledge Graph Question Answering
TCC-RAG answers questions over temporal knowledge graphs by indexing facts in time-sorted lists per subject-relation and object-relation pair, parsing the query with a dual-path entity grounder and an LLM, and keeping a deduplicated, minimal chain of facts for the answering LLM. Author-reported Hits@1 on MULTITQ with DeepSeek-Chat is 0.847 vs 0.765 for RTQA; on TimeQuestions, 0.710 vs 0.655.
Retrieval-augmented generationGraph-based RAGKnowledge base question answeringMulti-hop reasoningtemporal-knowledge-graphquestion-answeringcausal-retrievalretrieval-augmented-generation
AI-compiled by claude-haiku-5-5 on 2026-11-21, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Some questions depend on when things happened: who visited a country before someone else did, or what happened last before a given date. A common approach looks up text passages that sound similar to the question and hands them to a language model. For this kind of question, the passages that matter often do not sound like the question, while many passages that do sound similar are irrelevant and can lead the model to a wrong chain of reasoning.
This paper stores the facts in a way that makes time order easy to use. Facts are grouped by who did what, kept in date order, and looked up by the query's main subject or object. A small set of rules and language-model calls works out which entity, relation and time limit the question names. The system then keeps only the few facts that form a clear sequence leading to the answer, and passes those to the language model. The authors report that this helps most on questions that need several time-ordered steps, and that it sends fewer words to the model than a comparable method.
TL;DR
- The method replaces similarity-only retrieval over temporal facts with lookups along causal "cue" structures: time-ordered lists keyed by subject and relation, or by relation and object §IV.A.
- A query is parsed in stages (entity grounding, cue rules, relation and role extraction), routed to one of three views, and filtered to a deduplicated, minimal evidence chain §IV.B §IV.C alg. 1.
- Author-reported Hits@1 on MULTITQ: 0.847 with DeepSeek-Chat, 0.817 with GPT-4o-mini, 0.762 with LLaMA 3.1 8B, vs 0.765 for the best baseline RTQA tab. IV.
- Author-reported Hits@1 on TimeQuestions: 0.710 vs 0.655 for RTQA, with the generator fixed to DeepSeek-Chat tab. V.
- The method is training-free, but it needs two to three LLM calls per query and an entity matching setup. Read the Pitfalls before reusing any number; the word "causal" here is operational, not interventional §III.
Problem
Semantic retrieval-augmented generation (RAG) returns facts that are similar to the question. The authors identify two failures for multi-step temporal questions. First, a fact that is needed for the time order but shares few words with the question is missed §I. Second, similarity retrieval returns many facts about the same entity that are not on the causal path, and these can send the model down a wrong chain §I.
The method assumes a temporal knowledge graph of quadruples (head, relation, tail, time), with times given as dates, intervals or ordered indices §III. Questions are of three shapes: a pair of known entities with a relation, a single known entity with an unknown partner, and questions with an ordering constraint against a reference time, optionally followed by a first or last selection §III §IV.A. The paper evaluates question types "Equal", "Before/After", "First/Last", and the multi-step "Equal Multi", "After First" and "Before Last" tab. II. The paper's claims about its method hold for these shapes and for the two named benchmarks; it does not claim wider coverage.
Method
The method has three parts §IV. A multi-view index is built once from the facts §IV.A. A query is parsed and routed to one view, and time-ordered candidates are selected to form a chain §IV.B. A causal evidence filter removes duplicates and selects a minimal set §IV.C. The answering model then receives the filtered facts and the question §IV.D.
Index: three views of the same facts
Three views are built from the fact set \mathcal{F} §IV.A tab. I.
- Temporal Event Graph (TEG). A directed multi-edge graph with one edge per fact, from head to tail, labelled by relation and time. It serves queries about two known entities §IV.A.
- Subject Causal Cue Index (SCCI). A hash map keyed by (subject, relation). Each value is the list of that subject's facts under that relation, sorted by time §IV.A eq. 2.
- Object Causal Cue Index (OCCI). A hash map keyed by (relation, object), with the same sorted lists §IV.A eq. 3.
The paper does not store the cue relations (before, after, same) as edges. For two facts in a sorted list, the earlier one is before the later one, and equal times give only "same" §IV.A. The posting-list layout keeps storage linear in the number of facts rather than quadratic in the list length §IV.A tab. I.
Query parsing
Parsing runs in three stages, each using the output of the previous one §IV.B alg. 1.
- Entity grounding. A named-entity recognizer and an LLM each extract mentions from the query. Each mention is matched to the entity vocabulary using embedding similarity when the top score clears a threshold \theta_1, and using string-level fuzzy matching when it does not eq. 4. If the two extractors return the same entity set, that set is used; if not, an LLM is given both sets and the query and chooses the set eq. 5 §IV.B.
- Cue. Ordering and selection cues (before, after, first, last, same) are matched by fixed surface rules, not by the LLM eq. 6 §IV.B.
- Relation, roles and reference. An LLM extracts a relation phrase, the subject and object roles, and a time reference when the query has one eq. 7. The phrase is mapped to the nearest canonical relation in the knowledge graph by cosine similarity of embeddings eq. 8 §IV.B. The answer slot (subject, object or time) is read from the question's interrogative and the missing argument §IV.B.
Routing then chooses one view eq. 9 §IV.B:
- both subject and object are grounded and the question asks for a time: TEG;
- the grounded entity is the subject and the answer is an object: SCCI;
- the grounded entity is the object and the answer is a subject: OCCI.
The second entity in a multi-step question is used only for the time boundary, not for a second traversal. The executor does not join across views or relations §IV.B.
Candidate retrieval and the temporal chain
The boundary \tau_b is the explicit date in the query when there is one. Otherwise it is the time of a reference event that connects the anchor and the reference entity under the same relation in TEG. If neither applies, the boundary is unresolved, written \bot §IV.B.
Candidates depend on the view eq. 10 eq. 11 §IV.B.
- TEG: all edges from the subject to the object with the canonical relation.
- SCCI or OCCI: the posting list for the anchor and relation; binary search finds the boundary and a range scan keeps the facts that satisfy the ordering cue. With \bot no ordering is applied and the whole list is eligible. A missing key, or a required boundary that cannot be resolved, gives an empty set.
A selection step then applies the ordering cue and, if present, keeps only the earliest or latest eligible fact. A compound cue, such as "before last", narrows the range first and then picks its extreme. The selected facts are sorted by time to form the chain eq. 12 §IV.B.
When the candidate set is empty, the method uses semantic similarity search over the facts as a fallback. The text says this happens when the structured path finds nothing, not merely because a route was chosen §IV.B.
Causal evidence filter
The filter takes the candidates from either path and works in two deterministic steps §IV.C.
- Deduplication. Each fact gets a signature (head, relation, tail, \kappa) eq. 13. The value \kappa depends on the cue eq. 14. For before and after, it is the number of whole days between the fact's time and \tau_b, floored in 1-day buckets. For first and last, it is the fact's rank within its (head, relation, tail) group. For same or no cue, it is the calendar ordinal of the date. Facts with the same signature form a class, and the earliest fact in each class is kept §IV.C.
- Sufficiency. A greedy selection applies three conditions in order
§IV.C.
- Boundary preservation: for first or last, keep the earliest or latest eligible fact; for same with a resolved boundary, keep all facts on the anchor day.
- Cue coverage: add a representative of each class that satisfies the ordering cue.
- Chain connectivity: sort by time and check that consecutive facts share the relation and that times do not decrease. If this fails, return the deduplicated set instead.
The pseudocode below follows alg. 1 and §IV.A–§IV.C. It is a reading of the paper, not the authors' code; the step order and the union in the sufficiency step are interpretations, as flagged in Pitfalls.
# Build the three views from facts [§IV.A] [eq. 2] [eq. 3]
# Input: facts: list of (head, rel, tail, tau)
# Output: teg (edge list), scci and occi (dict of sorted posting lists)
def build_views(facts):
# TEG: one edge per fact, head to tail, labelled by relation, time [§IV.A]
teg = []
scci = {}
occi = {}
for head, rel, tail, tau in facts:
teg.append((head, tail, rel, tau))
# SCCI key (subject, relation) [§IV.A] [eq. 2]
scci.setdefault((head, rel), []).append((head, rel, tail, tau))
# OCCI key (relation, object) [§IV.A] [eq. 3]
occi.setdefault((rel, tail), []).append((head, rel, tail, tau))
# Posting lists sorted by time, ascending [§IV.A] [eq. 2] [eq. 3]
for postings in list(scci.values()) + list(occi.values()):
postings.sort(key=lambda fact: fact[3])
return teg, scci, occi# Retrieve a causal chain for one query [alg. 1] [§IV.B]
# Input: query, views (teg, scci, occi), kg_entities, relations, cue_rules
# Output: list of facts ordered by time, after the evidence filter
def retrieve(query, views, kg_entities, relations, cue_rules):
# Entity grounding: two extractors, then agreement or LLM [eq. 4] [eq. 5]
ner_set = match_to_kg(ner_mentions(query), kg_entities)
llm_set = match_to_kg(llm_mentions(query), kg_entities)
if ner_set == llm_set:
entities = ner_set
else:
entities = llm_choose(query, ner_set, llm_set)
# Cue from fixed rules, relation and roles from the LLM [eq. 6] [eq. 7]
cue = rule_match(query, cue_rules)
phrase, roles, reference = llm_parse_relation(query, entities)
# Map the phrase to the nearest canonical relation [eq. 8]
rel = nearest_relation(phrase, relations)
anchor, answer = anchor_and_answer(entities, roles)
# Time boundary: explicit date, else reference event, else None [§IV.B]
boundary = resolve_boundary(query, reference, anchor, rel, views)
# Route to one view by query shape [eq. 9] [eq. 10] [eq. 11]
if is_pair(query):
candidates = views.teg_edges(anchor, rel, other_entity(entities))
elif roles[anchor] == "subject" and answer == "object":
candidates = views.scci.get((anchor, rel), [])
elif roles[anchor] == "object" and answer == "subject":
candidates = views.occi.get((rel, anchor), [])
else:
# No branch in the paper for this case; the list stays empty [eq. 9]
candidates = []
# Apply the ordering cue, then first or last [eq. 11] [§IV.B]
candidates = temporal_select(candidates, cue, boundary)
# Similarity fallback only when the structured path is empty [§IV.B]
if not candidates:
candidates = semantic_retrieve(query)
# Order by time, then filter [eq. 12] [alg. 1] [§IV.C]
candidates = sorted(candidates, key=lambda fact: fact[3])
return causal_evidence_filter(candidates, cue, boundary, rel)# Causal evidence filter: dedupe, then sufficiency [§IV.C] [eq. 13] [eq. 14]
# Input: candidates (time-ordered facts), cue, boundary (or None), rel
# Output: filtered facts, time-ordered
def causal_evidence_filter(candidates, cue, boundary, rel):
# Signature (head, rel, tail, kappa); keep earliest per class [eq. 13]
classes = {}
for fact in candidates:
key = causal_signature(fact, cue, boundary) # kappa [eq. 14]
classes.setdefault(key, []).append(fact)
deduped = [min(group, key=time_of) for group in classes.values()]
eligible = [f for f in deduped if satisfies_ordering(f, cue, boundary)]
# (i) Boundary: earliest or latest, or all same-day facts [§IV.C]
selected = boundary_facts(eligible, cue, boundary)
# (ii) Cue coverage: one representative per eligible class [§IV.C]
representatives = [
min(group, key=time_of)
for group in eligible_groups(classes, cue, boundary)
]
selected = union(selected, representatives)
# (iii) Chain connectivity: same relation, non-decreasing time [§IV.C]
if not is_connected(sorted(selected, key=time_of), rel, cue):
return sorted(deduped, key=time_of)
return sorted(selected, key=time_of)The pseudocode above writes out the three helpers that the paper only names,
such as eligible_groups and is_connected, as calls. The paper does not
define the within-group rank used for first and last in causal_signature
beyond a one-line description, and it does not define how boundary_facts
interacts with step (ii).
Answer generation
The filtered facts are serialized as a list and sent to the LLM with the
question §IV.D. The prompt in fig. 3 asks for a JSON object with a single
key, answers, that lists every possible answer with no explanation. Entity
strings must match the facts exactly. Dates follow ISO format, at the precision
the question asks for: year, month or day fig. 3. The paper reports that the
answering LLM reasons over the fact chain without any fine-tuning §IV.D.
Complexity
Offline construction takes O(|\mathcal{F}| \log d_{\max}) time, dominated by sorting posting lists, and O(|\mathcal{F}|) storage §IV.E tab. I. Index lookup takes O(\log d_{\max} + k) per query for SCCI and OCCI, and O(\mathrm{deg}) for TEG, where k is the number of cue-consistent events tab. I. Parsing takes two LLM calls (mentions and predicates), plus one more when the two entity extractors disagree, and answer generation takes one more call §IV.E. The paper states that entity and relation matching costs are separate and depend on vocabulary size §IV.E. No embedding vectors are stored per fact; embedding caches and the fallback backend add storage on top of the O(|\mathcal{F}|) bound §IV.E.
Limitations (as stated)
- Grounding and relation-parsing errors can give empty or wrong structured evidence; the fallback catches empty results but not wrong non-empty ones §IV.F.
- On sparse graphs, posting lists hold one entry, so the multi-step path reduces to a single lookup and gives little benefit; the authors leave sparse graphs to future work §IV.F.
Hyperparameters
| Name | Value | Where | Notes |
|---|---|---|---|
| entity-grounding threshold \theta_1 | 0.85 | §V.A | cosine score; below it, fuzzy string matching |
| temporal bucket width \delta | 1 day | §V.A eq. 14 | for before and after only; same, first and last use exact time or rank |
| parsing LLM | LLaMA 3.1 8B, locally hosted | §V.A | entity and relation extraction |
| NER model | roberta-large-ner-english | §V.A | surface-form mention recognition |
| embedding model for mention matching | multi-qa-MiniLM-L6-cos-v1 | §V.A | cosine between mentions and KG entities |
| embedding model for relations \phi | not stated | eq. 8 | |
| answer generators | DeepSeek-Chat v3.1-20250922; GPT-4o-mini; LLaMA 3.1 8B | §V.A | MULTITQ uses all three; TimeQuestions uses DeepSeek-Chat only |
| decoding | temperature 0, top-p 0.9 | §V.A | all LLM calls; sampling seed not stated |
| hardware | NVIDIA A6000 GPU; Intel Xeon Gold 6330 @ 2.00 GHz | §V.A | |
| semantic fallback retriever | not stated | §IV.B | the paper does not name it |
| semantic fallback top-k | not stated | §IV.B | |
| fuzzy matching method and threshold | not stated | §IV.B §V.A | only the cosine threshold is given |
| prompts for entities, relations, arbitration | not stated | §IV.B | only the answer prompt is shown, in fig. 3 |
| train or fine-tune | none (training-free) | §IV.B §IV.D | the paper calls the method "training-free" |
Datasets
MULTITQ questions are split as in tab. II. TimeQuestions is split as in tab. III. The paper gives its own split sizes and the test size is what the results use.
| MULTITQ category | Train | Dev | Test |
|---|---|---|---|
| Single: Equal | 135,890 | 18,983 | 17,311 |
| Single: Before/After | 75,340 | 11,655 | 11,073 |
| Single: First/Last | 72,252 | 11,097 | 10,480 |
| Multiple: Equal Multi | 16,893 | 3,213 | 3,207 |
| Multiple: After First | 43,305 | 6,499 | 6,266 |
| Multiple: Before Last | 43,107 | 6,532 | 6,247 |
| Total | 386,787 | 57,979 | 54,584 |
| TimeQuestions 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 |
tab. II tab. III
Results
Author-reported. The numbers in tab. IV to tab. VII come from the paper's own runs, except where the paper says a baseline is copied from another paper (Pitfalls). Setup: MULTITQ test set (54,584 questions) and TimeQuestions test set (3,237 questions), with the generator named in each row §V.A.
MULTITQ, Hits@1 and Hits@10 (full table tab. IV). Improvement row is relative to the best baseline in each column.
| Model | H@1 Overall | H@1 Multiple | H@1 Single | H@1 Entity | H@1 Time | H@10 Overall | H@10 Multiple | H@10 Single | H@10 Entity | H@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 (prompt only) | 0.032 | 0.008 | 0.041 | 0.037 | 0.019 | 0.056 | 0.015 | 0.071 | 0.064 | 0.039 |
| GPT-4o mini (prompt only) | 0.064 | 0.019 | 0.081 | 0.071 | 0.048 | 0.094 | 0.030 | 0.118 | 0.115 | 0.048 |
| DeepSeek-Chat (prompt only) | 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 | not reported | ||||
| TimeR^4 | 0.728 | 0.335 | 0.887 | 0.639 | 0.945 | not reported | ||||
| 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 |
| Improvement (%) | 10.72 | 62.97 | 1.00 | 15.75 | 1.48 | 14.06 | 43.74 | 2.32 | 14.46 | 2.02 |
TimeQuestions, Hits@1 tab. V. TimeR^4 and RTQA were re-run with the same frozen DeepSeek-Chat generator; the other non-LLM rows are copied from the TimeR^4 paper.
| Model | Overall | Explicit | Implicit | Temporal | Ordinal |
|---|---|---|---|---|---|
| PullNet | 0.105 | 0.022 | 0.081 | 0.234 | 0.029 |
| Uniqorn | 0.331 | 0.318 | 0.316 | 0.392 | 0.202 |
| GRAFT-Net | 0.452 | 0.445 | 0.428 | 0.515 | 0.322 |
| CronKGQA | 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 |
| TwiRGCN | 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 |
| GenTKGQA | 0.584 | 0.596 | 0.611 | 0.563 | 0.578 |
| TimeR^4 (re-run) | 0.617 | 0.609 | 0.512 | 0.754 | 0.426 |
| RTQA (re-run) | 0.655 | 0.648 | 0.601 | 0.762 | 0.503 |
| TCC-RAG (DeepSeek-Chat) | 0.710 | 0.711 | 0.694 | 0.781 | 0.597 |
| Improvement (%) | 8.40 | 9.72 | 13.58 | 2.49 | 3.29 |
Ablation on MULTITQ, Hits@1 tab. VI.
| Variant | Overall | Multiple | Single | Entity | Time |
|---|---|---|---|---|---|
| w/o causal cue graph (semantic retrieval only) | 0.647 | 0.127 | 0.837 | 0.517 | 0.933 |
| w/o progressive query parsing (one LLM call) | 0.778 | 0.653 | 0.824 | 0.759 | 0.821 |
| w/o causal evidence filter | 0.841 | 0.664 | 0.910 | 0.791 | 0.958 |
| full TCC-RAG | 0.847 | 0.691 | 0.911 | 0.801 | 0.959 |
Fallback coverage and conditional Hits@1 tab. VII. With fallback disabled, uncovered queries receive no answer; overall Hits@1 is then 0.770 on MULTITQ and 0.678 on TimeQuestions (author-reported, §V.C).
| 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 |
Efficiency, MULTITQ, DeepSeek-Chat §V.E. Average input tokens per question: 1,403.8 for RTQA and 604.8 for TCC-RAG. Average end-to-end time per query: 1.82 s for RTQA and 2.11 s for TCC-RAG. The authors attribute the extra time to the dual-path entity grounding.
Qualitative results. The paper reports a case study fig. 4 and a per-granularity plot of Hits@1 for day, month and year questions fig. 5. In the granularity plot, RTQA is slightly better on some month-level equal questions, which the authors attribute to single-step alignment §V.D. A comparison of token cost and time against RTQA is shown in fig. 6.
Paper vs code
No official code. The paper has no code, data or project link in its text or its arXiv abstract page; the arXiv "Code, Data and Media" section lists only generic finders with no link to this paper. Searches made: GitHub repository search for "TCC-RAG" (many unrelated repositories, none linked from the paper), "TCC-RAG TKGQA" and "temporal causal chain RAG" (no results). A GitHub organisation search for the authors' university was not possible (the query returned an error), and no author organisation was identified. Nothing from any repository is used on this card.
Pitfalls
- "Causal" is operational. The paper says the term means temporally ordered event dependencies relevant to a query, not an intervention-based notion §III. Do not read the method as a causal-inference method.
- Routing has an unclear case. The routing rule eq. 9 and alg. 1 define a candidate set only for pair queries, subject-anchored object answers and object-anchored subject answers. A single-entity query with a time answer falls into no branch; in alg. 1 the candidate set then stays empty and falls back to semantic retrieval. The paper does not say whether this case is meant to occur.
- Boundary ambiguity. The paper does not say which reference event is used when several connect the anchor and the reference entity under the same relation, nor how month- or year-precision dates become day ordinals for the signature eq. 14 §IV.B. The day-based bucket is defined only for full dates, yet the granularity plot covers day, month and year.
- The filter's "minimal" subset is not fully specified. The paper calls the output minimal §IV.C, but step (ii) adds one representative per eligible class, so the size depends on how many classes exist. It also does not say how step (i) combines with step (ii) (the pseudocode takes a union, which is an assumption), nor how the rank for first and last is computed within a group.
- Fallback path is weaker. On MULTITQ, fallback Hits@1 is 0.492 vs 0.912 for the structured path tab. VII. The fallback retriever is not named and its top-k is not stated §IV.B.
- Hits@k and multi-answer scoring are not defined. The tables report Hits@1 and Hits@10 without a definition, and the paper does not say how a question with several correct answers is scored §V.B tab. IV.
- The improvement rows use different baselines. In tab. IV each column's improvement is against that column's best baseline: RTQA for overall Hits@1, MultiQA for Hits@10 on Multiple questions (43.74%), TimeR^4 for Time Hits@1 (1.48%). The text instead quotes 74.71% on Multiple Hits@10 against RTQA (0.427), so the two figures measure different things. Quote the number with its baseline.
- Dataset sizes in the text do not match the tables. The text says MULTITQ has "over 500K" questions; tab. II sums to 499,350. The text says TimeQuestions has "approximately 16K" questions; tab. III sums to 13,443.
- Token saving is slightly overstated. From the reported averages, the reduction is (1,403.8 − 604.8) / 1,403.8, about 56.9%, while the text says "over 57%" §V.E.
- Baselines are not like-for-like across the two tables. On MULTITQ, the non-LLM baselines, ARI and RTQA are copied from the RTQA paper, and TimeR^4 uses its public checkpoint with its original LLaMA backbone §V.A. On TimeQuestions, RTQA and TimeR^4 are re-run with the frozen DeepSeek-Chat generator, and the paper gives a leakage reason (partly overlapping splits) §V.A. Compare methods within a table only.
- Index description conflicts. The introduction says the two indices are "trie-structured" §I; the method defines them as hash maps of sorted lists §IV.A eq. 2 eq. 3.
- Ablation numbers have no variance. The ablation is a single run per variant with no seeds or intervals reported §V.C. The smallest drop, 0.71% for removing the filter, is within what a rerun could change.
- Hosted-LLM determinism. Temperature 0 and top-p 0.9 are stated §V.A. The paper does not say whether any API calls were repeated or how the hosted models' outputs were checked for stability.
- Unlisted cost. The per-query time figure includes two parsing calls and an answer call; entity and relation matching are not separated out in the 2.11 s figure §V.E §IV.E.
- Version. The metadata this card was built from records arXiv v1. The arXiv abstract page showed a later version at compile time; this card has not checked it, and numbers may differ.
- Figure cites. Figure and table numbers follow the order in the LaTeX source; the compiled PDF was not read, so check fig. 3 to fig. 6 and eq. 1 to eq. 14 against the PDF if exact printed numbers matter.
Lineage
- Compared against: RTQA; TimeR^4; ARI; MultiQA; CronKGQA; EmbedKGQA; GenTKGQA; BERT, DistilBERT and ALBERT (as baselines on MULTITQ); TempoQR, EXAQT, TwiRGCN, LGQA, PullNet, GRAFT-Net and Uniqorn (on TimeQuestions) §V.A.
- Builds on: semantic RAG pipelines for temporal questions, which the paper describes as its starting point §I §II.
- Superseded by: not known.
Source and license
Adapted from “TCC-RAG: Temporal Causal Chain-Guided RAG for Temporal Knowledge Graph Question Answering” by Xinxun Zhang, Yuxiang Wang, Shanshan Feng, Jun Zhang, Tieyun Qian, Binhang Yuan, Kai Yin, Xiao Yan, Jiawei Jiang (arXiv:2610.38366), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.