thinking-to-recall

name	thinking-to-recall
title	Thinking to Recall: How Reasoning Unlocks Parametric Knowledge in LLMs
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2603.09906
keywords	["Reasoning","Parametric Knowledge","Inference Time Scaling","Prompt Engineering","Fact Retrieval"]
description	Demonstrates that chain-of-thought reasoning improves LLM factual retrieval through computational buffering and self-priming. Improves single-hop factual accuracy by enabling models to generate contextual bridge facts before recalling answers.

Thinking to Recall: Unlocking Parametric Knowledge Through Reasoning

LLMs perform well on multi-hop reasoning tasks but surprisingly struggle on simple single-hop factual questions that require no complex logic. Enabling chain-of-thought reasoning dramatically improves performance on these supposedly simple queries. The question: why does reasoning help when the task requires no reasoning?

Through controlled experiments isolating different reasoning effects, this skill reveals three mechanisms: computational buffering (generating tokens to "warm up"), factual priming (recalling related facts that enable main answer), and verification (intermediate facts provide checkpoints). By understanding these mechanisms, you can optimize prompting strategies for pure factual retrieval tasks.

Core Concept

Reasoning doesn't just help complex tasks—it unlocks parametric knowledge on simple factual questions through:

1. Computational Buffer: Model generates reasoning tokens independently of semantic content; this computation alone improves main answer quality (even with random text of same length)

2. Factual Priming: Model generates topically related facts during reasoning that serve as "bridges" to the target answer, like priming in human memory

3. Hallucination Detection: Intermediate facts in reasoning traces can be verified, identifying when the trajectory will fail

Architecture Overview

• Chain-of-Thought Prompting: Request thinking before answering for simple facts
• Intermediate Fact Extraction: Parse generated reasoning to identify stated facts
• Fact Verification: Cross-check extracted facts against knowledge bases
• Trajectory Quality Assessment: Predict answer correctness from intermediate fact validity
• Calibration: Only prioritize high-confidence reasoning trajectories

Implementation Steps

Implement fact-aware reasoning with intermediate verification to improve single-hop factual recall.

Compute Reasoning Effect Isolation

import torch
from typing import List, Tuple

class ReasoningEffectAnalyzer:
    """Analyze what component of reasoning improves factual recall."""

     ():
        .model = model
        .tokenizer = tokenizer
        .kb = knowledge_base  

     () -> :
        
        effects = {}

        
        direct_answer = ._get_direct_answer(question)
        baseline_correct = direct_answer == ground_truth

        
        reasoning_output = ._get_reasoning_output(question)
        reasoning_answer = ._extract_answer(reasoning_output)
        reasoning_correct = reasoning_answer == ground_truth

        
        filler_length = (reasoning_output.split())
        filler_text = .join([] * filler_length)
        buffer_prompt = 
        buffer_answer = ._get_answer_from_prompt(buffer_prompt)
        buffer_correct = buffer_answer == ground_truth

        effects[] = (buffer_correct   baseline_correct)

        
        facts_in_reasoning = ._extract_facts(reasoning_output)
        related_facts = [f  f  facts_in_reasoning  ._is_related_to_question(f, question)]
        effects[] = (related_facts) > 

        
        facts_verified = [._verify_fact(f)  f  facts_in_reasoning]
        effects[] = (facts_verified) / ((facts_verified) + )

        
        effects[] = baseline_correct
        effects[] = reasoning_correct
        effects[] = reasoning_correct   baseline_correct

         effects

     () -> :
        
        prompt = 
         ._get_answer_from_prompt(prompt)

     () -> :
        
        prompt = 
         ._get_answer_from_prompt(prompt)

     () -> :
        
        
           reasoning_output:
             reasoning_output.split()[-].strip().split()[]
         reasoning_output.split()[-].strip()

     () -> []:
        
        
        sentences = [s.strip()  s  text.split()  s.strip()]
         sentences

     () -> :
        
        question_words = (question.lower().split())
        fact_words = (fact.lower().split())
        overlap = (question_words & fact_words)
         overlap > 

     () -> :
        
        
         .kb.is_true(fact)

     () -> :
        
        input_ids = .tokenizer.encode(prompt, return_tensors=)
         torch.no_grad():
            output_ids = .model.generate(
                input_ids, max_new_tokens=, temperature=
            )
         .tokenizer.decode(output_ids[])