Presentation, Not Mechanism: A Render Confound in Deprecation-Aware Memory Evaluation Zhaoyang Jiang1 Zhizhong Fu3 Zicheng Li1 Yunsoo Kim4 Jiacong Mi1 Xuanqi Peng1 Fei Teng2 Honghan Wu1 * 1
2
School of Health & Wellbeing, University of Glasgow, Glasgow, UK Department of Respiratory and Critical Care Medicine, Shanghai Sixth People’s Hospital, Shanghai Jiao Tong University School of Medicine, Shanghai, China 3 School of Life Science and Technology, University of Electronic Science and Technology of China, Chengdu, China 4 Institute of Health Informatics, University College London, London, UK
arXiv:2607.16019v1 [cs.LG] 17 Jul 2026
{3167645J, 3131960P, 3222974L}@student.gla.ac.uk, [email protected], [email protected], [email protected], [email protected], [email protected] Abstract
1
Introduction
Retrieval systems increasingly answer questions over records that revise themselves: software issue threads, encyclopedic histories, policy logs, incident reports, and long-running conversations. A maintainer may first recommend a workaround, later replace it with a patch, and later still qualify that patch by platform. In such streams, we call a claim in force when it is the value a system should use after later corrections, refinements, and supersessions. The right answer is therefore not always the newest sentence or the majority of retrieved passages; it is the value that remains live in the revision history. This matters because stale state is a high-impact failure mode for coding assistants, support agents, and analytic systems that must know when to answer, when to cite a prior value, and when to abstain. The central question is not simply whether memory should be “structured,” but what structure is actually necessary for the query being asked. Existing systems answer pieces of this question but not the selection problem. Flat RAG and GraphRAG-style systems retrieve and group evidence, yet mostly treat retrieved facts as additive: old and new claims are placed together as usable context, with no explicit decision about which one is still in force (Edge et al., 2024; Gutiérrez et al., 2024). Agent memories store evolving facts, but often leave supersession implicit in summaries or embeddings (Packer et al., 2023; Xu et al., 2026; Chhikara et al., 2025). Temporal graph memories such as Zep/Graphiti invalidate
AI systems increasingly retrieve from records that revise themselves: issue threads, encyclopedic histories, policy logs, and long conversations. The challenge is not only finding relevant evidence, but deciding which claims remain in force, which were superseded, and when to abstain. Structured memories promise to solve this with typed edges, temporal updates, and conflict status, yet evaluations often change mechanism and prompt presentation together. We study this as Evidence-State Revision, comparing flat retrieval, coarse edge invalidation, and fine-grained RevisionLedger on 2,907 highagreement questions from GitHub, multi-repo issue histories, Wikipedia, and DyKnow-style temporal streams. A render-matched control (same layout, deprecation disabled) reveals the central confound: when a value is changed and later restored, RevisionLedger appears to beat a flat baseline by +0.182, but almost all the gain comes from easier presentation; the fine-grained mechanism residual is indistinguishable from zero (+0.021 to +0.025 across two judge families). After presentation is controlled, coarse invalidation is the only mechanism that pays for current-state queries, beating the fine ledger by 0.084; the same querysufficiency principle says provenance mainly needs retained invalidated evidence, not richer typing. Memory evaluations should hold render fixed, and deprecation-aware systems should deploy the coarsest retained state that covers their queries. * Corresponding author.
1
old edges when a new one supersedes them, giving a coarse notion of deprecation (Rasmussen et al., 2025). Knowledge-conflict benchmarks study contradictions among passages or between retrieved and parametric knowledge (Xu et al., 2024; Hou et al., 2024; Ming et al., 2025; Li et al., 2024; Xie et al., 2024), but usually diagnose conflict at answer time rather than as an ingestion-time state update. The design space is therefore unsettled: should a revising stream use ordinary retrieval, a conflictaware merger, a supersession-aware store, or a full typed ledger? This design question has an evaluation trap. Structured memories often change both the mechanism they implement, such as typed edges or invalidation, and the presentation they show the answer model, such as cleaner ordering and explicit fields. If a ledger beats a flat baseline, the answer LLM may be benefiting from a better-formatted prompt rather than a better memory mechanism. A rendermatched evaluation is therefore part of the method, not a cosmetic control: without it, we may recommend an elaborate architecture when a simpler state representation, rendered well, would have worked. We study this problem as Evidence-State Revision (ESR): given an evolving evidence stream, maintain enough state to answer what currently holds, what was superseded, and when no single answer is justified. We organize streams by conflict locality: within a passage, across passages, or across time for the same entity attribute. The temporal case is distinctive because it requires a deprecation marker saying that a later event has made an earlier atom no longer live. On ESR-Bench, we compare a GraphRAG-style baseline with no deprecation marker (GraphRAG+abstain), a coarse edge-invalidation store in the Graphiti/Zep style, and RevisionLedger, a fine-grained ledger with relation types and unresolved status. Our hypothesis is query-sufficiency: current-value (snapshot) questions need only live/dead deprecation, provenance needs retained invalidated evidence, and fine relation types are useful only when the query asks for relation or status itself. Our experiments validate this view on 2,907 high-agreement ESR-Bench questions over GitHub, multi-repo issue histories, Wikipedia revisions, and DyKnow-style temporal streams. On reverted-revert questions, where a middle claim is superseded and the current value returns, RevisionLedger appears to beat a flat baseline by +0.182. A render-matched control shows
that almost all of this gain is presentation; the fine-grained mechanism residual is indistinguishable from zero (+0.021 to +0.025 across two judge families). Coarse invalidation is the mechanism that pays for current-state queries, and on the clean setting it matches or beats the fine ledger (∆RevisionLedger−Graphiti = −0.084). Provenance shows the dual lesson: a coarse store that discards invalidated edges fails because the prior value is absent, while a retaining coarse store recovers most of the apparent fine-ledger advantage. The practical recommendation is thus compact: hold render fixed when evaluating memory architectures, and deploy the coarsest retained state that covers the query mixture. Code is available at https://github. com/Anonymous-Awesome-Submissions/ ESR-pipeline. Privacy-minimized ESR-Bench artifacts are available at https://github.com/ Anonymous-Awesome-Submissions/ESR-bench; consistent with the Ethics Statement, released artifacts are derived benchmark artifacts rather than raw GitHub threads, Wikipedia revisions, or other verbatim source text.
2
Evidence-State Revision
An evidence stream is an ordered sequence C = (e1 , . . . , eT ), where each event has text, a timestamp, and optional metadata. An atom extractor maps events to tuples (x, a, v, π, t, ρ): entity, attribute, value, polarity, time, and source role. For atoms with the same entity–attribute key (x, a), ESR asks which value is currently in force, which events support it, and which earlier events have been closed by later evidence. The system may output A BSTAIN when no single current value is justified. The core state is a ledger row per key (x, a): the current value, valid-since time, supporting atoms, deprecated atoms, and conflict status. Relation labels are used to update this state: SUPERSEDES replaces the value and deprecates prior support, RE FINES adds finer support, and unresolved CONTRA DICTS routes to A BSTAIN . We assume each key holds a single current value; faceted states, where a value differs by platform or version, need a finer key and are outside the current extractor. The diagnostic is conflict locality: where the conflict lives fixes the minimal primitive a memory must expose. This is a selection rule, not a claim that every stream needs the largest repre2
1
Shared revised evidence
2 Flat baseline (d-blind)
3 Fine-grained ledger
Retrieved text t1
t2
t3
Set timeout = 30 s.
Update: use 60 s instead.
Correction: revert to 30 s.
Q: What timeout is currently in force?
[t3] Correction: revert to 30 s. This change restores the previous setting due to observed issues. --[t2] Update: use 60 s instead. The timeout was increased to improve reliability under load. --[t1] Set timeout = 30 s. Initial configuration for the request timeout. --(... other unrelated context ...)
Time
Evidence
Value
t3
Correction: revert to 30 s.
30 s
Status LIVE
t2
Update: use 60 s instead.
60 s
DEPRECATED
t1
Set timeout = 30 s.
30 s
-
30 s 4 Render-matched control
uncertain
(same layout)
mechanism off
Time
Evidence
Value
t3
Correction: revert to 30 s.
30 s
Status neutral
t2
Update: use 60 s instead.
60 s
neutral
t1
Set timeout = 30 s.
30 s
neutral
30 s Holding render fixed leaves little extra benefit for the fine-grained supersession mechanism.
Readable render, not fine-grained typing, explains most of the gain.
Figure 1: The render confound. In a reverted-revert stream (30s → 60s → 30s), RevisionLedger answers the current value while the flat baseline answers uncertain (an abstention). A render-matched control keeps the ledger layout but disables deprecation labels; it still answers 30s. Thus the apparent ledger gain can come from readable, time-ordered presentation rather than fine-grained supersession typing; §4.1 quantifies the near-zero residual mechanism effect.
sentation. L1 needs only readable evidence, L2 needs source-aware conflict status, and L3 needs deprecation. Because the implemented ledger subsumes lower tiers through its conflict-status field, unresolved cross-source conflicts must still route to A BSTAIN rather than be treated as temporal updates; DS CROSS - SOURCE - CONFLICT tests this high-recall gate directly.
The resulting recommendation is query-relative. Coarse-d stores recover Π directly through binary edge invalidation; fine-d ledgers can match that partition but also pay for a typed scorer, a heavier render, and an abstain path that is brittle in current LLMs (Kirichenko et al., 2026). Corollary 1 therefore predicts no intrinsic fine-typing gain on snapshot tasks when fine-d has non-negative excess cost; the render-matched ablation of §4.1 tests this by holding presentation fixed. Fine typing has room to help only when the query reads a relation coordinate that Π collapses, such as refinement or unresolved status, and only when that coordinate is actually recovered. Appendix Proposition 4 (P4) is used only as decision-channel bookkeeping; because P4’s out-of-sample sign prediction is falsified by the controlled noise sweep in §4.2, the granularity ranking rests on P2b and Corollary 1.
We write d for the deprecation coordinate: whether an atom is live or deprecated. This notation separates architectures that never represent deprecation (d-blind) from those that do (d-aware), but it does not by itself justify a fine-grained ledger. Appendix A formalizes three results we use below. Proposition 1 (P1) shows that a d-blind store cannot recover the current value on a symmetric subset of revising streams that look identical without d, giving a 50% ceiling there. Proposition 2b (P2b) then shows that for snapshot, or current-state, queries the binary live/dead partition Π induced by d is a minimal sufficient statistic: once Π is known, finer relation typing carries no additional valuerelevant information (the typing benefit btype = 0). Proposition 2c (P2c) generalizes this into a querysufficiency lattice and a retention-optimal selection rule.
3
ESR-Bench and Memory Classes
ESR-Bench tests the selection criterion by holding the task fixed and varying the memory primitive. We instantiate three memory classes: GraphRAG+abstain as the d-blind GraphRAGclass control with no deprecation marker, a coarsed edge-invalidation store in the Zep/Graphiti style, 3
Tier
L1 Intra-passage (read)
L2 Cross-passage (merge / abstain)
Where the conflict lives
Evidence sketch
Contradiction appears within a single piece of text.
What must be represented
"The function is thread-safe. However, the function is not thread-safe."
Minimal capability
Both statements and their polarity; contradiction can be detected by reading.
Note
Example source: Self-contradictory note
Read
Contradictory statements occur in different sources at overlapping times.
Page A
Page B
"The API limit is 1,000 requests/day."
"The API limit is 10,000 requests/day."
Example source: Two webpages
Provenance and time to link the two statements and mark conflict; abstain if unresolved.
Merge / Abstain Conflict across sources
L3 Temporal trajectory (supersession)
A later event about the same entity-attribute invalidates an earlier one.
supersedes e1
t2
t1 e1 "Use workaround X."
Example source: Issue/commit history
supersedes e2
time
t3
e2 "Use workaround Y instead of X."
e3 "Workaround Y reverted; X again."
Legend Support
Supersession edges (deprecation) to close validity of earlier evidence; binary live/dead status; retain closed evidence only for provenance queries.
Supersession-aware (deprecation)
* Tiers are a priority ordering: apply the highest applicable tier. Contradiction
Cross-source conflict
Supersedes (deprecates)
Time / chronology
* Higher-tier representations strictly subsume lower tiers via their conflictstatus field.
Where the conflict lives determines the minimal memory capability needed.
Figure 2: Conflict locality determines memory need. Intra-passage contradictions (L1 ) can be settled by reading; cross-passage conflicts (L2 ) require provenance and valid time to associate sources and abstain when unresolved; temporal entity-state revision (L3 ) requires deprecation. Tiers are a priority ordering: the highest applicable tier’s state subsumes the lower ones through its conflict-status field. The L3 minimal capability is a binary live/dead deprecation marker, plus retention of invalidated evidence when prior values are queried, rather than the fine-grained relation typing our experiments find idle on current-state queries (§4.1, §4.3).
and RevisionLedger as the fine-d ledger with relation labels and unresolved status. Comparing within and across these classes on each stratum tests when deprecation, retention, and fine relation typing are actually needed. The benchmark is designed to expose L3 temporal entity-state revision while retaining simpler L1 and L2 probes for falsifiability. The main ESRBench version contains 2,907 QAs drawn from GitHub issue histories, multi-repo issue histories, Wikipedia revisions, and a 109-item DyKnow temporal split. Each item stores a gold answer, supporting event ids, deprecated event ids, and a phenomenon label. An auxiliary high-noise construction (a 1,198-QA huggingface/datasets GitHub split, plus smaller multi-repo and Wikipedia splits) is used only in the appendix, not for the main claims. Public probes are outside the 2,907-item main version and test no-effect predictions on adjacent settings: WikiContradict (Hou et al., 2024), FaithEval (Ming et al., 2025), DyKnow-style latestknown questions, StreamingQA-style temporal QA (Liska et al., 2022), and LongMemEval-S (Wu et al., 2024) where relevant.
decoding, a shared QA prompt template, two-pass agreement filtering, and a bilingual phenomenon classifier. This version contains 1,698 GitHub, 252 multi-repo, 848 Wiki, and 109 DyKnow QAs. The rare strata comprise 99 reverted-revert, 88 crosssource conflict, and 89 refines questions; the remaining 2,631 are monotonic. Human validation. A domain expert handvalidated a stratified N = 150 subset under the same bilingual rubric the LLM labeller saw (per-stratum agreement in Appendix). This check supports the two gold assumptions used later. First, the humanconfirmed canonical subset preserves the revertedrevert gap (∆RevisionLedger−GraphRAG+abstain = +0.304 on the 25 canonical reverted-revert items, npaired =112), and §4.1 shows that this larger canonical gap is still driven mainly by render rather than mechanism. Second, on cross-source-conflict items, human validation confirms that abstention is the correct gold behavior in 94.7% of cases, supporting the abstention-channel analysis in §4.4. Overall phenomenon-label agreement is Cohen’s κ = 0.459 (95% CI [0.366, 0.553]); disagreement is asymmetric because the LLM over-labels REVERTED - REVERT, half of which are canonically
Primary ESR-Bench version. All main experiments use DeepSeek-V4-flash with non-thinking 4
Evaluation set
Items
GitHub Wiki MultiRepo DyKnow
1,698 5 Primary 848 4+partial Primary 252 5 Primary 109 4 Primary
Primary total
2,907
n/a Primary
Auxiliary ESR split
1,198
5 Auxiliary
any ledger advantage here is that the deprecation mechanism is doing the work. We show that reading is largely wrong.
Families Role
The headline gap. Under the DeepSeek-V3 judge, RevisionLedger beats GraphRAG+abstain on the primary reverted-revert slice by +0.182 (95% CI [+0.134, +0.230], npaired =439), with positive deltas on GitHub, Wiki, and DyKnow and a tie on the tiny MultiRepo slice. The coarse-d edge-invalidation store beats GraphRAG+abstain by even more, +0.266. So on clean supersession the load-bearing primitive is plainly d-awareness, not fine typing; the coarse architecture is the better deployment choice, and fine-d RevisionLedger loses to it (Corollary 1). But +0.182 does not establish that the ledger’s deprecation mechanism, rather than its presentation, earns the advantage over the d-blind baseline.
Table 1: Main and auxiliary ESR-Bench evaluation sets. The four primary sets sum to 2,907 QAs. “Families” counts paired answer-LLM families; Wiki includes partial Mistral-7B rare-stratum follow-ups, while DyKnow omits Mistral-7B. Paired bootstrap uses B = 10,000 unless otherwise noted.
MONOTONIC.
RevisionLedger instantiates the fine-d L3 architecture: a frozen LLM extracts atoms from a closed attribute inventory, a rule scorer labels co-keyed pairs, the ledger operator maintains current/deprecated sets and unresolved status, and the answer generator sees only the rendered ledger and an event-id index. This isolates whether a richer state representation helps the same frozen LLM answer more selectively. The primary d-blind control is GraphRAG+abstain: same extracted atoms, timestamps, and abstain instruction, but no supersession edges or bitemporal state update. Additional baselines cover three failure modes: retrieval-only systems (RAG - TOP - K, direct long context), time-only heuristics (latest-only, timestamp reranking, temporal chain-of-thought), and structure without deprecation (GRAPHRAG - LITE, metadata-only). Headline semantic-correctness numbers are judged by DeepSeek-V3 (Liu et al., 2024a); abstain calibration is independent of this semantic-correctness judge because it compares binary abstain decisions to gold abstain labels. We report paired bootstrap intervals (percentile, B=10,000) preserving (question id, answer family) pairs.
4
Main Results
4.1
Most Reverted-Revert Gain Is Render, Not Fine Typing
Render-matched decomposition. To separate mechanism from presentation we add a rendermatched control: the fine-d ledger’s exact structured layout, but with the deprecation mechanism switched off, forcing every co-keyed relation to SAME - STATE so there are no supersedes, no contradicts, and no unresolved status (a d-blind system with the ledger’s layout). All four systems are judged uniformly by the gold DeepSeek-V3 judge (Liu et al., 2024a) and by an out-of-family MiniMax-M2.5 judge, and the decomposition is stable across both (Table 2). Under DeepSeek-V3 the reverted-revert gain (+0.184, matching the +0.182 headline) splits into a render term of +0.159 (render-matched control − GraphRAG+abstain) and a d-mechanism residual of only +0.025 (RevisionLedger − render-matched control), the latter indistinguishable from zero; MiniMax agrees. On the 25 human-confirmed canonical reverted-revert items, the split is starker: the render component carries essentially the entire +0.304 canonical total while the mechanism residual remains indistinguishable from zero (+0.036 [−0.027, +0.098]). The fine-d deprecation machinery adds no measurable accuracy even on the cleanest items; almost all of the ledger’s apparent edge is that its structured layout is easier for the answer-LLM to read than GraphRAG+abstain’s flat entity-attribute groupings. The one mechanism that does pay is coarse-d invalidation (+0.087 over the render-matched control), a real but coarse deprecation effect. This is the central correction of this paper: a structuredmemory comparison that does not hold render fixed
The central prediction concerns reverted-revert items: a middle event appears to contradict the current answer but is itself superseded later. GraphRAG+abstain can detect conflict, but without the supersession edge it often abstains; the fine-d ledger deprecates the middle event and answers with the surviving value. The natural reading of 5
Term
DeepSeek-V3 [95% CI]
MiniMax
Render +0.159 [+0.114, +0.207] Fine-d mech. +0.025 [−0.005, +0.057] Coarse-d mech. +0.087 [+0.046, +0.130]
+0.164 +0.021 +0.098
4.2
When, if ever, does fine-d overtake coarsed? On the clean primary reverted-revert slice the coarse store beats RevisionLedger (∆RevisionLedger−Graphiti = −0.084 [−0.128, −0.041]). An earlier reading inferred a sign flip from the contrast with a noisier auxiliary split (fine-d led by 0.090), but that contrast confounds extractor noise with annotator identity and relation-type mix. We replace it with a controlled relation-noise sweep: holding dataset, judge, and answer model fixed, we corrupt each predicted relation to a random other label with probability p, identically in both arms. Across p ∈ {0, . . . , 0.5} and five families (n=445/level), the arms tie at clean signal on the sweep coverage (∆ = −0.016, n.s.) and every positive noise level still has a coarse-d point-estimate lead (Appendix Figure 5; Appendix C). The relation-noise curve is neither monotone in p nor sign-flipping, falsifying Appendix Proposition 4’s monotone-crossover prediction (C3) on the axis it names. We also test the extraction axis directly, dropping each atom with probability p (recall loss, the dominant extractor failure) identically in both arms. With the same n=445/level, coarse-d still leads or ties at every tested level (Appendix Table 13). Neither the relation-scoring nor the extraction axis yields a tested regime where fine grain wins; we do not claim every conceivable noise process is covered. Coarse d-awareness is the right granularity here, the simplicity-under-clean-signal pattern (Laitenberger et al., 2025) specialized to bitemporal memory.
Table 2: Most of the fine-ledger gain is render. Rendermatched decomposition (Render = render-matched control − GraphRAG+abstain; fine-d mech. = RevisionLedger − control; coarse-d mech. = Graphiti − control). The render term dominates; the fine-d mechanism residual is indistinguishable from zero (CI crosses 0); only coarse-d invalidation adds a real but small effect. The out-of-family MiniMax-M2.5 judge agrees, so the split is not a single-judge artifact.
Stratum (query)
Coord. in R?
Typed mech. residual
After recovery
reverted-revert (snapshot) monotonic (snapshot) REFINES (granularity) CSC (status)
no (Π only) no (Π only) yes yes
+0.025 (n.s.) −0.003 (n.s.) +0.009 (n.s.) −0.008 (n.s.)
n/a n/a +0.147a +0.152b
Controlled Noise Does Not Recover a Fine-d Advantage
Table 3: Fine typing pays only when the queried coordinate is recovered. The typed-mechanism residual is RevisionLedger minus the render-only control under the same scorer and prompt; it is statistically zero on every stratum. Where the answer reads a coordinate of R that Π collapses, recovering that coordinate then pays: a a learned scorer on REFINES, b a strict-prompt decode on CSC . There is no analogue on snapshot queries, where btype = 0 makes the signal provably absent.
will misattribute a presentation effect to its mechanism.
Why Fine Typing Is Idle on Snapshot and Where It Pays. Proposition 2b makes the render result coherent and predicts it generalizes: the typed mechanism residual (RevisionLedger − renderonly) is statistically zero on all four strata (Table 3). On snapshot queries this is forced: Π is sufficient, so btype = I(v ⋆ ; R | Π, values) = 0. But the theorem is query-relative: where the answer reads a relation coordinate that Π collapses, recovering it pays, as shown by a learned scorer on REFINES and a strict-prompt decode on CROSS - SOURCE CONFLICT (Table 3). There is no analogue on snapshot queries, where the signal is provably absent from R beyond Π. Typed structure pays only when the query reads a coordinate of R that Π collapses and that coordinate is recovered: the bitemporal current-value/provenance distinction, made quantitative.
4.3
Provenance Requires Retention, Not Fine Typing
The provenance result is a retention threshold, not a fine-typing win. The sufficiency lattice (Proposition 2c) is two-sided: if the binary partition is sufficient for snapshot queries, it must be insufficient for queries that read what it discards. We test the sharpest such case, a provenance query: “what value was in force immediately before the current one?” We construct 979 such queries whose gold prior value comes from the benchmark’s own gold_deprecated_event_ids (independent of any system’s scorer), and present each architecture with only its retained state (no rawevent fallback). Pooled over five answer-LLM 6
0.8
iting it to typing would be the snapshot-side error in reverse. The honest residual is fine − retain = +0.111 [+0.097, +0.125], significant but a fraction of +0.472, and plausibly itself presentation, since fine-d hands the reader a pre-ordered prior history while retention-coarse-d hands back unordered timestamped edges to sort. The out-offamily MiniMax-M2.5 judge agrees that the residual is small, +0.063 on its shared subset.
provenance accuracy
0.715 0.604
0.6 0.439
0.4 0.243
0.2
0.0 coarse-d (discard)
d-blind
coarse-d (retain)
Deployment renders can reverse the provenance residual. The provenance effect is memoryconstrained: using each system’s deployed render (raw-event text appended) reverses the sign, with fine-d at 0.311, coarse-d at 0.546, d-blind at 0.610, and fine − coarse = −0.236 [−0.250, −0.221], because the heavier ledger render now hurts the reader, the same render effect as §4.1 with opposite sign. We therefore do not claim typed relations decisively win provenance; we claim retention is necessary, coarse retention captures most of it, and even the residual narrows to presentation. The regime where retention matters at all is the one memory architectures are built for: compressed state under a retention budget, such as on-device, privacy-constrained, or cost-capped deployments that cannot keep the raw stream. The retention threshold replicates on external TempLAMA, with Wikidata gold, exact-match, and no LLM judge, where a discarding store falls to floor accuracy and retention recovers +0.514; Appendix D gives the full ordering, and DyKnow n=11 concurs.
fine-d
Figure 3: Provenance needs retention, not typing. Accuracy on provenance queries (“what value held just before?”) from retained state only, pooled over five answer-LLM families (DeepSeek judge, n=4,895). A coarse store that discards closed edges cannot answer the prior-value query; retaining them, whether coarse or fine, restores answerability. The fine-d bar is therefore an apparent edge over discard, not evidence that fine relation typing is the causal ingredient.
families (n=4,895, DeepSeek judge; an out-offamily MiniMax-M2.5 judge reproduces the ordering), a coarse-d that discards closed edges fails, while any store that retains closed edges with their invalid_at windows, whether coarse or fine, clears the threshold (Figure 3). Fine-d is highest in this state-only diagnostic, but the visual ordering should be read as answerability once prior state is retained, not as evidence that relation labels are the cause. The reason is information-theoretic: a store that discards superseded values cannot answer because the prior value is absent from its state. Retention repairs that missing state. This is the dual of §4.1: there fine-d’s extra state was wasted (btype = 0); here the missing state is fatal, but what repairs it is retention, not granularity.
4.4
Boundary Strata: Typed Gains Require Coordinate Recovery
The CSC and REFINES recovery gains (+0.152, +0.147; Table 3) are not render-matched and so upper-bound the mechanism contribution. The same strict-abstain prompt does not move GraphRAG+abstain (+0.006, n.s.), and a learned scorer flips REFINES from −0.086 to +0.147, with both queries reading a coordinate that Π collapses (Proposition 2b; Appendix Table 5). On MONOTONIC, the RevisionLedger − GraphRAG + abstain gap is larger on items carrying deprecated evidence (+0.073 vs +0.049 on the pure-no-revision half), yet even that pure half is mostly render: a SAME - STATE ablation already beats GraphRAG+abstain by +0.027 with full RevisionLedger adding only +0.022, the same renderover-mechanism split as reverted-revert.
What this does and does not credit to fine-d. The apparent fine-d provenance win is +0.472 [+0.455, +0.489] over a discarding coarse store, whose accuracy is 0.243. But real edgeinvalidation memories (Zep/Graphiti) do not discard: they stamp a superseded edge invalid_at and keep it. A faithful retention-coarse-d keeps closed edges with their windows but uses no typed relations; it scores 0.604, closing +0.361 [+0.344, +0.377] of that gap. Most of the apparent provenance win was therefore a discard modeling choice, not a property of the coarse-d class; cred7
5
Related Work
(Su et al., 2024). Our tiers are orthogonal to the residence-based taxonomy of Xu et al. (2024) (context vs. parametric vs. intra-memory): we partition retrieved evidence by spatiotemporal locality. The L3 case, where resolution lives in a supersession edge and an earlier claim remains useful for provenance, has no clean analogue in those benchmarks. ESR-Bench is therefore a vehicle for testing architecture selection under revision, not primarily another conflict benchmark. Our path-recall decomposition (Appendix Propositions 4–5) is closest in spirit to empirical RAGerror taxonomies (Leung et al., 2026), but uses oracle substitutions to localize which pipeline stage loses the decision-relevant signal. This is a diagnostic use of the causal-probing style (Didelez and Pigeot, 2001; Vig et al., 2020), not a controlled-directeffect claim. The state primitives are older than agent memory: belief update (Katsuno and Mendelzon, 1992; Alchourrón et al., 2016; Konieczny and Pérez, 2002) and valid-time databases (Snodgrass, 1999; Date et al., 2003) already distinguish current state from history, while selective classification and conformal risk control frame the unresolvedconflict abstention channel (Pugnana and Ruggieri, 2023; Angelopoulos et al., 2024; Xu et al., 2025).
Temporal graph memories already implement part of the state we study. Zep/Graphiti (Rasmussen et al., 2025), for example, closes an edge’s validity window when a newer edge supersedes it, which is a coarse-d implementation in our taxonomy. Our concern is not whether such systems are useful, but how their gains are attributed. Published comparisons of structured memory against flat baselines often give the structured system a distilled, reorganized fact set while giving the baseline raw chunks or the full transcript (Zep vs. MemGPT/fullcontext (Rasmussen et al., 2025); Mem0 vs. fullcontext and RAG (Chhikara et al., 2025)). Because mechanism and prompt presentation then co-vary, and because LLMs are sensitive to context layout and length (Liu et al., 2024b; Cuconasu et al., 2024), those comparisons do not by themselves establish which part of the architecture did the work. Our render-matched control isolates that attribution question. Recent memory systems map onto the design points our criterion distinguishes, rather than forming a single leaderboard. Write-time reconciliation and supersession handlers such as WorldDB and Zep/Graphiti sit at the coarse-d point (Ganesan, 2026; Rasmussen et al., 2025); our snapshot results predict that this point is already sufficient, provided invalidated evidence is retained when provenance is queried. Typed temporal memories add relation structure (Abtahi et al., 2026), while versioned-graph accounts give belief-revision semantics for fixed memory graphs (Park, 2026); our criterion assigns that extra structure value only for queries that read type or status coordinates. Routing systems choose among memory paths inside a fixed architecture (Hu et al., 2026; McKee, 2026), while privacy-aware forgetting work varies the retention budget on the storage frontier (Alqithami, 2025). ArbGraph (Niu et al., 2026) targets pregeneration conflict arbitration, closer to our L2 unresolved-conflict tier than to L3 temporal supersession. Their mechanisms are complementary; the missing layer is selection and attribution: when a retained statistic is necessary, when it is idle, and whether an observed gain is mechanism or render. Knowledge-conflict benchmarks study contradictions between context and parametric memory (Xu et al., 2024; Xie et al., 2024), between retrieved passages (Hou et al., 2024; Li et al., 2024), within passages (Ming et al., 2025), and by cause
6
Conclusion
Evidence-State Revision turns memory selection into a query-sufficiency question. Whether a task needs deprecation-aware memory is governed by where the conflict lives and what the query asks: P1 gives streams on which no d-blind architecture beats a 50% ceiling, P2b shows that binary live/dead state is sufficient for current-state queries, and P2c generalizes these facts into a query-sufficiency lattice with a retention-optimal selection rule. The experiments match this lattice. On snapshot questions, coarse-d matches or beats fine-d, and the render-matched ablation attributes the fine ledger’s apparent edge to layout; on provenance, the missing primitive is retention, not finer relation typing. The retention conclusion also replicates on external Wikidata-gold TempLAMA with exact-match scoring and no LLM judge (Appendix D). The practical rule is exactly the lattice’s selection rule: deploy the coarsest retained state that covers the query mixture. Two consequences follow. First, memoryarchitecture evaluations should hold render fixed, because a structured store’s apparent edge over a 8
flat baseline can be a reading-ease effect rather than mechanism, as our own headline number turned out to be. We specify the render-matched control as a reusable protocol (§F) so future comparisons can separate layout from mechanism. Second, the “best memory system” question is ill-posed without a stream prior and a query distribution. Our criterion catches two opposite errors: over-building typed history for current-state queries, where P2b makes it idle, and under-building by retrieving a revising stream with no supersession tracking, capped by P1’s ceiling. Concurrent agent-memory work (Park, 2026; Hu et al., 2026) optimizes inside a fixed class; ESR asks which class is necessary in the first place.
audit trails by surfacing deprecated evidence, but rule-derived supersession labels should not be read as human ground truth; we report unresolvedconflict abstention and deprecated-evidence provenance with every ledger row. Human validation (§3) was performed by a domain expert on public technical and revision records, not on private individuals, and releases no annotator personal data.
Limitations Generalization. Our central reading has two separable parts: presentation explains much of the fineledger’s apparent advantage, and retention, not relation granularity, is the state a discarding store lacks for provenance; coarse deprecation remains the load-bearing mechanism for non-monotone currentstate queries. This claim is established on a single architecture family (a fine-d ledger, a coarse-d invalidation store, and a d-blind baseline sharing one atom pipeline) and primarily one self-built benchmark; TempLAMA gives an external check for the retention result, but not for the high-clutter prose setting where the render confound is most consequential. The natural cross-family check—an independently implemented graph memory tested against a ledger under a render-matched control— remains future work. LLM judges and label noise. Semanticcorrectness scoring relies on LLM judges, and the phenomenon labels carry only moderate human agreement (Cohen’s κ = 0.459), so per-stratum effects are noisy. We mitigate this with two independent strong-judge families that agree on the near-zero fine-d mechanism residual (§4.1) and by replicating the retention threshold on external TempLAMA (Wikidata gold, exact-match, no LLM judge; Appendix D); residual cross-judge and label noise on the rarer strata nonetheless remains. Oracle assumptions and faceted state. The sufficiency results (P2a/P2b) assume exact extraction, exact co-keying, and single-valued keys; in practice our extractor misses roughly one gold-relevant event in seven (Appendix F, “Extractor coverage”), so the reported gains are net of that loss. The singlevalued-key assumption is the most consequential: faceted state, where a value depends on platform or version, needs a finer composite key and falls outside the current scope, with per-facet ledgers the natural extension. Theory scope and an evaluation gap. The channel benefit-cost identity’s one predictive sign
Ethics Statement Data minimization. The benchmark is built from public GitHub issue threads and Wikipedia revisions, which can carry usernames and incidental personal information even when publicly accessible. We therefore release only derived, privacyminimized material: event IDs, atom-level extractions, gold labels, and source URLs, but never raw thread or revision text. Before release we strip verbatim source spans and actor fields, scrub residual user handles, bare contributor names, and personal URL paths from free-text and extracted fields, and scan for personal data and credentials (emails, API keys and tokens, IP addresses, credential-like identifiers). Because the source URLs let auditors re-fetch the upstream text, the release is retraceable rather than fully anonymized; we remove items from the index on upstream deletion, license change, or removal request. The released examples are derived extractions of public content, not verbatim user text. Dual use and retention. Two risks are intrinsic to the mechanism, not the data. First, supersessionaware state tracking is dual-use: applied to people rather than software facts, the same machinery profiles how an individual’s stated attributes change over time, so deployments over personal data warrant access controls. Second, the retention our provenance results favour for accuracy is in tension with data minimization and the right to be forgotten: a store that keeps invalidated evidence remembers more about prior states; deployments should bound retention and propagate deletions into the ledger. Use and validation. The method can improve 9
claim (a noise-driven fine-vs-coarse sign flip) is falsified on our data (Appendix C); we therefore use it only as diagnostic bookkeeping, and the granularity conclusion rests on the render-matched decomposition (§4.1) and Corollary 1. This benchmark limitation is partly structural: the field lacks a public benchmark for high-clutter real revision streams with human gold, the regime where the render confound is both measurable and most consequential. We flag this as a field-level evaluation gap that this work motivates.
Christopher John Date, Hugh Darwen, and Nikos A Lorentzos. 2003. Temporal data & the relational model. Morgan Kaufmann. Bhuwan Dhingra, Jeremy R Cole, Julian Martin Eisenschlos, Daniel Gillick, Jacob Eisenstein, and William W Cohen. 2022. Time-aware language models as temporal knowledge bases. Transactions of the Association for Computational Linguistics, 10:257– 273. Vanessa Didelez and Iris Pigeot. 2001. Causality: models, reasoning, and inference. Darren Edge, Ha Trinh, Newman Cheng, Joshua Bradley, Alex Chao, Apurva Mody, Steven Truitt, Dasha Metropolitansky, Robert Osazuwa Ness, and Jonathan Larson. 2024. From local to global: A graph rag approach to query-focused summarization. arXiv preprint arXiv:2404.16130.
References Seyed Moein Abtahi, Rasa Rahnema, Hetkumar Patel, Neel Patel, Majid Fekri, and Tara Khani. 2026. Memanto: Typed semantic memory with informationtheoretic retrieval for long-horizon agents. arXiv preprint arXiv:2604.22085.
Ran El-Yaniv and 1 others. 2010. On the foundations of noise-free selective classification. Journal of Machine Learning Research, 11(5).
Carlos E. Alchourrón, Peter Gärdenfors, and David Makinson. 2016. On the Logic of Theory Change: Partial Meet Contraction and Revision Functions, pages 195–217. Springer International Publishing, Cham.
Vojtech Franc, Daniel Prusa, and Vaclav Voracek. 2023. Optimal strategies for reject option classifiers. Journal of Machine Learning Research, 24(11):1–49.
Saad Alqithami. 2025. Forgetful but faithful: A cognitive memory architecture and benchmark for privacy-aware generative agents. arXiv preprint arXiv:2512.12856.
Harish Santhanalakshmi Ganesan. 2026. Worlddb: A vector graph-of-worlds memory engine with ontology-aware write-time reconciliation. arXiv preprint arXiv:2604.18478.
Anastasios Angelopoulos, Stephen Bates, Adam Fisch, Lihua Lei, and Tal Schuster. 2024. Conformal risk control. In International conference on learning representations, volume 2024, pages 55198–55218.
Bernal J Gutiérrez, Yiheng Shu, Yu Gu, Michihiro Yasunaga, and Yu Su. 2024. Hipporag: Neurobiologically inspired long-term memory for large language models. Advances in neural information processing systems, 37:59532–59569.
Nontawat Charoenphakdee, Zhenghang Cui, Yivan Zhang, and Masashi Sugiyama. 2021. Classification with rejection based on cost-sensitive classification. In International Conference on Machine Learning, pages 1507–1517. PMLR.
Yufang Hou, Alessandra Pascale, Javier CarnereroCano, Tigran Tchrakian, Radu Marinescu, Elizabeth Daly, Inkit Padhi, and Prasanna Sattigeri. 2024. Wikicontradict: A benchmark for evaluating llms on real-world knowledge conflicts from wikipedia. Advances in Neural Information Processing Systems, 37:109701–109747.
Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. 2025. Mem0: Building production-ready ai agents with scalable long-term memory. arXiv preprint arXiv:2504.19413.
Jennifer Hsia, Afreen Shaikh, Zhiruo Wang, and Graham Neubig. 2024. Ragged: Towards informed design of scalable and stable rag systems. arXiv preprint arXiv:2403.09040.
Chi-Keung Chow. 1957. An optimum character recognition system using decision functions. IRE Transactions on Electronic Computers, (4):247–254.
Tianyu Hu, Weikai Lin, Weizhi Zhang, Jing Ma, and Song Wang. 2026. Memrouter: Memoryas-embedding routing for long-term conversational agents. arXiv preprint arXiv:2605.00356.
Thomas M Cover. 1999. Elements of information theory. John Wiley & Sons. Florin Cuconasu, Giovanni Trappolini, Federico Siciliano, Simone Filice, Cesare Campagnano, Yoelle Maarek, Nicola Tonellotto, and Fabrizio Silvestri. 2024. The power of noise: Redefining retrieval for rag systems. In Proceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval, pages 719–729.
Hirofumi Katsuno and Alberto O. Mendelzon. 1992. On the difference between updating a knowledge base and revising it, page 183–203. Cambridge Tracts in Theoretical Computer Science. Cambridge University Press.
10
Polina Kirichenko, Mark Ibrahim, Kamalika Chaudhuri, and Samuel J Bell. 2026. Abstentionbench: Reasoning llms fail on unanswerable questions. Advances in Neural Information Processing Systems, 38.
Qingying Niu, Yuhao Wang, Ruiyang Ren, Bohui Fang, and Wayne Xin Zhao. 2026. Arbgraph: Conflict-aware evidence arbitration for reliable longform retrieval-augmented generation. arXiv preprint arXiv:2604.18362.
Sébastien Konieczny and Ramón Pino Pérez. 2002. Merging information under constraints: a logical framework. Journal of Logic and computation, 12(5):773–808.
Charles Packer, Vivian Fang, Shishir_G Patil, Kevin Lin, Sarah Wooders, and Joseph_E Gonzalez. 2023. Memgpt: towards llms as operating systems. ArXiv. Young Bin Park. 2026. Graph-native cognitive memory for ai agents: Formal belief revision semantics for versioned memory architectures. arXiv preprint arXiv:2603.17244.
Alex Laitenberger, Christopher D Manning, and Nelson F Liu. 2025. Stronger baselines for retrievalaugmented generation with long-context language models. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 32547–32557.
Andrea Pugnana and Salvatore Ruggieri. 2023. Aucbased selective classification. In International conference on artificial intelligence and statistics, pages 2494–2514. PMLR.
Kin Kwan Leung, Mouloud Belbahri, Yi Sui, Alex Labach, Xueying Zhang, Stephen Anthony Rose, and Jesse C Cresswell. 2026. Classifying and addressing the diversity of errors in retrieval-augmented generation systems. In Proceedings of the 19th Conference of the European Chapter of the Association for Computational Linguistics (Volume 1: Long Papers), pages 3185–3207.
Preston Rasmussen, Pavlo Paliychuk, Travis Beauvais, Jack Ryan, and Daniel Chalef. 2025. Zep: a temporal knowledge graph architecture for agent memory. arXiv preprint arXiv:2501.13956. Richard Thomas Snodgrass. 1999. Developing timeoriented database applications in SQL. Morgan Kaufmann Publishers Inc.
Jierui Li, Vipul Raheja, and Dhruv Kumar. 2024. Contradoc: Understanding self-contradictions in documents with large language models. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 6509–6523.
Zhaochen Su, Jun Zhang, Xiaoye Qu, Tong Zhu, Yanshu Li, Jiashuo Sun, Juntao Li, Min Zhang, and Yu Cheng. 2024. Conflictbank: A benchmark for evaluating the influence of knowledge conflicts in llm. arXiv preprint arXiv:2408.12076. Naftali Tishby, Fernando C Pereira, and William Bialek. 2000. The information bottleneck method. arXiv preprint physics/0004057.
Adam Liska, Tomas Kocisky, Elena Gribovskaya, Tayfun Terzi, Eren Sezener, Devang Agrawal, Cyprien De Masson D’Autume, Tim Scholtes, Manzil Zaheer, Susannah Young, and 1 others. 2022. Streamingqa: A benchmark for adaptation to new knowledge over time in question answering models. In International Conference on Machine Learning, pages 13604–13622. PMLR.
Jesse Vig, Sebastian Gehrmann, Yonatan Belinkov, Sharon Qian, Daniel Nevo, Yaron Singer, and Stuart Shieber. 2020. Investigating gender bias in language models using causal mediation analysis. Advances in neural information processing systems, 33:12388– 12401.
Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, and 1 others. 2024a. Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437.
Kaiyang Wan, Lang Gao, Honglin Mu, Preslav Nakov, Yuxia Wang, and Xiuying Chen. 2025. A fano-style accuracy upper bound for llm single-pass reasoning in multi-hop qa. arXiv preprint arXiv:2509.21199.
Nelson F Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. 2024b. Lost in the middle: How language models use long contexts. Transactions of the association for computational linguistics, 12:157–173.
Di Wu, Hongwei Wang, Wenhao Yu, Yuwei Zhang, Kai-Wei Chang, and Dong Yu. 2024. Longmemeval: Benchmarking chat assistants on long-term interactive memory. arXiv preprint arXiv:2410.10813. Jian Xie, Kai Zhang, Jiangjie Chen, Renze Lou, and Yu Su. 2024. Adaptive chameleon or stubborn sloth: Revealing the behavior of large language models in knowledge conflicts. In International Conference on Learning Representations, volume 2024, pages 35623–35646.
Matthew McKee. 2026. Selroute: Query-type-aware routing for long-term conversational memory retrieval. arXiv preprint arXiv:2604.02431. Yifei Ming, Senthil Purushwalkam, Shrey Pandit, Zixuan Ke, Xuan-Phi Nguyen, Caiming Xiong, and Shafiq Joty. 2025. Faitheval: Can your language model stay faithful to context, even if" the moon is made of marshmallows". In International Conference on Learning Representations, volume 2025, pages 29430–29456.
Rongwu Xu, Zehan Qi, Zhijiang Guo, Cunxiang Wang, Hongru Wang, Yue Zhang, and Wei Xu. 2024. Knowledge conflicts for llms: A survey. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 8541–8565.
11
we compare against: every system in AEK+Tv in our experiments (LATEST- ONLY, GRAPHRAG - LITE, GraphRAG+abstain) is deterministic in its retrievaltime decision rule. A randomized extension of AEK+Tv that A BSTAINs with probability p ∈ (0, 1) on detected inconsistency does not match ABTL either, but for the weaker reason that it loses correctness in expectation rather than per-instance; we state and prove the deterministic case because it is the empirically relevant one and because it admits the cleaner pointwise statement. The underlying obstruction is pointwise non-recoverability: d is not a function of (E’s values, Tv ), so an architecture restricted to that surface is information-theoretically blocked from recovering it pointwise. This is the same structure as an omitted-variable obstruction; the term “identifiability” is reserved in causal inference for parameter recovery from a distribution, which is not what is at stake here. Only access to d resolves the ambiguity. Converse (characterization). The obstruction is confined to the non-monotone temporal part of L3 . Define the monotone sub-class Lmono : for 3 every key, the d-non-deprecated atom subset is value-consistent and its supersession edges respect valid-time order (no retroactive correction, no cokeyed unresolved residual). On Lmono the snap3 shot value equals the latest-Tv value, so LATESTONLY ∈ AEK+Tv matches ABTL exactly. Hence the d-blind class is provably sub-optimal only when a temporal deprecation fact is needed but absent from the surface view: resolved reverted-revert cases such as (I), or co-keyed temporal residual conflicts such as (II). Pure cross-source disagreement with no temporal supersession edge is an L2 /U -channel abstention case rather than a P1 necessity result. This is the temporal-database fact that a one-dimensional (valid-time-only) representation reconstructs a two-dimensional (bitemporal) one iff transaction time is monotone in valid time (Snodgrass, 1999; Date et al., 2003), specialized to the QA setting. Proposition 1 therefore characterizes which temporal items require a bitemporal store, not merely that the class as a whole does. Render invariance. Both AEK+Tv and ABTL are defined by what information their decision function reads ({values, Tv } versus {values, Tv , d}), not by how that information is serialised for a downstream LLM. The separation therefore holds for any ledger render: changing the serialisation changes the answer-LLM’s per-instance success rate (the αrender term defined in Proposition 3 be-
Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan, and Yongfeng Zhang. 2026. A-mem: Agentic memory for llm agents. Advances in Neural Information Processing Systems, 38:17577–17604. Yunpeng Xu, Wenge Guo, and Zhi Wei. 2025. Selective conformal risk control. arXiv preprint arXiv:2512.12844.
A
Proofs
Proposition 1 (non-monotonic supersession separation). Setup. Fix a key (x, a) with event set E, each event carrying a value and a valid time Tv . Let AEK+Tv be the class of deterministic architectures whose decision is a function of E’s values and valid times only — not of the deprecation marker d. This subsumes LATEST- ONLY (output the value of arg maxe Tv (e)), GRAPHRAG - LITE (output some value, never A BSTAIN), and GraphRAG+abstain (detect value-inconsistency, then A BSTAIN or pick a Tv -tie-breaker). The bitemporal ledger ABTL additionally reads d and applies ⊕ (§2). The L3 ground truth for (x, a) is the value supported by the maximal d-non-deprecated subset of E, or A BSTAIN if that subset is value-inconsistent. Claim (deterministic separation). No deterministic A ∈ AEK+Tv matches ABTL on all L3 instances. Proof. Take the surface configuration E = {e1 :ϕ@t1 , e2 :¬ϕ@t2 , e3 :ϕ@t3 } with t1 < t2 < t3 (Figure 4), and two ground-truth-distinct instances over it: (I) dI = {(e3 , e2 )}: e3 reverts e2 . The maximal non-deprecated subset is {e1 , e3 }, valueconsistent on ϕ ⇒ L3 truth = ϕ. (II) dII = ∅: no deprecation. The maximal non-deprecated subset is {e1 , e2 , e3 }, value-inconsistent (ϕ vs ¬ϕ) ⇒ L3 truth = A BSTAIN. E, its values, and its valid times are identical across (I) and (II); only d differs. By definition, every deterministic A ∈ AEK+Tv has A(I) = A(II). But the ground truths differ (ϕ ̸= A BSTAIN), so A is wrong on at least one of the two. ABTL reads d and applies ⊕, returning ϕ on (I) and A BSTAIN on (II): correct on both. Hence no deterministic A ∈ AEK+Tv matches ABTL on the full L3 class. □ Why this is not vacuous. The construction shows the gap is not closable by any Tv -based decision rule — not just that a particular baseline fails. The deterministic restriction is essential and not stronger than the empirical baselines 12
P1/P2b illustration on a three-event chain
1
Shared event chain
2
Structured ledger with binary status
Flat (unstructured) store
𝑡₁
𝑡₂
𝑡₃
𝑒₁: 𝜙 𝑒₁: 𝜙
𝑒₂: ¬𝜙
Binary d-aware view
3
d-blind view
𝑒₂: ¬𝜙
𝑒₃: 𝜙
same evidence,
𝑒3 : 𝜙 Competing current candidates
Q: What is currently in force?
different state representation
Time
Event
Content
d (status)
𝑡₁
𝑒₁
𝜙
LIVE
𝑡₂
𝑒₂
¬𝜙
DEAD
𝑡₃
𝑒₃
𝜙;
LIVE
supersedes e2
P1: without d, the store cannot represent which earlier event was deprecated.
P2b: for snapshot queries, the binary live/dead partition is sufficient; finer relation typing is unnecessary.
Cannot Know: 𝜙 or ABSTAIN
Answer: ϕ
A single binary deprecation bit is enough for current-value queries. The crucial information is which evidence is live vs dead, not a finer supersession label.
Figure 4: A binary live/dead marker is enough for current-value queries (P1/P2b). On the three-event chain e1 :ϕ, e2 :¬ϕ, e3 superseding e2 , a d-blind store cannot represent which earlier event was deprecated, so it cannot distinguish this resolved revert from an unresolved conflict and must give the same answer to both surfaces (P1, necessity). A store that records only binary live/dead status marks e2 dead and returns the surviving value ϕ; finer relation typing is unnecessary for snapshot queries once the live/dead partition is known (P2b). The crucial information is which evidence is live versus dead, not a finer supersession label.
low) but not which instances the architecture can in principle distinguish. A render-format ablation thus cannot falsify this proposition or Proposition 2a; it can only move αrender .
pirical test in this benchmark.
Empirical scope. In the primary ESR-Bench version, instance (I) is represented by the strict REVERTED - REVERT stratum (n = 99 QAs before family expansion). The empirical CROSS SOURCE - CONFLICT stratum (n = 88 QAs) is an L2 /U stress test: most examples ask for abstention over unresolved sources, not for temporal deprecation recovery. The architectures separate as P1 predicts on the deprecation channel (§4.1: d-aware systems beat GraphRAG+abstain on strict reverted-revert), while the csc outcome is governed by Proposition 4’s unresolved-gate recall. We conjecture an analogous separation holds for the transaction-time-inversion sub-case (retroactive corrections where Tv (ea ) < Tv (eb ) but Tt (ea ) > Tt (eb )), constructible with a three-event surface in which the discriminator is Tt -ordering rather than d. We do not state this formally here because ESR-Bench-GitHub timestamps are interpolated from created_at/closed_at, leaving Tt ≡ Tv on every item, so the case admits no em-
Fix the d-ambiguous fibre: surface configurations σ = (values, Tv ) realisable by at least two deprecation assignments that induce distinct L3 truths (the construction above shows the fibre is non-empty, and the strict REVERTED - REVERT stratum is built to populate it). A deterministic d-blind architecture emits a single answer per σ, so on the fibre its accuracy cannot exceed the Bayes ceiling of predicting the truth from σ alone, Eσ [maxy Pr(truth = y | σ)]; equivalently its error is at least the conditional Bayes error Eσ [1 − maxy Pr(truth = y | σ)] > 0. The ceiling value depends on the prior over d on the fibre; under the symmetric prior of the (I)/(II) construction — revert and no-revert equally likely given σ — maxy Pr(truth = y | σ) = 21 , so no d-blind architecture exceeds 50% on that fibre while ABTL reaches 100%.
Quantitative ceiling. P1 is pointwise, but it also implies a distribution-level accuracy ceiling that no d-blind architecture can break.
We can put an empirical anchor on this prior. On the human-validated subset (§3), of the 76 adjudicated items the LLM flagged as surface-ambiguous 13
REVERTED - REVERT — the stratum built to populate the fibre — a human found exactly 38 to be canonical reverts and 38 canonically non-reverts (predominantly MONOTONIC), an empirical fibre prior of 0.50. The symmetric 50% ceiling is therefore not a worst-case idealization but close to the realized prior on the stratum that instantiates the fibre, so the d-blind Bayes ceiling on it is ≈ 21 rather than something the data render vacuous. The bitemporal store does not merely help: it lifts a hard 12 accuracy ceiling that no amount of Tv -reasoning, retrieval, or decoding can raise. This is the QA-recoverability analogue of informationtheoretic single-pass accuracy bounds (Wan et al., 2025), with d playing the role of the missing bits. We emphasize the 50% figure is the symmetricfibre ceiling, a theoretical statement; the measured pooled GraphRAG+abstain accuracy on strict reverted-revert (0.226) sits below every d-aware system, which is consistent with (but does not by itself prove) operating under the ceiling — 0.226 < 0.5 also reflects extraction noise and the empirical d-prior, which we do not disentangle here. The ceiling concerns the deprecation benefit b; it does not bound the implementation cost κ that determines whether fine-grained machinery is worth deploying (Corollary 1, and the render-matched decomposition of §4.1 showing b for fine-grained typing is empirically near zero on this benchmark).
facets are handled by refining the key; if the extractor fails to do so, P2a no longer applies. Proof. Induction on the event sequence for a fixed key. Let Mt be the active set after t events: all atoms not deprecated by any observed later atom under d; the deprecated set is its complement. The oracle ⊕ is defined extensionally by maintaining this active set and recomputing status from it after each transaction, not by preserving any pathdependent status flag. Base: a single atom a gives M1 = {a}, deprecated = ∅, and status = ok. Step: assume the invariant “support = Mt , deprecated = Et \ Mt , and status is unresolved iff Mt is value-inconsistent at the chosen granularity.” For an incoming atom a′ , functional acyclic deprecation and transaction-order application make the following active-set cases exhaustive: • a′ deprecates one or more active atoms B ⊆ Mt : ⊕ moves every b ∈ B to deprecated and inserts a′ , so Mt+1 = (Mt \ B) ∪ {a′ }. If the removed atoms carried the only conflict, recomputation clears unresolved; if disagreement remains, it stays unresolved. • a′ is same-state with the active atoms at the chosen granularity: ⊕ adds a′ to support, so Mt+1 = Mt ∪ {a′ } remains value-consistent. • a′ refines an active atom at finer grain: by assumption (iv), the chosen key granularity has already been refined enough for the facet to be single-valued; ⊕ either adds the finergrain support to that refined key or leaves the broader key’s value unchanged. The active-set invariant is preserved at the chosen granularity.
Proposition 2a (oracle sufficiency). Statement. Suppose (i) atom extraction is exact (every event yields its true (x, a, v, π, Tv ) tuples, no spurious ones), (ii) co-keying is exact (atoms about the same entity-attribute share a key), (iii) the deprecation marker d is complete and sound, (iv) each key is single-valued at the chosen granularity, and (v) deprecation edges are functional, acyclic, and applied in transaction order. Then for every key (x, a) the ledger update ⊕ returns the currentvalid-time snapshot value — defined as the value supported by the maximal d-non-deprecated atom subset for that key, or A BSTAIN if that subset is value-inconsistent (the current-snapshot semantics of valid-time databases, in the tradition of Snodgrass, 1999; cf. Date et al., 2003).1 Multi-valued
• a′ is not deprecated, deprecates no active atom, and disagrees with at least one active value: Mt+1 = Mt ∪ {a′ } is valueinconsistent, so ⊕ sets status=unresolved. At the last event the invariant gives exactly the snapshot value (or A BSTAIN). □ Grounding: the ledger is a belief-update operator. P2a is not an ad-hoc construction but the specialization of a known representation result. The ⊕ operator is not AGM revision (Alchourrón et al., 2016) — incorporating new information about a static world — but Katsuno–Mendelzon update (Katsuno and Mendelzon, 1992): each event reports that the entity’s state has changed, and ⊕ moves the maintained model to the post-event state.
1
In strict Jensen–Snodgrass usage, “bitemporal” requires a (Tv , Tt ) tuple per fact. We use “bitemporal” throughout the paper in the looser temporal-graph-RAG sense (valid time plus an explicit deprecation marker), retaining the term because it is established in the memory-systems literature we compare against (Zep/Graphiti, etc.).
14
KM’s representation theorem characterizes the operators satisfying update postulates U1–U8 as exactly those induced by a family of faithful partial pre-orders, each event mapping every model to the closest models consistent with it. The supersedesedge update (install the new value, deprecate the prior support) is this closest-state update under the recency pre-order (the newest consistent atom is closest), and the unresolved-status routing is KM’s disjunctive case where two incomparable closest states survive (hence A BSTAIN). P2a’s snapshotcorrectness is then U1–U8 specialized to singlevalued keys, placing the ledger in the belief-update lineage rather than re-deriving it; it also locates our contribution precisely against concurrent Park (2026), who give an AGM-revision correspondence for a fixed versioned graph, whereas the update reading is what an evolving entity-state stream (L3 ) actually requires and is what makes coarse-d invalidation (a single faithful pre-order) already sufficient.
Proof. By P2a the snapshot value is the value supported by the live set M = {e : Πe = 1}, or A BSTAIN if M is value-inconsistent; thus v ⋆ = g(Π, values) for the deterministic read-out g. Conditioning on (Π, values) therefore fixes v ⋆ , giving I(v ⋆ ; R | Π, values) = 0: the type label can vary freely without changing the answer once the live/dead bit and the values are known. Minimality in this deterministic query sense: any statistic that cannot recover the needed live/dead distinction merges a live and a dead atom on some surface and so changes g there (resurrecting a deprecated value or killing a current one); by P1 such surfaces exist, so that statistic is not sufficient. Hence Π — the binary collapse of R — is the minimal sufficient statistic for v ⋆ . □ Scope: this is the oracle statement. The theorem is conditional on the correct partition Π; it says the five-way refinement beyond the binary live/dead collapse is value-irrelevant, not that relation scoring is unused (the collapse itself is recovered from SU PERSEDES edges, exactly the coarse-d mechanism). It therefore predicts that an architecture which recovers Π is oracle-optimal on snapshot queries; whether the implemented fine-d scorer recovers Π better than coarse-d is an empirical question the theorem does not settle and the render-matched ablation (§4.1) answers in the negative. This matches the emulation premise of Corollary 1: the fine-d relation alphabet collapses onto the coarse-d binary ⋆ on snapshot tasks. alphabet, so RF⋆ = RC What this predicts. (i) On snapshot queries, an architecture that recovers the binary partition is oracle-optimal; finer typing adds no recoverable benefit, only the implementation cost of P3. With Corollary 1 this forces coarse-d ⪰ fine-d on snapshot tasks — not merely κ > β, but β = 0. This is the theoretical content behind the render-matched decomposition of §4.1, where the fine-d deprecation mechanism contributes an insignificant residual. (ii) The sufficiency is query-relative: it holds for value queries, not for queries whose answer is a function of R itself. A refinement query (which granularity is current?) and an unresolved-status query (is the key in conflict?) read coordinates of R that Π collapses, so for them Π is insufficient. This is the bitemporal-database fact that the current snapshot answers current-value queries but not provenance/history queries (Snodgrass, 1999; Date et al., 2003), specialised to the relation alphabet. §4.1 and Table 3 test prediction (ii) directly: typed structure is worthless on snapshot
Proposition 2b (minimal sufficiency of the binary partition for snapshot queries). Statement. For a key (x, a), let R(E) be the typed co-keyed relation labelling (the five classes of §2) from which the ledger derives status, and let Π(E) ∈ {0, 1}|E| be the deprecation partition it induces: Πe = 1 iff atom e is live (in the maximal d-non-deprecated subset), else 0. Π is exactly the binary collapse of R that maps SUPERSEDES (and the unresolved trigger) to a live/dead decision and merges the remaining classes. The claim is about what the finer labelling adds beyond this collapse: for the snapshot-value query — return the current effective value v ⋆ or A BSTAIN — the partition is a sufficient statistic, i.e. v ⋆ ⊥ R | (Π, values). Equivalently btype ≜ I(v ⋆ ; R | Π, values) = 0: given the correct live/dead partition, the five-way relation type carries no additional value-relevant information. In the deterministic query sense used here, Π is also minimal: any statistic sufficient for the snapshot answer must recover the live/dead distinctions needed by the read-out, and no strictly coarser collapse of that partition remains sufficient (P1 exhibits two surfaces equal in (values, Tv ) that differ only in Π and have different v ⋆ , so the live/dead bit cannot be dropped). The result is clarifying rather than deep — it is close to immediate from the snapshot semantics — and we flag it as such; the non-trivial structure is the strict lattice of Proposition 2c. 15
reverted-revert (b ≈ 0), while relation-coordinate queries improve only when the relevant coordinate is actually recovered, as with the learned scorer on REFINES and strict-prompt decode on CROSS SOURCE - CONFLICT.
and fine-d is the oracle-level class that also covers Qtype when its relation coordinate is recovered. Empirically, the Qprov gap between a retaining coarse-d and fine-d is small and largely presentational (§4.3), and the deployable type-query gain is scorer-gated. The selection criterion is then: deploy the coarsest architecture whose retained statistic covers the query distribution. The snapshot result (§4.1: fine-d’s extra state is wasted, btype = 0) and the provenance result (§4.3: a discarding coarse-d’s missing state is fatal, but retention — not typing — repairs it) are the two endpoints of this lattice measured on the same benchmark — the negative and positive faces of one characterization. The Stype rung is oracle-level and scorer-gated (empirical). We also test the top rung directly with a relation-type query — “did the current value refine (narrow, prior still partly holds) or replace (supersede/correct) the value before it?” — on the 93 items whose prior value is gold-defined, gold taken from the phenomenon label, over five answer families. The deployable fine-d does not beat retentioncoarse-d (∆ = −0.015 [−0.037, +0.006], n.s.); on refinement items fine-d scores 0.00 and coarseretain 0.02 (both near floor), because RevisionLedger’s rule scorer collapses REFINES onto SU PERSEDES just as binary invalidation does, so its typed render merely propagates the scorer’s error. The rung is therefore an oracle property (the statistic Stype separates the classes) that is gated by scorer quality (P3) in any deployment: the typed benefit materializes only when the relation coordinate is actually recovered, which is exactly the learned-scorer gain on REFINES (−0.086 → +0.147, §4.1). Even on the one query class the lattice permits a typed win, raw typing without recovery is idle — the same representation-overmechanism pattern as on snapshot. Retention–accuracy frontier (the criterion is retention-optimal). The lattice induces a rate– distortion statement (Tishby et al., 2000) that makes the selection criterion itself an optimum, not a heuristic. Let a deployment face a query P mixture with class masses πsnap , πprov , πtype ( = 1), and let a memory retain statistic S ∈ {Ssnap , Sprov , Stype } at retention cost rate(S) (bits/key, strictly increasing along the chain since each statistic refines the last). By the strict gaps above, a memory retaining S achieves oracle accuracy on exactly the query mass whose minimal sufficient statistic is ⪯ S, and is capped below 1 on the rest. The achievable accuracy–rate frontier
Proposition 2c (query-sufficiency lattice: a strict hierarchy). Statement. P2b is the bottom of a lattice. For a key, let the event stream induce three nested statistics: Ssnap = the current value (the live atom); Sprov = the time-ordered value history (current plus the ordered superseded values); Stype = the value history annotated with each transition’s relation type (the full labelling R). Consider three query classes: Qsnap (current value), Qprov (the value in force immediately before the current one), and Qtype (was the last change a supersession or a refinement?). Then the minimal sufficient statistics are strictly ordered, Ssnap ⊏ Sprov ⊏ Stype , each query class being answerable from its own statistic and provably not from the one below it. Proof of the strict gaps. (a) Ssnap is insufficient for Qprov : the two streams a → b and c → b (a ̸= c) have identical Ssnap = b but different prior values, so any predictor reading only Ssnap errs on one. Sprov answers Qprov by construction. (b) Sprov is insufficient for Qtype : a value pair (u, v) can arise by SUPERSEDES (a correction replacing u by v) or by REFINES (v a narrower restatement that displaces the broader u); both yield the identical ordered history u → v but different gold transition types, so Sprov cannot separate them while Stype records the label. Minimality of each statistic for its class follows as in P2b (any coarser function merges two streams the query must distinguish). □ Architecture–query matching (corollary). The architecture classes retain these statistics: a d-blind store retains the unordered value multiset (neither current/prior order nor type); coarse-d comes in two variants — a discarding one that closes and drops superseded edges (retains Ssnap ) and a retaining one that keeps closed edges with their windows (retains Sprov , as Zep/Graphiti does); and fine-d retains up to Stype . Hence each is oracle-optimal precisely on the query classes its retained statistic covers and provably sub-optimal beyond: a discarding coarse-d is optimal on Qsnap (P2b) but cannot answer Qprov ; a retaining coarse-d covers Qprov ; 16
is therefore the upper staircase through the three lattice corners, and its optimum for a given mixture is the minimal S whose downward closure covers the positive-mass classes:
is decided by a supersession edge). Then crit crit αFC πco ≤ G ≤ αFC πco + αSM πsup + αrender ,
and the relative cost ε ≜ 1 − Acc(RevisionLedger)/Acc(tier-optimal) = G/Acc(tier-optimal) satisfies the same inequalities divided by Acc(tier-optimal). In particular crit π G ≥ αFC co > 0 whenever the task has co-keyed non-contradict pairs and the scorer has a nonzero decision-critical false-contradict rate. Proof. When πrevert = 0 and πunres = 0, the tieroptimal architecture (LATEST- ONLY for LLATEST , GRAPHRAG - LITE for monotonic) already returns the snapshot value without any supersession machinery, so on every item it is correct exactly when the snapshot value is recoverable from the surface — which, on this definite monotone task class, is every item. RevisionLedger’s extra machinery can only lose mass relative to this baseline, by three disjointly-attributable events. (i) Critical false-contradict: on an item with a co-keyed pair the scorer outputs CONTRADICTS although Y ∈ {same-state, supersedes}; the ledger sets status=unresolved, and when this status controls the answer RevisionLedger abstains, which is wrong because abstain is never gold on a πunres = 0 task. crit π fraction, giving This happens to at least an αFC co the lower bound. (ii) Supersede-miss: the scorer fails to mark a true monotone supersession, leaving the stale atom in the support set; the rendered current value is then ambiguous on at most an αSM πsup fraction. (iii) Render-confusion: even from a structurally correct ledger the answer-LLM selects the wrong field, on an αrender fraction. Each wrong RevisionLedger answer that the baseline gets right is caused by at least one of (i)–(iii), so by crit π + α a union bound G ≤ αFC co SM πsup + αrender . crit π The lower bound G ≥ αFC co additionally requires the tier-optimal baseline to have conditional accuracy above 1/2 on the critical-false-contradict subset (each such item then contributes a positive expected unit of G). Hypothesis (⋆) is the scope assumption named in the Statement; it is verifiable in principle by measuring baseline accuracy on {co-keyed pairs the scorer outputs as CONTRA DICTS }. The primary evaluation pool includes {RevisionLedger, GraphRAG+abstain, Graphiti} only — no LATEST- ONLY/GRAPHRAG - LITE comparisons — so we report the bound’s sign as conditional on (⋆). This is the abstain-prior-collapsed case of the Chow (1957) reject-option framework (cf. Franc et al., 2023); in the noise-free limit
S ⋆ (π) = min⊑ {S : πz > 0 ⇒ Sz ⊑ S}. This is exactly “deploy the coarsest architecture whose retained statistic covers the query distribution,” now derived as the rate–distortion-optimal point rather than asserted: a discarding coarse-d (S ⋆ = Ssnap ) is optimal iff πprov = πtype = 0; any provenance mass forces retention of prior state — which a retaining coarse-d already supplies, so fine typing is forced only by πtype > 0, and even the provenance gap to fine-d is small (§4.3). The deployment reversal (§4.3) is the boundary case where retaining the raw stream is a fourth, costlier point that dominates fine-d’s render on Qprov but defeats the purpose of a compressed memory — off the efficient frontier whenever rate is scarce. Proposition 3 (out-of-tier cost from scorer and render errors). Statement. On any definite task with πrevert = 0 and πunres = 0 (no genuine non-monotonic supersession and no gold unresolved-abstention decision — every decision-relevant conflicting atom pair is monotone supersession or paraphrase), and under scope hypothesis (⋆): the tier-optimal baseline has conditional accuracy above 1/2 on the criticalfalse-contradict subset (defined below), write G ≜ Acc(tier-optimal) − Acc(RevisionLedger) for the absolute accuracy gap. Define the stage rates over the item-weighted ledger update trace: crit : conditional probability, among items • αFC with a decision-relevant co-keyed noncontradict pair, that the update trace scores such a pair as CONTRADICTS and this spurious unresolved status changes the answer (this is the critical-false-contradict subset referenced in scope hypothesis (⋆) above),
• αSM : conditional probability, among items whose answer is decided by supersession, that the deciding edge is not scored SUPERSEDES (supersede-miss), • αrender : probability that the answer LLM picks a wrong field from a structurally valid ledger (render-confusion), and item-side fractions πco (items with a decisionrelevant co-keyed pair), πsup (items whose answer 17
crit = α αFC SM = αrender = 0 and G = 0, the standard “zero theoretical cost” of noise-free selective classification (El-Yaniv et al., 2010), so the entire out-of-tier cost is an implementation gap, decomposed by a learning-to-reject-style accounting (Charoenphakdee et al., 2021). □ Numerical instantiation. The 500-pair DeepSeek atom audit gives pair-level proxies α̂FC = 0.059 and α̂SM = 0.720 for the implemented rule scorer (Table 4). These are diagnostic pair-level rates, not crit used in the the item-weighted decision-critical αFC lower bound. The same audit explains the primary REFINES boundary case: rule-scorer refinement recall is only 0.050, while a diagnostic DeepSeeksupervised scorer reaches 0.425 recall. Observed ε runs roughly 0.3 to 0.65 across DyKnow, Wikimono, and GitHub-mono (ratios of two measured accuracies; read as order-of-magnitude). The decomposition shows ε is not a free knob: it is the union of named auditable rates. The current audit is proxy-level and does not instantiate the lower bound numerically, because the pair-level proxies are not item-weighted traces and αrender has no closed-form theory; item-weighted trace audits are left to future work. Scorer
Acc.
Rule scorer 0.312 DeepSeek-supervised audit 0.572
Macro-F1 0.225 0.463
α̂FC
α̂SM
0.059 0.720 – –
at only Cohen’s κ = 0.28 — so Pe ≥ 0.365 is an indicative floor against a noisy reference rather than a tight bound against ground truth; and it concerns the rule scorer of the headline system, not the supervised diagnostic scorer. The qualitative consequence is robust and is all we use: a scorer this information-limited keeps κ > 0, which is why fine-d’s implementation cost does not vanish even on clean signal (Corollary 1). Proposition 4 (channel benefit–cost equation). Statement. Let the latent decision channel Z take values in {D, S, U, Fr , O}: non-monotonic deprecation, state compression over stale evidence, unresolved-conflict abstention, refinement, and other. We assign Z by the priority order D ≻ U ≻ Fr ≻ S ≻ O, with D first as the constitutive nonmonotonic supersession primitive (the only one for which P1 gives an identifiability separation), U next because unresolved cross-source disagreement controls the abstain decision irrespective of any later refinement or compression, Fr before S because a granularity-refinement edge is decisioncritical (it can change the answer) whereas statecompression is purely an efficiency/representation effect on items with no other active channel. Items satisfying multiple channels are deterministically routed to the highest-priority decision-controlling channel; this makes {Z = z} a partition and the πZ identifiable from labels. The benchmark’s phenomenon labels are largely single-channel at the decision-controlling level, but the S-channel prediction test (Table 11) re-partitions DS-monotonic by a surface deprecation-evidence indicator π̃S (presence of deprecated event ids), distinct from the decision-controlling πS in the headline equation. The relation is π̃S ⊇ πS in the relevant strata: every item routed to the headline S channel carries deprecated evidence, but the converse can fail because priority routing may assign a deprecated-evidence item to a higher-priority channel (D, U , or Fr ). That test therefore reports a stratum-conditional effect within DS-monotonic, not a reassignment of items in the headline channel partition. Items where stream length is large are moderators of ∆Z within the active channel rather than mediator stages in the path-recall decomposition. For any two architectures A, B evaluated on distribution D,
Refine recall 0.050 0.425
Table 4: Atom-pair relation audit on 500 DeepSeeklabeled pairs. The α̂ columns are pair-level proxies for the item-weighted P3 stage rates. The rule scorer is used in the main RevisionLedger system; the supervised row is diagnostic only and is not used in the headline systems.
Scorer information floor (C2). The implementation cost κ is not incidental; it is bounded below by how much the relation scorer can possibly know. On the same 500pair audit, the rule scorer’s output R carries only ˆ Y ′ ) = 0.216 bits (Miller–Madow corrected) I(R; about the relation label Y ′ , whose marginal entropy is H(Y ′ ) = 1.89 bits. A list-decoding form of Fano’s inequality then lower-bounds the scorer’s relation-recovery error at Pe ≥ 0.365, so the supersede-confusion and false-contradict mass that P3 turns into out-of-tier cost cannot be driven to zero by this scorer. Two caveats keep the claim honest: the relation “oracle” Y ′ is itself judgedependent — Qwen-vs-Llama relation labels agree
Acc(A) − Acc(B) =
X Z
18
πZ (D) ∆Z (A, B),
where πZ = PrD [Z] and ∆Z (A, B) = Pr[A correct | Z] − Pr[B correct | Z]. Moreover, if channel Z has signal value bZ , implemented channel recall rA (Z), and conditional implementation cost cA (Z), then the operational approximation
answer decoder. Primary REFINES has low implemented rRevisionLedger (Fr ) under the rule scorer, but improves when the pair scorer is replaced. Finally, the coarse-d store and fine RevisionLedger are both d-aware; their ranking follows the same equation, with coarse-d lowering cost on binary D and RevisionLedger adding possible benefit on U and Fr . What is and is not falsifiable Phere. The decomposition Acc(A) − Acc(B) = Z πZ ∆Z is the law of total expectation: an accounting identity with no empirical content on its own. Empirical content enters only through architecture-determined sign restrictions on the ∆Z , in the sense that an accounting identity becomes testable once sign constraints are imposed on its terms. Three such restrictions are in principle refutable: (C1) P1 forces ∆D ≥ 0 for a d-aware A against a d-blind B, and ∆D = 0 between two d-blind architectures; (C2) the implementation cost is bounded below by the relation scorer’s information deficit (Appendix A); and (C3) the fine-vs-coarse gap should be monotone in a single scoring-noise parameter and eventually change sign. We tested C3 directly with a controlled noise-injection sweep (§4.2; Appendix C) and it failed: holding data, judge, and answer model fixed, coarse-d stays preferred at every injected noise level across five answer families, with no monotone trend and no sign flip. We therefore report C3 as falsified on this axis, and the granularity conclusion of the paper rests on the render-matched decomposition (§4.1) and Corollary 1, not on the channel equation’s predictive content. The earlier fine-vs-coarse crossover observed between the primary and noisier auxiliary constructions is, accordingly, attributed to confounds (annotator identity, relation-type mix, construction procedure) rather than to a clean noise axis.
∆Z (A, B) ≈ bZ [rA (Z) − rB (Z)] − [cA (Z) − cB (Z)]. would identify which system wins if its channel mass, implemented recall, and residual cost were independently estimated — which we do not do. We use it only as a diagnostic bookkeeping identity for per-stratum analysis; its one predictive sign claim is falsified below, and the granularity ranking rests on Proposition 2b and Corollary 1 instead. Path recall. In an implemented ledger pipeline, rA (Z) is not a pair-classifier recall. It is the probability that the channel survives the full path from extracted atoms to the final answer: rA (Z) = Pr(Epair ∩Earb ∩Erender ∩Edecode | Z). By the chain rule this equals Pr(Epair | Z) Pr(Earb | Z, Epair ) Pr(Erender | Z, Epair , Earb ) Pr(Edecode | Z, Epair , Earb , Erender ). No independence assumption is made. This factorization is useful because each stage can be intervened on: a pair-level oracle tests Epair , a row-status oracle tests Earb , render-only tests Erender , and output abstain rates expose Edecode . Proof. The first equality is the law of total expectation applied to the paired correctness difference 1{A correct} − 1{B correct}. The second display is a channel-level decomposition of conditional correctness into recovered decision signal minus implementation failures. It is exact if cA (Z) is defined as residual conditional risk after the recovered-signal term, and approximate when bZ and the path recall rA (Z) are estimated separately. □ Consequences. P1 is the D-channel separation: d-blind systems have r(D) = 0, while bitemporal systems can have r(D) > 0. Primary MONO TONIC items are not guaranteed to have πS = 0: many contain stale or deprecated evidence, so a ledger can win through state compression even without a strict flip-flop. Primary CROSS - SOURCE CONFLICT has high oracle U value but low implemented path recall: pair-level contradiction can be overwritten by ledger arbitration, and even rowlevel UNRESOLVED status is often ignored by the
Proposition 5 (a binding-bottleneck account of the observed signs). The accounting identity (P4) decomposes the architecture gap but, as shown above, carries no predictive content on its own. We now give a single principle that subsumes it: a data-processing account under which every empirical result of §4.1– §4.3 is a sign/zero consequence of which pipeline stage binds. We are explicit that this is a retrodictive, falsifiable synthesis (the magnitudes pre-date it; see “Status” below), not a pre-registered prediction; its value is parsimony and refutability, and it is what turns the lattice’s organizing role into a 19
(btype = 0): state does not bind, render does. Holding render fixed (render-matched control) equalizes Cren , so the mechanism residual is predicted to vanish (+0.025, n.s.). (2) Coarse ⪰ fine on snapshot, noise-robust. Fine-d differs only by a heavier render, so by (R) Cren (fine) ≤ Cren (coarse) ⇒ coarse ⪰ fine. Relation- or extraction-noise ext state ren dec Y → E −−→ X −−−→ SA −−→ RA −−→ Ŷ , corrupts X/the scorer upstream of the shared Π, lowering both arms identically; the gap stays the E the event stream, X = extract(E) the (non-negative) render penalty, so no level can flip atoms, SA = stateA (X) the retained statis- the sign — exactly the two null sweeps. (3) Provetic (where the deprecation mechanism lives), nance threshold. For Y = vprior , a discarding RA = renderA (SA ) the rendered context, Ŷ = coarse-d has Cstate = I(vprior ; v ⋆ ) = 0 (the prior decode(RA ) the answer LLM’s output. Define is absent): state binds at 0, hence floor. Retention the stage capacities Cext = I(Y ; X), Cstate (A) = lifts Cstate to H(vprior ) (closing +0.361); render I(Y ; SA ), Cren (A) = I(Y ; RA ). then binds, leaving only the render-penalty residual Theorem (capacity bottleneck and accuracy ceil- (+0.111, plausibly presentation). (4) Deployment ing). By the data-processing inequality along the reversal. Appending raw E to the render adds a chain (Cover, 1999), parallel E → R edge, so Cren rises toward Cext for all architectures and the state-capacity differences ⋆ I(Y ; Ŷ ) ≤ min{ Cext , Cstate (A), Cren (A) } =: CA , out; by (R) the binding quantity is now render wash length, which is largest for fine-d — so the sign and by Fano’s inequality the error reverses (−0.236). Same principle as (1), oppo probability obeys ⋆ Perr (A) ≥ H(Y ) − CA − 1 / log |Y| (the LLM- site sign because the task supplies the information QA specialization of Wan et al., 2025). Accuracy elsewhere. (5) Relation-type null. For Y = τ , oris thus capped by a monotone function of the mini- acle Cstate (fine) = H(τ ), but by (S) the deployed mum stage capacity — the binding bottleneck. This fine-d’s type comes from the rule scorer whose is the IB statement (Tishby et al., 2000) read along refine/replace capacity Csc ≈ 0, so its effective the pipeline: each stage is a bottleneck variable Cstate ≈ that of binary retention: deployed fine-d and the chain’s relevant information is set by the cannot beat retention-coarse-d (−0.015, n.s.; 0.00 tightest one. on refinements). (6) Recovery helps only on RDesign principle (corollary). An intervention reading queries. A learned scorer or strict prompt A → A′ raises accuracy only if it raises the ca- raises Csc /Cren for the relation coordinate; this pacity of the currently-binding stage for Y ; rais- lifts accuracy iff that coordinate is answer-relevant ing a non-binding stage is idle, and lowering the — positive on REFINES/CSC (−0.086 → +0.147; binding stage (e.g. a heavier render when render +0.152), and provably idle on snapshot where binds) strictly hurts. Two empirical regularities btype = 0. are used as premises (assumptions, not theorems, Operational meaning of “binds.” The DPI/Fano with the cited support): (R) render monotonicity — inequality is standard; the only non-trivial step is decode capacity Cren is non-increasing in render the per-query stage attribution, and it is empirically length/complexity (long-context position bias, Liu identified, not assumed. Each ablation isolates one et al., 2024b; distractor sensitivity, Cuconasu et al., stage: the render-matched control holds Cren fixed 2024); and (S) scorer-gating — a typed statistic (so a non-zero mechanism residual would mean computed by a relation scorer of channel capac- Cstate binds); the retention vs. discard contrast ity Csc contributes at most Csc to Cstate beyond moves Cstate ; the deployment fallback raises Cren the binary partition. The theory predicts signs and via the raw-text path; the learned scorer raises Csc . zeros, not magnitudes: under these premises, it The binding stage for a query is read off as the one says which gaps should vanish or reverse, up to a whose ablation moves accuracy. There is thus no roughly constant decode gap, not their exact size. free parameter: “which stage binds” is measured, All six results are corollaries (which stage and the principle’s role is to say that only the bindbinds). (1) Snapshot, mechanism ≈ 0. P2b ing stage’s movement should matter — which is ⋆ gives Cstate (coarse) = Cstate (fine) = H(v ) exactly the cross-ablation pattern we observe. single testable account. Setup. Fix a query class with answer variable Y (e.g. Y = v ⋆ for snapshot, vprior for provenance, the transition type τ for relation-type queries). For architecture A the answer is produced by a Markov chain
20
a deterministic map g such that the C-oracle decision equals g(yF⋆ ) for the F -oracle decision yF⋆ on the same surface — then g is surjective onto C’s decision space (by the fine-relation-contains-coarse premise in the Statement: the F -alphabet {SAME STATE , REFINES , SUPERSEDES ,. . . } collapses onto the binary C-alphabet {current, deprecated} by aggregating equivalence classes). For C’s Bayesoptimal policy fC⋆ , pick fF′ in F ’s class taking on each surface s any value in the non-empty preimage g −1 (fC⋆ (s)). Under the 0/1-correctness cost model (the deployed accuracy metric throughout the paper), refining the decision does not increase loss against ground truth — a finer answer that maps to gold under g scores correct iff its g-image ⋆ and does — so fF′ achieves Bayes risk at most RC ⋆ ⋆ hence RF ≤ RC . □ Empirical instantiation. Proposition 2b explains why fine-d should lose on snapshot queries: there βC←F = 0 exactly, because the binary partition is a sufficient statistic and fine typing has no value-relevant oracle benefit to add. The corollary then forces Acc(F ) − Acc(C) = −κF ←C ≤ 0. The data agree on the sign: on the clean primary reverted-revert slice, Acc(F ) − Acc(C) = −0.084 under the gold DeepSeek judge, and the controlled noise sweep concurs at clean signal (−0.016 [−0.058, +0.029] at the p=0 point, n=445) — coarse-d is never behind. The render-matched decomposition of §4.1 confirms the vanishing benefit directly — the fine-d d-mechanism residual is +0.025 [−0.005, +0.057] pooled and +0.036 [−0.027, +0.098] on canonical items, both CIs crossing zero — while coarse-d carries a real +0.087 [+0.046, +0.130] of mechanism over the same render. The corollary’s inequality is thus satisfied not by a large κ but by a β that Proposition 2b sets to zero: on snapshot queries, fine-grained relation typing has nothing to add over coarse invalidation that an optimal renderer cannot already deliver.
Status: retrodictive but falsifiable, not preregistered. We are explicit that Proposition 5 is a post-hoc unifying account, not a theory we registered and then tested: all six magnitudes pre-date it. Its value is therefore parsimony and falsifiability, not prospective confirmation. It earns its keep only if it (i) makes each result a necessary sign/zero consequence of one principle and (ii) is refutable — and each clause names an ablation that would have broken it: mechanism helping under a rendermatched snapshot control would falsify (1); any noise level flipping the sign would falsify (2); a discarding coarse store answering provenance would falsify (3); fine-d winning deployment would falsify (4); deployed fine-d beating retention on the type query would falsify (5). None occurred, on either judge. We claim signs and zeros, not magnitudes, and not that the principle was predictive ahead of the data. The one quantitative form we did commit to in advance (P4’s C3 monotonicity) was falsified, so we keep only the qualitative attribution the ablations support. Corollary 1 (within-tier fine-vs-coarse threshold). Statement. Let C be a coarse-d bitemporal architecture class and F a fine-d bitemporal architec⋆ (D) be the ture class. For a distribution D, let RA oracle risk of class A with exact atoms, exact relations, and an optimal renderer/decoder, and let ⋆ (D) be implementation exEA (D) = RA (D) − RA cess risk (distinct from the stage-event Ei in P4). If F can emulate C, then ⋆ Acc(F ) − Acc(C) = RC − R⋆ | {z F} βC←F ≥0
− (EF − EC ) . | {z } κF ←C
Thus fine-d beats coarse-d iff its extra oracle benefit exceeds its extra implementation cost. Here “F emulates C” means the C-oracle decision is determined by the F -oracle decision under the same surface (e.g. the fine-d relation alphabet contains a 2-class collapse equivalent to coarse-d — SAME STATE/ REFINES merged with SUPERSEDES — and an optimal F -renderer/decoder can apply that col⋆. lapse), so RF⋆ ≤ RC Proof. Since accuracy is one minus risk, Acc(F ) − Acc(C) = RC − RF . Add and sub⋆ and R⋆ to obtain (R⋆ − R⋆ ) − [(R − tract RC F F C F ⋆ )]. If F emulates C — there is RF⋆ ) − (RC − RC
Conjecture 1 (capacity-conditional ε, a falsifiable hypothesis). Hypothesis. We hypothesize that the out-of-tier magnitude obeys ε ≈ max(εarch , εreader ), where crit π + α εarch := (αFC co SM πsup )/Acc(tier-optimal) rescales the first two P3 terms to match ε’s relative-loss units, and εreader := αrender /Acc(tier-optimal) absorbs the renderconfusion term. Scope. The scorer-side term εarch is not conjec21
crit π and αcrit π + tural: P3 places it between αFC co FC co αSM πsup , both measurable with item-weighted traces. Only the reader-side term εreader and the max-form combination are conjectural: εreader is an increasing function of the render’s token length, its number of candidate fields, and the position prior of the answer field — empirically real (longcontext position bias (Liu et al., 2024b), distractorrate sensitivity (Cuconasu et al., 2024), readerdependent saturation (Hsia et al., 2024)) but lacking a closed form. The max rather than additive or product form is the binding-constraint regime: whichever stage is the bottleneck dominates, and the other becomes slack; we adopt it as the simplest monotone combiner consistent with the qualitative pattern across families. The hypothesis is consistent with the data — the smallest-effect family (Qwen3-8B) is where εreader plausibly dominates — but we make no claim it is correct. Falsification rule. A precommitted falsification rule that distinguishes the max form from capped-additive (min(1, εa + εr )) and noisy-OR (εa +εr −εa εr ) combiners (we use capped-additive because raw εa + εr can exceed 1, the natural range of a relative loss): sweep εreader along a monotone sequence of progressively stronger readers/shorter renders, and fit the dependence of ε on ε̂reader . The max form predicts a piecewise-linear curve with zero slope while ε̂reader ≤ ε̂arch and unit slope above; capped-additive predicts slope 1 until the cap; noisy-OR predicts slope 1 − εa throughout. A single-point ablation at ε̂reader ≤ ε̂arch /2 already gives a ∼0.5 εarch gap between max and the alternatives, comfortably outside the CI half-widths in [0.014, 0.050] we observe on dominant primary strata. Such an ablation tests εreader , not Proposition 1 or 2 (render-invariant).
B
2,631 QAs (4.7×), comparable to the rare-stratum coverage range (4.1–4.8×). Primary stratum
n
reverted-revert monotonic cross-source refines
439 0.408 12,382 0.343 363 0.039 428 0.262
RL GraphRAG+abstain Graphiti ∆RL−GRW ∆RevisionLedger−Graphiti 0.226 0.279 0.099† 0.348
0.492 +0.182 0.461 +0.064 0.022 −0.061† 0.484 −0.086
−0.084 −0.118 +0.017 −0.222
Table 5: Primary-surface results under the DeepSeek judge, pooled over answer families and sources (referenced from §4.4). RevisionLedger is the fine-d ledger, GraphRAG+abstain is the d-blind control, and Graphiti is coarse-d edge invalidation. n counts paired system– family observations after row-specific coverage and parsing filters, not raw QA items. † The cross-source GraphRAG+abstain entry is the standard-prompt baseline; the intervention tables report both the strict-vsstandard rescue (+0.185) and the strict-vs-strict recovery gain used in the main text (+0.152).
Channel Scope condition D
S
Fr
U
cost
Decision on primary surface
A deprecation edge is decision- In scope: both d-aware syscritical and d is not recoverable tems beat GraphRAG+abstain from values and valid times. on strict reverted-revert. Monotonic labels may still con- In scope after control: stale split tain stale state; render/readability supports S; render-only isolates effects must be separated from the nuisance render term and deprecation. residual representation signal. Pair-level refinement recall must The rule scorer fails this clear the implementation thresh- condition; a learned scorer old. recovers the refines signal and flips the sign against GraphRAG+abstain. Row-level unresolved status must The default decoder fails this survive arbitration and the de- condition; oracle rows localize coder must abstain when it sees the missing path stage, and posiit. tive U gain is claimed only after strict decoding. Fine-d typed scoring must keep Aggressive low-precision scordecision-critical false-conflict be- ers fail this condition; their low the P3 cost threshold (κ-side regressions instantiate the P3 scope). boundary.
Table 6: Scope conditions for the per-stratum bookkeeping (referenced from §4.4). Rows that fail their condition are diagnostic boundary cases, not failures of the deprecation or granularity claims.
The following tables give the interventions behind Table 6. They report different deltas for the same interventions: Table 8 measures oracle gains relative to the main RevisionLedger system, while Table 9 measures the same CSC chain against GraphRAG+abstain controls. All rows use the primary surface, the same DeepSeek-V3 judge, and paired bootstrap intervals with B = 10,000.
Path Diagnostics for Boundary Strata
This appendix unpacks the boundary-stratum results cited in §4.4. Its role is diagnostic: Table 5 reports the primary-surface outcomes, Table 6 states the recovery condition for each decision channel, and the remaining tables intervene on pair scoring, arbitration, and decoding to show where the missing coordinate is lost. All diagnostics use the DeepSeek-judged primary surface. Counts are paired system–family observations after coverage and parsing filters, so they need not equal the raw QA count times five. As a scale check, the monotonic row contributes 12,382 observations from
C
Controlled Noise Injection Does Not Produce a Sign Flip
The empirical pivot of the granularity question is the fine-d versus coarse-d gap. We write this gap as ∆RevisionLedger−Graphiti . A tempting reading is that this gap sign-flips as the signal gets noisier — 22
Stage oracle subst.
acc
∆RL−GRW ∆RL−GRAPHITI abstain
CSC stratum (npaired =363, gold abstain 86/88) 0.039 −0.061 +0.017 RevisionLedger baseline +sub(Spair ) 0.041 −0.058 +0.019 +sub(Sarb ) 0.058 −0.041 +0.036 +sub(Sdecode ) 0.284 +0.185 +0.262 † matched-α — −0.025 — GraphRAG+abstain ctrl 0.105 +0.006‡ — GraphRAG+abstain +sub(Sdecode ) ctrl Refines stratum (npaired =428) RevisionLedger 0.262 −0.086 baseline +sub(Spair ) ora- 0.252 −0.096 cle learned pair scorer 0.495 +0.147
0.025 0.027 0.041 0.223 0.025
—
−0.231
—
+0.012
—
Oracle RevisionLedger
CSC , pair-level oracle REFINES , pair-level oracle CSC , row-level oracle REFINES , row-level oracle
0.041 0.252 0.058 0.252
0.039 0.262 0.039 0.262
∆
95% CI
+0.003 −0.009 +0.019 −0.009
[−0.017, +0.022] [−0.026, +0.005] [+0.006, +0.033] [−0.026, +0.007]
Table 8: Oracle-gate diagnostics, reported as oracle minus the main RevisionLedger system on the same paired pool (n=363 for CSC, n=428 for REFINES). Pairlevel oracle forces the gold relation on the decisioncritical atom pair; row-level oracle additionally forces the rendered ledger row to carry the target status. The CSC null under pair-level oracle and positive row-level effect identify arbitration/decode bottlenecks; Table 9 reports the same CSC chain against GraphRAG+abstain controls.
0.066
−0.222
Stratum
Table 7: Stage-conditional substitutions on the pathrecall decomposition. The CSC rows are cumulative (pair relation → row arbitration → strict decode), so the jump from the row-level oracle to strict decode is the decoder contribution; the REFINES rows compare pair-scoring replacements. We read these conditional gains as diagnostics of where the channel is gated, not Pearl-style controlled-direct-effect estimates. The learned pair scorer is a BERT implementation; it gives the main-text REFINES recovery gain +0.147 relative to GraphRAG+abstain. † matched-α re-weights observed GraphRAG+abstain abstains; ‡ GraphRAG+abstain+sub(Sdecode ) is the strict-prompt control on GraphRAG+abstain’s flat memory.
Δ accuracy (fine-d − coarse-d)
0.05
relation-label noise atom-extraction noise
0.00
−0.05
−0.10
−0.15 0.0
0.1
0.2 0.3 0.4 corruption probability p
0.5
Figure 5: No tested noise setting gives fine-d a win. Fine-d − coarse-d accuracy on strict reverted-revert under two corruption axes (relation-label noise; atomextraction dropout), five answer families, n=445/level, with 95% CI error bars. Negative values mean coarse-d wins; the point estimates remain below zero at every tested level and no setting yields a significant fine-d win (some CIs cross 0, i.e. ties). The relation-label curve is also non-monotone, falsifying the conjectured monotone sign flip (C3) on the axis it names.
fine-d behind on the clean primary slice (−0.084), ahead on the noisier auxiliary split (+0.090). The checks below reject that as a clean noise effect. The p=0 rows below are baselines for the perturbation sweep, not a second estimate of the headline clean-slice gap. The headline −0.084 aggregates the original primary reverted-revert comparison (npaired =439), whereas each sweep rebuilds both arms on the paired noise-coverage pool with complete atom streams and five-family coverage (89 questions × five families, n=445). The relevant test is therefore within-sweep: as p increases, does the gap move monotonically toward and across zero? Observational precursor (confounded). Binning all primary items by stream length — an evidencerevision complexity proxy — does recover a monotone trend (Table 12): ∆RevisionLedger−Graphiti rises from −0.204 on the shortest quintile to +0.023 on the longest. But stream length is not a pure noise variable; it co-varies with relation-type mix, topic, and item difficulty, so this is suggestive at best. Controlled test (the noise is the only varying
axis). We therefore inject relation-scoring noise directly: holding dataset (primary reverted-revert), judge (DeepSeek), and answer model fixed, we wrap the relation function so that each predicted label is corrupted to a uniformly random other label with probability p, applied identically to the fined ledger and the coarse-d arm (seeded per atompair so both arms see the same corruption). Table 13 sweeps p ∈ {0, 0.1, . . . , 0.5} pooled over five answer-LLM families. At clean signal within this paired sweep (p=0), the two architectures tie (∆ = −0.016, n.s.) — consistent with Proposition 2b’s btype = 0 — and every positive noise level leaves coarse-d ahead. The curve is neither 23
Intervention (csc; npaired =363 rows, 440 final)
Acc abstain ∆ vs GraphRAG+abstain-std
RevisionLedger (no intervention) + pair-level oracle + row-level oracle + strict-prompt decode
0.039 0.041 0.058 0.284
0.025 0.027 0.041 0.223
−0.061 [−0.094, −0.027] −0.058 [−0.091, −0.028] −0.041 [−0.074, −0.008] +0.185 [+0.135, +0.234]
GraphRAG+abstain-default GraphRAG+abstain + strict-prompt control GraphRAG+abstain matched-α (k = 9, short-rank)
0.099 0.105 0.063
0.066 0.066 0.025
— +0.006 −0.036
— [−0.028, +0.039] —†
—
—
+0.152
[+0.107, +0.200]
∆ (RevisionLedger+strict − GraphRAG+abstain+strict)
95% CI
Stratum
CSC REFINES
0.342 0.378 0.041 0.495
0.408 0.343 0.039 0.262
0.226 0.279 0.099 0.348
0.492 0.461 0.022 0.484
−0.066 +0.035 +0.003 +0.234
Table 10: End-to-end learned-scorer RevisionLedger on the primary surface. The learned scorer recovers REFINES; the main text reports the learned-vsGraphRAG+abstain gain (+0.147), while this table’s final column reports the within-RevisionLedger gain over the rule-scorer baseline (+0.234). It leaves CSC unchanged because the CSC binding stage is the decoder, not the pair scorer, so the “Learned” csc cell coincides numerically with the pair-level relation oracle in Table 8. The reverted-revert regression is a visible instance of the P3 false-conflict cost term, not a calibrated estimate of the P3 lower bound.
Table 9: Stage-localized intervention chain on CSC, reported against GraphRAG+abstain controls. The strict-prompt decode substitution produces the largest single accuracy gain (+0.226 over the row-level oracle baseline), and the architectural attribution is confirmed because the same strict prompt does not move GraphRAG+abstain (+0.006, CI [−0.028, +0.039] crosses zero). Thus +0.185 is the strict-RevisionLedger vs standard-GraphRAG+abstain rescue, while the final row is the main-text strict-vs-strict gain: RevisionLedger beats GraphRAG+abstain by +0.152 on npaired = 440 CSC observations. The strict-prompt evaluation pool comprises 88 csc items × family coverage including Mistral-7B on Wiki csc (which the default n = 363 leaves out), 77 × 5 + 9 × 5 + 2 × 5 = 440. †paired ∆ vs RevisionLedger under matched-α is −0.025 [−0.052, +0.003], CI crosses zero; matched-α is the analytical re-weight that fixes GraphRAG+abstain’s observed abstain rate to RevisionLedger’s under the same coverage budget.
System on pure-mono RevisionLedger render-only GraphRAG+abstain Graphiti
Accuracy
∆ vs RevisionLedger
∆ vs GraphRAG+abstain
95% CI vs GraphRAG+abstain
0.353 0.331 0.304 0.440
— −0.022 −0.049 +0.087
+0.049 +0.027 — +0.136
[+0.033, +0.065] [+0.011, +0.043] — —
Table 11: Render-only decomposition on the 1,074 primary pure-mono items, the no-deprecated-evidence subset of the 2,631 primary monotonic QAs. The relation function is forced to SAME - STATE, so no supersedes, contradicts, unresolved status, or refinement can fire. The pure-mono advantage over GraphRAG+abstain splits into render benefit (+0.027) plus residual representation signal (+0.022).
monotone in p nor sign-flipping, so C3 fails on both parts of its monotone-crossover claim. We conclude the auxiliary crossover was driven by the confounds that distinguish the two constructions (annotator identity, relation-type mix, construction procedure), not by scoring noise, and we do not claim a controlled regime in which fine-d overtakes coarse-d. Extraction-noise axis. A null on the relationscoring axis does not by itself exclude an extraction-noise regime favouring fine-d. We test that axis too: dropping each atom independently with probability p (recall loss, the dominant extractor failure — our measured event recall is ∼0.86), identically in both arms, then rebuilding fine-d and coarse-d on the surviving atoms. The atom-dropout sweep in Table 13 gives the same sign conclusion: coarse-d leads or ties at every tested level, with no level where fine-d overtakes. Neither of the two natural noise processes tested here produces the proposed crossover.
D
Learned RevisionLedger GraphRAG+abstain Graphiti ∆learned−RevisionLedger
reverted-revert monotonic
mark of Wikidata (subject, relation, object, year) tuples. Each (subject, relation) is a genuine entitystate revision stream with canonical Wikidata gold; we build streams and queries directly from the tuples (no atom extractor) and score by normalized exact match on the gold name, with no self-built labels and no LLM judge anywhere in this experiment. From 5,839 streams we use the 237 revertedrevert streams (a value returns) for the snapshot test and 900 multi-value streams for provenance, over the same five answer-LLM families. Provenance retention replicates; the residual is presentation, not typing. Asking the value in force immediately before the current one (gold = the prior distinct value), a discarding coarse-d falls to floor accuracy at 0.061, while retaining the prior state recovers much of the missing answerability: d-blind 0.329, retaining coarse-d 0.576, fine-d 0.902. The retaining coarse-d store, not the fine ledger, is the source of the retention threshold: it closes +0.514 [+0.499, +0.531] over the discarding store (n=4,500 = 900 streams × five families). The remaining fine-over-retain gap is +0.326 [+0.310, +0.342], but it cannot be credited to relation labels: both retaining renders ex-
External Replication on TempLAMA (Wikidata Gold, No LLM Judge)
To reduce the core findings’ dependence on the selfbuilt, LLM-labelled ESR-Bench, we replicate on TempLAMA (Dhingra et al., 2022), a public bench24
Bin 1 2 3 4 5
Stream-length range
npaired
∆RevisionLedger−Graphiti
2–5 5–6 6–10 10–20 20–70
2,858 2,896 2,875 2,591 2,392
−0.204 −0.168 −0.150 −0.055 +0.023
vision histories), where layout determines whether the answer LLM can locate the current state at all; on a benchmark with no reading difficulty there is no render gap to measure. We therefore do not claim the render confound replicates on TempLAMA, only that the retention and representationdominates findings do.
Table 12: Observational precursor, confounded. Stream-length bins recover a monotone ∆RevisionLedger−Graphiti trend, but stream length co-varies with difficulty and relation mix (text). Relation-label noise Noise p 0.0 0.1 0.2 0.3 0.4 0.5
E
The table below summarizes auxiliary directional checks on the high-noise split and external probes. These checks provide descriptive support rather than primary evidence, and should not be read as prospective evidence for Proposition 4. Their “RevisionLedger > GraphRAG+abstain” entries are not render-matched: per the decomposition of §4.1, such gaps over a d-blind baseline are largely render readability rather than the fine-d mechanism, so these rows should be read as evidence that some d-awareness helps (P1), not that fine typing is responsible. We treat agreement of direction as confirmation; magnitudes are reported but not always predicted. Rows R2, R3, and R6 all derive from Proposition 1 on overlapping data, so the seven rows test roughly five independent constructs: the L1 near-null (R1), Proposition 1’s separation (R2/R3/R6), the latestknown tie (R4), entity-keyed-memory failing on L2 (R5), and the out-of-tier floor (R7).
Atom-dropout noise
∆
95% CI
∆
95% CI
n
−0.016 −0.099 −0.063 −0.097 −0.083 −0.034
[−0.058, +0.029] [−0.146, −0.054] [−0.108, −0.016] [−0.142, −0.049] [−0.128, −0.038] [−0.079, +0.013]
−0.007 −0.034 −0.049 −0.040 −0.045 −0.043
[−0.049, +0.036] [−0.079, +0.013] [−0.097, −0.002] [−0.085, +0.004] [−0.088, +0.000] [−0.083, −0.004]
445 445 445 445 445 445
Auxiliary Directional Checks
Table 13: Controlled noise sweeps (DeepSeek judge), pooled over five answer-LLM families (n=445 paired observations per level). Noise at level p is injected identically into the fine-d and coarse-d arms. Relationlabel noise is non-monotone and never crosses zero; atom dropout likewise gives no tested level where fine-d wins.
pose the same retained states, and their residual difference is ordering/layout. The residual is larger than on ESR-Bench because TempLAMA streams are longer (often ≥ 3 distinct values), so sorting unordered closed edges is harder than reading a pre-ordered history. The retention threshold (discarding the prior is fatal; retention is necessary) and the representation-dominates-mechanism reading therefore hold on external KG-gold data with exact-match scoring. The magnitude of the ordering residual is stream-length-dependent, so ESR-Bench’s “coarse retention captures most of it” (+0.111) is the short-stream case, not a universal scope point. The snapshot render confound is not testable here (ceiling, not refutation). On the reverted-revert streams, TempLAMA is a ceiling case rather than a mechanism test: all three renders score ≥ 0.96 (flat chronological list 0.965, render-only ledger 0.957, deprecation-marked ledger 1.000; render term −0.008 [−0.021, +0.006], n=1,185 = 237 streams × five families), so the apparent +0.043 fine-over-render-only difference is not a measurable mechanism effect. The reason is simple: a clean (year, value) tuple list makes the current value trivially readable in any layout. This is consistent with the render confound being a property of prose-like, hard-to-read streams (issue threads, re-
F
Reproducibility
Render-matched protocol. The render-matched control is specified as a benchmark-agnostic transformation that other memory comparisons can reuse: given a system’s structured render, construct a matched render-only ablation by forcing every co-keyed relation to SAME - STATE while holding layout and IDs fixed, then compare paired outputs under the same judge. This isolates layout from mechanism. The render-matched decomposition (§4.1), controlled noise sweeps (§C), and provenance experiments (§4.3) use the five answer-LLM families listed below and the same paired-scoring conventions as the corresponding main analyses. Robustness controls. All semantic-correctness numbers use a DeepSeek non-thinking judge as the primary axis (DeepSeek-V3 for the main analyses and render decomposition; DeepSeek-V4-flash for the provenance, noise, strata, and extraction experiments). We include three robustness controls. (i) Judge independence: the render decomposition 25
Row
Prediction
Direction
Test
Observed
R1
no useful ledger gain on singlepassage conflicts time-only entity memory fails on reverted-revert mixed-gold calibration trap is amplified in the auxiliary construction latest-known streams need no ledger
near-null
FaithEval-inc., n=7,500 Aux. GitHub, n=734
small loss: ∆ −0.026 [−0.039, −0.013] +0.131 [+0.101, +0.161]
ESR-GitHub 5-family, n=5,990
+0.375 [+0.362, +0.389]
✓dir
DyKnow, n=120/family
ε ≈ 0.3 noise floor (4 fam.)
✓qual
WikiContradict, n=1,265
0% recall every family
✓
GitHub×5 + Wiki×5, n=4,110
+0.087 [+0.075, +0.098]
✓
DyKnow/Wiki-mono/GHmono/LME
ε ≈ 0.3–0.65 (all ≫ 0)
✓qual
R2 R3 R4 R5 R6 R7
RevisionLedger > GraphRAG+abstain RevisionLedger > GraphRAG+abstain RevisionLedger ≲ latest-only entity-keyed memory fails cross- graphrag-lite ≪ all source conflict held-out L3 reverted-revert separation RevisionLedger > replicates GraphRAG+abstain fine ledger has out-of-tier implemen- ε > 0 qualitative tation cost
Status =
✓small ✓
Table 14: Auxiliary directional checks on the high-noise split and external probes. Confirmation is by direction and evidence strength, not magnitude. Status legend: ✓ is a full directional match; ✓small is a practical near-null rather than statistical equality; ✓dir is direction-only, with magnitude shaped by the auxiliary construction; and ✓qual is qualitative. This table is separate from the primary results and from Proposition 4’s channel explanation of the new reversals.
and the provenance gap are reproduced by an outof-family MiniMax-M2.5 judge; the d-mechanism residual stays at +0.021 (n.s.) and the provenance ordering is unchanged. (ii) External benchmark: the retention ordering replicates on TempLAMA with Wikidata gold and exact-match scoring (§D), while the small DyKnow provenance slice concurs. (iii) Fixed analysis rules: the external replication and deployment-fallback control used predictions and interpretation rules fixed before judging; the deployment-fallback outcome is interpreted under that fixed rule.
text excluded. No raw thread/revision text or personally-identifying data is redistributed; only event IDs, atom-level extractions, and source URLs are included after a PII/credential scan. Extractor coverage. We have no human atom labels, but the benchmark’s gold supporting/deprecated event ids give two automatic coverage checks. Event recall — the fraction of goldrelevant events that produced ≥ 1 atom — is 0.86 on ESR-Bench-GitHub (1770/2055) and 0.84 on MultiRepo (108/128); roughly one in seven goldrelevant events is missed, so the reported gains are conservative with respect to extraction recall. Co-key recall — among items with both a gold supporting and a gold deprecated event extracted, the fraction whose atoms land on a shared (x, a) key (the precondition for a supersession edge to fire) — is 0.96 on GitHub (585/609) and 1.00 on MultiRepo (38/38). The bottleneck is therefore event-level extraction recall, not co-keying: once both endpoints are extracted they almost always reach the same ledger key, so supersession is rarely lost to mis-keying. (Mean 2.6 atoms/event, 3.7–4.2 distinct keys/stream — the extractor is not collapsing the stream onto one key.)
Reproducibility details. Generation models: Llama-3.1-8B-Instruct, Mistral-7B-Instruct-v0.3, Qwen2.5-7B-Instruct, Qwen3-8B, Qwen3-14B; decoding T =0, single generation per item, batched on vLLM. DeepSeek-V3 / DeepSeek-V4-flash judge evaluations use T =0. The BERT pair scorer uses bert-base-uncased (∼110M parameters), trained on the 500-pair DeepSeek-labelled audit set with 5-fold stratified CV, AdamW learning rate 2×10−5 , and 8 epochs by default. The released artifacts document bootstrap seeds and B values. Data licences follow the upstream sources: GitHub issue threads under each repo’s licence (the dominant huggingface/datasets subset is Apache-2.0), Wikipedia revisions under CC-BYSA-4.0, and the external probes (DyKnow, LongMemEval, WikiContradict, FaithEval, StreamingQA) under their respective research-use distributions. The released artifacts include derived experiment outputs, generation and judge prompts, model versions and dates, decoding parameters, bootstrap seeds, pair-scorer metadata, and agreementfiltering rules, with upstream raw thread/revision
G
Supporting Noisy-Regime Tables
Unless explicitly marked as primary, the following appendix tables are measured on the auxiliary high-noise ESR-Bench construction or on external probes. They provide the supporting details behind the directional checks in §E; the main text uses the DeepSeek-labelled primary surface. These auxiliary numbers are deliberately not render-matched, 26
and several sit in a high-noise regime where RevisionLedger can lose on monotonic or csc through implementation cost rather than through a failure of the primary reverted-revert claim. FaithEval is the L1 no-effect probe in Table 14, so near-zero or negative RevisionLedger deltas there are expected. The reverted-revert slice in these tables is the larger auxiliary split (n = 734/family), distinct from the primary DeepSeek surface.
Family
RevisionLedger G RAPH RAG- LITE GraphRAG+abstain RAG- TOP - K D IRECT CONTEXT
0.543 0.693 0.548 0.101 0.101
0.086 0.343 0.314 0.029 0.029
0.238 0.180 0.136 0.052 0.078
0.643 0.000 0.857 0.500 0.452
Table 15: Per-phenomenon correctness under the auxiliary Qwen-judge evaluation on the high-noise ESRBench-GitHub split. RevisionLedger wins the target reverted-revert slice while entity-keyed memory wins monotonic and refines: the load-bearing claim is structural, not uniform. Conflict is the csc boundary case: under this evaluation’s gold-abstain scoring, prompt-only GraphRAG+abstain abstains more readily and scores higher, GraphRAG-lite floors because it never abstains, and the rule-scored RevisionLedger unresolved path is the brittle decoder case discussed in §E.
Family
RL cal. GRW cal.
Llama-3.1-8B Mistral-7B Qwen2.5-7B Qwen3-8B Qwen3-14B
0.910 0.871 0.634 0.960 0.932
0.466 0.276 0.362 0.918 0.407
0.297 0.269 0.089 0.097 0.113
0.038 0.023 0.028 0.101 0.042
Table 16: Per-family abstain calibration and chancecorrected agreement on ESR-Bench-GitHub. Qwen38B has the smallest calibration gap and is the only family where GraphRAG+abstain κ matches or slightly exceeds RevisionLedger κ, consistent with the noise-floor saturation regime where structured-render extraction is the binding constraint (§2).
H
VERB .
MIN .
JSON
Mistral-7B
RevRev +0.170 +0.253 +0.173 +0.215 FaithEval −0.021 −0.018 −0.012 +0.000
Qwen2.5-7B
RevRev +0.041 +0.089 +0.099 +0.072 FaithEval −0.161 −0.157 −0.146 −0.142
Qwen3-8B
RevRev +0.158 +0.289 +0.257 +0.312 FaithEval −0.043 −0.043 −0.033 −0.039
Qwen3-14B
RevRev +0.053 +0.112 +0.121 +0.108 FaithEval −0.018 −0.016 −0.024 −0.003
labels: event and relevant-atom counts, co-keyed value diversity, value/polarity reversal, granularity refinement, gold abstention, source-role diversity, any value change, and deprecated-event count. Because this feature set includes benchmark-side fields such as deprecated-event count and gold abstention, the table is a sanity check on structural separability, not a deployable pre-architecture router.
∆ RL κ GRW κ +0.444 +0.594 +0.272 +0.042 +0.525
COMP.
Table 17: Render-format ablation, full per-family ∆ grid. RevRev rows are ∆RL−GRW on the reverted-revert slice (n = 734/family); FaithEval rows are ∆RL−RAG on FaithEval-inconsistent (n = 1,500/family). FaithEval is an L1 intra-passage probe, so near-zero-to-negative rows are the expected no-effect pattern rather than a fine-ledger failure. All six arms use the same evaluation setup and DeepSeek-V3 judge. Qwen3 families used /no_think; the Qwen3-8B RevRev sign should therefore be read under the reader-capability scope condition, not as a contradiction of the main results.
Mono (n = 387) Refines (n = 35) Reverted (n = 734) Conflict (n = 42)
System
Slice
Llama-3.1-8B RevRev +0.046 +0.119 +0.155 +0.075 FaithEval +0.017 +0.027 +0.011 −0.013
Operationalizing the Diagnostic (Post Hoc)
The diagnostic claim — that the conflict tier is largely a structural property of the data — is testable post hoc: train a classifier on ESR-BenchGitHub phenomenon labels and evaluate it held-out on ESR-MultiRepo (a different repo distribution: PyTorch, Rust, Transformers, TensorFlow). We compare a structural diagnostic classifier against a lexical TF–IDF+LinearSVC over the stream text and a majority-class baseline. The structural classifier uses nine features from extracted atoms, event metadata, and benchmark 27
Family
MultiRepo ∆RL−GRW full (n=77)
ε (n=120)
+0.116 +0.140 +0.093 +0.233 +0.000
−0.065 −0.013 −0.052 +0.013 −0.091
— 0.317 0.250 0.350 0.241
+0.116 (4/5>0)
−0.04
0.290
Llama-3.1-8B Mistral-7B Qwen2.5-7B Qwen3-8B Qwen3-14B mean
DyKnow
RevRev (n=43)
Family
Table 18: Auxiliary held-out MultiRepo and DyKnow evaluations under the same auxiliary setup, extending single-family checks to five answer families. MultiRepo, RevRev subset (n = 43/family): ∆RL−GRW ; RevisionLedger > GraphRAG+abstain in 4 of 5 families (Qwen3-14B at the noise floor), cross-family mean +0.116, supporting P1 on a held-out repo distribution. MultiRepo, full set (n = 77/family): mean −0.04, near zero with a slight negative tilt because the non-revrev items are mostly monotonic/refines, where the auxiliary out-of-tier analysis expects little benefit. DyKnow: per-family ε from the auxiliary multifamily held-out evaluation; this auxiliary setting has no matched Llama-family DyKnow cell, unlike the primary DyKnow coverage in Table 1. For the four covered families, ε ∈ [0.24, 0.35], mean 0.29, with magnitude left to the implementation-cost terms.
GRW cal.
0.285 0.451 0.729
0.750 0.574 0.286
+0.625 +0.459 +0.181
terse verbose (main) conservative
0.572 0.409 0.421
0.452 0.624 0.613
+0.299 +0.462 +0.450
Mistral-7B
✓ × × ×
reverted-revert 734 +0.169 0.0001 ✓ monotonic 387 −0.233 0.0001 ✓loss csc (gold = A BSTAIN) 42 −0.167 0.016 ✓loss refines 35 −0.057 0.75 ×
acc
m-F1
RR
Mono
CSC
Ref
Majority-class 0.558 0.179 — — — — Lexical (TF–IDF) 0.766 0.399 0.887 0.711 0.000 0.000 Structural 0.818 0.794 0.816 0.958 1.000 0.400
abstain rate ∆RL−GRW
terse Llama-3.1-8B verbose (main) conservative
p Holm
Table 20: Auxiliary high-noise RL vs GraphRAG+abstain per-phenomenon results on Llama and Mistral × GitHub under DeepSeek-V3. Two-sided permutation p over paired binary outcomes (B = 10,000); Holm-Bonferroni at α=0.05 over four tests per family. ✓loss marks a Holm-significant effect in the expected-loss direction. The magnitude on monotonic and csc varies between Llama (effective tie) and Mistral (significant loss), showing the unpinned ε implementation-cost term in the auxiliary noisy regime.
Classifier
Wording
∆
reverted-revert 734 +0.131 0.0001 csc (gold = A BSTAIN) 42 −0.190 0.021 Llama-3.1-8B refines 35 −0.200 0.067 monotonic 387 +0.003 1.0
Mistral-7B
Family
n
Phenomenon
Table 21: Conflict-tier classification, trained on ESR-Bench-GitHub phenomenon labels and evaluated held-out on ESR-MultiRepo (n = 77; tiers RR = reverted-revert, Mono = monotonic, CSC = crosssource-conflict, Ref = refines). The structural diagnostic recovers the tier at 0.79 macro-F1, far above the majority baseline (0.18) and lexical baseline (0.40). RR, Mono, and CSC are recovered cleanly (F1 = 0.82/0.96/1.00); the low-sample boundary is REFINES (F1 = 0.40, n = 5 test, n = 35 train). The main confusion is RR versus Ref: 11 of 43 RR test items are predicted as Ref, reflecting overlap between valuereversal and granularity-refinement cues. Because this diagnostic uses benchmark-side fields, it is not claimed as a deployable router.
Table 19: Robustness of the GraphRAG+abstain control’s calibration to the abstain-prompt wording (gold abstain rate 0.035). Three paraphrases of the abstain instruction (terse, the paper’s wording, and a conservative “prefer to answer” variant) move the control’s calibration over a substantial band. RevisionLedger’s calibration is reused from Table 16 because the ledger decision is deterministic under this wording change. RevisionLedger beats GraphRAG+abstain in all six (variant, family) cells; the structural ordering “selective abstain > prompt-only abstain” is invariant to the control wording, while the magnitude moves.
28