Agentic-R1: Distilled Dual-Strategy Reasoning

Pranjal Aggarwal; Sean Welleck; Weihua Du; Yiming Yang

REVIEW 4 major objections 6 minor 22 references

Agentic-R1: Distilled Dual-Strategy Reasoning

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A distilled 7B model learns to choose between writing code and reasoning in text for each math problem, and beats same-size single-strategy baselines on computation-heavy benchmarks.

desk verdict Real distillation idea, but the implemented trajectory composition does not match the claimed correction mechanism; still deserves a referee for the data and the core method. read the letter →

arxiv 2507.05707 v2 pith:BJWLOCZC submitted 2025-07-08 cs.CL cs.AIcs.LG

Weihua Du , Pranjal Aggarwal , Sean Welleck , Yiming Yang This is my paper

classification cs.CLcs.AIcs.LG

keywords multi-teacherdistillationtool-augmentedreasoninglongchain-of-thoughtstrategyselectionmathematicalself-distillationtrajectorycomposition

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

DualDistill is a fine-tuning recipe for teaching one language model two complementary ways to solve math problems: writing text-based reasoning, and writing code that is executed by an interpreter. The paper claims that a 7B student trained on composed trajectories from a tool-using teacher and a text-reasoning teacher learns to choose which strategy fits each query, and that this choice improves accuracy on computation-heavy benchmarks while staying competitive on standard ones. The trained model, Agentic-R1, invokes code tools on most combinatorial or large-number problems and reasons in text on abstract ones, and a self-distillation stage pushes accuracy higher still. The point of the work is that strategy selection can be distilled, rather than learned by reinforcement or hand-coded.

What carries the argument

The carrying mechanism is trajectory composition with a rule-based correctness gate. Two teacher policies—one agentic/tool-using and one text-reasoning—generate solutions y1 and y2; a grader assigns binary scores g1 and g2, and the pair falls into one of four composition cases, with hand-written transition segments t−+ or t++ inserted between solutions when both appear. Loss masking removes failed segments so the student learns only from the successful portion. A second mechanism, self-distillation, samples K student trajectories per problem and, using thresholds $\beta_1$ and $\beta_2$, adds either a correct student trajectory plus a teacher verification or an incorrect trajectory plus a corrected teacher solution to a replay buffer for another fine-tuning round.

What would settle it

Run the same DualDistill pipeline with the second teacher actually conditioned on the first solution, $\pi(\cdot \mid x, y_1)$, and compare DeepMath-L and Combinatorics300 accuracy against the paper's independent-sampling version; if the conditioned pipeline does not improve on the independent one, the correction signal in the composed trajectories is not doing the claimed work.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that trajectory composition lets a unified student inherit heterogeneous reasoning strategies from two teachers without an explicit router. For each training problem, the two teachers produce solutions y1 and y2; a rule-based grader marks each correct or wrong, and the trajectories are concatenated in a fixed pattern—wrong-then-right becomes a correction example, right-then-right becomes a verification pair, right-then-wrong keeps only the correct trajectory, and wrong-then-wrong is discarded. Fine-tuned on about 2.6k such composed traces, the 7B student learns to switch mid-problem when a strategy is failing, and on the paper's benchmarks it beats same-size single-strategy baselines on the computation-heavy subsets, with further gains from self-distillation. The paper interprets the learned switching behavior as evidence that the student has internalized when tools and when text are the better strategy.

Load-bearing premise

The load-bearing premise, stated in the appendix, is that the second teacher's solution can be sampled without conditioning on the first solution, so a “correction” trajectory is really two independent attempts concatenated; if conditioning on the failed attempt is what would make a correction example useful, the composition gains may not survive.

Editorial extensions

If this is right

A single 7B model can internalize strategy selection from supervised fine-tuning alone, with no explicit router or reinforcement-learning stage.
Computation-heavy benchmarks need not be ceded to tool-only or text-only systems; a student of the same size as either specialist can beat both by choosing per query.
The learned choice is selective in practice: tool use appears in 79.2% of Combinatorics300 problems but only 52.0% of AMC problems.
Self-distillation strengthens the student further even when the teacher's correction is restricted to text-only solutions.
Composition itself, not just the presence of two teachers, is what drives the gain: the composition ablation beats the no-composition ablation on every reported benchmark.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Editorial inference: because the implementation samples y2 independently of y1, the wrong-then-right composed trajectories demonstrate “abandon a failing strategy and start fresh” rather than “repair the specific error”; a version where the second teacher actually reads y1 might teach true correction and could perform differently.
Editorial inference: the strategy-selection signal is likely tied to the student's pretraining, which already mixes code and text; on a model that has not seen both modalities, 2.6k trajectories may teach imitation rather than selection.
Editorial inference: the reported efficiency gain could be partly an artifact of the token-budget truncation used on the first teacher, since “Accuracy at Budget” rewards any correct answer that appears before the budget.
Editorial inference: the same composition idea could be applied to more than two teachers—say search, proof assistants, or vision tools—with the correctness gate deciding which trajectories to concatenate.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Two things to know. First, the core idea is genuinely new: distill a 7B student from two heterogeneous teachers (a tool-augmented agent and a pure text reasoner) by composing their trajectories based on correctness, then self-distill. They release code and data, and the results on arithmetic-heavy benchmarks are consistently positive. Second, the mechanism described in the main text is not what was actually run. Section 3.1 and Algorithm 1 write y2 ~ pi(·|x,y1), but Appendix A.4.2 explicitly sets pi(·|x,y1)=pi(·|x), so the second teacher samples independently and never sees y1. That makes the 1,393 (g1=0,g2=1) 'correction' trajectories not corrections at all—they are independent failures and successes stitched together with a hand-written transition. The student may still learn something useful from these demonstrations, but the specific claim that the second teacher corrects the first is untested, and the composition ablation in Table 2 does not separate conditioned from independent sampling.

What the paper does well: the training-data curation (filtering for problems where one strategy has an advantage) is sensible; the self-distillation stage is a nice addition and gives consistent gains; and the qualitative examples in Figures 6 and 7 do show the student switching strategies, which is evidence that the distillation signal, even if not the claimed correction, teaches the intended behavior. The related work is thorough and correctly identifies the gap: prior tool-augmented reasoning uses RL or homogeneous teachers.

Soft spots beyond the conditioning issue: the evaluation is thinner than the claims. DeepMath-L is 87 problems, Combinatorics300 is 300, and there are no error bars or significance tests. The large-answer filter (>1e5) overlaps with the training-set heuristic (>1000), so the headline gains are partly built into the benchmark choice. The MATH500 drop at the standard budget is acknowledged but not analyzed. These are fixable.

The conditioning discrepancy is the load-bearing weakness. If the authors had actually conditioned y2 on y1, the paper would be stronger. As it stands, the empirical finding that a 7B student can learn to invoke tools vs. reason from SFT on 2.6k composed trajectories is still interesting and worth publishing—with the mechanism caveat made explicit and a real experiment comparing conditioned vs. independent sampling.

For a reading group, I'd bring it to discuss the gap between what we write in papers and what we run. I would cite it as a distillation method for heterogeneous teachers, not for the correction mechanism. Send to peer review: yes, with a request for statistical rigor and the conditioned-sampling test.

Referee Report

4 major / 6 minor

Summary. The paper proposes DualDistill, a framework that distills two complementary teacher policies—an agentic tool-use teacher (OpenHands) and a text-reasoning teacher (DeepSeek-R1)—into a 7B student (DeepSeek-R1-Distill-7B). Trajectories from both teachers are composed based on the correctness of their solutions, with hand-written transition segments, and the student is further refined by self-distillation. The resulting model, Agentic-R1, is evaluated on two computation-intensive benchmarks (DeepMath-L, Combinatorics300) and three standard math benchmarks (MATH500, AIME, AMC), reporting improvements over same-size single-strategy baselines and showing adaptive tool-use rates across tasks.

Significance. If the empirical results hold, the paper offers a simple, SFT-based alternative to reinforcement-learning approaches for unifying tool use and long-CoT reasoning, with public code and data that support reproducibility. The qualitative examples and tool-usage statistics suggest the student learns a nontrivial per-query strategy switch from a relatively small (2.6k) curated training set. However, the core mechanism of 'correction' via trajectory composition is undercut by the implementation described in the appendix, and the benchmark evidence, especially on DeepMath-L, has no statistical support. The ideas are worth pursuing after the implementation/description gap is resolved and the evidence is strengthened.

major comments (4)

[Section 3.1 / Algorithm 1 / Appendix A.4.2] Section 3.1 and Algorithm 1 specify that the second teacher samples y2 ~ pi(·|x, y1), conditioned on the first solution y1, and the paper describes the (g1=0, g2=1) case as 'the second teacher successfully corrects it.' Appendix A.4.2, however, explicitly overrides this: 'we assume conditional independence and explicitly define the teacher model inference policy as pi(· |x, y1) = pi(· |x).' As a result, 1,393 of the 2,678 training trajectories (Table 3) in the (g1=0, g2=1) category are not demonstrations of the second teacher correcting the first; they are independent successes paired with independent failures. The central claim that composed trajectories teach the student to correct errors is therefore untested. The authors should either implement the conditioned sampling described in the main text or revise the method description and the interpretation of the ablation in Table 2, ideally adding an experiment that directly compares independent sampling with conditioned sampling.
[Appendix A.2] Appendix A.2 states that trajectory segments occurring before a transition from incorrect to correct reasoning (t−+) are omitted from the loss calculation. This means that in (0,1) trajectories, the student never sees the first teacher's erroneous solution, because the loss covers only the transition and the second solution. Even if the second teacher had been conditioned on y1, the loss would not expose the model to the error it is supposed to learn to recover from. This undercuts the claimed 'correction' supervision and should be reported and analyzed explicitly.
[Table 1 / Section 4.4] Table 1 reports results 'averaged over 5 seeds' but gives no error bars, standard deviations, or significance tests. The headline gain on DeepMath-L at budget L is 59.3% vs 56.3% (a difference of about 2.6 problems on 87 problems) and on Combinatorics300 is 49.4% vs 44.5% (a difference of about 15 problems on 300). Without variance estimates, the claim of 'substantial performance improvements' is not supported. At minimum, the authors should report per-seed results and confidence intervals or a significance test for the main comparisons.
[Section 4.1 / Appendix A.3.1] Section 4.1 constructs the DeepMath-L evaluation set by selecting problems with answers whose absolute value exceeds 1e5, while Appendix A.3.1 uses a similar numerical-scale heuristic (answers exceeding 1,000) to build the agentic-favored training subset. The reported gain on DeepMath-L may therefore reflect distributional alignment with the training selection rather than a general capability for computation-intensive problems. The authors should demonstrate robustness on an independently constructed large-answer benchmark or explicitly discuss this selection overlap and its implications.

minor comments (6)

[Abstract] The abstract claims the method 'improves accuracy across a range of tasks,' but Agentic-R1 without self-distillation is 3.1 points below DeepSeek-R1-Distill on MATH500 at the standard budget (80.0 vs 83.1 in Table 1); the wording should be softened to 'improves accuracy on computation-intensive tasks while remaining competitive on standard benchmarks,' as the limitations section acknowledges.
[Table 1 / Fig. 4] The 5-seed averages are reported without error bars or standard deviations in Table 1 and in the budget curves of Fig. 4; adding variance information would greatly strengthen the presentation.
[Section 4.4] The text says the student improves 'from 44.7% to 50.9%' on Combinatorics300, but Table 1 lists the DeepSeek-R1-Distill-7B baseline as 44.5% at the large budget; the numbers should be unified.
[Fig. 2] The inference prompt in Fig. 2 uses 'brown' to highlight tool-specific instructions, which will not be visible in grayscale; please use a different visual marker (e.g., bold or a box).
[Related Work (Section B)] The claim of being 'the first framework to employ distillation with trajectory composition from two heterogeneous teacher models' is stronger than necessary; consider 'we are not aware of' or restrict the claim to the specific setting of tool-augmented versus text-reasoning teachers.
[Section 3.4 / Appendix A.2] The hyperparameters beta1, beta2, K, and the random first-teacher inference budget L0 are not subjected to a sensitivity analysis; a brief robustness check would increase confidence that the reported behaviors are not artifacts of a particular threshold choice.

Circularity Check

2 steps flagged · score 3.0 of 10

No fitted prediction or load-bearing self-citation, but the DeepMath-L benchmark reuses the training-set's answer-magnitude heuristic and the implemented trajectory composition drops the conditional dependence claimed in the method.

other [Section 4.1 (DeepMath-L) and Appendix A.3.1 (Problem Filtering Heuristics)]
"We curate a subset of 87 problems with large answers (absolute value greater than 105). These problems are excluded from our fine-tuning data, although they may appear in some pretraining corpora. We refer to this evaluation set asDeepMath-L, with the assumption that code-aided computation is more effective in solving such problems."

The agentic-favored training subset is selected by the same numerical-scale heuristic: 'Problems whose final integer answers exceed an absolute value of 1,000 often require nontrivial arithmetic operations or algorithms that are more suitable for tool-assisted computation' (A.3.1). The evaluation benchmark is constructed from the same property used to select the training distribution, so the reported gain on DeepMath-L partially re-measures the selection criterion rather than independently validating dynamic strategy selection. This is not a fitted parameter, but the benchmark is not an independent probe of the mechanism.
other [Appendix A.4.2 (Trajectory Composition Implementation), contrasted with Section 3.1 and Algorithm 1 lines 6-7]
"To avoid performance degradation of y2 due to potential contamination from combined inputs, we assume conditional independence and explicitly define the teacher model inference policy as π(· |x, y1) = π(· |x)."

Section 3.1 specifies y2 ∼ (1−z)πA(·|x,y1)+zπR(·|x,y1) and describes the (0,1) case as 'the second teacher successfully corrects it.' Appendix A.4.2 defines away the conditioning, so y2 is generated from the problem alone. The 'correction' trajectories (1,393 of 2,678 examples) are therefore independent solution pairs by construction; the claimed mechanism of conditional correction is not implemented and is not tested by the composition ablation. This is a definitional mismatch rather than a fitted prediction, but it makes the central compositional claim equivalent, by construction, to concatenating two unconditioned samples.

full rationale

The paper's headline accuracy numbers are measured on held-out benchmarks (DeepMath-L, Combinatorics300, MATH500, AIME, AMC) with no parameter fitted to produce those numbers; no step in the derivation chain fits a variable to the target result and then presents it as a prediction. Self-citations in related work (L1, LeanStar, scaling laws) are background and do not carry the argument. Two concerns prevent a score of 0. First, DeepMath-L is curated using the same answer-magnitude criterion that defines the agentic-favored training subset, so the benchmark's difficulty hypothesis is not independent of the training-data construction; part of the gain may reflect distributional overlap rather than strategy-switching behavior. Second, the implementation in Appendix A.4.2 explicitly replaces the conditional sampling π(·|x,y1) with π(·|x), directly contradicting Section 3.1 and Algorithm 1. The 1,393 '(0,1)' correction trajectories are therefore not corrections in the conditional sense claimed. This is a correctness and reproducibility problem, not a circular derivation of the accuracy results, and for that reason it is flagged as 'other' rather than counted as full circularity. Overall, the empirical comparisons remain self-contained and externally benchmarked, so the paper does not exhibit the fitted-input or self-citation circularity that would warrant a score of 6 or above; the moderate self-reference in benchmark construction and the definitional mismatch cap the score at 3.

Assumptions & free parameters 7 free parameters · 4 assumptions · 0 invented entities

The central claim rests on the reliability of the rule-based grader, on the independence assumption for the second teacher, on the large-answer heuristic that shapes both training and evaluation sets, and on the prior capabilities of the student base model. The training and evaluation design introduces hand-chosen thresholds and hyperparameters that are not fitted to independent data.

free parameters (7)

beta1 (self-distillation lower threshold) = 0
Problems with average correctness g_bar > beta1 are selected with a correct student trajectory plus teacher verification. Chosen by hand to encourage diversity.
beta2 (self-distillation upper threshold) = 0.9
Problems with average correctness g_bar < beta2 are selected with an incorrect student trajectory plus teacher correction. Chosen by hand.
K (self-distillation samples per problem) = 16
Number of student trajectories sampled per problem to estimate average correctness. Hand-chosen.
L0 (random inference budget for first teacher) = not specified in text
A random token budget is imposed on the first teacher's inference; if not completed within the budget, the attempt is labeled unsuccessful. The distribution of L0 is not specified, but it affects composition labels.
Agentic-favored numerical scale threshold = 1000
Problems whose final integer answer exceeds 1000 are classified as tool-beneficial for training selection. Chosen by hand in Appendix A.3.1.
DeepMath-L answer magnitude threshold = 10^5
The evaluation set DeepMath-L is curated to include only problems with answers greater than 1e5, assumed to favor code-aided computation. Same large-answer heuristic as the training filter.
Transition segments t-+, t++ = hand-written sentences
Hand-designed sentences connecting strategies (Table 4). They shape the training text and student output style; the paper acknowledges manual transitions as a limitation.

assumptions (4)

domain assumption Rule-based grader G assigns correct and incorrect labels reliably
The composition of training trajectories and all reported accuracies depend on exact-match plus MathVerify fuzzy matching being correct (Section 3.1, Section 4.3, Appendix A.6).
ad hoc to paper Second teacher can be treated as independent of the first teacher's solution
Appendix A.4.2 sets pi(·|x, y1)=pi(·|x), so composed 'correction' trajectories are concatenated independent attempts, not real corrections. This contradicts the main-text notation and is load-bearing for the composition claim.
domain assumption Large answer magnitude is a valid proxy for tool benefit
Used to construct the agentic-favored training subset and the DeepMath-L evaluation set (Section 4.1, Appendix A.3.1). Not empirically validated as a causal criterion.
domain assumption Student base model is already proficient in both text reasoning and code generation
The paper argues 2.6k examples suffice only because DeepSeek-R1-Distill-7B was pretrained on both modalities (Section 3.3, Limitations). If false, the method's data efficiency claim fails.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Agentic-R1: Distilled Dual-Strategy Reasoning." pith.science (2026). https://pith.science/paper/BJWLOCZC

@misc{pith2026250705707,
  author       = {Pith},
  title        = {Pith review of: Agentic-R1: Distilled Dual-Strategy Reasoning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BJWLOCZC}},
  note         = {Machine review of arXiv:2507.05707}
}

read the original abstract

Current long chain-of-thought (long-CoT) models excel at mathematical reasoning but rely on slow and error-prone natural language traces. Tool-augmented agents address arithmetic via code execution, but often falter on complex logical tasks. We introduce a fine-tuning framework, DualDistill, that distills complementary reasoning strategies from multiple teachers into a unified student model. Using this approach, we train Agentic-R1, which dynamically selects the optimal strategy for each query, invoking tools for arithmetic and algorithmic problems, and using text-based reasoning for abstract ones. Our method improves accuracy across a range of tasks, including both computation-intensive and standard benchmarks, demonstrating the effectiveness of multi-strategy distillation in achieving robust and efficient reasoning. Our project is available at https://github.com/StigLidu/DualDistill

Figures

Figures reproduced from arXiv: 2507.05707 by the authors.

**Figure 1.** Overview of DualDistill. We distill knowledge from two complementary teacher models. Trajectories from teachers are composed based on correctness, enabling the student model to learn when and how to select the appropriate strategy for each problem. Furthermore, the student internalizes these strategies through self-distillation. The resulting agentic trajectories are effective for tool-intensive tasks, but often … view at source ↗

**Figure 2.** Inference Prompt. The system prompt used to guide the model during inference. Instructions highlighted in brown indicate guidance specific to tool usage. Meaning Content tool (×) → text (✓) Wait, the code is not correct, let’s try text reasoning. text (×) → tool (✓) Wait, use text reasoning is too tedious, let’s try code reasoning. A (✓) → B (✓) Wait, we can also use {B}-reasoning as an alternative way to verify the… view at source ↗

**Figure 3.** The average accuracy across benchmarks un [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗

Figures from the paper (4 more)

**Figure 4.** Figure 4: Performance trend of different tested models [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]

**Figure 5.** Figure 5: An example agentic trajectory derived from OpenHands. 11 [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]

**Figure 6.** Figure 6: Example Behavior I of Agentic-R1. The model initially attempts to solve the problem using the tool to compute a limit expression, but fails after several attempts. Notably, it then transitions to a pure text-based reasoning strategy and successfully arrives at the corr…

**Figure 7.** Figure 7: Example Behavior II of Agentic-R1. The model first attempts to solve the combinatorial problem via text-based reasoning, but switches to tool-assisted reasoning due to computational complexity. It then implements a dynamic programming algorithm to solve the problem eff…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

22 extracted references · 19 canonical work pages

[1]

Let’s understand what we’re calculating: * We have a function ∇(x, y) =x − 1 y * We’re nesting this function 2016 times * Each time, the first argument is 2 * The innermost y starts with 2

work page 2016
[2]

After { i +1} iterations : { result }\

Let’s try to see if there’s a pattern by calculating the first few terms: Let’s write a Python program to help us: </think> <code> def nabla (x , y ) : return x - 1/ y # Let ' s calculate first several terms result = 2 # Starting value for i in range (10) : # First 10 iterations result = nabla (2 , result ) print ( f \" After { i +1} iterations : { result...

work page
[3]

If this sequence converges to some value L, then: L = 2− 1 L

work page
[4]

In The Twelfth Inter- national Conference on Learning Representations

Let’s verify step by step. In The Twelfth Inter- national Conference on Learning Representations. Haohan Lin, Zhiqing Sun, Sean Welleck, and Yiming Yang. 2024. Lean-star: Learning to interleave think- ing and proving. arXiv preprint arXiv:2407.10040. Ilya Loshchilov and Frank Hutter. 2017. Decou- pled weight decay regularization. arXiv preprint arXiv:1711...

arXiv 2024
[5]

After 2016 iterations : { result }\

Let’s verify this is indeed what we get after 2016 iterations: </think> <code> result = 2 # Starting value for i in range (2016) : result = nabla (2 , result ) print ( f \" After 2016 iterations : { result }\") # Let ' s convert to fraction from fractions import Fraction final = Fraction ( result ) . l im it _d eno mi na to r () print ( f \"\ As a fractio...

work page 2016
[7]

Let’s call the sequence an where a1 = 2and an+1 = ∇(2, an)

work page
[8]

For any term after the first: an+1 = 2− 1 an

work page
[10]

This gives us: L2 = 2L − 1, L2 − 2L + 1 = 0, (L − 1)2 = 0, L= 1

work page

Show all 22 references

[12]

2018 and 2017 are indeed relatively prime (2017 is prime)

2018
[13]

The value is very close to but slightly larger than 1, which matches our convergence analysis
[14]

11 tion, lacking mechanisms to automatically balance long-term reasoning against tool use based on task complexity

For 100m + n: 100(2018) + 2017 = 203817 Therefore, 203817 </think> <answer> 203817 </answer> Figure 5: An example agentic trajectory derived from OpenHands. 11 tion, lacking mechanisms to automatically balance long-term reasoning against tool use based on task complexity. Long...

2018
[15]

Similarly, S1 (Muen- nighoff et al., 2025) and L1 (Aggarwal and Welleck,

and DeepSeek-R1 (Guo et al., 2025) used outcome-driven reinforcement learning to generate extensive reasoning trajectories, substantially out- performing short-CoT baselines in complex math and reasoning benchmarks. Similarly, S1 (Muen- nighoff et al., 2025) and L1 (Aggarwal a...

2025
[16]

Empirical evidence supports that an increase in inference computation can of- ten yield more cost-effective gains than an increase in model size alone (Wu et al., 2025)

demonstrated scaling curves showcasing a log-linear relationship between performance and inference compute. Empirical evidence supports that an increase in inference computation can of- ten yield more cost-effective gains than an increase in model size alone (Wu et al., 2025)....

2022
[17]

First expression for n ={ n }: { first_expr ( n ) }

enables self-evolving reasoning across mul- tiple modalities and fuses them during inference. C License Our training dataset is constructed based on exist- ing datasets, language models, and software. The following lists the relevant resources and their cor- responding license...
[18]

We need to find the number of 26-tuples where each element is 0, 1, or 3
[19]

The sum of all elements must be 15
[20]

This is a constrained counting problem that can be solved using dynamic programming
[21]

Let’s use Python to implement a solution
[22]

The number of valid 26 - tuples is : { result }

We’ll need to: - Create a 2D DP table where dp[i][j] represents the number of ways to make sum j using first i numbers - For each position i, we can use 0, 1, or 3 - We’ll build this up from 0 to 26 numbers - The final answer will be in dp[26][15] </think> <code> def count_tup...
[2023]

Preprint, arXiv:2305.02301

Distilling step-by-step! outperforming larger language models with less training data and smaller model sizes. Preprint, arXiv:2305.02301. HuggingFace. 2025. Math-verify: A robust mathemati- cal expression evaluation system. Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richard- s...

2025 arXiv
[2024]

In Proceedings of the 2024 Joint International Conference on Computational Linguis- tics, Language Resources and Evaluation (LREC- COLING 2024), pages 11475–11485, Torino, Italia

MoDE-CoTD: Chain-of-thought distillation for complex reasoning tasks with mixture of decou- pled LoRA-experts. In Proceedings of the 2024 Joint International Conference on Computational Linguis- tics, Language Resources and Evaluation (LREC- COLING 2024), pages 11475–11485, To...

2024
[2025]

Preprint, arXiv:2502.08235

The danger of overthinking: Examining the reasoning-action dilemma in agentic tasks. Preprint, arXiv:2502.08235. Jinhao Duan, Renming Zhang, James Diffenderfer, Bhavya Kailkhura, Lichao Sun, Elias Stengel-Eskin, Mohit Bansal, Tianlong Chen, and Kaidi Xu. 2024. Gtbench: Uncover...

2024 arXiv

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Let’s understand what we’re calculating: * We have a function ∇(x, y) =x − 1 y * We’re nesting this function 2016 times * Each time, the first argument is 2 * The innermost y starts with 2

work page 2016

[2] [2]

After { i +1} iterations : { result }\

Let’s try to see if there’s a pattern by calculating the first few terms: Let’s write a Python program to help us: </think> <code> def nabla (x , y ) : return x - 1/ y # Let ' s calculate first several terms result = 2 # Starting value for i in range (10) : # First 10 iterations result = nabla (2 , result ) print ( f \" After { i +1} iterations : { result...

work page

[3] [3]

If this sequence converges to some value L, then: L = 2− 1 L

work page

[4] [4]

In The Twelfth Inter- national Conference on Learning Representations

Let’s verify step by step. In The Twelfth Inter- national Conference on Learning Representations. Haohan Lin, Zhiqing Sun, Sean Welleck, and Yiming Yang. 2024. Lean-star: Learning to interleave think- ing and proving. arXiv preprint arXiv:2407.10040. Ilya Loshchilov and Frank Hutter. 2017. Decou- pled weight decay regularization. arXiv preprint arXiv:1711...

arXiv 2024

[5] [5]

After 2016 iterations : { result }\

Let’s verify this is indeed what we get after 2016 iterations: </think> <code> result = 2 # Starting value for i in range (2016) : result = nabla (2 , result ) print ( f \" After 2016 iterations : { result }\") # Let ' s convert to fraction from fractions import Fraction final = Fraction ( result ) . l im it _d eno mi na to r () print ( f \"\ As a fractio...

work page 2016

[6] [7]

Let’s call the sequence an where a1 = 2and an+1 = ∇(2, an)

work page

[7] [8]

For any term after the first: an+1 = 2− 1 an

work page

[8] [10]

This gives us: L2 = 2L − 1, L2 − 2L + 1 = 0, (L − 1)2 = 0, L= 1

work page