betaFeedback

WorksComputer Science

Curriculum Learning Teaches LLMs Long-Horizon Implicit Reasoning, Up To A Limit

Abstract

LLMs "reason" by externalizing intermediate steps as tokens through chain-of-thought (CoT), yet even frontier reasoning models hit abrupt performance cliffs on long-horizon tasks. Implicit reasoning (reasoning within a single forward pass) is useful during CoT generation, as the model can "search ahead" to decide the correct next move without explicit search. Models with weak implicit reasoning are more likely to commit to wrong paths and must attempt to recover via backtracking, while models with strong implicit reasoning identify the correct proof strategy directly, shortening the CoT. However, prior work shows LLMs struggle to reason implicitly beyond shallow depths, with no relief from scale. We investigate whether curriculum learning can extend this depth by fine-tuning on examples with progressively increasing vocabulary size and lookahead (the number of steps a model must search ahead to identify the correct next move). At matched compute, curriculum-trained models achieve lookaheads where no-curriculum training fails. Qwen3-0.6B reaches 98% accuracy on problems with lookahead up to 256 with curriculum, compared to 45% without. However, progress slows as fine-tuning continues, following a saturating exponential that suggests a maximum intrinsic lookahead to which models can learn to reason implicitly. Larger models reach higher fitted ceilings, fine-tuning pretrained models far outpaces training from scratch, and curriculum step sizes that are too large stall progression. Finally, the capability acquired on synthetic data transfers to natural language reasoning, with curriculum-trained models outperforming models trained without curriculum at matched compute on 11 natural language reasoning benchmarks.

Introduction

Large language models (LLMs) are increasingly applied in reasoning-intensive settings such as coding [28], deductive proof generation [40], planning [52], multi-hop question answering [61], and game AI [48]. Reasoning in LLMs is typically performed by externalizing intermediate tokens through chain-of-thought (CoT; [57]), and reinforcement learning has been used to further improve reasoning performance [19] (Jaeck et al. 2024). However, even state-of-the-art reasoning models struggle on long-horizon tasks, hitting abrupt performance cliffs at modest depths, and these failures persist even when models are given their full reasoning-token budgets [42]. Errors early in a reasoning chain can compound over the remaining steps [14], forcing models to spend substantial tokens backtracking in order to recover. Even when models avoid such mistakes, reasoning chains can consume a considerable amount of tokens when each reasoning step makes only a small advance towards the solution.

Implicit reasoning occurs within a single forward pass and determines how a model can “look ahead” over potential later steps before committing to the next CoT step. This capability becomes increasingly important in long-horizon reasoning tasks, which require the model to reason over greater depths. Consider the example in Figure 1, where a model with weak implicit reasoning commits to a wrong path and must attempt to recover via backtracking, while a model with strong implicit reasoning looks far enough ahead to identify the correct next step directly, shortening the

Figure 1. Curriculum versus non-curriculum fine-tuning of the same pretrained LLM. The curriculum orders training problems by increasing difficulty, whereas the baseline draws from the full range of difficulties from the start. On the example proof, the curriculum-trained model takes the correct next step each time, while the baseline commits to a wrong branch and must backtrack. Section 4.1 reports the measured comparison.

CoT. Despite these benefits, recent work has shown that transformers struggle to learn implicit search beyond shallow depths, with no relief from increased model scale [46]. This raises the question: can LLMs be trained to perform long-horizon implicit reasoning, and if so, is there a limit to the depth they can reach?

To address this question, we examine whether the training procedure itself can be shaped to unlock deeper implicit reasoning. Incrementally increasing the depth a model must look ahead during training might offer a natural path to do so, and we therefore investigate whether curriculum learning [2] can extend this depth. We generate training data using a modified version of DeepRD [42], where each example provides a set of premises in natural language over entities and attributes (e.g., in “Alex is a cat,” “Alex” is an entity and “cat” is an attribute) and asks the model to predict the next step of a multi-hop proof. We deliberately keep the curriculum simple, as our goal is not to find the optimal design but to characterize the behavior of curriculum training itself. Our curriculum gradually increases the lookahead—the number of steps a model must search ahead to identify the correct next step—jointly with the attribute vocabulary, which we find outperforms a curriculum over lookahead alone (Section 4.1). As an illustration, the lookahead in Figure 1 is 3, since the model must search 3 steps ahead to conclude that the correct second step is “Carol is Bob’s mother,” and not “George is Bob’s father.” By training only on the output of a single forward pass, we isolate implicit reasoning as a pure computational capability, separating it from what can be achieved by externalizing intermediate steps. With this setup, we pose two primary research questions. RQ1: Can LLMs learn to reason implicitly to arbitrary depths, and what training conditions—including curriculum, model size, and initialization—govern this capability? RQ2: Does training a model to perform long-horizon implicit reasoning improve its performance on downstream natural-language reasoning tasks?

We make the following contributions to answer the aforementioned research questions:

C1 We introduce a curriculum over lookahead and attribute vocabulary and show that it extends the depth to which LLMs can reason implicitly. At matched compute, Qwen3-0.6B reaches 98% accuracy on problems up to lookahead 256 with curriculum vs. 45% without (Section 4.1).

C2 We show that achieved lookahead grows predictably with training compute, following a saturating exponential, suggesting a maximum intrinsic lookahead to which each model can learn to reason implicitly (Section 4.2).

C3 We show that larger models have higher maximum intrinsic lookaheads, that pretrained initialization allows a model to reason implicitly to far greater depths than training from scratch, and that the curriculum step size (the increase in lookahead between successive stages) must be small enough for training to progress. Pythia-410M, 1.4B, and 2.8B have maximum intrinsic lookaheads of 51, 82, and 235, respectively (Section 4.4). At a 1.5M PFLOP budget, Pythia-1.4B achieves lookahead 63 from pretrained weights vs. 23 from random initialization (Section 4.5). With Qwen3-0.6B, step size 64 stalls at lookahead 128, while step size 8 reaches 256 (Section 4.3).

C4 We show that the implicit reasoning capability acquired on synthetic data transfers to natural language reasoning. Curriculum-trained models outperform models trained without curriculum at matched compute on 11 benchmarks, with the largest gains on multi-step deductive reasoning—Qwen3-1.7B gains 14.3 points on ProofWriter OWA at lookahead 48 (Section 4.6).

Related Work

Reasoning and search in transformers. A growing line of work characterizes how LLMs struggle in long-horizon reasoning. Dziri et al. [14] argue that transformers reduce multi-step reasoning to pattern matching, so errors compound as tasks grow more complex. Formal analyses of deductive reasoning show that LLMs reason greedily at branch points ((Saparov & He, 2023)) and that their accuracy decreases as the correct proof grows longer ([45]). Saparov et al. [46] formalize task complexity via a lookahead metric and show that while small transformers can learn to search under a carefully balanced training distribution, learning degrades as graphs grow, with no relief from model scale. Rameshkumar et al. [42] show that even frontier reasoning models hit a performance cliff at modest lookaheads on graph connectivity and proof planning, without exhausting their token budgets. Heyman & Zylberberg [23] report similar failures on graph-coloring tasks.

Explicit and implicit reasoning. Explicit reasoning externalizes tokens via CoT prompting ([57]) and its derivatives ([55, 62]), extended further by trace-supervised search ([32, 15]) and reinforcement learning ([30, 26, 19]). Implicit approaches enhance reasoning without verbalizing intermediate steps via learnable auxiliary tokens ([18]), soft tokens in place of discrete tokens ([21, 47, 58]), or architectural recurrence ([11, 17]). Mechanistic studies show transformers can reason implicitly within a forward pass ([5, 27]), and it can emerge through grokking, but only with significant over-training ([53]). However, implicit reasoning can reflect shortcut learning rather than generalizable reasoning ([34]), and its generalization depends on which compositional structures appear in training ([64]).

Curriculum learning for reasoning. In early curriculum learning work, Bengio et al. [2] train language models on a restricted vocabulary that is progressively expanded; our attribute-vocabulary curriculum applies the same idea to the attributes of synthetic proofs. Curriculum learning has since been used to improve performance on reasoning tasks, for example by gradually removing CoT tokens ([12]) or replacing them with soft tokens ([21]) while keeping the remainder of the prompt invariant. Our curriculum instead never uses CoT and increases the lookahead of the problems. Recent theoretical results show that staged curricula can avoid exponential sample-complexity bottlenecks ([56, 6, 25]) and can enable agents trained with reinforcement learning to perform search on trees that are deeper than those seen during training ([60]). Empirically, the picture is mixed: curriculum learning improves learning efficiency ([1]) and mitigates, but does not eliminate, the exponential data cost of implicit kk-hop reasoning in small from-scratch models ([63]), while difficulty-ordering a fixed dataset gives no robust advantage for explicit CoT post-training ([36]). Lee et al. [31] report that pretrained initialization accelerates curriculum progression. Whether a curriculum can unlock implicit reasoning in pretrained LLMs at depths where direct training fails has remained open; our work answers this question.

Methods

Task Formulation and Complexity

We study whether LLMs can learn to perform long-horizon reasoning implicitly, where the model emits the next proof step directly, without intermediate reasoning tokens. To do so, we focus on the task of predicting the next step in a proof: given a set of premises and a goal conclusion, the model must identify the correct next step in a valid proof of the goal from the premises. A proof is a sequence of proof steps, where each proof step has some premises followed by a conclusion, and the conclusion of one proof step may serve as a premise for a later proof step. Solving the task requires the model to search through possible inference paths, starting from the premises, and find a proof from the premises to the goal.

Training Data. To generate examples of this task, we use a modified version of the DeepRD dataset. In DeepRD, each problem is generated by first generating a directed acyclic graph (DAG). Each graph is then translated into natural language by mapping every node into an atomic proposition (e.g., “Alice is a cat”) and every edge into a rule (e.g., “If Alice is a cat, then Alice is a mammal”). In DeepRD, attribute names, such as “cat”, are replaced with fictional names (e.g., “zorbi”) to facilitate the generation of very large reasoning problems and to avoid data contamination issues during evaluation. Since DeepRD is synthetic, we can generate a limitless number of examples for large-scale training. Some examples are shown in Appendix § 16. A key reason we choose DeepRD is that our curriculum requires a large number of examples whose lookahead is highly controllable and can be made arbitrarily large. Real-world reasoning data cannot meet this requirement, because its complexity is long-tailed [42] and examples with very large lookahead are rare. The representation of each reasoning problem as a graph enables us to precisely control problem complexity: in the graph analogy, finding a proof from a premise to a goal is equivalent to finding a directed path from a start node to a goal node.

Lookahead. We measure task complexity using the lookahead ℓ\ell which is the minimum number of breadth-first search iterations that must be performed from the start node to determine the correct next step in the path to the goal. Intuitively, ℓ\ell captures how far the model must search to determine the correct path from incorrect alternatives.2 This is distinct from the length of the path from the start node to the goal node. For example, if the start node has only one valid child node, no search is needed to determine the next correct step, regardless of the distance of the goal node from the start node. In this case, ℓ=1\ell= 1, and lookahead is a more faithful characterization of problem complexity.

Curriculum over Lookahead and Attribute Vocabulary

We aim to test whether curriculum learning can help transformers to learn to perform long-horizon implicit reasoning. With this in mind, we develop a curriculum learning procedure (Figure 8 and Algorithm 1, Appendix § 8). We train the model in stages: at stage kk, the model is presented with examples whose lookahead is at most LkL_k, where Lk=k⋅sL_k = k \cdot s and s≥1s \ge1 is the curriculum step size—i.e., the amount by which the lookahead is increased at each stage of the curriculum. For example, with s=8s = 8, a 12-stage curriculum advances through Lk=8,16,24,…,96L_k = 8, 16, 24, \ldots, 96. Figure 13 illustrates the first three stages of a curriculum with s=1s = 1. At each stage, we perform supervised fine-tuning on examples from DeepRD where, for each example ii, the lookahead of the example ℓi\ell_i is sampled i.i.d. from a uniform distribution ℓi∼Uniform⁡{1,…,Lk}\ell_i \sim\operatorname{Uniform}\{1,\ldots,L_k\}. Including easier examples at each stage helps prevent catastrophic forgetting of previously learned lookaheads. The training objective is cross-entropy on the answer tokens: the tokens identifying the correct next attribute in the proof chain. The model advances from stage kk to stage k+1k + 1 when its exact-match accuracy over the most recent WW training examples reaches 98%.

Figure 8. Training loop of our curriculum over lookahead and attribute vocabulary, as described in Section 3.2.

Figure 13. Curriculum over lookahead and attribute vocabulary size. The three stages use maximum lookahead L=1,2,3L=1, 2, 3 and attribute vocabulary size ∣Vk∣=4,6,8\lvert V_k\rvert= 4, 6, 8, respectively. The arrows indicate stage advancement. Each DAG is converted into natural-language premises; for example, the edge vimba →\to vorga reads “If Alice is vimba, then Alice is vorga.” The abbreviated examples below the graphs show the goal and proof prefix; the model predicts the next attribute at the blank. Green marks goal-reaching paths and red marks distractor paths. Neither the colors nor the graph diagrams are part of the model input.

Attribute-vocabulary curriculum. Besides lookahead, the number of distinct attribute labels that appear across training examples also affects the difficulty of the task. We therefore also grow the attribute vocabulary as part of the curriculum, akin to the vocabulary curriculum of Bengio et al. [2]. The attributes in each generated proof are given fictional labels (e.g., zorbi in “Alice is zorbi”); the attribute vocabulary Vk\mathcal{V}_k is the pool of these attribute labels available to the instances at stage kk, and ∣Vk∣\lvert\mathcal{V}_k\rvert denotes its size. We emphasize that ∣Vk∣\lvert\mathcal{V}_k\rvert does not refer to the model’s tokenizer vocabulary. The tokenizer and its token set are unchanged, and each attribute label is encoded as ordinary subword tokens. We grow ∣Vk∣\lvert\mathcal{V}_k\rvert with lookahead LkL_k so that the vocabulary is always sufficient to provide distinct attributes with distinct labels. Specifically, an instance at lookahead LkL_k contains at most 2Lk+12L_k + 1 distinct attributes: the “correct chain” of length LkL_k plus a distractor chain of length LkL_k that shares the initial attribute as the correct chain. We set ∣Vk∣=2(Lk+1)\lvert\mathcal{V}_k\rvert= 2(L_k + 1), which is one more than the upper bound, so every attribute in each instance can receive a distinct label. A pool smaller than 2Lk+12L_k + 1 would force two or more attributes to share a label, which would make the problem ill-posed. We explore whether this joint curriculum over both lookahead and attribute vocabulary size performs better than a curriculum over lookahead alone (§ 4.1). In the latter setting, holding the pool fixed at its maximum size from the start leaves proof structure unchanged and only reduces cross-instance reuse of attribute labels.

Experiments and Results

Models. We use two model families. Qwen3 (0.6B, 1.7B; [59]) gives capable models at low training cost across our many curriculum configurations, and it has fairly strong instruction following capabilities, which facilitates evaluation using downstream benchmarks that require specifically formatted outputs (§ 4.6). Pythia (160M, 410M, 1.4B, 2.8B; [3]) provides models of different sizes pretrained, where each model is trained on the same data and the same number of tokens, so that they differ mainly in scale, together with base (non-instruction-tuned) checkpoints; our scaling and initialization comparisons (§ 4.4 and § 4.5) rely on both properties.

Setup. All training examples are generated with our modified DeepRD generator as described in § 3.1 and § 3.2. Experiments perform full fine-tuning with AdamW, a constant learning rate, and bf16 precision; per-experiment hyperparameters are listed in Appendix § 9. Training compute is estimated as C≈6NDC \approx6ND (NN parameters, DD tokens; [29]).

Evaluation. The comparison of training with vs. without curriculum (§ 4.1) uses exact-match accuracy of the predicted next attribute on a held-out set shared by both settings, with lookaheads sampled uniformly from 1 to LL (Appendix § 12).3 All other synthetic-task experiments report achieved lookahead LL, the last curriculum stage completed, i.e., the largest LL at which the rolling exact-match training accuracy reaches 98% (§ 3.2).

Baselines. In both the next-step proof prediction comparisons (§ 4.1) and the downstream transfer experiments (§ 4.6), the baseline is the same model trained without curriculum, directly on data with a fixed maximum lookahead LL from the start, compared against its curriculum-trained counterpart at matched training compute.

Curriculum Learning Enables Deeper Reasoning at Matched Compute

Curriculum versus no curriculum. To determine whether curriculum learning is needed to train models to perform long-horizon reasoning implicitly, we compare training Qwen3-0.6B with curriculum learning at s=8s = 8 against training without curriculum learning, where the maximum lookahead is fixed from the start. We run this comparison for each maximum lookahead L∈{96,104,112,120,128,256}L \in\{96, 104, 112, 120, 128, 256\}. Figure 2 shows evaluation accuracy vs. cumulative training compute for L∈{96,128,256}L \in\{96, 128, 256\}, with the full sweep reported in Appendix § 10.§ 1.

Figure 2. Eval accuracy of Qwen3-0.6B at maximum L∈{96,128,256}L \in\{96, 128, 256\} vs. cumulative training compute (PFLOPs). The dashed line marks the 98% threshold; dotted lines mark where each setting crosses it (Table 1).

Table 1 summarizes the compute required to reach 98% evaluation accuracy across all six values of LL. For L≤128L \le128 both methods eventually converge, but training with curriculum is consistently 1.25–2.27×\times more compute-efficient. At maximum lookahead L=256L=256 the gap becomes qualitative: training without curriculum plateaus at ∼\sim45% accuracy and never converges within the compute budget, while training with curriculum continues climbing to 98%.

LLCurriculumNo curriculumSpeedup
9666.5K82.8K1.25×\times
10466.5K106K1.59×\times
11274.3K140K1.89×\times
12074.3K106K1.42×\times
12881.8K186K2.27×\times
256259K––

Table 1. Cumulative training compute (PFLOPs) to reach 98% accuracy at each target lookahead LL. A dash marks a setting that never reaches 98% within budget.

Joint curriculum over attribute vocabulary. We next test the design choice introduced in § 3.2: using a curriculum over both attribute vocabulary size and lookahead, with ∣Vk∣=2(Lk+1)|V_k| = 2(L_k+1), versus using a curriculum over lookahead alone, with the attribute vocabulary fixed at its maximum size throughout training. We train Qwen3-0.6B under both configurations, holding all other hyperparameters constant. Figure 3 and Table 9 show that the joint curriculum completes L=128L=128 within 100K PFLOPs, where the fixed-vocabulary configuration has completed only L=96L=96. One plausible explanation is the following: at a fixed (large) attribute vocabulary, the model sees fewer examples of each attribute label in diverse reasoning contexts, encouraging memorization rather than generalization, while the joint curriculum keeps the attribute vocabulary small in early stages and grows it progressively as the model masters larger lookaheads. We therefore conduct all subsequent experiments using the joint curriculum over lookahead and attribute vocabulary size.

Figure 3. Achieved lookahead LL vs. cumulative training compute (PFLOPs) for Qwen3-0.6B at s=8s=8, with the attribute vocabulary grown as ∣Vk∣=bLk+2|\mathcal{V}_k| = bL_k + 2 or held fixed at its maximum size. The bold entry (b=2b=2, growing ∣Vk∣|\mathcal{V}_k|) is the configuration used in all other experiments.

Stage LLJoint curriculumLookahead only
8144401
169832.54K
243.14K4.30K
326.19K7.66K
4813.6K20.6K
6423.5K43.7K
8037.7K61.6K
9667.3K88.8K
11274.3K–
12887.5K–
LL at 100K12896

Table 9. Cumulative training compute (PFLOPs) at which each configuration completes stage LL for Qwen3-0.6B with s=8s=8, and the stage completed within a shared budget of 100K PFLOPs. The joint curriculum grows the attribute vocabulary as ∣Vk∣=2(Lk+1)|V_k| = 2(L_k + 1), and the lookahead-only curriculum holds it fixed at its maximum size. A dash (–) means the model never reached that lookahead during training. The fixed-vocabulary configuration ends with L=96L=96 completed after 107K PFLOPs. PFLOPs are computed as 6N6N per token with actual parameter counts.

Vocabulary growth rate. Beyond whether to grow the attribute vocabulary at all, we also test how quickly it should grow. We compare ∣Vk∣=bLk+2|\mathcal{V}_k| = bL_k + 2 for b∈{2,3,4}b \in\{2,3,4\} on Qwen3-0.6B with s=8s = 8 under an otherwise identical curriculum (Figure 3). At b=2b = 2, this recovers our original schedule, ∣Vk∣=2Lk+2=2(Lk+1)|\mathcal{V}_k| = 2L_k + 2 = 2(L_k + 1). For a given lookahead, a larger bb “widens” the deepest instances from 2 branches to bb, rather than simply enlarging the attribute vocabulary while holding proof structure fixed, since ∣Vk∣|\mathcal{V}_k| is one more than the maximum number of attributes in an instance. This comparison therefore varies proof breadth alongside attribute vocabulary size. Within a budget of 100K PFLOPs, the three settings achieve L=128L=128, 72, and 64, respectively. Thus, the curriculum design that advances fastest is the one that grows the attribute vocabulary while holding the deepest instances at two branches (b=2b = 2), and we use this configuration in all subsequent experiments.

Achieved Lookahead Grows Predictably toward an Apparent Ceiling

Having shown that curriculum is instrumental in teaching models to perform long-horizon implicit reasoning, we examine how achieved lookahead grows with compute. Figure 4 plots achieved LL against cumulative training compute (PFLOPs, log–log) for the trajectories of two models trained under our curriculum with s=1s = 1: Qwen3-0.6B and Pythia-1.4B. In both cases achieved LL grows smoothly with compute but accelerates, curving below a straight line on log–log axes. We fit two functional forms4: a power law L=aCp+L0L = aC^p + L_0, the simplest unbounded form, and a saturating exponential L=Lmax⁡(1−exp⁡(−(C/C0)k))L = L_{\max}(1 - \exp(-(C/C_0)^k)), the simplest bounded form, with a ceiling Lmax⁡L_{\max}.

Figure 4. Achieved lookahead LL vs. cumulative training compute (PFLOPs, log–log scale) for Qwen3-0.6B (left) and Pythia-1.4B (right) trained under the curriculum with s=1s=1, with the power-law and saturating exponential fits overlaid on the observed trajectory.

Under the constraint L0≥0L_0 \ge0 (to ensure positive lookahead) the fitted offset vanishes, leaving a pure power law. Table 2 gives the fitted forms and their in-sample RMSE.

TrajectoryFormFitted equationRMSE
Qwen3-0.6BPower lawL≈1.03C0.390L \approx1.03C^{0.390}6.10
Qwen3-0.6BSaturating exponentialL≈3241(1−exp⁡(−(C/7.7×105)0.547))L \approx3241(1-\exp(-(C/7.7\times10^5)^{0.547}))2.22
Pythia-1.4BPower lawL≈2.45C0.228L \approx2.45C^{0.228}2.98
Pythia-1.4BSaturating exponentialL≈82(1−exp⁡(−(C/5.0×105)0.371))L \approx82(1-\exp(-(C/5.0\times10^5)^{0.371}))0.53

Table 2. Fitted forms of achieved lookahead LL against cumulative training compute CC (PFLOPs), with in-sample RMSE.

The saturating exponential achieves lower in-sample RMSE than the power law by factors of 2.7 and 5.6 on Qwen3-0.6B and Pythia-1.4B, respectively.

We next test whether this in-sample advantage extends to prediction. We fit both forms on the first 70% of each trajectory’s stage completions, ordered by cumulative compute, and evaluate on the remaining 30%. Held-out RMSE is 1.4×\times and 23.8×\times lower for the saturating exponential on Qwen3-0.6B and Pythia-1.4B (Table 3).

TrajectoryPower lawSat. exp.pp-value
Qwen3-0.6B23.8817.087×10−107\times10^{-10}
Pythia-1.4B16.140.681.5×10−41.5\times10^{-4}

Table 3. Held-out RMSE for achieved lookahead LL. pp-value: significance of the saturating exponential’s advantage under the per-stage iteration test, two-sided. Additional fits on less-trained trajectories in Table 17.

A Diebold & Mariano [13] test is a standard comparison of held-out forecast errors. Because errors along a single trajectory are serially correlated, however, we instead apply the test to the number of training iterations required to complete each stage, whose residuals are approximately independent (Appendix § 11.§ 1). On both trajectories, the saturating exponential predicts the held-out duration of each stage significantly better than the power law (p=7×10−10p = 7\times10^{-10} for Qwen3-0.6B and p=1.5×10−4p = 1.5\times10^{-4} for Pythia-1.4B; Table 3). The advantage also increases with lookahead, as the gap between the two forms’ held-out prediction errors widens at later stages. Appendix § 11 reports the results of the same comparisons on Pythia-410M and Pythia-2.8B.

Within our observed range both forms describe the data closely, but achieved LL decelerates faster than a power law allows. The saturating fit is better, and it assigns each model a finite ceiling Lmax⁡L_{\max}. The slowdown is particularly pronounced for Pythia-1.4B. Within a budget of 5M PFLOPs, it reaches L=75L=75, 91% of the fitted asymptote Lmax⁡≈82L_{\max}\approx82. Its last five completed stages, L=71L=71–7575, consume 2.10M PFLOPs, approximately 42% of the budget, and the per-stage cost is still increasing at the end of training (Appendix § 11.§ 2, Figure 12).

Figure 12. Mean training compute per completed curriculum stage for Pythia-1.4B with s=1s=1. Each bar averages five consecutive completed stages; labels show the mean in PFLOPs. Compute for a stage is measured between consecutive stage completions, with the first stage measured from the start of training. The unfinished stage L=76L=76 is excluded.

These trajectories suggest a model- and procedure-specific ceiling on achievable lookahead: for a given model, our curriculum appears to drive LL upward with diminishing returns toward that ceiling.

Small Step Sizes Are Required for Deep Curriculum Progression

Achieved lookahead versus cumulative compute for Qwen3-0.6B with step sizes $s \in \{1,4,8,16,32,64\}$.

Figure 5. Achieved lookahead LL vs. cumulative training compute for Qwen3-0.6B with step sizes s∈{1,4,8,16,32,64}s \in\{1,4,8,16,32,64\}.

Our curriculum has one main hyperparameter, the step size ss, which controls the increase in maximum lookahead LL between consecutive stages. We examine how ss affects the lookahead the curriculum reaches within a fixed compute budget. We tune Qwen3-0.6B using our curriculum at step sizes s∈{1,4,8,16,32,64}s \in\{1,4,8,16,32,64\}, each with a target lookahead of L=256L=256.

Figure 5 shows that the step size must be neither too large nor too small. A step size that is too large stalls curriculum advancement: s=64s=64 stalls at L=128L=128 and s=32s=32 at L=192L=192. A step size that is too small does not stall but advances slowly: within 300K PFLOPs, s=1s=1 reaches only L=145L=145 and s=4s=4 reaches L=212L=212, whereas s=8s=8 and s=16s=16 achieves the target L=256L=256.

A plausible explanation for stalling is that larger ss makes training more similar to the no-curriculum case: at ss equal to the target lookahead the curriculum has a single stage, which is exactly the no-curriculum case, and § 4.1 shows that this stalls at L=256L=256. The higher the target, the smaller ss must be to avoid stalling.

Maximum Intrinsic Lookahead Grows with Model Scale

Prior work finds that scaling model size alone does not improve implicit reasoning [46]. We test whether this conclusion holds with curriculum learning, and whether the curriculum’s progression rate depends on model size. We train Pythia models of four different sizes (160M, 410M, 1.4B, 2.8B) using our curriculum with s=1s=1, with learning rate and batch size individually tuned per model size (Appendix § 9).

At matched compute, larger models reach greater lookaheads once the training budget is sufficiently large (Figure 6). Pythia-2.8B achieves the deepest lookahead among the tested Pythia models (L=133L=133). It completes L=130L=130 using 2.40M PFLOPs, less than half the compute Pythia-1.4B uses to reach L=75L=75 (4.97M PFLOPs). Pythia-160M plateaus at L=9L=9 over the observed trajectory, suggesting that the model’s capacity is insufficient for curriculum progression.

Figure 6. Achieved lookahead LL vs. cumulative training compute for the four Pythia sizes at s=1s=1. At 1M PFLOPs, the curves reach L=9L=9, 44, 58, and 94, from smallest to largest.

Scaling of the fitted asymptote with model size. The saturating exponential’s asymptote Lmax⁡L_{\max} is itself model-dependent. We fit the saturating-exponential curve introduced in § 4.2 separately to each Pythia trajectory except that of Pythia-160M, which plateaus at L=9L=9. The fitted asymptote rises with model size: Lmax⁡≈51L_{\max} \approx51, 82, and 235 for Pythia-410M, -1.4B, and -2.8B respectively (per-size fits in Appendix § 11, Figure 11; fitted parameters in Table 19). Parameter count is not the whole story, however: Qwen3-0.6B has a fitted asymptote of Lmax⁡≈324L_{\max}\approx324, well above the larger Pythia-1.4B’s ≈82\approx82, suggesting that factors beyond parameter count also affect a model’s maximum intrinsic lookahead. Bootstrap intervals (Table 19) show that the ordering of these ceilings is robust.

Figure 11. Saturating exponential fits (black dotted, over the observed range) to the achieved-lookahead trajectories of Pythia-410M, -1.4B, and -2.8B trained with s=1s=1 (log–log). Legends give each fitted ceiling Lmax⁡L_{\max} (Table 19).

TrajectoryLmax⁡L_{\max} [95% CI]C0C_0 (PFLOPs)kk
Qwen3-0.6B323.6 [304, 404]7.7×1057.7 \times10^50.547
Pythia-410M51.2 [49.2, 56.9]1.4×1051.4 \times10^50.341
Pythia-1.4B81.9 [77.8, 83.0]5.0×1055.0 \times10^50.371
Pythia-2.8B235.1 [175, 315]3.8×1063.8 \times10^60.497

Table 19. Fitted saturating exponential parameters, L=Lmax⁡(1−exp⁡(−(C/C0)k))L = L_{\max} (1 - \exp(-(C/C_0)^k)), for the four long s=1s=1 trajectories. Lmax⁡L_{\max} is the fitted ceiling plotted in Figure 11. Brackets give 95% moving-block bootstrap percentile intervals for Lmax⁡L_{\max} (block length ≈n1/3\approx n^{1/3}, 300 resamples). Their lower ends are stable under longer blocks, while the upper ends for Qwen3-0.6B and Pythia-2.8B widen substantially, so those upper bounds are indicative only.

Pretrained Initialization Reaches Greater Lookahead at Matched Compute

Lee et al. [31] report that pretrained initialization accelerates curriculum progression in arithmetic and maze-solving tasks. We test whether this effect holds for our curriculum learning in reasoning and quantify the size of the gap. We train Pythia-1.4B and Qwen3-0.6B, each twice under our curriculum with s=1s=1: once from the released pretrained checkpoint (full fine-tuning) and once from random weights (training from scratch). Learning rate and batch size are tuned separately for each condition, since random initialization makes little progress under the small learning rate suited to fine-tuning (Appendix § 9). Pretraining gives a large head start in both families (Figure 7). Within a budget of 1.5M PFLOPs, random initialization reaches L=23L=23 for Pythia-1.4B and L=35L=35 for Qwen3-0.6B. Pretrained initialization reaches the same lookaheads with ∼53×\sim53\times and ∼117×\sim117\times less compute, respectively (Table 14, Appendix § 10.§ 4). That the stronger, more heavily pretrained model benefits more suggests the curriculum builds on capabilities already present in the pretrained weights rather than instilling them from scratch. Applying our curriculum to Pythia-1.4B checkpoints saved after different amounts of pretraining shows the same pattern within a single model, as checkpoints with more pretraining need less compute to advance through the curriculum (Appendix § 10.§ 4).

Figure 7. Achieved lookahead LL vs. cumulative training compute (PFLOPs), starting from the pretrained checkpoint vs. random initialization. Left: Pythia-1.4B, Right: Qwen3-0.6B.

Stage LLPythia-1.4B pretrainedPythia-1.4B randomQwen3-0.6B pretrainedQwen3-0.6B random
81.07K79.7K61874.8K
167.75K636K2.35K285K
2428.2K1.64M5.78K618K
3273.6K4.41M10.8K1.36M
48385K–25.4K2.22M
641.65M–48.0K–
96––121K–
128––228K–
192––628K–
244––1.49M–
LL at 300K461314516
LL at 1.5M632324435

Table 14. Cumulative training compute (PFLOPs) at which each condition completes stage LL under the curriculum with s=1s=1, and the stage completed at 300K and 1.5M PFLOPs. A dash (–) means the model never reached that lookahead during training. Training from random initialization ends with L=35L=35 completed (Pythia-1.4B, 6.02M PFLOPs) and L=61L=61 completed (Qwen3-0.6B, 4.82M PFLOPs). PFLOPs are computed as 6N6N per token with actual parameter counts.

Pretrained models have a larger fitted asymptote. We train the randomly initialized Qwen3-0.6B long enough to fit the curve of § 4.2, which gives Lmax⁡≈120L_{\max} \approx120, against ≈324\approx324 from pretrained initialization. This suggests that without pretrained knowledge, the model not only progresses more slowly but also reaches a lower ceiling.

Implicit Reasoning Learned on Synthetic Data Transfers Downstream

We now ask whether the implicit-reasoning capability acquired through curriculum learning on synthetic data transfers to natural language reasoning benchmarks. We fine-tune Qwen3-1.7B with our curriculum (s=1s=1). To avoid catastrophic forgetting of the instruction-following capability that downstream benchmarks require, we draw 6% of training examples, outside the curriculum, from the instruction-tuning corpus Dolci-Instruct-SFT [37].

We evaluate at curriculum stages L∈{8,16,32,48}L \in\{8, 16, 32, 48\} on 14 downstream reasoning tasks spanning logical, multi-hop, constraint-satisfaction, and graph reasoning (Tafjord et al., [51]; Clark et al., [10]; Lin et al., [33]; Saparov et al., [45]; Han et al., [20]; Chen et al., [7]; Qi et al., [41]; Sinha et al., [49]; Parmar et al., [39]; Suzgun et al., [50]; Liu et al., [35]; Zhong et al., [66]; Wang et al., [54]) (full list in Table 4; descriptions in Appendix § 15). Evaluating at multiple stages tracks how the transfer evolves as the curriculum deepens. We compare against the same model trained without curriculum, directly at L=48L=48, compute-matched to the final curriculum checkpoint.

Benchmark8163248No curr.Δ\Delta
ProofWriter OWA41.133.639.354.9*40.6+14.3
ProofWriter CWA66.857.267.667.9*55.2+12.8
ParaRules46.136.239.155.1*50.4+4.7
ZebraLogic-MC47.453.451.853.5*48.3+5.2
PrOntoQA†52.555.356.857.1*52.0+5.1
FOLIO45.846.345.845.8*41.4+4.4
JustLogic51.152.645.553.5*46.1+7.4
ProverQA42.044.446.347.849.2−1.4
CLUTRR25.527.223.228.626.7+1.9
LogicBench-BQA74.272.574.173.6*71.2+2.4
RuleTaker60.560.663.560.058.8+1.2
Web of Lies†55.556.557.257.957.8+0.2
LogiQA42.644.944.942.443.4−0.9
NLGraph41.543.544.343.746.2−2.5

Table 4. Downstream reasoning accuracy (%) for Qwen3-1.7B at curriculum stages LL, vs. trained directly at L=48L=48 without curriculum at matched compute. Δ\Delta: accuracy of curriculum at L=48L=48 minus that of no curriculum. Best per row in bold. *: curriculum wins are statistically significant (two-sided exact McNemar test on paired items, p<0.05p < 0.05); confidence intervals in Appendix F. †Extended by us to test for greater depths (Appendix G).

Table 4 reports the results, and Appendix § 13 additionally reports the base model and an instruction-only control. At L=48L=48, training with curriculum outperforms training without curriculum on 11 of the 14 benchmarks, with statistically significant gains on ProofWriter (both settings), JustLogic, ZebraLogic-MC, PrOntoQA, ParaRules, FOLIO, and LogicBench-BQA. On the three benchmarks where the model trained without curriculum scores higher, none of the differences is significant. These results suggest that training a model with curriculum learning to perform long-horizon implicit reasoning can improve its downstream reasoning. Optimizing the training procedure to maximize these gains is left to future work.

General model capability is preserved. On eight language-understanding benchmarks and IFEval, the curriculum-trained Qwen3-1.7B exceeds the non-finetuned model at every curriculum stage (eight-benchmark mean ranging from 63.4 to 64.2 for the various curriculum approaches vs. 61.7 for non-finetuned model) and stays within one point of a compute-matched model fine-tuned only on instruction data (Table 24, Appendix § 13.§ 1). Thus, we find no evidence that gains in implicit reasoning come at the expense of general capability.

ModelMMLUARC-EARC-CHellaSwagWinoG.PIQABoolQLAMBADAMeanIFEval
Base Qwen3-1.7B55.572.642.760.561.772.577.650.361.733.1
Curriculum, L=8L=856.976.248.062.463.272.876.457.464.235.1
Curriculum, L=16L=1657.175.745.962.562.473.377.158.064.039.0
Curriculum, L=32L=3257.374.345.862.561.673.077.859.263.934.6
Curriculum, L=48L=4856.174.445.664.059.873.377.256.563.441.2
No curriculum57.575.545.362.762.973.773.255.163.240.1
Instruction-only56.475.748.364.060.473.379.256.464.246.4

Table 24. General model capability of Qwen3-1.7B across curriculum stages. Accuracy on eight standard benchmarks (zero-shot, lm-evaluation-harness v0.4.11, identical settings for every model) for the non-finetuned model, four curriculum stage checkpoints, the model trained without curriculum, and an instruction-only control, the last two compute-matched to the L=48L=48 checkpoint. “Mean” is the unweighted mean of the eight language understanding benchmarks. IFEval (prompt-level strict accuracy) is reported separately and is excluded from the mean.

Conclusion

We investigate whether LLMs can be trained to perform implicit reasoning at greater depths using a curriculum over lookahead and attribute vocabulary size that gradually increases the maximum number of steps the model must search ahead to identify the next step in a proof. We find that curriculum learning enables models to reach greater depths than no-curriculum baselines. Achieved lookahead grows predictably with training compute but decelerates and fine-tuning progresses, and across both model families, the trajectories are better described by a saturating exponential than by an unbounded power law, suggesting a maximum intrinsic lookahead that varies

across models. Our fits suggest that model size and pretrained initialization raise the maximum intrinsic lookahead, while step sizes that are too large cause the curriculum to stall. Finally, the capability acquired on synthetic data can transfer to downstream natural-language reasoning benchmarks, showing that curriculum-trained implicit reasoning can generalize beyond the synthetic training distribution.

Future work includes separating the effects of architecture and pretraining on the fitted asymptotes, applying the curriculum to semantically richer generators with a controllable difficulty parameter, and training curriculum-trained models with reinforcement learning to measure the effect on chain-of-thought length and backtracking.

Reproducibility Statement

All required details to reproduce our results are contained in the paper and its appendices. Additionally, our full code is freely available at https://github.com/MaxNickell/implicit-reasoning-curriculum. The task formulation and the curriculum over lookahead and attribute vocabulary are specified in § 3.1 and § 3.2; the training procedure is given as pseudocode in Appendix § 8, and worked examples of generated training instances appear in Appendix § 16. Training data is produced with a modified version of the DeepRD generator, with our modifications described in § 3.1. Model configurations, optimizer settings, batch sizes, and learning rates for every experiment are listed in Appendix § 9. The downstream evaluation protocol, including benchmarks, prompting format, and scoring, is given in Appendices § 12 and § 15; all models are evaluated under an identical protocol. Confidence intervals and the significance tests behind our downstream comparisons are reported in Appendix § 13, and the curve-fitting procedure behind our L(C)L(C) claims, including held-out validation, is detailed in Appendix § 11. We note that every downstream number comes from a single training seed, and that the intervals we report reflect evaluation sampling only.

Acknowledgments

This research was supported by computational resources from Purdue University’s Rosen Center for Advanced Computing and Contextual AI, Inc.

Curriculum Training Algorithm

The pseudocode below specifies the curriculum training procedure described in § 3.2. Stages advance based on a rolling exact-match accuracy criterion over the WW most recent training examples, after a per-stage minimum step floor (200 steps, see Appendix § 9) is reached.

Algorithm 1 Curriculum Training over Lookahead and Attribute Vocabulary

Require: Model fθf_{\theta} with parameters θ\theta, step size ss, number of stages KK, threshold τ\tau, window WW, batch size BB, minimum steps per stage MM

  1. Initialize θ\theta; set k←1k \leftarrow1

  2. while k≤Kk \le K do

  3. Lk←k⋅sL_k \leftarrow k \cdot s

  4. ∣Vk∣←2(Lk+1)\lvert V_k\rvert\leftarrow2(L_k + 1)

  5. Sample ℓi∼Uniform⁡{1,…,Lk}\ell_i \sim\operatorname{Uniform}\{1, \ldots, L_k\} independently for i=1,…,Bi = 1, \ldots, B

  6. Generate batch {(xi,yi)}i=1B\{(x_i, y_i)\}_{i=1}^{B} with lookaheads ℓi\ell_i and attribute labels drawn from a vocabulary of size ∣Vk∣\lvert V_k\rvert, where xix_i is the premises and query and yiy_i is the next proof step

  7. L←1B∑i=1BCrossEntropy⁡(fθ(xi),yi)\mathcal{L} \leftarrow\frac{1}{B}\sum_{i=1}^{B}\operatorname{CrossEntropy}(f_{\theta}(x_i), y_i) on answer tokens

  8. Update θ\theta to minimize L\mathcal{L}

  9. if at least MM steps have been taken in stage kk and exact-match accuracy over the most recent WW examples ≥τ\ge\tau then

  10. k←k+1k \leftarrow k + 1

  11. end if

  12. end while

  13. return $\theta

Experimental Details

We list the training hyperparameters for each experiment in § 4. All experiments use AdamW (β1=0.9\beta_1 = 0.9, β2=0.999\beta_2 = 0.999, ϵ=10−8\epsilon= 10^{-8}) with a constant learning rate, no weight decay, gradient clipping at 1.0, and bf16 mixed precision; we find scheduled learning rates consistently degrade or fail to improve over constant LR. All experiments use a fixed random seed of 1234. Unless noted, every experiment uses 100 warmup steps, τ=0.98\tau= 0.98 rolling-accuracy advancement threshold over a rolling window of W=800W = 800 examples, and a 200-step floor per stage. Training uses predominantly 2–4× NVIDIA H100 80GB GPUs, with 8× NVIDIA H200 used for Pythia-2.8B and 6× NVIDIA A100 80GB used for Pythia-160M and parts of the Qwen3-1.7B downstream training. Gradient accumulation is chosen to match the effective batch size listed per experiment. Downstream evaluation uses a single NVIDIA A100 GPU.

Notation. “Batch size” refers to the combined effective batch size across GPUs. All Pythia and Qwen3 models are initialized from the released checkpoints (Pythia: base; Qwen3: the post-trained release) unless explicitly marked random init.

Joint Curriculum vs. Fixed-Vocabulary

Both configurations use Qwen3-0.6B (full FT) with the same optimization stack as Section 4.1: batch 768, LR 5×10−55 \times10^{-5}, curriculum step s=8s = 8 to L=256L=256. They differ only in attribute-vocabulary handling: the joint configuration scales the attribute vocabulary size with stage as ∣Vk∣=2(Lk+1)|V_k| = 2(L_k + 1), while the fixed-vocabulary configuration holds ∣V∣|V| at the maximum from the start. The runs with ∣Vk∣=bLk+2|V_k| = bL_k + 2 for b∈{3,4}b \in\{3, 4\} use the same settings.

Curriculum vs. No-Curriculum

SettingCurriculumNo-curriculum
ModelQwen3-0.6B (full FT)Qwen3-0.6B (full FT)
Batch size768768
Learning rate5×10−55 \times10^{-5}5×10−55 \times10^{-5}
Curriculum step ss8N/A
LL8→2568 \to256{96,104,112,120,128,256}\{96, 104, 112, 120, 128, 256\}

Table 5. Hyperparameters for Section 4.1 (Qwen3-0.6B).

Scaling Behavior

Qwen3-0.6B uses batch 768 and LR 5×10−55 \times10^{-5} with s=1s = 1 and a target of L=256L=256; Pythia-1.4B uses the per-model settings in Table 6 with s=1s = 1 and a target of L=96L=96.

Curriculum Step Size Sweep

All six step sizes share the same Qwen3-0.6B optimization stack: batch 768, LR 5×10−55 \times10^{-5}, curriculum to L=256L=256.

Model Size Sweep

Batch size and learning rate are tuned per model size by a small grid search; for each model, we select the (batch size, learning rate) pair that produces the fastest curriculum advancement during early stages.

ModelBatch sizeLR
Pythia-160M1921×10−41 \times10^{-4}
Pythia-410M1925×10−55 \times10^{-5}
Pythia-1.4B1922.7×10−52.7 \times10^{-5}
Pythia-2.8B1,5362.7×10−52.7 \times10^{-5}

Table 6. Per-model hyperparameters for Section 4.4 (Pythia model-size sweep). All sizes: s=1s=1, AdamW, constant LR.

Initialization

Random initialization makes little progress under the small learning rate suited to fine-tuning, so each condition uses its own best-found learning rate and batch size.

ConditionBatch sizeLRInit
Pythia-1.4B, pretrained1922.7×10−52.7 \times10^{-5}Pythia-1.4B base
Pythia-1.4B, random init7681×10−41 \times10^{-4}default initializer
Qwen3-0.6B, pretrained7685×10−55 \times10^{-5}Qwen3-0.6B post-trained release
Qwen3-0.6B, random init1,5363×10−43 \times10^{-4}default initializer

Table 7. Hyperparameters for Section 4.5 (s=1s=1; curriculum to L=96L=96 for Pythia-1.4B and to L=256L=256 for Qwen3-0.6B). The Qwen3-0.6B pretrained row reuses the training from Section 4.2.

Downstream Reasoning Transfer

Qwen3-1.7B uses a 6% Dolci-Instruct-SFT mix-in alongside the graph-search curriculum; the matched-compute baseline trains the same model on the same mix without curriculum, directly at L=48L=48. The instruction-only control trains the same model with the same optimizer settings on 100% Dolci-Instruct-SFT, with no graph-search data. All three configurations wrap inputs in a chat template with enable_thinking=False.

ConfigurationMix
Qwen3-1.7B, curriculum6%
Qwen3-1.7B, no curriculum (direct at L=48L=48)6%
Qwen3-1.7B, instruction only100%

Table 8. Hyperparameters for Section 4.6. All: AdamW, constant LR 5×10−55 \times10^{-5}, batch 768, chat template with enable_thinking=False. The curriculum uses s=1s=1 up to L=48L=48.

Detailed Experimental Results

This appendix tabulates the core experiments of Section 4, with one subsection per experiment.

Full Per-LL Curriculum vs. No-Curriculum Sweep

Figure 9 shows training-compute-vs-accuracy curves for the complete sweep of target lookaheads L∈{96,104,112,120,128,256}L \in\{96, 104, 112, 120, 128, 256\} from Section 4.1. The body of the paper shows three representative panels (L=96,128,256L=96, 128, 256) for compactness; the additional intermediate values (L=104,112,120L=104, 112, 120) included here exhibit the same qualitative pattern: training with curriculum reaches the 98% threshold 1.25–2.27×\times faster than training without curriculum at every L≤128L \le128 (Table 1).

Figure 9. Same layout as Figure 2, for the full sweep L∈{96,104,112,120,128,256}L \in\{96, 104, 112, 120, 128, 256\}.

Joint Curriculum vs. Fixed Attribute Vocabulary

Table 9 reports, for the joint curriculum and for the lookahead-only curriculum with a fixed attribute vocabulary (Section 4.1), the cumulative compute at which each configuration completes stage LL, and the stage completed at the shared budget.

Model Size

Table 10 reports, for the four Pythia sizes trained under the curriculum with s=1s=1, the achieved lookahead LL at the end of training and the cumulative training compute at which that stage is completed. Table 11 reports the stage completed at fixed compute budgets. Both use the convention of Section 4 (the reported LL is the last stage completed).

ModelAchieved lookahead LLCompleted at (PFLOPs)
Pythia-160M9921K
Pythia-410M461.72M
Pythia-1.4B754.97M
Pythia-2.8B1332.55M

Table 10. Achieved lookahead LL at the end of training for each Pythia size under the curriculum with s=1s=1, and the cumulative training compute (PFLOPs, computed as 6N6N per token) at which that stage is completed.

Model100K200K300K500K750K1MLLPFLOPsTokens
Pythia-160M7788899995,6621,022B
Pythia-410M303437404244462,017,056828B
Pythia-1.4B344146525658755,000,829589B
Pythia-2.8B3146607384941332,561,267154B

Table 11. Curriculum stage completed by each Pythia size (s=1s=1) at fixed cumulative training compute and at the end of training. Pythia-410M leads Pythia-1.4B only below ∼30\sim30K PFLOPs, and Pythia-2.8B overtakes Pythia-1.4B between 100K and 200K PFLOPs. Pythia-2.8B completes L=130L=130 at 2.40M PFLOPs and L=133L=133 at 2.55M PFLOPs; Pythia-1.4B completes L=75L=75 at 4.97M PFLOPs.

Table 12 reports the cumulative compute at which each Pythia size completes stage LL.

Model8162432486496128
Pythia-160M253K–––––––
Pythia-410M7487.64K34.3K134K––––
Pythia-1.4B1.07K7.75K28.2K73.6K385K1.65M––
Pythia-2.8B2.62K15.2K33.6K102K212K347K1.04M2.30M

Table 12. Cumulative training compute (PFLOPs) at which each Pythia model completes stage LL under the curriculum with s=1s=1. A dash (–) means the model never reached that lookahead during training. Training ends with L=9L=9 (160M, 996K PFLOPs), 46 (410M, 2.02M), 75 (1.4B, 5.00M) and 133 (2.8B, 2.56M) completed. PFLOPs are computed as 6N6N per token with actual parameter counts.

Table 13 reports the same stage completions in training tokens.

Model8162432486496128
Pythia-160M260–––––––
Pythia-410M0.313.114.155.1––––
Pythia-1.4B0.130.913.38.745.4194.8––
Pythia-2.8B0.160.912.06.212.720.962.5138.4

Table 13. Training tokens (billions) at which each Pythia model completes stage LL under the curriculum with s=1s=1; the same stage completions as Table 12, in tokens rather than PFLOPs. A dash (–) means the model never reached that lookahead during training.

Initialization

Table 14 reports, for Pythia-1.4B and Qwen3-0.6B initialized from the released checkpoint or from random weights (§ 4.5), the cumulative compute at which each condition completes stage LL and the stage completed at two budgets.

Intermediate pretraining checkpoints. We test whether the benefit grows with the amount of pretraining within a single model. We fine-tune Pythia-1.4B from three intermediate checkpoints released by Biderman et al. [3], at pretraining steps 1,000, 10,000 and 100,000 (about 2.1B, 21B and 210B tokens). Each trajectory follows the curriculum with s=1s=1, using the pretrained Pythia-1.4B batch size and learning rate (192 and 2.7×10−52.7 \times10^{-5}) with no warmup, and stops at 500K PFLOPs. Later checkpoints advance faster (Figure 10, Table 15). The step-100,000 checkpoint completes L=24L=24 with about 9×9\times less compute than the step-1,000 checkpoint and reaches L=57L=57 within the budget, while both earlier checkpoints stop at L=27L=27. The advantage of step 10,000 over step 1,000 shrinks as LL grows, while the advantage of step 100,000 over step 10,000 widens. Even the step-1,000 checkpoint completes L=8L=8 with about 8×8\times less compute than random initialization.

Figure 10. Achieved lookahead LL vs. cumulative training compute (PFLOPs) for Pythia-1.4B fine-tuned from intermediate pretraining checkpoints, each stopped at 500K PFLOPs. The dashed curve is the random-initialization trajectory from Section 4.5.

Stage LLStep 1,000 (∼2.1B tokens)Step 10,000 (∼21B)Step 100,000 (∼210B)
89.95K3.79K1.04K
1683.0K43.1K7.25K
24259K203K27.7K
32––66.7K
48––235K
LL at 100K172038
LL at 300K242551
LL at 500K272757

Table 15. Cumulative training compute (PFLOPs) at which Pythia-1.4B, fine-tuned from intermediate pretraining checkpoints, completes stage LL under the curriculum with s=1s=1, and the stage completed at three budgets. Column headers give the pretraining step and the approximate number of pretraining tokens. A dash (–) means the model never reached that lookahead during training. Each trajectory ends at 500K PFLOPs.

LoRA vs. Full Fine-Tuning

LoRA vs. Full Fine-Tuning

We compare full fine-tuning, used in all other experiments, with LoRA [24] at ranks r=8r=8 and r=64r=64. All three conditions train Qwen3-0.6B under the curriculum with s=8s=8 up to L=128L=128, using the step-size sweep settings of Appendix § 9 without warmup. Adapters are applied to all attention and MLP projections, with α=2r\alpha=2r and dropout 0.1. Because the frozen base weights need no weight gradients, we count LoRA compute as 4N+6NLoRA4N + 6N_{\mathrm{LoRA}} per token, where NLoRAN_{\mathrm{LoRA}} is the number of adapter parameters. Both ranks reach L=128L=128 with roughly the same compute as full fine-tuning (0.95× for r=8r=8 and 0.85× for r=64r=64) but need more optimizer steps (1.56× and 1.13×; Table 16). Each condition uses a single seed, so these ratios are approximate. We use full fine-tuning elsewhere because it reaches the same lookahead with similar compute and does not require choosing a LoRA rank.

Stage LLCompute (PFLOPs)Optimizer steps
Full FTr=8r=8r=64r=64Full FTr=8r=8r=64r=64
324.25K7.97K4.49K3,2508,5754,375
6425.6K34.3K22.1K10,70022,17512,600
9666.5K60.4K45.2K19,55031,00019,475
128116K110K98.1K27,57543,12531,200

Table 16. Cumulative training compute and optimizer steps at which Qwen3-0.6B completes stage LL under the curriculum with s=8s=8, with full fine-tuning (Full FT) and with LoRA at rank rr. LoRA compute is counted as 4N+6NLoRA4N + 6N_{\mathrm{LoRA}} per token.

Functional forms for achieved lookahead

We fit achieved lookahead LL as a function of cumulative training compute CC for the two trajectories of § 4.2, Qwen3-0.6B and Pythia-1.4B, and for the less trained Pythia-410M and Pythia-2.8B, using the power law and saturating exponential defined there. This appendix reports the full comparison (RMSE with confidence intervals, AICc, and held-out prediction of both cumulative lookahead and per-stage training iterations), along with the per-size saturating exponential fits underlying the ceiling analysis of § 4.2 (Figure 11).

Data and procedure. Stage completions (one point per stage, L∈[1,Lend]L \in[1, L_{\mathrm{end}}], at the compute where the 98% gate is passed) yield n=244n=244 points for Qwen3-0.6B and n=46n=46, 75 and 133 for Pythia-410M, -1.4B and -2.8B. We fit each form with SciPy differential_evolution (Sobol init, popsize=30, maxiter=200, seed=42) polished by Levenberg–Marquardt, retaining the lowest-RSS solution. Confidence intervals on RMSE are 95% moving-block bootstrap intervals (block length ≈n1/3\approx n^{1/3}, 300–500 resamples), which partly account for the serial correlation of a single trajectory; with residual autocorrelation persisting over many lags they should be read as descriptive, not as calibrated 95% intervals. AICc treats the stage points as independent, which they are not (residual autocorrelation exceeds 0.8 at lag 1), so we read it as a ranking of in-sample fit rather than as a calibrated test; the formal comparison is the held-out test on per-stage training iterations in Appendix D.1. Because the power-law offset is at its bound L0=0L_0=0 in every fit and the saturating exponential approaches aCkaC^k as C0C_0 grows, the in-sample comparison is one-sided by construction and only the size of the RMSE gap is informative. Held-out comparisons fit both forms on the first 70% of the stage points, ordered by compute, and evaluate their predictions on the remainder (Table 17).

TrajectoryHeld-out RMSERatiopp
Power lawSat. exp.
Qwen3-0.6B23.8817.081.407×10−107\times10^{-10}
Pythia-410M8.230.849.800.018
Pythia-1.4B16.140.6823.771.5×10−41.5\times10^{-4}
Pythia-2.8B9.253.722.490.65

Table 17. Held-out prediction error for achieved lookahead LL on all four s=1s=1 trajectories, fitting on the first 70% of stage completions and predicting the remainder. Ratio is power-law over saturating-exponential RMSE. pp: significance of the saturating exponential’s advantage under the per-stage iteration test of Appendix D.1, two-sided.

TrajectorynnLendL_{\mathrm{end}}Power-law RMSE [95% CI]Saturating exponential RMSE [95% CI]Δ\DeltaAICc
Qwen3-0.6B2442446.10 [3.27, 6.75]2.22 [1.57, 2.35]493
Pythia-410M46461.93 [0.71, 2.05]0.47 [0.32, 0.53]130
Pythia-1.4B75752.98 [1.69, 3.24]0.53 [0.40, 0.57]259
Pythia-2.8B1331332.67 [1.92, 3.16]2.15 [1.46, 2.54]57

Table 18. Fit comparison for the four long s=1s=1 trajectories. Δ\DeltaAICc is (power-law − saturating exponential); positive favors the saturating exponential, and since both forms have three parameters it reflects fit quality alone. RMSE confidence intervals are 95% moving-block bootstrap. Both in-sample criteria favor the saturating exponential on every trajectory. Held-out prediction is compared in Table 17 and Appendix D.1.

What the comparison shows. On every trajectory the saturating exponential attains lower RMSE, is preferred by AICc (Δ\DeltaAICc = 57–493; Table 18) and predicts the held-out stages with lower RMSE (Table 17). The in-sample gap is largest on the three trajectories nearest their fitted ceilings and small on Pythia-2.8B (RMSE 2.67 vs. 2.15), which sits at only ∼\sim57% of its fitted ceiling and whose RMSE intervals overlap; the two forms separate more cleanly as a model nears its ceiling. Appendix D.1 reports a significance test on per-stage training iterations. Figure 11 plots the per-size saturating exponential fits (parameters in Table 19); the resulting ceilings (Lmax⁡≈51L_{\max} \approx51, 82, 235) underlie the ceiling analysis in Section 4.2. The bootstrap intervals in Table 19 show that the lower bound of each ceiling is well determined, while the upper bound is poorly determined for the two trajectories furthest from saturation, Qwen3-0.6B and Pythia-2.8B. Pythia-160M plateaus at L=9L=9 (Section 4.4) and is excluded, since neither form is meaningful for a capacity-limited trajectory.

Held-out prediction of per-stage training iterations

A Diebold–Mariano test on the held-out residuals of L(C)L(C) is not valid for these trajectories. Its variance estimate assumes a weakly dependent loss differential, whereas the held-out residuals along a single trajectory share one extrapolation error and are strongly autocorrelated (lag-1 autocorrelation 0.95 for Qwen3-0.6B and 0.92 for Pythia-2.8B; Table 20). We therefore compare the two forms on a quantity whose residuals are approximately independent, the number of training iterations required to complete each stage, ΔI(L)=I(L)−I(L−1)\Delta I(L) = I(L) - I(L - 1) with I(0)=0I(0) = 0, where I(L)I(L) is the cumulative number of optimizer steps at the completion of stage LL. We use iterations rather than compute because the compute cost of a stage is its iteration count multiplied by the tokens per step, and tokens per step grow with LL as the sequence length grows, so per-stage iterations isolate the learning dynamics from that growth. Each form implies a per-stage iteration count g(L)−g(L−1)g(L) - g(L - 1), where gg is the inverse of the form fitted with cumulative iterations as the independent variable. We fit both forms to log⁡ΔI(L)\log\Delta I(L) by least squares on the first 70% of stages, ordered by compute, and predict the remaining stages. Table 20 shows that on per-stage iterations the residuals of the saturating exponential are consistent with independence on three trajectories and marginal on Pythia-1.4B (p=0.046p = 0.046).

TrajectoryCumulative lookahead L(C)L(C)Per-stage iterations ΔI(L)\Delta I(L)
lag-1 autocorr.Ljung–Box pplag-1 autocorr.Ljung–Box pp
Qwen3-0.6B0.952×10−1992 \times10^{-199}−0.140.15
Pythia-410M0.250.36−0.280.36
Pythia-1.4B0.330.08−0.330.046
Pythia-2.8B0.924×10−944 \times10^{-94}−0.100.13

Table 20. Residual dependence of the saturating exponential fit on cumulative lookahead and on per-stage training iterations (log units). Ljung–Box tests use five lags. Per-stage iterations remove the serial dependence that invalidates a Diebold–Mariano test on cumulative lookahead.

For each held-out stage we form the loss differential dL=ePL(L)2−eSE(L)2d_L = e_{\mathrm{PL}}(L)^2 - e_{\mathrm{SE}}(L)^2 in log units, which is positive when the saturating exponential predicts that stage better. Because the advantage may grow with depth, we regress dLd_L on the centered stage index with Newey–West standard errors (Bartlett kernel, bandwidth ⌊4(T/100)2/9⌋\lfloor4(T/100)^{2/9} \rfloor) and report the intercept α\alpha, which equals the mean of dLd_L, and the slope β\beta (Table 21). All pp-values are two-sided and are stable for bandwidths from 0 to four times this rule. The saturating exponential has lower held-out RMSE on per-stage iterations for three trajectories and ties on Pythia-2.8B. The advantage is significant for Qwen3-0.6B, Pythia-410M and Pythia-1.4B, and on all three it grows with depth (β>0\beta> 0). Across train/held-out splits from 50% to 80% of the stages, α\alpha is significant at every split for Qwen3-0.6B and Pythia-410M, at the 70% split only for Pythia-1.4B, and at no split for Pythia-2.8B. The Pythia-1.4B result is sensitive to the split because that trajectory’s per-stage costs vary by two orders of magnitude between adjacent stages, so a held-out set of 8 to 24 stages is dominated by a few of them. For Pythia-2.8B the two forms predict per-stage iterations identically, because the saturating exponential fitted to that trajectory’s iterations has no identified ceiling and reduces to the power law. Per-stage iterations are a noisy quantity, with held-out RMSE near 1 in log units for both forms, so this test has less power than the comparison on cumulative lookahead but rests on assumptions the data satisfy.

TrajectoryTTHeld-out RMSE (log ΔI\Delta I)Mean advantage α\alphaTrend β\beta (per stage)
Sat. exp.Power lawRatioEstimate [95% CI]ppEstimate [95% CI]pp
Qwen3-0.6B730.930.961.040.068 [0.049, 0.087]7×10−107 \times10^{-10}0.0025 [0.0016, 0.0034]1×10−61 \times10^{-6}
Pythia-410M141.141.901.672.33 [0.47, 4.18]0.0180.51 [0.08, 0.95]0.025
Pythia-1.4B231.061.761.661.97 [1.08, 2.86]1.5×10−41.5 \times10^{-4}0.18 [0.05, 0.32]0.010
Pythia-2.8B401.131.131.006×10−66 \times10^{-6} [−2×10−52 \times10^{-5}, 3×10−53 \times10^{-5}]0.65−9×10−7-9 \times10^{-7} [−3×10−63 \times10^{-6}, 1×10−61 \times10^{-6}]0.37

Table 21. Held-out prediction of per-stage training iterations. TT is the number of held-out stages. α\alpha and β\beta are the intercept and slope of dLd_L regressed on the centered stage index, with Newey–West standard errors; α>0\alpha> 0 favors the saturating exponential and β>0\beta> 0 indicates an advantage that grows with depth.

Compute per curriculum stage

Figure 12 shows the mean compute per completed curriculum stage for Pythia-1.4B with s=1s = 1, averaged over consecutive groups of five stages. The last five completed stages, L=71L=71–7575, consume 2.10M PFLOPs, approximately 42% of its 5M-PFLOP budget. Thus, nearly half the training compute produces only five additional stages of progress, illustrating the sharply diminishing returns to further training in this regime. Within this budget, the trajectory reaches L=75L=75, 91% of the fitted asymptote Lmax⁡≈82L_{\max} \approx82, without having plateaued. The flattening captured by the saturating exponential is therefore accompanied by a substantial observed increase in the compute required for further curriculum progress.

Downstream Evaluation Methodology

Next-step proof prediction. On the synthetic next-step prediction task (§ 3.1) we use greedy autoregressive decoding, and the first whitespace- or punctuation-delimited word of the generated continuation is compared case-insensitively with any accepted gold attribute.

We evaluate on 14 reasoning benchmarks (full list in Table 4). Thirteen are scored by log-likelihood over a fixed candidate label set; the open-ended NLGraph benchmark uses its authors’ per-task scorers. Samples are drawn with a fixed random seed, and the number of items per benchmark is listed in Table 25.

BenchmarkReasoning typeAnswer formatSplit / subsetnn
Reasoning benchmarks
ProofWriter OWA†^{\dagger} (Tafjord et al. [51])Synthetic deductiveTrue/False/UnknownOWA, depths 0–5, label-balanced3000
ProofWriter CWA (Tafjord et al. [51])Synthetic deductiveTrue/FalseCWA, depths 0–53000
ParaRules†^{\dagger} (Clark et al. [10])Synthetic deductive, paraphrasedTrue/False/UnknownProofWriter OWA NatLang test, depths 0–5, label-balanced4566
ZebraLogic-MC (Lin et al. [33])Constraint satisfactionMultiple choicemc_mode1000
PrOntoQA†^{\dagger} (Saparov et al. [45])Synthetic deductiveTrue/Falsegenerated, 8 depths up to 644000
FOLIO (Han et al. [20])First-order logicTrue/False/Unknownvalidation203
JustLogic (Chen et al. [7])Knowledge-independent deductiveTrue/False/Uncertaindepths 1–74897
ProverQA (Qi et al. [41])First-order logic with distractors3-way multiple choicedev, easy/medium/hard1497
CLUTRR (Sinha et al. [49])Inductive kinshipRelation label setfull1000
LogicBench-BQA (Parmar et al. [39])Single-rule deductiveYes/NoBQA1512
RuleTaker (Clark et al. [10])Synthetic deductiveTrue/Falsetest, depths D0–D51000
Web of Lies†^{\dagger} (Suzgun et al. [50])Truth-teller chainsYes/Nogenerated, 8 depths up to 64, label-balanced4000
LogiQA (Liu et al. [35]; Zhong et al. [66])Mixed (exam)4-way multiple choiceAGIEval split648
NLGraph (Wang et al. [54])Graph reasoningOpen-ended (8 sub-tasks)full1000
General-capability benchmarks
MMLU (Hendrycks et al. [22])World knowledge4-way multiple choicetest14042
ARC-Easy (Clark et al. [9])Science QA4-way multiple choicetest2376
ARC-Challenge (Clark et al. [9])Science QA4-way multiple choicetest1172
HellaSwag (Zellers et al. [65])Commonsense inference4-way completionvalidation10042
WinoGrande (Sakaguchi et al. [43])Commonsense inference2-way completionvalidation1267
PIQA (Bisk et al. [4])Physical commonsense2-way multiple choicevalidation1838
BoolQ (Clark et al. [8])Reading comprehensionYes/Novalidation3270
LAMBADA (Paperno et al. [38])Reading comprehensionLast-word predictiontest (OpenAI)5153
IFEval (Zhou et al. (2023))Instruction followingGeneration, prompt-level strictfull541

Table 25. The fourteen downstream reasoning benchmarks and the nine general-capability benchmarks, with the number of evaluation items nn. General-capability benchmarks use the default lm-evaluation-harness splits. ProofWriter appears twice because its open- and closed-world splits differ in label set. NLGraph is scored with the authors’ per-task scorers, and we report the mean over its eight sub-tasks (Appendix § 12). †^{\dagger}Modified by us, as described in this appendix.

Why constrained log-likelihood rather than CoT. Several of these benchmarks are designed for chain-of-thought or free-form decoding. Our curriculum-trained models do not produce verbose CoT natively. The curriculum task contains no signal for natural-language reasoning style, so unconstrained free-form decoding would entangle output style with underlying capability. For benchmarks with a fixed answer set we therefore use log-likelihood scoring over the candidate labels, isolating reasoning from format-following. This is the same convention used by lm-evaluation-harness [16] for its loglikelihood request type.

Fused single-pass scoring. For each example we run the model once on the prompt and compute the per-token log-probabilities of every candidate label. When a label tokenizes to a single token (the common case for True/False/Unknown, multiple-choice letters, etc.) we read its log-prob directly from the next-token distribution. For multi-token labels we fall back to teacher-forced log-likelihood with the same approach as lm-evaluation-harness: walk forward to the first divergent token between tokenize(prefix) and tokenize(prefix + label), then sum log-probs of the suffix tokens. This handles BPE boundary merges correctly and remains a single forward pass per choice.

Reported metric. The headline accuracy reported in Table 4 is log-likelihood accuracy: argmax over candidate labels by total log-probability. This matches the dominant convention for log-likelihood-scored benchmarks in the literature.

Per-benchmark prompting protocol. For each benchmark we adapt its canonical LLM evaluation protocol to a constrained-log-likelihood setting: we keep the canonical demonstration count and prompt format where compatible, and substitute Direct prompting where the canonical convention uses chain-of-thought. The same protocol is applied to the base model, every curriculum checkpoint, the no-curriculum baseline, and the instruction-only control for each benchmark. Per-benchmark choices are summarized in Table 22.

BenchmarkCanonical LLM protocolOur protocol
Reasoning benchmarks
ProofWriter OWAnone0-shot Direct
ProofWriter CWAnone0-shot Direct
ParaRulesnone0-shot Direct
ZebraLogic-MCnone3-shot Direct
PrOntoQA8-shot CoT [45]8-shot Direct
FOLIO8-shot [20]8-shot Direct
JustLogic3-shot [7]3-shot Direct
ProverQA2-shot [41]2-shot Direct
CLUTRRnone5-shot Direct
LogicBench-BQA0-shot CoT [39]3-shot Direct
RuleTakernone5-shot Direct
Web of Lies3-shot [50]3-shot Direct
LogiQA0-shot [66]0-shot Direct
NLGraph1–5-shot [54]1–5-shot, generation
General-capability benchmarks
MMLU0-shot [16]0-shot
IFEval0-shot (Zhou et al., 2023)0-shot, generation
ARC-Enone0-shot
ARC-Cnone0-shot
HellaSwagnone0-shot
WinoGrandenone0-shot
PIQAnone0-shot
BoolQnone0-shot
LAMBADAnone0-shot

Table 22. Per-benchmark prompting protocol. Where a benchmark has a canonical zero-shot protocol, we keep it; where it has a canonical few-shot protocol, we use its shot count; where the canonical protocol uses chain-of-thought or no LLM protocol exists, we use Direct prompting. All demonstrations show the question and label only and are removed from the scored items. The seven general-capability benchmarks without a canonical protocol use the lm-evaluation-harness default of zero-shot.

Sampling and stratification. Item counts per benchmark are listed in Table 25. For benchmarks with subsets (per-depth, per-task, or per-puzzle-size), we draw a fixed-seed random sample within each subset rather than a deterministic prefix. ProofWriter OWA and ParaRules are label-balanced within each depth; PrOntoQA and Web of Lies use 500 items per depth; NLGraph uses 125 items per sub-task.

NLGraph (generation). NLGraph contains 8 sub-tasks (shortest path, Hamilton, connectivity, etc.) and the canonical scoring is per-task: path validation for Hamilton, weight match for shortest path, regex-based answer extraction for others. We use the authors’ canonical k-shot-prompt.txt files (with task-dependent kk, no CoT) and their per-task scorers ported from the official repo. The accuracy we report on NLGraph is the average of these per-task scores.

Confidence Intervals on Downstream Results

Table 23 reports the accuracies of Table 4 with 95% confidence intervals, together with the base model and the instruction-only control, and marks every curriculum checkpoint that is significantly above training without curriculum, not only the best one per benchmark. The base model and the instruction-only control are not part of the matched comparison, and they score above curriculum L=48L=48 on four and six of the 14 benchmarks, respectively.

BenchmarkBase8163248No curr.Instr. only
ProofWriter OWA40.3±\pm1.841.1±\pm1.833.6±\pm1.739.3±\pm1.754.9±\pm1.8*40.6±\pm1.847.8±\pm1.8
ProofWriter CWA52.7±\pm1.866.8±\pm1.7*57.2±\pm1.8*67.6±\pm1.7*67.9±\pm1.7*55.2±\pm1.858.0±\pm1.8
ParaRules43.8±\pm1.446.1±\pm1.436.2±\pm1.439.1±\pm1.455.1±\pm1.4*50.4±\pm1.557.1±\pm1.4
ZebraLogic-MC25.5±\pm2.747.4±\pm3.153.4±\pm3.1*51.8±\pm3.1*53.5±\pm3.1*48.3±\pm3.153.2±\pm3.1
PrOntoQA{sup}†`53.1±\pm1.552.5±\pm1.555.3±\pm1.5*56.8±\pm1.5*57.1±\pm1.5*52.0±\pm1.552.2±\pm1.5
FOLIO45.3±\pm6.845.8±\pm6.9*46.3±\pm6.9*45.8±\pm6.9*45.8±\pm6.9*41.4±\pm6.845.3±\pm6.8
JustLogic60.9±\pm1.451.1±\pm1.4*52.6±\pm1.4*45.5±\pm1.453.5±\pm1.4*46.1±\pm1.455.7±\pm1.4
ProverQA48.0±\pm2.542.0±\pm2.544.4±\pm2.546.3±\pm2.547.8±\pm2.549.2±\pm2.552.0±\pm2.5
CLUTRR28.6±\pm2.825.5±\pm2.727.2±\pm2.823.2±\pm2.628.6±\pm2.826.7±\pm2.722.3±\pm2.6
LogicBench-BQA73.9±\pm2.274.2±\pm2.2*72.5±\pm2.374.1±\pm2.2*73.6±\pm2.2*71.2±\pm2.369.5±\pm2.3
RuleTaker67.8±\pm2.960.5±\pm3.060.6±\pm3.063.5±\pm3.0*60.0±\pm3.058.8±\pm3.170.4±\pm2.8
Web of Lies{sup}†`53.0±\pm1.555.5±\pm1.556.5±\pm1.557.2±\pm1.557.9±\pm1.557.8±\pm1.558.8±\pm1.5
LogiQA39.4±\pm3.842.6±\pm3.844.9±\pm3.844.9±\pm3.842.4±\pm3.843.4±\pm3.843.2±\pm3.8
NLGraph35.8±\pm3.041.5±\pm3.143.5±\pm3.144.3±\pm3.143.7±\pm3.146.2±\pm3.139.5±\pm3.0

Table 23. Downstream reasoning accuracy (%) of Qwen3-1.7B from Table 4, with 95% confidence intervals, given by a simple normal approximation. Base is the non-finetuned Qwen3-1.7B under the same prompts, with the answer cue prefilled in its own markdown answer format. Instruction-only is trained on the instruction data alone at compute matched to curriculum L=48L=48. \*: curriculum checkpoint significantly above no curriculum (two-sided exact McNemar test on paired items, p<0.05p < 0.05). {sup}†Extended by us to greater depths ({xref}Appendix G`).

General Model Capability

Table 24 reports the accuracies summarized in § 4.6. The benchmarks are MMLU, ARC-Easy and ARC-Challenge, HellaSwag, WinoGrande, PIQA, BoolQ, LAMBADA and IFEval. Each is evaluated on the non-finetuned Qwen3-1.7B, on an instruction-only control, on the model trained without curriculum, and on four curriculum stage checkpoints. The first eight benchmarks probe knowledge and single-step commonsense rather than multi-step deductive chaining, so we do not expect the curriculum to improve them.

Because the curriculum trains the model almost exclusively on synthetic proof data, it could plausibly narrow the capabilities of the model in other respects. We evaluate Qwen3-1.7B on 8 standard benchmarks spanning world knowledge (MMLU), science QA (ARC-Easy/Challenge), commonsense inference (HellaSwag, WinoGrande, PIQA), reading comprehension (BoolQ) and discourse-level language modeling (LAMBADA), plus IFEval for instruction following, using an identical lm-evaluation-harness protocol for every model evaluated. Mean accuracy over the eight is above the non-finetuned model’s at every curriculum stage (63.4 to 64.2 vs. 63.1, Table 24). The largest single-benchmark drop below it is WinoGrande at L=48L=48 (59.8 vs. 61.7). IFEval is also above the non-finetuned model at every stage (34.6 to 41.2 vs. 33.1). Because our training mixture also contains instruction data, a comparison against the non-finetuned model alone would leave open the possibility that this instruction data offsets damage done by the synthetic data. We therefore fine-tune the same base model on 100% Dolci-Instruct-SFT, with no synthetic data and no curriculum but otherwise identical hyperparameters, and evaluate it at cumulative training compute matched to the L=48L=48 curriculum checkpoint. It scores within one point of that checkpoint on the eight-benchmark mean (64.2 vs. 63.4), so training on the synthetic data adds little measurable cost on these benchmarks. The model trained without curriculum on the same data at the same compute scores essentially the same as the curriculum (63.2), so the curriculum itself adds no further cost. On IFEval, the L=48L=48 checkpoint scores below the instruction-only control (41.2 vs. 46.4), which trains on instruction data alone, and slightly above the model trained without curriculum (40.1). Thus, we find no evidence that gains in implicit reasoning capability are at the expense of general model capability.

Benchmark Descriptions

Table 25 summarizes the fourteen downstream reasoning benchmarks and the nine general-capability benchmarks: the reasoning type each targets, the answer format we score, the split or subset we evaluate, and the number of evaluation items nn. The prompting protocol for each benchmark is given in Table 22.

PrOntoQA. The released PrOntoQA data stops at 4 to 5 hops, and the shipped generator cannot go further, because it samples a random ontology over 17 concept names and takes a random proof walk through it. We replace the ontology sampler with a chain of exactly k+1k+1 concepts, script the walk to the unique kk-step proof, and enlarge the vocabulary to 624 names and 274 adjectives. Rendering, inflection, parsing, distractors and label negation use the official code. An independent solver verifies every item for its label, for a proof depth equal to kk, for consistency, and for distractor sign. The set covers eight depths, k∈{1,2,4,8,16,32,48,64}k \in\{1, 2, 4, 8, 16, 32, 48, 64\}, 500 items each, balanced on both the label and the query polarity.

ProofWriter OWA and ParaRules. We use the published data but draw equal numbers of True, False and Unknown items within each official QDep stratum. Without this, the Unknown share falls from 69% at depth 0 to 3% at depth 5, because an unprovable question inherits the depth of its deepest failing search, so a model that always answers Unknown would score 66% at depth 0 and 4% at depth 5. Balancing fixes chance at 33.3% at every depth. The closed-world split is already near 50/50 at every depth and needs no resampling. We apply the same balancing to ParaRules, whose items come from the ProofWriter open-world NatLang test split.

Web of Lies. Our Web of Lies set is generated from the BBH web_of_lies template and its 50-name pool, as truth-value chains of k∈{1,2,4,8,16,32,48,64}k \in\{1, 2, 4, 8, 16, 32, 48, 64\} speakers with 500 items per depth and exactly balanced Yes/No labels. Our solver reproduces all 250 published BBH items, all of which have k=4k=4.

All other benchmarks are the published data as released. Source repositories: ProofWriter from AllenAI proofwriter-dataset-v2020.12.3; FOLIO from yale-nlp/FOLIO; ZebraLogic from WildEval/ZebraLogic; RuleTaker from tasksource/ruletaker (fallback hitachi-nlp/ruletaker); CLUTRR from kendrivp/CLUTRR_v1_extracted (fall-klang5/CLUTRR_huggingface_dataset); LogiQA from Zhong et al. [66]; LogicBench and NLGraph from their authors’ releases.

Training Data Examples

We show generated training examples at three lookahead values to illustrate how problem complexity scales across curriculum stages. Each example consists of premises (rendered as conditional predicates), a query naming the start fact and goal, and a proof prefix ending where the model must predict. The model’s target output is a single attribute (tokenized as one or more BPE tokens). Within a stage, lookaheads are sampled uniformly from 1 to the cap, so most stage-LL instances have lookahead below LL; the examples below are chosen with lookahead equal to the cap.

Stage cap L=2L=2, example lookahead ℓ=2\ell= 2 (5 attributes)

Suppose we have the following facts: If someone is itaema, then they are isum. If a person is ugphi, they are itaema. If Krystal is nwazao, then they are asico. If Krystal is ugphi, then they are nwazao. Given that Krystal is ugphi, and we want to prove Krystal is asico. Proof: Krystal is ugphi. Krystal is __________

Answer: nwazao

Stage cap L=8L=8, example lookahead ℓ=8\ell= 8 (17 attributes)

Suppose we have the following facts: If someone is kfusau, then they are kacown. If a person is aqyqoj, they are adawr. Everyone that is fucboo is nuuht. Everyone that is kacown is upocoo. If a person is yuekl, they are xwohoo. If Steven is buey, then Steven is zacipo. Everyone that is xuilat is wxilvu. Everyone that is ahxbwu is ezhol. If Steven is adawr, then Steven is fucboo. If someone is aqyqoj, then they are ornce. If a person is ecqni, they are ahxbwu. If someone is upocoo, then they are yuekl. If Steven is ezhol, then Steven is xuilat. Everyone that is nuuht is kfusau. If someone is ornce, then they are buey. If Steven is zacipo, then they are ecqni. Given that Steven is aqyqoj, and we want to prove Steven is xwohoo. Proof: Steven is aqyqoj. Steven is __________

Answer: adawr

Stage cap L=32L=32, example lookahead ℓ=32\ell= 32 (65 attributes)

Suppose we have the following facts: If someone is pyaqau, then they are tsawob. If Jennifer is etuupu, then they are poqgje. If a person is vaorea, they are zfaqa. If Jennifer is dduosi, then they are biisi. Everyone that is saiaqt is heeru. If someone is ussdoi, then they are gidxio. Everyone that is fosin is miaize. If someone is xdilxo, then they are ivgau. Everyone that is azlwoo is inaba. Everyone that is hzueda is azlwoo. If Jennifer is owaosy, then they are ahuvyi. If Jennifer is inaba, then Jennifer is agez. If Jennifer is iklau, then they are pyaqau. If Jennifer is ahuvyi, then Jennifer is afueji. If a person is miaize, they are efeh. If Jennifer is wimeu, then they are taew. If Jennifer is efeh, then Jennifer is saiaqt. Everyone that is ssoone is ruosa. Everyone that is idudz is ezejoi. If someone is hjinua, then they are ughtuf. If Jennifer is biisi, then they are faxids. Everyone that is zg uul is dpielu. If someone is elorbi, then they are ruywqo. If Jennifer is aqico, then Jennifer is oresu. If Jennifer is ruosa, then they are hjinua. If Jennifer is afueji, then they are oxuogj. If Jennifer is ict ox, then Jennifer is etuupu. If someone is gidxio, then they are raeesb. If a person is heereu, they are owaosy. If Jennifer is liiz, then they are elorbi. If Jennifer is yuq bop, then Jennifer is ekice. If a person is raeeb, they are yuq bop. If a person is umuf, they are iyeriu. If Jennifer is emaca, then they are ssoone. Everyone that is yoxo is fosin. Everyone that is ekice is zaxbom. If Jennifer is dpielu, then they are obaqka. If someone is apenii, then they are luanx. If someone is faxids, then they are ussdoi. Everyone that is sbooi is wimeu. If Jennifer is xuuur, then they are emaca. If someone is oresu, then they are brapuz. If someone is obaqka, then they are yoxo. If someone is jijiel, then they are idudz. If someone is taew, then they are ufn sih. If a person is apenii, they are yutou. If Jennifer is ufn sih, then Jennifer is aqico. Everyone that is zaxbom is zg uul. If someone is ivgau, then

References

  1. [1]Emmanuel Abbe, Samy Bengio, Aryo Lotfi, Colin Sandon, and Omid Saremi. How far can transformers reason? the globality barrier and inductive scratchpad. In Advances in Neural Information Processing Systems, volume 37, pp. 27850–27895, 2024. URL https://proceedings.neurips.cc/paper_files/paper/2024/hash/3107e4bdb658c79053d7ef59cbc804dd-Abstract-Conference.html.arxiv.org/abs/2406.06467
  2. [2]Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proceedings of the 26th Annual International Conference on Machine Learning, pp. 41–48. ACM, 2009. doi: 10.1145/1553374.1553380.
  3. [3]Stella Biderman, Hailey Schoelkopf, Quentin Gregory Anthony, Herbie Bradley, Kyle O’Brien, Eric Hallahan, Mohammad Afkhah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, Aviya Skowron, Lintang Sutawika, and Oskar van der Wal. Pythia: A suite for analyzing large language models across training and scaling. In Proceedings of the 40th International Conference on Machine Learning, ICML’23. JMLR.org, 2023.arxiv.org/abs/2304.01373
  4. [4]Yonatan Bisk, Rowan Zellers, Ronan Le Bras, Jianfeng Gao, and Yejin Choi. PIQA: reasoning about physical commonsense in natural language. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, pp. 7432–7439. AAAI Press, 2020. doi: 10.1609/AAAI.V34I05.6239. URL https://doi.org/10.1609/aaai.v34i05.6239.
  5. [5]Jannik Brinkmann, Abhay Sheshadri, Victor Levoso, Paul Swoboda, and Christian Bartelt. A mechanistic analysis of a transformer trained on a symbolic multi-step reasoning task. In Findings of the Association for Computational Linguistics: ACL 2024, pp. 4082–4102, Bangkok, Thailand, 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.findings-acl.242. URL https://aclanthology.org/2024.findings-acl.242.DOI
  6. [6]Dake Bu, Wei Huang, Andi Han, Atsushi Nitanda, Hau-San Wong, Qingfu Zhang, and Taiji Suzuki. Provable sample efficiency of curriculum post-training for transformer reasoning. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research. PMLR, 2026. doi: 10.48550/arXiv.2511.07372. URL https://arxiv.org/abs/2511.07372.
  7. [7]Michael K. Chen, Xikun Zhang, and Dacheng Tao. Justlogic: A comprehensive benchmark for evaluating deductive reasoning in large language models, 2025. URL https://arxiv.org/abs/2501.14851.
  8. [8]Christopher Clark, Kenton Lee, Ming-Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. BoolQ: Exploring the surprising difficulty of natural yes/no questions. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 2924–2936, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1300. URL https://aclanthology.org/N19-1300/.DOI
  9. [9]Peter Clark, Isaac Cowhey, Oren Etzioni, Thakur Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge, 2018. URL https://arxiv.org/abs/1803.05457.
  10. [10]Peter Clark, Oyvind Tafjord, and Kyle Richardson. Transformers as soft reasoners over language. In Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence (IJCAI), pp. 3882–3890. International Joint Conferences on Artificial Intelligence Organization, 2020. doi: 10.24963/ijcai.2020/537. URL https://doi.org/10.24963/ijcai.2020/537.
  11. [11]Mostafa Dehghani, Stephan Gouws, Ooriol Vinyals, Jakub Uszkoreit, and Łukasz Kaiser. Universal transformers. In The Seventh International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id=HyzdRiR9Y7.
  12. [12]Yuntian Deng, Yejin Choi, and Stuart Shieber. From explicit CoT to implicit CoT: Learning to internalize CoT step by step. arXiv preprint arXiv:2405.14838, 2024.arxiv.org/abs/2405.14838
  13. [13]Francis X. Diebold and Roberto S. Mariano. Comparing predictive accuracy. Journal of Business & Economic Statistics, 13(3):253–263, 1995.
  14. [14]Nouha Dziri, Xingyu Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jiang, Bill Yuchen Lin, Peter West, Chandra Bhagavatula, Ronan Le Bras, Jena D. Hwang, Soumya Sanyal, Sean Welleck, Xiang Ren, Allyson Ettinger, Zaid Harchaoui, and Yejin Choi. Faith and fate: Limits of transformers on compositionality. In Advances in Neural Information Processing Systems, volume 36, pp. 70293–70332, 2023.
  15. [15]Kanishk Gandhi, Denise Lee, Gabriel Grand, Muxin Liu, Winson Cheng, Archit Sharma, and Noah D. Goodman. Stream of search (SoS): Learning to search in language. In First Conference on Language Modeling, 2024. URL https://openreview.net/forum?id=6LNTrsJjBe.arxiv.org/abs/2404.03683
  16. [16]Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Golding, Jeffrey Hsu, Alain Le Noac’h, Haonan Li, Kyle McDonnell, Niklas Muennighoff, Chris Ociepa, Jason Phang, Laria Reynolds, Hailey Schoelkopf, Aviya Skowron, Lintang Sutawika, Eric Tang, Anish Thite, Ben Wang, Kevin Wang, and Andy Zou. A framework for few-shot language model evaluation, 2026. URL https://zenodo.org/records/18636344.
  17. [17]Jonas Geiping, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian R. Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. Scaling up test-time compute with latent reasoning: A recurrent depth approach. In Advances in Neural Information Processing Systems, volume 38, 2025. URL https://openreview.net/forum?id=S3GhJooWIC.arxiv.org/abs/2502.05171
  18. [18]Sachin Goyal, Ziwei Ji, Ankit Singh Rawat, Aditya Krishna Menon, Sanjiv Kumar, and Vaishnavh Nagarajan. Think before you speak: Training language models with pause tokens. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=ph04CRkPdC.arxiv.org/abs/2310.02226
  19. [19]Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, et al. DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning. Nature, 645:633–638, 2025. doi: 10.1038/s41586-025-09422-z.DOI
  20. [20]Simeng Han, Hailey Schoelkopf, Yilun Zhao, Hanqi Zhu, Martin K. Martin, Zaid K. Burrow, Lucy Sun, Ekaterina Zubova, Yujie Qiao, Matthew Burtell, et al. Folio: Natural language reasoning with first-order logic. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2024.arxiv.org/abs/2209.00840
  21. [21]Shibo Hao, Sainbayar Sukhbaatar, DiJia Su, Xian Li, Zhiting Hu, Jason Weston, and Yuandong Tian. Training large language models to reason in a continuous latent space. In Second Conference on Language Modeling, 2025. URL https://openreview.net/forum?id=txz7S4Ip3.arxiv.org/abs/2412.06769
  22. [22]Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. Measuring massive multitask language understanding. In 9th International Conference on Learning Representations. ICLR 2021. OpenReview.net, 2021. URL https://openreview.net/forum?id=d7KBjmI3GmQ.
  23. [23]Alex Heyman and Joel Zylberberg. Evaluating the systematic reasoning abilities of large language models through graph coloring. arXiv preprint arXiv:2502.07087, 2025.arxiv.org/abs/2502.07087
  24. [24]Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-rank adaptation of large language models. In International Conference on Learning Representations, 2022.arxiv.org/abs/2106.09685
  25. [25]Yixiao Huang, Hanlin Zhu, ZiXuan Wang, Jiantao Jiao, Stuart Russell, Somayeh Sojoudi, and Song Mei. Transformers probably learn to internalize chain-of-thought. arXiv preprint arXiv:2605.28600, 2026. URL https://arxiv.org/abs/2605.28600.
  26. [26]Aaron Jaech, Adam Kalai, Adam Lehrer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. OpenAI o1 system card. arXiv preprint arXiv:2412.16720, 2024.arxiv.org/abs/2412.16720
  27. [27]Erik Jenner, Shreyas Kapur, Vasil Georgiev, Cameron Allen, Scott Emmons, and Stuart Russell. Evidence of learned look-ahead in a chess-playing neural network. In Advances in Neural Information Processing Systems, volume 37, pp. 31410–31437, 2024. URL https://proceedings.neurips.cc/paper_files/paper/2024/hash/37d9f19150fce07bced2a81fc87d47a6-Abstract-Conference.html.arxiv.org/abs/2406.00877
  28. [28]Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kevin Pei, Ofir Press, and Karthik Narasimhan. SWE-bench: Can language models resolve real-world GitHub issues? In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=VTF8yNQM66.arxiv.org/abs/2310.06770
  29. [29]Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.arxiv.org/abs/2001.08361
  30. [30]Nathan Lambert, Jacob Morrison, Valentina Pyatkin, Shengyi Huang, Hamish Ivison, Faeze Brahman, Lester James V. Miranda, Alisa Liu, Nouha Dziri, Shane Lyu, Yuling Gu, Saumya Malik, Victoria Graf, Jena D. Hwang, Jiangjiang Yang, Ronan Le Bras, Oyvind Tafjord, Chris Wilhelm, Luca Soldaini, Noah A. Smith, Yizhong Wang, Pradeep Dasigi, and Hanneen Hajishirzi. Tülu 3: Pushing frontiers in open language model post-training. arXiv preprint arXiv:2411.15124, 2024.arxiv.org/abs/2411.15124
  31. [31]Nayoung Lee, Ziyang Cai, Avi Schwarzschild, Kangwook Lee, and Dimitris Papailiopoulos. Self-improving transformers overcome easy-to-hard and length generalization challenges. In Proceedings of the 42nd International Conference on Machine Learning, Proceedings of Machine Learning Research. PMLR, 2025.arxiv.org/abs/2502.01612
  32. [32]Lucas Lehnert, Sainbayar Sukhbaatar, Dijia Su, Qinqing Zheng, Paul McVay, Michael Rabbat, and Yuandong Tian. Beyond A*: Better planning with transformers via search dynamics bootstrapping. In First Conference on Language Modeling, 2024. URL https://openreview.net/forum?id=SWYE2eGmYw.arxiv.org/abs/2402.14083
  33. [33]Bill Yuchen Lin, Ronan Le Bras, Kyle Richardson, Ashish Sabharwal, Radha Poovendran, Peter Clark, and Yejin Choi. Zebralogic: On the scaling limits of llms for logical reasoning. In Proceedings of the 42nd International Conference on Machine Learning, volume 267 of Proceedings of Machine Learning Research, pp. 37889–37905. PMLR, 2025a. URL https://proceedings.mlr.press/v267/lin25i.html.arxiv.org/abs/2502.01100
  34. [34]Tianhe Lin, Jian Xie, Siyu Yuan, and Deqing Yang. Implicit reasoning in transformers is reasoning through shortcuts. In Findings of the Association for Computational Linguistics: ACL 2025, pp. 9470–9487, Vienna, Austria, 2025b. Association for Computational Linguistics. doi: 10.18653/v1/2025.findings-acl.493. URL https://aclanthology.org/2025.findings-acl.493/.
  35. [35]Jian Liu, Leyang Cui, Hanmeng Liu, Dandan Huang, Yile Wang, and Yue Zhang. LogiQA: A challenge dataset for machine reading comprehension with logical reasoning. In Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence (IJCAI), pp. 3622–3628, 2020.arxiv.org/abs/2007.08124
  36. [36]Maximilian Mordig, Andreas Opedal, Weiyang Liu, and Bernhard Schölkopf. Rethinking easy-to-hard: Limits of curriculum learning in post-training for deductive reasoning. arXiv preprint arXiv:2603.27226, 2026. URL https://arxiv.org/abs/2603.27226.
  37. [37]Olmo Team. Olmo 3. arXiv preprint arXiv:2512.13961, 2025.arxiv.org/abs/2512.13961
  38. [38]Denis Paperno, Germán Kruszewski, Angeliki Lazaridou, Ngoc Quan Pham, Raffaella Bernardi, Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernández. The LAMBADA dataset: Word prediction requiring a broad discourse context. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1525–1534, Berlin, Germany, August 2016. Association for Computational Linguistics. doi: 10.18653/v1/P16-1144. URL https://aclanthology.org/P16-1144/.
  39. [39]Mihir Parmar, Nisarg Patel, Neeraj Varshney, Mutsumi Nakamura, Man Luo, Santosh Mashetty, Arindam Mitra, and Chitta Baral. Logicbench: Towards systematic evaluation of logical reasoning ability of large language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL), 2024.arxiv.org/abs/2404.15522
  40. [40]Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving. arXiv preprint arXiv:2009.03393, 2020.arxiv.org/abs/2009.03393
  41. [41]Chengwen Qi, Ren Ma, Bowen Li, He Du, Binyuan Hui, Jinwang Wu, Yuanjun Laili, and Conghui He. Large language models meet symbolic provers for logical reasoning evaluation. In International Conference on Learning Representations, pp. 54186–54205, 2025. URL https://proceedings.iclr.cc/paper_files/paper/2025/file/862819c227b16f9af64dd6ad6cfdf275-Paper-Conference.pdf.arxiv.org/abs/2502.06563
  42. [42]Revanth Rameshkumar, Jimson Huang, Yunxin Sun, Fei Xia, and Abulhair Saparov. Reasoning models reason well, until they don’t. In Proceedings of the 14th International Joint Conference on Natural Language Processing and the 4th Conference of the Asia-Pacific Chapter of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 936–956, Mumbai, India, 2025. Asian Federation of Natural Language Processing and Association for Computational Linguistics. URL https://aclanthology.org/2025.ijcnlp-long.52/.
  43. [43]Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale. In The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, pp. 8732–8740. AAAI Press, 2020. doi: 10.1609/AAAI.V34I05.6399. URL https://doi.org/10.1609/aaai.v34i05.6399.
  44. [45]Abulhair Saparov, Richard Yuanzhe Pang, Vishakh Padmakumar, Nitish Joshi, Mehran Kazemi, Najoung Kim, and He He. Testing the general deductive reasoning capacity of large language models using OOD examples. In Advances in Neural Information Processing Systems, volume 36, pp. 3083–3105, 2023. URL https://proceedings.neurips.cc/paper_files/paper/2023/hash/09425891e393e64b0535194a81ba15b7-Abstract-Conference.html.arxiv.org/abs/2305.15269
  45. [46]Abulhair Saparov, Srushti Pawar, Shreyas Pimpalkar, Nitish Joshi, Richard Yuanzhe Pang, Vishakh Padmakumar, Seyed Mehran Kazemi, Najoung Kim, and He He. Transformers struggle to learn to search. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum?id=9cQB1Hwrtw.arxiv.org/abs/2412.04703
  46. [47]Zhenyi Shen, Hang Yan, Linhai Zhang, Zhanghao Hu, Yali Du, and Yulan He. CODI: Compressing chain-of-thought into continuous space via self-distillation. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 677–693, Suzhou, China, 2025. Association for Computational Linguistics. doi: 10.18653/v1/2025.emnlp-main.36. URL https://aclanthology.org/2025.emnlp-main.36/.
  47. [48]David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, Timothy Lillicrap, Karen Simonyan, and Demis Hassabis. A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play. Science, 362(6419):1140–1144, 2018. doi: 10.1126/science. aar6404.
  48. [49]Koustuv Sinha, Shagun Sodhani, Jin Dong, Joelle Pineau, and William L. Hamilton. Clutrr: A diagnostic benchmark for inductive reasoning from text. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2019.arxiv.org/abs/1908.06177
  49. [50]Mirac Suzgun, Nathan Scales, Nathanael Schärli, Sebastian Gehrmann, Yi Tay, Hyung Won Chung, Aakanksha Chowdhery, Quoc Le, Ed Chi, Denny Zhou, and Jason Wei. Challenging BIG-bench tasks and whether chain-of-thought can solve them. In Findings of the Association for Computational Linguistics: ACL 2023, pp. 13003–13051, 2023. URL https://aclanthology.org/2023.findings-acl.824/.arxiv.org/abs/2210.09261
  50. [51]Oyvind Tafjord, Bravhanna Dalvi, and Peter Clark. Proofwriter: Generating implications, proofs, and abductive statements over natural language. In Findings of the Association for Computational Linguistics: ACL-IJCNLP 2021, 2021.arxiv.org/abs/2012.13048
  51. [52]Karthik Valmeekam, Matthew Marquez, Alberto Olmo, Sarath Sreedharan, and Subbarao Kambhampati. PlanBench: An extensible benchmark for evaluating large language models on planning and reasoning about change. In Advances in Neural Information Processing Systems, volume 36, pp. 38975–38987, 2023. URL https://proceedings.neurips.cc/paper_files/paper/2023/hash/7a92bcdede88c7afd108072faf5485c8-Abstract-Datasets_and_Benchmarks.html.
  52. [53]Boshi Wang, Xiang Yue, Yu Su, and Huan Sun. Grokking of implicit reasoning in transformers: A mechanistic journey to the edge of generalization. In Advances in Neural Information Processing Systems, volume 37, 2024. URL https://proceedings.neurips.cc/paper_files/paper/2024/hash/ad217e0cf e c c71bdf48660ad6714b07-Abstract-Conference.html.DOI
  53. [54]Heng Wang, Shangbin Feng, Tianxing He, Zhaoxuan Tan, Xiaochuan Han, and Yulia Tsvetkov. Can language models solve graph problems in natural language? In Advances in Neural Information Processing Systems, 2023a.arxiv.org/abs/2305.10037
  54. [55]Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, 2023b. URL https://openreview.net/forum?id=1PL1N1MRw.arxiv.org/abs/2203.11171
  55. [56]Zixuan Wang, Eshaan H. A. Bietti, Alex Damian, Daniel Hsu, Jason D Lee, and Denny Wu. Learning compositional functions with transformers from easy-to-hard data. In Proceedings of Thirty Eighth Conference on Learning Theory, volume 291 of Proceedings of Machine Learning Research, pp. 5632–5711. PMLR, 2025. URL https://proceedings.mlr.press/v291/wang25a.html.arxiv.org/abs/2505.23683
  56. [57]Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems, volume 35, pp. 24824–24837. Curran Associates, Inc., 2022. URL https://proceedings.neurips.cc/paper_files/paper/2022/hash/9d5609613524ecf415af0f7b31abca4-Abstract-Conference.html.arxiv.org/abs/2201.11903
  57. [58]Xilin Wei, Xiaoran Liu, Yuhang Zang, Xiaoyi Dong, Yuhang Cao, Jiaqi Wang, Xipeng Qiu, and Dahua Lin. SIM-CoT: Supervised implicit chain-of-thought. In International Conference on Learning Representations, pp. 56721–56742, 2026. URL https://proceedings.iclr.cc/paper_files/paper/2026/hash/5d087955ee13fe9a7402eedec879b9c3-Abstract-Conference.html.arxiv.org/abs/2509.20317
  58. [59]An Yang, Yanfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chenggen Huang, Chenxu Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388, 2025.arxiv.org/abs/2505.09388
  59. [60]Tong Yang, Yu Huang, Yingbin Liang, and Yuejie Chi. Agentic transformers provably learn to search via reinforcement learning. arXiv preprint arXiv:2606.00183, 2026. URL https://arxiv.org/abs/2606.00183.
  60. [61]Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William W. Cohen, Ruslan Salakhutdinov, and Christopher D. Manning. HotpotQA: A dataset for diverse, explainable multi-hop question answering. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 2369–2380, Brussels, Belgium, 2018. Association for Computational Linguistics. doi: 10.18653/v1/D18-1259. URL https://aclanthology.org/D18-1259/.DOI
  61. [62]Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. In Advances in Neural Information Processing Systems, volume 36, pp. 11809–11822, 2023.arxiv.org/abs/2305.10601
  62. [63]Yuekun Yao, Yupei Du, Dawei Zhu, Michael Hahn, and Alexander Koller. Language models can learn implicit multi-hop reasoning, but only if they have lots of training data. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 9684–9702, Suzhou, China, 2025. Association for Computational Linguistics. doi: 10.18653/v1/2025.emnlp-main.490. URL https://aclanthology.org/2025.emnlp-main.490/.DOI
  63. [64]Jiaran Ye, Zijun Yao, Zhidian Huang, Liangming Pan, Jinxin Liu, Yushi Bai, Amy Xin, Weichuan Liu, Xiaoyin Che, Lei Hou, and Juanzi Li. How do transformers learn implicit reasoning? In Advances in Neural Information Processing Systems, volume 38, pp. 65810–65838. Curran Associates, Inc., 2025. doi: 10.52202/085713-2208. URL https://proceedings.neurips.cc/paper_files/paper/2025/hash/5f1cb1d23261b19cbd45f90f7b4f251f-Abstract-Conference.html.
  64. [65]Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. HellaSwag: Can a machine really finish your sentence? In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 4791–4800, Florence, Italy, July 2019. Association for Computational Linguistics. doi: 10.18653/v1/P19-1472. URL https://aclanthology.org/P19-1472/.DOI
  65. [66]Wanjun Zhong, Ruixiang Cui, Yiduo Guo, Yaobo Liang, Shuai Lu, Yanlin Wang, Amin Saied, Weizhu Chen, and Nan Duan. Agieval: A human-centric benchmark for evaluating foundation models. arXiv preprint arXiv:2304.06364, 2023.arxiv.org/abs/2304.06364

Paper details

vlnc:W_uecn7uaq
Version
v1 · latest
Published
Added
License
CC BY 4.0
Usage

views · 10

downloads · 4

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents