🤖 AI

D $^2$ F-ReAG: Dynamic Decomposition and Filtering for Multi-Hop Reasoning-Augmented Generation

The paper proposes D $^2$ F-ReAG, a novel retrieval-augmented generation framework that improves multi-hop reasoning accuracy and efficiency by adaptively deciding whether to directly answer or dynamically decompose and filter sub-questions based on the reliability of the initial reasoning.

Original authors: Jiaoyang Li, Junhao Ruan, Shengwei Tang, Kaiyan Chang, Zhengtao Yu, Tong Xiao, Jingbo Zhu

Published 2026-08-06

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jiaoyang Li, Junhao Ruan, Shengwei Tang, Kaiyan Chang, Zhengtao Yu, Tong Xiao, Jingbo Zhu

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 trying to solve a mystery, but instead of having all the clues in one notebook, they are scattered across a thousand different books in a giant library. This is the challenge facing modern "Large Language Models" (LLMs), the super-smart computer brains that write stories, answer questions, and chat with us. These models are like brilliant students who have read a massive library of books during their training, but they can't remember everything perfectly, and sometimes they make things up (a problem scientists call "hallucination"). To fix this, researchers use a trick called Retrieval-Augmented Generation (RAG). Think of RAG as giving the student a search engine: when asked a question, the computer first looks up the answer in its library of books before writing it down.

For simple questions, like "Who wrote Harry Potter?", the search engine finds the answer in one quick step. But for multi-hop reasoning, the puzzle is much harder. It's like asking, "Who directed the movie that came out before the one starring the actor who won an Oscar in 1995?" To answer this, you can't just look up one fact; you have to find the actor, then the movie, then the director, and finally the release date, connecting the dots across different pages. Current methods often get lost in this maze, either breaking the question down into too many tiny, confusing pieces or failing to filter out the wrong clues they find along the way.

Enter D2F-ReAG, a new framework proposed by researchers Jiaoyang Li and their team. Think of D2F-ReAG as a very smart, cautious detective who refuses to guess until they are sure. Instead of blindly breaking every question into tiny sub-questions (which wastes time) or trying to solve the whole thing in one giant leap (which often leads to errors), this new method uses a "confidence check."

Here is how the detective works:

The First Guess: The system first tries to answer the big question using the information it finds immediately.
The Confidence Check: A special "judge" model looks at that first guess and asks, "Are you sure?" If the answer is confident and reliable, the detective stops right there and writes down the final answer. This saves a lot of time for easy questions.
The Breakdown: If the judge says, "No, that doesn't look right," then the system breaks the big question into smaller, manageable sub-questions. It solves these smaller puzzles one by one.
The Filter: Crucially, the system doesn't just dump all the answers from the small puzzles back into the big one. It checks if each small answer is actually relevant and correct. If a small answer is wrong or off-topic, it gets thrown away. If it's right, it's used to fix and improve the answer to the big question.

The researchers tested this idea on three different "mystery" datasets (HotpotQA, 2WikiMultiHopQA, and MuSiQue) that are designed to be tricky. They found that D2F-ReAG was better at solving these complex puzzles than previous methods. For example, on the 2WikiMultiHopQA test, it achieved a score of 70.3 (using a strict matching metric) and 68.9 (using a flexible semantic check), beating the previous best method, LogicRAG, which scored 65.3 and 62.6 respectively.

The paper suggests that this "on-demand" approach is key. By only breaking down questions when necessary and filtering out bad information, the system avoids getting confused by too much noise. It's like a chef who only chops vegetables if the recipe actually needs them, rather than chopping everything in the kitchen and hoping something fits. The experiments show that this method not only gets more answers right but also handles the "noise" of irrelevant information better, leading to more accurate and trustworthy results for complex, multi-step questions.

Technical Summary: D2F-ReAG

Problem Statement

Large Language Models (LLMs) frequently generate factually incorrect or unsupported outputs in knowledge-intensive scenarios due to reliance on outdated parametric knowledge and hallucinations. While Retrieval-Augmented Generation (RAG) mitigates these issues for single-hop queries by integrating external knowledge, it struggles with multi-hop reasoning questions that require connecting scattered evidence across multiple documents.

Existing approaches to multi-hop RAG face specific limitations:

Graph-based methods (e.g., GraphRAG, HippoRAG) rely on pre-constructed graph structures. These are costly to build and maintain, often incomplete, and become less effective when underlying knowledge evolves.
Prompt-based decomposition methods (e.g., LogicRAG, ChainRAG) decompose complex queries into sub-questions. However, they often suffer from rigid decomposition strategies (decomposing simple questions unnecessarily or failing to decompose complex ones deeply enough) and a lack of effective filtering. This leads to the accumulation of noise and erroneous intermediate results across iterations, degrading the final answer's accuracy.

Methodology: D2F-ReAG

The authors propose D2F-ReAG (Dynamic Decomposition and Filtering for Multi-Hop Reasoning-Augmented Generation), a framework designed to adaptively control reasoning depth based on the reliability of the current reasoning state. The process operates in four iterative stages:

Retrieval & Generation:
For a given question (initially the root question), the system retrieves top- $k$ relevant documents using a dense retriever. A generator model produces a reasoning process ( $r(q)$ ) conditioned on these retrieved documents to ground the output in external evidence.
Judge Reliability:
An LLM-based scoring mechanism evaluates the reliability of the generated reasoning. The system assesses logical coherence, factual consistency with retrieved documents, and answer completeness, assigning a score $s_r(q) \in [0, 10]$ .
- If $s_r(q) > \theta$ (threshold set to 7), the question is deemed solved, and the final answer is generated.
- If $s_r(q) \le \theta$ , the reasoning is deemed unreliable, triggering the decomposition phase.
Decomposition & Rewriting:
If the question is unsolved, it is logically decomposed into smaller, tractable sub-questions ($sub(q)$).
- Iterative Solving: Sub-questions are solved sequentially.
- Rewriting: Once a sub-question is solved with high confidence, its verified reasoning ( $r_q$ ) is used to rewrite related subsequent sub-questions. This resolves ambiguous references and missing entities, ensuring subsequent retrieval is targeted and avoids redundant or contradictory paths.
ReAG (Reasoning-Augmented Generation):
Verified and relevant reasoning traces from solved sub-questions are integrated back into the root reasoning process. This step updates the root reasoning ( $r'(q_{root})$ ) with accurate intermediate conclusions, progressively enriching the global context.
- Relevance Check: A mechanism filters out tangential sub-questions to prevent noise contamination.
- Early Stopping: The process terminates immediately once the root question's reasoning score exceeds the threshold, preventing unnecessary computational overhead and over-decomposition.

Key Contributions

The paper outlines three primary contributions:

Dynamic Decomposition Framework: A novel paradigm that decomposes questions on-demand based on reasoning reliability. Unlike fixed-depth methods, it ensures accurate intermediate results are propagated back to guide the final answer rather than being lost in lossy memory compression.
Adaptive Control Mechanism: A confidence-driven approach that balances decomposition depth. It performs deep decomposition only when necessary (for complex questions) while avoiding redundant steps for simpler queries, achieving truly adaptive reasoning.
Iterative Error Correction: A method that leverages reliable reasoning chains from sub-questions to iteratively update and correct the root reasoning process. This effectively identifies and fixes intermediate errors, reducing error accumulation across reasoning steps.

Experimental Results

The authors evaluated D2F-ReAG on three standard multi-hop benchmarks: HotpotQA, 2WikiMultiHopQA, and MuSiQue. Performance was measured using Str-Acc (strict lexical matching) and LLM-Acc (semantic equivalence judged by a strong LLM).

Performance: D2F-ReAG achieved the best or near-best results across all datasets. Notably, on 2WikiMultiHopQA, it achieved 70.3 Str-Acc and 68.9 LLM-Acc, outperforming the strongest baseline (LogicRAG) by 5.4 and 6.4 points, respectively. On HotpotQA, it achieved the highest LLM-Acc (63.4).
Efficiency: An ablation study comparing "with decomposition" vs. "without decomposition" showed that a significant portion of questions can be solved without decomposition. The dynamic approach skips unnecessary steps for easy cases, balancing performance and efficiency better than methods that always decompose.
Case Study: A qualitative comparison with LogicRAG demonstrated that D2F-ReAG successfully corrects intermediate errors (e.g., missing comparison targets) by decomposing the query and rewriting sub-questions based on verified facts, whereas LogicRAG failed due to rigid decomposition and lack of verification.

Significance and Claims

The paper claims that D2F-ReAG addresses the critical limitations of existing RAG methods: fixed decomposition strategies and the inability to filter erroneous information during reasoning.

By adaptively decomposing questions only when necessary and selectively filtering intermediate reasoning based on reliability, D2F-ReAG effectively suppresses error propagation. The authors assert that this approach produces more faithful reasoning chains and achieves strong performance on challenging multi-hop benchmarks without the high maintenance costs of graph-based structures or the noise accumulation of rigid prompt-based methods. The framework is presented as a step toward more human-like, efficient, and accurate reasoning in LLMs.