Time is Not a Label: Continuous Phase Rotation for Temporal Knowledge Graphs and Agentic Memory Weixian Waylon Li* University of Edinburgh
Jiaxin Zhang LIGHTSPEED
Xianan Jim Yang University of St Andrews
Tiejun Ma† University of Edinburgh
Yiwen Guo† Independent Researcher
arXiv:2604.11544v1 [cs.CL] 13 Apr 2026
Abstract
2025; Huang et al., 2026; Jiang et al., 2026), providing unbounded, structured, and verifiable memory that decouples storage from the LLM. However, a fundamental challenge remains: most graph-based systems model time as discrete metadata, a timestamp column that cannot encode whether a relation is permanent or transient. The real world is dynamic (Cai et al., 2023): executive boards shift, borders change, and markets fluctuate. When temporal conflicts arise (e.g., “Obama is president” vs. “Biden is president”), current systems resort to three workarounds: (i) destructive overwriting, which erases historical context (Xu et al., 2025; Gutierrez et al., 2024); (ii) LLM arbitration, which requires a language model call at every ingestion step to predict symbolic UPDATE/DELETE commands (Chhikara et al., 2025; Rasmussen et al., 2025; Yan et al., 2025); or (iii) recency sorting, which ranks facts by timestamp to surface the latest version. Each has notable limitations. Destructive overwriting permanently loses historical context. LLM arbitration may suit short-term conversational memory, but becomes infeasible when scaling to long-term memory with millions of facts. Recency sorting, the most common workaround, appears to work until it silently buries static knowledge: a recency-based system ranks the decades-old fact (Obama, born_in, Hawaii) below fresher but irrelevant entries. Disabling recency bias leaves temporal conflicts unresolved, confusing the downstream LLM (Liu et al., 2024). We call this the static-dynamic dilemma: discrete metadata treats all relations identically and cannot resolve temporal conflicts without sacrificing static knowledge. To this end, we introduce RO M EM, a temporal reasoning module for graph-based agentic memory that internalises time as a continuous geometric operator. Rather than building a new memory system, RO M EM provides a drop-in temporal engine for the knowledge graph component: it learns to distinguish static from dynamic
Structured memory representations such as knowledge graphs are central to autonomous agents and other long-lived systems. However, most existing approaches model time as discrete metadata, either sorting by recency (burying old-yet-permanent knowledge), simply overwriting outdated facts, or requiring an expensive LLM call at every ingestion step, leaving them unable to distinguish persistent facts from evolving ones. To address this, we introduce RO M EM, a drop-in temporal knowledge graph module for structured memory systems, applicable to agentic memory and beyond. A pretrained Semantic Speed Gate maps each relation’s text embedding to a volatility score, learning from data that evolving relations (e.g., “president of”) should rotate fast while persistent ones (e.g., “born in”) should remain stable. Combined with continuous phase rotation, this enables geometric shadowing: obsolete facts are rotated out of phase in complex vector space, so temporally correct facts naturally outrank contradictions without deletion. On temporal knowledge graph completion, RO M EM achieves state-of-the-art results on ICEWS0515 (72.6 MRR). Applied to agentic memory, it delivers 2∼3× MRR and answer accuracy on temporal reasoning (MultiTQ), dominates hybrid benchmark (LoCoMo), preserves static memory with zero degradation (DMR-MSC), and generalises zero-shot to unseen financial domains (FinTMMBench).
1
Introduction
Structured memory representations such as knowledge graphs have become widely adopted as the long-term memory substrate for agentic systems (Pan et al., 2024b; Chhikara et al., 2025; Gutierrez et al., 2024; Gutiérrez et al., 2025; Rasmussen et al., * This work was done during an internship of Weixian Waylon Li at LIGHTSPEED (UK). † Corresponding authors.
1
relations zero-shot and resolves conflicts through geometry rather than database operations. We achieve this through two mechanisms: (1) Continuous Geometric Shadowing, which models time as a functional phase shift in complex vector space, rotating dynamic facts out of alignment as they become obsolete while keeping static facts permanently locked in phase; and (2) a Semantic Speed Gate that estimates relational volatility from text embeddings, outputting a per-relation scalar αr ∈ (0, 1) that controls rotation speed, so static relations (αr ≈ 0) remain stable while dynamic ones (αr ≈ 1) rotate to shadow obsolete facts. The memory remains strictly append-only, yet the LLM receives a clean, unambiguous context window driven entirely by geometric proximity. 1.0
2
0.857
0.856
0.862
0.726
0.6 0.4
0.366
0.337
0.2 0.0 MRR
LLM@5
MultiTQ
Zep Mem0
Temporal
Avg
LoCoMo
HippoRAG A-Mem
MRR
Related Work
Agentic Memory Paradigms. Graph-based memory is widely adopted for long-term agent knowledge, with frameworks such as Mem0 (Chhikara et al., 2025), HippoRAG (Gutierrez et al., 2024; Gutiérrez et al., 2025), Zep (Rasmussen et al., 2025), DialogGSR (Park et al., 2024), LicoMemory (Huang et al., 2026), and DescGraph (Hu et al., 2026a) offering scalable, controllable retrieval. Parametric approaches (Yao et al., 2024; Zhang et al., 2025a) require costly retraining and offer less transparent retrieval (Zhang et al., 2025b; Hu et al., 2026b). Context engineering strategies, including compression (Ye et al., 2025), dynamic context management (Yu et al., 2025; Zhou et al., 2025b; Yan et al., 2025; Salama et al., 2025), and reflective evolution (Liang et al., 2024; Zhou et al., 2025a), are typically limited to short-term conversational state.
LLM: GPT-5-mini | Emb: text-embedding-3-small
0.8
Performance
hybrid tasks (LoCoMo), preserves static memory (DMR-MSC), and generalises zero-shot to unseen financial domains (FinTMMBench).
LLM@5
DMR-MSC
Temporal Gap in Memory. Existing memory systems lack a native mechanism for managing changing facts Most treat memory as a static snapshot and resort to three workarounds: (i) destructive overwriting that permanently erases historical context (Xu et al., 2025; Gutierrez et al., 2024; Yu et al., 2025); (ii) LLM-driven arbitration that requires additional language model calls at every ingestion step to predict UPDATE or DELETE actions (Chhikara et al., 2025; Rasmussen et al., 2025; Yan et al., 2025), adding significant latency; or (iii) recency-based metadata sorting, which inadvertently buries old-yet-permanent facts (Jiang et al., 2026). Notably, none of these approaches distinguish relational volatility: they apply the same temporal policy to permanent facts (“born in”) and evolving ones (“president of”).
LocoMemory RoMem (Ours)
Figure 1: Performance Overview.
Our main contributions are as follows: • We formalise the static-dynamic dilemma in graph-based agentic memory, showing that discrete timestamp metadata treats all relations identically, preventing temporal conflict resolution without sacrificing static knowledge. • We formulate temporal conflict resolution as continuous geometric shadowing in complex vector space, replacing destructive database updates and per-ingestion LLM calls with an append-only architecture. • We introduce a Semantic Speed Gate that addresses this dilemma by learning relational volatility from text embeddings, generalising zero-shot to unseen relations and domains without manual annotation.
Discrete vs. Continuous Temporal Operators. TKG embedding methods such as RotatE (Sun et al., 2019a), TeRo (Xu et al., 2020), and ChronoR (Sadeghian et al., 2021a) model time as geometric operators but rely on discrete look-up tables, causing two failures: granularity rigidity: the model must predefine a fixed temporal resolution (e.g., hour, day, etc.) to serve as dictionary keys and cannot be dynamically adjusted during training; and generalisation failure, where the model
• We demonstrate that RO M EM achieves SOTA temporal knowledge graph completion on ICEWS05-15 (72.6 MRR) and, applied to agentic memory, delivers 2∼3× MRR and accuracy on temporal reasoning (MultiTQ), dominates 2
cannot interpolate between observed timestamps (e.g., inferring Sep 22nd from Sep 21st and 23rd) because the embedding space lacks a continuous function to bridge the gap.
3
Our central idea is to model time as a continuous geometric rotation, aligning with evidence from cognitive neuroscience that the mammalian hippocampus encodes time as continuous geometric trajectories rather than discrete timestamps (Eichenbaum, 2014; Howard et al., 2014). Consider a “clock hand” analogy: the entity embedding for “Donald Trump” at τ = 2025 is rotated to a phase angle aligned with the “President” relation (pointing to 12 o’clock). As time flows to τ = 2010, the vector continuously rotates away from this alignment, reducing the retrieval score for “Donald Trump” while simultaneously aligning with “Barack Obama”. The most temporally relevant fact naturally shadows obsolete ones through geometric proximity, without deletion. Crucially, the Semantic Speed Gate (§3.4) controls this rotation per-relation: static facts do not rotate (and therefore are never buried by recency), while dynamic facts rotate rapidly (resolving temporal conflicts geometrically). Beyond the metadata-based approach, this design also overcomes two limitations of prior temporal embedding methods. First, additive models (e.g., T-TransE (Leblay and Chekol, 2018), HyTE (Dasgupta et al., 2018)) treat time as a linear bias added to structural embeddings. This suffers from additive decoupling: a strong structural affinity (e.g., for popular entities) can overpower the temporal penalty so that anachronistic facts are retrieved based on popularity. Our multiplicative rotation ensures that even highly popular entities are strictly shadowed when their phase does not align, enforcing hard temporal constraints. Second, discrete rotation models (e.g., ChronoR (Sadeghian et al., 2021a), TeRo (Xu et al., 2020)) learn a separate embedding vector τ t for every observed timestamp. Lacking a continuous functional bridge, this design leaves blind spots between observed timestamps. Our functional definition θ(τ ) resolves this by treating time as a continuous geometric variable. The rotational trajectory naturally spans the gaps between historical anchors, mathematically guaranteeing the zero-shot temporal interpolation of any unobserved date (proof in Appendix F.4).
Methodology: RO M EM
RO M EM (Figure 2) internalises temporal conflict resolution as a geometric physical law within the knowledge graph embedding space, replacing discrete memory management with continuous phase rotation. The architecture is strictly append-only: contradictions co-exist in memory and are resolved at query time through geometric shadowing, where the temporally aligned fact naturally outranks obsolete ones via phase proximity. Because time is a continuous function rather than a discrete index, the system natively supports historical retrieval and zero-shot evaluation of unseen dates. 3.1
Problem Setting and Memory Design
We process a stream of textual episodes {di }N i=1 to answer queries q. Each episode yields relational facts via temporal Open Information Extraction (OpenIE): f = (h, r, t) where h, t ∈ E, r ∈ R, with a valid time thappen (f ) extracted from text and an observation time tobs (f ) at ingestion. If no valid time presents, thappen remains unknown. We maintain an append-only memory state M where contradictions co-exist: m = (f, thappen (f ), tobs (f ), src), where src ∈ {di }N i=1 . We store dense embeddings for passages and entities using a text encoder ϕ(·) and build a heterogeneous graph G = (V, E) induced by facts. Extraction prompts are provided in Appendix B. 3.2
Core Insight: Why Geometry Solves Temporal Conflicts
The most straightforward approach to temporal memory is to store a timestamp with each fact and sort by recency at retrieval time. However, as discussed in §1, this metadata-based approach faces the static–dynamic dilemma: it treats all relations identically, unable to distinguish “born in” (permanent) from “president of” (changes). To resolve this dilemma, we employ a Temporal Knowledge Graph Embedding (TKGE) that internalises time as a continuous geometric operator rather than a discrete metadata field. RO M EM exploits the inductive power of TKG representational learning (Cai et al., 2023) to resolve temporal conflicts natively in vector space.
3.3
Functional Rotation Mechanism
We embed entities and relations in R2d , interpreted as complex vectors in Cd . A scalar time τ acts as a rotation operator in the unitary group U (1)d via the operator Rot(x, θ), which applies an element-wise phase shift x ⊙ eiθ . We define the relation-specific 3
Figure 2: Overview of the RO M EM Architecture. The framework consists of four stages: (A) Functional Rotation (§3.3) applies geometric phase shifts to obsolete facts; (B) Semantic Speed Gate (§3.4) determines relational volatility from text embeddings; (C) Two-Phase Training (§3.5) pretrains the gate and learns the temporal spectrum; (D) Inference-Time Retrieval (§3.6) resolves contradictions via geometric shadowing.
rotation angle as: θ r (τ ) = s · αr · τ · ω,
Since unitary rotation preserves the vector modulus and only shifts the phase, an invalid timestamp rotates the fact out of alignment rather than merely penalising its magnitude. The efficient 1-vs-N retrieval reformulation and a simplified DistMult variant are detailed in Appendix A.
(1)
where s ∈ R+ is a global time scale parameter. Although initialised with a day-level prior (s0 = 1/86400), s is fully learnable and automatically adapts to the native temporal density of the target dataset during training. αr ∈ (0, 1) is the semantic speed gate (§3.4), τ is the continuous timestamp, and ω ∈ Rkd is a learnable inverse frequency vector defined by ωi = b−i/(kd) (with learnable base b initialised at 10,000). We build upon the multi-component bilinear architecture of ChronoR (Sadeghian et al., 2021a), replacing its discrete timestamp lookup with our functional time definition. Each entity has k components in Cd , with relation embeddings wr , ŵr ∈ Rk×2d for forward and inverse semantics respectively. The scoring function is: vrc (e, τ ) = Rot(ec , θ r (τ ))
(2)
ṽrc (e, τ ) = vrc (e, τ ) ⊙ wrc ⊙ ŵrc
(3)
3.4
Semantic Speed Gate
A fundamental challenge in applying KGE to OpenIE is relational diversity: OpenIE yields thousands of surface forms (e.g., “married to”, “wedded to”, “spouse of”) for identical relations. Methods that learn a fixed parameter per string cannot generalise across linguistic variations. Moreover, relations have distinct temporal natures: “born in” is permanent while “visiting” is ephemeral. We introduce a Semantic Speed Gate that derives rotation velocity from the relation’s text embedding ϕ(r): αr = σ MLP(ϕ(r)) ∈ (0, 1). This achieves zero-shot temporal transfer: if the model learns that “married” implies stability (α ≈ 0), it automatically stabilises unseen relations like “wedded” because their embeddings lie close in semantic space. The model is not told which relations are timeinvariant; it learns this from structural signals. For dynamic relations where the tail entity changes over time (e.g., president_of), the model must rotate to separate competing facts, driving αr → 1.
k X skge (h, r, t) | τ = ṽrc (eh , τ ), vrc (et , τ ) c=1
(4) 4
For static relations (e.g., born_in), no competing facts exist, so αr → 0. This functions as a “temporal clutch”: static facts (αr → 0) are permanently locked in alignment, while dynamic facts (αr → 1) rotate to shadow obsolete contradictions. 3.5
3.6
Geometric Shadowing. The shadowing effect is a direct consequence of continuous functional modelling. The scoring function skge depends on geometric alignment modulated by the phase difference ∆θ ∝ |τq − thappen |. When querying for current information (τq ≈ τnow ), the most recent fact has minimal phase difference and maximal alignment, while obsolete facts are rotated out of phase. Thus, the new fact naturally shadows the old one without explicit deletion. Similarly, setting τq to a past date restores the historical fact’s alignment while rotating modern facts out of focus. A formal proof regarding this is given in Appendix F, and a concrete scoring trace illustrating the mechanism on real ICEWS05-15 facts is provided in Appendix G.
Two-Phase Training
A central design challenge is decoupling the semantic gate αr from the global time spectrum (s, ω). Joint training on a single dataset causes two failure modes: (i) sparse datasets lack sufficient competing facts to provide a learning signal for αr , causing gate collapse; and (ii) temporal discrimination objectives (Equation (7)) treat alternative timestamps as negative samples, which incorrectly penalises the infinite validity of static relations and forces αr away from the desired zero state. We address these issues with a two-phase training procedure since αr depends exclusively on relation text embeddings.
Dual-Stream Retrieval. We build upon HippoRAG’s (Gutiérrez et al., 2025) retrieval pipeline, which computes a semantic score Ssem by combining dense passage similarity with Personalised PageRank over the knowledge graph. We then apply the TKGE scoring function Skge = skge ((h, r, t) | τ ) from §3.3 as a temporal re-ranker. To prevent “right time, wrong topic” boosts, we use multiplicative gating with strength αg ≥ 0: Sfinal = Ssem · (1 + αg · Skge ), so temporal signals only amplify facts that are already semantically plausible.
Phase 1: Offline Gate Pretraining. We construct a self-supervised dataset of temporal transition observations from ICEWS05-15 (GarcíaDurán et al., 2018). For each relational slot (h, r), we record whether the counterpart entity changed between consecutive timestamps, filtering nonfunctional slots whose ratio of unique counterparts to observations exceeds a threshold. The gate MLP is trained with a rotation-based BCE objective: θi = αri · λ · ∆ti ,
pchange (θi ) = 1 − e−θi , (5)
Lgate = BCE(yi , pchange (θi ))
(6)
Query-Time Modes. We infer query time and intent to support three retrieval modes: (1) Explicit Time (τq present), which scores candidates at a specific timestamp to strictly enforce temporal validity; (2) Time-Seeking (e.g., “When did X happen?”), which evaluates each candidate against its own stored thappen to verify internal validity without an external τq ; and (3) Time-Agnostic, which defaults to τnow , leveraging geometric shadowing to naturally prioritise fresher facts. This design ensures the memory remains append-only while robustly supporting ordering queries, historical retrieval, and general open-domain QA.
where ∆ti is the time gap between adjacent observations, yi ∈ {0, 1} indicates entity change. After pretraining, only the MLP weights are retained. Phase 2: Online Spectrum Learning. We load the pretrained gate and freeze αr . The online objective L = Ltriple + λt Ltime + Lreg learns the global spectrum (s, ω) and entity/relation embeddings on the target dataset. The structural loss Ltriple uses 1-vs-all cross-entropy scoring, while the time contrastive loss Ltime employs a listwise objective: Ltime = −
J X
Inference-Time Retrieval
p∗j log pj ,
4
j=0
pj = softmax([s(f |τ ), s(f |τ̃1 ), . . . , s(f |τ̃J )])j (7)
Experiments
We evaluate RO M EM through three research questions: (RQ1) Does the transition from discrete timestamp projections to functional temporal modelling maintain or improve performance on standard TKGE benchmarks? (§4.2); (RQ2) Can RO M EM outperform existing agentic memory base-
where p∗j uses a Gaussian kernel to softly prefer timestamps close to the validity center. Detailed loss formulations, regularisation, and negative sampling strategies are provided in Appendix A. 5
Table 1: Results on ICEWS05-15. Baseline results are taken from Li et al. (2025) and Shen et al. (2025). Best results are in bold. Green cells indicate results where RO M EM improves over its backbones (DistMult and ChronoR).
lines on temporal reasoning tasks while maintaining robustness on non-temporal retrieval? (§4.3); and (RQ3) Can RO M EM generalise to unseen domain-specific relations? (§4.4).
Method
MRR
Hit@1
Hit@3
Hit@10
45.6 51.3 66.5 68.6 68.8 69.2
33.7 39.2 58.3 60.7 60.8 61.3
57.8 71.6 73.5 74.0 74.5
69.1 74.8 81.1 83.1 83.5 83.7
58.6 68.4 63.3 68.3 69.2 69.4
46.9 61.1 52.9 60.4 61.2 61.4
66.8 73.0 70.9 73.2 74.3 74.7
79.5 82.1 81.3 82.9 83.7 84.1
62.1 72.6
54.2 66.8
66.3 75.9
77.2 83.7
Non-Rotation Based
4.1
Experimental Setup
DistMult (2015) DE-SimplE (2020) TComplEx (2020) TLT-KGE (2022) HGE (2024a) TimeGate (2025)
Datasets. We evaluate on a diverse set of benchmarks categorised by our research questions. For RQ1, we use ICEWS05-15 (García-Durán et al., 2018). For RQ2, we stress-test agentic memory across a three-tier spectrum of temporal complexity: (1) Heavy Temporal: MultiTQ (Chen et al., 2023) focuses exclusively on complex temporal reasoning and conflict resolution; (2) Hybrid: LoCoMo (Maharana et al., 2024) evaluates a mixture of dynamic temporal updates and general knowledge queries; and (3) Static Benchmark: DMRMSC (Packer et al., 2024) tests purely conversational memory to prove our temporal mechanics do not degrade standard retrieval. Finally, for RQ3, we use FinTMMBench (Zhu et al., 2025). Full dataset statistics are provided in Appendix C.
Rotation Based TeRo (2020) ChronoR (2021a) RotateQVS (2022) TeAST (2023) TCompoundE (2024) 3DG-TE (2025) RO M EM (Ours) RO M EM-DistMult RO M EM-ChronoR
† We use k = 3 for (RO M EM-)ChronoR, following Sadeghian et al. (2021a). k is the rotation dimensionality defined therein.
4.2
Verification of Functional Temporal Modelling (RQ1)
We first verify that the functional time modelling, pretrained semantic speed gate, and the add-on time contrastive loss do not introduce performance deductions compared to our TKGE backbones (DistMult and ChronoR) and other TKGE baselines.
Metrics and Baselines. For retrieval, we report Mean Reciprocal Rank (MRR), Hits@k, and Recall@k. We evaluate answer quality using LLM-as-judge accuracy (Acc@k). For temporal knowledge graph (TKG) completion task on ICEWS05-15, we compare against both nonrotation based such as the vanilla DistMult (Yang et al., 2015), DE-SimplE (Goel et al., 2020), TComplEx (Lacroix et al., 2020), TLT-KGE (Zhang et al., 2022), HGE (Pan et al., 2024a), TimeGate (Shen et al., 2025) and rotation-based methods including TeRo (Xu et al., 2020), ChronoR (Sadeghian et al., 2021a), RotateQVS (Chen et al., 2022), TeAST (Li et al., 2023) ,TCompoundE (Ying et al., 2024), and 3DG-TE (Li et al., 2025). For agentic memory benchmarks, we compare against recent graphbased agentic memory systems, including Mem0 (Chhikara et al., 2025), Zep (Rasmussen et al., 2025), LicoMemory (Huang et al., 2026) and HippoRAG (Gutierrez et al., 2024; Gutiérrez et al., 2025), as well as a widely used non-graph method, A-Mem (Xu et al., 2025).
As shown in Table 1, RO M EM-ChronoR achieves an MRR of 72.6, outperforming the vanilla ChronoR (68.4) on ICEWS05-15. Similarly, our DistMult-based variant, RO M EM-DistMult, shows a substantial performance improvement (62.1 MRR) compared to the static DistMult baseline (45.6 MRR). Notably, RO M EM-ChronoR achieves state-of-the-art performance, reaching 72.6 MRR and 66.8 Hit@1, while remaining highly competitive under looser metrics, with 83.7 Hit@10 compared with 3DG-TE’s 84.1. This confirms that our three core modifications, the continuous functional operator θ(τ ), the pretrained semantic speed gate αr , and the additional time contrastive loss Ltime , successfully preserve, and even enhance, the representational power of the original backbone on standard triple completion tasks. This verification ensures that our temporal modelling component serves as a robust foundation for memory management without sacrificing baseline TKGE accuracy.
Detailed metric definitions, answer verification procedures, implementation configurations, and TKGE hyperparameters are provided in Appendices D, E.1, and E.2, respectively. 6
4.3
Performance on Episodic and Temporal Memory Tasks (RQ2)
A-Mem achieves competitive Single Hop (0.740) and Temporal Reasoning (0.691) scores, demonstrating that non-graph methods can perform well on conversational benchmarks; however, its overall average (0.825) remains below RO M EM. Although highly competitive baselines like Zep edge out marginal wins in Multi-Hop retrieval, RO M EM achieves the highest overall average (0.857). This confirms our Semantic Speed Gate correctly isolates dynamic facts from static ones, allowing temporal rotation to assist open-domain queries without destroying the underlying graph topology.
To answer RQ2, we evaluate whether RO M EM can resolve complex temporal conflicts in agentic memory without degrading foundational, non-temporal retrieval capabilities. The results across MultiTQ (Table 2a), LoCoMo (Table 2b), and DMR-MSC (Table 2c) demonstrate a structural advantage over existing memory systems. We evaluate all agentic memory methods under two implementation configurations: a closed-source API setup (GPT-5-mini with text-embedding-3-small) and an open-source setup (LLaMA-3.1-70B with BGE-M3) to serve as a robustness check.
Preservation of General Memory (DMR-MSC). To definitively prove that our temporal mechanics do not compromise general, non-temporal memory, we evaluate on the DMR-MSC benchmark. This dataset tests purely conversational and static memory retrieval where time is largely irrelevant. As shown in Table 2c, RO M EM achieves an MRR of 0.856 and an LLM@5 Accuracy of 0.862 under the GPT-5-mini setup, slightly improving upon the baseline HippoRAG performance of 0.848 and 0.852, respectively. We observe similar gains in the LLaMA-3.1-70B implementation. This result directly validates the Semantic Speed Gate’s role as a temporal clutch: by assigning low αr to static relations, the gate suppresses rotation and preserves standard topological retrieval, precisely the behaviour that naive recency-based approaches would destroy.
Structural Dominance in Temporal Reasoning (MultiTQ). The MultiTQ dataset explicitly isolates a system’s ability to reason over time-varying facts. Here, static baselines suffer a catastrophic failure. As shown in Table 2a, RO M EM demonstrates sheer dominance. Under the GPT-5-mini implementation, we elevate the base HippoRAG MRR from 0.203 to an unprecedented 0.337, and more than triple the downstream LLM@5 Accuracy (from 0.112 to 0.366). This massive delta highlights the exact problem defined in our methodology. All existing baselines including Mem0, Zep, LicoMemory, and HippoRAG, treat memory as a static snapshot, causing contradictory facts to cluster together in the retrieval space and confuse the LLM. By internalising time as a continuous geometric operator, RO M EM seamlessly rotates obsolete facts out of phase. The correct fact geometrically shadows the contradictions, serving the LLM a clean, unambiguous context window.
An instructive observation emerges from the baselines: HippoRAG, which has no explicit memory management mechanism, performs comparably to Mem0, which employs an additional LLM call at every ingestion step for UPDATE/DELETE arbitration. Despite this per-ingestion cost, Mem0’s symbolic memory management provides little benefit for static retrieval, reinforcing our argument that temporal conflict resolution is better handled geometrically within the embedding space rather than through expensive discrete database operations.
Broad Spectrum Robustness (LoCoMo). While MultiTQ proves our temporal superiority, the LoCoMo benchmark tests a wider spectrum of agentic reasoning, including single-hop, multi-hop, and open-domain QA. A common failure mode of temporal models is “catastrophic drifting”, where forcing temporal physics onto a graph degrades standard topological queries. Table 2b proves RO M EM avoids this entirely. We achieve state-of-the-art results in the Temporal Reasoning subtask (boosting HippoRAG’s Recall@10 from 0.645 to 0.726 in the GPT-5-mini setup) while actively improving both Single Hop (0.768) and Open Domain (0.904) performance. Notably,
Conclusion for RQ2. Collectively, these benchmarks conclusively answer RQ2. RO M EM definitively solves temporal conflict resolution for agentic memory, effectively doubling or tripling downstream generation accuracy on time-sensitive queries, while maintaining absolute robustness and competitive edge across standard, non-temporal retrieval tasks.
1
A-Mem is excluded from MultiTQ because it lacks native support for massive structured triple ingestion (∼11K).
7
Table 2: Comprehensive evaluation of RO M EM. (a) MultiTQ: Heavy temporal reasoning. (b) LoCoMo: Hybrid reasoning (Recall@10). (c) DMR-MSC: Static memory preservation. (d) FinTMMBench: Zero-shot domain generalisation. Implementation = LLM for graph construction (named entity recognition and triple extraction) + Embedding model. Best results are in bold. Green cells indicate results where RO M EM improves over its HippoRAG backbone. (a) MultiTQ (RQ2, Heavy Temporal) Method
MRR
Hit@3
Hit@10
(b) LoCoMo (RQ2, Hybrid Tasks)
Acc@5
Acc@10
0.310 0.282 – 0.292 0.348 0.502
0.110 0.122 – 0.114 0.112 0.366
0.118 0.122 – 0.128 0.102 0.392
0.370 0.356 – 0.304 0.354 0.440
0.098 0.120 – 0.114 0.122 0.312
0.116 0.114 – 0.120 0.116 0.338
Method
GPT-5-mini + text-embedding-3-small Zep Mem0 A-Mem1 LicoMem. HippoRAG RO M EM
0.192 0.174 – 0.149 0.203 0.337
0.208 0.190 – 0.160 0.232 0.384
0.217 0.228 – 0.159 0.236 0.316
0.252 0.264 – 0.182 0.266 0.342
Zep Mem0 A-Mem LicoMem. HippoRAG RO M EM
MRR
Hit@1
Zep Mem0 A-Mem LicoMem. HippoRAG RO M EM
0.170 0.847 0.825 0.326 0.848 0.856
0.110 0.766 0.732 0.224 0.768 0.774
Hit@3
Acc@5
Acc@10
Method
4.4
0.333 0.821 0.823 0.202 0.818 0.847
0.232 0.714 0.732 0.138 0.718 0.760
Average
0.557 0.740 0.740 0.727 0.711 0.768
0.861 0.832 0.846 0.856 0.837 0.850
0.553 0.690 0.691 0.661 0.645 0.726
0.770 0.834 0.825 0.816 0.815 0.857
0.831 0.883 0.860 0.848 0.862 0.904
0.180 0.926 0.912 0.372 0.926 0.934
0.394 0.926 0.902 0.228 0.912 0.930
0.557 0.746 0.658 0.605 0.717 0.759
0.861 0.860 0.776 0.768 0.852 0.824
0.831 0.875 0.777 0.725 0.870 0.879
0.553 0.737 0.702 0.584 0.732 0.759
0.770 0.839 0.750 0.703 0.830 0.838
MRR
R@5
R@10
Acc@5
Acc@10
GPT-5-mini + text-embedding-3-small 0.302 0.858 0.848 0.670 0.852 0.862
0.376 0.848 0.856 0.728 0.850 0.858
Zep Mem0 A-Mem LicoMem. HippoRAG RO M EM
Implementation: LLaMA-3.1-70B + BGE-M3 Zep Mem0 A-Mem LicoMem. HippoRAG RO M EM
Temporal Reason
(d) FinTMMBench (RQ3)
GPT-5-mini + text-embedding-3-small Zep Mem0 A-Mem LicoMem. HippoRAG RO M EM
Open Domain
Implementation: LLaMA-3.1-70B + BGE-M3
(c) DMR-MSC (RQ2, Static Memory) Method
Multi Hop
GPT-5-mini + text-embedding-3-small
LLaMA-3.1-70B + BGE-M3 Zep Mem0 A-Mem1 LicoMem. HippoRAG RO M EM
Single Hop
0.384 0.758 0.728 0.258 0.768 0.774
0.703 0.691 0.716 0.488 0.690 0.728
0.644 0.645 0.647 0.480 0.645 0.673
0.759 0.768 0.796 0.609 0.768 0.779
0.480 0.550 0.540 0.480 0.550 0.580
0.520 0.610 0.640 0.590 0.650 0.650
Implementation: LLaMA-3.1-70B + BGE-M3 0.428 0.770 0.738 0.338 0.776 0.786
Zep Mem0 A-Mem LicoMem. HippoRAG RO M EM
Domain Generalisation (RQ3)
0.515 0.718 0.650 0.554 0.724 0.726
0.510 0.647 0.631 0.559 0.680 0.707
0.591 0.765 0.742 0.662 0.766 0.793
0.430 0.570 0.520 0.460 0.610 0.620
0.450 0.610 0.590 0.520 0.610 0.650
(e.g., “held office”), allowing it to modulate phase rotation correctly for unseen domains.
To answer RQ3, we evaluate RO M EM on FinTMMBench to test zero-shot generalisation in highvolatility financial contexts (Li and Ma, 2025; Li et al., 2026). As shown in Table 2d, we achieve a dominant 0.728 MRR and 0.580 LLM@5 Accuracy under GPT-5-mini, outperforming all baselines including A-Mem (0.716 MRR) and HippoRAG (0.690 MRR). It confirms that the Semantic Speed Gate learns universal relational volatility invariants rather than a domain-specific vocabulary. The gate identifies that specialised financial predicates (e.g., “has quarterly revenue”) share semantic signatures with general dynamic relations
5
Conclusion
We identified two limitations in how graph-based memory systems handle time: discrete metadata treats all relations identically, burying permanent knowledge under recency sorting, and existing workarounds (destructive overwriting or peringestion LLM calls) do not scale. RO M EM addresses both by internalising time as continuous phase rotation within the KG embedding space. A pretrained Semantic Speed Gate learns relational volatility zero-shot from text embeddings, preserv8
ing static facts while rotating obsolete ones out of phase, all within an append-only architecture. Empirically, RO M EM achieves state-of-the-art TKGE results and, applied to agentic memory, delivers large gains on temporal reasoning while preserving static knowledge and generalising zero-shot to unseen domains. As a self-contained module with a standard scoring interface, it can serve as a drop-in replacement for the KG component in any graph-based or hierarchical memory system.
Alberto García-Durán, Sebastijan Dumančić, and Mathias Niepert. 2018. Learning sequence encoders for temporal knowledge graph completion. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 4816–4821, Brussels, Belgium. Association for Computational Linguistics. Rishab Goel, Seyed Mehran Kazemi, Marcus Brubaker, and Pascal Poupart. 2020. Diachronic embedding for temporal knowledge graph completion. Proceedings of the AAAI Conference on Artificial Intelligence, 34(04):3988–3995. Bernal Jimenez Gutierrez, Yiheng Shu, Yu Gu, Michihiro Yasunaga, and Yu Su. 2024. Hipporag: Neurobiologically inspired long-term memory for large language models. In Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024.
References Borui Cai, Yong Xiang, Longxiang Gao, He Zhang, Yunfeng Li, and Jianxin Li. 2023. Temporal knowledge graph completion: a survey. In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, IJCAI ’23. Jianlyu Chen, Shitao Xiao, Peitian Zhang, Kun Luo, Defu Lian, and Zheng Liu. 2024. M3embedding: Multi-linguality, multi-functionality, multi-granularity text embeddings through selfknowledge distillation. In Findings of the Association for Computational Linguistics: ACL 2024, pages 2318–2335, Bangkok, Thailand. Association for Computational Linguistics.
Bernal Jiménez Gutiérrez, Yiheng Shu, Weijian Qi, Sizhe Zhou, and Yu Su. 2025. From RAG to memory: Non-parametric continual learning for large language models. In Forty-second International Conference on Machine Learning. Marc W Howard, Christopher J. MacDonald, Zoran Tiganj, Karthik H. Shankar, Qian Du, Michael E. Hasselmo, and Howard Eichenbaum. 2014. A unified mathematical framework for coding time, space, and sequences in the hippocampal region. The Journal of Neuroscience, 34:4692 – 4707.
Kai Chen, Ye Wang, Yitong Li, and Aiping Li. 2022. RotateQVS: Representing temporal information as rotations in quaternion vector space for temporal knowledge graph completion. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 5843–5857, Dublin, Ireland. Association for Computational Linguistics.
Sen Hu, Yuxiang Wei, Jiaxin Ran, Zhiyuan Yao, Xueran Han, Huacan Wang, Ronghao Chen, and Lei Zou. 2026a. Does memory need graphs? a unified framework and empirical analysis for long-term dialog memory. Preprint, arXiv:2601.01280.
Ziyang Chen, Jinzhi Liao, and Xiang Zhao. 2023. Multigranularity temporal question answering over knowledge graphs. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 11378–11392, Toronto, Canada. Association for Computational Linguistics.
Yuyang Hu, Shichun Liu, Yanwei Yue, Guibin Zhang, Boyang Liu, Fangyi Zhu, Jiahang Lin, Honglin Guo, Shihan Dou, Zhiheng Xi, Senjie Jin, Jiejun Tan, Yanbin Yin, Jiongnan Liu, Zeyu Zhang, Zhongxiang Sun, Yutao Zhu, Hao Sun, Boci Peng, and 28 others. 2026b. Memory in the age of ai agents. Preprint, arXiv:2512.13564.
Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. 2025. Mem0: Building production-ready ai agents with scalable long-term memory.
Zhengjun Huang, Zhoujin Tian, Qintian Guo, Fangyuan Zhang, Yingli Zhou, Di Jiang, Zeying Xie, and Xiaofang Zhou. 2026. Licomemory: Lightweight and cognitive agentic memory for efficient long-term reasoning. Preprint, arXiv:2511.01448.
Shib Sankar Dasgupta, Swayambhu Nath Ray, and Partha Talukdar. 2018. HyTE: Hyperplane-based temporally aware knowledge graph embedding. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 2001–2011, Brussels, Belgium. Association for Computational Linguistics.
Dongming Jiang, Yi Li, Guanpeng Li, and Bingzhe Li. 2026. Magma: A multi-graph based agentic memory architecture for ai agents. Preprint, arXiv:2601.03236. Timothée Lacroix, Guillaume Obozinski, and Nicolas Usunier. 2020. Tensor decompositions for temporal knowledge base completion. In International Conference on Learning Representations.
Howard Eichenbaum. 2014. Time cells in the hippocampus: a new dimension for mapping memories. Nature Reviews Neuroscience, 15(11):732–744.
9
Julien Leblay and Melisachew Wudage Chekol. 2018. Deriving validity time in knowledge graph. In Companion Proceedings of the The Web Conference 2018, WWW ’18, page 1771–1776, Republic and Canton of Geneva, CHE. International World Wide Web Conferences Steering Committee.
Shirui Pan, Linhao Luo, Yufei Wang, Chen Chen, Jiapu Wang, and Xindong Wu. 2024b. Unifying large language models and knowledge graphs: A roadmap. IEEE Transactions on Knowledge and Data Engineering, 36(7):3580–3599. Jinyoung Park, Minseok Joo, Joo-Kyung Kim, and Hyunwoo J. Kim. 2024. Generative subgraph retrieval for knowledge graph–grounded dialog generation. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 21167–21182, Miami, Florida, USA. Association for Computational Linguistics.
Jiang Li, Xiangdong Su, and Guanglai Gao. 2023. TeAST: Temporal knowledge graph embedding via archimedean spiral timeline. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 15460–15474, Toronto, Canada. Association for Computational Linguistics.
Preston Rasmussen, Pavlo Paliychuk, Travis Beauvais, Jack Ryan, and Daniel Chalef. 2025. Zep: A temporal knowledge graph architecture for agent memory.
Jiang Li, Xiangdong Su, and Guanglai Gao. 2025. Leveraging 3D Gaussian for temporal knowledge graph embedding. In Findings of the Association for Computational Linguistics: EMNLP 2025, pages 7852–7865, Suzhou, China. Association for Computational Linguistics.
Ali Sadeghian, Mohammadreza Armandpour, Anthony Colas, and Daisy Zhe Wang. 2021a. Chronor: Rotation based temporal knowledge graph embedding. Preprint, arXiv:2103.10379.
Weixian Waylon Li, Hyeonjun Kim, Mihai Cucuringu, and Tiejun Ma. 2026. Can llm-based financial investing strategies outperform the market in long run? Preprint, arXiv:2505.07078.
Ali Sadeghian, Mohammadreza Armandpour, Anthony Colas, and Daisy Zhe Wang. 2021b. Chronor: Rotation based temporal knowledge graph embedding. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 6471–6479.
Weixian Waylon Li and Tiejun Ma. 2025. Learn to rank risky investors: A case study of predicting retail traders’ behaviour and profitability. ACM Trans. Inf. Syst., 44(1).
Rana Salama, Jason Cai, Michelle Yuan, Anna Currey, Monica Sunkara, Yi Zhang, and Yassine Benajiba. 2025. MemInsight: Autonomous memory augmentation for LLM agents. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 33124–33140, Suzhou, China. Association for Computational Linguistics.
Xuechen Liang, Yangfan He, Yinghui Xia, Xinyuan Song, Jianhui Wang, Meiling Tao, Li Sun, Xinhang Yuan, Jiayi Su, Keqin Li, Jiaqi Chen, Jinsong Yang, Siyuan Chen, and Tianyu Shi. 2024. Self-evolving agents with reflective and memory-augmented abilities.
Jinqing Shen, Chengjin Xu, Yingqi Liu, Xuhui Jiang, Jiaming Li, Zhenxin Huang, Jens Lehmann, and Xuesong Chen. 2025. Learning temporal knowledge graphs via time-sensitive graph attention. IEEE Access, 13:178517–178526.
Nelson F. Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. 2024. Lost in the middle: How language models use long contexts. Transactions of the Association for Computational Linguistics, 12:157–173.
Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang. 2019a. Rotate: Knowledge graph embedding by relational rotation in complex space. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net.
Adyasha Maharana, Dong-Ho Lee, Sergey Tulyakov, Mohit Bansal, Francesco Barbieri, and Yuwei Fang. 2024. Evaluating very long-term conversational memory of LLM agents. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 13851– 13870, Bangkok, Thailand. Association for Computational Linguistics.
Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang. 2019b. Rotate: Knowledge graph embedding by relational rotation in complex space. In International Conference on Learning Representations (ICLR).
Meta AI. 2024. Introducing meta llama 3: The most capable openly available llm to date.
Xingyu Tan, Xiaoyang Wang, Qing Liu, Xiwei Xu, Xin Yuan, Liming Zhu, and Wenjie Zhang. 2026. Memotime: Memory-augmented temporal knowledge graph enhanced large language model reasoning. Preprint, arXiv:2510.13614.
Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2024. Memgpt: Towards llms as operating systems. Preprint, arXiv:2310.08560. Jiaxin Pan, Mojtaba Nayyeri, Yinan Li, and Steffen Staab. 2024a. Hge: Embedding temporal knowledge graphs in a product space of heterogeneous geometric subspaces. Proceedings of the AAAI Conference on Artificial Intelligence, 38(8):8913–8920.
Chengjin Xu, Mojtaba Nayyeri, Fouad Alkhoury, Hamed Shariat Yazdi, and Jens Lehmann. 2020. TeRo: A time-aware knowledge graph embedding via temporal rotation. In Proceedings of the 28th
10
Zhaorun Chen, Xiaohan Fu, Jian Xie, Yuxuan Sun, Boyu Gou, Qi Qi, Zihang Meng, Jianwei Yang, Ning Zhang, Xian Li, Ashish Shah, and 11 others. 2025a. Agent learning via early experience. Preprint, arXiv:2510.08558.
International Conference on Computational Linguistics, pages 1583–1593, Barcelona, Spain (Online). International Committee on Computational Linguistics. Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan, and Yongfeng Zhang. 2025. A-mem: Agentic memory for llm agents.
Zeyu Zhang, Quanyu Dai, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2025b. A survey on the memory mechanism of large language model-based agents. ACM Trans. Inf. Syst., 43(6).
Sikuan Yan, Xiufeng Yang, Zuchao Huang, Ercong Nie, Zifeng Ding, Zonggen Li, Xiaowen Ma, Kristian Kersting, Jeff Z. Pan, Hinrich Schütze, Volker Tresp, and Yunpu Ma. 2025. Memory-r1: Enhancing large language model agents to manage and utilize memories via reinforcement learning.
Huichi Zhou, Yihang Chen, Siyuan Guo, Xue Yan, Kin Hei Lee, Zihan Wang, Ka Yiu Lee, Guchun Zhang, Kun Shao, Linyi Yang, and Jun Wang. 2025a. Memento: Fine-tuning llm agents without fine-tuning llms.
Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. 2015. Embedding entities and relations for learning and inference in knowledge bases. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings.
Zijian Zhou, Ao Qu, Zhaoxuan Wu, Sunghwan Kim, Alok Prakash, Daniela Rus, Jinhua Zhao, Bryan Kian Hsiang Low, and Paul Pu Liang. 2025b. Mem1: Learning to synergize memory and reasoning for efficient long-horizon agents.
Weiran Yao, Shelby Heinecke, Juan Carlos Niebles, Zhiwei Liu, Yihao Feng, Le Xue, Rithesh R N, Zeyuan Chen, Jianguo Zhang, Devansh Arpit, Ran Xu, Phil L Mui, Huan Wang, Caiming Xiong, and Silvio Savarese. 2024. Retroformer: Retrospective large language agents with policy gradient optimization. In The Twelfth International Conference on Learning Representations.
Fengbin Zhu, Junfeng Li, Liangming Pan, Wenjie Wang, Fuli Feng, Chao Wang, Huanbo Luan, and Tat-Seng Chua. 2025. Towards temporal-aware multi-modal retrieval augemented generation in finance. In Proceedings of the 33rd ACM International Conference on Multimedia, MM ’25, page 6289–6297, New York, NY, USA. Association for Computing Machinery.
Rui Ye, Zhongwang Zhang, Kuan Li, Huifeng Yin, Zhengwei Tao, Yida Zhao, Liangcai Su, Liwen Zhang, Zile Qiao, Xinyu Wang, Pengjun Xie, Fei Huang, Siheng Chen, Jingren Zhou, and Yong Jiang. 2025. Agentfold: Long-horizon web agents with proactive context management.
A
Scoring, Training, and Gate Formulations
A.1
Scoring Variants
Efficient 1-vs-N Retrieval. In practice, the tracediagonal sum across k components reduces to a flat element-wise product and summation over the k × 2d real dimensions. An important consequence of this structure is the unrotation trick: to score a query (h, r, ?) against all N entities simultaneously, we form q = Rot(eh , θ) ⊙ wr ⊙ ŵr and then unrotate by −θ, yielding a vector in the same space as the raw entity embeddings. A single matrix multiplication Rot(q, −θ) · E⊤ then produces scores for all entities without materialising N separate rotations, enabling efficient 1-vs-all training. A formal proof with complexity analysis is provided in §F.
Rui Ying, Mengting Hu, Jianfeng Wu, Yalan Xie, Xiaoyi Liu, Zhunheng Wang, Ming Jiang, Hang Gao, Linlin Zhang, and Renhong Cheng. 2024. Simple but effective compound geometric operations for temporal knowledge graph completion. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 11074–11086, Bangkok, Thailand. Association for Computational Linguistics. Hongli Yu, Tinghong Chen, Jiangtao Feng, Jiangjie Chen, Weinan Dai, Qiying Yu, Ya-Qin Zhang, WeiYing Ma, Jingjing Liu, Mingxuan Wang, and Hao Zhou. 2025. Memagent: Reshaping long-context llm with multi-conv rl-based memory agent. Fuwei Zhang, Zhao Zhang, Xiang Ao, Fuzhen Zhuang, Yongjun Xu, and Qing He. 2022. Along the time: Timeline-traced embedding for temporal knowledge graph completion. In Proceedings of the 31st ACM International Conference on Information & Knowledge Management, CIKM ’22, page 2529–2538, New York, NY, USA. Association for Computing Machinery.
DistMult Variant. As a simplified variant, setting k=1 and removing the inverse relation table recovers a time-conditioned DistMult (Yang et al., 2015) backbone. This variant uses selfadversarial negative sampling instead of the 1-vsall cross-entropy loss: Ltriple = − log σ(s+ ) − P − − k wk log σ(−sk ), where wk = softmax(sk /T ) are self-adversarial weights (Sun et al., 2019a). For
Kai Zhang, Xiangchao Chen, Bo Liu, Tianci Xue, Zeyi Liao, Zhihan Liu, Xiyao Wang, Yuting Ning,
11
regularisation, we use global L3 on the full embedding tables instead of per-batch N3. A.2
progressively sharpening temporal discrimination. Negative times are sampled preferentially from the same (h, r) slot history when available, with jitter (±0.02 years) and one forced far negative (±365 days). A minimum-gap curriculum decays from 90 to 3 days over 60 epochs to avoid trivially easy negatives early in training.
Training Objectives
Structural Triple Loss. With the ChronoR backbone, we use a 1-vs-all cross-entropy loss exploiting the unrotation trick (§A.1). The unrotated query qt (τ ) = Rot Rot(eh , θ r (τ )) ⊙ wr ⊙ ŵr , −θ r (τ ) lives in the same space as the raw entity embeddings, enabling a single matrix multiplication qt (τ ) · E⊤ to score all entities. Crucially, qt (τ ) remains τ -dependent because the relation weights break the symmetry between the forward and inverse rotations; consequently, the same (h, r) pair produces distinct query vectors at different timestamps, allowing the structural loss alone to learn temporal discrimination: Ltriple = 12 CEtail (qt (τ ) · E⊤ , t) + CEhead (qh (τ ) · E⊤ , h)
A.3
Semantic Speed Gate Pretraining
The semantic speed gate αr = MLP(ϕ(r)) is pretrained on self-supervised transition observations mined from ICEWS05-15 before online TKGE training begins. Stage 1: Transition Mining. We group all temporal triples by (h, r) slot and identify consecutive temporal observations. For each pair of adjacent observations at times ti and ti+1 , we record a binary changed label indicating whether the tail entity changed. Filtering criteria: minimum 3 observations per slot, maximum functional ratio 0.5, and up to 256 pairs per slot.
(8)
where CE is the standard cross-entropy over the full entity vocabulary and qh (τ ) is the symmetric head-prediction query. This loss is computed with the gate αr detached, so gradients update only the entity, relation, and time parameters.
Stage 2: Gate Training. The gate MLP is trained with the rotation-based BCE objective defined in Equation 5 (§3.5), with pchange clamped to avoid numerical overflow. Training uses 100 epochs with learning rate 5 × 10−4 , embedding batch size 64, and class-weighted loss with auto-computed weights. The pretrained checkpoint is loaded and frozen at the start of online TKGE training.
Conflict-Aware Negative Sampling. We enhance both training variants with conflict-aware negative sampling: rather than sampling random entities, we prioritise sampling competing tails from the same (h, r) group when available. This forces the model to discriminate between mutually exclusive facts (e.g., Obama born in Hawaii vs. Kenya) rather than easy negatives.
B
Prompts
B.1
Answer Generation
Answer LLM. All downstream answer generation uses GPT-5.2 with temperature=0 and JSON response format {"answer": "<text>"}. The answer LLM is always routed to the OpenAI API, independent of whether the graph construction LLM is hosted locally via vLLM.
Regularisation. We apply backbone-specific embedding regularisation. For ChronoR, we use perbatch N3 regularisation (fourth-power penalty): Lreg = λr ∥eh ∥44 + ∥wr ∥44 + ∥ŵr ∥44 + ∥et ∥44 /B, where B is the batch size. For the DistMult variant, we use global L3 regularisation on the full embedding tables. Additionally, a gate regularisanon-comp tion term Lgate_reg = αr softly encourages αr → 0 for non-competing relation slots, reinforcing the temporal clutch’s static behaviour where no temporal discrimination is needed.
System prompts. The system prompt varies by benchmark: • MultiTQ, DMR-MSC: “You answer questions using only provided facts.” • LoCoMo: “You answer using only the provided context.”
Time-Contrastive Loss. The listwise timecontrastive loss Ltime (Equation 7 in §3.5) uses a Gaussian target kernel whose width σ follows a cosine curriculum from σstart = 0.5 yr to σend = 0.02 yr over the configured decay epochs (Table 4),
• FinTMMBench: “You are a financial analyst assistant. Use only the provided financial data to answer the question. Be concise and precise.” 12
Box I and Box II show the user prompt templates for MultiTQ and FinTMMBench, respectively.
extraction (Appendix B.2.2), and query-time entity and time extraction (Appendix B.2.3, Appendix B.2.4).
Box I: Answer Generation Prompt (MultiTQ / DMRMSC)
B.2.1 Named Entity Recognition (NER) Box III shows the one-shot NER prompt used to extract entities from each passage during graph construction.
Question: {question} Supporting facts: {bullet_list_of_retrieved_documents}
Box III: Named Entity Recognition Prompt (OneShot)
Provide a concise answer grounded in the facts. Respond with JSON {"answer": "<text>"}.
System: Your task is to extract named entities from the given paragraph. Respond with a JSON list of entities.
Box II: Answer Generation Prompt (FinTMMBench)
Rules: - Only include real-world entities, people, organizations, locations, products, and named events. - Do not include time expressions, dates, durations, or clock times (these are handled separately). - Do not include numbers that are only quantities or durations (e.g., "5 years").
Question: {question} Financial data: {bullet_list_of_retrieved_documents} Provide a short answer grounded in the data. Respond with JSON {"answer": "<text>"}.
LoCoMo answer prompts. For LoCoMo, we follow the original benchmark protocol (Maharana et al., 2024):
One-shot example: User: "Radio City is India's first private FM radio station and was started on 3 July 2001\ldots"
• Categories 1–4 (open-ended): "Based on the above context, write an answer in the form of a short phrase for the following question. Answer with exact words from the context whenever possible. Question: {q} Short answer:"
Assistant: {"named_entities": ["Radio City", "India", "Hindi", "English", " PlanetRadiocity.com"]
B.2.2 Temporal Triple Extraction (OpenIE) Box IV shows the system prompt for NERconditioned triple extraction with temporal metadata. This prompt is paired with three few-shot examples covering standard extraction, relative time resolution, and duration inference.
• Category 5 (adversarial): "Based on the above context, answer the following question. Question: {q} Short answer:"
Box IV: Temporal Triple Extraction System Prompt
• Multiple choice: "Based on the above context, choose the best answer from the options below. Respond with the exact choice text. Question: {q} Choices: {choices} Answer:"
Your task is to construct an RDF graph from the given passages and named entity lists. Respond with JSON where each triple entry also carries timing metadata. Requirements: - Represent each triple as an object with fields: head, relation, tail, text_time, observed_time. - text_time must be a normalized date string in YYYY-MM-DD, or "" if no time is mentioned. - If only a month or year is mentioned, use the first day of that month or year. - If the year is missing, use the year from observed_time.
All LoCoMo responses are appended with: Respond with JSON {"answer": "<text>"}. B.2
Information Extraction
RO M EM uses three LLM-based extraction stages during knowledge graph construction: named entity recognition (Appendix B.2.1), temporal triple 13
Given the query, output the time constraint, temporal ordering intent, and whether the query asks for a time. Return exactly one line in this format: time=YYYY-MM-DD; ordering=earliest|latest| none; time_request=yes|no
- Resolve relative expressions using the closest explicit date in the passage. If none exists, use observed_time. - observed_time is always set to the provided observed_time string. - Do not infer a time if the passage does not contain a temporal expression. - Do NOT use time expressions as head or tail entities; keep time only in text_time. - Each triple should contain at least one, but preferably two, of the named entities in the list. - Resolve pronouns to their specific names. - Extract all factual relations, including actions, states, plans, and events. - Do not omit facts; prioritize completeness over brevity. - Duration handling: if the passage states a duration such as "for 5 years" and an explicit reference date is present, infer the start date and put it in text_time.
Rules: - If a time constraint exists, return it as YYYY-MM-DD. - If the query only specifies a month or year, use the first day of that month or year. - If the query omits the year, use the year from the reference date. - Resolve relative expressions using the reference date. - If no time constraint exists, return time= NONE. - ordering=earliest for queries like " earliest/first/oldest". - ordering=latest for queries like "latest/ most recent/last time". - ordering=none otherwise. - time_request=yes if the query asks for a time as the answer (e.g., when/what year/ which year/what date). - time_request=no if the query only uses time as a constraint or does not ask for time.
Output format: {"triples": [ {"head": "X", "relation": "Y", "tail": "Z ", "text_time": "YYYY-MM-DD", "observed_time": "2024-01-01T00:00:00Z"} ]}
B.2.3 Query-Time Entity Extraction At query time, we extract named entities from the question to initialise graph traversal.
Reference date (UTC): {reference_date} Query: {query}
Box V: Query NER Prompt (One-Shot)
C
Benchmark Datasets
System: Table 3 summarises the key statistics for each dataset. Detailed descriptions follow.
"You're a very effective entity extraction system."
User:
ICEWS05-15 (García-Durán et al., 2018). The Integrated Crisis Early Warning System (ICEWS) dataset contains geopolitical event triples spanning 2005–2015. Each triple takes the form (head, relation, tail, date) with dates in YYYY-MM-DD format. The standard split comprises 368,962 training, 46,275 validation, and 46,092 test triples. We use this dataset exclusively for RQ1 to verify that our functional temporal modelling preserves standard TKGE accuracy.
Please extract all named entities that are important for solving the questions below. Place the named entities in json format. Question: Which magazine was started first Arthur's Magazine or First for Women?
Assistant: {"named_entities": ["First for Women", " Arthur's Magazine"]}
B.2.4 Time Extraction At query time, we extract temporal constraints and ordering intent from the question.
MultiTQ (Chen et al., 2023). Multi-Temporal Question answering over Knowledge Graphs. The full benchmark builds on the ICEWS05-15 KG (461,329 temporal quads, 4,017 timestamps) with 54,584 test questions spanning types such as equal, before_after, after_first, and first_last, with answers classified as entity or time at day, month, or year granularity. For agentic memory evaluation, we sample 500 questions and process
Box VI: Time Extraction Prompt
System: "You extract the time constraint from a query. Return a single line only."}
User:
14
Table 3: Summary statistics of evaluation datasets. Dataset
RQ
Facts/Docs
Queries
Task Type
ICEWS05-15 MultiTQ LoCoMo DMR-MSC FinTMMBench
RQ1 RQ2 RQ2 RQ2 RQ3
461,329 11,074 10 conv. 500 dial. 908 docs†
46,092 500 1,986 500 100†
TKG completion Temporal KGQA Conv. memory QA Dialogue memory QA Financial temporal QA
† Stratified sample: 100 questions with a corpus of 908 documents (227 gold sources + 681 randomly sampled non-gold documents).
only the corresponding time snapshots, yielding 11,074 facts ingested incrementally per snapshot.
ing 227 gold sources and 681 randomly sampled non-gold documents.
LoCoMo (Maharana et al., 2024). LongContext Conversational Memory benchmark consisting of 10 synthetic multi-session conversations with 1,986 question–answer pairs. Questions are divided into five categories: (1) Single-Hop: direct fact retrieval; (2) Multi-Hop: multi-step reasoning; (3) Temporal Reasoning: time-sensitive queries requiring date resolution; (4) Open Domain: general knowledge queries; and (5) Adversarial: queries about information not present in the conversations. Each question is accompanied by evidence references (e.g., D1:3) pointing to specific conversation segments.
D
Evaluation Metrics and Answer Verification
Temporal KG Completion (RQ1). For ICEWS05-15, we report Mean Reciprocal Rank (MRR) and Hits@k for k ∈ {1, 3, 10}, following the standard filtered setting: 1 X 1 |Q| rank(q)
(9)
1 X 1[rank(q) ≤ k] |Q|
(10)
MRR =
q∈Q
Hits@k =
q∈Q
Agentic Memory Retrieval (RQ2, RQ3). For MultiTQ and DMR-MSC, we report MRR and Hits@k (k ∈ {1, 3, 10}) computed over retrieved facts, where each query has a single gold answer:
DMR-MSC (Packer et al., 2024). The Dynamic Memory Retrieval Multi-Session Chat dataset contains 500 multi-session dialogues with selfinstructed question–answer pairs. Each example includes persona statements, dialog turns with speaker identities, and temporal context via time_back annotations (e.g., “14 days”). This dataset serves as our static-memory baseline to verify that temporal modelling does not degrade standard conversational retrieval.
Hits@k = 1[∃ i ≤ k : doci ∈ G]
(11)
For LoCoMo, we report Recall@10 per question category, computed as the fraction of gold evidence passages found in the top-10 retrieved documents: Recall@k =
FinTMMBench (Zhu et al., 2025). Financial Temporal Multi-Modal Benchmark containing 5,676 question–answer pairs over NASDAQ-100 companies. The corpus comprises 162,311 documents across four modalities: News (3,143 articles), FinancialTable (35,038 indicator records), StockPrice (124,130 price records), and Chart (visionbased, excluded from our text-only evaluation). Each question references specific date ranges (e.g., “from 2022-06-27 to 2022-09-23”) and gold source document UUIDs for provenance evaluation. Question subtasks include Extraction, Calculation, Sentiment, and Trend analysis. To enable feasible evaluation, we use a stratified sample of 100 questions and a reduced corpus of 908 documents, compris-
|{d ∈ top-k : d ∈ G}| |G|
(12)
For FinTMMBench, we report Recall@k for k ∈ {1, 3, 5, 10} and MRR, computed against gold source document UUIDs. Answer Quality. We evaluate downstream answer quality using LLM@k Accuracy, where k denotes the number of retrieved documents provided to the answer LLM. For DMR-MSC and FinTMMBench, a generated answer is scored as correct via the two-stage LLM judge pipeline described in Appendix D.1. For MultiTQ, we instead use a rule-based cascading verifier (Appendix D.2) following the original benchmark protocol. We report LLM@k Accuracy at context sizes k ∈ {5, 10}. 15
D.1
LLM Judge
Just return the label CORRECT or WRONG in a json format with the key as "label".
We use a two-stage answer evaluation pipeline. Stage 1 (fast path): normalised substring matching—if the lowercased, whitespacenormalised gold answer is a substring of the generated answer, the answer is immediately labelled CORRECT. Stage 2 (LLM fallback): for non-matching answers, we invoke GPT-5.2 as a judge using the prompt shown in Box VII. The judge is called with temperature=0 and JSON response format {"label": "CORRECT"|"WRONG"}.
D.2
MultiTQ Answer Verifier
For MultiTQ, answer correctness is determined by a cascading multi-strategy rule-based verifier (rather than the LLM judge used for other benchmarks), adopted from Tan et al. (2026) to handle the diverse answer formats in temporal KGQA (entities, dates at varying granularities, and multi-part answers). The strategies are applied in order; the first match determines the verdict:
Box VII: LLM Judge Prompt
1. Exact match: normalised entity string equality.
Your task is to label an answer to a question as `CORRECT' or `WRONG'. You will be given: (1) a question (posed by one user to another user), (2) a `gold' (ground truth) answer, (3) a generated answer which you will score as CORRECT/WRONG.
2. Containment: bidirectional substring check (gold ⊆ prediction or prediction ⊆ gold). 3. Advanced normalisation: strip prefixes (e.g., “The”), brackets, and punctuation, then substring match.
The point of the question is to ask about something one user should know about the other user based on their prior conversations. The gold answer will usually be a concise and short answer that includes the referenced topic, for example:
4. Time format matching: year–month level matching with month-name support (e.g., “January 2013” ≈ “2013-01”).
Question: Do you remember what I got the last time I went to Hawaii? Gold answer: A shell necklace
5. Multi-answer: comma-separated answer parts are matched individually.
The generated answer might be much longer, but you should be generous with your grading - as long as it touches on the same topic as the gold answer, it should be counted as CORRECT.
6. Semantic overlap: word overlap > 50% between prediction and gold answer tokens. 7. Loose match: remove all spaces and underscores, then substring match.
For time related questions, the gold answer will be a specific date, month, year, etc. The generated answer might be much longer or use relative time references (like "last Tuesday" or "next month"), but you should be generous with your grading - as long as it refers to the same date or time period as the gold answer, it should be counted as CORRECT. Even if the format differs (e.g., " May 7th" vs "7 May"), consider it CORRECT if it's the same date.
E
Implementation Configurations and Hyperparameters
E.1
Configurations
We evaluate all agentic memory benchmarks under two implementation configurations: 1. OpenAI: GPT-5-mini for graph construction (NER + OpenIE) and text-embedding-3-small for embedding. This configuration tests performance with API-based models.
Now it's time for the real question: Question: {question} Gold answer: {gold_answer} Generated answer: {generated_answer} First, provide a short (one sentence) explanation of your reasoning, then finish with CORRECT or WRONG. Do NOT include both CORRECT and WRONG in your response, or it will break the evaluation script.
2. Server: LLaMA-3.1-70B-Instruct (Meta AI, 2024) served via vLLM for graph construction and BAAI/BGE-M3 (Chen et al., 2024) for embedding. This configuration demonstrates open-source reproducibility. 16
In both configurations, the answer LLM and LLM judge always use GPT-5.2 via the OpenAI API to ensure fair comparison across all baselines. Baseline systems.
bound guarantees a unique, monotonic pairwise crossover between historical anchors. F.2
We compare against:
Complex vs. Real Representation
Table 4 reports the full TKGE hyperparameter configuration used across all experiments.
Our methodology embeds entities in R2d and interprets them as complex vectors in Cd . These two views are algebraically equivalent: a rotation by angle θ in Cd corresponds to applying a blockdiagonal orthogonal matrix Rθ ∈ R2d×2d composed of d independent 2 × 2 rotation blocks. The complex formulation is not merely notational convenience. As established by RotatE (Sun et al., 2019b) and ChronoR (Sadeghian et al., 2021b), expressing relational transformations as element-wise rotations (Hadamard products) in the unitary group U (1)d naturally captures critical graph structures such as symmetry, antisymmetry, inversion, and composition, while reducing transformation cost from O(d2 ) (general matrix multiplication) to O(d) (element-wise operations). Our analysis below establishes that these algebraic benefits seamlessly extend to continuous time dynamics.
F
Theoretical Analysis
F.3
F.1
Overview
• Mem0 (Chhikara et al., 2025): FAISS-based vector memory with per-document embedding and search. • Zep (Rasmussen et al., 2025): Temporal knowledge graph with Neo4j backend and entity extraction. • HippoRAG (Gutierrez et al., 2024; Gutiérrez et al., 2025): Knowledge graph-augmented RAG with Personalised PageRank retrieval and Neo4j backend. RO M EM builds upon HippoRAG’s graph construction pipeline. All baselines use the same answer LLM, LLM judge, and evaluation metrics for fair comparison. E.2
TKGE Hyperparameters
Retrieval Reformulation and Static Index Compatibility
In the temporal knowledge graph retrieval setting, evaluating a query (h, r, ?) against all candidate tail entities t ∈ E under continuous time introduces a severe scalability bottleneck. Naively applying the time-dependent rotation to the entire candidate vocabulary dictates an O(N · d) dynamic transformation at query time, which fundamentally breaks compatibility with prebuilt static vector search indices and renders large-scale querying computationally intractable. Here, we answer a critical prerequisite question: Can we evaluate continuous temporal queries without dynamically modifying the candidate index? To address this, we work in the realspace implementation introduced in §3.3, where Rθr (τ ) ∈ R2d×2d is the block-diagonal orthogonal matrix representation of Rot(·, θ r (τ )), and Wr = diag(wr ⊙ w̄r ) ∈ R2d×2d is the corresponding relation-specific diagonal scaling matrix. We demonstrate that the exact 1-vs-N retrieval can be mathematically reformulated to isolate the temporal transformation entirely to the query side, preserving strict compatibility with highly-optimised Maximum Inner Product Search (MIPS) architectures.
While transitioning from a discrete timestamp dictionary to a continuous functional rotation resolves the granularity and extrapolation limitations of traditional temporal models, it introduces distinct algebraic and computational challenges. This appendix section provides the rigorous theoretical justification for our framework, structured around three core aspects: • Complex vs. Real Representation (F.2): We clarify the relationship between the complexspace formulation in Cd and its real-space equivalent in R2d , demonstrating why the complex unitary group offers concrete structural advantages for temporal knowledge graphs. • Retrieval Reformulation (F.3): We prove that the orthogonal structure of the rotation operator allows the continuous temporal transformation to be isolated entirely on the query side, thereby preserving strict compatibility with static vector search indices. • Temporal Interpolation (F.4): We establish a mechanistic mathematical foundation for the model’s zero-shot temporal interpolation capability. We prove that a half-period frequency 17
Table 4: TKGE hyperparameters. Parameters above the mid-rule are core KGE settings; below are temporal extension parameters. Parameter
Value
Description
temporal_backbone chronor_k gamma adversarial_temperature regularization_weight steps_per_update num_conflict_negatives
chronor 3 200.0 1.0 10−5 500 1
ChronoR rotation backbone Number of rotation sub-spaces Embedding range: (γ + 2)/dim Self-adversarial sampling temperature N3 per-batch regularization (ChronoR) Training epochs per update cycle Tails from same (h, r) group
time_source time_loss_type time_contrastive_weight num_time_negatives time_sigma_years time_sigma_years_start time_sigma_years_end time_neg_jitter_years time_neg_far_days time_neg_min_days_start time_neg_min_days_end time_neg_min_days_decay
happen listwise 0.5 8 0.25 0.5 0.02 0.02 365 90 3 60
Use text_time for temporal scoring Distribution-matching time loss Time-contrastive loss weight (λtime ) Negative time samples per fact Gaussian kernel σ (years) Curriculum start σ Curriculum end σ Temporal jitter for negatives Far negative offset (days) Curriculum start min-gap (days) Curriculum end min-gap (days) Min-gap curriculum decay (epochs)
Proposition 1 (Query-Side Reformulation of Temporal Retrieval). Let C ∈ RN ×2d be the static matrix of candidate embeddings in the real-space implementation, where the t-th row of C is e⊤ t . For a continuous timestamp τ , suppose the score against candidate t is defined by the standard Euclidean inner product:
prevents the use of any prebuilt static inner-product index. However, since the rotation matrix Rθr (τ ) is orthogonal, its transpose satisfies Rθ⊤r (τ ) = R−θr (τ ) . Utilizing the adjoint property of the Euclidean inner product, we can strictly transfer the rotation from the candidate vector back to the query side:
skge ((h, r, t) | τ ) = ⟨Wr Rθr (τ ) eh , Rθr (τ ) et ⟩
skge ((h, r, t) | τ ) = ⟨R−θr (τ ) Wr Rθr (τ ) eh , et ⟩
where Rθr (τ ) ∈ R2d×2d is a block-diagonal orthogonal matrix representing the phase shift, and Wr ∈ R2d×2d is the diagonal relation-specific scaling operator. Then there exists a candidateindependent query vector q(τ ) ∈ R2d defined as:
By substituting the definition of the unrotated query vector q(τ ), the scoring function trivially simplifies to skge ((h, r, t) | τ ) = ⟨q(τ ), et ⟩. We note that the temporal dependence remains nontrivial whenever the relation-specific operator Wr does not commute with Rθr (τ ) . Complexity Analysis. Constructing the query vector q(τ ) requires O(d) trigonometric evaluations and O(d) structured linear operations, since Rθr (τ ) is block-diagonal and Wr is a diagonal matrix. To evaluate the query against all N candidates simultaneously, we compute the full score vector s(τ ) ∈ RN , where each t-th element strictly corresponds to the individual scalar score skge ((h, r, t) | τ ). This is achieved via a single matrix-vector multiplication: s(τ ) = C q(τ )
q(τ ) = R−θr (τ ) Wr Rθr (τ ) eh such that the score reduces to: skge ((h, r, t) | τ ) = ⟨q(τ ), et ⟩ for all candidates t. Consequently, the exact 1vs-N retrieval reduces to an O(d) query-side preprocessing step followed by an O(N · d) static inner-product search over C. Proof. In a direct candidate-side implementation, evaluating the score requires applying the timedependent rotation Rθr (τ ) to every candidate vector et at query time. Although this can be computed in a streaming fashion in O(N · d) time, this query-time temporal transformation fundamentally
which requires O(N ·d) arithmetic operations. The additional query-time workspace is O(d), and the retrieval stage requires no candidate-side temporal transformation. This proves the proposition. 18
Remark: Because the final formulation reduces retrieval to a standard inner-product evaluation over a static candidate matrix C, the model is directly compatible with exact or approximate innerproduct search libraries (e.g., FAISS) without requiring index rebuilds across queries. F.4
across all dimensions structurally reduces the exact relational inner product to a multi-frequency synchronised cosine expansion. This rigorous isomorphism justifies the stylised scoring dynamics analysed below. In this section, we establish a sufficient condition under which the temporal competition between two consecutive facts exhibits a smooth, monotonic crossover, thereby yielding a deterministic decision boundary for unobserved intermediate timestamps.
A Stylised Analysis of Pairwise Temporal Interpolation
A fundamental advantage of formulating time as a continuous rotation operator lies in its structural capacity to interpolate knowledge between historical observations. While exact global retrieval over an entire knowledge graph entails complex multidimensional phase interference, we can rigorously demonstrate the model’s interpolation mechanics by analysing a stylised pairwise regime. Trigonometric Isomorphism of the Scoring Function. Before stating the formal proposition, we establish the algebraic bridge between the global inner-product scoring formulation (Equation (4)) and its corresponding trigonometric expansion. Since the total score skge is a linear sum of P independent dimensional contributions (skge = j sj ), we can isolate the temporal dynamics within a single complex dimension. For each 2D rotational subspace j, the partial score evaluates a bilinear form:
Proposition 2 (Sufficient Condition for Monotone Pairwise Crossover). Consider a temporal query (h, r) with two mutually exclusive facts, A and B, observed at consecutive timestamps T and T + t (t > 0). Assume that over the interpolation interval [T, T + t], the expansion of the inner-product scoring function (Equation (4)) for each candidate c ∈ {A, B} is governed by a stylised synchronised cosine expansion: sc (τ ) =
d X
γc,j cos ω̃j (τ − τc ) ,
γc,j > 0
j=1
where τA = T and τB = T + t denote the local phase-alignment peaks. Consistent with the continuous functional time definition in Equation (1), ω̃j = s · αr · ωj represents the effective angular velocity, which explicitly incorporates the global time scale s, the global inverse frequency ωj , and the relation-specific semantic speed gate αr . Assume the model accurately reconstructs these historical anchors such that sA (T ) > sB (T ) and sA (T + t) < sB (T + t). Provided the effective angular velocities satisfy the strict half-period bound ω̃j ∈ (0, πt ] for all j, the pairwise confidence gap ∆s(τ ) = sA (τ ) − sB (τ ) is strictly monotonically decreasing on the open interval (T, T + t). Consequently, there exists a unique crossover timestamp τ ∗ ∈ (T, T + t) satisfying sA (τ ∗ ) = sB (τ ∗ ). For any intermediate time τ ∈ (T, T + t), the model strictly prefers A when τ < τ ∗ , strictly prefers B when τ > τ ∗ , and yields an exact pairwise tie at τ ∗ .
⊤ sj (τ ) = h⊤ j Rθj (τ ) Wj Rθj (τ ) tj
where hj , tj ∈ R2 are the static entity vectors, Wj = diag(wj,1 , wj,2 ) is the relation weight matrix, and θj (τ ) is the j-th scalar component of the relation-specific rotation vector θ r (τ ) (defined in Equation (1)). Because the relation weights typically break rotational symmetry (wj,1 ̸= wj,2 ), expanding Rθ⊤j (τ ) Wj Rθj (τ ) via double-angle identities yields a linear combination of trigonometric functions: sj (τ ) = Cj + Aj cos(2θj (τ )) + Bj sin(2θj (τ )) where Cj , Aj , Bj are time-independent constants determined by the entities and relation weights. By applying the harmonic addition theorem, this combination can be exactly re-parameterised as a phase-shifted cosine wave:
Proof. By the assumption of anchor correctness, the relative confidence at the boundaries satisfies ∆s(T ) > 0 and ∆s(T + t) < 0. To analyse the transition mechanics, we differentiate the confidence gap with respect to continuous time τ :
sj (τ ) = Cj + γj cos(2θj (τ ) − ϕj ) q with amplitude γj = A2j + Bj2 > 0 and phase shift ϕj = arctan(Bj /Aj ). Since the rotation angle θj (τ ) is linearly proportional to time τ (Equation (1)), summing these independent subspaces
d ∆s(τ ) = s′A (τ ) − s′B (τ ) dτ 19
G
The derivatives of the stylised scoring functions are given by: s′A (τ ) = −
d X
γA,j ω̃j sin ω̃j (τ − T )
To make the geometric shadowing mechanism concrete, we present scoring traces from a controlled experiment. We select a small subset of real temporal triples from ICEWS05-15 (García-Durán et al., 2018), including 4 (Obama, Consult, Blair) facts timestamped between June 2007 and April 2008, and 6 (Obama, Consult, Xi Jinping) facts timestamped between June 2013 and September 2015, along with static facts (born in) and auxiliary relation slots (Make a visit, Express intent to cooperate). These additional facts are included to provide sufficient training signal for the shared entity embeddings and frequency spectrum while training on the two competing facts alone leaves the model severely underconstrained, producing degenerate oscillations. We train a RO M EMChronoR model on this subset with the bundled pretrained gate and sweep the query timestamp τq to observe how candidate scores evolve continuously.
j=1
s′B (τ ) = −
d X
γB,j ω̃j sin ω̃j (τ − (T + t))
j=1
For any intermediate time τ = T + dt with dt ∈ (0, t), the temporal displacement for candidate A is dt. Given ω̃j ∈ (0, πt ], the phase argument ω̃j dt strictly resides in (0, π). In this interval, the sine function is strictly positive. Since γA,j > 0 and ω̃j > 0, it strictly follows that s′A (τ ) < 0. Conversely, the temporal displacement for candidate B is dt − t < 0. Under the same frequency bound, the phase argument ω̃j (dt − t) strictly resides in (−π, 0), where the sine function is strictly negative. This renders s′B (τ ) > 0. Therefore, the derivative of the pairwise gap is strictly negative across the entire open interval: d ∆s(τ ) < 0 dτ
Qualitative Analysis: Geometric Shadowing in Action
G.1
Dynamic Relation: Score Crossover
Consider the relational slot (Barack Obama, Consult, ?) with two competing tail entities: Tony Blair (4 observations, 2007-06 to 2008-04) and Xi Jinping (6 observations, 2013-06 to 201509). The pretrained semantic speed gate assigns αr (Consult) = 0.87, correctly identifying this as a highly dynamic relation. Figure 3 visualises the TKGE scores skge as the query time τq sweeps continuously from 2007 to 2016. As τq moves forward, Blair’s score initially dominates but progressively decreases as the phase difference |τq − tBlair | grows. Simultaneously, Xi’s score rises as τq approaches his observed period. The crossover occurs around 2009, after which Xi geometrically shadows Blair. Note that the crossover point τ ∗ is not necessarily at the midpoint of the two observation windows, as Proposition 2 guarantees the existence and uniqueness of τ ∗ but not its location, which depends on the learned embedding amplitudes of each candidate. Crucially, neither fact is deleted: both remain in the append-only memory, and the rotation operator continuously modulates their alignment with the query time.
∀τ ∈ (T, T + t)
This strict monotonicity, coupled with the continuity of the scoring functions on [T, T + t] and the boundary conditions, guarantees via the Intermediate Value Theorem (IVT) the existence of exactly one root τ ∗ in (T, T + t) where ∆s(τ ∗ ) = 0. Remark: While exact global retrieval over the full candidate set remains subject to the arbitrary phase offsets of all other entities, this stylized proposition formalizes the core inductive bias of the model: continuous functional rotations, when strictly regularized by the semantic speed gate αr , inherently induce smooth, oscillation-free pairwise transitions between historical anchors. Furthermore, the exact crossover point τ ∗ is not constrained to the geometric midpoint T + t/2. Its precise location shifts dynamically based on the relative structural amplitudes (γA,j and γB,j ) of the competing entities, allowing the interpolation boundary to naturally reflect their topological significance in the graph. This provides a rigorous mechanistic foundation for zero-shot temporal interpolation—a property structurally absent in discrete lookup-table paradigms.
On raw oscillations and multiple crossings. The raw quarterly scores (light traces in Figure 3) exhibit local oscillations that cause the two curves to cross multiple times, seemingly at odds with 20
1.50
TKGE score skge
1.25
skgeBlair (Obama, Consult, Blair) observed (2007 08) Consult, Xi) skge(Obama,
crossover
*
Xi observed (2013 15)
2009
1.00 0.75 0.50 0.25 r(Consult) = 0.87
0.00 2007
2008
2009
2010
2011
2012
Query time q
2013
2014
2015
2016
Figure 3: Scoring trace for the competing slot (Obama, Consult, ?). Bold curves are smoothed (5-quarter rolling average); light traces show raw quarterly scores. The blue and yellow shaded regions mark the observation windows for Blair (2007–2008) and Xi (2013–2015) respectively. The crossover point τ ∗ (red dot) marks where the temporally outdated fact is geometrically shadowed by the newer one. The gate value αr = 0.87 confirms the model treats “Consult” as a highly dynamic relation.
the unique crossover guaranteed by Proposition 2. This is expected: the Proposition establishes a sufficient condition that strict monotonicity holds when all frequency components satisfy the half-period bound ω̃j ≤ π/t. In practice, two factors contribute to the observed fluctuations. First, the model learns a spectrum of kd frequency components, and higher-frequency components (those with period shorter than the ∼5-year observation gap) violate this bound, producing local oscillations. Second, entity embeddings are shared across all relation slots. Obama’s embedding is jointly trained on Consult, Make a visit, and born in facts, so temporal dynamics from other slots introduce additional phase interference into the Consult scores. For instance, Blair’s raw score briefly rises around 2010–2011 before resuming its decline, and Xi’s score dips near 2015 before recovering. The bold smoothed curves apply a 5-quarter rolling average, which acts as a low-pass filter that isolates the dominant low-frequency components — precisely those that satisfy the half-period bound and carry the primary temporal signal. Under this view, smoothing reveals the signal that Proposition 2 describes, while the raw oscillations represent higher-frequency residuals that diminish with larger training sets. The smoothed trend exhibits a single, clean crossover consistent with the theoretical prediction. G.2
lations that appeared in the ICEWS05-15 pretraining data (seen) and relations the gate has never encountered (unseen). The gate correctly assigns high volatility to relations where the object entity changes frequently, and low volatility to inherently stable relations without any manual annotation. Table 5: Pretrained semantic speed gate values. Higher αr = faster rotation. Seen: appeared in ICEWS05-15 during pretraining; Unseen: zero-shot via text embedding similarity. Relation
αr
Category
Seen during gate pretraining (ICEWS05-15) Consult Host a visit Engage in negotiation Sign formal agreement Cooperate economically Cooperate militarily
0.87 0.86 0.63 0.53 0.16 0.09
Dynamic Dynamic Dynamic Dynamic Static Static
Unseen (zero-shot via text embeddings) met with visited negotiated with CEO of capital of species citizen of
0.71 0.64 0.62 0.44 0.36 0.22 0.17
Dynamic Dynamic Dynamic Moderate Moderate Static Static
A notable property of this result is that ICEWS05-15 contains few semantically static relations. All 251 relation types describe political events (consulting, visiting, threatening, etc.), lacking permanent properties like “born in” or “species”. Across 461K facts spanning 4,017 timestamps, the average (h, r) slot has 3.08 distinct tail entities, which means every relation exhibits tempo-
Gate Inspection: Learned Relational Volatility
Table 5 shows the pretrained gate values αr for representative relations, split into two groups: re21
ral variation.2 Yet the gate still learns a meaningful volatility gradient within this event-driven spectrum: episodic interactions like “Consult” (0.87) and “Host a visit” (0.86) receive high αr , while sustained state-level conditions like “Cooperate militarily” (0.09) and “Cooperate economically” (0.16) receive lower values. The stronger claim, however, lies in the unseen relations. Despite being pretrained exclusively on political events, the gate correctly generalises to different semantic domains: it assigns high αr to episodic relations it has never seen (“met with” at 0.71, “visited” at 0.64) and low αr to genuinely permanent properties absent from the pretraining data (“citizen of” at 0.17, “species” at 0.22). This zero-shot transfer is possible because the gate MLP operates on text embeddings rather than relation IDs: “met with” lies close in embedding space to seen diplomatic events, while “citizen of” and “species” are embedded far from any high-volatility predicate. In effect, the text embedding model encodes sufficient semantic structure for the gate to infer temporal volatility even for relation types that never appeared during pretraining. The temporal clutch effect where low αr suppresses rotation and preserves static fact retrieval is also empirically validated by the DMR-MSC benchmark results (Table 2c), which show zero degradation on purely static conversational memory.
2
57 of 251 relations technically have single-tail slots, but these are all rare event types (≤42 facts each) that appear static mostly due to data sparsity, not semantic permanence (e.g., “Attempt to assassinate,” “Demand mediation”).
22