Several hallucination detectors work by asking a language model to turn text into a knowledge graph, meaning a list of subject–relation–object facts. They then check each extracted fact against a source document. These detectors assume the extracting model is a neutral reader that writes down what the text says. This note argues that the assumption fails in a specific and predictable way. Suppose a document states something that conflicts with what the extracting model memorized in pretraining, for example a player's new team or a deliberately edited birthplace. The extractor tends to write down the memorized fact instead of the stated one.
The consequence is a blind spot. Take a generated summary that wrongly repeats the "famous" version of a fact while the source says otherwise. Both the summary and the source can be parsed into the same memorized triple, so the detector passes the summary as faithful. The proposal measures this extraction leakage, shows how it hides one class of hallucinations, and tests a cheap fix that strips the extractor's ability to recognize the entity.
Core Claim
Graph-based hallucination detectors built on large-language-model extractors have systematically lower recall on hallucinations that agree with the extractor's pretraining memory than on hallucinations that disagree with it. We predict three things about this gap. It should widen for more prominent entities. It should widen for larger extractors, which DCR characterizes as more "contamination-exploitable." And it should widen when the conflicting object is a near neighbor of the true one in the graph.
The gap can be reduced by twin extraction. The extractor reads the document twice: once as written, and once with the focal entity's name replaced by an unfamiliar placeholder. Facts that change between the two readings were supplied by memory rather than by the text.
The idea draws on three findings that point in the same direction but were never connected. The first is AntiLeakBench, which built post-cutoff question answering from Wikidata edits and found an "Outdated Knowledge Trap": models answer with memorized facts even when the provided context states the update. The second is KG-FPQ, which generated false-premise questions by swapping graph neighbors and found that errors concentrate on near-neighbor swaps (the "proximity trap"). The third is GraphEval together with FactAlign. GraphEval extracts triples from a response and checks each with natural language inference, a classifier that judges whether one text entails or contradicts another. FactAlign aligns graphs extracted from both source and output. Both treat extraction errors as random information loss.
Our claim is that these errors are not random: they are pulled toward memory. That matters because it biases which hallucinations get caught. The contamination angle also differs from existing contamination work. We do not ask whether a benchmark leaked into a model being scored. We ask whether the evaluator's own memorized knowledge corrupts the measurement. Loss-based contamination detectors cannot answer that, and On The Fragility of Benchmark Contamination Detection in Reasoning Models shows such detectors fall to 50–58% AUROC on reasoning models. So we measure leakage behaviorally.
Research Program
The first step builds memory-conflict documents. The first source is AntiLeakBench, whose post-cutoff Wikipedia revisions state facts that changed after the model's cutoff; the authors report over 96% human-verified accuracy. In these documents the old value is what a model remembers and the new value is what the text says. The second source applies KG-FPQ-style object swaps directly inside source passages from WikiBio and from the summarization sets used by GraphEval. Swaps come in two kinds: near-neighbor swaps (place of death replaced with place of birth) and non-neighbor swaps. KGHaluBench supplies a prominence signal, based on page views and site links, which we use to stratify entities by how famous they are.
From each document we derive paired generated outputs, in which the injected hallucination either repeats the memorized fact (memory-consistent) or introduces a new wrong fact (memory-inconsistent). The two classes are matched in length and in which relation is affected. Unedited facts in the same documents serve as controls.
The second step measures extraction leakage directly. For each edited fact, leakage is the fraction of extractions that output the memorized object instead of the stated one. We measure it across extractor families and sizes, prompting styles, prominence tiers, and neighbor versus non-neighbor swaps.
The third step propagates the effect downstream. We run complete detectors on the paired outputs and report recall separately on the memory-consistent and memory-inconsistent classes. The quantity of interest is the recall gap between the two classes.
The fourth step tests twin extraction. If a triple's object differs between the named and placeholder readings, the triple is flagged as memory-supplied. The detector then substitutes the placeholder reading's object, re-bound to the real entity, before verification.
The obvious risk is that the placeholder itself degrades parsing. We control for this by measuring agreement between the two readings on the unedited control facts. If that agreement is low, the fix is confounded and we report it as such.
Baselines
The naive reference point skips the graph entirely. Sentence-level natural language inference is applied directly between source and output. GraphEval itself reports this is roughly as good as graph decomposition on short outputs. Because it never paraphrases the source into triples, it may suffer less memory leakage, which makes it a real competitor on exactly our question. It runs on the same paired outputs with the same inference model used inside the graph pipelines.
The strongest existing graph method is GraphEval with a large-model extractor. On SummEval, QAGS-C and QAGS-X it reports an average 6.2% balanced-accuracy improvement (standard error 1.3) over standalone inference models. We reproduce it with the same inference models and the same few-shot prompts. We use the same extractor model for GraphEval and for our twin variant, and give both an equal prompt-tuning budget on a held-out split.
The second graph baseline is FactAlign, which uses a classical pipeline of coreference resolution, named-entity recognition and relation extraction. FactAlign reports 0.889 F1 for hallucination detection on WikiBio and 0.825 F1 for intrinsic/extrinsic classification on XSum. Its smaller, non-generative extractor may carry less memory, so it tests whether leakage is specific to generative extraction. We predict FactAlign's WikiBio score will fall on our edited versions, because WikiBio biographies are prominent, likely pretraining material on which memory and source normally agree.
The ablation keeps the two-pass structure but replaces the placeholder reading with a meaning-preserving paraphrase that leaves the name intact. This isolates whether removing entity recognition is the active ingredient. A further baseline is span-anchored extraction, where every triple must quote a supporting span that is checked by string match.
Beating the field means two things. Twin extraction must shrink the recall gap between memory-consistent and memory-inconsistent hallucinations by a margin outside run-to-run variance. It must also keep overall balanced accuracy on the unedited SummEval/QAGS sets within GraphEval's reported range.
Why not just…?
Why not just drop the graph and use sentence-level inference? This is the most serious alternative. If the recall gap is small for sentence-level inference and large for graph pipelines, the honest conclusion is that extraction introduces the bias, and practitioners should prefer sentence-level checks on memory-sensitive content. That would be a useful negative result. The paired experiment decides it directly. We expect sentence-level inference models to carry their own memory bias, but we do not assume it.
Why not just tell the extractor to use only the text? Instructions are the cheapest fix. AntiLeakBench, however, shows that context which explicitly states an update still loses to memory, which suggests instructions may not suffice. We include instruction-only and span-anchored prompts as baselines. Span anchoring could plausibly close much of the gap. If it does, the leakage measurement still stands, and the recommendation becomes span anchoring rather than twin extraction.
Why not just use a classical extraction pipeline, which has less memory? FactAlign's pipeline is the test. Its documented costs are a restriction to named entities and errors that cascade from coreference resolution. If it shows a small recall gap with acceptable coverage, that is a legitimate answer to the problem, and we would report it.
Proposed Experiments
The decisive check comes first: on AntiLeakBench-derived documents and on the neighbor-swapped WikiBio and SummEval passages, does GraphEval-style detection show lower recall on memory-consistent than on memory-inconsistent hallucinations? If the gap is absent, the core claim fails.
Second, does leakage grow with entity prominence, with extractor size, and for near-neighbor rather than non-neighbor swaps? These patterns are predicted from DCR's scaling finding and KG-FPQ's proximity trap.
Third, does twin extraction close the gap more than the paraphrase ablation and the instruction baselines do, at matched compute of two extraction passes? We also run a double-pass GraphEval baseline so that the comparison isolates the placeholder rather than the extra pass.
All verdicts on edited facts are checked against the known edits rather than an automated judge. A 200-item human audit covers the unedited controls, given KGHaluBench's reported 87.74% ceiling on agreement between automated verifiers and humans.
References
- DCR: Quantifying Data Contamination in LLMs Evaluation
- AntiLeakBench: Preventing Data Contamination by Automatically Constructing Benchmarks with Updated Real-World Knowledge
- KG-FPQ: Evaluating Factuality Hallucination in LLMs with Knowledge Graph-based False Premise Questions
- GraphEval: A Knowledge-Graph Based LLM Hallucination Evaluation Framework
- FactAlign: Fact-Level Hallucination Detection and Classification Through Knowledge Graph Alignment
- On The Fragility of Benchmark Contamination Detection in Reasoning Models