Systems that fix factual errors in text written by large language models (LLMs) have a quiet failure mode. Asked to repair one wrong date, they also reword three correct sentences, swap a rare technical term for a common one, or "fix" a claim that was never wrong. This is over-correction. It gets worse when the fixer runs in a loop: every extra pass is another chance to rewrite something that was fine, and each pass costs another full read of the document. We propose that one learned decision can address both problems: after each pass, decide which spans of the text are settled and lock them. Locked spans are copied verbatim and never sent back to the model or the fact-checker again. The loop then works only on what is still uncertain, which should make it both more conservative and cheaper as it runs.
The difficulty is training that decision without human labels. Correctors in this area learn from synthetic data, meaning correct claims that another model has deliberately corrupted. In that data nearly every input contains an error. Real LLM output is mostly correct, so a corrector trained on corrupted claims arrives expecting something to fix. Our main technical bet is that the most realistic synthetic data for teaching restraint is not produced by a corruptor at all. It is the corrector's own over-corrections: the spans it wrongly edits when run on synthetic documents whose correct spans are known. These are exactly the mistakes it will make at deployment.
Core Claim
Iterative factual correction over-corrects for a structural reason. Suppose a document has $n_c$ correct spans and the corrector falsely edits each one with probability $p$ on every pass. After $K$ independent passes the expected number of damaged correct spans is about $n_c\,(1-(1-p)^K)$, which grows with $K$. The form follows directly from treating passes as independent chances to err. Locking changes this. If a correct span is locked after its first pass with probability $q$, damage is bounded by roughly $n_c\,p\,(1 + (1-q)(K-1))$, and compute per pass shrinks with the fraction of the document still unlocked. We claim three things. A span-locking decision trained on synthetic corruptions mixed with the corrector's own false edits reaches $q$ high enough that multi-pass correction keeps its recall gains on multi-error documents without its precision loss. The same decision cuts verifier calls and regenerated tokens by a large factor relative to full-document passes. And these gains carry over from synthetic training data to real, human-annotated LLM hallucinations.
This is not the same as stopping the whole loop early, and it is not a penalty on edit distance. Both of those act on the entire sequence. Locking acts on individual spans and persists across passes.
Where This Sits in Prior Work
Four papers motivate the proposal. Large Language Models Cannot Self-Correct Reasoning Yet shows that asking a model to revise its own answers flips correct answers into wrong ones. For example, Llama-2-70b on GSM8K drops from 62.0% to 36.5%. That is over-correction by iteration in its starkest form, and it tells us repeated passes are not free even when an external signal is present. Grammatical Error Correction with Contrastive Learning in Low Error Density Domains shows that the mismatch between training and deployment error density drives both gratuitous edits and missed edits in grammar correction. We carry that diagnosis into factual correction, where the mismatch is more extreme because synthetic corruptions are nearly 100% erroneous. FaithBench and HaluEval show that detecting hallucinations in real outputs remains hard: the best FaithBench detector reaches 62.31% balanced accuracy. So any locking decision will be imperfect, and the design has to tolerate errors in it.
Three papers supply methods we reuse. Improving Factual Error Correction by Learning to Inject Factual Errors (LIFE) trains a corruptor to inject factual errors into correct claims, filters the results by Levenshtein distance and a fact-verification classifier, and trains a single-pass T5 corrector on them. We keep its corruptor. We change the data mixture and add a pass loop and a locking decision, none of which LIFE has. Multi-pass Decoding for Grammatical Error Correction adds a sequence-level classifier that decides whether another pass is worthwhile, and fuses the source into each round. Our locking decision is its per-span generalization, and its classifier is our main ablation target. iRe2f shows in parsing that refinement need not re-encode everything, preserving throughput with lightweight updates. We borrow that principle, in a simpler form, by never regenerating or re-verifying locked spans.
Four papers constrain the design. Converge to the Truth (VENCE) already combines iterative editing, a verifier and a Hamming-distance penalty in a Metropolis-Hastings sampler. It is the closest existing work. However, its penalty is a soft global cost re-evaluated at every proposal, every span stays editable at every step, and every step calls a heavy verifier. We make persistent, hard, per-span commitments instead. DSVD and CoBa cut the cost of refinement by rolling back a few tokens during generation. They act while the text is being generated and rely on the model's internal signals, whereas we edit finished text against external evidence. Synthetic Alone is a warning: noise injection and rebalancing that help human-labeled data hurt purely synthetic grammar data, in one case taking TED from 56.14 to 38.15. Randomizing error density is exactly such a rebalancing, so we treat it as a hypothesis to test, not an assumption. Shipard et al. point the other way, finding that diversity in synthetic data matters more than realism. Our density ablation is designed to decide between these two views for factual text.
Research Program
The system has three parts. The first is a corrector: a 7B instruction-tuned model that, given evidence and a document split into claim-level spans, proposes a replacement for each span it is allowed to touch and copies every other span exactly. The copying is enforced by constrained decoding, so locked spans are guaranteed to stay untouched rather than merely encouraged to. The second is a fact-checker that scores each span against the evidence. We use the same RoBERTa-large-style verifier VENCE uses, so cost comparisons line up. The third is the locking head. It is a small classifier that reads the corrector's hidden state over a span, the checker's score, and whether the span changed in the last pass, and outputs the probability that the span is settled. Spans above a threshold are locked. The loop ends when every span is locked or after a pass limit.
Training data comes in three layers. The base layer applies the LIFE corruptor to Wikipedia passages and FEVER-supported claims, but at a per-document error density sampled from a wide range that includes zero, so most spans stay correct. This gives span-level ground truth: a span is "correct" exactly when the corruptor left it alone. The second layer is self-generated. We run the partially trained corrector over held-out synthetic documents for several passes and record every span it edited that was originally correct, labeling each as "should have been locked." We also record every corrupted span that it left alone or edited wrongly, labeling each as "must stay open." Retraining the locking head and the corrector on these cases is repeated twice. The third layer, used only for the corrector, adds edit-weighted training in the style of Edit-Wise Preference Optimization. That work concentrates reward on the first token of each edit and penalizes gratuitous rewrites. We apply it here to factual data for the first time, but we keep it as a separate ingredient so its contribution can be measured on its own.
The analysis has two measurements. For each system we plot two curves against the number of passes $K$: damage to correct spans (the $p$ and $q$ quantities above) and recovery of errors. The central prediction is that the damage curve flattens under locking and keeps climbing without it. For cost we report verifier calls, generated tokens and wall-clock time per document, all measured on the same hardware.
Baselines
The do-nothing reference returns the input unchanged. It scores perfectly on preserving correct text and zero on fixing errors, and it anchors the over-correction metric. Every system must beat its SARI score by a clear margin before its preservation numbers mean anything.
The strongest existing single-pass method is LIFE (LIFE), which reports a SARI of 65.59 on FECDATA, 10.59 points above VENCE, and beats 8-shot ChatGPT by 7.16 SARI. We retrain LIFE on our backbone with its own corruptor and filters, using the same pool of source passages and the same number of gradient steps as our system. We also run a stronger variant, LIFE plus unchanged correct claims mixed into training at the same density schedule we use. Beating LIFE means matching its FECDATA SARI within one point while achieving a significantly lower false-edit rate on correct spans, and exceeding it on multi-error documents.
The strongest iterative method is VENCE (VENCE), which reports SARI-Final 55.0 and ROUGE-2 59.1 on FECDATA. We run it with its published verifier and tune its sampling steps and Hamming weight on the same development set, with the same budget of tuning runs as our threshold search. Beating it requires higher SARI at no more than its verifier-call count. Our design target is at least 3× fewer calls.
The ablation that isolates our key ingredient replaces per-span locking with the sequence-level early-stop classifier from Multi-pass Decoding, keeping the same corrector, checker and training data. If this matches our damage curve and our cost, per-span locking adds nothing. Two further ablations remove the self-generated layer of training data, leaving corruptor data only, and replace randomized density with a single fixed realistic density.
We found no reported result on Lacuna for over-correction rates on correct spans for any of these systems, so all such rates will be measured by us. For real LLM output, the closest reported correction number is FLEEK's revision accuracy of about 72.7% on BenchLLM (FLEEK). We found no reported correction result on Lacuna for FaithBench.
Why not just…?
Why not just run one pass, since the first refinement step yields most of the gain? This is the most serious threat. On short, single-error FECDATA claims, we expect a strong single-pass corrector to be hard to beat, and we will report that honestly. Iteration earns its place only when documents contain several errors, or when fixing one claim changes what the evidence implies about another. We therefore build multi-error test documents by concatenating related FEVER claims at controlled densities, and we also evaluate on real multi-sentence LLM summaries. If single-pass LIFE with identity mixing matches our recall on these, we will drop the loop and report locking as a single-pass abstention mechanism.
Why not just mix unchanged correct examples into LIFE's training data? Cao et al. (contrastive GEC) suggest that density matching alone does not remove the tradeoff between restraint and missed errors. Synthetic Alone also shows that naive rebalancing of synthetic data can backfire. We run this directly as the "LIFE plus identity" baseline. Its difference from our self-generated-data ablation measures whether the corrector's own mistakes teach more than extra clean data does.
Why not just add an edit-distance penalty or a "make minimal edits" instruction? A penalty on edit distance is what VENCE already uses. It treats a correct long rewrite and a wrong short one as equally costly, and it must be paid again at every step. In our experiments that is the VENCE baseline and the EPO-only corrector with the loop but no locking. If either matches locking on the damage curve, our claim fails.
Why not just use DSVD-style rollback during generation? Rollback catches errors that the model's own hidden states flag. DSVD itself notes that it cannot fix facts the model never learned, and it does not see external evidence. Our setting is post-hoc editing against evidence, so the two methods are complementary rather than competing. We therefore do not run it as a head-to-head baseline.
Proposed Experiments
We evaluate on three test sets. The first is FECDATA, used to compare with LIFE and VENCE on their home ground. The second is density-controlled documents built from FEVER (FEVER): supported and refuted claims mixed at 10%, 25% and 50% error density, with the Thorne and Vlachos correction annotations (Evidence-based Factual Error Correction) serving as references. The third is real LLM output: FaithBench summaries with expert span annotations, and FLEEK's BenchLLM. The real-output sets are never used for training or threshold tuning. They are the direct test of synthetic-to-real transfer.
We report five metrics: SARI; false-edit rate on correct spans; recovery rate on erroneous spans; human-rated correctness on a 300-item sample, following LIFE's protocol; and verifier calls, generated tokens and latency.
Four checks are decisive. First, on density-controlled documents, the damage-versus-passes curve must stay flat under locking while it rises for unlocked iteration and for sequence-level early stopping. Second, on FaithBench and BenchLLM, the false-edit rate on correct spans must fall relative to LIFE plus identity, while error recovery is maintained. Third, removing the self-generated training layer must measurably reduce the locking rate $q$ on real data. If it does not, our synthetic-to-real argument is wrong. Fourth, the fixed-versus-randomized density ablation will show whether the fragility result from Synthetic Alone extends from grammatical noise to factual error counts.
References
- Large Language Models Cannot Self-Correct Reasoning Yet
- Grammatical Error Correction with Contrastive Learning in Low Error Density Domains
- FaithBench: A Diverse Hallucination Benchmark for Summarization by Modern LLMs
- HaluEval: A Large-Scale Hallucination Evaluation Benchmark for Large Language Models
- Improving Factual Error Correction by Learning to Inject Factual Errors
- Multi-pass Decoding for Grammatical Error Correction
- iRe2f: Rethinking Effective Refinement in Language Structure Prediction via Efficient Iterative Retrospecting and Reasoning
- Converge to the Truth: Factual Error Correction via Iterative Constrained Editing
- DSVD: Dynamic Self-Verify Decoding for Faithful Generation in Large Language Models
- Correction with Backtracking Reduces Hallucination in Summarization
- Synthetic Alone: Exploring the Dark Side of Synthetic Data for Grammatical Error Correction
- Diversity is Definitely Needed: Improving Model-Agnostic Zero-shot Classification via Stable Diffusion
- Edit-Wise Preference Optimization for Grammatical Error Correction
- FLEEK: Factual Error Detection and Correction with Evidence Retrieved from External Knowledge
- FEVER: a Large-scale Dataset for Fact Extraction and VERification
- Evidence-based Factual Error Correction