When a language model is asked to check and revise its own answer, it often makes things worse. It talks itself out of correct answers, and when the same model both writes and grades, the grades rise while real quality stalls. This note proposes a narrow fix taken from logic. Classical logic has the principle of explosion: once a knowledge base contains a contradiction, every statement follows from it. Database theory and paraconsistent logic avoid this by marking each fact with one of four states: supported, refuted, both, or neither. Facts in conflict are quarantined and are never used to derive anything. We apply that bookkeeping to the history of a self-correction loop. Each draft is broken into short atomic claims. Each claim is checked twice, in a fresh context with no dialogue history: once for evidence that supports it and once for evidence that refutes it. The reviser may rewrite a claim only if the claim is refuted and has never been supported. A claim that is supported in one round and refuted in another becomes "both," and it is flagged or withheld rather than flipped to its negation.
The third ingredient is how drift gets measured. Word-overlap metrics such as ROUGE and BLEU count shared word sequences. They cannot see the most dangerous revision, which is a small edit that inverts meaning: a swapped entity, a moved negation, a changed number. Assessing The Factual Accuracy of Generated Text reports ROUGE above 90 after dates and locations were deliberately corrupted. A refinement loop monitored by overlap with the previous draft or with a reference will therefore miss the correct-to-incorrect flips that make self-correction fail. The proposal tracks revisions at the level of claims and their truth states, and it reports flips explicitly.
Core Claim
Most of the damage from intrinsic self-correction comes from unsupported overwrites: the reviser asserts the negation of a claim for which independent evidence existed. A four-valued gate removes most of these overwrites without giving up the true fixes. The gate permits an edit only when a claim is refuted and unsupported. It quarantines claims that have been both supported and refuted, and it keeps evidence monotone across rounds, so that once a claim is supported the support is never forgotten. The expected result is that refinement stops falling below the single-pass baseline on closed-answer reasoning tasks, and that on long-form summarization it improves factual consistency where majority voting is not even defined. The new part is not checking claims, which earlier work already does. It is treating the accumulated checks across rounds as a possibly inconsistent knowledge base and deciding edit permissions and the final output with repair-style semantics, instead of letting the latest critique win.
Grounding in Prior Work
Two papers motivate the work by documenting the failure. Large Language Models Cannot Self-Correct Reasoning Yet shows that, without an oracle, self-review lowers GSM8K accuracy (GPT-4 from 95.5% to 89.0%, Llama-2-70b from 62.0% to 36.5%) mainly through correct-to-incorrect flips. Spontaneous Reward Hacking in Iterative Self-Refinement shows that a judge sharing history with the writer inflates its scores. We take both diagnoses at face value. Our verifier never sees the dialogue, and our gate targets flips specifically.
Two papers supply the method. Sound and Complete Neurosymbolic Reasoning with LLM-Grounded Interpretations maps model outputs to a four-valued logic using separate "verify" and "refute" prompts, keeps a persistent cache of valuations, and reports that this bilateral scheme beats unilateral true/false prompting by 0.062 macro F1 on GPQA. That system is a one-shot verifier for isolated propositions. We reuse its bilateral valuation and its cache, and we make them control a multi-round rewrite of free text. The repair semantics from consistent query answering decide what the final answer contains. Cautious semantics keeps only what holds in every repair. Intersection-of-repairs semantics keeps only facts involved in no conflict. Ultimately we mostly need the simple claim-level form of these, and we do not use the heavier abduction machinery of Abductive Reasoning in a Paraconsistent Framework.
The closest refinement methods constrain the design. Self-Refine uses one model for writing, feedback, and revision, and nothing arbitrates when feedback in round $t$ contradicts round $t-1$. REFINER trains a critic that returns structured ⟨error type, position, hint⟩ feedback on intermediate steps and gains +13.1 points on SVAMP. It requires task-specific training and does not handle a critic that contradicts itself. Chain-of-verification (CoVe), as evaluated in Can LLMs Correct Themselves?, asks independent verification questions and revises; it is the most dangerous competitor, discussed below. On evaluation, TRUE supplies factual-consistency checkers based on entailment and question answering. It also documents a sharp accuracy drop once the grounding text exceeds about 200 tokens, which shapes how we chunk evidence.
Research Program
The loop has four parts. A generator produces a draft. A decomposer splits the draft into atomic claims; for math these are the stated intermediate equalities and the final answer, and for summaries they are subject–relation–object statements in the style of the triplet extraction of Assessing The Factual Accuracy of Generated Text. A bilateral verifier assigns each claim $c$ a pair $v(c) = \langle u, w \rangle$. Here $u = 1$ if some independent query found support and $w = 1$ if some independent query found refutation. Each query sees only the claim and an evidence chunk of under 200 tokens: the problem statement, a source passage, or recomputed arithmetic. Valuations are cached and only ever move upward across rounds, so a claim supported in round 1 and refuted in round 3 ends at $\langle 1,1 \rangle$. The reviser receives the draft together with a list of editable claims, defined as those with $v(c) = \langle 0,1 \rangle$. It is instructed to leave everything else intact, and a post-check rejects any revision that negates a claim with $u = 1$.
The final output follows cautious semantics. Claims at $\langle 1,0 \rangle$ are asserted. Claims at $\langle 1,1 \rangle$ are either withheld or stated with an explicit hedge; we test both. Claims at $\langle 0,0 \rangle$ are kept only under a looser variant that accepts any claim not refuted. For closed-answer tasks, if the final answer's claim ends at $\langle 1,1 \rangle$, the system returns the earliest supported answer rather than the latest one.
The analysis rests on a flip ledger. For every revision we record which claims changed truth state and whether the change moved toward or away from gold. Gold comes from the answer key on reasoning tasks and from entailment against the source on summaries. Correct-to-incorrect flips become the primary diagnostic rather than a footnote. Alongside the ledger we report draft-to-draft ROUGE. This tests directly the claim that overlap-based monitoring misses the flips that matter: we expect flips to concentrate in revisions whose ROUGE against the previous draft is above 0.9.
Baselines
The naive reference point is the single-pass answer with no refinement, using the same initial prompt as every refinement method. Following the warning in Large Language Models Cannot Self-Correct Reasoning Yet that weak initial prompts inflate refinement gains, this prompt is a tuned chain-of-thought prompt. Can LLMs Correct Themselves? reports that such a baseline is often competitive. Beating it is the minimum bar.
Intrinsic self-correction in the form of Huang et al. ("review your previous answer and find problems") and Self-Refine are the methods the gate is meant to repair. They run with the same generator, the same number of rounds (up to four), and no oracle stopping. The reported reference points are the GSM8K drops above, 95.5% to 89.0% for GPT-4 and 75.9% to 74.7% for GPT-3.5. Success means the gated loop stays at or above single-pass accuracy, with flips cut by at least half relative to these loops.
The strongest existing method is CoVe, which Can LLMs Correct Themselves? reports improves GPQA by +23.24% on CorrectBench. We run it on CorrectBench with the same generator. We count every model call and match total tokens, and the verifier model is shared with our method. Beating CoVe means higher accuracy at equal tokens on CorrectBench, together with a lower flip rate. A tie on accuracy with fewer flips would still be informative, but it would not count as a win.
On closed-answer tasks, self-consistency at matched sample count is the compute-matched rival. Huang et al. report 88.2% on GSM8K with nine voted samples, against 83.0% for nine-sample debate. We report against it honestly.
Two ablations isolate the key ingredient. The first is a unilateral gate: one true/false verifier query per claim, with edits allowed when the claim is judged false. This tests whether the four-valued state matters, extending to multi-round revision the 0.062 F1 gap that Sound and Complete Neurosymbolic Reasoning found for single queries. The second is a memoryless gate with bilateral queries but no cross-round cache, so only the current round's valuation counts. It tests whether monotone evidence, the part that turns "supported earlier, refuted now" into quarantine, is what prevents flips. A third ablation lets the verifier see the dialogue history, to reproduce the collusion effect.
Why not just…?
Why not just use self-consistency voting? On GSM8K this is a real threat: 88.2% with nine votes per Huang et al. is a hard number to beat. Our gate may only match it there. We say so in advance and treat closed-answer tasks mainly as the place where flips can be measured cleanly. The case for the gate rests on long-form summaries, where there is no discrete answer to vote on. Prompt-reverse inconsistency, described in Prompt-Reverse Inconsistency, also suggests that repeated sampling from the same prompt shares systematic errors. We also test the hybrid of voting over gated outputs, which tells us whether the two help in different ways.
Why not just use CoVe, which already verifies claims independently? CoVe checks the current draft and revises it, so it has no record that a claim was supported two rounds ago. A noisy refutation in the latest round can therefore still flip a correct claim. The memoryless-gate ablation is essentially CoVe with explicit edit permissions. If the full gate does not beat it on flip rate, the cross-round paraconsistent bookkeeping adds nothing, and we would report that the gains come from verification alone.
Why not just accept a revision only when an LLM judge scores it higher? This is G-Eval-style judging, with a Spearman correlation of 0.514 on SummEval in G-Eval. It produces a whole-draft score and cannot say which claim got worse, and inside a loop it is exactly the setup that Spontaneous Reward Hacking shows inflating. We run a judge-gated loop as an extra baseline on SummEval. We expect its online scores to rise while human-annotated consistency does not, whereas the claim gate's improvements should hold up under the same evaluation.
Why not just use a fixed threshold on a factuality score such as the TRUE ensemble? The ensemble reaches ROC AUC 86.0 in TRUE. A threshold folds "refuted" and "contested" into one number, so a contested claim gets edited whenever noise pushes it below the cut. The unilateral-gate ablation, run with the TRUE ensemble as its verifier, tests this directly.
Proposed Experiments
For reasoning we use GSM8K, CommonSenseQA, and HotpotQA under the protocol of Huang et al., plus the 3,825 items of CorrectBench for the CoVe comparison. Metrics are accuracy, correct-to-incorrect and incorrect-to-correct flip counts, and total tokens.
For long-form text we refine CNN/DailyMail summaries from the SummEval codebase. We score them with TRUE-style entailment against source chunks of under 200 tokens, with triplet precision ($fact_{acc}$) on the Wikifact setting, and with fresh human consistency ratings on a 200-summary subset. Draft-to-draft ROUGE is logged throughout.
We also build a minimal-pair stress set. Correct drafts are perturbed with single entity swaps or negation insertions, so overlap with the original stays very high. We then measure whether each loop restores the original or adopts the perturbation; on this set word-overlap monitoring is blind by construction.
The decisive check has three parts that must hold together. The gated loop must not fall below single-pass accuracy on GSM8K, where Self-Refine-style loops do. Its correct-to-incorrect flip rate must fall well below the memoryless and unilateral ablations. On SummEval, its human-rated consistency gains must exceed those of the judge-gated loop at matched tokens. If the memoryless ablation matches the full system, the paraconsistent component is unnecessary and we will report that plainly.
References
- Assessing The Factual Accuracy of Generated Text
- Large Language Models Cannot Self-Correct Reasoning Yet
- Spontaneous Reward Hacking in Iterative Self-Refinement
- Sound and Complete Neurosymbolic Reasoning with LLM-Grounded Interpretations
- Abductive Reasoning in a Paraconsistent Framework
- Self-Refine: Iterative Refinement with Self-Feedback
- REFINER: Reasoning Feedback on Intermediate Representations
- Can LLMs Correct Themselves? A Benchmark of Self-Correction in LLMs
- TRUE: Re-evaluating Factual Consistency Evaluation
- Prompt-Reverse Inconsistency: LLM Self-Inconsistency Beyond Generative Randomness and Prompt Paraphrasing
- G-Eval: NLG Evaluation using Gpt-4 with Better Human Alignment