💬 NLP

RAISE: Enhancing Scientific Reasoning in LLMs via Step-by-Step Retrieval

The paper introduces RAISE, a step-by-step retrieval-augmented framework that enhances scientific reasoning in large language models by decomposing problems and generating logical queries to retrieve domain-specific, logically relevant documents from in-the-wild corpora, thereby outperforming existing baselines on scientific reasoning benchmarks.

Original authors: Minhae Oh, Jeonghye Kim, Nakyung Lee, Donggeon Seo, Taeuk Kim, Jungwoo Lee

Published 2026-03-20

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Minhae Oh, Jeonghye Kim, Nakyung Lee, Donggeon Seo, Taeuk Kim, Jungwoo Lee

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 brilliant detective trying to solve a incredibly complex, graduate-level mystery. The case involves a specific type of barley that has a bad taste, and you need to figure out exactly which genetic mutation caused it.

If you just ask your brain (a standard Large Language Model) to solve this, it might guess based on what it remembers from its training. But scientific facts change, and the details are tricky. It might hallucinate (make things up) or get stuck because it doesn't have the exact right piece of information at the right time.

This paper introduces RAISE, a new way to help AI detectives solve these hard science problems. Think of RAISE not as a single genius, but as a super-organized research team that follows a strict three-step process.

Here is how RAISE works, using a simple analogy:

The Problem: The "One-Shot" Search

Most AI methods try to solve the whole mystery at once. They ask a search engine: "Why does this barley taste bad?"
The search engine returns a bunch of articles about barley. Some are about farming, some about genetics, and some are just about how to cook barley soup. The AI gets overwhelmed by the noise and might pick the wrong article, leading to a wrong answer.

The RAISE Solution: The Three-Step Detective Process

RAISE breaks the big mystery down into three distinct phases:

1. Problem Decomposition (Breaking the Case into Clues)

Instead of asking one big question, RAISE acts like a smart detective who breaks a huge case into small, manageable clues.

The Analogy: Instead of asking, "Who killed the victim?", the detective asks: "Where was the victim last seen?" then "What weapon was used?" then "Who had a motive?"
In RAISE: The AI takes the hard science question and splits it into smaller sub-questions. For our barley example, it doesn't just ask about the mutation; it asks, "What does the first part of the gene do?" and "How does a mutation there stop the protein from working?"

2. Logical Query Generation (Writing the Perfect Search Terms)

This is the secret sauce. Once the AI has the small clues, it doesn't just type them into Google. It rewrites them into logical search terms that capture the reasoning needed, not just the keywords.

The Analogy: If you are looking for a specific type of lockpick, a normal search might say "lock." A logical search says, "How to pick a pin-tumbler lock without breaking the key."
In RAISE: If the sub-question is about a mutation, a normal search might just look for "mutation." RAISE rewrites the query to be: "How does a mutation in the start of a gene stop the protein from being made?" This ensures the search engine finds the logic behind the answer, not just a dictionary definition.

3. Logical Retrieval (Finding the Right Evidence)

Now, the AI goes to the "wild" internet (like Wikipedia) to find answers for each small clue. Because the search terms were so precise, it finds documents that are logically relevant.

The Analogy: Imagine you are building a house. A normal search might bring you a pile of bricks, wood, and random furniture. RAISE brings you only the specific blueprint for the foundation, then only the instructions for the roof, one step at a time.
In RAISE: It retrieves a document that explains exactly why a specific mutation breaks the gene. It ignores the articles about barley farming because they aren't logically needed for this specific step.

Why This Matters

The paper tested RAISE on tough science exams (like graduate-level biology and chemistry).

Other methods (like standard AI or AI with a basic search) often got lost in the details or picked the wrong facts.
RAISE consistently won. It didn't just know the answer; it knew how to find the answer by breaking the problem down and searching for the right logic at every single step.

The Bottom Line

RAISE is like giving an AI a checklist and a magnifying glass. Instead of guessing the whole answer at once, it:

Splits the big problem into tiny steps.
Writes perfect search questions for each step.
Finds the exact evidence needed to solve that specific step.

By doing this, it turns a chaotic search for answers into a clear, logical path, making AI much better at solving real-world science problems.

1. Problem Statement

Scientific reasoning in Large Language Models (LLMs) faces three critical challenges that current methods struggle to address simultaneously:

Complexity of Reasoning: Scientific problems often require long-chain, multi-step reasoning rather than single-hop inference.
Domain Specificity: Solutions require precise knowledge of specialized terminologies and concepts (e.g., specific chemical mechanisms or biological pathways).
Knowledge Currency: Scientific findings evolve rapidly, and static parametric knowledge in LLMs often becomes outdated.

Existing approaches like Chain-of-Thought (CoT) rely solely on internal parametric knowledge, leading to hallucinations or outdated facts. Retrieval-Augmented Generation (RAG) helps but often fails in "in-the-wild" settings (e.g., general Wikipedia) because standard retrieval methods prioritize domain similarity (keywords) over logical relevance. Consequently, retrieved documents may be topically related but fail to provide the specific logical connections needed to solve intermediate reasoning steps. Furthermore, naive decomposition strategies without tailored retrieval can degrade performance, especially in smaller models.

2. Methodology: RAISE Framework

The authors propose RAISE (Step-by-Step Retrieval-Augmented Inference for Scientific rEasoning), a framework designed to retrieve logically relevant documents for each step of a reasoning chain. The process consists of three distinct stages:

Stage 1: Problem Decomposition

The original complex question ( $x$ ) is decomposed into a sequence of subquestions ( $r_1, \dots, r_n$ ).
For each subquestion, an initial search query ( $q_i$ ) is generated.
Unlike standard approaches that use the original question for a single retrieval, this stage creates a structured sequence of subquestion-query pairs $\{(r_i, q_i)\}$ to guide step-wise retrieval.

Stage 2: Logical Query Generation

This is the core innovation. The initial query $q_i$ often lacks sufficient reasoning context, while the subquestion $r_i$ can be too specific or noisy.
RAISE jointly processes the subquestion ( $r_i$ ) and the initial query ( $q_i$ ) to generate a Logical Query ( $q^*_i$ ).
Goal: The reformulated query $q^*_i$ is designed to capture the reasoning intent and the underlying scientific principles required to solve the subquestion, rather than just surface-level keywords. This ensures the retrieval system targets documents that explain mechanisms and logic rather than just definitions.

Stage 3: Logical Retrieval

The logical query $q^*_i$ is used to retrieve documents from an in-the-wild corpus (e.g., Wikipedia), rather than a curated, task-specific dataset.
A similarity threshold ( $T$ ) is applied to filter out documents that are topically related but logically irrelevant.
The retrieved documents ( $D_i$ ) are then used by the LLM to generate the answer for the specific subquestion ( $a_i$ ), conditioned on the original question and previous steps.
Finally, all sub-answers are synthesized to produce the final answer ( $y$ ).

3. Key Contributions

Novel Framework: Introduction of RAISE, the first framework to explicitly separate logical query generation from standard retrieval, specifically tailored for multi-step scientific reasoning in open-domain settings.
Shift from Domain to Logic: Demonstrates that for scientific reasoning, retrieving documents that are logically relevant (supporting the reasoning chain) is more critical than those that are merely domain-similar (sharing keywords).
In-the-Wild Applicability: Proves that complex scientific reasoning can be achieved using general, uncurated corpora (like Wikipedia) if the retrieval strategy is aligned with the reasoning steps, removing the dependency on expensive, domain-specific datasets.
Comprehensive Evaluation: Extensive experiments across three major benchmarks (GPQA, SuperGPQA, MMLU) showing that RAISE outperforms baselines across different model sizes (from 8B to 24B parameters) and difficulty levels.

4. Experimental Results

The authors evaluated RAISE on GPQA (graduate-level science), SuperGPQA (285 graduate disciplines), and MMLU (STEM and Professional categories).

Performance Gains: RAISE consistently outperformed all baselines, including Direct CoT, CoT+RAG, and decomposed reasoning methods (Least-to-Most, Step-Back, HyDE) combined with RAG.
- On GPQA, RAISE achieved 51.01%, a 9.8% absolute improvement over the best baseline (HyDE at 46.46%).
- On SuperGPQA, it achieved 10.05% on the "science-hard" subset, a 33.3% relative improvement over the best baseline.
- On MMLU, it achieved 51.00%, outperforming the best baseline by 3.0%.
Ablation Studies:
- Removing the Problem Decomposition step (RAISE-Direct) resulted in lower performance, confirming that breaking problems down is essential for guiding retrieval.
- Logical Query Generation was identified as the key differentiator. Baselines like Step-Back+RAG and HyDE (which also reformulate queries) performed worse, indicating that RAISE's specific method of generating logic-enriched queries is superior.
Retrieval Quality Analysis:
- Using an LLM-as-a-judge and human evaluation, the authors found that RAISE retrieved significantly fewer "superficially relevant" documents and more "fully logically relevant" documents compared to other RAG baselines.
- Baselines often retrieved documents with correct terminology but missing the causal logic needed for the specific step.

5. Significance and Impact

Bridging the Gap: RAISE addresses the gap between the need for deep, multi-step reasoning and the limitations of current retrieval systems that rely on keyword matching.
Scalability: The method is effective across models of varying sizes (8B to 24B+), suggesting it is a robust architectural improvement rather than a model-specific trick.
Generalizability: While focused on science, the authors argue the "step-wise logical retrieval" paradigm is applicable to other domains requiring precise inference, such as mathematics and legal reasoning.
Practicality: By utilizing "in-the-wild" corpora, RAISE offers a cost-effective solution for scientific reasoning without requiring the curation of specialized, domain-specific knowledge bases.

In conclusion, RAISE demonstrates that the key to enhancing scientific reasoning in LLMs lies not just in retrieving more information, but in retrieving the right kind of information—specifically, documents that provide the logical scaffolding necessary to solve complex, multi-step problems.