🤖 AI

Entropic Claim Resolution: Uncertainty-Driven Evidence Selection for RAG

This paper introduces Entropic Claim Resolution (ECR), a novel inference-time algorithm that enhances Retrieval-Augmented Generation systems by dynamically selecting evidence to maximize Expected Entropy Reduction, thereby shifting the retrieval paradigm from semantic relevance to discriminative uncertainty minimization for resolving conflicting or ambiguous queries.

Original authors: Davide Di Gioia

Published 2026-03-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Davide Di Gioia

Original paper licensed under CC BY 4.0 (http://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 are a detective trying to solve a mystery. You have a big box of clues (documents) and a list of suspects (possible answers).

The Old Way (Standard RAG):
Most current AI systems work like a detective who just grabs the first 5 clues that look most similar to the crime scene photo. If the photo shows a red car, the AI grabs all the clues mentioning "red" or "car."

The Problem: Sometimes, the clues are all about the same red car, but they don't tell you who drove it. Or worse, one clue says "John drove the red car," and another says "Mary drove the red car." If the AI just grabs the "most similar" clues, it might grab 5 clues about John and ignore the clues about Mary, leading it to confidently guess the wrong suspect. It's like reading the same page of a book five times and thinking you know the whole story.

The New Way (Entropic Claim Resolution - ECR):
This paper introduces a new detective strategy called Entropic Claim Resolution (ECR). Instead of grabbing clues based on how similar they look, this detective grabs clues based on how much they reduce confusion.

Here is how it works, using a simple analogy:

1. The "Confusion Meter" (Entropy)

Imagine your mind is a foggy room. Every time you have a question, the room is full of fog (uncertainty).

Standard AI: Just looks for clues that match the fog's color.
ECR: Has a special "Confusion Meter." Its only goal is to clear the fog as fast as possible. It asks: "Which single clue, if I read it right now, will clear the most fog?"

2. The "Tipping Point" Strategy (Expected Entropy Reduction)

Let's say you have three suspects: Alice, Bob, and Charlie.

Clue A: "Alice likes pizza." (This doesn't help much; all three like pizza. It doesn't clear the fog.)
Clue B: "Bob was seen at the scene." (This clears some fog; Alice and Charlie are less likely.)
Clue C: "Charlie was in another country." (This clears a lot of fog! It instantly eliminates Charlie.)

ECR is smart enough to know that Clue C is the most valuable, even if it doesn't sound exactly like your question. It picks the clue that splits the possibilities the most. It's like playing "20 Questions" where you always ask the question that cuts the remaining possibilities in half, rather than asking "Is it a dog?" when you already know it's a vehicle.

3. The "Stop Sign" (Epistemic Sufficiency)

Most AI keeps reading until it runs out of time or hits a word limit. ECR has a mathematical stop sign.

It keeps checking the "Confusion Meter."
As soon as the fog is thin enough (the meter hits a low number), it says, "Stop! We know enough. Let's give the answer."
If the meter stays high because the clues are contradictory (e.g., one says "It was Alice," another says "It was definitely NOT Alice"), ECR stops and says, "I can't solve this. The clues fight each other. I will tell you that I'm confused." It refuses to guess wildly.

4. The "Truth Detective" (Claim Verification)

Instead of reading whole paragraphs, ECR breaks the text down into tiny, atomic facts (claims).

It treats every sentence like a tiny fact-checker.
It builds a "web of truth." If a new clue supports a suspect, that suspect gets a point. If a clue contradicts them, they lose points.
It keeps adding points until one suspect has so many points that the others can't catch up.

Why Does This Matter?

In the real world (like in hospitals, courts, or banks), being "mostly right" isn't good enough.

Old AI: Might confidently give a wrong medical diagnosis because it found a few similar-sounding articles.
ECR: Will realize the evidence is conflicting, stop the process, and tell the doctor, "The evidence is mixed; I cannot be sure." This prevents dangerous hallucinations.

The "Magic" Summary

Think of ECR as a super-efficient librarian who doesn't just hand you the books with the most similar titles. Instead, she asks: "Which book will help you understand the topic the fastest?"

She picks the book that clears up the most confusion.
She stops reading the moment you understand the topic.
If the books contradict each other, she admits, "I can't decide," instead of making up a story.

This paper proves that by focusing on reducing confusion rather than just finding similarities, we can build AI that is smarter, safer, and more honest about what it knows and doesn't know.

1. Problem Statement

Current Retrieval-Augmented Generation (RAG) systems rely heavily on relevance-based dense retrieval (e.g., Maximum Inner Product Search) to fetch documents. While effective for simple factoid questions, this approach fails in complex, knowledge-intensive scenarios characterized by:

Conflicting Evidence: Multiple sources providing contradictory information.
Query Ambiguity: Questions where the ground truth is not singular or clear.
Epistemic Collapse: The tendency to retrieve redundant, semantically similar information that fails to resolve uncertainty, leading the Large Language Model (LLM) to generate overconfident or hallucinated answers.

Existing solutions, such as agentic frameworks (ReAct, Tree-of-Thoughts) or graph-based retrieval, lack a principled, decision-theoretic stopping criterion and a rigorous objective function for selecting the next piece of evidence. They often rely on heuristics, fixed thresholds, or prompt-driven self-reflection, which can lead to infinite loops, premature termination, or unprincipled evidence weighting.

2. Methodology: Entropic Claim Resolution (ECR)

The authors propose Entropic Claim Resolution (ECR), an inference-time algorithm that reframes RAG reasoning as a process of entropy minimization over a space of semantic answer hypotheses.

Core Concepts

Hypothesis Space ( $A$ ): The system initializes a set of mutually exclusive potential answers (hypotheses) with a uniform prior probability.
Atomic Claims: Instead of retrieving full documents, the system operates on a pool of atomic factual claims derived from the retrieved corpus.
Objective: The goal is not to find the most relevant claim, but the most discriminative claim—one that maximally reduces the entropy (uncertainty) of the hypothesis space.

The Algorithm

Initialization: Generate a hypothesis space $A$ and a candidate pool of claims $C_{cand}$ .
Selection Policy (Expected Entropy Reduction - EER): At each step, the system selects the claim $c^*$ $c^{*}$ that maximizes the Expected Entropy Reduction:
$c^* = \arg \max_{c \in C_{cand}} \text{EER}(c | X_{eval})$
Where EER is the difference between current entropy and the expected posterior entropy after verifying the claim.
- Proxy Implementation: To ensure low-latency inference, a computationally efficient proxy is used that scores claims based on how well they split the probability mass between supporting and non-supporting hypotheses.
Coherence-Aware Selection: A regularization term ( $\lambda$ ) is added to prioritize claims that complete explicit contradictions. This ensures that if evidence is inherently inconsistent, the system surfaces the conflict rather than averaging it out.
Verification & Update: The selected claim is verified (using topological provenance or LLM verification), and the posterior probability distribution $P(A|X)$ is updated using Bayesian rules.
Stopping Criterion: The process terminates when Epistemic Sufficiency is reached:
$H(A | X_{eval}) \le \epsilon \quad \land \quad \neg \text{Conflict}(X_{eval})$
If the entropy drops below a threshold $\epsilon$ and no contradictions exist, the system synthesizes the answer. If contradictions persist, it halts and exposes the ambiguity.

System Integration (CSGR++)

ECR is integrated into CSGR++, a production-grade, multi-strategy retrieval pipeline that:

Treats structured tabular data and unstructured text as first-class atomic claims.
Uses an Entity-Attribute-Value (EAV) backend for provenance tracking.
Employs a hybrid retrieval strategy (Vector + Graph + Claim) fused via Reciprocal Rank Fusion (RRF).
Triggers ECR only when high epistemic uncertainty is detected (e.g., high claim volume, syntactic ambiguity, or high confidence variance).

3. Key Contributions

Paradigm Shift: Moves RAG from "retrieving what is most relevant" to "retrieving what is most discriminative" for resolving hypothesis ambiguity.
Mathematical Rigor: Defines a principled stopping criterion based on Epistemic Sufficiency ( $H \le \epsilon$ ), replacing heuristic or fixed-budget limits.
Phase Transition Behavior: Demonstrates that ECR transitions from "forced epistemic collapse" to "principled ambiguity exposure" when structured contradictions are present, preventing the system from hallucinating a single answer when evidence is inconsistent.
Scalability: Implements ECR as a lightweight, inference-time algorithm requiring no model fine-tuning, integrated into a complex production pipeline.

4. Experimental Results

The evaluation was conducted in two phases: controlled claim-level harnesses and end-to-end multi-hop QA.

Controlled Claims-Only Harness:
- Efficiency: ECR reached epistemic sufficiency ( $H \le 0.3$ bits) using only 5 claims, whereas relevance-based baselines required 15 claims and failed to reduce entropy significantly.
- Performance: ECR reduced final entropy to ~0.21 bits compared to 1.58 bits for retrieval-only baselines.
- Robustness: Results remained stable across multiple random seeds.
End-to-End HotpotQA Evaluation:
- Accuracy: ECR achieved performance comparable to strong relevance-based baselines (Exact Match: 0.297 vs. 0.313) while using a similar number of claims (~19.7).
- Random Baseline: ECR substantially outperformed random evidence selection (EM 0.297 vs. 0.207).
- Noise Robustness: When 40% of candidate claims were replaced with noise, ECR degraded predictably without amplifying errors or hallucinating, unlike relevance-based systems which suffered more significant drops in faithfulness.
Contradiction Injection (Offline):
- Baseline RAG: Remained pathologically overconfident (99% overconfident error rate) even when explicit contradictions were injected.
- ECR: Exhibited a sharp phase transition. As contradiction rates increased ( $\alpha \ge 0.3$ ), ECR stopped attempting to collapse the hypothesis space, instead exposing the ambiguity (100% ambiguity exposure) and halting due to unresolved conflict.

5. Significance

High-Stakes Reliability: ECR provides a critical safety mechanism for domains like medicine, law, and finance. By refusing to synthesize an answer when evidence is contradictory or insufficient, it mitigates "unhedged hallucinations."
Cost Efficiency: The dynamic stopping criterion prevents unnecessary retrieval and processing of redundant context, reducing latency and computational costs.
Theoretical Foundation: It bridges the gap between Information Theory, Bayesian Experimental Design, and Neural Generation, offering a formal framework for uncertainty-aware reasoning.
Future Direction: The paper suggests that scaling knowledge-intensive systems should rely on decision-theoretic inference (controlling how evidence is selected) rather than just indiscriminate context expansion or larger models.

In summary, Entropic Claim Resolution offers a mathematically grounded, computationally efficient method to transform RAG from a passive retrieval system into an active, uncertainty-aware reasoning engine capable of handling conflicting evidence and ambiguity with rigor.