Skip to content

ReasoningFlow: Discourse Structures for Understanding LLM Reasoning Traces

Conference: EMNLP 2026
arXiv: 2506.02532
Paper: ACL Anthology
Area: Large Language Model Reasoning
Keywords: Large Reasoning Models, Discourse Parsing, Long Chain-of-Thought, Error Propagation, Process Monitoring

TL;DR

ReasoningFlow formalizes the non-linear reasoning traces of Large Reasoning Models into fine-grained directed acyclic graphs with 8 node types and 14 edge types, demonstrating that 79.6% of erroneous intermediate steps in models like DeepSeek-R1 and QwQ are safely bypassed during backtracking or local verification without degrading final answers.

Background & Motivation

Large Reasoning Models (LRMs) such as DeepSeek-R1, QwQ, and GPT-oss generate extended reasoning traces filled with complex, non-linear reasoning behaviors including exploratory trial-and-error, backtracking, self-reflection, and local self-verification. Evaluating and monitoring the safety, correctness, and faithfulness of these sprawling thought processes has quickly emerged as an urgent challenge. Standard process reward models (PRMs) and stepwise evaluation frameworks typically assume a monotonically forward deductive chain, penalizing any trace containing an intermediate error under the assumption that a local calculation slip irreparably corrupts the final outcome. However, empirical observation reveals that LRMs frequently stumble into erroneous steps but subsequently recognize anomalies, trigger self-corrections, and arrive at fully correct final answers. Without a structured semantic lens to trace which premises actually feed into the final decision, conventional evaluation creates an artificial divide between step-level correctness and outcome-level validity.

Existing discourse and argumentation parsing methodologies, as well as early attempts to inspect LRM reasoning chains, fall short when confronted with these long, improvised traces. Classical frameworks such as Rhetorical Structure Theory (RST) and Persuasive Essay argumentation mining were constructed for well-curated human essays or news articles. They impose rigid projective tree structures that forbid crossing edges, making it impossible to capture cross-stage dependency jumps where an autoregressive model references an initial constant alongside a recent intermediate computation. Furthermore, prior frameworks completely omit discourse roles tailor-made for reasoning, such as hypothesis scoping, backtracking, and local error attack. Recent LLM trace annotation schemas—such as Thought Anchors, R1-Thoughtology, LCoT2Tree, and ReJump—operate either at the overly coarse paragraph level or constrain traces to simple linear stages and hyperedge trees. Crucially, none of these preceding frameworks established inter-annotator agreement (IAA) across multiple human experts, leaving the reliability of their schemas unverified.

To resolve this tension, this work bridges computational linguistics and cognitive science to formalize the left-to-right causal stream of autoregressive reasoning into an expressive directed acyclic graph (DAG). The framework accounts for the reality that while token generation is temporally irreversible, logical premises, plan executions, and meta-cognitive reflections naturally interweave with multi-predecessor convergence and long-range non-projective connections. Core idea: construct ReasoningFlow, a fine-grained directed acyclic discourse parsing framework for LRM reasoning traces with 8 functional node types and 14 semantic edge types, enabling topological tracking of error propagation and cognitive behaviors.

Method

Overall Architecture

ReasoningFlow maps raw, unstructured reasoning traces into topologically sound left-to-right directed acyclic graphs (DAGs), where vertices represent sub-sentence atomic reasoning units and directed edges capture premise dependencies, plan implementations, meta-evaluations, and logical contradictions. The complete pipeline executes across four tightly coupled stages: first, raw reasoning traces undergo rule-based paragraph bounding followed by LLM-driven sub-sentence segmentation and functional role classification; second, incoming edges and relation types are resolved within a constrained DAG topology; third, the resulting graph structure is leveraged for context pruning to enable accurate, low-cost stepwise quality evaluation; finally, discourse path traversal maps each intermediate flaw to its eventual downstream fate.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Raw LRM Reasoning Trace<br/>Unstructured Text Stream"] --> B["Fine-Grained Segmentation & Classification<br/>Sub-sentence Units & 8 Functional Roles"]
    B --> C["Four-Category DAG Discourse Parsing<br/>Directed Edges with 14 Relation Types"]
    C --> D["Graph-Pruned Stepwise Quality Evaluation<br/>Context Window Pruning via Graph Distance"]
    D --> E["Discourse Error Propagation Analysis<br/>Topological Path Tracing to Conclusions"]
    E --> F["Downstream Monitoring & Faithfulness Diagnostics<br/>Faithful vs. Unused vs. Neglected Errors"]

Key Designs

1. Fine-Grained Segmentation & Classification: overcoming paragraph-level coarseness and multi-intent clause blending

Traditional discourse corpora and thought-chain studies treat whole sentences or paragraphs as monolithic steps. However, LRM traces constantly exhibit rapid cognitive shifts within a single punctuation-delimited sentence—such as deducing a value in the first clause and immediately launching an audit plan in the second ("Therefore x must be 17, but I should double check"). Forcing sentence-level granularity conflates reasoning with meta-planning. ReasoningFlow introduces a two-tier segmentation paradigm: coarse splitting isolates paragraph blocks by identifying sentence-ending periods adjacent to capitalized starts without disrupting multi-line LaTeX math blocks; subsequently, an LLM splits compound sentences at semantic transition markers into atomic clauses. The node taxonomy defines 8 functional roles: Context (problem text/prompts), Planning (forward directions/subgoals), Fact (parametric laws/constants), Reasoning (deductive/inductive derivations), Restatement (zero-information paraphrases), Assumption (scoped speculative premises), Example (illustrative instances), Reflection (meta-evaluations/emotions), and Conclusion (asserted intermediate or final answers). To prevent missing target states, a two-stage prompting sequence classifies non-conclusion labels first before enforcing conclusion node resolution, ensuring that every trace has well-defined terminal endpoints.

2. Four-Category DAG Discourse Parsing: retiring projective tree constraints to capture non-projective cross-stage reasoning

Applying Rhetorical Structure Theory (RST) trees to LRM traces requires discarding approximately 42.6% of valid dependency edges to uphold projectivity, severely corrupting trace integrity. ReasoningFlow adopts an unconstrained left-to-right DAG structure that inherently accommodates crossing dependencies while matching the autoregressive forward nature of LLM generation. To handle the potential \(O(N^2)\) edge complexity, edge parsing is executed in an incoming-edge-per-node paradigm where the model identifies the minimal complete set of predecessor premises for each destination step. The 14 edge labels span four major categories: - Reason-oriented: infer (premise to conclusion), execute (plan to implementation), restate (pointing to the original restated unit), elaborate-fact (general law to concrete fact), and exemplify (concept to instance); - Plan-oriented: proceed (prior facts motivating a next plan), verify (reasoning node initiating a verification plan), decompose (high-level plan split into subplans), and backtrack (abandoned plan triggering an alternative search branch); - Reflect-oriented: capturing the sentiment of Reflection nodes toward prior steps via positive (validation), negative (doubt or denial), and uncertain (confusion or hesitation); - Validate-oriented: measuring propositional consistency across distant reasoning steps via support (independent derivation agreeing with prior claims) and attack (explicit contradiction, refutation, or direct arithmetic correction). This taxonomy allows representing complex reasoning mechanisms—such as depth-first search branch switching or proof-by-contradiction—as clean subgraphs.

3. Graph-Pruned Stepwise Quality Evaluation: resolving context pollution and false-positive PRM penalties on non-deductive steps

Evaluating mathematical or scientific validity across thousand-token traces suffers from context bloat: feeding the entire trace history into an evaluator LLM introduces distractor noise, whereas evaluating a step in isolation strips necessary premises. Furthermore, standard process reward models (like Qwen2.5-Math-PRM) lack discourse awareness, assigning erroneous step labels to 24%–51% of valid Planning and Reflection nodes simply because they contain no deduction. ReasoningFlow deploys graph topology pruning: to evaluate the validity of a Reasoning node, the context is restricted strictly to antecedent nodes within a graph distance \(\le 2\). This minimal complete context reduces input token overhead by over 70% while sharpening evaluative precision. The evaluation categorizes validity into three distinct states—Correct, Direct Error (an intrinsic derivation mistake with valid premises), and Propagated Error (a derivation that correctly follows flawed premises)—significantly reducing evaluation ambiguity in long chains.

4. Discourse Error Propagation Analysis: categorizing error fates to expose unfaithfulness and enhance process monitorability

Once the complete DAG is constructed and stepwise validity is established, ReasoningFlow performs reverse-reachability graph traversal from Conclusion nodes to diagnose the true impact of every flawed step. Intermediate errors are categorized into three mutually exclusive outcomes: - Unused: the erroneous node belongs to an abandoned dead-end branch or was refuted by a subsequent attack correction, having zero directed paths to the final conclusion; - Neglected: the error sits along the formal lineage of a correct final answer, yet the model unfaithfully bypassed or ignored the flawed numerical premise down the line, miraculously arriving at the right conclusion; - Faithful: the error directly propagates downstream through logical dependencies to produce an incorrect final answer. Quantifying these error pathways demystifies why intermediate step mistakes do not automatically trigger task failures in LRMs, providing an empirical compass for designing next-generation, trajectory-aware process reward models.

A Worked Example

The operation of ReasoningFlow is illustrated through a chemical molecular weight calculation trace: 1. node_1 (Planning): "Let's calculate the molecular weight of the ester fragment." 2. node_2 (Reasoning): "For the ethyl group -OCH2CH3, oxygen is 16 and ethyl is 13, sum is 29." [Direct Error introduced here] 3. node_3 (Planning): "Wait, let me double check the calculation." [Edge: node_2 \(\xrightarrow{\text{verify}}\) node_3] 4. node_4 (Reflection): "This calculation seems off." [Edge: node_2 \(\xrightarrow{\text{negative}}\) node_4] 5. node_5 (Reasoning): "Ethyl is C2H5, which has 212 + 51 = 29, so OCH2CH3 is 16 + 29 = 45." [Edge: node_2 \(\xrightarrow{\text{attack}}\) node_5] 6. node_6 (Conclusion): "The correct fragment mass is 45 g/mol." [Edge: node_5 \(\xrightarrow{\text{infer}}\) node_6]

Under naive step evaluation, node_2 would cause the whole solution to be rejected. Under ReasoningFlow, node_5 explicitly attacks and supersedes node_2, and the terminal node node_6 connects only through the corrected node node_5. The error in node_2 is thus formally diagnosed as Unused/Corrected, preserving the validity of the overall solution.

Key Experimental Results

Main Results

The validity and stability of ReasoningFlow were verified through double-blind human annotation on 31 traces (2.1k steps), evaluating inter-annotator agreement (Krippendorff's \(\alpha\)). Automated LLM annotators were benchmarked against human ground truth on Node Classification (NC, \(k=8\)) and Edge Detection/Classification (EDC, \(k=15\)).

Annotation Configuration / Model NC Macro-F1 EDC Macro-F1 NC Agreement (\(\alpha\)) EDC Agreement (\(\alpha\)) Operational Role & Notes
Human-Human Double Blind (IAA) — — 0.8851 0.9193 4 expert annotators; \(\alpha > 0.8\) proves schema consistency
GPT-5-mini 0.792 0.425 0.741 0.444 Lightweight baseline; struggles with 14-way edge discrimination
GPT-5.1 0.833 0.574 0.761 0.604 High node classification, moderate edge recall
Gemini-2.5-Flash 0.811 0.535 0.749 0.576 Efficient baseline
Gemini-3-Flash 0.865 0.583 0.820 0.607 Top node classifier; deployed for large-scale node parsing
Gemini-3.1-Pro 0.859 0.646 0.812 0.677 Top edge parser; only model exceeding \(\alpha \ge 0.67\) on edges
Human Verification on LLM Annotations 0.909 0.869 — — 30 randomly inspected traces confirm production quality

Ablation Study

Using the scaled dataset of 1,260 traces (247.7k steps) across 5 models on competition math (AIME 2024) and graduate science (GPQA-Diamond), the paper evaluated how intermediate erroneous steps are handled relative to final answers.

Dataset Domain Evaluated Model Total Errors Unused Errors (%) Neglected Errors (%) Faithful Errors (%) Empirical Takeaway
AIME (Math) QwQ-32B 123 98 (79.7%) 12 (9.8%) 13 (10.6%) Backtracking and local checks cleanly isolate mistakes
AIME (Math) DeepSeek-R1 215 192 (89.3%) 8 (3.7%) 15 (7.0%) RL-trained reasoning model discards nearly 90% of local errors
AIME (Math) GPT-oss-120B 61 39 (63.9%) 2 (3.3%) 20 (32.8%) Medium reasoning effort exhibits higher direct error leakage
AIME (Math) Qwen2.5-32B (Non-LRM) 83 28 (33.7%) 3 (3.6%) 52 (62.7%) Standard instruct models lack backtracking; errors directly corrupt answers
AIME (Math) DeepSeek-V3 (Non-LRM) 200 180 (90.0%) 0 (0.0%) 20 (10.0%) Baseline struggles to terminate, generating abandoned loops
GPQA (Science) QwQ-32B 3398 2813 (82.8%) 203 (6.0%) 382 (11.2%) Dense scientific reasoning heavily leverages local verification
GPQA (Science) DeepSeek-R1 2928 2529 (86.4%) 156 (5.3%) 243 (8.3%) Only 8.3% of mistakes faithfully reach final incorrect answers
GPQA (Science) GPT-oss-120B 1409 1060 (75.2%) 108 (7.7%) 241 (17.1%) Consistent isolation of dead-end hypotheses across tasks
GPQA (Science) Qwen2.5-32B (Non-LRM) 438 171 (39.0%) 102 (23.3%) 165 (37.7%) Multiple-choice format inflates lucky guesses from flawed premises
GPQA (Science) DeepSeek-V3 (Non-LRM) 405 117 (28.9%) 47 (11.6%) 241 (59.5%) Over half of erroneous steps directly propagate to wrong answers

Furthermore, the authors benchmarked mechanistic interpretability (Thought Anchors attention masking KL-divergence) against ReasoningFlow's semantic edges. On QwQ-32B AIME traces, Thought Anchors achieved a PR-AUC of 0.549 for edge prediction, which barely surpassed the heuristic baseline of selecting the closest \(K\) recent nodes (AUC = 0.531). On Qwen2.5-32B, the proximity baseline (AUC = 0.635) substantially outperformed Thought Anchors (AUC = 0.527), proving that attention masking primarily reflects token distance rather than genuine discourse relationships.

Key Findings

  • Structural Convergence Across LRMs: Despite divergent base model initializations and distinct post-training corpora, DeepSeek-R1 and QwQ-32B exhibit near-identical reasoning graph triplet distributions (Jensen-Shannon Divergence = 0.010), while their non-reasoning counterparts (DeepSeek-V3 vs. Qwen2.5-32B) diverge substantially (JS-Div = 0.083). Reinforcement learning on long thinking trajectories converges toward a universal cognitive discourse structure.
  • Local Verification Dominates Global Checking: Local verification occurs three times more frequently than global answer verification (19.1 vs. 6.1 occurrences per trace). When local checks trigger explicit correction (attack), the step error rate drops from 36% to 16% (accuracy rises from 64% to 84%), and corrected nodes are four times more likely to feed the correct final answer than their flawed predecessors (20% vs. 5%).
  • Reflection Sentiment Faithfully Tracks Model Confidence: Across AIME and GPQA traces, steps followed by positive reflection are 78.1% logically correct; this drops to 66.2% under uncertain reflection and plummets to 45.6% under negative reflection. The model's conversational self-doubt markers are genuine signals of internal validity rather than decorative filler tokens.
  • Divergence Between Language Discourse and Mechanistic Causal Masks: Stepwise causal effects measured via attention masking fail to match high-level semantic dependencies, warning against using raw attention attribution as a proxy for discourse logic.

Highlights & Insights

  • First Rigorous DAG Schema for Reasoning Traces: Replaces overly restrictive tree grammars with a flexible, directed acyclic graph formalization, validating its categories with human agreement exceeding 0.88.
  • Disproving the "Single Error Invalidates Trace" Dogma: Demonstrates that nearly 80% of intermediate errors are safely pruned during backtracking, explaining why outcome-based Best-of-N filtering often discards perfectly viable reasoning paths.
  • Enabling High-Precision Context Pruning for PRMs: By providing graph distance bounds (\(\le 2\)), ReasoningFlow strips away irrelevant context tokens, reducing computation costs while shielding PRMs from falsely penalizing non-deductive planning and reflection clauses.

Limitations & Future Work

  • High Automated Annotation Costs: Parsing 1,260 long reasoning traces with commercial frontier models cost thousands of dollars; future work should distill ReasoningFlow parsers into specialized, open-source 7B/14B models.
  • Unverified on Proprietary Frontier LRMs: The current evaluation is restricted to open-weight models (DeepSeek-R1, QwQ, GPT-oss); proprietary reasoning APIs (OpenAI o1/o3, Claude 3.7 Sonnet) with closed thinking traces remain to be systematically studied.
  • Limited to Text-Only Modalities: The current schema spans mathematics, science, and argumentation, but has yet to be adapted for multimodal vision-language chains or interactive code-interpreter trajectories.
  • vs Rhetorical Structure Theory (RST-DT): RST assumes single-parent projective trees and is unable to represent the 42.6% of crossing edges that appear in long CoT, whereas ReasoningFlow supports multi-parent DAGs and reasoning-specific discourse relations.
  • vs Thought Anchors: Thought Anchors relies on unsupervised attention masking that conflates proximity with causality; ReasoningFlow establishes grounded semantic discourse relations that expose the limitations of attention-mask metrics.
  • vs R1-Thoughtology & LCoT2Tree: Previous schemas are restricted to coarse paragraph units or semi-linear trees without human IAA validation, whereas ReasoningFlow operates at the sub-sentence clause level with verified high reliability.

Rating

  • Novelty: ⭐⭐⭐⭐⭐ Formulates the first comprehensive, fine-grained DAG discourse parsing ontology for LRM reasoning traces, bridging computational linguistics and LLM reasoning.
  • Experimental Thoroughness: ⭐⭐⭐⭐⭐ Includes 31 human double-blind verified traces, 1,260 machine-annotated traces totaling 247.7k steps across five models, alongside rigorous IAA and error propagation analyses.
  • Writing Quality: ⭐⭐⭐⭐⭐ Clear definitions, coherent narrative progression, robust formalization, and transparent documentation of error taxonomies.
  • Value: ⭐⭐⭐⭐⭐ Provides an indispensable theoretical and empirical blueprint for developing trajectory-aware process reward models and faithful reasoning monitors.