Superseded Facts as Distractors: Top-Weighted Ordinal Memory for Evolving Knowledge

When a language model's memory or retrieval index holds several versions of the same fact, the old versions do not sit there harmlessly. A user's address from last year, a company's revenue guidance from two quarters ago, or a minister who has since resigned all read as plausible, on-topic text. We propose that these superseded versions behave like the semantically coherent distractors that are known to break model reasoning. If that is right, the fix is not better timestamps. The fix is a memory that records the order in which versions replaced one another, keeps that order precisely only near the top (the current value), and blurs or hides everything below.

The idea borrows from an old result. Judea Pearl showed that when stored data is ordered and transitive (if A beats B and B beats C, then A beats C), tolerating a little error saves far more memory than it does for independent facts. We apply this to evolving facts. For each fact "slot" (one entity and one attribute), the system infers a supersession order from pairwise textual evidence, using transitivity to limit the number of model calls. It stores the order with a distortion measure that punishes errors at the top heavily and errors deep in the history lightly. At answer time, the reader sees only as much of the order as the question needs. The deliverables are a diagnostic showing whether obsolescence acts as distraction, and a memory design whose reader-facing "rate" (tokens shown, comparisons spent) traces a measurable curve against state-drift hallucination.

Core Claim

We make two linked claims. First, an empirical one: under oracle retrieval, adding superseded versions of a fact to the context degrades current-state accuracy more, per token, than adding unrelated distractors of matched length. The effect grows when the old version is repeated or prominent. This would explain two findings that so far stand apart. Can Agent Memory Systems Track Evolving State? reports a "salience trap": agents pick stale values even with perfect retrieval, and chain-of-thought sometimes makes this worse. Breaking Focus: Contextual Distraction Curse in Large Language Models shows that coherent distractors cut accuracy by about 45% even when the model knows the answer. No one has tested whether the first is an instance of the second.

Second, a design claim. Answering "what is true now" depends only on the top of each slot's version order, so the right distortion measure is asymmetric. Consider a slot with $n$ versions whose true supersession order is $\sigma$, and a stored approximation $\hat\sigma$. We define

$$ D_w(\sigma,\hat\sigma)=\sum_{(i,j)\ \text{misordered in}\ \hat\sigma} w\big(\min(\mathrm{rank}_\sigma(i),\mathrm{rank}_\sigma(j))\big). $$

Here the sum runs over pairs of versions whose relative order $\hat\sigma$ gets wrong, and $w(r)$ is a weight that decreases with rank $r$, so that $r=1$ is the current version. With uniform $w$ this is the Kendall-tau distance (the number of misordered pairs) studied by Compression in the Space of Permutations. That paper derives rate-distortion functions for symmetric metrics and gives block-sorting quantizers. The file notes that such symmetric bounds ignore the top-$k$ emphasis of real queries.

Under a steeply decreasing $w$, we expect a scheme to be near-optimal if it keeps the top version exact and sorts only coarse blocks of older versions. Such a scheme needs about $n-1$ pairwise comparisons to find the top, plus a few block comparisons. That is far fewer than the roughly $n\log n$ comparisons that work shows are needed for moderate symmetric distortion. This expectation follows from adapting their "sorting subsequences" quantizer: finding a maximum costs $n-1$ comparisons, and coarse blocks cost little. We treat it as a conjecture to check empirically, not a proven bound.

Research Program

The work has three parts.

The diagnostic. We start from StateMemBench scenarios with oracle retrieval of the relevant slot. We then inject controlled contexts:

  • $k$ superseded versions of the queried slot, with or without timestamps, and with or without repetition of the oldest version;
  • length-matched unrelated distractors;
  • length-matched distractors from other slots of the same entity.

We measure current-state accuracy as a function of $k$ and of salience. We also run a version where superseded values are placed by the error-guided tree search of Adaptive Distraction, restricted to true historical values rather than invented ones. This tests whether real obsolescence is near worst-case distraction.

The write path. When a new mention of a slot arrives, an LLM judge decides from text alone whether it supersedes the current top version. The judge reads cues such as "moved," "now," "used to," or a retrospective "back in March I had…". Transitive closure fills in the rest of the order. Older versions are merged into coarse blocks, compared only when a history question requires it.

This departs deliberately from timestamp-driven systems. RAG Meets Temporal Graphs builds quadruples with timestamps and a fixed year-to-day tree, and admits that missing or noisy timestamps break it. The duration predictor of Mitigating Temporal Misalignment by Discarding Outdated Facts needs the fact's start time, which it lacks. Our order is relative and needs neither. Timestamps, when available, enter only as one more piece of pairwise evidence.

The read path. A light classifier routes each question as current-state, point-in-time, or trend/history. Current-state questions see only the top version. Point-in-time questions see the block containing the target time, resolved exactly within that block. Trend questions see the coarse order with one representative per block.

This read path also addresses the discard-versus-retain tension in the file. Zhang and Choi discard expired facts. Respecting Temporal-Causal Consistency argues that pruning old states causes "narrative blindness." In our design, both behaviours are points on one curve, chosen per question type rather than fixed globally.

Baselines

Naive reference. The model receives the full uncompressed history in a long context, with timestamps where the benchmark provides them. Every method uses the same reader model (one open model and one API model), the same retrieval, and the same token budget cap where applicable.

Last-write-wins. Keep each slot's most recent value by turn order or timestamp, and show only that. This is the cheapest serious competitor. On clean data it should nearly match our current-state accuracy. We will report it on clean splits and on two stress splits we construct from StateMemBench and ECT-QA:

  • a timestamp-corrupted split, where dates are removed or shuffled;
  • a retrospective-mention split, where an old value is mentioned after the new one.

Beating it means matching it on clean data and exceeding it on the stress splits.

StateMem. This is the strongest existing method on the core question. It stores structured state units with dependency links and uses a deterministic rechecker to flag stale derived values. Can Agent Memory Systems Track Evolving State? reports that it raised current-state accuracy on DeepSeek-V4-Flash from 0.205 to 0.363 over the strongest baseline. It also reports StateMemWrapper lifts of +32 to +67 points across six backends. We will run StateMem with the same reader and the same parsing model as our judge, so that differences come from the memory structure and not the extractor. Beating it means higher current-state accuracy on StateMemBench at equal or lower reader tokens. On the clean split, we expect parity rather than a win.

Temporal and retrieval systems. On SituatedQA we compare against duration-based discounting from Mitigating Temporal Misalignment, which reports 20.5 EM while retrieving for 45% of queries on $N=322$. On ECT-QA we compare against TG-RAG, which reports correctness 0.599 versus 0.385 for NaiveRAG (RAG Meets Temporal Graphs). On RealTime QA and NQ-style distractor settings we compare against Distraction-Aware Answer Selection from Improving Zero-shot Reader. That method adds an "unanswerable" escape instruction and reweights answers by query likelihood, and reports a 64% EM gain over naive zero-shot readers. For RealTime QA we report against GPT-3 with Google Search at 66.5% multiple-choice accuracy and 34.6 EM (RealTime QA). Our method there reorders and filters the same retrieved snippets.

Ablations. These isolate the key ingredient:

  • symmetric Kendall-tau quantization at the same comparison budget, versus top-weighted;
  • exhaustive pairwise comparison, versus transitive closure;
  • top-only display for all question types, which is Zhang–Choi-style discarding;
  • full exact order shown for all question types.

Why not just…?

Why not just keep the latest value by timestamp? On clean, well-timestamped data this may tie with our method, and we say so. Its weakness is that it assumes the write order equals the world order. That assumption fails under extraction noise, which RAG Meets Temporal Graphs names as its main brittleness, and under retrospective mentions. The stress splits settle this directly. If last-write-wins matches us there too, the ordinal judge is unnecessary, and the contribution shrinks to the diagnostic plus question-routed display.

Why not just pass everything and tell the model to use the newest fact, or let it reason step by step? The file reports two relevant failures. Instructions to ignore irrelevant text do not restore robustness (Breaking Focus). Chain-of-thought sometimes lowers state-tracking accuracy by rationalizing salient stale values (Can Agent Memory Systems Track Evolving State?). We include both as conditions in the diagnostic rather than assume they fail.

Why not just discard old versions entirely? For current-state questions, discarding is exactly what our read path does. Trend queries in ECT-QA and character-arc questions in ChronoQA, however, need history. The top-only ablation will show how much accuracy discarding costs on those question types.

Why not just use StateMem? StateMem tracks dependencies between derived facts, which we do not. It still takes the order of versions from turn order, and it does not control how many superseded versions the reader sees. We will test this point directly: if StateMem also beats us on the stress splits, our ordering mechanism adds nothing.

Decisive Checks

The project rests on three checks.

Is obsolescence distraction? In the diagnostic, superseded versions must hurt current-state accuracy more than length-matched unrelated text, with a dose-response in $k$ and in repetition. If they do not, obsolescence is not a distraction problem and the framing fails.

Does top-weighting earn its place? At equal comparison and token budgets, top-weighted quantization must beat symmetric quantization on current-state accuracy, while holding trend-question accuracy on ECT-QA. Otherwise the asymmetric distortion measure is decoration.

Does relative order beat timestamps? On the timestamp-corrupted and retrospective splits, our method must beat both last-write-wins and StateMem. Otherwise ordinal inference adds nothing over timestamps.

We will also plot accuracy against reader tokens and judge calls, giving an empirical rate-distortion curve. For Kendall-tau and footrule, the file reports no measured rate-distortion numbers on natural-language data; the closest existing quantitative results are theoretical. ChronoQA serves as the retention check: our method should not fall below the reported $E^2RAG$ score of 7.125/10 (Respecting Temporal-Causal Consistency).