Pith. sign in

REVIEW 5 major objections 5 minor 34 references

RTQA : Recursive Thinking for Complex Temporal Knowledge Graph Question Answering with Large Language Models

T0 review · 5 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A training-free recursive decomposition-and-aggregation framework raises Hits@1 on complex temporal knowledge graph QA, with the biggest gains on Multiple and Complex question categories.

desk verdict A training-free recursive decomposition framework for TKGQA that shows promising ablations, but the headline SOTA gains rest on a possibly mismatched LLM baseline—needs a matched-LLM comparison before believing the numbers. read the letter →

arxiv 2509.03995 v1 pith:JW37OIQF submitted 2025-09-04 cs.CL cs.AI

Zhaoyan Gong , Juan Li , Zhiqiang Liu , Lei Liang , Huajun Chen , Wen Zhang This is my paper · ORCID
classification cs.CLcs.AI
keywords temporalknowledgegraphquestionansweringlargelanguagemodelsdecompositionrecursivereasoningansweraggregationretrieval-augmentedgenerationconstraintsMultiTQandTimelineKGQA
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that complex temporal questions—those with implicit temporal references, compound constraints such as “before” and “last,” and multi-hop dependencies—can be answered accurately without training a model. The proposed RTQA framework recursively decomposes each question into sub-questions, solves them bottom-up with an LLM grounded in retrieved temporal facts, and aggregates multiple answer paths to keep one wrong sub-answer from poisoning the final result. If true, this matters because prior TKGQA methods either handle only simple questions or decompose in one round, and the reported gains appear exactly where those methods fail: MultiTQ “Multiple” Hits@1 rises from 0.335 to 0.424, and TimelineKGQA “Complex” Hits@1 rises from 0.009 to 0.135. A reader should care because the approach is training-free and plug-and-play, so any capable LLM can be dropped into the solver stage.

What carries the argument

The load-bearing object is the temporal question decomposition tree. A root question is split into ordered sub-questions; placeholders such as #1 refer to answers of earlier siblings, so implicit constraints become explicit. The Recursive Solver traverses the tree bottom-up in post-order, replacing placeholders with concrete timestamps or entities as it goes. At each non-leaf node, the Answer Aggregator fuses two candidates—IR_answer from direct retrieval-plus-reasoning and child_answer from the sub-answers—using a strict fallback rule, which is what prevents error propagation.

What would settle it

Take the subset of MultiTQ “Multiple” questions whose gold supporting fact is not among the top-50 retrieved facts. If RTQA answers a non-negligible fraction correctly, the recursive framework can reason past retrieval misses; if it answers near zero, the framework’s reported gains are bounded by retrieval recall, not by decomposition or aggregation.

Watch

Extended reading notes

Core claim

RTQA’s central claim is that complex temporal questions can be answered accurately without training by turning each question into a decomposition tree, solving the tree from the leaves upward with an LLM grounded in retrieved temporal-knowledge-graph facts, and at each non-leaf node fusing two independently derived candidates: IR_answer, obtained by direct retrieval plus LLM reasoning, and child_answer, obtained by summarizing the sub-answers. The key idea is that implicit constraints such as “before Kuwait” or “last” become explicit sub-questions whose answers fill placeholders in parent questions, while the aggregator’s fallback rule stops a single wrong sub-answer from propagating to the

Load-bearing premise

The load-bearing premise is that the retrieval step returns the temporal facts that support each question; if the correct fact is missing from the top-50 retrieved context, the LLM has no evidence to reason from and the framework cannot recover (ablation drops Hits@1 from 0.765 to 0.070).

Editorial extensions

If this is right

  • RTQA raises MultiTQ Hits@1 overall from 0.728 (TimeR4) to 0.765, with the Multiple-question category jumping from 0.335 to 0.424.
  • On TimelineKGQA, RTQA raises Complex-question Hits@1 from 0.009 to 0.135 and Medium from 0.092 to 0.218, while Simple drops slightly from 0.704 to 0.608.
  • Removing the decomposer cuts Multiple-question Hits@1 by about half (0.424 to 0.214), showing recursive decomposition is the main driver on complex questions.
  • Removing the answer aggregator reduces MultiTQ Hits@1 by 19.6% on Multiple questions, evidence that multi-path aggregation absorbs single-subquestion errors.
  • Removing fact retrieval collapses overall Hits@1 to 0.070, so external TKG grounding is a hard requirement for the framework.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same recursive decomposition-plus-fallback aggregation pattern should transfer to static multi-hop KGQA and to temporal QA over text, since those settings share the same failure mode of implicit constraints and propagating sub-errors.
  • Because Recall@50 is only 71.78%, retrieval, not LLM reasoning, is likely the current capacity bottleneck; a better retriever or a retrieval-verification loop should yield larger gains than stronger reasoning prompts.
  • The decomposer and solver are decoupled (the paper fixes the decomposer while swapping solver LLMs), so the framework invites a cheap ablation: test whether a stronger decomposer with a weaker solver outperforms the reverse, which would point future tuning at decomposition quality rather than reasoning size.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 5 minor

Summary. The paper introduces RTQA, a training-free framework for temporal knowledge graph question answering (TKGQA) that recursively decomposes complex temporal questions into sub-questions, solves them bottom-up with an LLM grounded in retrieved TKG facts, and aggregates answers from multiple paths to mitigate error propagation. The method is evaluated on MultiTQ and TimelineKGQA, reporting Hits@1 improvements over existing baselines, especially in 'Multiple' and 'Complex' question categories. The main claimed contribution is a plug-and-play recursive decomposition and aggregation scheme that improves complex temporal reasoning without retraining. The paper includes ablations, generalizability tests across LLMs, efficiency measurements, and a case study.

Significance. If the empirical claims hold, RTQA offers a practical, training-free approach to a challenging problem, with clear modular design and released code. The decomposition tree and multi-path aggregation are intuitive, and the ablation studies (e.g., w/o decomposer, w/o multi-answer) provide useful evidence about which components matter. The paper also honestly acknowledges its dependence on the retriever and LLM capability. However, the headline claim of 'outperforming state-of-the-art methods' rests on comparisons whose fairness is not yet established, and the statistical support is thin. The framework itself is plausible and likely valuable, but the current evidence does not fully separate the framework's contribution from the choice of reasoning LLM and baseline configurations.

major comments (5)
  1. [§5.1, Table 1] The central claim that RTQA outperforms TimeR4 is not supported by a matched-LLM comparison. RTQA uses deepseek-v3 for answer reasoning, while TimeR4's results are taken from (Qian et al., 2024) without reporting the LLM backbone used there. Since the ablation 'w/o decomposer' (0.709) is below TimeR4 (0.728), the 0.037 overall Hits@1 margin could partly reflect the stronger reasoning model rather than the recursive framework. Please re-run TimeR4 (and preferably other LLM-based baselines) with the same reasoning LLM, retriever, and context limit as RTQA, and report these matched results.
  2. [§5.4, Figure 4] The 'Generalizability across different LLMs' experiment varies only RTQA's solver LLM; baselines are not re-run with the same models. Thus it cannot control for the LLM confound raised above. The figure also reports results on a randomly sampled 1,000 questions with no variance or confidence intervals, so it is unclear whether differences among LLMs are statistically meaningful. Please include matched-LLM baseline runs on the same sample, and report repeated-run variance or at least a significance test.
  3. [§5.2, Table 2] On TimelineKGQA, RTQA is compared only against a single RAG baseline, which is extremely weak on Complex questions (Hits@1 = 0.009). The abstract and conclusion claim SOTA performance on this benchmark, but with only one, apparently minimal, baseline this claim is unsupported. Please compare against stronger or additional baselines (e.g., other LLM-based TKGQA methods adapted to this benchmark, or a stronger RAG pipeline with the same retriever/LLM as RTQA). Without this, the 1400% 'improvement' on Complex questions cannot be interpreted as a fair comparison.
  4. [§5.3, Table 6] The context-limit analysis reports Hits@1 = 77.8% at n=50, but Table 1 reports overall Hits@1 = 76.5% for RTQA on MultiTQ. The paper does not explain this discrepancy (e.g., whether Table 6 is on a subset, uses a different evaluation setting, or is a typo). Also, the relationship between Hits@1 and Recall@n is not discussed: Hits@1 can exceed Recall@n only if the metric definitions differ, and the reader needs this clarified. This is load-bearing because n=50 is the main hyperparameter setting for the reported performance.
  5. [§5.4, Table 4] The multi-granular time analysis reports large gains over baselines (e.g., RTQA 0.916 vs. MultiQA 0.445 for Equal/Day), but the baseline numbers are taken from prior work without any indication of whether the same evaluation protocol and LLM settings were used. The lack of any statistical significance testing or repeated-run variance is especially problematic here, given the gains are claimed to be 'significant' in the abstract. Please provide at least standard errors or confidence intervals for the main comparisons, or temper the significance language.
minor comments (5)
  1. [Throughout] Typos: 'anather' in Figure 2; 'Sourth' in Figure 3; 'Timer4' in the reference for TimeR4; inconsistent spacing 'MULTI TQ' vs 'MultiTQ'.
  2. [Table 7] The 'Total' row for MultiTQ appears to have a typo: '587,979' is likely '58,979' for the dev set. Please check.
  3. [§4.2] The decomposition prompt examples are described as 'carefully selected from the validation set' with 'manually crafted' sub-question decompositions. This is a standard and acceptable practice, but it should be explicitly noted that the decomposition templates and few-shot examples are tuned on the validation set, and the paper should discuss potential selection bias.
  4. [§5.1] The implementation details indicate temperature 0 for deterministic outputs, but LLM APIs are not fully deterministic; the paper should state whether the reported numbers are from a single run and whether any sampling variance was observed.
  5. [§5.5, Error Analysis] The error analysis mentions five error categories but does not quantify their frequencies. A small table or distribution would make the analysis more useful.

Circularity Check

0 steps flagged · score 2.0 of 10

No load-bearing circularity; only a minor non-load-bearing self-citation.

full rationale

RTQA is a training-free framework: equations (1)-(15) describe prompt construction, recursive solving, and aggregation, with no parameter fitted to the test set. The aggregator is a fixed priority heuristic (Figure 10), and the decomposition few-shot examples come from the validation set, which is standard practice. The only self-citation is Chen (2024) in the Introduction, used for a general statement about the significance of temporal knowledge graphs; it is not load-bearing for any derivation. The choice of context length n=50 in Table 6 is a test-set hyperparameter selection, which is a statistical validity concern rather than a circular step. No equation reduces to its own input, and the reported gains are benchmark comparisons rather than constructions. The paper's acknowledged limitations about retrieval dependence and LLM capability are limitations, not circularity. The score reflects the presence of a minor, non-load-bearing self-citation.

Assumptions & free parameters 2 free parameters · 2 assumptions · 0 invented entities

This is an empirical systems paper, not a derivation. The only free 'parameters' are design choices (top-k, aggregator priority, prompt examples) that are fixed using validation set heuristics. No new theoretical entities are introduced.

free parameters (2)
  • n (number of retrieved facts) = 50
    Chosen by validation performance in Table 6; the paper states 'we observed that setting n=50 achieves the best accuracy'.
  • aggregator priority order = C > B > A (fallback)
    Hand-set priority rules in the aggregator prompt (Appendix C.3, Figure 10) that favor the child/decomposed answer over direct IR answer; no sensitivity analysis reported.
assumptions (2)
  • domain assumption Retrieved TKG facts are sufficient and correct for answering the question
    The framework does not verify retrieved facts; the w/o fact retrieval ablation (Table 3) shows the method fails without them. Stated in Limitations: 'RTQA relies on a robust retriever... Failure to retrieve key information can significantly reduce the reasoning accuracy.'
  • domain assumption LLM can decompose and reason correctly given few-shot examples
    The decomposer and solver are prompted LLMs; the paper notes in Limitations that smaller models may struggle to generate high-quality sub-questions.

how reviews work

0 comments
Cite this review

Pith. "Pith review of RTQA : Recursive Thinking for Complex Temporal Knowledge Graph Question Answering with Large Language Models." pith.science (2026). https://pith.science/paper/JW37OIQF

@misc{pith2026250903995,
  author       = {Pith},
  title        = {Pith review of: RTQA : Recursive Thinking for Complex Temporal Knowledge Graph Question Answering with Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JW37OIQF}},
  note         = {Machine review of arXiv:2509.03995}
}
read the original abstract

Current temporal knowledge graph question answering (TKGQA) methods primarily focus on implicit temporal constraints, lacking the capability of handling more complex temporal queries, and struggle with limited reasoning abilities and error propagation in decomposition frameworks. We propose RTQA, a novel framework to address these challenges by enhancing reasoning over TKGs without requiring training. Following recursive thinking, RTQA recursively decomposes questions into sub-problems, solves them bottom-up using LLMs and TKG knowledge, and employs multi-path answer aggregation to improve fault tolerance. RTQA consists of three core components: the Temporal Question Decomposer, the Recursive Solver, and the Answer Aggregator. Experiments on MultiTQ and TimelineKGQA benchmarks demonstrate significant Hits@1 improvements in "Multiple" and "Complex" categories, outperforming state-of-the-art methods. Our code and data are available at https://github.com/zjukg/RTQA.

Figures

Figures reproduced from arXiv: 2509.03995 by the authors.

Figure 1
Figure 1. Motivation comparison: Prior methods (a– [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Comparison of RTQA and Only-Child strate￾gies. RTQA mitigates error propagation by integrating child_answer with IR_answer, while Only-Child relies solely on child_answer, compounding earlier errors. questions (sub[3], sub[4]) rely on a single answer source, while non-atomic questions (sub[1], sub[2], Root) aggregate multiple sources. For instance, when sub[4] incorrectly outputs “1929,” sub[1]’s IR_answer correctly… view at source ↗
Figure 3
Figure 3. An illustration of the RTQA framework applied to a complex temporal question. The framework consists of three stages: (I) Temporal Question Decomposer, which breaks down the original query into sub-questions with explicit temporal constraints; (II) Recursive Solver, where each sub-question is solved using an LLM and retrieved TKG facts; and (III) Answer Aggregator, which integrates the sub-answers to produce the fin… view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: Hits@1 results with different LLMs. On medium-complexity questions, RTQA scores 0.218 v.s. RAG’s 0.092 (137% improvement); for complex questions, it reaches 0.135 vs. RAG’s 0.009, marking a 1400% gain. These results highlight RTQA’s strong capability in complex tempora…
Figure 5
Figure 5. Figure 5: Case study of RTQA. 5.5 Case Study [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Prompt example of RTQA for Temporal Question Decomposition, the category is [PITH_FULL_IMAGE:figures/full_fig_p015_6.png]
Figure 7
Figure 7. Figure 7: Prompt example of RTQA for Temporal Question Decomposition, the category is [PITH_FULL_IMAGE:figures/full_fig_p016_7.png]
Figure 8
Figure 8. Figure 8: Prompt example of RTQA for Recursive Solver. This prompt utilizes the triples in the TKG retrieved by [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]
Figure 9
Figure 9. Figure 9: Prompt example of RTQA for Recursive Solver. This prompt is mainly used to solve the problem of [PITH_FULL_IMAGE:figures/full_fig_p018_9.png]
Figure 10
Figure 10. Figure 10: Prompt example of RTQA for Answer Aggregator. [PITH_FULL_IMAGE:figures/full_fig_p018_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

34 extracted references · 24 canonical work pages

  1. [1]

    James F. Allen. 1984. Towards a general theory of action and time. Artif. Intell., 23(2):123--154

    work page 1984

  2. [2]

    Amos Azaria, Rina Azoulay, and Shulamit Reches. 2024. https://doi.org/10.1162/dint_a_00235 Chatgpt is a remarkable tool—for experts . Data Intelligence, 6(1):240--296

    doi:10.1162/dint_a_00235 2024

  3. [3]

    Elizabeth Boschee, Jennifer Lautenschlager, Sean O'Brien, Steve Shellman, James Starz, and Michael Ward. 2015. https://doi.org/10.7910/DVN/28075 ICEWS Coded Event Data

    doi:10.7910/dvn/28075 2015

  4. [4]

    Shulin Cao, Jiaxin Shi, Liangming Pan, Lunyiu Nie, Yutong Xiang, Lei Hou, Juanzi Li, Bin He, and Hanwang Zhang. 2022. KQA pro: A dataset with explicit compositional programs for complex question answering over knowledge base. In ACL (1) , pages 6101--6119. Association for Computational Linguistics

    work page 2022

  5. [5]

    Shulin Cao, Jiajie Zhang, Jiaxin Shi, Xin Lv, Zijun Yao, Qi Tian, Lei Hou, and Juanzi Li. 2023. Probabilistic tree-of-thought reasoning for answering knowledge-intensive complex questions. In EMNLP (Findings) , pages 12541--12560. Association for Computational Linguistics

    work page 2023

  6. [6]

    Huajun Chen. 2024. https://doi.org/10.3724/2096-7004.di.2024.0001 Large knowledge model: Perspectives and challenges . Data Intelligence, 6(3):587--620

    arXiv 2024

  7. [7]

    Jianlv Chen, Shitao Xiao, Peitian Zhang, Kun Luo, Defu Lian, and Zheng Liu. 2024 a . BGE m3-embedding: Multi-lingual, multi-functionality, multi-granularity text embeddings through self-knowledge distillation. CoRR, abs/2402.03216

    arXiv 2024

  8. [8]

    Zhuo Chen, Zhao Zhang, Zixuan Li, Fei Wang, Yutao Zeng, Xiaolong Jin, and Yongjun Xu. 2024 b . Self-improvement programming for temporal knowledge graph question answering. In LREC/COLING , pages 14579--14594. ELRA and ICCL

    work page 2024

Show all 34 references
  1. [9]

    Ziyang Chen, Dongfang Li, Xiang Zhao, Baotian Hu, and Min Zhang. 2024 c . Temporal knowledge question answering via abstract reasoning induction. In ACL (1) , pages 4872--4889. Association for Computational Linguistics

    2024

  2. [10]

    Ziyang Chen, Jinzhi Liao, and Xiang Zhao. 2023. Multi-granularity temporal question answering over knowledge graphs. In ACL (1) , pages 11378--11392. Association for Computational Linguistics

    2023

  3. [11]

    Ziyang Chen, Xiang Zhao, Jinzhi Liao, Xinyi Li, and Evangelos Kanoulas. 2022. Temporal knowledge graph question answering via subgraph reasoning. Knowl. Based Syst., 251:109134

    2022

  4. [12]

    Jacob Devlin, Ming - Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT (1) , pages 4171--4186. Association for Computational Linguistics

    2019

  5. [13]

    Wentao Ding, Hao Chen, Huayu Li, and Yuzhong Qu. 2022. Semantic framework based query generation for temporal question answering over knowledge graphs. In EMNLP , pages 1867--1877. Association for Computational Linguistics

    2022

  6. [14]

    Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre - Emmanuel Mazar \' e , Maria Lomeli, Lucas Hosseini, and Herv \' e J \' e gou. 2024. The faiss library. CoRR, abs/2401.08281

    2024 arXiv

  7. [15]

    Yifu Gao, Linbo Qiao, Zhigang Kan, Zhihua Wen, Yongquan He, and Dongsheng Li. 2024. Two-stage generative question answering on temporal knowledge graph using large language models. In ACL (Findings) , pages 6719--6734. Association for Computational Linguistics

    2024

  8. [16]

    Alberto Garc \' a - Dur \' a n, Sebastijan Dumancic, and Mathias Niepert. 2018. Learning sequence encoders for temporal knowledge graph completion. In EMNLP , pages 4816--4821. Association for Computational Linguistics

    2018

  9. [17]

    Zhen Jia, Abdalghani Abujabal, Rishiraj Saha Roy, Jannik Str \" o tgen, and Gerhard Weikum. 2018. TEQUILA: temporal question answering over knowledge bases. In CIKM , pages 1807--1810. ACM

    2018

  10. [18]

    Zhen Jia, Philipp Christmann, and Gerhard Weikum. 2024. Faithful temporal question answering over heterogeneous sources. In WWW , pages 2052--2063. ACM

    2024

  11. [19]

    Tushar Khot, Harsh Trivedi, Matthew Finlayson, Yao Fu, Kyle Richardson, Peter Clark, and Ashish Sabharwal. 2023. Decomposed prompting: A modular approach for solving complex tasks. In ICLR . OpenReview.net

    2023

  12. [20]

    Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut. 2020. ALBERT: A lite BERT for self-supervised learning of language representations. In ICLR . OpenReview.net

    2020

  13. [21]

    Yonghao Liu, Di Liang, Mengyu Li, Fausto Giunchiglia, Ximing Li, Sirui Wang, Wei Wu, Lan Huang, Xiaoyue Feng, and Renchu Guan. 2023. Local and global: Temporal question answering via information fusion. In IJCAI , pages 5141--5149. ijcai.org

    2023

  14. [22]

    Ioannidis, Adesoji Adeshina, Phillip Ryan Howard, Tetiana Grinberg, Nagib Hakim, and George Karypis

    Costas Mavromatis, Prasanna Lakkur Subramanyam, Vassilis N. Ioannidis, Adesoji Adeshina, Phillip Ryan Howard, Tetiana Grinberg, Nagib Hakim, and George Karypis. 2022. Tempoqr: Temporal question reasoning over knowledge graphs. In AAAI , pages 5825--5833. AAAI Press

    2022

  15. [23]

    Srivastava, Cezar Pendus, Saswati Dana, Dinesh Garg, Achille Fokoue, G

    Sumit Neelam, Udit Sharma, Hima Karanam, Shajith Ikbal, Pavan Kapanipathi, Ibrahim Abdelaziz, Nandana Mihindukulasooriya, Young - Suk Lee, Santosh K. Srivastava, Cezar Pendus, Saswati Dana, Dinesh Garg, Achille Fokoue, G. P. Shrivatsa Bhargav, Dinesh Khandelwal, Srinivas Ravis...

    2021 arXiv

  16. [24]

    Xinying Qian, Ying Zhang, Yu Zhao, Baohang Zhou, Xuhui Sui, Li Zhang, and Kehui Song. 2024. Timer4 : Time-aware retrieval-augmented large language models for temporal knowledge graph question answering. In EMNLP , pages 6942--6952. Association for Computational Linguistics

    2024

  17. [25]

    Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. 2019. Distilbert, a distilled version of BERT: smaller, faster, cheaper and lighter. CoRR, abs/1910.01108

    2019 arXiv

  18. [26]

    Talukdar

    Apoorv Saxena, Soumen Chakrabarti, and Partha P. Talukdar. 2021. Question answering over temporal knowledge graphs. In ACL/IJCNLP (1) , pages 6663--6676. Association for Computational Linguistics

    2021

  19. [27]

    Talukdar

    Apoorv Saxena, Aditay Tripathi, and Partha P. Talukdar. 2020. Improving multi-hop question answering over knowledge graphs using knowledge base embeddings. In ACL , pages 4498--4507. Association for Computational Linguistics

    2020

  20. [28]

    Talukdar, and Soumen Chakrabarti

    Aditya Sharma, Apoorv Saxena, Chitrank Gupta, Seyed Mehran Kazemi, Partha P. Talukdar, and Soumen Chakrabarti. 2023. Twirgcn: Temporally weighted graph convolution for question answering over temporal knowledge graphs. In EACL , pages 2041--2052. Association for Computational ...

    2023

  21. [29]

    Qiang Sun, Sirui Li, Du Huynh, Mark Reynolds, and Wei Liu. 2025. Timelinekgqa: A comprehensive question-answer pair generator for temporal knowledge graphs. CoRR, abs/2501.04343

    2025 arXiv

  22. [30]

    Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, Dan Bikel, Lukas Blecher, Cristian Canton - Ferrer, Moya Chen, Guillem Cucurull, David Esiobu, Jude Fernandes, Jeremy Fu,...

    2023 arXiv

  23. [31]

    Harsh Trivedi, Niranjan Balasubramanian, Tushar Khot, and Ashish Sabharwal. 2022. Musique: Multihop questions via single-hop question composition. Trans. Assoc. Comput. Linguistics, 10:539--554

    2022

  24. [32]

    Suifeng Zhao, Tong Zhou, Zhuoran Jin, Hongbang Yuan, Yubo Chen, Kang Liu, and Sujian Li. 2024. https://doi.org/10.3724/2096-7004.di.2024.0035 Awecita: Generating answer with appropriate and well-grained citations using llms . Data Intelligence, 6(4):1134--1157

    2024

  25. [33]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  26. [34]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.