Carrying a chain of inference through to its conclusion

Claims

• mechanismsingle paper↑1↓0
  For 0.6B-8B Qwen3 models on math, logic and multiple-choice reasoning, quantifying reasoning uncertainty from a directed acyclic graph built by sampling several chains and merging semantically equivalent steps with an NLI model separates correct from incorrect generations better than sequence-level entropy, likelihood and self-prompting uncertainty measures.
• observationsingle paper↑1↓0
  For 1.5B-7B Qwen2.5 backbones trained with RL on multi-hop retrieval QA, giving the policy reversible memory operations (summary, backtrack over a stack) with per-action process rewards raises F1 over trajectory-reward agentic-RAG baselines, and removing the two memory actions costs more than removing the planning action.
• mechanismsingle paper↑1↓0
  For agentic retrieval-augmented multi-hop QA with 7B-class policy models, scoring each intermediate step for both logical validity and grounding in the retrieved passages — rather than scoring steps by the final answer — yields higher EM/F1 than outcome-reward and final-answer-based process-reward training, because it removes preference pairs where flawed retrieval happened to reach the right answer.
• observationsingle paper↑1↓0
  When a document image states multi-step selection constraints in narrative text and the supporting numbers sit in several charts, multimodal models degrade steadily as either the number of logical hops (2 to 5) or the number of charts (2 to 6) grows, with the best model reaching 62.83% overall against over 90% for human annotators.
• observationsingle paper↑1↓0
  When an error is injected into a supplied chain of thought, models mostly carry it to the answer: a planted arithmetic error costs small models 50-60% accuracy and 18% on average, though the largest models lose only 3-7%; unit-conversion errors cost about 9% at every scale; skipped steps and sycophantic steps cost small models about 10%; extra correct steps cost almost nothing (0-6%).
• mechanismsingle paper↑1↓0
  When fine-tuning a 14B model on knowledge-graph-derived multiple-choice QA for a single medical domain, attaching supporting triples from the same source text chunk to each target triple during supervision, and repairing residual one-hop failures before reinforcement learning, gives higher accuracy on held-out 3-, 4- and 5-hop questions than training on isolated triples or running RL from an unrepaired checkpoint.
• observationsingle paper↑1↓0
  Having a model score its confidence step by step detects failures in multi-step reasoning better than one holistic confidence score for the whole answer, with up to 15% higher AUROC on two multi-step benchmarks, so where a chain fails is more visible per step than in the final answer.
• observationsingle paper↑1↓0
  For LLM agents under a fixed ReAct harness answering questions over executable database-backed APIs plus document retrieval, accuracy falls sharply as the required reasoning depth grows from 1 to 5 hops (most models lose over half their accuracy), and the surviving failures concentrate in language-mediated steps — entity disambiguation, cross-source grounding, schema alignment — rather than in emitting syntactically valid tool calls.
• mechanismsingle paper↑1↓0
  When a long chain of thought is verified by classifying a graph of its steps, the predictive signal comes almost entirely from the semantic content of the steps, not the graph shape: replacing step embeddings with purely structural metadata (child/parent counts, chain index, position) drops accuracy to near chance on math, science and multiple-choice reasoning, while remaining above chance only on code.
• observationsingle paper↑1↓0
  On natural-language logical reasoning benchmarks, auto-formalizing each reasoning step into SMT-LIB and regenerating from the first step the solver cannot verify raises both the share of solver-verified steps and final-answer accuracy over plain chain-of-thought, and greedy regeneration at the failure point beats beam search or MCTS on step verifiability.
• mechanismsingle paper↑1↓0
  Verifying a chain of thought by decomposing it into nodes and asking binary consistency questions per node localizes errors better than judging the whole chain at once (F1 up 10-25% over CoT-based verifiers, error-localization accuracy far above an 8-vote end-to-end judge) while using 6-58 times fewer tokens, because whole-chain judging dilutes attention and multi-sampling pays for long generations.

Techniques

• Build the reasoning graph with a local NLI model, then classprocess
  Split a long chain of thought on transition keywords, link steps with entailment and contradiction edges predicted by a local NLI model instead of LLM calls, and train a graph attention network to predict whether the chain's final answer is
• Node-wise binary consistency checks for chain verificationprocess
  Split a reasoning chain into dependent nodes, check each node's consistency with its inputs by a yes/no query, and report the first failing node, instead of asking a verifier to read and judge the entire chain.
• Repair one-hop gaps and add same-chunk context before RLtraining
  Augments each KG triple with same-source-chunk supporting triples for supervision, then uses LLM judges to separate noisy triples from genuine one-hop knowledge gaps, continually fine-tunes on targeted repair items weighted by failure histo
• Reversible memory stack with per-action process rewardstraining
  Gives an RL-trained retrieval agent a LIFO memory stack with push/pop actions (plan, think, search, summary, backtrack, conclusion) and assigns format, retrieval-relevance and memory-usefulness rewards to the tokens of each action, plus bat
• Score reasoning steps for grounding, not final-answer matchtraining
  Train a generative process reward model that labels each interleaved reason/retrieve step for logical validity and evidential grounding, use it in value tree search to build step-level chosen/rejected pairs, and optimize the policy with ste
• Score uncertainty by complexity of a merged reasoning-step gdecoding
  Sample several chains of thought, merge semantically equivalent steps into a DAG using a bidirectional-entailment NLI model, and score uncertainty by graph width, height, or propagated per-step token uncertainty.
• Stepwise self-scoring for failure detectionprompting
  After a multi-step answer, ask the model to rate each step's correctness separately and combine the step scores, rather than asking for one confidence on the final answer.
• Verify each reasoning step with a solver and backtrack on fadecoding
  Decompose each generated reasoning step into context, implicit assumptions and conclusion, formalize it into a solver specification, score it by premise fidelity plus solver entailment, and regenerate from that step when the score falls bel

Sources

Every paper, post or observation behind this capability. Ones cited by a claim show the claim and its stance; ones filed directly are about the capability but have no claim drafted from them yet. Open one to add support or contest it.

• LogicTrack: Auditing Reasoning Trajectories of Large Language Models with Formal Logic Solvers2026-09-18
  ↑ supports a claim here
• Theseus in the Graph: Towards Traceable Multi-Hop Graph Navigation2026-09-13
  about this capability · no claim drafted yet
• TimeThink: Eliciting Compositional Reasoning in Timeseries Large Language Models2026-09-11
  about this capability · no claim drafted yet
• Repair Before Reinforce: Context-Augmented Knowledge Graph Reasoning for Multi-Hop Question Answering2026-09-10
  ↑ supports a claim here
• GUT: Quantifying and Optimizing the Reasoning Uncertainty of LLMs via Graph Complexity2026-09-04
  ↑ supports a claim here
• DocHop: Benchmarking Out-of-domain Multi-hop Reasoning in Information-Dense Documents2026-09-02
  ↑ supports a claim here
• PRO-Step: Step-level Process Reward Optimization for Retrieval-Augmented Generation2026-08-31
  ↑ supports a claim here
• LCoT-GV: Graph Attention Networks for Verifying Long Reasoning Chains in Large Language Models2026-08-31
  ↑ supports a claim here
• AgenticRag-R1: Agentic Reinforcement Learning with Stack Memory for Multi-Step Reasoning, Retrieval and Memorizing2026-08-30
  ↑ supports a claim here
• VAKRA: Evaluating Multi-Hop Reasoning Across APIs and Retrieval Under Tool-Use Policies2026-08-12
  ↑ supports a claim here
• Counterfactual Benchmarking and Training for Factuality Consistency and Order-Robust Grounded Reasoning in LLMs over Heterogeneous Knowledge2026-08-08
  about this capability · no claim drafted yet
• Fragile Thoughts: How Large Language Models Handle Chain-of-Thought Perturbations2026-02-11
  ↑ supports a claim here
• Self-Evaluating LLMs for Multi-Step Tasks: Stepwise Confidence Estimation for Failure Detection2025-11-10
  ↑ supports a claim here
• NCV: A Node-Wise Consistency Verification Approach for Low-Cost Structured Error Localization in LLM Reasoning2025-10-03
  ↑ supports a claim here