💻 computer science

A Multi-Layer Framework for Hallucination Detection and Mitigation in Large Language Models Using Retrieval Grounding and Small Language Model Verification

This paper proposes a multi-layer framework that enhances the factual reliability of large language models by decomposing responses into atomic claims, grounding them with retrieval, and verifying them through a small language model and neuro-symbolic reasoning, achieving significant performance gains on HotpotQA and SciFact datasets while maintaining interpretability and computational efficiency.

Original authors: Md. Mahmudul Hasan, Israk Kayum Chowdhury, Md. Eliyas Akondo, Tanvir Ahammad, Khandaker Mohammad Mohi Uddin

Published 2026-06-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Md. Mahmudul Hasan, Israk Kayum Chowdhury, Md. Eliyas Akondo, Tanvir Ahammad, Khandaker Mohammad Mohi Uddin

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very talented, fast-talking storyteller (the Large Language Model, or LLM). This storyteller can spin a tale that sounds perfect, flows beautifully, and sounds incredibly confident. But here's the catch: sometimes, this storyteller makes things up. They might invent a date, a place, or a fact that sounds plausible but is actually wrong. This is called a "hallucination."

The problem is that because the story sounds so smooth, you might believe it without checking.

This paper proposes a new way to check the storyteller's work before you hear the final version. Instead of just listening to the whole story and guessing if it's true, the authors built a multi-layer fact-checking factory. Here is how it works, step-by-step, using simple analogies:

1. The Storyteller Writes the Draft

First, the LLM writes an answer to your question. Let's say you ask, "Who won the Nobel Prize in Physics in 1903?"
The LLM might say: "Marie Curie won the 1903 Nobel Prize in Physics, and she also won a second one in Chemistry in 1911."
At this stage, the system treats this answer as unverified. It's just a draft.

2. Breaking the Story into Lego Bricks (Atomic Decomposition)

Instead of checking the whole paragraph at once, the system breaks the answer down into tiny, individual "Lego bricks" (atomic claims).

Brick 1: "Marie Curie won the 1903 Nobel Prize in Physics."
Brick 2: "She won a second one in Chemistry in 1911."

Why do this? Because a story can be 99% true but have one tiny lie in it. If you check the whole story, you might miss that one lie. By checking each brick, you can spot exactly where the error is.

3. The Librarian's Search (Retrieval Grounding)

Now, for each "brick," the system sends a librarian (a Retrieval System) to a massive library of documents to find proof.

The librarian looks for books or articles that talk about Marie Curie and 1903.
If the librarian finds a book that says, "Yes, she won in 1903," that brick gets a "Supported" stamp.
If the librarian finds a book that says, "She won in 1905," that brick gets a "Contradicted" stamp.
If the librarian comes back empty-handed or finds a book that only talks about her but not the year, the brick gets an "Uncertain" stamp.

Key Finding: The paper found that if you remove this librarian step, the whole system collapses. Without real evidence from the library, the system can't tell truth from lies.

4. The Quick-Check Judge (Small Language Model Verification)

Next, the system brings in a Small Language Model (SLM). Think of this as a quick, efficient judge who is very good at reading the "brick" and the "librarian's notes" and deciding: Is this true, false, or unclear?

This judge is smaller and faster than the original storyteller.
It doesn't just say "True" or "False." It gives a confidence score. For example, "I am 90% sure this is true" or "I am only 40% sure."
If the evidence is weak, the judge says, "I can't decide yet" (Uncertain) rather than guessing.

5. The Wise Elder (Neuro-Symbolic Reasoning)

Sometimes, the evidence is tricky. Maybe the librarian found two books that disagree, or the judge is confused.
This is where the Neuro-Symbolic Reasoning layer comes in. Think of this as a wise elder who knows the rules of logic.

If the judge is unsure, the elder applies strict rules (like "If the date is wrong, the whole claim is wrong").
The elder can also fix the claim. If the LLM said "1911" but the evidence says "1903," the elder doesn't just delete the sentence; they can rewrite it to say "1903."
This layer also explains why a decision was made, making the process transparent.

6. The Final Report (Trust-Calibrated Output)

Finally, the system rebuilds the answer using only the bricks that passed the checks.

True bricks stay.
Fixed bricks get corrected.
False bricks are removed.
Uncertain bricks are either removed or flagged as "we aren't sure about this part."

The system also gives you a "Trust Score." It tells you, "I am 85% confident in this answer." If the score is low, you know to be careful.

What Did They Find?

The researchers tested this factory on two types of tasks:

Science Fact Checking: Checking if scientific claims were true.
Complex Questions: Answering questions that require connecting multiple pieces of information.

The Results:

The Librarian is Key: When they removed the librarian (the retrieval step), the system's ability to get the right answer dropped drastically. This proves you need real evidence, not just the AI's memory.
The Small Judge does the heavy lifting: The small, fast judge (SLM) did most of the work in deciding if facts were true or false. The "Wise Elder" (reasoning layer) didn't change the final score much in these tests, but it was very good at explaining why and fixing errors.
Better Safe Than Sorry: The system is designed to be cautious. It would rather say "I don't know" (Uncertain) than guess and be wrong. This means it might miss some true facts, but it rarely lies confidently.

The Bottom Line

This paper shows that you don't need a super-computer to check an AI's work. By breaking answers into small pieces, checking them against real documents, using a fast "mini-AI" to judge them, and applying simple logic rules, you can catch lies and fix mistakes. The result is an AI that doesn't just sound confident, but is actually trustworthy.

Technical Summary: A Multi-Layer Framework for Hallucination Detection and Mitigation in Large Language Models

1. Problem Statement

Large Language Models (LLMs) generate fluent and coherent text but frequently produce "hallucinations"—statements that are factually incorrect, unsupported, or incomplete. This issue is particularly critical in high-stakes domains such as healthcare, education, and scientific research, where minor inaccuracies can lead to significant misunderstandings or flawed decision-making. Existing detection methods often suffer from several limitations:

Coarse Granularity: Many approaches evaluate the entire response as a single unit, failing to detect partial hallucinations where an answer is mostly correct but contains specific false statements.
Lack of External Grounding: Self-consistency or internal-state analysis methods rely on the model's own outputs or hidden states, which may propagate the same errors.
Computational Cost: Multi-agent debate or repeated sampling methods are often too expensive for real-time deployment.
Integration Gaps: Retrieval-Augmented Generation (RAG), fact verification, and uncertainty estimation are often treated as separate processes rather than a unified pipeline.

The paper argues for a need to decompose answers into atomic claims, ground them in external evidence, verify them efficiently, and refine uncertain cases using structured reasoning.

2. Methodology

The authors propose a Multi-Layer Framework that integrates retrieval grounding, atomic claim decomposition, Small Language Model (SLM) verification, and neuro-symbolic reasoning. The pipeline operates through the following stages:

2.1 Initial Generation and Atomic Decomposition

Generation: An LLM generates an initial response ( $A_0$ ) to a user query ( $Q$ ). This response is treated as unverified.
Decomposition: The framework breaks $A_0$ into a set of atomic factual claims ( $F = \{f_1, f_2, ..., f_n\}$ ). Each claim is a self-contained, verifiable proposition (e.g., separating "Marie Curie was born in Warsaw" and "Marie Curie won two Nobel Prizes"). Non-verifiable content (opinions, style) is excluded.

2.2 Layer 1: Semantic Grounding (Retrieval)

For each atomic claim $f_i$ , the system retrieves relevant evidence ( $E_i$ ) from a document corpus ( $D$ ) using vector-based semantic search.
Claims and document chunks are encoded into dense vectors, and cosine similarity is used to identify the top- $k$ most relevant evidence passages.
This layer provides the factual context necessary for verification, reducing reliance on the LLM's internal knowledge.

2.3 Layer 2: Uncertainty and Consistency Gate (SLM Verification)

A lightweight Small Language Model (SLM), specifically Qwen2.5-1.5B-Instruct, acts as a probabilistic verifier.
The SLM receives the claim ( $f_i$ ), retrieved evidence ( $E_i$ ), and the original query ( $Q$ ).
It outputs probabilities for three labels: SUPPORTED, CONTRADICTED, and UNDER-SPECIFIED.
Calibration: The system calculates uncertainty (normalized entropy) and applies decision thresholds ( $\tau$ ). To minimize false positives, a conservative threshold ( $\tau \approx 0.6$ ) is used in the final system, even though a lower threshold ( $\approx 0.40$ ) yields a higher F1 score. Claims with low confidence are flagged as uncertain rather than forced into a binary decision.

2.4 Layer 3: Neuro-Symbolic Reasoning

This layer refines decisions for borderline or uncertain cases.
It employs a predefined set of logical rules (e.g., numerical claims require explicit evidence) and a reasoning LLM to re-evaluate claims where the SLM's confidence is low or evidence is ambiguous.
The output is a refined verdict: SUPPORTED, CORRECTED (modified claim), REJECTED, or INSUFFICIENT, accompanied by a natural language explanation ( $w_i$ ).

2.5 Trust-Calibrated Output

The final response ( $A^*$ ) is reconstructed using only the validated and corrected claims.
A global Trust Score ( $T$ ) is calculated based on the support probabilities and uncertainty of the included claims, providing the user with a reliability indicator.

3. Key Contributions

Claim-Level Decomposition: The framework shifts hallucination detection from a response-level evaluation to an atomic claim-level analysis, enabling the identification of partial hallucinations within otherwise correct answers.
Hybrid Verification Pipeline: It integrates retrieval grounding, SLM-based verification, and neuro-symbolic reasoning into a single architecture. This combines the efficiency of lightweight models with the logical consistency of rule-based reasoning.
Uncertainty-Aware Design: By explicitly modeling uncertainty and using conservative thresholds, the system prioritizes avoiding false "SUPPORTED" labels over maximizing recall, making it suitable for high-trust applications.
Interpretability: The system generates explanations for why claims are accepted, rejected, or corrected, and provides a global trust score, enhancing transparency.

4. Experimental Results

The framework was evaluated on two datasets: SciFact (scientific claim verification) and HotpotQA (multi-hop question answering).

4.1 Performance Metrics

SciFact: The full framework achieved an accuracy of 0.511 and a macro-F1 score of 0.504.
- Observation: The "no-reasoner" variant performed nearly identically, suggesting the SLM verifier handles most of the structured classification work for this dataset.
HotpotQA: The full pipeline achieved a token-level F1 score of 0.146.
- Ablation Study: Removing the retrieval component caused a drastic drop in performance (F1 dropped to 0.034), highlighting that retrieval grounding is the most critical component for answer quality.
- Removing the reasoning layer or SLM verifier had a minimal impact on token-level F1 but affected verification behavior and interpretability.

4.2 Verification Behavior and Calibration

Conservative Strategy: The model frequently classifies claims as UNDER-SPECIFIED (42.7% of claims) when evidence is weak, rather than guessing. This reduces false positives but lowers recall for supported claims.
Confidence Calibration: The ROC-AUC was 0.87, and the calibration curve showed that higher confidence scores generally correlated with higher correctness. The system effectively distinguishes between supported, contradicted, and uncertain claims.
Threshold Sensitivity: While the optimal F1 score occurred at a threshold of $\approx 0.40$ , the final system uses a stricter threshold ( $\approx 0.6$ ) to ensure high precision and reduce the risk of validating unsupported claims.

4.3 Efficiency

The full pipeline averages 20.6 seconds per query.
The SLM verification step accounts for the majority of the latency, while retrieval adds minimal overhead. This is significantly more efficient than multi-agent debate or repeated large-model sampling.

5. Significance and Claims

The paper claims that this framework offers a practical balance between accuracy, reliability, interpretability, and computational cost. Its significance lies in:

Mitigating Partial Hallucinations: By verifying claims individually, the system can correct specific errors without discarding the entire response.
Reducing Computational Burden: Using a small, specialized verifier (SLM) instead of repeatedly querying a large LLM makes the system feasible for real-world deployment.
Trust Calibration: The system does not just output an answer; it provides a confidence score and explanation, allowing users to gauge the reliability of the information.
Evidence-Driven Reliability: The results demonstrate that without retrieval grounding, verification performance collapses, proving that external evidence is essential for factual reliability.

The authors conclude that while the system remains conservative (potentially missing some supported claims to avoid errors), this trade-off is necessary for high-stakes applications where a confident but incorrect answer is more harmful than an uncertain one. Future work is suggested to improve retrieval quality, expand reasoning rules, and test the framework in broader open-domain contexts.