The Molecular Structure of Thought: Mapping the Topology of Long Chain-of-Thought Reasoning

ArXiv: 2601.06002

🎯 Pitch

Long chain-of-thought reasoning is not learned by imitating human or weak-LLM outputs—instead, it requires stable, molecule-like architectures of Deep-Reasoning, Self-Reflection, and Self-Exploration bonds that emerge from distributional structure, not keywords. Mixing structurally incompatible reasoning patterns (semantic isomers) destabilizes training even when token statistics match, but a new synthesis method can transfer those effective bond distributions from strong models to instruction-tuned LLMs without using their actual reasoning traces.

---

1. Executive Summary

This paper studies why large language models (LLMs) fail to learn effective long chain-of-thought (Long CoT) reasoning from human or weak-LLM imitation, proposing that successful Long CoT trajectories exhibit stable molecular-like structures formed by three interaction types: Deep-Reasoning (covalent-like bonds that form dense local clusters of coupled deductions), Self-Reflection (hydrogen-bond-like links that create long-range corrective connections to prior steps), and Self-Exploration (van der Waals-like forces that bridge distant reasoning clusters). Analyzing distillation from strong reasoning models (DeepSeek-R1, OpenAI-OSS, QwQ) across six benchmarks (GSM8K, MATH-500, AIME2024, AIME2025, AMC2023, OlympiadBench), the authors find that these bond structures emerge from fine-tuning on structural patterns rather than surface keywords, and introduce Effective Semantic Isomers — reasoning chains with identical concepts but different behavior distributions — showing that mixing structurally incompatible isomers destabilizes learning even when token statistics match. Building on these findings, the paper introduces Mole-Syn, a distribution-transfer-graph method that synthesizes Long CoT structures from instruction-tuned LLMs by following behavior transition probabilities estimated from strong reasoning models, boosting performance close to direct distillation while stabilizing reinforcement learning, establishing that effective Long CoT capability can be induced through structural transfer alone without access to teacher reasoning traces.

2. Context and Motivation

The Core Problem: Long CoT Reasoning Cannot Be Learned Through Simple Imitation

The fundamental puzzle this paper tackles is why standard distillation approaches fail to transfer long chain-of-thought reasoning capabilities to language models. Recent advances in reasoning-specialized LLMs like DeepSeek-R1 [8] and OpenAI's o-series models [16] demonstrate that generating extended, multi-step reasoning traces — often spanning dozens or hundreds of steps with interleaved self-verification, backtracking, and hypothesis exploration — dramatically improves performance on complex mathematical and logical tasks. However, when practitioners attempt to replicate these capabilities by distilling from these strong reasoning models into smaller or instruction-tuned models, the results are inconsistent and often disappointing.

The paper's preliminary studies establish this failure concretely. As shown in Figure 3, when the authors fine-tune standard instruction-tuned models (Llama-3.1-8B-Instruct, Qwen2.5-7B-Instruct) on Long CoT traces generated through three different approaches, only one works:

• Distillation from strong reasoning LLMs (DeepSeek-R1, QwQ-32B, OpenAI-OSS-120B) reliably imparts Long CoT capabilities, improving performance across all six benchmarks.
• Distillation from weak instruction-tuned LLMs using in-context learning (ICL-Distill) — where a Qwen2.5-32B-Instruct model is given a 1-shot Long CoT example and prompted to emulate the style — fails catastrophically. Performance drops sharply compared to both the base model and the reasoning-LLM distillation baseline. The instruction model can mimic short reasoning traces (~6–8 steps) but cannot maintain coherence or exploration over extended trajectories.
• Fine-tuning on human-annotated reasoning traces — following the approach of Du et al. [7], who showed humans can generate step-by-step solutions without imitating reasoning models — also fails to reproduce Long CoT gains. Figure 4 shows that human-trace training yields substantially lower performance than R1 distillation, even when both are trained on the same number of examples.

This failure pattern poses a deep question: if both human-written solutions and instruction-LLM-generated traces contain the same surface-level reasoning content (step-by-step derivations, logical transitions, final answers), why do they fail to teach Long CoT reasoning when strong reasoning model traces succeed?

Why This Matters: Practical and Theoretical Stakes

The gap this paper addresses carries significant implications across multiple dimensions:

Economic and access concerns. Distillation from strong reasoning models is currently the dominant approach for building capable open-source reasoning systems. However, this creates a dependency: only organizations with access to the most capable (and often proprietary) reasoning models can produce high-quality Long CoT training data. If the mechanisms underlying effective distillation were understood, it might be possible to synthesize training data from cheaper instruction-tuned models, democratizing access to Long CoT capabilities. Mole-Syn, the paper's proposed method, is directly motivated by this goal — it uses transfer graphs estimated from strong teachers to guide instruction-LLM synthesis, producing effective training data without requiring access to teacher reasoning traces.

Scientific understanding of reasoning acquisition. A deeper question concerns what, exactly, is being learned during Long CoT fine-tuning. If surface-level imitation of keywords and reasoning steps fails, then the model must be acquiring something more structural — a capacity to organize reasoning over extended horizons that goes beyond mimicking lexical patterns. Understanding this acquisition mechanism is fundamental to building more capable reasoning systems and diagnosing why certain training recipes succeed or fail.

Robustness and generalization. The paper's structural isomer analysis reveals that statistically similar reasoning chains (with correlation $r \approx 0.95$ in behavior distributions) can produce performance differences exceeding 10 percentage points (Table 1). This fragility means that distillation is not a robust process — small perturbations to the training data's structural composition can cause large performance swings — and understanding the underlying geometry of effective reasoning structures is essential for reliable system building.

Protection of proprietary reasoning. The paper's analysis of how summarization and compression disrupt Long CoT structures (Section 8, Tables 3–4) provides mechanistic insight into why private LLM providers can expose their "thinking" content without enabling effective distillation. This has commercial and policy implications for the open-source ecosystem.

Self-improvement and reinforcement learning. The finding that Mole-Syn-initialized models exhibit more stable and sustained RL improvement (Figure 12) suggests that structural composition of initial training data has lasting effects on learning dynamics. This connects to the broader question of how to design data that supports continual improvement, not just one-shot performance.

Where Prior Approaches Fall Short

The paper identifies several specific limitations in existing work on Long CoT and reasoning transfer:

1. Node-centric models of reasoning structure are insufficient. Prior work has modeled CoT reasoning as sequences of steps (chain structures) [1, 2, 3] or as trees/graphs where nodes represent reasoning states and edges represent transitions [20, 21, 22, 23]. These approaches capture local connectivity — which step follows which, where branching occurs, where the chain revisits earlier nodes — but they treat reasoning behaviors as node attributes rather than as relational properties of the transitions themselves. In a tree or graph model, a self-reflection step and a deep-reasoning step are both simply nodes with different labels; what matters in this paper's analysis is how these behaviors connect — the distribution of behavior transitions across the entire trajectory — which node-centric models cannot represent.

The paper's molecular structure framework (Section 3) differs fundamentally by treating behaviors as edge types (bonds) and focusing on their global distribution $P(b' \mid b)$ over consecutive transitions and the marginal distribution $\pi(b)$. A Long CoT trajectory is characterized not by which behaviors appear, but by how they are composed into a stable, self-consistent macromolecular structure. This shift from nodes to edges enables the paper's key analytical tools: transfer graphs (Figure 5), attention energy analysis (Figure 8), and semantic isomer comparison via distribution divergence.

2. Self-correction and exploration have been studied in isolation. Prior work on self-reflection [17] and self-exploration [18] treated these as individual capabilities that could be prompted or fine-tuned independently. The paper's contribution is to show that these behaviors are not independent skills but are mutually constraining components of a unified structure. The effectiveness of self-reflection depends on how it is distributed relative to deep reasoning and exploration in the trajectory — excessive reflection causes overthinking on simple problems, while insufficient reflection allows drift on complex ones (Appendix G, Figure 16). Similarly, the paper's semantic isomer analysis (Section 5) demonstrates that mixing reflection-heavy traces from one teacher with exploration-heavy traces from another — even when both distributions are individually effective — creates structural chaos that degrades performance below either source alone. Prior work had no framework for analyzing these interactions.

3. Distillation literature focuses on content, not structure. The dominant paradigm in knowledge distillation for reasoning has been to maximize the similarity between student and teacher outputs, either at the token level (next-token prediction on teacher-generated sequences) or at the representation level (matching hidden states or attention patterns). Recent work [14, 12] emphasizes that only "high-quality" reasoning traces are effective, but defines quality primarily in terms of correctness and completeness. The paper's keyword replacement experiment (Figure 6c) and isomer analysis (Section 5) demonstrate that correctness and lexical similarity are insufficient: models trained on traces with shuffled behavior distributions but identical token content perform substantially worse, while models trained on traces with replaced keywords but preserved behavior distributions perform comparably. This implies that the student learns the structural composition of reasoning, not the surface form — a finding that existing distillation frameworks cannot explain or exploit.

4. No understanding of why mixing reasoning sources fails. Practitioners commonly observe that combining Long CoT data from multiple teachers yields worse results than using a single teacher, but the mechanism is unclear. The paper's conflict learning experiment (Figure 11) provides a structural explanation: when two teachers have highly correlated ($r \approx 0.9$) but subtly different behavior transition distributions, joint training prevents the model from converging to either stable mode. The self-correlation of the jointly trained model drops below 0.8, and the resulting behavior distribution fluctuates across samples rather than settling into either teacher's stable configuration. This is a genuine discovery — the incompatibility arises not from distributional mismatch (the distributions are nearly identical by standard metrics) but from structural incompatibility in how reasoning behaviors compose, analogous to how two stable protein folds cannot be simultaneously maintained by the same amino acid sequence.

5. ICL-based distillation is poorly understood. The common technique of using in-context learning demonstrations to transfer reasoning style [39] is shown to work only under very specific conditions — when the demonstration's behavior transition distribution closely matches the target teacher's distribution (correlation $\gtrsim 0.9$, Figure 9). Randomly selected demonstrations, or demonstrations with slightly different behavior distributions ($r < 0.8$), produce negligible gains. This explains why ICL-based distillation has produced inconsistent results in prior work — the critical variable (behavior structure of the demonstration) was uncontrolled and unreported.

How This Paper Positions Itself

The paper positions itself as providing a mechanistic account of Long CoT learning that explains the empirical patterns above through a single coherent framework. Rather than proposing a new training method or architecture, the primary contribution is analytical: modeling reasoning trajectories as molecular-like structures with three distinct bond types whose global distribution determines learning success. This framework enables:

• Explaining why distillation succeeds from strong reasoning models but fails from humans or weak instruction models: only strong reasoning models produce the stable three-bond distribution (Figure 5), and their traces teach this distribution rather than surface keywords (Figure 6).
• Predicting when mixing training sources will fail: structural incompatibility in behavior transition distributions, not token-level distribution mismatch (Section 5.2).
• Synthesizing effective training data from scratch: Mole-Syn uses transfer graphs estimated from strong teachers to guide instruction-LLM generation, decoupling structural transfer from surface imitation (Section 6).
• Quantifying the geometric effects of each bond type: deep reasoning densifies logical structure, self-exploration expands search space, and self-reflection folds the chain toward stable solutions (Section 7, Figure 13).

The paper explicitly contrasts its approach with the dominant node-centric frameworks in prior work (Section 1, Figure 2). In chain/tree/graph models, reasoning is represented as a sequence or branching structure of logical states. In the molecular model, reasoning is represented as a distribution of edge types forming a stable macromolecule. This shift from local to global structure — from "what reasoning steps occur" to "how reasoning behaviors are arranged and interact" — is the paper's key conceptual move.

The paper also positions itself relative to the human reasoning literature, specifically Du et al. [7] and Chen et al. [10]. The metacognitive oscillation analysis (Figure 10) reveals a fundamental difference in information dynamics: humans exhibit uniform entropy reduction across reasoning steps (81.3% of cases show changes < 0.1), while R1 models alternate between high-entropy exploration (slope > 0.6, $\Delta\text{entropy} > 0.05$) and rapid convergence. This suggests that human reasoning traces — despite being step-by-step and logically valid — do not encode the oscillatory dynamics that make LLM-generated Long CoT learnable, which explains why fine-tuning on human traces fails (Figure 4) despite their surface similarity to model-generated traces.

3. Technical Approach

3.1 Reader Orientation

This is primarily an analytical and synthesis paper — it proposes a theoretical framework for understanding Long CoT reasoning as a molecular-like structure formed by three interaction types (covalent-like, hydrogen-bond-like, van der Waals-like bonds), validates this framework through extensive empirical analysis, and then builds on these insights to create Mole-Syn, a practical method for synthesizing effective Long CoT training data from instruction-tuned LLMs without requiring access to expensive reasoning teacher model outputs. The core problem it solves is: given that distillation from strong reasoning LLMs works but distillation from humans or weak instruction-tuned LLMs fails, what structural property of reasoning trajectories determines learnability, and how can we transfer only that property to enable low-cost data synthesis? The shape of the solution is: (1) formalize Long CoT as a behavior-directed graph with edge types that have stable distributions across models, (2) identify why certain structural configurations (semantic isomers) succeed or fail, (3) use the behavior transition distribution — not the surface text — as the transferable unit, and (4) synthesize new trajectories by following this transition distribution with instruction-tuned LLMs.

3.2 Big-Picture Architecture (Diagram in Words)

The system has four major components that span analysis, validation, and synthesis:

1. Behavior Tagger (Appendix C.1–C.2): Annotates every transition between consecutive reasoning steps with one of four behavior labels — Normal Operation (N), Deep Reasoning (D), Self-Reflection (R), or Self-Exploration (E) — producing a labeled edge sequence for any reasoning trajectory. This component is the foundation for all subsequent analysis; it is implemented using Qwen2.5-32B-Instruct prompted with detailed classification rules, validated against human annotations at macro-F1 > 0.85.

2. Transfer Graph Estimator (Section 4.1, Figure 5): Aggregates labeled transitions across a corpus of reasoning traces to estimate the empirical behavior transition distribution $P(b' \mid b)$ and the marginal distribution $\pi(b)$. Input is a set of (question, Long CoT trajectory) pairs from a teacher model; output is a $4 \times 4$ normalized transition matrix visualized as a heatmap. This graph converges to stability (Pearson r > 0.95) when computed over >2,000 samples, and the graphs from different strong reasoning models (DeepSeek-R1, OpenAI-OSS, QwQ) correlate at r > 0.9 (p < 0.001).

3. Structural Analysis Modules (Sections 4.3–4.4, 5, 7): A collection of analysis pipelines that validate and extend the molecular hypothesis:

   • Geometric embedding (Section 4.3 and Appendix C.3): Maps reasoning steps to vectors via Qwen3-8B penultimate-layer hidden states, reduces dimensionality with t-SNE, and quantifies clustering, folding, and expansion behavior using minimum enclosing ball volumes and cluster distance metrics.
   • Attention energy analysis (Section 4.4 and Appendix C.1.2–C.1.4): Extracts attention weights between step pairs labeled with different bond types, converts them to energy values via the negative logit $E_{ij} = -q_i^\top k_j / \sqrt{d_k}$, and shows that Deep Reasoning consistently exhibits the lowest effective energy (strongest attention), Self-Reflection intermediate, and Self-Exploration the highest (weakest attention).
   • Information flow/entropy trajectory analysis (Section 5.1.1, Appendix D.3): Encodes each reasoning step as a semantic probability vector, tracks cumulative entropy and entropy change $\Delta I_t$ across steps, and characterizes reasoning dynamics in a 2D phase space (cumulative entropy vs. instantaneous change).
   • Semantic isomer construction and comparison (Section 5, Appendix D): Defines semantic isomers as reasoning trajectories that solve the same task and visit similar concepts but differ in behavior transition distributions, enabling controlled studies of structural compatibility by mixing isomers from different teacher models.

4. Mole-Syn Synthesizer (Section 6, Appendix E): Uses an estimated transfer graph $\hat{P}(b' \mid b)$ from a strong teacher to guide the synthesis of new Long CoT trajectories using only an instruction-tuned LLM. The pipeline works as a controlled random walk:

   • Initialize the synthesis state to Self-Exploration (to begin the trajectory with broad hypothesis generation).
   • At each step, sample the next behavior $b_{t+1}$ from $\hat{P}(b_{t+1} \mid b_t)$ using the current behavior $b_t$.
   • Prompt the instruction-tuned LLM with a behavior-specific prompt designed to elicit that type of reasoning (separate prompts for N, D, R, E, listed in Appendix E).
   • Append the model's output to the trajectory and repeat until a final answer is produced (or a maximum length is reached). The output is a complete Long CoT trajectory with a behavior transition distribution that statistically matches the strong teacher's distribution, but whose surface text is generated by the instruction-tuned model from scratch.

Information flows: (a) Strong reasoning teacher generates Long CoT traces → Behavior tagger labels edges → Transfer graph estimator computes $\hat{P}$ → (b) Mole-Syn uses $\hat{P}$ to guide instruction-LLM through behavior-space random walk with behavior-specific prompts → (c) Synthetic traces used for supervised fine-tuning or RL initialization → (d) Structural analysis modules validate that synthetic traces exhibit the expected geometric and attention-energy properties.

3.3 Roadmap for the Deep Dive

• First, the formalization of Long CoT as a behavior-directed graph (Section 3, Appendices C.1–C.2): this is the mathematical substrate for everything that follows — we need the definitions of nodes, edges, bond types, and transition distributions before we can analyze or synthesize anything.
• Second, the behavior annotation pipeline (Appendix C.1–C.2): how the paper automatically labels each transition with one of four behavior types, including the prompt template, decision rules, and validation against human annotations. This is the measurement instrument whose reliability determines the validity of all subsequent analyses.
• Third, the transfer graph estimation and stability analysis (Section 4.1, Figure 5): how empirical transition distributions are computed from annotated trajectories, what "stable" means (Pearson correlation convergence), and the key empirical finding that different strong reasoning models produce highly correlated transfer graphs.
• Fourth, the structural validation analyses (Sections 4.2–4.4, Appendices C.3–C.5): the sparse auto-encoder experiment showing SFT learns structure not keywords, the geometric embedding analysis showing folding/expansion/densification, and the attention-energy analysis showing the Boltzmann-distribution interpretation. These establish empirical grounding for the molecular analogy.
• Fifth, the semantic isomer framework and conflict learning experiments (Section 5, Appendix D): what constitutes a semantic isomer, how they are constructed and compared, the information-flow/entropy analysis that distinguishes effective from ineffective isomers, and the critical experiment showing that mixing stable isomers from different teachers creates structural chaos.
• Sixth, the Mole-Syn synthesis methodology (Section 6, Appendix E): the random-walk-on-transition-graph algorithm, the behavior-specific prompts, the supervised fine-tuning and RL initialization results, and the relationship between synthesis backbone quality and performance.
• Seventh, the bond shaping function analysis (Section 7, Appendix F): how each of the three bond types geometrically reshapes the semantic space — deep reasoning densifies, self-exploration expands, self-reflection stabilizes — quantified via minimum enclosing ball volume changes.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an analytical and methods paper whose core idea is that effective Long CoT reasoning trajectories possess a stable, molecular-like structure characterized by the global distribution of three behavior-labeled edge types (bonds), and that this structure — not surface lexical patterns — is what gets learned during supervised fine-tuning, explaining why distillation from structurally coherent teachers works while imitation of surface form does not. The paper then operationalizes this insight into Mole-Syn, which transfers only the structural skeleton (the behavior transition graph) to guide synthesis.

---

Formalizing Long CoT as a Behavior-Directed Graph

The paper models a Long CoT reasoning trajectory not as a sequence of step-level contents but as a behavior-labeled directed graph $G = (V, E)$. This formalism is defined in Section 3 and elaborated mathematically in Appendix C.1.

Trajectory segmentation. Given an input query $x$, a model generates an output text $y$ containing intermediate reasoning steps followed by a final answer. The text is segmented into $T$ step-level units $\tau = (u_1, \ldots, u_T)$ using standard delimiters (line breaks, bullet markers), following the segmentation conventions of Chen et al. [19] and ROSCOE [34]. Each $u_t$ is a textual step — a paragraph or sentence-level chunk representing one coherent reasoning unit.

Nodes and edges. Each step $u_t$ is a node $v \in V$. For each consecutive pair of steps, a directed transition (edge) is defined:

$e_t = (u_t \rightarrow u_{t+1})$

representing the logical flow from step $t$ to step $t+1$. The entire trajectory yields an edge sequence $(e_1, \ldots, e_{T-1})$.

Behavior labels. Each edge $e_t$ is annotated with a behavior type from the set:

$\mathcal{B} = \{N, D, R, E\}$

where N is Normal Operation (routine computation, direct execution), D is Deep Reasoning (multi-step causal or deductive inference extending the logical chain), R is Self-Reflection (explicit commentary on, auditing, or revision of the model's own reasoning process, including tracing back to prior logical nodes), and E is Self-Exploration (branching into alternative hypotheses or candidate solution paths, keeping multiple possibilities active). The formal definitions (Appendix C.1.1) emphasize intent: D introduces new latent assumptions or intermediate logical variables; R explicitly comments on the reasoning process itself, expressing uncertainty or revising strategy; E intentionally raises new sub-questions or alternatives without committing to convergence; N covers everything else (arithmetic, formatting, paraphrase, direct plan execution).

A critical distinction from node-centric models. In prior tree- or graph-of-thought work [20, 21, 22, 23], nodes represent reasoning states and behaviors are node attributes. Here, behaviors are properties of edges — they characterize the relationship between steps, not the steps themselves. A Deep Reasoning edge from $u_t$ to $u_{t+1}$ means that $u_{t+1}$ extends the logical chain via non-trivial inference building on $u_t$. A Self-Reflection edge means that $u_{t+1}$ looks back at $u_t$ (and likely earlier steps as well) to evaluate, correct, or reconsider. This edge-centric view is what enables the paper's key analytical move: focusing on the distribution of how behaviors compose, not just which behaviors appear.

Transfer distribution. From a corpus $\mathcal{C}$ of reasoning trajectories, the empirical behavior transition distribution is estimated:

$P_{\mathcal{C}}(b' \mid b) = \frac{\text{count}(b \rightarrow b')}{\sum_{b''} \text{count}(b \rightarrow b'')}$

where $\text{count}(b \rightarrow b')$ is the number of consecutive edge pairs where the first edge has behavior $b$ and the second has behavior $b'$. The marginal distribution is:

$\pi_{\mathcal{C}}(b) = \frac{\text{count}(b)}{\sum_{b'} \text{count}(b')}$

In plain language: for every occurrence of a behavior type $b$, tally what behavior type comes next, normalize to get conditional probabilities, and similarly tally overall frequencies to get marginals. The resulting $4 \times 4$ matrix $\{P_{\mathcal{C}}(b' \mid b)\}_{b,b' \in \mathcal{B}}$ is the transfer graph — it captures the sequential composition patterns of reasoning behaviors.

What the transfer graph captures. The transfer graph encodes the temporal dynamics of reasoning. For example, a high $P(\text{R} \mid \text{D})$ means that after deep reasoning steps, the model often pauses to self-reflect. A high $P(\text{E} \mid \text{E})$ means exploration tends to persist across multiple steps (self-transition). The graph captures global properties like: does deep reasoning typically follow reflection? Does exploration usually resolve into deep reasoning or normal operation? These patterns constitute what the paper calls the "molecular structure" — the stable arrangement of bond types that characterizes effective Long CoT.

Why this formalism enables the paper's contributions. By reducing reasoning trajectories to behavior transition distributions, the paper can:

• Compare reasoning styles across models and tasks quantitatively (via Pearson correlation of flattened transfer matrices).
• Synthesize new trajectories without imitating surface text (by following the same transition distribution).
• Diagnose structural incompatibility when mixing training sources (by comparing transfer graph correlations).
• Quantify learning success (by measuring whether the student model's self-generated trajectories converge to the teacher's transfer distribution).

---

Behavior Annotation Pipeline

The automatic labeling of reasoning behaviors is the measurement instrument underlying all subsequent analyses. Appendix C.1–C.2 provides full details on the annotation prompt, decision rules, and validation.

Annotation model. The paper uses Qwen2.5-32B-Instruct as the behavior classifier. For each consecutive pair of steps $(u_{t-1}, u_t)$ in a trajectory, the model receives the PREVIOUS STEP and CURRENT STEP and classifies the CURRENT STEP into exactly one of the four behavior categories. The annotation is edge-level: it labels the transition from previous to current step.

Prompt design. The prompt (reproduced in full in Appendix C.2) defines each category with clear operational criteria:

• Normal Operation: "Straightforward, direct operations (e.g., arithmetic, factual recall, simple step-by-step logic) without introducing new logical nodes."
• Deep Reasoning: "Multi-step causal, deductive, or analogical thinking that extends the reasoning chain by introducing new logical nodes or hidden assumptions."
• Self-Reflection: "Commenting on its own thought process (e.g., confidence, strategy, uncertainty, mistakes, or reconsideration of earlier reasoning) and tracing back to previous logical nodes."
• Exploration: "Generating new possibilities, hypotheses, or questions, branching into alternative paths rather than following a single conclusion."

Decision rules for ambiguity. The prompt includes a priority-based tie-breaking rule: "If mixed, choose the dominant intent; break ties with this priority: self-reflection > exploration > deep reasoning > normal operation." This ensures that when a step both reasons deeply and reflects (e.g., "I realize that my earlier assumption was wrong because..."), it is classified as Self-Reflection rather than Deep Reasoning — consistent with the framework's emphasis on reflection as meta-cognitive oversight.

Validation against human annotation. On a 200-example subset, the automated annotation achieves macro-F1 > 0.85 against human labels. This establishes reliability sufficient for the distribution-level analyses in the paper — the classification is accurate enough that estimated transfer graphs are stable and comparable across models. The label set was developed by Chen et al. [5] in a prior survey of Long CoT behaviors and is reused here with the same operational definitions.

What the annotations capture. The behavior labels capture the functional role of each transition in the reasoning process. Deep Reasoning corresponds to extending the logical chain forward — building new deductions on prior steps. Self-Reflection corresponds to looking backward — evaluating, correcting, or reconsidering earlier commitments. Self-Exploration corresponds to looking sideways — opening alternative branches rather than committing to convergence. Normal Operation is the residual category for routine, non-structural moves.

Why automatic labeling is necessary. Manual annotation of full Long CoT trajectories (often hundreds of steps) across thousands of examples is impractical. The >0.85 macro-F1 provides sufficient reliability for estimating aggregate distributional properties even if individual edge labels have some error, because the downstream analyses aggregate over large numbers of labeled edges. This is a standard statistical argument: unbiased or low-bias label noise attenuates correlations but does not create spurious structure, so stable correlations between graphs from different models (r > 0.9) are strong evidence of genuine structural similarity.

---

Transfer Graph Estimation and Stability Analysis

The core empirical claim of Section 4.1 is that effective Long CoT reasoning models — despite different architectures, training recipes, and scale — produce behavior transition distributions that are highly correlated, converging to a stable "molecular structure." The procedure for establishing this is described in Sections 4.1 and 4.2 with full details in Appendix C.2.

Data source for analysis. Long CoT traces are generated by prompting three strong reasoning models — DeepSeek-R1-671B-0528 [8], OpenAI-OSS-120B [33], and QwQ-32B [32] — on queries drawn from OpenThoughts-3 [24], a mixed-domain corpus covering math, code, and scientific reasoning tasks typical of QwQ-style distillation. OpenThoughts-3 is used because it provides diverse multi-step reasoning problems that require Long CoT; it is a standard benchmark in this research area. Generation uses maximum token lengths of 16,384 or 32,768, temperature $T \in [0, 1]$, top-p = 0.95, and standard repetition penalties.

Construction of transfer graphs. For each model-task pair, the generated trajectories are segmented into steps, each transition is labeled with a behavior type, and transition frequencies are aggregated into a $4 \times 4$ transition matrix. Each cell $(i, j)$ is the empirical probability that a step with behavior $i$ is followed by a step with behavior $j$. The matrix is then visualized as a heatmap where darker colors indicate higher transition probabilities (Figure 5).

Stability analysis via subsampling. To assess whether the estimated transfer graph is stable (not dependent on a particular small sample), the paper computes transfer graphs for varying sample sizes $N \in \{500, 1000, 2000, 5000, 10000, 20000\}$ and measures the Pearson correlation between graphs from different sample sizes. The correlation stabilizes above $r > 0.95$ when $N > 2000$, meaning that beyond 2,000 labeled transitions, the estimated distribution converges — adding more data doesn't meaningfully change it. This convergence is a strong signal that the transfer graph captures a genuine structural property of the model's reasoning process, not a sampling artifact.

Cross-model correlation. The key result (Figure 5 and Section 4.1 text): transfer graphs from DeepSeek-R1, OpenAI-OSS-120B, and QwQ-32B exhibit Pearson correlations exceeding $r > 0.9$ with $p < 0.001$. Despite these models having completely different architectures, training procedures, and scale (671B vs. 120B vs. 32B parameters), their behavior transition distributions are nearly identical. This convergence is the paper's central empirical justification for the molecular structure hypothesis — the stable distribution of reasoning behavior transitions is a universal property of effective Long CoT reasoning, not an artifact of any particular model's training.

Why this matters for the subsequent analyses. The cross-model stability of transfer graphs enables two critical moves:

• Validation of the molecular analogy: If different reasoning models all converge to the same behavior transition distribution, this distribution can be interpreted as a "low-energy" or "stable" configuration — analogous to a molecule's ground state — that emerges naturally from the demands of extended reasoning.
• Synthesis via transfer graph transfer: If the transfer graph (not the surface text or specific reasoning content) is what makes Long CoT effective, then Mole-Syn can transfer only this structural skeleton to guide synthesis, without needing access to teacher model reasoning traces. The transfer graph serves as a compressed representation of "how to do Long CoT" that is model-agnostic.

Comparison with non-reasoning sources. The paper states (Section 4.1) that "simple human simulation or ICL cannot emulate the global bond distribution." While explicit quantitative evidence is not provided for this claim in Section 4.1, it is indirectly supported by the distillation failure results (Figures 3–4) and the ICL demonstration selection experiment (Figure 9), which shows that ICL-generated traces only succeed when the demonstration's behavior distribution matches the teacher's. Instruction-tuned LLMs prompted to emulate Long CoT do not spontaneously produce the stable transition distribution that reasoning-specialized models do.

---

Structural Validation 1: SFT Learns Structure, Not Keywords

Section 4.2 addresses a crucial alternative hypothesis: maybe what gets learned during Long CoT supervised fine-tuning is just the surface lexical patterns (keywords like "wait," "however," "alternatively") rather than the underlying reasoning structure. The paper refutes this through a combination of sparse auto-encoder analysis and keyword manipulation experiments. Appendix C.5 provides full methodological details.

Sparse auto-encoder (SAE) analysis. The experiment uses a cross-coder sparse auto-encoder [37, 38] to compare hidden representations between two models:

• Base model: Llama-3.1-8B-Base, pre-trained but not instruction-tuned on Long CoT data.
• Think-SFT model: Llama-3.1-8B-Base fine-tuned on R1-distilled Long CoT data (the same kind of SFT that Figure 3 shows successfully imparts Long CoT capability).

The cross-coder SAE architecture works as follows (Appendix C.5.1):

• Input: For each token position, the concatenation of the hidden state from the base model and the hidden state from the Think-SFT model at aligned token positions.
• Encoder: A single linear layer mapping the concatenated hidden state to a high-dimensional latent space. Sparsity is induced via an $\ell_1$ penalty calibrated to achieve approximately 1-3% average activation rate per latent unit — meaning most latent units are inactive for most tokens, forcing the SAE to learn interpretable, specialized features.
• Decoder: A linear layer trained to reconstruct the original concatenated hidden state from the sparse latent code.

This architecture enables "model diffing" — identifying latent features that are differentially active between the base and SFT models. The paper specifically identifies features whose activation probability on the base model is more than $3\times$ that on the SFT model, or vice versa. Among these differentially activated features, they select those with the strongest enrichment on "think tokens" (tokens belonging to explicit reasoning segments in the SFT corpus, as opposed to prompt context or final-answer tokens).

Key finding from SAE analysis (Figure 6a-b). The features most strongly activated specifically in the Think-SFT model (and largely inactive in the base model) are "predominantly driven by a few connective keywords, such as 'Maybe', 'But / so', and 'Alternatively'." This means that after SFT, the model has developed dedicated representational machinery for managing these discourse transitions — features specialized for hypothesis revision ("Maybe"), contrastive moves ("But/so"), and branch selection ("Alternatively"). The paper's interpretation is that these features encode the reasoning behaviors that these keywords signal — local hypothesis revision, contrastive reasoning, branch exploration — not the lexical tokens themselves. The SAE analysis reveals that the SFT process "carves out dedicated latents" for managing these behavioral transitions.

Keyword replacement experiment (Figure 6c). To directly test whether surface keywords or underlying behavioral structure matters for learning, the paper creates two modified versions of the QwQ distillation training corpus:

• Keyword-variant 1: Each occurrence of a target keyword (e.g., "wait," "maybe," "however," "therefore," "alternatively") is randomly replaced by one of four semantically similar alternatives (e.g., "wait" → "hold on," "maybe" → "perhaps," "however" → "on the other hand"). The full replacement tables for each behavior type's keywords are provided in Appendix C.5.1 boxes, covering deep reasoning markers (therefore, because, so, first, next, finally, note, important, actually, basically, etc.), self-reflection markers (wait, but, however, reflect, verify, double-check, I might be wrong, reconsider, alternatively, etc.), and self-exploration markers (maybe, now, let's, probably, seems, consider, assume, if, explore, etc.).
• Keyword-variant 2: A distinct set of replacements applied to the same keywords, ensuring that any observed effect is not specific to a particular substitution set.

Critically, the underlying reasoning trajectories (the sequence of logical steps and their content) are preserved identically — only the surface lexical markers are altered.

Training and evaluation. Identical LLMs are fine-tuned on the original QwQ-distilled data, Keyword-variant 1, and Keyword-variant 2, using the same hyperparameters. Long CoT reasoning performance is evaluated across data scales (1K, 2K, 5K, 10K, 20K samples, plus 20K samples with 5 training epochs).

Results (Figure 6c). At small data scales (1K–2K samples), models trained on keyword-replaced data underperform those trained on original data, suggesting that keywords provide a useful learning signal when data is scarce. However, as data scale increases to 20K samples, the performance gap disappears: "Models trained without keywords, or with arbitrary alternatives, achieve comparable reasoning performance given sufficient training, provided the underlying reasoning behaviors remain intact." The 20K-5epoch condition further closes any remaining gap. The paper's conclusion: "LLMs internalize reasoning structure rather than surface lexical cues."

Why this is a critical result for the paper's thesis. If models were learning only surface keyword patterns, then the entire molecular structure framework would be epiphenomenal — just a fancy description of lexical co-occurrence. This experiment eliminates that alternative explanation. The model learns something structural about how reasoning behaviors compose, and keywords merely serve as accelerants (providing initial signal) rather than as the substance of what is learned.

The open question this raises (explicitly stated in the paper). At the end of Section 4.2, the paper asks: "Do these bonds drive Long CoT structure learning, and if so, why do explicit human imitation or random ICL distillation of these markers often fail?" This motivates the next set of analyses — if surface markers aren't what's learned, and if having the right keywords isn't sufficient (as the ICL failure in Figure 3 shows), then what structural property distinguishes learnable from unlearnable reasoning trajectories?

---

Structural Validation 2: Geometric Embedding and "Logical Folding"

Section 4.3 tests a specific structural hypothesis: that effective Long CoT reasoning exhibits a folded, domain-structured topology in semantic space, analogous to protein folding, rather than a simple linear chain. The analysis uses geometric embedding and clustering in a shared semantic space. Full details are in Appendix C.3.

Step embedding construction (Appendix C.3.1). Each reasoning step $u_t$ is mapped to a dense vector representation:

• Encoder: Qwen3-8B [36], which is a general-purpose LLM (not specifically reasoning-trained) used solely as a representation encoder — the paper explicitly states this is for visualization, not as a claim about what the SFT model itself represents.
• Representation: For each step, average the penultimate-layer hidden states of all its constituent tokens, producing a single vector $\mathbf{h}_t \in \mathbb{R}^d$. This mean-pooled representation captures the semantic content of the step.
• Dimensionality reduction: t-SNE with cosine distance, 5,000 iterations, early exaggeration of 12.0, projecting to 3 dimensions for visualization. The parameters are chosen to preserve local neighborhood structure — points that are close in the original high-dimensional space remain close in the 3D projection.

Cluster definition. The paper defines a "logic cluster" $c(\mathbf{h}_t)$ by iteratively merging points within a distance $\alpha$ of existing clusters, where:

$\alpha = 0.02 \times (h_{\text{max}} - h_{\text{min}})$

with $h_{\text{max}}$ and $h_{\text{min}}$ being the maximum and minimum pairwise distances among all embedded points in the trajectory. The scaling factor 0.02 is an empirically chosen threshold that makes clustering "sensitive to the specific geometry of each reasoning trace" rather than using a fixed global radius. This adaptive clustering accounts for the fact that different reasoning trajectories may occupy different volumes in semantic space.

Deep Reasoning as covalent bonding (Figure 7a). The analysis of deep reasoning edges reveals two geometric properties:

• Local connectivity: Deep reasoning steps remain within a small semantic neighborhood. After a deep reasoning edge, 72.56% of steps remain within a group distance of less than 3 in the t-SNE space (the paper notes that "generally, group-group distance > 5.6" for transitions between different semantic regions). The cluster-level graph distance $g_t$ satisfies $d_t < g_t < 3$, where $d_t = \|\mathbf{h}_{t+1} - \mathbf{h}_t\|_2$.
• Cluster formation: Deep reasoning "mainly increases local connectivity, forming stable subdomains" — it bridges nearby logical nodes into coherent clusters without jumping between distant regions. The paper quantifies this as "72.56% of steps remained within a group distance of less than 3," meaning the vast majority of deep reasoning transitions operate within an existing logical neighborhood rather than opening new frontiers.

Self-Reflection as hydrogen bonding (Figure 7b). Self-reflection edges exhibit a geometrically distinct pattern:

• Reconnection to prior clusters: 81.72% of reflection steps reconnect to a previously formed cluster with high semantic similarity, rather than extending the chain linearly. The reconnection metric is $r_t = \min_{s < t} \|\mathbf{h}_{t+1} - \mathbf{h}_s\|_2$, and a step is classified as reconnecting if $r_t < \alpha$ (within the adaptive clustering threshold).
• Folding behavior: Reflection does not advance the reasoning forward; it folds the chain back onto earlier, semantically similar regions. This is the geometric analog of hydrogen bonds in proteins — long-range interactions that stabilize the three-dimensional structure by connecting distant parts of the chain. The quantitative claim is that over 4/5 of reflection steps explicitly return to previously established semantic territory rather than exploring new ground.

Self-Exploration as van der Waals forces (Figure 7c). Exploration edges show the opposite pattern:

• Large step-to-step distances: Exploration transitions exhibit "much larger step-to-step distances" compared to deep reasoning or reflection. The average trajectory length for exploration steps is 5.32 in the 3D t-SNE projection.
• Connecting distant clusters: These edges act as "loose links between otherwise separated clusters" — they bridge distant semantic regions with relatively weak, transient connections. This is the geometric analog of van der Waals forces in molecular structures: weak, non-directional attractive forces between distant parts of a molecule that enable structural flexibility and conformational exploration without committing to strong bonds.

Synthesis of geometric findings. The three bond types create a characteristic folded topology: deep reasoning builds dense local clusters (covalent bonding forming the primary structure), self-exploration creates weak bridges between distant clusters (van der Waals interactions enabling conformational sampling), and self-reflection folds the chain back to previously established clusters for verification and stabilization (hydrogen bonding driving tertiary structure formation). This is not a linear chain but a "folded, domain-structured topology" — a direct geometric analog to protein folding that gives the molecular analogy its empirical grounding.

Why this matters. The geometric analysis provides a spatial interpretation of the behavior transition distributions. The transfer graph (Figure 5) shows that certain behavior transitions are probabilistically favored — e.g., deep reasoning tends to follow deep reasoning (self-transition), self-reflection tends to follow deep reasoning (verification after extension). The geometric analysis shows why these transitions are favored in terms of semantic proximity: it's easier (lower "energy" in the attention-based sense of Section 4.4) to continue deep reasoning within the same local cluster than to jump to a distant cluster for exploration, while reflection provides a mechanism to deliberately traverse back to earlier clusters when verification is needed. Together, Sections 4.1-4.3 establish that the molecular structure is both statistically stable (across models) and geometrically interpretable (in semantic space).

---

Structural Validation 3: Attention Energy and the Boltzmann Interpretation

Section 4.4 establishes a mathematical correspondence between attention weights in Transformers and the Boltzmann distribution from statistical mechanics, then uses this correspondence to compare the effective "energies" of different bond types. The full mathematical derivation is in Appendix C.1.2–C.1.5.

The attention-energy correspondence (Appendix C.1.2). In a standard Transformer layer with RoPE positional encoding [35], for a given attention head, let $\mathbf{q}_i, \mathbf{k}_j \in \mathbb{R}^{d_k}$ be the query and key vectors of the $i$-th and $j$-th tokens, respectively. The pre-softmax attention logit is:

$s_{ij} = \frac{\mathbf{q}_i^\top \mathbf{k}_j}{\sqrt{d_k}}$

The attention weight (probability of token $i$ attending to token $j$) is the softmax normalization:

$\alpha_{ij} = \frac{\exp(s_{ij})}{\sum_{\ell} \exp(s_{i\ell})}$

The paper defines the attention energy as the negative logit:

$E_{ij} \triangleq -s_{ij} = -\frac{\mathbf{q}_i^\top \mathbf{k}_j}{\sqrt{d_k}}$

With this definition, the attention weight becomes:

$\alpha_{ij} = \frac{\exp(-E_{ij})}{\sum_{\ell} \exp(-E_{i\ell})}$

This is exactly the Gibbs-Boltzmann distribution over targets $j$ with inverse temperature $\beta = 1$:

$P(\text{state}_j) = \frac{\exp(-E_j / k_B T)}{\sum_{\ell} \exp(-E_\ell / k_B T)}$

where $E_j$ is the energy of state $j$, $k_B$ is the Boltzmann constant, and $T$ is temperature. The correspondence is: lower attention energy $E_{ij}$ implies higher attention weight $\alpha_{ij}$ — the model preferentially attends to token pairs with lower effective energy.

The paper explicitly notes: "We do not assume any physical semantics for $E_{ij}$; it is simply a convenient reparameterization of the attention logits." This is a methodological disclaimer — the energy interpretation is a mathematical isomorphism, not a claim about physical energy in the model.

Why this reparameterization is useful. By mapping attention logits to "energies," the paper can:

• Compare the relative "strength" of different bond types in a common, interpretable unit (higher attention = lower energy = stronger bond).
• Draw direct analogies to chemical bond energies (covalent bonds are strongest, hydrogen bonds intermediate, van der Waals forces weakest).
• Use the energy formulation to prove a mathematical ordering theorem (Appendix C.1.3) about why deep reasoning bonds should have lower expected energy than self-reflection bonds, which should have lower expected energy than self-exploration bonds.

Bond-level energy computation (Appendix C.1.4). For each behavior-labeled edge $(u \rightarrow v)$, the bond-level energy is computed by aggregating token-level attention weights between the source and target steps. The procedure:

• For each target token in step $v$ (typically the final token(s) of the step), extract its attention weights to the final token of step $u$, aggregating across attention heads using the head-wise mean.
• Convert the aggregated attention logit to an energy value via $E = -s$.
• This yields one energy sample per bond instance. Aggregating across all bonds of a given type yields the empirical energy distributions $E_D$, $E_R$, $E_E$ for deep reasoning, self-reflection, and self-exploration respectively.

The attention-energy ordering theorem (Appendix C.1.3). The paper proves that under RoPE positional encoding and two mild assumptions, the expected bond energies should satisfy:

$\bar{E}_D < \bar{E}_R < \bar{E}_E$

The assumptions are:

• A1 (Isotropic, distance-decaying cross-covariance): There exists a strictly decreasing function $\rho(d) \geq 0$ such that $\mathbb{E}[\mathbf{u}_i \mathbf{v}_j^\top] = \rho(d)\mathbf{I}$ for tokens with relative distance $d = |i - j|$. This formalizes the intuition that tokens farther apart in the sequence have weaker expected alignment — they're semantically less related on average.
• A2 (Positive average alignment of rotation): The trace of the RoPE rotation matrix $\mu(d) = \text{tr}(\mathbf{R}(d)) / \sqrt{d_k}$ is non-increasing in $d$ and bounded below by $\mu > 0$ for the relevant distances. This ensures that positional encoding doesn't arbitrarily amplify long-range attention.

The proof (Appendix C.1.3) shows that under these assumptions, the expected attention logit $\mathbb{E}[s_{i,i-d}] = \rho(d)\mu(d)$ is strictly decreasing in distance $d$. Since deep reasoning edges connect adjacent steps (distance $d=1$), self-reflection connects moderately separated steps (distance $d_R$), and self-exploration connects maximally separated steps (distance $d_E$), with $1 < d_R < d_E$, it follows that $\mathbb{E}[s_{i,i-1}] > \mathbb{E}[s_{i,i-d_R}] > \mathbb{E}[s_{i,i-d_E}]$ and thus $\bar{E}_D < \bar{E}_R < \bar{E}_E$ after taking negatives.

What this theorem establishes. The ordering of bond energies is not an arbitrary empirical finding — it follows structurally from the definition of the bond types as operating over different temporal distances, combined with the distance-decaying nature of attention under RoPE. Deep reasoning is "stronger" (lower energy/higher attention) because it connects adjacent steps. Self-reflection is intermediate because it connects steps separated by moderate distances. Self-exploration is "weakest" because it connects the most distant steps. The theorem provides a mathematical bridge between the behavioral definitions of the bonds and their neural implementation in attention patterns.

Empirical validation (Figure 8). The paper computes empirical bond energy distributions for models fine-tuned on QwQ-distilled data and OSS-distilled data. The results (Figure 8) show the predicted ordering: Deep Reasoning exhibits the largest $q \cdot k$ values (lowest energy $E$), Self-Reflection is intermediate, and Self-Exploration shows the smallest $q \cdot k$ values (highest energy). The exact $q \cdot k$ values differ between models (e.g., $qk = 61.20$ for Deep Reasoning on QwQ-distilled models vs. $qk = 32.29$ on OSS-distilled models), but the relative ordering is preserved: $qk_D > qk_R > qk_E$ and consequently $E_D < E_R < E_E$.

Interpretation of the energy ordering. Lower energy means the attention mechanism more strongly connects those tokens — deep reasoning bonds are "strong" because adjacent reasoning steps are tightly coupled via attention. Self-reflection bonds are "moderate" because looking back to earlier steps requires bridging larger positional gaps where attention decays. Self-exploration bonds are "weak" because connecting to distant, semantically divergent regions requires overcoming even larger attention decay. This energy hierarchy explains, at the mechanism level, why the three bond types play different functional roles: deep reasoning forms the strong backbone, self-reflection provides moderate-stability long-range links, and self-exploration creates weak, transient connections that can be easily broken or redirected.

Connection to path aggregation (Appendix C.1.4). The paper extends the energy formulation to multi-step reasoning paths. For a path $p = (b_1, \ldots, b_L)$ of bonds from a source step to a target step, the path energy is $E(p) = \sum_{\ell=1}^L E_{b_\ell}$. The effective energy over all paths is the soft-min (log-sum-exp):

$E^\star(s \rightarrow t) = -\log \sum_{p \in \mathcal{P}(s \rightarrow t)} \exp(-E(p))$

This formulation shows that paths with lower energy bonds are exponentially favored in the induced dependency distribution. If deep reasoning edges consistently have lower energy than exploration edges, then multi-hop dependencies that rely on chains of deep reasoning will dominate the effective aggregation from premises to conclusions, stabilizing long chain-of-thought structures.

Ergodic convergence argument (Appendix C.1.5). The paper further argues that the Long CoT learning process seeks a stable, low-energy reasoning configuration. Under the assumption that behavior transitions form an irreducible, aperiodic Markov chain with stationary distribution $\pi$, the time-averaged energy converges almost surely to:

$\bar{E}_T \xrightarrow{\text{a.s.}} \sum_{b \in \mathcal{B}} \pi_b \mu_b$

where $\mu_b = \mathbb{E}[E_t \mid s_t = b]$ is the mean energy conditional on behavior type $b$. This implies that reasoning trajectories with higher proportions of low-energy bonds (deep reasoning, reflection) will have lower average energy and are thus more "stable" — the attention mechanism inherently biases the model toward these configurations. This provides a mathematical interpretation of why effective Long CoT trajectories tend toward the specific bond distribution captured by the transfer graph (Figure 5): it is the low-energy equilibrium configuration of the attention dynamics.

---

Semantic Isomer Framework

Section 5 introduces the concept of Semantic Isomers — Long CoT trajectories that share the same task (solve the same problem) and visit similar conceptual ground (semantic regions) but differ in their behavior transition distributions. This framework enables the paper to study why some structural configurations work and others fail, even when they are superficially similar.

Formal definition. The paper defines a semantic isomer of a trajectory corpus $\mathcal{D}$ as any corpus $\mathcal{D}'$ whose behavior transition distribution $(P_{\mathcal{D}'}, \pi_{\mathcal{D}'})$ lies near $(P_{\mathcal{D}}, \pi_{\mathcal{D}})$ under a suitable divergence $D(\cdot \| \cdot)$ (Section 5, introductory paragraph). In practice, the paper operationalizes this through the behavior transition graph correlation — isomers are trajectories whose transfer graphs correlate at varying levels with the reference distribution.

What "same concepts, different bonds" means concretely. Consider two reasoning trajectories that both solve a modular arithmetic problem. Both trajectories might discuss the same mathematical concepts: prime factorization, modular inverses, Chinese Remainder Theorem. But one trajectory might structure its reasoning as: explore multiple approaches → deep reasoning on the most promising → reflect on edge cases → deep reasoning to conclusion. The other might structure it as: deep reasoning from start → exploration when stuck → more deep reasoning → normal operation to finish. These are semantic isomers: same conceptual atoms (primes, inverses, CRT), different molecular structures (behavior transition distributions).

Why this concept is central to the paper. The semantic isomer framework provides the mechanism for understanding:

• Why distillation quality varies: Different teacher models produce different semantic isomers of the same solution concept. Table 1 shows that R1-distilled and OSS-distilled data have distribution correlation $r \approx 0.9$ yet produce performance differences exceeding 10 percentage points. These are near-optimal semantic isomers — both individually effective, but different enough to matter substantially.
• Why mixing data sources fails: When two stable semantic isomers from different teachers are combined in training, the model cannot converge to either stable configuration. The result is "structural chaos" (Section 5.2, Figure 11): the behavior distribution fluctuates across samples without settling, and self-correlation drops below 0.8.
• Why ICL demonstration selection matters: Figure 9 shows that ICL-generated traces succeed only when the demonstration's behavior distribution matches the teacher's (correlation $\gtrsim 0.9$). This is the isomer-matching condition — the demonstration must be in the same structural basin as the target isomer.

Distillation of well-structured isomers (Table 1 and Appendix D.1). The paper evaluates distillation from three strong reasoning teachers (R1, OSS, QwQ) across eight student backbones (Llama-3.1-8B-Base/Instruct, Qwen-2.5-7B-Base/Instruct, Qwen-2.5-32B-Base/Instruct, Llama-3.1-70B-Base/Instruct) on six benchmarks, using 20K training samples each (Appendix B, Table 5). The key finding for the isomer framework: each teacher produces an effective but structurally distinct isomer. All three teachers achieve strong performance across student models, but the rankings differ — OSS distillation generally performs best for smaller models (Table 5), while QwQ excels for larger models. This suggests that the "optimal" isomer depends on the student architecture, not just the problem domain.

The fragility of semantic isomers. The structural correlation between R1 and OSS transfer graphs is $r \approx 0.95$ — very high by conventional statistical standards — yet "for some models performance with R1-based chains drops by more than 10%" compared to OSS-based chains (Table 1). This is the paper's demonstration that statistical similarity of behavior distributions does not guarantee functional compatibility. Small structural differences (what behaviors follow what, in what proportions) propagate into large performance differences, analogous to how small changes in protein folding can dramatically affect function even when the amino acid sequence is nearly identical.

ICL isomer simulation (Figure 9, Appendix D.2). The paper tests whether ICL demonstration selection can simulate an effective semantic isomer. Using Qwen2.5-32B-Instruct as the generator, demonstrations are selected from a pool of QwQ-32B-generated Long CoT solutions based on the Pearson correlation between the demonstration's behavior distribution and the teacher's target distribution. Three selection strategies:

• Random: Uniform sampling from the pool (correlation varies stochastically).
• Aligned: Select demonstration with correlation $r \gtrsim 0.9$ to the teacher distribution.
• Mismatched: Select demonstration with correlation $r < 0.8$, corresponding to structurally incompatible reasoning paths.

The result (Figure 9): "Substantial performance gains emerge only when demonstrations are constructed to match a specific target distribution." Random demonstrations and mismatched demonstrations produce negligible improvement, while aligned demonstrations (isomer-matched) produce significant gains. This directly explains the ICL-distill failure in Figure 3 — in that experiment, demonstrations were selected randomly, meaning they sampled from the wrong structural basins most of the time.

---

Information Flow Analysis: Why Effective Isomers Work (Section 5.1.1, Appendix D.3)

Section 5.1.1 addresses a deeper question: what property of the behavior transition distribution makes some semantic isomers effective and others ineffective? The answer involves an information-theoretic analysis of reasoning dynamics, comparing human reasoning traces with R1-generated traces.

Phase space representation (Appendix D.3.1). Each reasoning step $s_t$ is mapped to a semantic probability distribution $\mathbf{p}_t$ using Llama-3.1-8B-Instruct as a semantic probability encoder. The encoder assigns a probability distribution over a vocabulary or concept space to each step, capturing what the model "knows" or "believes" at that point. From this, two quantities are derived:

• Cumulative entropy $I_t$: the total entropy (uncertainty) accumulated up to step $t$.
• Instantaneous entropy change $\Delta I_t = I_t - I_{t-1}$: how much the uncertainty changed at step $t$ specifically.

Plotting $(I_t, \Delta I_t)$ across steps yields a trajectory in a 2D information phase space, where the x-axis is cumulative uncertainty and the y-axis is the rate of uncertainty change. The slope between consecutive points:

$m_t = \frac{\Delta I_t - \Delta I_{t-1}}{I_t - I_{t-1}}$

characterizes the reasoning dynamics: positive slopes indicate accelerating entropy (diverging, exploring), near-zero slopes indicate stable entropy (converging, validating), negative slopes indicate decelerating entropy (rapid convergence).

Human vs. R1 reasoning dynamics (Figure 10). The paper compares human reasoning traces (from Du et al. [7]) with R1-generated traces on multi-step logical deduction tasks. The key finding:

• Humans: "Nearly uniform forward information gains" across steps. In 81.3% of cases, entropy changes are less than 0.1, corresponding to "a near-zero slope in phase space." Human reasoning progresses through steady, incremental information accumulation without dramatic shifts in uncertainty.
• R1 models: "Accelerating informativeness" — progressing "from low entropy to rapid convergence." In 76.1% of cases, absolute entropy changes exceed 0.1, and the trajectory shows large slopes $m_t > 0.6$ during exploration phases, followed by near-zero slopes during convergence phases.

Metacognitive oscillation (Section 5.1.1, Appendix D.3.2). The paper identifies the R1 pattern as metacognitive oscillation: "alternation between high-entropy divergent exploration (slope > 0.6, $\Delta\text{entropy} > 0.05$) and stable convergent validation." This oscillation is the dynamic signature of the bond structure: self-exploration bonds increase entropy (divergent phase), deep reasoning bonds decrease it (convergent phase), and self-reflection bonds provide the transitions between these phases by evaluating whether convergence is on track.

Why human traces fail for distillation. This analysis provides a mechanistic explanation for Figure 4's finding that human-annotated traces fail to teach Long CoT: "Human reasoning is additionally constrained by semantic coherence and social feedback," resulting in uniform entropy profiles that lack the oscillatory dynamics of R1 reasoning. When a student model is fine-tuned on human traces, it learns the uniform information flow pattern — steady, incremental deduction — but does not learn the oscillation between exploration and convergence that characterizes effective Long CoT. The molecular structure (bond distribution) that emerges from this training lacks the characteristic exploration-convergence alternation.

Why effective isomers produce the right dynamics. Effective semantic isomers (like those from R1, OSS, and QwQ distillation) exhibit the metacognitive oscillation pattern because their behavior transition distributions allocate appropriate probability mass to cycles of exploration → deep reasoning → reflection → convergence. Ineffective isomers (like those from random ICL or human traces) either lack exploration entirely (uniform) or lack convergence (excessive exploration without resolution). The paper's formulation (Section 5.1.1): "Effective reasoning bonds cause metacognitive oscillation and alignment" — they create the right dynamic balance between divergent and convergent phases.

Quantitative characterization of effective isomers. While the paper does not provide a closed-form criterion for an effective isomer, it characterizes them implicitly through three properties:

1. Behavior transition distribution closely matches a strong reasoning teacher (correlation $\gtrsim 0.9$, Figure 9).
2. Information dynamics exhibit metacognitive oscillation — alternating phases of entropy increase (exploration) and entropy decrease (convergence) — rather than uniform progression (humans) or monotonic divergence (random/ICL-generated traces).
3. Geometric structure exhibits the folded topology (Section 4.3) — dense local clusters formed by deep reasoning, long-range reconnections formed by self-reflection, and weak inter-cluster bridges formed by self-exploration.

---

Conflict Learning Between Two Stable Isomers (Section 5.2, Appendix D.4)

Section 5.2 provides the paper's most striking experimental demonstration: mixing two individually effective semantic isomers from different teacher models destabilizes learning, producing a model that performs worse than either source alone. This experiment directly tests the hypothesis that structural compatibility — not just statistical similarity — governs whether reasoning frameworks can coexist.

Experimental design (Appendix D.4). The experiment uses two strong reasoning teachers — OpenAI-OSS-120B (OSS) and DeepSeek-R1-671B-0528 (R1) — to generate Long CoT traces on the same 20K training questions from OpenThoughts-3. Both sets of traces are highly effective when used alone for distillation (Table 1). Their transfer graphs are highly correlated: Pearson $r \approx 0.9$ between OSS and R1 distributions.

Five training configurations are compared (Section 5.2, Appendix D.4):

• OSS-Distill-Data: 20K samples from OSS only (single isomer, baseline).
• R1-Distill-Data: 20K samples from R1 only (single isomer, baseline).
• R1-then-OSS: Sequential training — first 10K from R1, then 10K from OSS.
• OSS-then-R1: Sequential training — first 10K from OSS, then 10K from R1.
• R1-mix-OSS: Randomly interleaved — 10K from OSS and 10K from R1, shuffled together.

All configurations use the same total data (20K samples) and identical training hyperparameters.

Structural chaos measurement (Figure 11d). The paper measures the self-consistency of the jointly trained model's behavior distribution. For a model trained on OSS-only or R1-only, the behavior transition distribution (computed from the model's own generated trajectories) is stable — self-correlation across different samples is high. For the jointly trained model, "co-activation prevents the model from converging to a single stable behavioral mode: it produces molecular bond distributions that fluctuate across samples and deviate from those characteristic of either OSS or R1." The self-correlation of the jointly activated model "does not exceed 0.8."

Performance degradation (Figure 11e). The performance consequences are severe:

All three mixing strategies degrade performance below either single-teacher baseline. The interleaved mixture (R1-mix-OSS) performs worst, suggesting that simultaneous exposure to two incompatible isomers is more destabilizing than sequential exposure (where the model can partially commit to one isomer before encountering the other).

Why this happens — the structural incompatibility hypothesis. The paper's interpretation is that OSS and R1 produce different stable isomers — near-optimal but structurally distinct configurations of the behavior transition distribution. When training data contains both, the model receives contradictory signals about which transitions should follow which. For example, after a deep reasoning step, OSS might predominantly transition to further deep reasoning (extending the chain), while R1 might more frequently transition to self-reflection (verifying the chain). The model cannot simultaneously satisfy both patterns — it cannot have both a high $P(\text{D} \mid \text{D})$ and a lower $P(\text{D} \mid \text{D})$ (coupled with higher $P(\text{R} \mid \text{D})$). The result is a model whose behavior distribution oscillates between basins, never settling into either stable configuration.

The significance of the correlation being $\approx 0.9$. A Pearson correlation of 0.9 between two distributions is typically considered very high — strong evidence of similarity. The fact that distributions this similar are structurally incompatible is a non-obvious finding. It implies that simple statistical metrics (correlation, KL divergence) are insufficient to predict compatibility — what matters is whether the two distributions can be simultaneously realized as the stationary distribution of a single model's reasoning dynamics. The paper doesn't fully formalize this compatibility condition, but the experiment demonstrates its practical importance.

Connection to isomer fragility. The conflict learning experiment reinforces the isomer fragility finding from Table 1: "slight differences can significantly affect the results." Even within the same structural basin (the set of isomers with high correlation to a reference distribution), different isomers can be mutually incompatible — they represent local optima in the space of behavior transition distributions that cannot be combined without losing the structural stability that makes each individually effective.

Practical implication. This experiment provides a principled explanation for a common practitioner observation: combining Long CoT data from multiple sources often produces worse results than using a single source, even when each source is individually high-quality. The mechanism is structural incompatibility of semantic isomers, not data quality issues. The practical recommendation is to treat each reasoning teacher as producing a distinct structural isomer and to avoid mixing them without explicit structural alignment.

---

Mole-Syn: Synthesizing Long CoT Structures from Instruction LLMs

Section 6 introduces Mole-Syn, the paper's practical synthesis method. The core idea is to transfer only the behavior transition graph from a strong reasoning teacher to guide an instruction-tuned LLM's generation, rather than distilling the teacher's surface reasoning traces. Full details are in Appendix E.

Problem setting and motivation. The paper has established that (1) only strong reasoning LLMs produce effective Long CoT training data (Figures 3-4), (2) what makes this data effective is its behavior transition distribution (the molecular structure), not surface keywords (Figure 6), and (3) different strong reasoning teachers produce structurally distinct but individually effective isomers (Table 1). The practical question: can we synthesize effective Long CoT data from cheaper instruction-tuned LLMs by providing only the structural skeleton (the transfer graph), without access to the teacher's reasoning traces?

Mole-Syn algorithm (Section 6, Appendix E.1). The synthesis procedure is a controlled random walk in behavior space:

Step 1: Estimate the transfer graph. From a strong reasoning teacher (e.g., QwQ-32B, OpenAI-OSS-120B), annotate 20K distilled CoT rationales with behavior labels at each transition and compute the empirical $4 \times 4$ transition matrix $\hat{P}(b_{t+1} \mid b_t)$. This is the same transfer graph estimation procedure as in Section 4.1/Appendix C.2. The transfer graph captures the teacher's "molecular structure" — the relative frequencies with which each behavior type follows each other behavior type.

Step 2: Initialize the synthesis state. The synthesis process begins in the Self-Exploration state. This initialization is a design choice motivated by the observation that Long CoT trajectories typically begin with broad hypothesis generation and exploration of the problem space before converging to a specific solution path. Beginning in exploration encourages the instruction-tuned LLM to consider multiple approaches rather than prematurely committing to one.

Step 3: Iterative behavior sampling and generation. For each step $t$:

• Given the current behavior state $b_t$, sample the next behavior $b_{t+1}$ from $\hat{P}(b_{t+1} \mid b_t)$. This is a categorical draw from the teacher's estimated transition distribution. For example, if the current state is Deep Reasoning and the teacher's graph shows $P(\text{R} \mid \text{D}) = 0.25$, $P(\text{D} \mid \text{D}) = 0.40$, $P(\text{E} \mid \text{D}) = 0.20$, $P(\text{N} \mid \text{D}) = 0.15$, then the next behavior is sampled from this categorical distribution.
• Prompt the instruction-tuned LLM with a behavior-specific prompt (detailed in Appendix E.1 boxes) that instructs the model to produce output in the sampled behavior mode while continuing from the previously generated reasoning.
• The model generates the next step of reasoning text, which is appended to the trajectory.
• Update $b_t \leftarrow b_{t+1}$ and repeat.

Step 4: Termination. The process continues until the model produces a final answer (typically indicated by \boxed{...} format) or a maximum step count is reached. The output is a complete Long CoT trajectory whose behavior transition distribution should approximately match the teacher's $\hat{P}$, but whose surface content is generated entirely by the instruction-tuned LLM from scratch.

Behavior-specific prompts (Appendix E.1). Each behavior type has a dedicated prompt that instructs the instruction-tuned LLM in how to produce that type of reasoning. The prompts share a common structure:

• System instruction: "Assume that you are a helpful assistant."
• Input: The original question and all previously generated reasoning steps.
• Behavior definition block: All four behavior types are defined (same definitions as the annotation prompt), establishing shared understanding of the target behavior space.
• Behavior-specific instruction: E.g., for Self-Reflection: "You should conduct self-reflection behavior now. Please reflect on the response and provide a self-reflection." For Self-Exploration: "You should conduct exploration behavior now. Please explore a novel reasoning path in the response." For Deep Reasoning: "You should conduct deep reasoning behavior now. Please further deepen the reasoning on the response." For Normal Operation: "You should conduct normal operation behavior now. Please conduct normal operation on the response."
• Escape clause: "If you can directly get the answer, please output the concise answer with \boxed{}." This prevents infinite generation when the model has reached a solution.

Why this works — decoupling structure from surface form. The key insight is that the instruction-tuned LLM doesn't need to know how to produce Long CoT reasoning autonomously (it can't — the ICL-distill results in Figure 3 show that instruction-tuned LLMs fail to sustain Long CoT when left to their own devices). It only needs to follow a local instruction ("do deep reasoning now," "do self-reflection now") given the accumulated context. The transition graph provides global coherence — when to explore, when to reason deeply, when to reflect — while the instruction-tuned LLM provides local generation capability. This is a division of labor: the transfer graph handles structure, the instruction LLM handles content.

Synthesis backbone quality matters (Appendix E, Table 7). The paper tests Mole-Syn using different instruction-tuned LLMs as the generator backbone, each guided by the same target transfer graph (from QwQ or OSS). Results show a hierarchy:

• Llama-3.1-8B-Instruct as backbone: Produces the weakest synthetic data (13.95% average accuracy when trained on Llama-8B-synthesized data, vs. 25.32% for the base instruction model).
• Llama-3.1-70B-Instruct as backbone: Produces effective synthetic data (31.97% average), competitive with direct QwQ distillation for many benchmarks.
• Qwen-7B as backbone: Similar effectiveness to Llama-70B (31.82% average).
• Qwen-32B as backbone: Best overall synthetic data (35.73% average), approaching direct distillation performance.

The hierarchy follows the model's intrinsic reasoning capability: stronger base models produce higher-quality synthetic Long CoT traces when guided by the same transfer graph. For deep reasoning-heavy tasks (AIME), Qwen-32B's intrinsic depth provides an advantage over both Qwen-7B and Llama-70B, consistent with the finding that deep reasoning performance depends on the model's capacity for extended logical deduction.

Supervised fine-tuning results with Mole-Syn data (Table 2). Training on 20K Mole-Syn-synthesized data provides:

• For base models (Llama-3.1-8B-Base): Mole-Syn data achieves 22.89% average (OSS guide) and 22.44% (QwQ guide), substantially above the 18.58% from Qwen-Distill-Data (ICL-based), but below the 33.69% from direct OSS distillation. This represents ~67% of the distillation gain at zero teacher-trace cost.
• For instruction-tuned models (Llama-3.1-8B-Instruct): Mole-Syn data achieves 32.40% (OSS guide) and 32.29% (QwQ guide), compared to 39.27% for direct OSS distillation. The gap between synthetic and distilled data narrows for stronger base models — the instruction-tuned model is better at executing the behavior-specific prompts and thus produces higher-quality synthetic traces.

Mole-Syn and reinforcement learning (Figure 12, Appendix E.2). The paper shows that Mole-Syn-initialized models provide superior starting points for reinforcement learning (RL) with the DAPO framework [40]. Using Llama-3.1-8B-Instruct as the base:

• QwQ-Distill-Data initialization: SFT on 20K QwQ-distilled traces, then RL. Achieves 39.72% average after RL (up from 35.73% pre-RL).
• QwQ-Mole-Syn initialization (20K): SFT on 20K Mole-Syn-synthesized data using QwQ transfer graph, then RL. Achieves 38.44% average after RL (up from 32.29% pre-RL). The RL improvement is larger (+6.15 percentage points vs. +3.99 for distillation initialization).
• QwQ-Mole-Syn initialization (35K): SFT on 35K Mole-Syn-synthesized data, then RL. Achieves 39.51% average after RL, essentially matching the distillation-initialized RL performance (39.72%).

The key finding (Figure 12a): Mole-Syn-initialized models show "steadier fine-tuning gains" — the RL reward curve is more stable and continues improving over 1,000 steps without plateauing as early as distillation-initialized models (Figure 12b-d). The interpretation: "Synthesized Long CoT structures provide a robust foundation for continual learning in dynamic environments" — the structural regularity of Mole-Syn data (controlled by the transfer graph rather than noisy teacher outputs) may provide a better initialization for RL by avoiding spurious patterns that the teacher produces but that don't generalize.

RL hyperparameters (Appendix E.2). All RL runs use DAPO with: learning rate $1 \times 10^{-5}$, batch size 16, sampling size 16 per prompt, maximum sequence length 16,384 tokens, clipping parameters clip-low = 0.2 and clip-high = 0.68, training for 1,000 steps. Training data: MATH [26] and AIME 1989-2023 [41].

Why Mole-Syn matters. This component represents the paper's transition from analysis to application. The molecular structure hypothesis and semantic isomer analysis explain why certain training data works. Mole-Syn operationalizes this understanding: by transferring only the structural skeleton (the transfer graph), one can synthesize effective Long CoT training data from models that cannot autonomously produce it. This decoupling of structural transfer from surface imitation is the paper's key practical contribution — it enables democratized access to Long CoT capabilities without requiring distillation access to proprietary reasoning models.

---

Bond Shaping Function Analysis

Section 7 analyzes how each of the three bond types geometrically reshapes the semantic space during reasoning, using minimum enclosing ball (MEB) volume as the metric. Full details are in Appendix F.

Experimental setup (Appendix F). For each bond type analysis, the paper constructs two model variants by manipulating the transfer probabilities during Mole-Syn synthesis:

• Baseline: Standard short CoT prompting or standard Mole-Syn with default transfer probabilities.
• Bond-enhanced: Mole-Syn synthesis with the target bond's self-transition probability increased to >50% (e.g., for deep reasoning analysis, $P(\text{D} \mid \text{D})$ is increased such that >50% of transitions from deep reasoning stay in deep reasoning). All other probabilities are scaled proportionally.

For each configuration, 100 reasoning trajectories are sampled from OlymBench problems. Step-level representations are extracted from the penultimate Transformer layer via mean pooling of token embeddings. t-SNE reduces these to 3 dimensions for visualization (consistent with Section 4.3's embedding protocol).

Minimum enclosing ball (MEB) computation (Appendix F.1). For a set of step representations $\mathcal{S} = \{\tilde{\mathbf{h}}_1, \ldots, \tilde{\mathbf{h}}_{TN}\}$ aggregating all steps from $N$ trajectories, the MEB is the smallest sphere (in t-SNE 3D space) containing all points. The volume is:

$V = C_d \cdot r^d$

where $C_d$ is the unit-ball volume constant (the same for all comparisons, so it cancels in relative measures), $r$ is the radius, and $d = 3$. Relative volume change is reported as:

$\Delta_{\text{bond}} = \frac{V_{\text{bond}} - V_{\text{baseline}}}{V_{\text{baseline}}} \times 100\%$

Positive values indicate expansion of the semantic space; negative values indicate contraction (densification).

Deep Reasoning: Densifying the primary structure (Figure 13a). Comparing Deep Reasoning-enhanced vs. baseline:

• Result: The MEB volume decreases by approximately 22% (from $V_{\text{avg}} = 30.12$ to $V_{\text{avg}} = 23.47$). The paper interprets this as deep reasoning "densifying the core logical structure" — it contracts the volume of the semantic space occupied by the reasoning, pulling steps closer together.
• Functional interpretation: Deep reasoning forms the logical backbone ("Primary Structure") by synthesizing a coherent chain of deductions. This stage "builds the answer's skeleton, but it does not yet ensure global stability or correctness." The densification reflects convergence toward a solution within a narrower conceptual region — the model is honing in on the specific chain of implications needed, rather than exploring broadly.
• Analogy to covalent bonding: Just as covalent bonds create strong, directional, short-range connections that define a molecule's primary chain, deep reasoning creates strong (low-energy, Section 4.4) local connections that reduce the semantic spread of the reasoning.

Self-Reflection: Stabilizing and folding (Figure 13b). Comparing self-reflection steps before and after the reflection edge:

• Result: The MEB volume decreases from 35.20 to 31.20 — approximately an 11.4% contraction induced specifically by the reflection step. Additionally, the paper notes that "intra-cluster distances decrease substantially, while inter-cluster distances remain stable or increase slightly" (Appendix F.3), indicating that reflection "consolidates the hydrophobic core and suppresses inconsistent branches."
• Functional interpretation: Self-reflection "folds" the logical chain by cross-linking distant nodes to test consistency, rather than adding new deductive steps. The volume reduction reflects pruning of inconsistent or redundant reasoning branches — reflection identifies and eliminates logical paths that don't align with earlier commitments.
• Analogy to hydrogen bonding: Just as hydrogen bonds in proteins stabilize the folded tertiary structure by creating specific long-range interactions between distant parts of the chain, self-reflection creates corrective links between later verification steps and earlier premises, constraining the reasoning into a more compact, self-consistent configuration.

Self-Exploration: Expanding logical space (Figure 13c). Comparing exploration-enhanced vs. baseline:

• Result: The MEB volume increases from 23.95 to 29.22 — approximately 22% expansion. This is the opposite of deep reasoning's effect, consistent with exploration's functional role.
• Functional interpretation: Self-exploration "broadens the set of feasible solutions and also increases variability and may introduce less consistent branches." The expansion reflects the exploration of diverse conceptual territory — the model considers possibilities that are semantically distant from the current focus, increasing the volume of the reasoning's semantic footprint. This "improves coverage at the cost of reduced immediate stability."
• Analogy to van der Waals forces: Just as van der Waals forces enable weak, transient interactions between distant parts of a molecule, supporting conformational flexibility without strong commitment, exploration creates weak (high-energy, Section 4.4) bridges between distant semantic clusters, enabling the model to sample alternative reasoning approaches before converging.

Synthesis of shaping functions (Takeaway 5). The paper summarizes the three-stage process: "Deep Reasoning densifies the logical backbone, Self-Exploration expands the search space to avoid local minima, and Self-Reflection converges toward a stable, optimized solution state in semantic space." This maps directly to the protein folding analogy: covalent bonding forms the primary structure (sequence of amino acids), van der Waals interactions enable conformational sampling (exploring the folding landscape), and hydrogen bonding stabilizes the native folded state (the low-energy configuration). The three bond types play complementary, sequential roles — expansion, densification, stabilization — that together constitute the "folding funnel" toward a solution.

Relationship to reinforcement learning potential (Figure 16, Appendix G). The paper also analyzes how varying the proportion of each bond type affects performance. Key findings:

• For complex queries (AIME), higher deep reasoning proportions improve performance up to a point, after which excessive deep reasoning without exploration causes diminishing returns (the model gets stuck in locally coherent but globally incorrect reasoning chains).
• Higher self-reflection proportions improve performance on hard problems but degrade performance on easy problems due to "overthinking" — excessive verification of already-correct reasoning.
• Excessive self-exploration on complex tasks "often impedes convergence" — 62.7% of AIME cases exhibit extended reasoning without reaching a conclusion when exploration is too heavily weighted.
• "Across all models, performance consistently peaks at a balanced distribution of behaviors" — the stable, task-invariant optimal configuration corresponds to the transfer graph that strong reasoning models naturally produce.

These findings reinforce the molecular structure hypothesis: the specific proportions and transition patterns matter — not just the presence of each behavior type but their balanced integration into a stable global structure. This provides additional justification for why Mole-Syn's transfer-graph-guided synthesis works: it reproduces the balanced distribution that strong reasoning models have converged to, rather than arbitrarily allocating behavior types.

---

Design Choices and Their Justifications (Cross-Cutting Summary)

The technical approach embodies several key design decisions that are motivated by specific goals:

Edge-centric over node-centric formulation: The paper chooses to define behaviors as properties of transitions (edges) rather than states (nodes) because the molecular analogy requires understanding how behaviors compose — the global distribution of bond types, not just their presence. This shift enables the transfer graph as the central analytical and synthesis tool.

Automatic behavior annotation with validated prompts: Rather than training a specialized classifier, the paper uses prompted Qwen2.5-32B-Instruct with detailed decision rules. This choice prioritizes reproducibility (the prompt is fully specified) and flexibility (the same prompt can be used for any model's reasoning traces) over maximum accuracy. The >0.85 macro-F1 validation threshold ensures sufficient reliability for distribution-level analyses.

Transfer graph as the unit of structural transfer: The paper identifies the behavior transition distribution (not individual trajectories, not keywords, not logits) as the transferable unit. This choice is justified by the cross-model stability finding (Figure 5: r > 0.9) and the keyword replacement experiment (Figure 6c: surface form is not what's learned). It enables Mole-Syn to transfer structure without content, decoupling the two aspects of reasoning.

Boltzmann energy reparameterization of attention: Rather than working directly with attention weights (bounded, non-additive), reparameterizing to energies $E_{ij} = -s_{ij}$ yields additive, unbounded quantities that map naturally to the chemical bond analogy and enable path-level aggregation. The paper is explicit that this is a mathematical convenience, not a physical claim.

MEB volume as geometric metric: The paper chooses minimum enclosing ball volume (not average pairwise distance, not cluster count) to quantify semantic space changes because it captures both spread and density in a single scalar, and is invariant to the number of points (unlike average distance, which can decrease with more points). The use of 3D t-SNE for visualization and volume computation is a pragmatic choice for interpretability, though the paper acknowledges that this is an approximation to the true high-dimensional geometry.

Mole-Syn random walk over direct prompt chaining: Rather than prompting the instruction LLM with a single "do Long CoT" instruction (which Figure 3 shows fails), Mole-Syn decomposes the problem into sequential behavior-specific local generation steps guided by a global transition distribution. This decomposition leverages the instruction LLM's strength (following specific local instructions) while compensating for its weakness (maintaining global coherence over long horizons) with the teacher-derived transfer graph.

Initialization in self-exploration: Beginning Mole-Syn generation in the exploration state is motivated by the observation that effective Long CoT trajectories typically begin with broad consideration of the problem space before narrowing. This initialization ensures the synthetic trajectory starts with sufficient breadth to avoid premature convergence to suboptimal solution paths.

4. Key Insights and Innovations

Innovation 1: Reframing Long CoT as a Molecular Bond Structure — Moving from Node-Centric to Edge-Centric Analysis

The paper's foundational conceptual move is replacing the dominant node-centric view of chain-of-thought reasoning — where each reasoning step is an independent state with optional labels — with an edge-centric, distributional view where what matters is how reasoning behaviors compose across transitions. Prior work on structured reasoning (Tree-of-Thoughts [20], Graph-of-Thoughts [21, 22, 23]) models reasoning as nodes in a graph, with edges representing local control flow. In those frameworks, a self-reflection step and a deep-reasoning step are both just node types — the graph captures which step follows which, but not the global statistical regularities of how behavior transitions occur across the entire trajectory.

This paper argues that this misses the essential organizing principle. By redefining behaviors (Deep-Reasoning, Self-Reflection, Self-Exploration) as edge types — properties of the transitions between steps, not the steps themselves — and then studying the global distribution of these edge types (the transfer graph $P(b' \mid b)$ and marginal $\pi(b)$), the paper reveals a stable structure that is invisible to node-level analysis. The finding that transfer graphs from DeepSeek-R1 (671B), OpenAI-OSS (120B), and QwQ (32B) correlate at $r > 0.9$ (Figure 5) — despite completely different architectures, scales, and training recipes — is the empirical anchor. This convergence implies that effective Long CoT reasoning has a universal structural signature that transcends implementation details.

The molecular analogy (covalent bonds for deep reasoning, hydrogen bonds for self-reflection, van der Waals forces for self-exploration) is not decorative. It provides a precise conceptual vocabulary for reasoning about how these edge types interact: covalent bonds are strong and local (high attention energy), hydrogen bonds are directional and long-range (moderate energy, specific pairing), van der Waals forces are weak and non-directional (low energy, enabling exploration without commitment). The attention-energy analysis (Section 4.4, Figure 8) provides a mechanistic grounding for this analogy by showing that the three bond types map to distinct energy levels in the Transformer's attention distribution — a correspondence formalized through the Boltzmann reparameterization rather than asserted metaphorically.

Why this is fundamental rather than incremental. This is not a new architecture or training method; it is a diagnostic reframing that changes what questions can be asked. The node-centric view could ask "does this trajectory contain self-reflection?" The edge-centric view asks "how are self-reflection transitions distributed relative to deep reasoning and exploration transitions, and does this distribution form a stable configuration?" The latter question leads to the semantic isomer framework, the conflict learning analysis, and Mole-Syn — none of which are naturally formulated in a node-centric paradigm. The shift from content to structure (from "what reasoning steps occur" to "how reasoning behaviors are arranged") is what enables the paper to explain why distillation from strong reasoning models works while surface imitation fails: it's the structural composition that gets learned, not the lexical patterns (proven by the keyword replacement experiment, Figure 6c).

---

Innovation 2: Semantic Isomers — A New Diagnostic Concept Explaining Why Statistically Similar Training Data Produces Radically Different Results

The concept of Semantic Isomers — reasoning trajectories that solve the same task and cover similar conceptual ground but differ in their behavior transition distributions — is the paper's most distinctive intellectual contribution. It provides a unified explanatory mechanism for a cluster of previously puzzling empirical phenomena: why mixing training data from multiple strong teachers degrades performance (Section 5.2), why ICL demonstration selection matters so much (Figure 9), and why small changes in distillation source can cause >10% accuracy swings despite nearly identical token-level statistics (Table 1).

Before this paper, the dominant assumption in the distillation literature was that training data quality was primarily about correctness and completeness of reasoning traces [14, 12]. If two teachers both produce correct, step-by-step solutions to the same problems, standard wisdom would predict that mixing their outputs should be neutral or beneficial — more diverse training data is generally helpful. The isomer framework explains why this intuition fails: correctness and completeness are properties of individual trajectories, but what gets learned during SFT is the structural composition — the behavior transition distribution that characterizes how the model organizes its reasoning over extended horizons. Two teachers can produce semantically identical content (same concepts, same derivations, same final answers) arranged in structurally incompatible ways, and forcing a model to learn both simultaneously creates "structural chaos" where the behavior distribution oscillates between basins without converging (Figure 11d, self-correlation drops below $r = 0.8$).

The non-obviousness of the isomer incompatibility finding. The conflict learning experiment (Figure 11) is particularly striking because the two source distributions are highly correlated ($r \approx 0.9$). By any conventional statistical metric, these are very similar distributions — yet mixing them produces performance worse than either alone. This implies that what matters for learnability is not distributional similarity in the statistical sense, but structural compatibility — whether two behavior transition distributions can be simultaneously realized as the stationary distribution of a single model's reasoning dynamics. The paper doesn't fully formalize this compatibility condition (that remains open), but the empirical demonstration is powerful: it establishes that there are phase boundaries in the space of behavior transition distributions, and crossing them — even by a small amount — destabilizes learning.

This concept has implications beyond the paper's immediate domain. Any setting where a model learns to generate structured outputs with long-range dependencies — code generation, multi-step planning, dialogue management — may exhibit similar isomer phenomena, where statistically similar training examples encode structurally incompatible generation strategies. The isomer framework provides vocabulary and diagnostic tools (transfer graph comparison, self-correlation measurement) for detecting these incompatibilities, which is a practical contribution to data curation.

The connection to human reasoning traces. The isomer concept also provides the cleanest explanation for why human-annotated Long CoT traces fail for distillation (Figure 4). Humans produce correct, step-by-step solutions covering the same concepts as R1 traces, but their behavior transition distribution is structurally different — characterized by uniform entropy reduction (Figure 10, left) rather than the metacognitive oscillation between exploration and convergence that LLMs exhibit (Figure 10, right). Human reasoning traces are a different semantic isomer — same conceptual atoms, different molecular structure — and that structural difference is what prevents them from transferring effectively. This reframes the "humans can't teach reasoning to LLMs" finding from Du et al. [7] as a specific case of isomer incompatibility rather than a fundamental limitation of human reasoning quality.

---

Innovation 3: Mole-Syn — Structural Transfer Without Content Transfer, and the Decoupling of Reasoning Architecture from Surface Form

Mole-Syn represents a paradigm shift in how to transfer reasoning capabilities: instead of distilling the teacher's outputs (surface text), transfer only the behavior transition graph (structural skeleton) and let an instruction-tuned LLM synthesize the content from scratch. This decoupling of structure from surface form is the paper's key practical innovation.

The standard approach in the reasoning distillation literature is output imitation: generate Long CoT traces from a strong teacher and fine-tune a student on next-token prediction over those traces [12, 13]. This requires access to the teacher's reasoning outputs, which is expensive (proprietary API costs) or impossible (when providers compress or hide thinking traces, as Section 8 documents). The alternative — prompting instruction-tuned LLMs to produce Long CoT autonomously — fails (Figure 3) because these models lack the structural knowledge of how to organize reasoning over hundreds of steps.

Mole-Syn splits the problem: the transfer graph (estimated once from a small set of teacher traces) provides global structural knowledge — the statistical regularities of which reasoning behaviors should follow which. The instruction-tuned LLM provides local generation capability — when told "now do deep reasoning" or "now self-reflect," it can produce coherent text in that mode, given the accumulated reasoning context. This division of labor is what makes the approach work: the instruction model doesn't need to know how to sustain Long CoT autonomously (which it can't); it only needs to follow behavior-specific local instructions, with the transfer graph handling global coherence.

Why this is conceptually significant, not just practically useful. Mole-Syn demonstrates that the "reasoning capability" that makes Long CoT effective is separable from the surface text of any particular teacher's reasoning traces. The transfer graph is a compressed representation — a 4×4 matrix of transition probabilities — that encodes the structural essence of effective Long CoT reasoning. The fact that this sparse structural signal is sufficient to guide synthesis of effective training data (Table 2: Mole-Syn data achieves ~67% of the distillation gain at zero teacher-trace cost) validates the paper's central claim: the molecular structure (behavior transition distribution) is what matters for learning, not the specific reasoning content or lexical patterns.

The RL stability finding as an emergent property. The finding that Mole-Syn-initialized models exhibit more stable and sustained RL improvement than distillation-initialized models (Figure 12) was not engineered into the method but emerged from it. The paper's interpretation — that synthetic data with controlled structural regularity avoids spurious teacher-specific patterns that don't generalize — suggests an additional benefit of structural-only transfer: it may produce cleaner training signals by removing teacher-specific idiosyncrasies while preserving the universal structural features (the stable transfer graph that multiple strong models converge to). This connects Mole-Syn to broader questions about data quality for continual learning and suggests that structural regularity, not just correctness, should be a design target for training data synthesis.

The democratization argument. By showing that effective Long CoT training data can be synthesized using only instruction-tuned LLMs (which are widely available open-source) and a transfer graph estimated from any accessible strong reasoning model, Mole-Syn reduces the barrier to entry for building Long CoT systems. Organizations without access to proprietary reasoning APIs can still produce effective training data. This is a direct practical response to the documentation in Section 8 of how private LLM providers protect their reasoning traces through summarization and compression — Mole-Syn provides an end-run around these protections by showing that the reasoning traces themselves are not necessary; only their structural skeleton is needed.

---

Innovation 4: Verifier Over-Optimization as a First-Class Phenomenon in Test-Time Scaling — Applied to Structural Rather Than Reward-Based Optimization

The paper identifies and characterizes a novel form of optimization pathology specific to Long CoT learning: structural over-optimization, where forcing the model toward a particular behavior distribution beyond its natural equilibrium degrades rather than improves performance. This is conceptually parallel to reward hacking in RLHF, but operates on the level of reasoning behavior composition rather than reward signals.

The evidence accumulates across multiple experiments. In the bond proportion analysis (Appendix G, Figure 16): increasing self-reflection probability improves hard-problem performance but degrades easy-problem performance through "overthinking" — excessive verification of already-correct reasoning. Increasing self-exploration probability beyond a threshold causes "extended reasoning without reaching a conclusion" on 62.7% of AIME cases. The optimal configuration is a balanced distribution — not the maximum of any single behavior type. This mirrors the U-shaped scaling curves in the RLHF reward hacking literature, where optimizing too aggressively against a proxy signal eventually produces degenerate outputs.

The conflict learning experiment (Section 5.2) demonstrates a structural analog: when two individually optimal structural isomers are combined, the result is not a compromise between them but a breakdown of structural stability — the behavior distribution fluctuates without converging to either basin. This suggests that the space of effective Long CoT configurations has multiple local optima (stable semantic isomers) separated by regions of structural instability. Optimization that crosses these boundaries — by mixing training data from incompatible sources — produces non-monotonic degradation rather than interpolation.

Why this insight changes how we should think about Long CoT training. Prior work on reasoning distillation treated training data as a homogeneous resource: more data is better, more diverse data is better, stronger teachers produce better data. The structural over-optimization findings show that none of these heuristics hold unconditionally. More data that mixes incompatible structural isomers is worse than less data from a single coherent isomer. More diverse data (in terms of teacher sources) can be worse than homogeneous data if the sources are structurally incompatible. A "stronger" teacher (in terms of benchmarks) may produce a structural isomer that is less compatible with the student architecture than a "weaker" teacher's isomer (as seen in Table 1, where OSS outperforms R1 for some student models despite both being highly capable).

This reframes the Long CoT data curation problem from one of quality filtering (keep correct traces, discard incorrect ones) to one of structural coherence maintenance (keep traces that share a compatible behavior transition distribution, discard structurally incompatible ones even if individually correct). This is a qualitatively different optimization target, and it suggests that the key bottleneck for Long CoT learning is not data quantity or correctness but structural consistency of the training distribution.

---

Innovation 5: Unified Explanation of Why Distillation from Different Sources Succeeds or Fails — Resolving Contradictory Findings in Prior Work

Before this paper, the literature on reasoning distillation contained a puzzle: why does distillation from strong reasoning LLMs work (DeepSeek-R1, OpenAI's models) while distillation from human traces [7] and ICL-prompted instruction models fails, even when all sources produce correct step-by-step solutions? The molecular structure framework provides a single, coherent explanation that encompasses all these findings.

The mechanism is: SFT learns the behavior transition distribution (the molecular structure), not surface reasoning content or correctness patterns (proven by the SAE and keyword replacement experiments, Figure 6). Strong reasoning LLMs have converged to a stable, universal behavior transition distribution (proven by cross-model transfer graph correlation > 0.9, Figure 5) characterized by metacognitive oscillation between exploration and convergence (proven by the information flow analysis, Figure 10). When a student model is fine-tuned on these traces, it learns this stable structural configuration, which enables effective Long CoT generation.

Human traces fail because they encode a different structural configuration — uniform entropy reduction without the exploration-convergence oscillation — despite covering the same conceptual ground and producing correct answers. This makes them a structurally incompatible semantic isomer. ICL-prompted instruction models fail because without careful demonstration selection (matching the target behavior distribution at $r \gtrsim 0.9$, Figure 9), they do not spontaneously produce the stable transition distribution; they produce structurally noisy traces whose behavior distribution fluctuates without converging to the stable configuration.

This unified explanation resolves the apparent contradiction in prior work between studies showing that reasoning distillation works [8, 14] and studies showing limitations of human-to-LLM reasoning transfer [7]. The contradiction arose because these studies were implicitly comparing different structural isomers without controlling for behavior transition distribution — the critical mediating variable that this paper identifies.

Why this is more than just a post-hoc rationalization. The paper doesn't just claim that structural differences explain past results — it makes testable predictions that it then validates. The ICL demonstration selection experiment (Figure 9) directly tests the prediction that matching the behavior distribution of the demonstration to the target teacher's distribution should rescue ICL-based distillation. The result confirms this: substantial gains emerge only in the aligned condition. The keyword replacement experiment (Figure 6c) tests the prediction that surface lexical patterns are not the transferable unit; the result confirms that models trained with replaced keywords but preserved behavior structure achieve comparable performance. These are not retrospective explanations of old data but prospective tests of the framework's predictions, which substantially strengthens the claim that the molecular structure is causally relevant, not just correlational.

The unified framework also provides practical guidance: to diagnose why a particular distillation pipeline is failing, measure the behavior transition distribution of the training data and compare it to the stable configuration (transfer graph from any strong reasoning model). If the correlation is low or the distribution is unstable (self-correlation < 0.8), the data is structurally inadequate regardless of per-sample correctness. To fix it, either filter for structurally compatible traces or use Mole-Syn to synthesize data with the correct structural properties. This transforms distillation from a black-box process into a diagnostically tractable one.

5. Experimental Analysis

Evaluation Methodology

Dataset. The primary training data for distillation and Mole-Syn experiments is drawn from OpenThoughts-3 [24], a mixed-domain corpus covering math, code, and scientific reasoning tasks, from which 20K–35K high-quality Long CoT queries are randomly sampled (Appendix A). Evaluation occurs across six challenging mathematical reasoning benchmarks: GSM8K [25] (grade-school math requiring multi-step calculations), MATH-500 [26] (high-school and early college-level problems across major math topics), AMC 2023 [27] (high-school competition problems in algebra, geometry, combinatorics), AIME 2024 [28] and AIME 2025 [29] (invitational-level problems with integer final answers), and OlympiadBench [30] (a comprehensive Olympiad-level benchmark). For the conflict learning and transfer graph analysis (Section 5.2, Figure 5), Long CoT traces from three strong reasoning teachers (DeepSeek-R1-671B-0528 [8], OpenAI-OSS-120B [33], QwQ-32B [32]) are generated on questions from OpenThoughts-3 at maximum token lengths of 16,384 or 32,768, temperature T ∈ [0, 1], top-p = 0.95. The information flow analysis (Figure 10) uses human reasoning traces from Du et al. [7] and R1-generated traces on multi-step logical deduction tasks. No explicit test/validation split is described for the 500-question subsets of individual benchmarks; the main text reports accuracy on full benchmark test sets.

Base model(s). All supervised fine-tuning experiments use two base families: Llama-3.1 [9] at 8B and 70B scales (both base and instruction-tuned variants), and Qwen-2.5 [31] at 7B and 32B scales (both base and instruction-tuned variants), spanning approximately 7B to 70B parameters. Llama-3.1-8B-Instruct is the primary student backbone for the SFT, RL, and keyword replacement experiments, while Llama-3.1-8B-Base is used for the sparse auto-encoder analysis comparing pre- and post-SFT representations. The choice of these models is motivated by their representativeness of instruction-tuned LLMs that are not specifically optimized for long chain-of-thought reasoning — they serve as "cold-start" baselines to test whether Long CoT capabilities can be imparted through various distillation and synthesis approaches. For the structural analysis modules (geometric embedding, attention energy), representations are extracted from intermediate models: Qwen3-8B [36] as a fixed encoder for step embeddings, and the fine-tuned Llama-3.1-8B-Instruct on QwQ-distilled data for attention patterns.

Metrics. The primary evaluation metric is accuracy, reported as Avg@1 for GSM8K, MATH-500, and OlympiadBench (single greedy or temperature-sampled generation per question), and Avg@16 for AMC 2023, AIME 2024, and AIME 2025 (averaged over 16 sampled generations per question, due to smaller test set sizes). For the main results tables, "Overall Accuracy" is the arithmetic mean across all six benchmarks. For structural analyses, the key metrics are: Pearson correlation coefficient between flattened transfer matrices (Figure 5, Section 5.2 — computed as $r = \sum_i (p_i - \bar{p})(q_i - \bar{q}) / \sqrt{\sum_i (p_i - \bar{p})^2 \sum_i (q_i - \bar{q})^2}$ where $p, q$ are flattened normalized frequency vectors), attention energy (Figure 8 — defined as $E_{ij} = -q_i^\top k_j / \sqrt{d_k}$, with bond-level energies aggregated by taking the mean across token pairs connecting source and target steps, Appendix C.1.2), minimum enclosing ball volume (Figure 13 — computed via Welzl's algorithm in 3D t-SNE space, relative change reported as $\Delta = (V_{\text{method}} - V_{\text{baseline}})/V_{\text{baseline}} \times 100\%$, Appendix F), macroscopic F1 for behavior annotation validation (>0.85 on a 200-example subset against human labels, Appendix C.2), and cluster-level graph distance for geometric folding analysis (Appendix C.3.2). For the RL experiments (Appendix E.2), the training metric is DAPO reward, and evaluation accuracy on MATH-500 is reported at RL training steps 0–1000. Answers are extracted from \boxed{...} format and matched using standard math-verify tools (Appendix A).

Baselines. The experiments compare against multiple baselines organized by experimental axis. For the distillation quality experiments (Section 2, Figure 3, Table 1): (1) Base model without Long CoT training — Llama-3.1-8B-Base, Llama-3.1-8B-Instruct, Qwen-2.5-7B-Base, Qwen-2.5-7B-Instruct, Qwen-2.5-32B-Base, Qwen-2.5-32B-Instruct, Llama-3.1-70B-Base, Llama-3.1-70B-Instruct, each evaluated in their pretrained or instruction-tuned state without additional Long CoT fine-tuning. (2) ICL-Distill — fine-tuning on Long CoT traces generated by Qwen2.5-32B-Instruct prompted with a randomly selected 1-shot R1 Long CoT example (Appendix B, Setting 2). (3) Human-Distill — fine-tuning on 50 human-written step-by-step solutions collected from Du et al. [7] plus 50 R1-generated traces (Section 2, Figure 4). (4) Single-teacher distillation — fine-tuning on 20K traces from DeepSeek-R1-671B-0528, QwQ-32B, or OpenAI-OSS-120B individually (Table 1, Appendix D.1). For the ICL demonstration selection experiments (Figure 9): (5) Random demonstration — a 1-shot QwQ-32B demonstration selected uniformly from a candidate pool. (6) Mismatched demonstration — a demonstration with behavior distribution correlation $r < 0.8$ to the target teacher. For the conflict learning experiments (Figure 11): (7) Single isomer baselines — OSS-only (20K) and R1-only (20K). For Mole-Syn (Table 2): (8) Qwen-Distill-Data — distillation from Qwen2.5-32B-Instruct (ICL-based, effectively a weak baseline for Mole-Syn's target). For the RL experiments (Table 8): (9) QwQ-Distill-Data + RL — RL fine-tuning starting from the QwQ-distilled SFT checkpoint.

Generation budget / compute accounting. The paper does not use a unified "compute budget" in FLOPs across experiments — rather, each experiment controls for data quantity (number of training examples, typically 20K) and training protocol (1 epoch, learning rate $2 \times 10^{-5}$, global batch size 128, maximum sequence length 16K or 32K tokens, selecting the better-performing setting). For inference, generation uses temperature = 0.6 for evaluation to reduce SFT–RL mismatch (Appendix A). For the transfer graph stability analysis (Figure 5), "budget" is measured in sample size — graphs are computed from N ∈ {500, 1000, 2000, 5000, 10000, 20000} trajectories, with stability assessed via Pearson correlation between graphs from different sample sizes. For the RL experiments (Figure 12, Table 8), compute is measured in training steps (fixed at 1000 steps) with batch size 16 and sampling size 16 per prompt.

Cross-validation / statistical protocol. For the transfer graph analysis (Section 4.1), five independent trials are run at each sample size, with stability assessed via Pearson correlation between graphs from different sample sizes. For the conflict learning experiment (Section 5.2), three mixing strategies (sequential R1-then-OSS, sequential OSS-then-R1, interleaved R1-mix-OSS) are compared to single-source baselines. For RL experiments, all runs use the same RL tasks, reward functions, and hyperparameters, so performance differences are attributed to the initialization checkpoint (Appendix E.2 explicitly states this design). Statistical significance is reported for the cross-model transfer graph correlation: "Pearson correlations exceeding 0.9 (p<0.001) for over 2,000 samples" (Section 4.1). For benchmark evaluations, no confidence intervals or standard errors are reported; accuracy is presented as point estimates per benchmark.

---

Main Quantitative Results

Distillation from Strong Reasoning LLMs Works; ICL and Human Traces Do Not

The headline finding from the preliminary studies (Section 2, Figure 3, and Appendix Table 5) is that only distillation from strong reasoning-specialized LLMs reliably imparts Long CoT reasoning capabilities to student models, while ICL-based distillation from instruction-tuned LLMs and fine-tuning on human-annotated reasoning traces both fail to produce meaningful gains.

Full results across eight student backbones (Appendix Table 5). Training on 20K OSS-distilled traces produces the strongest results across most model configurations. For Llama-3.1-8B-Base, OSS distillation achieves 33.69% average accuracy across six benchmarks (up from 2.70% for the untrained base model), with performance concentrated on simpler benchmarks: 75.89% on GSM8K, 54.20% on MATH-500, 37.34% on AMC2023, but only 4.38% on AIME2024 and 6.46% on AIME2025. For Llama-3.1-8B-Instruct (starting from 25.32% average), OSS distillation achieves 39.27% average, with notable improvements on MATH-500 (35.20% → 60.80%), AMC2023 (23.59% → 47.03%), and OlympiadBench (12.00% → 30.22%). For larger models, the gains are even more dramatic: Qwen-2.5-32B-Instruct improves from 52.76% to 73.05% (OSS distillation) or 74.16% (QwQ distillation), with AIME2024 reaching 64.17% (OSS) and AIME2025 reaching 53.54% (OSS).

ICL-Distill failure (Figure 3, Appendix Table 5). Qwen2.5-32B-Instruct prompted with a random 1-shot R1 demonstration produces traces that, when used for fine-tuning, yield substantially lower performance than direct distillation. For Llama-3.1-8B-Instruct fine-tuned on such ICL-generated data: accuracy reaches only approximately 27.84% average (from the Qwen-Distill row in Table 6), compared to 39.27% for OSS distillation — a gap of over 11 percentage points. The pattern is consistent across backbone models: for Llama-3.1-8B-Base, Qwen-Distill achieves 18.58% vs. 33.69% for OSS-Distill (Table 5). The ICL-generated traces cannot maintain coherence beyond ~6–8 steps (Section 2), limiting their utility for teaching extended reasoning.

Human-annotated traces are also inadequate (Figure 4). On Llama-3.1-8B-Instruct fine-tuned on 50 human-written step-by-step solutions plus 50 R1 traces, performance is substantially lower than on pure R1 distillation, as shown in Figure 4's bar chart (exact values are visually approximated — the paper does not provide a table for this specific comparison; GSM8K reaches roughly 60–65% for human distill vs. ~80% for R1 distill). The paper's interpretation: human solutions "aid local problem solving but may not reliably encode abstractions for long-horizon reasoning distributions" (Section 2, Takeaway 1).

Why the strong reasoning teacher matters — structural signal, not content quality. The distillation results are not simply about the correctness of individual traces; the keyword replacement experiment (Section 4.2, Figure 6c) will later show that models trained on keyword-shuffled QwQ-distilled data achieve comparable performance given sufficient data scale. Rather, the strong reasoning teachers provide a stable behavior transition distribution (the molecular structure) that teaches the model how to organize reasoning over long horizons. The ICL-generated traces and human traces, while containing correct content, do not encode this stable structural distribution.

---

Three Strong Reasoning Teachers Produce Highly Correlated Transfer Graphs

Section 4.1 (Figure 5) demonstrates that when Long CoT reasoning traces from DeepSeek-R1-671B-0528, OpenAI-OSS-120B, and QwQ-32B are annotated with behavior labels (N, D, R, E) at each transition and aggregated into $4 \times 4$ transfer matrices, the resulting graphs are near-identical. The Pearson correlation between any pair of these three transfer graphs exceeds 0.9 (p<0.001) when computed over >2,000 labeled transitions. The transfer graphs stabilize at correlations above 0.95 across different sampling sizes above this threshold, confirming that the distribution is a robust property of the model's reasoning process, not a sampling artifact.

The transfer graphs (visualized as heatmaps in Figure 5) reveal a consistent structural pattern across all three teachers:

• Deep Reasoning exhibits strong self-transition probability (the D→D cell is among the darkest), indicating that deep reasoning tends to persist across consecutive steps — the model extends the logical chain through multiple linked deductions rather than switching behaviors frequently.
• Self-Reflection most commonly follows Deep Reasoning (high R∣D probability), consistent with the functional role of verification after extending the logical chain.
• Self-Exploration shows moderate self-transition probability (sustained exploration across steps) and moderate probability of transitioning to Deep Reasoning (narrowing from broad search to focused deduction).
• Normal Operation serves as the catch-all residual, with transitions distributed across other behaviors.

The paper explicitly notes: "simple human simulation or ICL cannot emulate the global bond distribution" (Section 4.1) — while no quantitative transfer graph is provided for human or ICL-generated traces, this claim is supported implicitly by the ICL-Distill failure results (Figure 3) and the ICL demonstration selection experiment (Figure 9), which shows that instruction-tuned LLMs only produce structurally aligned traces when demonstrations are carefully selected to match the target distribution.

---

SFT Learns Reasoning Structure, Not Keywords — Evidence from Sparse Auto-Encoders and Keyword Replacement

Section 4.2 presents two complementary experiments demonstrating that what is acquired during Long CoT supervised fine-tuning is the structural composition of reasoning behaviors, not surface lexical markers.

Sparse auto-encoder analysis (Figure 6a-b). A cross-coder sparse auto-encoder is trained on concatenated hidden states from Llama-3.1-8B-Base (pretrained, no Long CoT training) and Think-SFT (Llama-3.1-8B-Base fine-tuned on R1-distilled data). Features that are preferentially activated in the Think-SFT model (activation probability >3× that in the base model) are predominantly "driven by a few connective keywords, such as 'Maybe', 'But / so', and 'Alternatively'" (Figure 6b). The paper interprets these features as encoding the discourse-control structures corresponding to hypothesis revision ("Maybe"), contrastive moves ("But/so"), and branch selection ("Alternatively") — that is, the reasoning behaviors themselves, not the lexical tokens. The features are "concentrated in a small set of discourse-control structures rather than being uniformly distributed across tokens" (Section 4.2).

Keyword replacement experiment (Figure 6c). To test whether surface keywords or underlying behavioral structure drives learning, the QwQ distillation training corpus is modified by replacing keywords associated with deep reasoning, self-reflection, and self-exploration with semantically similar alternatives (full replacement tables in Appendix C.5.1 boxes). Two keyword-variant datasets are created with different replacement sets. Identical LLMs are fine-tuned on original and keyword-variant data at varying scales (1K, 2K, 5K, 10K, 20K samples, plus 20K-5epoch). At small data scales (1K–2K), models trained on keyword-variant data underperform those trained on original data — suggesting keywords provide a useful learning signal when data is scarce. However, at 20K samples, the performance gap largely disappears, and the 20K-5epoch condition further equalizes performance. As the paper states: "Models trained without keywords, or with arbitrary alternatives, achieve comparable reasoning performance given sufficient training, provided the underlying reasoning behaviors remain intact." The key numbers from Figure 6c: at 20K samples, Original achieves roughly 35–37% accuracy, Keyword-variant 1 achieves roughly 33–36%, and Keyword-variant 2 achieves roughly 34–36% (exact values estimated from the bar chart). The gap narrows from 5–8 percentage points at 2K to ~1–2 percentage points at 20K, and essentially vanishes at 20K-5epoch.

---

Geometric Embedding Reveals a Folded, Domain-Structured Topology

Section 4.3 (Figure 7, Appendix C.3) analyzes the topology of Long CoT trajectories in 3D t-SNE semantic space using Qwen3-8B penultimate-layer embeddings. The analysis quantifies how each bond type geometrically shapes the reasoning trajectory.

Deep Reasoning as covalent bonding (Figure 7a): 72.56% of deep reasoning steps remain within a group distance of less than 3 in the t-SNE space, while "group-group distance >5.6" for transitions between different semantic regions. This means nearly three-quarters of deep reasoning edges connect steps within the same local logical neighborhood rather than jumping between distant clusters. Deep reasoning "mainly increases local connectivity, forming stable subdomains."

Self-Reflection as hydrogen bonding (Figure 7b): 81.72% of reflection steps "reconnect to a previously formed cluster with high semantic similarity." The reflection edge does not advance the reasoning linearly forward but rather folds back to earlier, semantically similar regions. This is quantified by the return distance $r_t = \min_{s < t} \|\mathbf{h}_{t+1} - \mathbf{h}_s\|_2$ — for a reflection edge to be counted as reconnecting, this minimum distance must fall below the adaptive clustering threshold $\alpha$ (see Technical Approach 3.4 for the exact definition). Over four-fifths of reflection transitions satisfy this criterion.

Self-Exploration as van der Waals forces (Figure 7c): Exploration transitions exhibit "an average trajectory length of 5.32 in the 3D t-SNE projection" — substantially larger than the within-cluster distances for deep reasoning (<3). These edges act as "loose links between otherwise separated clusters," forming transient, non-directional connections that enable the model to sample diverse solution approaches.

The training effect: The paper also compares representations before and after Long CoT training (Figure 13, Section 7), finding that:

• Deep Reasoning-enhanced training reduces minimum enclosing ball volume by ~22% (from $V_{\text{avg}} = 30.12$ to 23.47), densifying the logical backbone.
• Self-Exploration-enhanced training expands MEB volume by ~22% (from 23.95 to 29.22), broadening the explored semantic space.
• Self-Reflection steps reduce volume from 35.20 to 31.20 (~11.4% contraction), consolidating the logical structure by pruning inconsistent branches.

These geometric findings provide spatial grounding for the molecular analogy: the three bond types create a characteristic folded, domain-structured topology that is not captured by linear chain or simple tree models.

---

Attention Energy Levels Order as Predicted by Distance and Behavior Type

Section 4.4 (Figure 8) validates the Boltzmann reparameterization of attention by showing that the three bond types exhibit distinct, ordered attention energies.

Empirical attention energies (Figure 8): For models fine-tuned on QwQ-distilled data:

• Deep Reasoning bonds: $q \cdot k = 61.20$ (lowest energy $E_d = -3.9 \times 10^3 / kT$)
• Self-Reflection bonds: $q \cdot k = 34.44$ (intermediate energy $E_r = -2.2 \times 10^3 / kT$)
• Self-Exploration bonds: $q \cdot k = 16.87$ (highest energy $E_e = -1.1 \times 10^3 / kT$)

For models fine-tuned on OSS-distilled data, the absolute values differ but the ordering is preserved: Deep Reasoning $q \cdot k = 32.29$ > Self-Reflection $q \cdot k = 21.82$ > Self-Exploration $q \cdot k = 9.32$. As the paper states: "This ordering and the relative proportions are consistent across models" (Section 4.4).

Theoretical grounding (Appendix C.1.3): Theorem 1 proves that under RoPE positional encoding with two assumptions (isotropic, distance-decaying cross-covariance and positive average alignment of rotation), the expected energies satisfy $\bar{E}_D < \bar{E}_R < \bar{E}_E$ because Deep Reasoning connects adjacent steps (shortest relative distance), Self-Reflection connects moderately separated steps, and Self-Exploration connects maximally separated steps. The distance-decaying nature of attention under RoPE ($\rho(d)$ strictly decreasing in $d$) ensures this ordering.

This analysis establishes that "a bond-like mechanism broadly links these reasoning behaviors" (Takeaway 2) — the attention mechanism implements a physical-chemical analog where bond strength inversely correlates with the distance being bridged and the functional role of the connection.

---

Semantic Isomers Are Fragile: Small Structural Differences Cause Large Performance Swings

Section 5.1 and Table 1 demonstrate that different strong reasoning teachers produce structurally distinct "semantic isomers" — reasoning trajectories with highly correlated but not identical behavior transition distributions — and that these small differences propagate into large performance variations.

Quantifying isomer similarity and effect (Table 1, Appendix Table 5): The transfer graph correlation between R1 and OSS distilled data reaches "r ≈ 0.95" (Section 5.1), yet performance differences between R1-distilled and OSS-distilled models often exceed 10 percentage points. For Llama-3.1-8B-Base: R1-distillation achieves 19.52% average vs. OSS-distillation at 33.69% — a gap of 14.17 points. For Llama-3.1-8B-Instruct: R1-distillation achieves 33.99% vs. OSS at 39.27% — a gap of 5.28 points. The relative ranking of teachers varies by student backbone: for Qwen-2.5-32B-Instruct, QwQ distillation (74.16%) outperforms OSS distillation (73.05%), while for Llama-3.1-8B-Instruct, OSS outperforms QwQ (39.27% vs. 35.73%).

ICL demonstration selection confirms the isomer matching requirement (Figure 9): When using ICL-generated traces for distillation, three demonstration selection strategies are compared: random selection, aligned selection (demonstration behavior distribution correlated at $r \gtrsim 0.9$ with the target teacher), and mismatched selection ($r < 0.8$). The results show that "substantial performance gains emerge only when demonstrations are constructed to match a specific target distribution of reasoning keys" (Section 5.1). For aligned demonstrations (with appropriate isomer structure), accuracy reaches approximately 32–36% for both Llama3 and Qwen2.5 backbones (estimated from Figure 9's bar chart). For random or mismatched demonstrations, accuracy drops to approximately 5–12%, comparable to the untrained base model. The aligned condition essentially rescues ICL-based distillation, demonstrating that the demonstration's structural match to the target isomer is the critical variable.

The implication (Takeaway 3): "Well-structured isomers perform effectively when their reasoning-key distributions align closely, but small structural shifts cause fragility and sharp performance losses." This fragility means that distillation quality depends sensitively on the specific structural configuration of training data — not just its correctness or completeness — and that structurally near-identical traces can produce substantially different learning outcomes.

---

Mixing Two Stable Isomers Creates Structural Chaos and Degrades Performance

Section 5.2 (Figure 11) provides the paper's most direct demonstration of structural incompatibility: when training data from two individually effective semantic isomers (OSS and R1) are combined, the resulting model performs worse than either source alone, and its behavior distribution becomes unstable.

Experiment design (Appendix D.4): Five training configurations are compared, all using 20K total examples on Llama-3.1-8B-Instruct:

• OSS-Distill-Data (single isomer, 20K OSS): 39.3% average accuracy
• R1-Distill-Data (single isomer, 20K R1): 37.9% average accuracy
• R1-then-OSS (sequential, 10K R1 then 10K OSS): 34.0%
• OSS-then-R1 (sequential, 10K OSS then 10K R1): 31.9%
• R1-mix-OSS (randomly interleaved, 10K OSS + 10K R1): 31.6%

All three mixing strategies degrade performance below either single-teacher baseline. The interleaved mixture performs worst (31.6%), and sequential mixtures show intermediate degradation (31.9–34.0%). The gap between single-isomer (37.9–39.3%) and mixed-isomer training (31.6–34.0%) is roughly 4–7 percentage points.

Structural stability measurement (Figure 11d): The self-correlation (Pearson correlation between transfer graphs computed from different subsets of the jointly trained model's own generated trajectories) "does not exceed 0.8" for the co-activated model. In contrast, single-isomer models exhibit stable transfer graphs with self-correlations presumably higher (the paper does not provide exact values, but the claim is that they significantly exceed 0.8). The paper's interpretation: "co-activation prevents the model from converging to a single stable behavioral mode: it produces molecular bond distributions that fluctuate across samples and deviate from those characteristic of either OSS or R1" (Section 5.2).

The non-obviousness of this result: The two source distributions are extremely similar by conventional metrics ($r \approx 0.9$ between their transfer graphs). The fact that combining them causes structural destabilization rather than interpolation implies that there is a phase boundary in the space of behavior transition distributions — two nearby but distinct stable configurations cannot be simultaneously learned by a single model.

---

Mole-Syn Synthesized Data Achieves Near-Distillation Performance from Instruction-Only Sources

Section 6 and Table 2 present the results for Mole-Syn, the structure-guided synthesis framework. Using only instruction-tuned LLMs (Llama-3.1-8B-Instruct, Qwen-2.5-7B/32B, Llama-3.1-70B-Instruct) guided by a transfer graph estimated from a strong reasoning teacher, Mole-Syn produces synthetic Long CoT training data that achieves a substantial fraction of the gains from direct distillation.

Main SFT results (Table 2, full results in Appendix Table 6): For Llama-3.1-8B-Instruct as the student backbone:

• Starting from 25.32% average (untrained base)
• OSS-Mole-Syn (20K synthetic data guided by OSS transfer graph): 32.40% average — achieving ~82% of the OSS distillation gain (39.27% — 25.32% = 13.95% gain; Mole-Syn captures 32.40% — 25.32% = 7.08 points of this gain)
• QwQ-Mole-Syn (20K synthetic data guided by QwQ transfer graph): 32.29% average — achieving ~67% of the QwQ distillation gain (35.73% — 25.32% = 10.41% gain; Mole-Syn captures 6.97 points)
• Qwen-Distill-Data (ICL-based, comparison point): 27.84% average

For Llama-3.1-8B-Base: OSS-Mole-Syn achieves 22.89%, QwQ-Mole-Syn achieves 22.44%, both substantially above Qwen-Distill-Data (18.58%) and the untrained base (2.70%), but below OSS-Distill (33.69%). For Qwen-2.5-7B-Instruct: OSS-Mole-Syn achieves 44.87%, QwQ-Mole-Syn achieves 44.25%, compared to OSS-Distill (48.94%) and QwQ-Distill (46.31%).

On simpler vs. harder benchmarks: Mole-Syn's strongest gains are on GSM8K (e.g., 83.24% for Llama-3.1-8B-Instruct + OSS-Mole-Syn vs. 79.00% for OSS-Distill — actually slightly higher) and MATH-500 (51.80% vs. 60.80%), while the gap is larger on competition-level benchmarks: AIME2024 (4.79% vs. 10.83%), AIME2025 (1.04% vs. 7.71%), AMC2023 (32.50% vs. 47.03%), OlympiadBench (21.04% vs. 30.22%). The synthetic data provides reasonable coverage of the easier benchmarks where deep reasoning requirements are less extreme, but on the hardest competition problems requiring extended multi-step deduction, the synthetic traces are less effective — consistent with the hierarchy of synthesis backbone quality (Appendix Table 7 shows that Qwen-32B backbone is required for strong deep reasoning synthesis).

Synthesis backbone quality matters (Appendix Table 7): Using the same OSS transfer graph to guide different instruction-tuned LLMs in generating synthetic data:

• Llama-3.1-8B-Instruct as synthesizer: Only 13.95% average when trained on Llama-8B-synthesized data (Mole-Syn-by-Llama-3.1-8B-Instruct), worse than untrained Llama-3.1-8B-Instruct baseline (25.32%) — likely because the weak synthesizer produces poor-quality reasoning that actively degrades the student.
• Llama-3.1-70B-Instruct as synthesizer: 31.97% average.
• Qwen-7B as synthesizer: 31.82% average.
• Qwen-32B as synthesizer: 35.73% average — approaching direct QwQ distillation performance (35.73%).

The hierarchy follows the synthesizer's intrinsic reasoning capability, with the paper noting: "Models with limited self-reflection or exploration capabilities, such as Llama-3.1-8B-Instruct, struggled to synthesize effective reasoning data" (Appendix E).

---

Mole-Syn Initialization Provides Superior and More Stable RL Performance

Section 6 and Figure 12 demonstrate that models initialized with Mole-Syn-synthesized Long CoT weights exhibit more sustained and stable improvement during reinforcement learning than those initialized from direct distillation.

RL accuracy trajectory (Figure 12, Appendix Table 8): On Llama-3.1-8B-Instruct as the base:

• QwQ-Distill-Data initialization + RL: Starts at 35.73% (pre-RL SFT accuracy), improves to 39.72% after 1,000 RL steps — a gain of 3.99 percentage points.
• QwQ-Mole-Syn initialization (20K) + RL: Starts at 32.29%, improves to 38.44% — a gain of 6.15 percentage points.
• QwQ-Mole-Syn initialization (35K) + RL: Starts at a higher pre-RL baseline (exact value not in Table 8 but implied by the "35K" row: this is the SFT accuracy from 35K synthetic data before RL), improves to 39.51% — essentially matching the distillation-initialized RL performance.

The RL accuracy curve on MATH-500 (Figure 12d) shows that Mole-Syn-initialized models (both 20K and 35K) start lower but catch up and in some cases surpass the distillation-initialized model over the 1,000-step training horizon. By step ~600–800, the 35K Mole-Syn + RL curve reaches approximately 69–70% on MATH-500, comparable to or slightly above the QwQ-Distill + RL curve.

RL reward and response length dynamics (Figure 12b-c): Mole-Syn-initialized RL training exhibits "steadier fine-tuning gains" with less variance in both reward and response length compared to distillation-initialized RL. Figure 12b shows that the reward curve for QwQ-Graph-Syn + RL continues to trend upward across all 1,000 steps, while the QwQ-Distill + RL curve plateaus earlier. Response length (Figure 12c) is more stable for the synthetic initialization, suggesting the model converges to a consistent reasoning depth more reliably.

The interpretation (Takeaway 4): "Models initialized with synthesized Long CoT weights demonstrate superior and sustained RL performance gains, providing a robust foundation for continual learning in dynamic environments." The controlled structural regularity of synthetic data (guided by a clean transfer graph without teacher-specific noise) appears to provide a better RL initialization than direct distillation, where the model may learn spurious patterns specific to the teacher that interfere with RL optimization.

---

Summarization Disrupts Long CoT Structure and Reduces Distillation Effectiveness

Section 8 and Tables 3–4 analyze how summarization and compression — techniques used by private LLM providers to protect reasoning traces — disrupt the molecular structure and reduce the effectiveness of distillation.

Distillation from Gemini and Claude (Table 3): Training on 20K distilled traces from Gemini-2.5-Pro-Thinking and Claude-4-Sonnet (both of which expose "thinking" content that is substantially shorter than full Long CoT traces from open-weight reasoning models):

• Gemini-Distill-Data on Llama-3.1-8B-Instruct: 16.43% average — substantially below the untrained baseline (25.32%) and far below OSS-distilled (39.27%). Performance actually degrades from the instruction-tuned baseline.
• Claude4-Distill-Data on Llama-3.1-8B-Instruct: 23.06% average — also below the untrained baseline.
• On Qwen-2.5-32B-Instruct, Gemini-Distill achieves only 28.19% (vs. 52.76% baseline), while Claude4-Distill achieves 41.55%.

These results show that the compressed thinking traces from private model providers are structurally insufficient for effective Long CoT distillation — they lack the full bond distribution that open models like R1, OSS, and QwQ provide.

Summarized Long CoT traces perform worse (Table 4): When the full Long CoT traces from QwQ-32B and OpenAI-OSS-120B are summarized using Qwen2.5-32B (compressing the reasoning into concise summaries), the distillation effectiveness drops:

• OSS-Summarized on Llama-3.1-8B-Instruct: 16.43% average (vs. 39.27% for full OSS-Distill)
• QwQ-Summarized on Llama-3.1-8B-Instruct: 23.06% average (vs. 35.73% for full QwQ-Distill)
• On Qwen-2.5-7B-Instruct, the drop is smaller but still present: OSS-Summarized achieves 37.17% (vs. 48.94% for full OSS-Distill), QwQ-Summarized achieves 36.77% (vs. 46.31%).

The paper quantifies this as "reduces distillation effectiveness by ~2%" (Section 8), though the exact meaning of "2%" is ambiguous in context — the absolute accuracy drops are substantially larger (e.g., 39.27% → 16.43% is a 22.84-point drop).

How summarization disrupts structure (Figure 14): The transfer graph for summarized QwQ traces (Figure 14b) shows a visibly different distribution from the full QwQ transfer graph (Figure 14a). The bond energies for summarized traces (Figure 14c) are substantially different: Deep Reasoning $q \cdot k = 15.97$ (vs. 61.20 for full traces), Self-Reflection $q \cdot k = 12.13$ (vs. 34.44), Self-Exploration $q \cdot k = 4.50$ (vs. 16.87). Summarization collapses the energy hierarchy — the distinct ordering and separation between bond types is largely erased, and the absolute attention strength is much lower across all bond types. This structural disruption explains why summarization "protects Long CoT structures from distillation by disrupting structural coherence" (Takeaway 6) — the compressed traces no longer encode the stable bond distribution that makes Long CoT learnable.

---

Ablation Studies and Robustness Checks

Behavior annotation validation (Appendix C.2): The automated behavior classifier (Qwen2.5-32B-Instruct with the detailed annotation prompt) achieves macro-F1 > 0.85 on a 200-example subset against human annotations. This establishes that the measurement instrument is reliable enough for distribution-level analyses — some individual edge misclassifications are tolerable because downstream analyses aggregate over large numbers of labeled edges, where unbiased or low-bias noise attenuates correlations but does not create spurious structure.

Transfer graph stability across sample sizes (Section 4.1, Figure 5): Pearson correlations between transfer graphs computed from different sample sizes stabilize above 0.95 when $N > 2000$ labeled transitions. Below this threshold, correlations are lower and more variable. Averaged across five independent trials, correlations exceed 0.9 for $N > 2000$. This confirms that the transfer graph captures a genuine structural property rather than a sampling artifact, and establishes 2,000+ as the minimum sample size for reliable estimation.

Transfer graph cross-model robustness (Figure 5, Section 4.1): The three transfer graphs from DeepSeek-R1-671B-0528, OpenAI-OSS-120B, and QwQ-32B exhibit Pearson correlations exceeding 0.9 (p<0.001) for samples over 2,000. This convergence occurs despite completely different model architectures, training procedures, and scales (671B vs. 120B vs. 32B). This is the central robustness check for the molecular structure hypothesis — if the transfer graph were an artifact of a particular training recipe, one would expect divergence across model families, not convergence.

Keyword replacement at multiple data scales (Figure 6c): The keyword sensitivity experiment tests at 1K, 2K, 5K, 10K, 20K samples, and 20K-5epoch. The finding that keyword dependence diminishes with data scale (gap narrows from 5–8 points at 2K to ~1–2 points at 20K) suggests that keywords provide a useful but non-essential learning signal — they accelerate learning when data is scarce but become redundant when sufficient data is available for the model to infer the underlying behavioral structure from context alone.

Two alternative keyword replacement sets (Appendix C.5.1): Keyword-variant 1 and Keyword-variant 2 use different replacement sets for each keyword (fully specified in the appendix boxes). The comparable performance of both variants at 20K samples rules out the possibility that a particular replacement set accidentally preserved the structural signal — both altered-lexicon datasets produce comparable results, and both converge to near-original performance with sufficient data.

Semantic isomer mixing strategies (Figure 11, Appendix D.4): Three mixing strategies are compared (sequential R1-then-OSS, sequential OSS-then-R1, random interleaved R1-mix-OSS) to test whether the order of exposure matters. Sequential mixing performs slightly better than interleaved (34.0% and 31.9% vs. 31.6%), but all three degrade below single-source baselines (37.9–39.3%). The interleaved being worst is consistent with the interpretation that simultaneous exposure to both isomers is maximally destabilizing, while sequential exposure allows some partial commitment to the first isomer before encountering the second.

Synthesis backbone quality hierarchy (Appendix Table 7): Mole-Syn is tested with four different instruction-tuned LLMs as synthesizers (Llama-3.1-8B-Instruct, Llama-3.1-70B-Instruct, Qwen-7B, Qwen-32B), all using the same transfer graph. The results show that synthesis quality monotonically increases with backbone capability, but even weak backbones (Llama-70B, Qwen-7B) produce useful data (31.82–31.97% average). Only the weakest backbone (Llama-8B) fails catastrophically (13.95%), indicating that successful synthesis requires at least moderate instruction-following and reasoning capability.

Mole-Syn data quantity scaling (Figure 12, Appendix Table 8): Mole-Syn data is tested at 20K and 35K samples for RL initialization. The 35K variant achieves stronger final RL performance (39.51% vs. 38.44%) that essentially matches distillation-initialized RL (39.72%), suggesting that the synthetic data's structural quality can compensate for its content gap relative to distillation with sufficient scale.

Learning rate and training hyperparameter controls (Appendix B, E.2): All SFT experiments use learning rate $2 \times 10^{-5}$, global batch size 128, 1 epoch, maximum sequence length 16K or 32K (selecting the better). All RL experiments use DAPO with learning rate $1 \times 10^{-5}$, batch size 16, sampling size 16, max sequence length 16,384, clipping 0.2/0.68, 1,000 steps. These are held constant across comparisons so performance differences are attributable to data source/initialization, not hyperparameter tuning.

Answer extraction and grading consistency (Appendix A): Answers are extracted from \boxed{...} format using standard math-verify tools, and grading uses standard answer-matching against reference solutions. This ensures that differences in performance reflect genuine reasoning quality differences, not extraction artifacts.

Information flow analysis — Multi-human comparison (Figure 10): The phase space analysis compares R1 trajectories against traces from four different human subjects (Human 1–4). The uniformity of human entropy profiles (81.3% of cases show changes <0.1) across different individuals rules out the possibility that the human–R1 difference is an artifact of a particular human's reasoning style.

RL reward and response curves stability (Figure 12): The Mole-Syn + RL curves show less variance and more sustained improvement over 1,000 steps compared to Distill + RL curves. Response length (Figure 12c) for Mole-Syn-initialized RL is more stable, suggesting the model converges to a consistent reasoning depth rather than oscillating, as the distillation-initialized model does.

Replication across student architectures (Appendix Table 5): The distillation results are replicated across eight student backbones (Llama-3.1 8B/70B base/instruct, Qwen-2.5 7B/32B base/instruct). The consistent pattern (OSS and QwQ distillation work, ICL fails) across different model families and scales strengthens the claim that the effect is about structural properties of the training data, not a peculiarity of a specific student model.

Negative result — ReST EM revision model (Appendix K, Figure 16, mentioned in reference example): An attempt to optimize the revision model using ReST EM [Singh et al., 2024] backfires — additional sequential revisions substantially hurt performance. This negative result highlights the sensitivity of revision training to data generation procedure and is noted as a notable failure case that the paper does not explore further.

---

Critical Assessment

Claim 1: Effective Long CoT trajectories exhibit stable molecular-like structures with three bond types that converge across models.

What was demonstrated: The transfer graphs from three strong reasoning models correlate at $r > 0.9$ (Figure 5). The geometric analysis shows that each bond type has distinct spatial signatures (Figure 7), and the attention-energy ordering confirms a mechanistic distinction (Figure 8). The keyword replacement experiment (Figure 6c) shows that the structural pattern, not surface form, is what gets learned.

What was not demonstrated — and what would be needed: The paper does not establish that the three-bond taxonomy (N, D, R, E) is complete or optimal. The behavior annotation relies on a specific prompt and a specific annotator model (Qwen2.5-32B-Instruct); different annotation schemes might yield different transfer graphs or reveal additional bond types. The >0.85 macro-F1 validation is reasonable but means ~15% of individual edge labels are incorrect — this could smooth out genuine structural variations that matter for isomer compatibility. More critically, the paper does not compare the three-bond model against alternative structural decompositions (e.g., 2-bond, 5-bond, continuous behavioral dimension) to show that this particular taxonomy is necessary or uniquely predictive. The claim that "simple human simulation or ICL cannot emulate the global bond distribution" is stated but not quantified with a transfer graph for human or ICL-generated traces — this is an assertion, not a measurement.

The convergence of transfer graphs across three models is strong evidence for a stable structure, but three models (all from a narrow time window with similar training paradigms) is a small sample. Architectural families not tested (e.g., Gemini, Claude, non-Transformer architectures) might exhibit different stable distributions or not converge to this particular distribution.

Conditional assessment: The claim is well-supported for the specific models tested (DeepSeek-R1, OpenAI-OSS, QwQ) on the specific data distribution (OpenThoughts-3). Generalizability to a broader set of reasoning models and domains remains to be established.

---

Claim 2: Semantic isomers explain why structurally similar traces produce different learning outcomes, and mixing incompatible isomers destabilizes learning.

What was demonstrated: Table 1 shows that R1 and OSS distillation (transfer graphs correlated at $r \approx 0.95$) produce >10% accuracy differences on some student models. Figure 11 shows that mixing OSS and R1 data degrades performance below either single-source baseline, and the mixing model's behavior distribution self-correlation drops below 0.8. Figure 9 shows that ICL demonstrations work only when structurally matched ($r \gtrsim 0.9$).

What was not demonstrated — and what would be needed: The paper does not provide a formal criterion for when two isomers are "compatible" vs. "incompatible." The finding that $r \approx 0.95$ isomers can be incompatible, while $r \gtrsim 0.9$ demonstrations can be compatible for ICL, suggests that correlation is not the right metric — but no alternative is proposed. This limits the practical utility of the isomer concept: without a computable compatibility measure, one cannot predict a priori whether mixing two data sources will succeed or fail without running the experiment. The paper also does not explore how many distinct stable isomers exist ("two" — OSS and R1 — is a small number) or whether some students are more robust to isomer mixing than others.

The conflict learning experiment (Figure 11) uses only two isomer sources (OSS and R1) and tests only three mixing strategies. A more systematic sweep — varying the mixing ratio (not just 50-50), testing more isomer pairs, measuring the onset of structural chaos as a function of distribution divergence — would substantially strengthen the claim. The paper's assertion that the mixing model "does not exceed 0.8" self-correlation is a single number without distributional characterization; we don't know how this self-correlation varies across model checkpoints, data subsets, or evaluation prompts.

Conditional assessment: The claim that structurally similar but distinct reasoning frameworks can be incompatible when mixed is convincingly demonstrated for the specific OSS–R1 pair. The broader claim that this is a general property of semantic isomers — that there exist phase boundaries in behavior transition space — is suggested but not systematically established.

---

Claim 3: SFT learns reasoning structure, not surface keywords, as evidenced by the SAE and keyword replacement experiments.

What was demonstrated: The SAE identifies discourse-control features in the SFT model that are absent in the base model and are associated with specific connectives (Figure 6a-b). Keyword-replaced training data achieves comparable performance to original data at 20K+ scale (Figure 6c).

What was not demonstrated — and what would be needed: The SAE analysis shows that the SFT model develops dedicated features for discourse transitions, but it does not show what these features encode — the paper asserts they encode "reasoning behaviors," but this is an interpretation, not a measurement. One could equally interpret them as encoding syntactic patterns, register shifts, or other surface properties associated with Long CoT style. A causal intervention — e.g., ablating these features and showing that Long CoT capability degrades — would strengthen the claim that they are causally responsible for structural reasoning.

The keyword replacement experiment addresses a different question: it shows that models can learn Long CoT without specific keywords, but it does not show that what they learn in that case is the same as what they learn with keywords. The SAE is only analyzed for the model trained on original (keyword-containing) data, not for the keyword-variant models. It is possible that the keyword-variant models learn a different internal representation that happens to achieve comparable performance — the paper's inference that they must be learning "the same underlying structure" is not directly tested.

Missing experiment: Train the SAE on keyword-variant models and compare feature activation patterns to the original model — if the discourse-control features are identical, that would directly confirm structure learning. If they are different but functionally equivalent, that would reveal something about the flexibility of structural representation. Neither is done.

Conditional assessment: The keyword replacement experiment convincingly shows that specific surface lexical markers are not necessary for Long CoT learning at scale. The claim that "SFT learns reasoning structure" is supported by the SAE evidence but not rigorously distinguished from alternative interpretations (syntactic pattern learning, style transfer).

---

Claim 4: Mole-Syn synthesizes effective Long CoT structures from instruction-tuned LLMs without requiring teacher reasoning traces, achieving near-distillation performance.

What was demonstrated: Table 2 shows that Mole-Syn data achieves 32.29–32.40% average on Llama-3.1-8B-Instruct, compared to 39.27% for direct OSS distillation — capturing a substantial fraction of the gain. Figure 12 shows that Mole-Syn-initialized models have more stable and sustained RL improvement, with 35K synthetic data + RL essentially matching distillation + RL.

What was not demonstrated — and what would be needed: Mole-Syn still requires a transfer graph estimated from a strong reasoning teacher — it does not eliminate the dependency on teacher models entirely. The transfer graph estimation requires annotating thousands of teacher-generated traces; while cheaper than generating the full distillation dataset, it still requires API access or open-weight reasoning models. The paper does not test whether transfer graphs from different teachers or tasks generalize — can a transfer graph estimated on math problems guide synthesis for code generation? Can a graph from R1 guide synthesis that works for OSS-level performance?

The synthesis quality is sensitive to the backbone model — Llama-8B as synthesizer fails catastrophically (13.95%, Table 7), while Qwen-32B nearly matches distillation. The paper does not systematically investigate what minimal backbone capability is required or whether specific architectural properties (instruction-tuning quality, reasoning benchmark performance, model scale) predict synthesis quality. Without this, a practitioner cannot determine whether their available instruction-tuned LLM will be an adequate synthesizer.

Missing ablation: The paper does not compare Mole-Syn against a simpler baseline — e.g., prompting the instruction LLM with a single "do long chain-of-thought reasoning" instruction (without the behavior-guided random walk) but with the same number of generated tokens. Such a baseline would help isolate whether the gain comes from the transfer graph specifically or simply from using the instruction LLM to generate any Long CoT data at scale. Given that Figure 3 shows single-prompt ICL generation fails, the transfer graph is clearly doing something — but the incremental contribution of each component (graph guidance, behavior-specific prompts, sequential sampling) is not isolated.

Conditional assessment: The claim that transfer-graph-guided synthesis from instruction LLMs can produce effective Long CoT training data is supported. The claim that this "eliminates the need for access to teacher reasoning traces" is overstated — teacher access is still needed for the graph estimation step, and the graph's transferability across domains and teachers is untested. The approach works but within a bounded regime (good backbone models, math reasoning domain, 20K–35K data scale).

---

Claim 5: Each bond type has a distinct geometric shaping function — deep reasoning densifies, exploration expands, reflection stabilizes.

What was demonstrated: Figure 13 and Appendix F show MEB volume changes of approximately -22% for deep reasoning, +22% for exploration, and -11.4% for reflection. Figure 7 shows geometric clustering properties for each bond type (72.56% within-cluster for deep reasoning, 81.72% reconnection for reflection, 5.32 average trajectory length for exploration).

What was not demonstrated — and what would be needed: The MEB volume measurements use 3D t-SNE projections, which are a lossy approximation of the true high-dimensional geometry. The paper acknowledges this limitation (Section 10, Limitations: "We can only approximately visualize the geometric characteristics"), but does not provide any high-dimensional analog of the volume measurements. The 22% numbers are specific to the t-SNE parameters used (cosine distance, early exaggeration 12.0, 5,000 iterations); different parameters could yield different volumes and relative changes. The cluster definitions depend on the adaptive threshold $\alpha = 0.02 \times (h_{\text{max}} - h_{\text{min}})$ — the 0.02 factor is empirically chosen (Appendix C.3.1) and sensitivity to this choice is not tested.

The "shaping function" analysis manipulates transfer probabilities during Mole-Syn synthesis (increasing target bond self-transition to >50%) rather than analyzing natural trajectories. This tests what happens when a particular bond type is artificially amplified, but does not directly measure the contribution of that bond type in balanced, naturally distributed trajectories. The functional roles (densification, expansion, stabilization) might interact non-additively in natural reasoning, which this manipulation design cannot capture.

Missing experiment: A causal intervention during inference — e.g., forcing the model to skip reflection steps or replace exploration with deep reasoning — and measuring the effect on solution quality. This would more directly test whether the bonds play the claimed functional roles, rather than just measuring their geometric correlates.

Conditional assessment: The geometric measurements are internally consistent and align with the bond type definitions (deep reasoning = local, exploration = distant, reflection = backward). The claim that these bonds "shape" the reasoning process is plausible but based on correlational geometric analysis rather than causal demonstrations.

---

Claim 6: Summarization and compression protect Long CoT structures from distillation.

What was demonstrated: Table 3 shows that distillation from Gemini and Claude (which expose compressed thinking) produces accuracy below untrained baselines for most configurations. Table 4 shows that summarizing full Long CoT traces reduces distillation effectiveness, and Figure 14 shows that summarization disrupts the transfer graph and collapses the bond energy ordering.

What was not demonstrated — and what would be needed: The summarization experiment uses a specific summarization model (Qwen2.5-32B) and a specific approach (compressing each trace into a concise summary). The paper frames this as modeling "protection strategies" used by private LLM providers (Section 8), but it does not establish that private providers actually use the same summarization approach — Gemini and Claude's thinking traces may be shortened through other mechanisms (architectural constraints, different training objectives, deliberate truncation). The finding that training on summarized traces hurts performance is confounded by the reduced information content — any form of compression reduces available training signal, so performance degradation is expected. The interesting question is whether the performance degradation from summarization is worse than what would be predicted by token count reduction alone (i.e., whether structural disruption causes additional harm beyond information loss). The paper does not include a baseline that controls for token count — e.g., a randomly truncated version of the same traces matched for length — which would isolate the structural disruption effect.

Conditional assessment: Summarization does disrupt the molecular structure and reduce distillation effectiveness. Whether this is the mechanism by which private LLM providers protect reasoning traces, as opposed to simpler explanations (they just expose less information), is not conclusively established. The experiments demonstrate correlation between structural disruption and distillation degradation, but the causal claim that structural disruption is the protective mechanism would require controlling for information quantity.

---

Broader experimental design limitations

Benchmark diversity and domain coverage: All six evaluation benchmarks are mathematical reasoning tasks. While OpenThoughts-3 contains code and science data, the paper does not report results on non-math domains. The molecular structure framework is claimed to be a general property of Long CoT reasoning, but it is validated only on math. The transfer graph might look different for code reasoning (which has different structural demands — debugging, iterative refinement, test-case generation) or scientific reasoning (which involves more factual recall and hypothesis testing). Extending the analysis to non-math domains would be a natural and important validation.

Base and student model coverage: While eight student backbones are tested for the distillation results (Appendix Table 5), the deeper structural analyses (SAE, geometric embedding, attention energy) are only performed on Llama-3.1-8B variants. The Mole-Syn synthesis backbone analysis (Table 7) tests four models. The paper does not explore whether the molecular structure properties hold for models at substantially different scales (e.g., 1B vs. 405B) or for non-Transformer architectures.

No confidence intervals or statistical testing for accuracy: All accuracy numbers in Tables 1–4, 5–8 are reported as point estimates without variance information. For small test sets like AIME2024 and AIME2025 (with few questions), sampling variance could be substantial — a few lucky or unlucky generations could meaningfully shift the reported Avg@16 accuracy. The lack of error bars means that claims about small differences (e.g., 38.44% vs. 39.72% in Table 8) cannot be assessed for statistical reliability.

Data scale — only 20K training examples tested: The SFT experiments use 20K training examples as the standard scale, with RL experiments extending to 35K synthetic examples. The paper does not explore scaling laws for structural learning — does the advantage of structural coherence over surface imitation grow or shrink with data scale? Does the isomer incompatibility threshold change with more data (can models learn to reconcile conflicting isomers given enough examples)? These are important practical questions left open.

Difficulty estimation is absent — unlike the reference example paper's approach: The reference example paper (on test-time compute scaling) uses a difficulty estimation step (2048 samples per question, binned into quintiles) to adaptively allocate compute. This paper's framework could analogously benefit from structural difficulty estimation — predicting whether a given question or domain requires a particular behavior distribution for effective reasoning — but no such mechanism is developed. All experiments treat all questions uniformly (same training data distribution applied to all benchmarks). The finding that "excessive reflection causes overthinking on easy problems while insufficient reflection limits hard-problem performance" (Appendix G) suggests that difficulty-adaptive structural allocation could be beneficial, but this is not operationalized.

The "entropy convergence" criterion for effective isomers is suggestive but not operationalized: Section 5.1.1 argues that effective isomers cause "metacognitive oscillation" visible in the information phase space, but this analysis is only performed on a small set of human and R1 traces — it is not used as a screening criterion for training data quality, nor is it validated against the broader set of distillation results. A stronger paper would use entropy convergence metrics to predict which data sources will be effective for distillation, and test those predictions prospectively.

The RL experiments conflate two effects: Mole-Syn-initialized models differ from distillation-initialized models in (1) the structural regularity of training data and (2) potentially the average difficulty or length of training examples. The paper attributes RL stability gains to structural regularity, but does not control for other differences between synthetic and distilled data. A controlled experiment that matches synthetic and distilled data on example-level features (length, difficulty, answer correctness) while varying only structural regularity would strengthen the causal claim.

6. Limitations and Trade-offs

Difficulty Estimation — The Transfer Graph Requires Access to Strong Reasoning Teachers

The assumption or constraint. Mole-Syn synthesizes Long CoT training data using a behavior transition graph $\hat{P}(b' \mid b)$ estimated from strong reasoning teacher models. While the paper frames this as eliminating the need for teacher reasoning traces ("enables the generation of Long CoT data that match target behavior distributions from scratch, without directly copying teacher outputs," Section 6), the transfer graph estimation itself requires annotating thousands of teacher-generated traces. The paper does not hide this — Appendix E.1 states explicitly that Mole-Syn uses "20k distilled CoT rationales generated by teacher models (e.g., QwQ-32B and OpenAI-OSS-120B)" to estimate the empirical transition matrix. Every Mole-Syn experiment in Table 2 uses a graph derived from a specific strong reasoning teacher (OSS or QwQ).

The consequence. A practitioner seeking to use Mole-Syn for a new domain, task family, or model ecosystem must either (a) have API access to a strong reasoning model to generate the 20K estimation traces, (b) have access to an open-weight strong reasoning model that can produce Long CoT outputs, or (c) hope that the transfer graph transfers across domains. The paper provides no evidence that a graph estimated on math reasoning problems (OpenThoughts-3) will guide effective synthesis for code generation, scientific reasoning, or other domains. If the transfer graph is domain-specific — and the paper's finding that different isomers (OSS vs. R1) produce different downstream performance (Table 1, >10% differences) suggests structural specificity — then each new domain would require its own graph estimation step, re-introducing the very dependency on strong reasoning teachers that Mole-Syn claims to circumvent.

What evidence exists in the paper. Section 4.1 establishes that transfer graphs from three strong reasoning models (R1, OSS, QwQ) correlate at $r > 0.9$ on OpenThoughts-3 queries — but this is a single-domain corpus. The paper does not report transfer graph comparisons across domains (math vs. code vs. science). Appendix E (Table 7) shows that the synthesis backbone quality substantially affects downstream performance — but this tests the generator side, not the transferability of the graph itself. The paper does not include an experiment where a graph estimated from one domain's queries is used to synthesize data for a different domain.

Mitigation status. Not addressed. The paper presents Mole-Syn as a method for reducing dependency on teacher models ("enabling lower-cost behavior transfer," Section 6), but does not discuss the remaining dependency for graph estimation, nor test whether graphs transfer across tasks or teacher models. This is a significant gap between the stated goal (democratizing Long CoT data synthesis) and the current method's requirements.

---

Single-Domain Validation — All Experiments Are on Mathematical Reasoning

The assumption or constraint. Every evaluation benchmark in the paper — GSM8K, MATH-500, AIME2024, AIME2025, AMC2023, OlympiadBench — is a mathematical reasoning task. The training data for distillation and Mole-Syn is drawn from OpenThoughts-3, described as a "mixed-domain corpus comprising math, code, and scientific reasoning tasks" (Appendix C.2), but no results are reported on non-math domains. The structural analyses (geometric embedding in Section 4.3, attention energy in Section 4.4) are performed on trajectories from these evaluation benchmarks and OpenThoughts-3 queries.

The consequence. The paper's central claims — that effective Long CoT exhibits a stable three-bond molecular structure, that this structure is learnable through SFT, that semantic isomers explain distillation success/failure — are validated exclusively on mathematical reasoning. Mathematics has specific structural properties that may not generalize: problems have unique correct answers (enabling clean pass@1 evaluation and answer extraction), reasoning typically follows linear deductive chains with occasional branching (mapping naturally to the D→D, D→R, D→E transitions the transfer graph captures), and there is a well-defined notion of "correctness" for intermediate steps (enabling the behavior annotation to distinguish deep reasoning from normal operation based on whether new logical nodes are introduced).

Code generation, for instance, involves debugging cycles (iterative self-reflection), refactoring (restructuring without changing functionality), and test-case generation (exploration with concrete validation) — these might map differently onto the D/R/E/N taxonomy, or require additional bond types. Scientific reasoning involves weighing evidence, updating beliefs, and handling uncertainty — the paper's behavior definitions (Appendix C.1.1), with their emphasis on logical deduction chains, may not capture these dynamics. The paper acknowledges this limitation obliquely in Section 10 ("limited by cost and scale constraints, our analysis relies on a limited set of teacher models and student backbones"), but does not frame it as a domain-generalization concern.

What evidence exists in the paper. Zero experiments on non-math domains. Table 2, Table 1, and Appendix Table 5 report only the six math benchmarks. Figure 5's transfer graphs are from OpenThoughts-3 — a mixed-domain dataset, but the paper does not disaggregate the graphs by domain to test whether the same stable structure appears in code and science subtasks. The information flow analysis (Figure 10) uses "multi-step logical deduction and structured reasoning tasks from Du et al. [7]" — again, logical/mathematical.

Mitigation status. Not addressed beyond a general "limitations" acknowledgment. The paper does not claim domain-generality of the molecular structure — but neither does it restrict its claims to mathematical reasoning. Section 1 states the framework applies to "diverse reasoning tasks," and the molecular analogy is presented as a general theory of Long CoT. Without non-math validation, a practitioner cannot determine whether Mole-Syn or the isomer framework will work for their domain.

---

No Accounting for Behavior Annotation Cost and Reliability in Practice

The assumption or constraint. All structural analyses — transfer graph estimation, isomer comparison, behavior distribution measurement — depend on the behavior annotation pipeline (Appendix C.2). This pipeline uses Qwen2.5-32B-Instruct prompted with detailed decision rules to classify each transition into one of four types (N, D, R, E), validated at macro-F1 > 0.85 on a 200-example subset against human labels. The paper treats this annotation as a solved measurement problem and does not factor its cost or reliability into any practical assessment.

The consequence. A practitioner deploying the molecular structure framework — for data filtering (rejecting training examples whose behavior distribution is structurally incompatible), for synthesis quality control (verifying that Mole-Syn-generated data matches the target transfer graph), or for diagnosing distillation failures — must run the same annotation pipeline on their own data. This requires an LLM capable of reliable behavior classification (the paper uses a 32B model), and it requires that the annotator model's behavior definitions transfer to the practitioner's domain. The >0.85 macro-F1 validation was performed on a "200-example subset" (Appendix C.2) from the paper's specific reasoning traces and teacher models; there is no guarantee that this reliability holds for traces from different models, domains, or languages. At 15% misclassification rate on individual edges, distribution-level metrics (transfer graph correlations, isomer divergence) could be meaningfully affected — systematic biases in the classifier (e.g., over-predicting Deep-Reasoning for certain linguistic patterns) could create spurious structural signatures.

More practically, the behavior annotation cost is non-trivial. Processing 20K trajectories, each with potentially hundreds of steps, through a 32B-parameter annotator model is computationally expensive — the paper does not report annotation throughput or cost. If a practitioner wants to estimate the transfer graph for a new teacher model (the prerequisite for Mole-Syn), they must first annotate thousands of teacher-generated traces before synthesis can begin. This annotation cost, like the teacher access requirement discussed above, is not accounted for in any of the paper's efficiency claims.

What evidence exists in the paper. Section 4.2 (Figure 6a-b) provides indirect evidence of annotation reliability by showing that the taxonomy captures meaningful representational differences in sparse auto-encoder features. Appendix C.2 reports the macro-F1 > 0.85 validation result. No experiment measures how annotation errors propagate to downstream analyses — e.g., how much does the estimated transfer graph change when labels are perturbed at a 15% rate? No experiment tests the annotator model's performance on traces from instruction-tuned LLMs (as opposed to strong reasoning models) or on non-math domains.

Mitigation status. Not addressed. The paper treats the annotation as a reliable instrument and does not discuss its failure modes, domain sensitivity, or practical cost. Section 10 acknowledges "label noise or bias will inevitably appear on estimated distributions" but offers no quantification or mitigation strategy.

---

The Hardest Problems Remain Unsolved — Test-Time Structural Amplification Cannot Create New Capability

The assumption or constraint. Across all experiments — distillation from strong reasoning teachers, Mole-Syn synthesis, reinforcement learning — the hardest mathematical reasoning problems (exemplified by AIME 2024, AIME 2025, and to some extent AMC 2023) show substantially lower absolute performance than easier benchmarks. For Llama-3.1-8B-Instruct trained on 20K OSS-distilled data (Table 1): MATH-500 reaches 60.80%, but AIME2024 reaches only 10.83%, AIME2025 reaches 7.71%. For Mole-Syn (Table 2, same backbone + OSS-Mole-Syn): MATH-500 reaches 51.80%, AIME2024 reaches 4.79%, AIME2025 reaches 1.04% (barely above the untrained baseline of 1.04%). The gap between synthetic and distilled data is largest on the hardest benchmarks — OSS-Mole-Syn captures ~67% of the OSS-Distill gain on average benchmarks, but only a small fraction of the gain on competition-level problems.

The consequence. This is the paper's most serious practical limitation and it parallels the finding in the reference example paper (Section 7) that test-time compute provides "essentially zero benefit" on the hardest problem difficulty bin. The molecular structure framework and Mole-Syn can amplify existing reasoning capability — taking a model that can sometimes reason correctly and teaching it to do so more reliably and with better structure — but they cannot create reasoning capability from scratch. If the base model (or the instruction-tuned synthesizer) fundamentally lacks the mathematical knowledge or deductive depth required for AIME-level problems, no amount of structural optimization will compensate. The paper is partially transparent about this: Appendix E notes that "for deep reasoning-heavy tasks (e.g., AIME), performance depended heavily on the model's intrinsic reasoning depth" and that Qwen-32B backbone outperforms both Qwen-7B and Llama-70B for such tasks.

The practical implication is that Mole-Syn and structural transfer are most useful for medium-difficulty problems — those within the base model's rough capability range where the bottleneck is reasoning organization rather than knowledge or raw deductive power. For the hardest problems, scaling the base model (pretraining) or distillation from substantially stronger teachers remains necessary, and the paper provides no path around this constraint.

What evidence exists in the paper. This limitation is visible in nearly every results table. Table 2: AIME2025 accuracy is 1.04% for OSS-Mole-Syn vs. 7.71% for OSS-Distill — the synthetic data provides essentially no benefit for this benchmark. Table 8 (RL results): even after RL, AIME2025 accuracy is 4.17% (QwQ-Distill + RL) and 3.33% (QwQ-Mole-Syn + RL). Appendix G (Figure 16) explicitly shows that "62.7% of AIME cases exhibited extended reasoning without reaching a clear conclusion" when exploration probability is too high — but the problem is not just exploration; even with balanced distributions, AIME performance remains low. Table 7's backbone analysis confirms the hierarchy: only the 32B synthesizer produces useful data for deep reasoning tasks, suggesting a fundamental capability floor.

Mitigation status. The paper acknowledges this limitation implicitly through its results but does not discuss it as a systematic constraint. Section 10 (Limitations) mentions "limited by cost and scale constraints, our analysis relies on a limited set of teacher models and student backbones" but frames this as a sampling limitation, not a capability ceiling. The paper does not provide guidance on when structural transfer will be insufficient and pretraining or stronger distillation is required — a practitioner has no way to predict, before investing in Mole-Syn, whether their target task difficulty exceeds the structural amplification ceiling.

---

Mixing Multiple Teacher Sources Is Destabilizing — But No Practical Compatibility Diagnostic Is Provided

The assumption or constraint. The conflict learning experiment (Section 5.2, Figure 11) demonstrates that mixing training data from two structurally incompatible semantic isomers (OSS and R1) degrades performance below either single-source baseline and prevents the model from converging to a stable behavior distribution (self-correlation drops below 0.8). The paper frames this as evidence of "structural incompatibility" and warns that "statistical similarity does not guarantee compatibility" (Takeaway 3). However, the paper does not provide a computable compatibility criterion — it shows that two specific isomers are incompatible, but offers no method for predicting whether two new isomers (from different teachers, domains, or data processing pipelines) will be compatible or not.

The consequence. This is a critical practical gap. A practitioner curating Long CoT training data from multiple sources — which is common in real-world distillation pipelines — has no way to determine whether their data mixture will succeed or produce structural chaos. The paper's primary diagnostic tool for structural similarity is the Pearson correlation between transfer graphs, but the incompatible isomers in the conflict learning experiment are correlated at $r \approx 0.9$ (Section 5.2) — correlation does not predict compatibility. The secondary diagnostic — self-correlation of the trained model's behavior distribution — can only be measured after training is complete, making it a post-hoc check rather than a pre-training filter.

The practical scope of this limitation is broad. The paper shows that even two highly capable teachers (OSS and R1, both producing individually effective isomers) cannot be combined. If this incompatibility is common — if most pairs of distinct reasoning teachers produce structurally incompatible isomers — then practitioners must either restrict themselves to single-teacher distillation (limiting data quantity and diversity) or risk performance degradation. Without a predictive compatibility test, the only option is trial and error: train on each candidate mixture and measure the outcome, which is expensive at scale.

What evidence exists in the paper. The conflict learning experiment tests exactly one isomer pair (OSS and R1) with three mixing strategies. Appendix Table 5 provides distillation results from three teachers (R1, OSS, QwQ) across eight student backbones, which could in principle be used to test whether any pair of teachers is mutually compatible — but the paper only tests pairwise mixing for OSS and R1. The ICL demonstration selection experiment (Figure 9) shows that structural matching at $r \gtrsim 0.9$ is sufficient for effective ICL-based distillation — but this is a different regime (single demonstration per example vs. mixed training data) and tests compatibility for demonstration selection, not for data mixture.

Mitigation status. Not addressed. The paper presents the incompatibility finding as a key insight but does not operationalize it into a diagnostic tool. Section 10 does not mention this gap. Future work on a computable structural compatibility measure — perhaps based on whether two transfer graphs can be simultaneously realized as the stationary distribution of a single Markov chain, or based on the geometry of the space of $4 \times 4$ stochastic matrices — would directly address this limitation, but none is proposed.

---

No Latency or Serial Dependency Analysis — Sequential Mole-Syn Generation Has Unstated Wall-Clock Costs

The assumption or constraint. Mole-Syn synthesizes Long CoT trajectories through a sequential random walk: at each step, the current behavior state is sampled from the transfer graph, a behavior-specific prompt is constructed (incorporating the original question and all previously generated steps), and the instruction-tuned LLM generates the next reasoning step. This process is inherently serial — each generation step depends on the full accumulated context from all previous steps, and the behavior sampling at step $t+1$ depends on the behavior at step $t$ (which must be produced by the LLM before the next sampling decision can be made). The paper measures compute cost solely in terms of "20K training examples produced" (Table 2) and does not report wall-clock time, latency, or the parallelizability of the synthesis process.

The consequence. For practitioners considering Mole-Syn as a data synthesis pipeline, the serial bottleneck is a practical concern that the paper's headline efficiency comparisons do not capture. Producing 20K synthetic Long CoT trajectories — each with potentially hundreds of sequential generation steps, each requiring a forward pass through a model of at least 7B parameters (based on Table 7's hierarchy, where weaker models fail) — represents a substantial wall-clock investment. In comparison, distillation from a strong teacher can generate all 20K trajectories in parallel if sufficient API quota or GPU capacity is available. The paper's claim that Mole-Syn enables "lower-cost behavior transfer" (Section 6) is based on the cost of not needing the teacher's reasoning traces, not on the synthesis cost itself — and if the synthesis cost (in wall-clock time and GPU hours) approaches or exceeds the cost of simply obtaining distillation data, the practical advantage diminishes.

This concern is compounded for the RL initialization results (Figure 12), where Mole-Syn data at 35K scale provides the strongest performance. Scaling up synthesis to 35K or larger datasets extends the serial generation wall-clock time proportionally. The paper does not discuss whether Mole-Syn generation can be parallelized — e.g., by generating multiple trajectories simultaneously on different GPU instances, each following its own independent random walk — or whether the per-trajectory serial dependency is fundamental.

What evidence exists in the paper. None. Synthesis throughput, latency, or computational cost (in FLOPs or GPU-hours) is not reported anywhere. Appendix E describes the algorithm and prompts but provides no timing or resource measurements. Table 7 compares synthesis backbones by downstream accuracy, not by synthesis speed or cost.

Mitigation status. Not addressed. The paper does not acknowledge latency or serial dependency as a trade-off. Section 10 (Limitations) mentions "limited by cost and scale constraints" in reference to the number of teacher models tested, not in reference to synthesis throughput. A simple remedy — reporting the average wall-clock time per synthetic trajectory and comparing it to the cost of obtaining a distilled trajectory — would substantially improve the practical guidance, but is absent.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a diagnostic reframing rather than a new architecture or training recipe, and that reframing has substantial practical and conceptual consequences. The core shift is from asking "what reasoning steps does this trajectory contain?" to "how are reasoning behaviors composed across the trajectory, and does this composition form a stable distribution?" This is not an incremental refinement — it changes what the field measures, what it optimizes, and what counts as an explanation for distillation failure.

The most immediate shift is in how distillation data quality is conceptualized. Prior to this work, the dominant quality heuristic for Long CoT training data was correctness and completeness: if the teacher produces correct step-by-step solutions, the data is good; more data and more diverse teachers are better. This paper demonstrates that correctness is necessary but not sufficient — what matters equally is whether the training data encodes a stable, self-consistent behavior transition distribution (the molecular structure). This explains a cluster of previously puzzling practitioner observations: why mixing high-quality reasoning traces from multiple strong teachers degrades performance (Figure 11: mixing OSS and R1 data drops accuracy from ~39% to ~32% despite their transfer graphs correlating at r ≈ 0.9), why small changes in distillation source can cause >10% accuracy swings (Table 1: OSS vs. R1 distillation on Llama-3.1-8B-Base yields 33.69% vs. 19.52%), and why human reasoning traces fail for distillation despite being correct and complete (Figure 4). Each of these was previously treated as a separate puzzle; the molecular structure framework provides a unified mechanism — structural incompatibility of semantic isomers — that explains them all.

The paper also recasts the problem of data synthesis. The standard approach to building Long CoT training data has been output imitation: prompt a strong reasoning teacher, collect its traces, fine-tune. This creates a dependency on access to capable (and often proprietary) reasoning models. Mole-Syn demonstrates that the structural skeleton of effective Long CoT — the 4 × 4 behavior transition matrix — is separable from the surface text of any particular teacher's reasoning traces, and that this skeleton alone is sufficient to guide instruction-tuned LLMs in synthesizing effective training data from scratch. This is a genuinely new capability: it shows that the "reasoning know-how" that makes Long CoT learnable can be represented as a compressed structural signal (20 numbers in a transition matrix) rather than as terabytes of teacher-generated text. The practical consequence is that organizations without ongoing API access to proprietary reasoning models can still produce effective Long CoT training data, provided they can estimate a transfer graph once from any accessible strong reasoning model.

A less obvious but equally important shift concerns the status of surface-level imitation in reasoning research. The paper's keyword replacement experiment (Figure 6c) — showing that models trained with all discourse markers replaced by alternatives achieve comparable Long CoT performance given sufficient data — effectively falsifies the hypothesis that surface lexical patterns are the vehicle for reasoning transfer. Combined with the sparse auto-encoder analysis (Figure 6a-b, showing that the SFT process carves out dedicated representational capacity for discourse-control transitions), this establishes that what is learned during Long CoT fine-tuning is genuinely structural: the model acquires an internal organization of reasoning behaviors, not a bag of keyword-triggered heuristics. This should shift research attention from designing better prompts and keyword sets toward designing better structural configurations — the transfer graph becomes the optimization target, not the lexical surface.

The paper also resolves a tension in the self-correction and exploration literature. Prior work was divided: some studies found that LLMs can self-correct and benefit from iterative refinement [17, 18], while others found that self-correction fails on reasoning tasks [Huang et al., 2023]. The molecular structure framework reconciles these findings through the lens of structural balance. Self-reflection (the mechanism underlying self-correction) is effective when it is distributed appropriately within the reasoning trajectory — following deep reasoning to verify extended chains, interspersed with exploration to avoid premature convergence — and ineffective when it dominates (causing "overthinking" on easy problems, Appendix G, Figure 16) or is absent (allowing drift on hard problems). The conflicting prior results were likely sampling different regions of this structural space without controlling for behavior transition distribution. The paper's bond proportion analysis (Appendix G) provides a concrete mechanism for this reconciliation: performance peaks at a balanced distribution of behaviors, not at the maximum of any single type.

Finally, the paper's analysis of summarization as a structural disruption mechanism (Section 8, Figure 14) provides a mechanistic account of why private LLM providers can expose "thinking" content without enabling effective distillation. This has policy and commercial implications: it suggests that the current practice of hiding or compressing reasoning traces is not just about reducing output length or protecting specific reasoning content, but about disrupting the structural coherence that makes Long CoT learnable. The transfer graph of summarized traces (Figure 14b) is visibly different from the full trace graph, and the bond energy separation collapses (Figure 14c: q·k values drop from 61.20/34.44/16.87 to 15.97/12.13/4.50). This provides a quantifiable metric for how much structural information is lost through summarization, which could inform both protection strategies and attempts to reconstruct reasoning capabilities from compressed outputs.

Research directions that become more attractive: The paper makes structural analysis of reasoning trajectories — transfer graph estimation, isomer comparison, geometric embedding — a first-class research activity rather than a supporting measurement. It also elevates data synthesis from imitation toward controlled structural generation, opening a design space of transfer-graph-guided data production. Research on prompt engineering for reasoning style becomes less attractive, since the keyword replacement experiment shows surface form is not causal; research on structural composition and compatibility becomes more attractive, since the isomer incompatibility finding shows these are the operative variables.

Research directions that become less promising: Simple "more data, more diverse teachers" approaches to scaling Long CoT training are undercut by the isomer incompatibility finding. If mixing structurally incompatible sources actively degrades performance (Figure 11), scaling data quantity without controlling structural coherence is counterproductive. Approaches that focus on improving per-example correctness (filtering out wrong answers) without considering structural distribution may hit a ceiling where correctness is high but structural incompatibility prevents learning. The paper's results suggest that a smaller, structurally coherent dataset (single isomer, 20K examples) can outperform a larger, structurally noisy dataset (mixed isomers, also 20K examples, but with degraded performance), which inverts the usual scaling assumption.

---

Follow-Up Research This Work Enables

A computable structural compatibility criterion for reasoning data mixtures. The paper's most striking finding — that statistically near-identical behavior distributions (r ≈ 0.9) can be structurally incompatible when mixed — is demonstrated for exactly one isomer pair (OSS and R1) with no predictive diagnostic. The immediate question is: given two transfer graphs P₁(b'∣b) and P₂(b'∣b), can we predict whether a model trained on their mixture will converge to a stable behavior distribution or exhibit structural chaos? A promising direction is to model the student's learned behavior distribution as the stationary distribution of a Markov chain whose transition matrix is a convex combination of the teacher distributions, and to test whether the spectral gap (the difference between the first and second eigenvalues) predicts convergence stability. The hypothesis would be: when P₁ and P₂ are close in total variation but their mixing produces a transition matrix with a small spectral gap, the model will exhibit slow convergence and distributional instability (analogous to the self-correlation < 0.8 observed in Figure 11d). A strong follow-up would compute this metric for a range of isomer pairs (not just OSS–R1, but also R1–QwQ, OSS–QwQ, and mixtures with human or ICL-generated traces) and test whether the spectral gap predicts downstream accuracy degradation. The paper already provides the necessary infrastructure: the transfer graph estimation pipeline (Appendix C.2), the behavior annotation prompts, and the mixing experiment design (Appendix D.4). The key measurement would be: for each isomer pair, compute the spectral gap of the mixed transition matrix and correlate it with the accuracy drop relative to single-isomer training.

Transfer graph generalizability across domains and teacher models. The paper validates the cross-model stability of transfer graphs for exactly three reasoning models (R1, OSS, QwQ) on exactly one corpus (OpenThoughts-3, which is mixed-domain but treated as a single distribution). The natural stress test is: does the same stable transfer graph emerge for code generation traces, scientific reasoning traces, or multi-step planning traces? And does it emerge for non-Transformer architectures or for models trained with different objectives (e.g., outcome-supervised vs. process-supervised)? A strong follow-up would annotate Long CoT traces from at least two additional domains (e.g., code generation on SWE-bench-style tasks, scientific QA on GPQA-style tasks) and at least two additional model families (e.g., Gemini-2.5-Pro-Thinking with its compressed thinking, Claude-4-Sonnet, or a process-reward-model-trained variant) and measure transfer graph correlations both within and across domains. The paper's finding that Gemini and Claude traces are ineffective for distillation (Table 3, with accuracy below untrained baselines) already suggests their transfer graphs will differ — quantifying this difference would anchor the claim that the stable transfer graph is a property specifically of effective Long CoT reasoning. A critical negative result would be if different domains exhibit different stable transfer graphs — this would imply that Mole-Syn requires domain-specific graph estimation, constraining its practicality. A critical positive result would be if the same graph works across math, code, and science, implying a genuinely universal structural signature.

Causal interventions on behavior transitions during inference to test bond shaping functions. The paper's geometric analysis (Section 7, Figure 13) demonstrates correlation between bond types and semantic space transformations (deep reasoning densifies, exploration expands, reflection stabilizes), but does not establish causation. A strong follow-up would intervene during inference: given a model trained to produce Long CoT, force the model to replace exploration transitions with deep reasoning (or vice versa) at specific points in the trajectory and measure the effect on solution quality, reasoning length, and geometric properties of the resulting trajectory in semantic space. This could be implemented by modifying the sampling logits or by inserting control tokens that bias the model toward or away from specific behavior types (analogous to classifier-free guidance). The specific hypothesis to test: does forcing additional self-reflection on easy problems cause the performance degradation that the correlation analysis predicts (the "overthinking" phenomenon from Appendix G)? Does removing exploration on hard problems cause the model to converge to incorrect solutions more frequently? These interventions would transform the molecular structure from a descriptive framework into a causal one, and would directly test whether the bond types play the functional roles the paper claims.

Difficulty-adaptive structural allocation during synthesis or inference. The paper's bond proportion analysis (Appendix G, Figure 16) shows that the optimal behavior distribution depends on problem difficulty: easy problems benefit from less reflection (to avoid overthinking) and more direct deep reasoning, while hard problems require balanced exploration and reflection. However, Mole-Syn uses a single fixed transfer graph for all problems during synthesis. A natural extension is to estimate difficulty-conditioned transfer graphs P(b' ∣ b, difficulty) by stratifying the teacher's traces by problem difficulty (using pass@1 or a simpler proxy) and learning separate transition matrices for each difficulty bin. During synthesis, the difficulty of each problem would be estimated (via a lightweight classifier or via the instruction model's initial output entropy), and the appropriate transfer graph would guide generation — allocating more exploration to hard problems and more direct reasoning to easy ones. This would be the structural analog of the compute-optimal test-time scaling in the reference example paper: just as that work adaptively allocates inference compute between search methods based on difficulty, this extension would adaptively allocate reasoning behavior based on difficulty. The paper already provides the necessary tools (transfer graph estimation, behavior-guided synthesis) and the motivating evidence (Figure 16's difficulty-dependent optimal proportions). The key measurement would be whether difficulty-conditioned Mole-Syn outperforms uniform Mole-Syn on benchmarks with heterogeneous difficulty (like MATH-500, which spans multiple difficulty levels), and whether the improvement is largest on the easiest and hardest problems (where uniform allocation is most mismatched).

Scaling laws for structural coherence vs. data quantity in Long CoT learning. The paper shows that 20K structurally coherent examples (single-isomer distillation) outperform 20K structurally incoherent examples (mixed isomers), but it does not explore how this tradeoff scales with data quantity. The critical question: if you have 100K structurally noisy examples (mixed from multiple teachers), do they eventually outperform 20K structurally clean examples, or does the structural noise impose a permanent ceiling? This is the difference between a data-inefficiency problem (noise slows learning but can be overcome with scale) and a structural incompatibility problem (noise prevents convergence to any stable configuration, regardless of scale). A strong follow-up would replicate the conflict learning experiment (Figure 11) at multiple data scales — 10K, 20K, 50K, 100K, 200K — for both single-isomer and mixed-isomer training, and track both accuracy and behavior distribution self-correlation. If self-correlation remains below 0.8 for the mixed condition even at 200K scale, that confirms a fundamental incompatibility ceiling. If self-correlation rises above 0.9 at some scale, that suggests the model can eventually reconcile conflicting structural signals given enough data. The paper's existing infrastructure (transfer graph estimation, self-correlation measurement, the OSS–R1 isomer pair) makes this a straightforward scaling experiment whose outcome would substantially refine the practical guidance for data curation: it would tell practitioners whether they should invest in structural curation (if incompatibility is fundamental) or simply scale up (if it's a data efficiency issue).

Applying Mole-Syn to non-mathematical reasoning domains with domain-specific behavior taxonomies. The paper's behavior taxonomy (Deep-Reasoning, Self-Reflection, Self-Exploration, Normal Operation) was designed for mathematical reasoning and validated only on math benchmarks. It is an open question whether the same four categories capture the structural dynamics of code generation (which involves debugging cycles, refactoring, test-driven development), scientific reasoning (which involves hypothesis generation, evidence weighing, uncertainty quantification), or multi-agent debate and negotiation. A productive follow-up would develop domain-specific behavior taxonomies using the same methodological template: (1) identify candidate behavior categories from analysis of strong model traces, (2) develop an annotation prompt with operational definitions and decision rules, (3) validate against human annotations at macro-F1 > 0.85, (4) estimate transfer graphs and test cross-model stability. For code generation, candidate categories might include: plan-then-implement (analogous to deep reasoning), debug-and-fix (analogous to self-reflection), explore-alternative-implementations (analogous to self-exploration), and test-verify (a new category). The key measurement would be whether a stable transfer graph emerges for each domain, whether it differs from the math transfer graph, and whether Mole-Syn guided by a domain-specific graph improves performance on domain-specific benchmarks (HumanEval, SWE-bench, GPQA). A negative result — no stable transfer graph emerges, or the graph does not predict distillation success — would bound the generality of the molecular structure framework. A positive result would open up code and science as domains for structural synthesis.

---

Practical Applications and Downstream Use Cases

Cost-effective Long CoT training data synthesis for organizations without ongoing access to proprietary reasoning APIs. The most direct application of Mole-Syn is replacing distillation from expensive or access-restricted strong reasoning teachers with synthesis guided by a one-time-estimated transfer graph. Concretely, an organization with access to an open-weight instruction-tuned LLM (e.g., Qwen-2.5-32B-Instruct, which Mole-Syn Table 7 shows is an adequate synthesizer) and a one-time budget to estimate a transfer graph from any accessible strong reasoning model could generate an effectively unlimited quantity of structurally coherent Long CoT training data. The paper's numbers: for Llama-3.1-8B-Instruct, Mole-Syn synthesized data achieves 32.29–32.40% average accuracy compared to 39.27% for direct OSS distillation — capturing ~67–82% of the distillation gain without requiring per-example teacher API calls. For deployments where the target problem distribution skews toward medium difficulty (GSM8K, MATH-500, AMC 2023), the absolute accuracies are competitive: OSS-Mole-Syn achieves 83.24% on GSM8K and 51.80% on MATH-500 (Table 2). The cost savings scale with the volume of training data needed — the transfer graph estimation cost (annotating ~20K teacher traces) is fixed, while the synthesis cost scales linearly with desired data quantity but uses only the instruction-tuned LLM, not the reasoning teacher.

Structural quality control for Long CoT data curation pipelines. Organizations building Long CoT training datasets from multiple sources (different teachers, different domains, filtered web data, human annotations) can use the transfer graph and self-correlation metrics as quality control tools. The workflow: (1) estimate the transfer graph for each candidate data source or subset, (2) measure cross-source transfer graph correlations, (3) exclude sources whose transfer graphs are structurally incompatible with the primary source (based on a compatibility threshold — although the paper does not provide this threshold, the conflict learning experiment suggests that mixing sources with r ≈ 0.9 can be destabilizing, so a conservative threshold might be r > 0.95), and (4) after training, measure the student model's self-correlation as a diagnostic for whether structural convergence occurred. The paper's numbers provide concrete warning signs: self-correlation dropping below 0.8 (Figure 11d) indicates structural chaos and predicts accuracy degradation. This transforms data curation from a subjective process ("these traces look high-quality") to a measurement-driven one ("these traces share a compatible structural configuration, and the trained model exhibits stable behavior distribution self-correlation > 0.9").

RL initialization with synthetic Long CoT data for more stable and sustained improvement. The paper's RL results (Figure 12, Table 8) show that models initialized with Mole-Syn-synthesized Long CoT weights exhibit more stable reward curves and more sustained improvement across 1,000 RL steps compared to distillation-initialized models. For Llama-3.1-8B-Instruct, QwQ-Mole-Syn initialization (35K) + RL achieves 39.51% average, essentially matching QwQ-Distill + RL (39.72%) — but the synthetic initialization uses no teacher reasoning traces. More importantly, the Mole-Syn-initialized RL curves (Figure 12b–c) have less variance and continue improving where distillation-initialized curves plateau. This suggests that for practitioners using RL to optimize reasoning models (via DAPO or similar frameworks), Mole-Syn initialization may provide a more reliable foundation than distillation, with the additional benefit of not requiring access to the teacher's reasoning traces at scale. The specific recipe: estimate transfer graph from accessible strong reasoning model → synthesize 35K+ traces using an instruction-tuned LLM as backbone → SFT on synthetic data → RL with DAPO. The paper provides all necessary hyperparameters (Appendix E.2).

Diagnosing and repairing failed distillation pipelines. When a distillation pipeline produces unexpectedly poor results — a common occurrence given the isomer fragility the paper documents — the molecular structure framework provides diagnostic tools. A practitioner can: (1) annotate a sample of the training data for behavior transitions, (2) estimate the transfer graph and compare it to the stable configuration from any strong reasoning model (Figure 5 provides reference graphs), (3) measure self-correlation to check whether the training data's own behavior distribution is internally consistent, and (4) if the transfer graph deviates substantially or self-correlation is low, use Mole-Syn to synthesize replacement data that matches the stable configuration. The paper's ICL demonstration selection experiment (Figure 9) provides proof of concept: when demonstrations are selected to match the target behavior distribution (r ≳ 0.9), ICL-based distillation succeeds where random or mismatched demonstrations fail. This diagnostic approach transforms distillation failures from mysterious black-box outcomes into tractable structural problems that can be measured and corrected. The annotation prompt and transfer graph visualization code are fully specified in the appendices, making the diagnostic pipeline reproducible.