One-sentence Summary

Researchers from Renmin University of China, Southeast University, and Zhejiang University propose DEDUCE, a three-stage framework that enhances LLM robustness by detecting input fact errors, devising correction strategies through multi-perspective deliberation, and correcting misconceptions, and introduce Mis-FactQA and new evaluation metrics, achieving consistent accuracy and error-correction gains on TruthfulQA, FalseQA, and MisFactQA across Qwen, LLaMA, and Gemma models.

Key Contributions

• The paper introduces DEDUCE, a three-stage framework that detects factual errors in user inputs through fine-grained fact extraction and verification, devises correction strategies via multi-perspective deliberation, and corrects misconceptions while generating reliable answers, thereby transforming LLMs from passive responders into proactive error correctors.
• A new dataset, MisFactQA, is presented along with fine-grained evaluation metrics to systematically assess model robustness against fact-perturbed inputs containing false premises, factual contradictions, and compound errors.
• Experiments on TruthfulQA, FalseQA, and MisFactQA show that DEDUCE consistently improves both answer accuracy and error correction capability across Qwen, LLaMA, and Gemma model families, confirming its effectiveness and scalability.

Introduction

Large language models encode substantial real-world knowledge and perform well on generative tasks, yet they remain prone to hallucinations, especially when real-world users enter queries with factual errors such as false premises, contradictions, or compound mistakes. Prior mitigation work mostly treats hallucination as a model-side problem across pretraining, fine-tuning, and inference, often assumes user input is correct, and either ignores erroneous premises or attempts self-correction that can be derailed by the same input. The authors argue that misleading user inputs can override parametric knowledge and induce hallucinations even in well-optimized models. To address this, they introduce DEDUCE, a detect, devise, and correct framework that locates and analyzes input errors, deliberates over response strategies, and answers from verified knowledge, alongside the MisFactQA benchmark and fine-grained metrics for evaluating robustness to fact-perturbed questions.

Dataset

The authors construct MisFactQA, a dataset for False Premise Question Answering (FPQA), by combining three sources with verified ground truth:

• Sources: a curated subset of Prize, EchoMist, and publicly available question answering datasets.
• Query–response pairs: each example requires the model to detect false information in the input and then generate the corrected premise together with the answer.
• Error types: to go beyond single‑error evaluation, the dataset introduces three categories of factual perturbation:
  • Single false premise – the input contains one incorrect statement that can mislead reasoning.
  • Internally contradictory descriptions – the input includes conflicting claims, forcing the model to choose between them.
  • Multiple errors – the input combines several false premises or a false premise with a contradiction, challenging the model’s ability to catch all issues.
• Usage: the paper employs MisFactQA as a benchmark to measure model robustness under factual perturbations. No explicit training split or mixture ratios are given in the main text; further construction details (e.g., exact sizes, filtering rules, metadata) are provided in Appendix B.2.

Method

The authors introduce DEDUCE, an input-side hallucination mitigation framework designed to address the limitations of existing approaches when handling factually perturbed inputs. Rather than propagating misinformation or failing at self-correction due to reasoning biases, DEDUCE reformulates the challenge into an explainable, debatable, and verifiable collaborative process. The framework comprises three synergistic modules: Detect, Devise, and Correct.

Detect: Input Detection and Analysis To prevent the model from being misled by superficially coherent queries, the Detect module employs an atomic fact detection mechanism. It decomposes a query $Q$Q into a set of minimal, independently verifiable factual units using a decomposition function $\phi$ϕ:

$$\phi(Q) = \{AC_1, AC_2, \dots, AC_n\}$$ϕ(Q)={AC1​,AC2​,…,ACn​}

where each $AC_i$ACi​ is a self-contained factual assertion. Each unit is independently assessed via a truthfulness check $\mathcal{F}(\cdot)$F(⋅) and a pairwise consistency check $C(\cdot, \cdot)$C(⋅,⋅):

$$\mathcal{F}(AC_i) = \begin{cases} 1, & \text{if } AC_i \text{ is factually incorrect} \\ 0, & \text{otherwise} \end{cases}$$F(ACi​)={1,0,​if ACi​ is factually incorrectotherwise​ $$C(AC_i, AC_j) = \begin{cases} 1, & \text{if } AC_i \text{ and } AC_j \text{ are mutually inconsistent} \\ 0, & \text{otherwise} \end{cases}$$C(ACi​,ACj​)={1,0,​if ACi​ and ACj​ are mutually inconsistentotherwise​

These checks yield disjoint error sets $\mathcal{E}_{\text{fact}}$Efact​ and $\mathcal{E}_{\text{conflict}}$Econflict​, allowing precise identification of error types and locations. The module then produces a structured diagnostic summary $\text{MisSum}(Q)$MisSum(Q) that grounds abstract judgments into concrete natural language claims, specifying whether errors exist, their locations, and their implications.

Devise: Multi-Perspective Deliberation To overcome the self-reinforcing biases inherent in single-model self-correction, the Devise module introduces a multi-perspective strategy debate mechanism. This process decomposes correction strategy formulation into three complementary roles, all conditioned on the internal knowledge of the model and $\text{MisSum}(Q)$MisSum(Q). First, the Generator (G) produces an initial draft strategy $s^{(0)}$s(0) to enumerate plausible correction pathways:

$$s^{(0)} = \mathcal{G}(Q, \text{MisSum}(Q))$$s(0)=G(Q,MisSum(Q))

Second, the Reviewer (R) adopts an adversarial stance to identify weaknesses in $s^{(0)}$s(0) across completeness, accuracy, and reliability, producing a structured critique $r$r:

$$r = \mathcal{R}(s^{(0)}, \text{MisSum}(Q))$$r=R(s(0),MisSum(Q))

If deficiencies are found ($r \neq \emptyset$r=∅), the Arbiter (A) intervenes to impartially evaluate both perspectives and generate a final, validated strategy $\pi^*(Q)$π∗(Q):

$$\pi^*(Q) = \mathcal{A}(s^{(0)}, r)$$π∗(Q)=A(s(0),r)

This role separation ensures a comprehensive and multi-perspective validated strategy before execution.

Correct: Correction and Response In the final stage, the model executes the validated strategy $\pi^*(Q)$π∗(Q) sequentially to ensure faithful adherence. The execution pipeline consists of three concrete actions: (1) Error Identification, explicitly pointing out factual errors in the input; (2) Correction with Justification, providing correct information with supporting reasoning; and (3) Reliable Answering, producing the final answer under the corrected premises.

Implementation Strategies The authors implement DEDUCE using two complementary strategies: DEDUCE-Prompting and DEDUCE-Tuning. DEDUCE-Prompting directly applies the three modules via prompts, offering an interpretable and flexible approach without additional training. DEDUCE-Tuning internalizes the reasoning patterns into model parameters through a two-stage process. In Stage 1 (Detect Fine-Tuning), the model learns to identify factual errors and conflicts using training data generated by a teacher model, ensuring a reliable foundation for error detection. In Stage 2 (Devise and Correct Fine-Tuning), the model is trained on validated multi-perspective strategies and corresponding correct answers, filtered by strict quality criteria. This combined stage enables the model to internalize multi-perspective reasoning and execute corrections in a single step, mitigating self-reinforcing biases.

Experiment

The evaluation combines TruthfulQA, FalseQA, and MisFactQA with accuracy and complementary metrics that assess whether models are misled by, detect, and correct factual errors in queries. DEDUCE is compared against default prompting, in-context learning, chain-of-thought, LoRA fine-tuning, and an interpretable false assumption detection baseline, and it consistently improves accuracy and error correction across model families while reducing misleading responses. Error analysis shows that false premises degrade performance more than overt contradictions, and ablation indicates the strategy generation module is especially important. The approach also generalizes to stronger LLMs, which remain vulnerable to fact perturbations, and case studies confirm that decomposing queries into atomic claims helps prevent uncritical acceptance of erroneous information.

The Clarification Score rubric defines five levels of response quality when a model faces erroneous queries, from accepting false claims to fully correcting them. It enables fine-grained evaluation of partial correctness, going beyond binary accuracy or surface-level similarity metrics. A score of 1 (Misled) means the model reinforces the error, while a score of 5 (Full Clarification) requires explicit refutation of false claims and an accurate answer. Intermediate levels distinguish Avoidance (ignoring the error and answering incorrectly), Contradictory responses (identifying some false claims but giving conflicting information), and Partial Correction (detecting most errors without answering under the correct premise).

DEDUCE-P consistently outperforms all baselines on both FalseQA and MisFactQA, achieving the highest accuracy, clarification score, and correction rate while yielding the lowest misleading rate. The improvement over the next best method, SFT, is particularly notable on FalseQA, where accuracy rises by nearly five percentage points and the correction rate increases by about four points. DEDUCE-P attains the best results on every metric for both datasets, with the lowest misleading rate and highest correction rate. Compared to SFT, the strongest baseline, DEDUCE-P reduces the misleading rate on FalseQA from 20.47 to 19.12 and on MisFactQA from 23.47 to 18.23, while raising the correction rate on MisFactQA from 65.16 to 70.62.

On TruthfulQA, the DEDUCE-P method consistently achieves the highest accuracy across all tested instruct models, while chain-of-thought prompting underperforms the original baseline in every case. This counterintuitive drop supports the hypothesis that reasoning over flawed inputs amplifies errors. In-context learning and supervised fine-tuning offer only modest improvements compared to the structured detection and correction approach. DEDUCE-P yields the best accuracy on all three models, with particularly large gains on LLaMA-3.1-8B and Gemma3-12B. Chain-of-thought prompting reduces accuracy below the original model on every architecture, illustrating how uncritical reasoning on misleading inputs can harm performance.

DEDUCE improves accuracy on FalseQA and MisFactQA for both GPT-4o-mini and DeepSeek-V3, while using fewer tokens than other robustness methods like CoT and IAQ-FA. Even stronger models remain vulnerable to misleading inputs, but DEDUCE mitigates this with a better accuracy-efficiency trade-off. DEDUCE-T achieves the highest MisFactQA accuracy for both models, lifting GPT-4o-mini from 65.1% to 82.9% and DeepSeek-V3 from 69.9% to 84.6%. Compared to CoT and IAQ-FA, DEDUCE-T delivers higher accuracy with substantially lower average token consumption on both datasets. Original model accuracy on MisFactQA is below 70% for both GPT-4o-mini and DeepSeek-V3, confirming that stronger LLMs are not immune to misleading factual premises.

The evaluation uses datasets with false premises (FalseQA, MisFactQA, TruthfulQA) to assess how well models detect and correct erroneous queries. DEDUCE-P consistently outperforms baselines by explicitly refuting false claims, yielding higher correction rates and lower misleading rates. Chain-of-thought prompting on flawed inputs amplifies errors and reduces accuracy, while DEDUCE improves robustness even for strong models like GPT-4o-mini and DeepSeek-V3 with a more efficient token usage.