WorksComputer Science
Weaken to Strengthen: Weakening-Induced On-Policy Self-Distillation for Large Reasoning Models
Abstract
Self-distillation offers a way to improve reasoning models when a suitable external teacher is unavailable. However, common approaches rely on privileged information to construct a stronger self-teacher, limiting their use when only unlabeled prompts are available. In this paper, we introduce Weakening-Induced On-Policy Self-Distillation (WISD), which instead constructs a weaker counterpart of the original model and uses the contrast between the two as a training signal without requiring privileged information. We explore two ways to construct the weaker model: low-bit quantization and magnitude pruning. We evaluate WISD across diverse architectures and scales on mathematical and coding reasoning tasks. Across these benchmarks, quantization and pruning improve average accuracy over the original models by 4.0 and 5.5 percentage points, respectively, achieving state-of-the-art performance even without privileged information. Notably, pruning raises Qwen3.5-4B's accuracy from 57.7% to 70.5% on HMMT 2025 and from 39.1% to 56.7% on LiveCodeBench v6. Quantization raises Qwen3.6-35B-A3B's accuracy from 68.5% to 74.6% and from 61.8% to 69.5% on the same benchmarks, respectively. These results establish WISD as a novel and effective self-distillation framework for large reasoning models.
Introduction
On-policy distillation (OPD) has emerged as an effective approach to improving the reasoning capabilities of large language models ([1] (Gu et al. 2024; Lu & Lab 2025)). It trains a student on its own generated trajectories using dense token-level supervision from a teacher, combining learning on the student’s own states with fine-grained feedback. For reasoning tasks, this allows learning to address errors in intermediate computations and decisions along the student’s own solution paths. This approach has demonstrated substantial gains in training efficiency and is now used in the post-training of Qwen3, MiMo-V2-Flash, Nemotron-Cascade 2, and DeepSeek-V4 ([63, 53, 67, 5]). Recent work extends OPD to self-distillation, in which the same model serves as both teacher and student, removing the need for a separate teacher model ([74, 47] (Hübotter et al. 2026)).
Self-distillation is particularly appealing when a suitable external teacher is unavailable, especially when the goal is to improve an already capable model (Hübotter et al., 2026). A common approach uses the model’s in-context learning ability to construct a stronger teacher by providing privileged information, such as reference solutions ([74]), expert demonstrations ([47]), or textual environment feedback (Hübotter et al., 2026). With this additional context, the teacher can provide more informed predictions for trajectories that the student generates from the task input alone. Training matches the student’s next-token distributions to the teacher’s, transferring the benefit of the richer context into a policy that operates without privileged information at inference time.
However, these approaches retain a dependence on privileged information during training. Reference-based methods require solutions or expert demonstrations ([74, 47]), and obtaining high-quality solutions can be costly ([72]). Feedback-based alternatives rely on informative environment responses or reward-verified successful rollouts ([20]). These requirements limit their applicability when only unlabeled prompts are available. Even when privileged information is available, conditioning on it can shift the teacher’s predictions away from the student’s and complicate knowledge transfer ([39]). This motivates our central question: Can a model improve its reasoning through self-distillation without privileged information?
Recent work on weak-to-strong OPD shows that the log- @Join? probability contrast between paired models can provide useful supervision even when both are weaker than the student [7] (Yu et al. 2026). Differences in token preferences between paired models encode a direction of policy improvement that can be transferred to a more capable student. From this perspective, the privileged-information approaches above take the model itself as the weaker member of a pair and construct a stronger counterpart through additional context [74, 47] (Hübotter et al. 2026). We introduce Weakening-Induced On-Policy Self-Distillation (WISD), which reverses this construction: we take the original model as the stronger member and create a weaker counterpart by degrading its weights. The contrast between the original model and its weakened copy then provides dense supervision on the model’s own trajectories, without privileged information. This formulation turns model weakening into a source of supervision, enabling self-improvement using the original model and unlabeled task prompts alone. Table 1 compares WISD with representative reasoning post-training methods in terms of learning signals and external supervision requirements.
Table 1. Comparison of training methods for reasoning. WISD provides dense supervision without external teachers, reference solutions, or environment feedback. Reference solutions are externally supplied answers or worked solutions used as teacher context. Environment feedback includes outcome verification and textual responses. GRPO uses verifiable outcome rewards. SDPO uses textual feedback or reward-verified self-generated solutions.
Following this idea, we explore two training-free constructions of a weaker self: low-bit quantization and magnitude pruning. Both operate directly on model weights and require no calibration data. Experiments across diverse model architectures and scales demonstrate the effectiveness of WISD on mathematical and coding reasoning tasks. Figure 1 summarizes the gains in mathematical and coding reasoning. Across these benchmarks, quantization and pruning improve average accuracy over the original models by 4.0 and 5.5 percentage points, respectively, with positive gains in 21 and 23 of the 25 model–benchmark settings, achieving state-of-the-art performance even without privileged information. Notably, pruning raises Qwen3.5-4B’s accuracy from 57.7% to 70.5% on HMMT 2025 and from 39.1% to 56.7% on LiveCodeBench v6. Quantization raises Qwen3.6-35B-A3B’s accuracy from 68.5% to 74.6% and from 61.8% to 69.5% on the same benchmarks, respectively. These results establish WISD as a novel and effective self-distillation framework for large reasoning models, requiring minimal prerequisites.
Figure 1. Accuracy gains from self-distillation against a weakened model. By constructing a weakened copy of the original model and using the contrast between them as a training signal, WISD achieves consistent accuracy improvements across diverse reasoning models and benchmarks. Full results are reported in Table 2.
Our contributions are as follows:
We introduce WISD, a self-distillation approach that treats the original model as the stronger member of a pair and learns from its contrast with a weakened copy, improving reasoning without privileged information.
We instantiate this approach with two weak-model constructions, low-bit quantization and magnitude pruning, which require no calibration data and yield dense supervision on the model’s own trajectories.
We validate the approach across widely used reasoning models spanning diverse architectures and scales, demonstrating broad accuracy improvements on mathematical and coding reasoning tasks.
Related Work
On-Policy Distillation. On-policy distillation trains a student on its own generated trajectories [44] (Li et al. 2026b; Fu et al. 2026) with token-level teacher feedback [24, 3] (Xu et al. 2026; Wang et al. 2026), reducing the distribution mismatch between training and inference [1] (Gu et al. 2024; Lu & Lab 2025; Wu et al. 2026b; Xu et al. 2025). Direct On-Policy Distillation (DOPD) and related approaches transfer policy shifts through log-probability contrasts between paired models [65, 7] (Wu et al. 2026c), enabling weak-to-strong distillation (Yu et al., 2026). A growing line of work extends OPD to self-distillation by conditioning the model itself on additional information to obtain a stronger teacher: refreference solutions ([74, 46, 64] (Ke et al. 2026)), demonstrations ([47]), and environment feedback or verified successful rollouts ([20, 52, 66, 51] (He et al. 2026)). Compared to these prior self-distillation approaches, WISD requires no privileged information. Instead, it constructs a weaker copy of the original model and uses the contrast between the two as the training signal. OPSA takes a complementary approach, constructing entropy-adaptive negative advantages without an external teacher or privileged information ([6]).
Learning from Weaker Models. Contrasting a model with a weaker counterpart has been explored for both generation ([48, 19, 2]) and learning. Contrastive decoding uses a smaller amateur to guide a stronger expert at inference time ([37] (Li et al. 2023)). Variants derive weaker predictions from the model itself ([11, 71, 22, 73]) through early layers in DoLa ([4]), dropout or quantization in DCD ([40]), and layer pruning in PruneCD ((Yu et al., 2025)). Related small-model contrasts support decoding-time adaptation ([36, 32]). In diffusion, classifier-free guidance contrasts conditional and unconditional predictions ((Ho & Salimans, 2022)), while autoguidance uses a smaller, less-trained counterpart ([25]). Training-time approaches include pruned self-competitors for visual representation learning ([23]) and expert–amateur contrasts for reasoning supervision ((Wang et al., 2026a)). Recent distillation methods construct degraded references for flow-matching models ([31]) or reduce expert activation in an external MoE teacher to obtain a reference ((Gu et al., 2026)). Self-distillation also exploits predictions conditioned on ablated visual inputs ([30]) or self-generated negative context ([38]). WISD constructs a weaker counterpart directly through training-free weight quantization or magnitude pruning and distills its contrast with the original model to improve reasoning without privileged information.
Method
We first review OPD and policy-shift supervision, then revisit self-distillation from a weak-to-strong perspective to introduce WISD. Finally, we describe two training-free ways to construct its weaker model. Figure 2 contrasts WISD with prior self-distillation and summarizes its training pipeline.
Figure 2. Overview of WISD. (a) Prior self-distillation. Privileged information , such as solutions, demonstrations, or feedback, strengthens the original model into a self-teacher. (b) WISD. We instead retain the original model as the stronger member and construct a weaker copy through training-free quantization or pruning. The frozen pair scores the same self-generated trajectories, and its token-level log-probability contrast provides cached supervision for a student initialized from the original model, without privileged information.
Preliminaries
Let be an autoregressive student, a prompt, and a generated response. At position , the state determines a distribution over next-token actions . OPD supervises the student on the states it visits during generation. Writing for this state distribution, a common objective matches the student to a teacher through reverse KL ([1] (Gu et al. 2024)):
DOPD ([7]) represents supervision through a pair of frozen models , typically a post-trained model and its checkpoint before post-training. Their token-level log-probability difference defines a policy shift:
This contrast specifies which actions the student should favor more or less, allowing a model pair to provide useful supervision even when neither member is stronger than the student ([7] (Yu et al. 2026)). We next use this perspective to revisit on-policy self-distillation.
Weakening-Induced On-Policy Self-Distillation
Weak-to-strong distillation suggests that a useful supervision signal can come from the difference between two models, even when a stronger teacher is unavailable ((Yu et al., 2026)). The central design choice is therefore how to obtain a model pair whose relative predictions provide a learning signal. This paired-model perspective also offers a way to understand prior on-policy self-distillation (OPSD). Given a model and privileged information , these approaches construct a more informed self-teacher using reference solutions (Zhao et al., [74]), demonstrations (Shenfeld et al., [47]), or environment feedback (Hübotter et al., [20]). Viewed as a model pair, the original policy is the weaker member, while its context-conditioned counterpart is the stronger member. These two roles can be written as and . The student encounters the task without , and the additional context gives the teacher a more informed view of the student’s decisions. The construction therefore depends on additional information to create the gap from which the student learns.
WISD reverses this construction: we take the original model as the stronger member and construct a weaker counterpart from its own weights. Let denote the original model and its copy under a weakening operator . Setting in Eq. (2) gives
Both models receive the same prompt and generated prefix, so the contrast compares their token preferences under an identical context. A token receives a positive contrast when it is more likely under the original model and a negative contrast when it is more likely under the weak model. Distillation uses this signal to favor tokens with larger original-to-weak probability ratios relative to those with smaller ratios. Using two identical policies in Eq. (2) would yield zero contrast. Weakening creates a token-dependent signal even when the student starts from the original model. This supplies dense self-supervision using only the original checkpoint and unlabeled prompts.
For training, we adopt the offline DOPD procedure of Lightning distillation (Wu et al., 2026c), with the tilted target and distillation objective
Here is the distillation coefficient which controls how strongly the contrast tilts the target away from and scales the objective accordingly. The original model generates trajectories on unlabeled prompts, and the frozen pair scores their states to provide cached supervision. A student initialized from is then trained on this supervision. The trajectories and both scoring models remain fixed throughout optimization. The trained student is used alone at inference time.
Constructing a Weaker Self
We instantiate with low-bit quantization and magnitude pruning, both of which operate directly on model weights without calibration data or training. These operators introduce two different forms of degradation: quantization coarsens weight values, while pruning removes low-magnitude connections. Both retain the model’s architecture and tokenizer, making their next-token predictions directly comparable to those of the original model. The transformations apply to attention and feed-forward projection weights, including MoE expert projections. Embeddings, output heads, normalization parameters, and routing parameters are preserved. The transformation is applied only to the frozen weak scorer. The student retains the original weights at initialization. For each projection matrix , we divide every output row into groups of 128 input columns and write .
Low-bit quantization. For an integer bit width , let . Symmetric round-to-nearest quantization gives
where . The group maximum adapts the step size to the local weight scale. The quantization grid contains levels, including zero. We dequantize the resulting weights for scoring with the original model architecture. Our default uses .
Magnitude pruning. For a group-relative threshold , we remove weights at or below within each group, then restore the original norm of each complete output row:
The group-relative threshold accounts for variation in weight scale across the matrix. Its value specifies a relative magnitude threshold. The achieved sparsity depends on the distribution of weight magnitudes. Pruning preserves the surviving values before rescaling, while the whole-row normalization compensates for the norm lost through deletion. Our default uses . For both operators, all-zero groups or rows remain zero, and MoE experts are processed independently.
Experiments
Experimental Setup
Models and weakening variants. We evaluate WISD on five reasoning models: Qwen3-4B [63], Qwen3.5-4B [43], OLMo-3-7B-Think [54], Qwen3.6-27B [41], and Qwen3.6-35B-A3B [42]. These models span diverse sizes, families, and attention architectures, covering both dense and mixture-of-experts (MoE) designs. For each model, we compare the original checkpoint with students trained using the quantization and pruning constructions in § 3.3, denoted by WISD (Quantization) and WISD (Pruning). The main results use for quantization and for pruning. Both variants initialize the student from the original model.
Training data. We train separate mathematics and coding students using 3,200 prompts per domain from Skywork-OR1-RL-Data (He et al., 2025) and KlearReasoner-CodeSub-15K (Su et al., 2026), respectively. Each original model generates four responses per prompt to form its own cached trajectories for self-distillation.
Benchmarks and metrics. We evaluate mathematical reasoning on AIME 2024, AIME 2025 [35], and HMMT 2025 [14], and code generation on LiveCodeBench (LCB) v5 and v6 [21]. We report mean accuracy over 32 samples per mathematics problem (Avg@32) and four per coding problem (Avg@4).
Training and evaluation settings. We follow Lightning Weave’s offline DOPD training procedure (Wu et al., 2026c), using a learning rate of , global batch size 64, and distillation coefficient . Full training and evaluation settings are provided in Appendix A.
Comparison methods. We include published results from OPSD [74], SDPO (Hüboter et al., 2026), PW-OPSD [33], and LOPD [70] for the corresponding models and benchmarks. These methods use reference solutions or feedback-conditioned self-teachers.
Main Results
Table 2 reports accuracy across five reasoning models and five mathematics and code benchmarks. The quantization and pruning variants of WISD improve average accuracy over the original models by 4.0 and 5.5 percentage points, respectively, with positive gains in 21 and 23 of the 25 model–benchmark settings. On both Qwen3-4B and OLMo-3-7B-Think, the two constructions improve the mathematics and code averages and are competitive with OPSD and SDPO. Both variants also surpass the reported five-benchmark averages of baselines that use privileged information. The largest gains occur on Qwen3.5-4B, where quantization and pruning increase the five-benchmark average by 11.3 and 13.4 points, respectively. In particular, pruning raises its HMMT 2025 accuracy from 57.7% to 70.5% and LCB v6 accuracy from 39.1% to 56.7%. The gains also extend to larger dense and MoE models, where pruning improves Qwen3.6-27B’s average accuracy by 5.2 points and quantization improves Qwen3.6-35B-A3B’s by 5.9 points. On the latter, HMMT 2025 and LCB v6 accuracies rise from 68.5% to 74.6% and from 61.8% to 69.5%, respectively. These results demonstrate that WISD turns simple weight degradation into effective self-distillation supervision, improving reasoning accuracy across model families, scales, and architectures without privileged information.
| Method | Math Reasoning | Code Generation | Avg. | |||||
| AIME24 | AIME25 | HMMT25 | Avg. | LCB v5 | LCB v6 | Avg. | ||
| Qwen3-4B | ||||||||
| Original | 73.4 | 65.6 | 41.1 | 60.07 | 53.0 | 46.8 | 49.86 | 55.98 |
| OPSD ([74]) | 75.2 | 66.7 | 43.9 | 61.92 | 42.7 | 35.1 | 38.88 | 52.70 |
| SDPO ([20]) | 70.6 | 62.8 | 40.8 | 58.06 | 40.9 | 34.4 | 37.61 | 49.88 |
| PW-OPSD ([33]) | 76.2 | 67.8 | 43.3 | 62.44 | — | — | — | — |
| LOPD ([70]) | — | — | — | — | 50.5 | 45.0 | 47.79 | — |
| WISD (Quantization) | 75.4 | 65.8 | 42.8 | 61.35 | 56.4 | 49.2 | 52.80 | 57.93 |
| WISD (Pruning) | 75.8 | 66.0 | 45.2 | 62.36 | 55.7 | 50.2 | 52.96 | 58.60 |
| Qwen3.5-4B | ||||||||
| Original | 74.3 | 67.0 | 57.7 | 66.32 | 41.7 | 39.1 | 40.39 | 55.95 |
| WISD (Quantization) | 80.2 | 72.1 | 68.1 | 73.47 | 60.8 | 55.0 | 57.86 | 67.23 |
| WISD (Pruning) | 78.8 | 76.8 | 70.5 | 75.35 | 64.0 | 56.7 | 60.33 | 69.34 |
| OLMo-3-7B-Think | ||||||||
| Original | 74.0 | 65.3 | 45.2 | 61.49 | 52.1 | 47.3 | 49.71 | 56.78 |
| OPSD ([74]) | 72.8 | 67.4 | 43.9 | 61.36 | 44.1 | 45.0 | 44.57 | 54.64 |
| SDPO ([20]) | — | — | — | — | 49.8 | 43.5 | 46.67 | — |
| PW-OPSD ([33]) | 72.6 | 69.6 | 43.8 | 62.01 | — | — | — | — |
| LOPD ([70]) | — | — | — | — | 53.4 | 45.8 | 49.61 | — |
| WISD (Quantization) | 74.6 | 67.4 | 44.5 | 62.15 | 52.9 | 49.4 | 51.15 | 57.75 |
| WISD (Pruning) | 72.7 | 69.1 | 47.2 | 62.99 | 52.1 | 49.2 | 50.65 | 58.05 |
| Qwen3.6-27B | ||||||||
| Original | 86.8 | 78.8 | 75.1 | 80.21 | 73.2 | 69.1 | 71.15 | 76.58 |
| WISD (Quantization) | 85.1 | 78.9 | 73.2 | 79.06 | 76.5 | 67.7 | 72.14 | 76.29 |
| WISD (Pruning) | 88.8 | 84.4 | 82.5 | 85.21 | 80.1 | 73.1 | 76.60 | 81.76 |
| Qwen3.6-35B-A3B | ||||||||
| Original | 83.3 | 74.3 | 68.5 | 75.38 | 71.1 | 61.8 | 66.49 | 71.82 |
| WISD (Quantization) | 85.9 | 81.9 | 74.6 | 80.80 | 76.6 | 69.5 | 73.04 | 77.69 |
| WISD (Pruning) | 86.3 | 80.8 | 71.7 | 79.58 | 76.3 | 69.3 | 72.76 | 76.86 |
Table 2. Accuracy (%) across mathematics and code benchmarks. Training and evaluation settings are described in § 4.1. Bold and underlined values denote the best and second-best reported results per model. A dash denotes an unavailable result. Math Avg. averages three benchmarks, Code Avg. averages two, and the final Avg. weights all five equally. WISD achieves consistent improvements across models and benchmarks and remains competitive with other on-policy self-distillation methods without using any privileged information.
Ablation Study
We study quantization precision and pruning threshold using Qwen3.5-4B on HMMT25 (Avg@32), varying the hyper-parameters and to control the strength of quantization and pruning respectively while keeping all other settings the same as 4.1. The sweeps cover and . We report both student accuracy and average generated length.
Quantization strength. Figure 3(a) shows a nonmonotonic relationship between weight precision and student accuracy. Reducing precision from 8 to 3 bits raises accuracy from 56.04% to 68.33%, while a further reduction to 2 bits lowers it to 49.90%. After self-distillation, the student also generates shorter responses than the Base model. This pattern suggests that mild quantization provides too little contrast for substantial gains over the original model, whereas excessive quantization erodes the weak model’s reasoning ability and allows noise to overwhelm useful contrast. Moderate quantization balances contrast strength and signal quality, with giving the best result in this sweep and serving as our default.

Figure 3. Ablations of weak-model construction on Qwen3.5-4B, evaluated on HMMT25. (a) Quantization bit width. (b) Pruning threshold. Each pair shows accuracy (Avg@32, left plot) and average generated length in thousands of tokens (right plot). Dashed lines denote Base accuracy and average generated length. Outlined diamonds mark the default settings and . Both constructions achieve their highest accuracy at intermediate weakening strengths. This pattern highlights the importance of balancing contrast strength and signal quality for effective self-distillation.
Pruning threshold. Figure 3(b) shows a similar intermediate range of effective constructions. Accuracy rises from 60.94% at to 69.38% at and 70.52% at the default , then falls to 54.79% and 49.58% at and . After self-distillation, the student also generates shorter responses than the Base model. Similarly, the pruning results favor an intermediate level of damage that creates informative contrast while preserving the weak model’s reasoning ability. Our default threshold therefore combines the highest accuracy with the shortest responses in this sweep.
Analysis
We analyze the effectiveness of weak-model constructions and the resulting distillation signals on Qwen3-4B.
Effectiveness of Weak-Model Constructions
Alternative quantization and pruning methods. To evaluate the effectiveness of weak-model construction in providing contrast signals, we also explore alternative methods, including GPTQ (Frantar et al., [9]) with 3-bit weights and W4A4 with and without SmoothQuant-style smoothing (Xiao et al., [60]) for quantization, and Wanda-based pruning (Sun et al., [50]) and SparseGPT (Frantar & Alistarh, [8]), both with a 2:4 sparsity pattern, for pruning. We train separate students for mathematics and code using the identical training settings in § 4.1.
Table 3 shows that Smooth W4A4, Wanda, and SparseGPT provide useful training signals on both tasks, whereas GPTQ and plain W4A4 do not yield consistent gains. The different outcomes of GPTQ and RTN at 3-bit precision, and of W4A4 and Smooth W4A4 at 4-bit precision, show that bit width alone does not determine the training value of a weak model. The gains obtained with multiple quantization and pruning methods further support the generality of weak-model construction as a source of self-distillation signals. Additional results are presented in Appendix § 10.§ 1.
| Method | AIME24 | LCB v5 |
| Qwen3-4B | 73.4 | 53.0 |
| Quantization | ||
| GPTQ (3-bit) (Frantar et al., [9]) | 72.0 | 53.4 |
| W4A4 | 70.0 | 53.0 |
| Smooth W4A4 (Xiao et al., [60]) | 75.3 | 55.2 |
| RTN (3-bit) | 75.4 | 56.4 |
| Pruning | ||
| Wanda (Sun et al., [50]) | 74.4 | 55.6 |
| SparseGPT (Frantar & Alistarh, [8]) | 73.5 | 55.7 |
| Magnitude pruning | 75.8 | 55.7 |
| Simple baselines | ||
| Self-enhancing | 72.8 | 53.6 |
| Temperature weak () | 73.1 | 53.0 |
Table 3. Qwen3-4B student accuracy (%) with weak-model constructions and simple baselines on AIME24 (Avg@32) and LCB v5 (Avg@4). Multiple quantization and pruning constructions improve accuracy on both tasks. Our default RTN and magnitude-pruning constructions outperform both simple baselines, supporting the value of structured contrast beyond confidence reinforcement. Bold marks the highest displayed accuracy within the quantization and pruning families.
Confidence-based simple baselines. To further assess the role of weight weakening, we consider two alternative training signals derived from the original model’s predictions. Self-enhancing directly uses the frozen original model’s token log-probabilities as rewards. Temperature weak softens the original model’s output distribution with a temperature of , and uses the log-probability difference between the original and softened distributions as the reward. Implementation details are provided in Appendix A.§ 5. Table 3 shows the two confidence-based alternatives remain close to the original model. These results show that our quantization and pruning constructions provide effective, structured contrast signals for self-distillation, going beyond simply reinforcing the original model’s confidence and leading to improved reasoning capabilities.
Understanding the Training Signal
We analyze how weak-model contrasts allocate supervision across reasoning roles on 64 Qwen3-4B mathematics training trajectories. We label response segments using the ThinkARM taxonomy (Li et al., 2026a) and measure each role’s share of the initial logit-gradient L1 magnitude. Table 4 shows that quantization and pruning allocate about 22% of the signal to exploration and 11% to verification, exceeding these roles’ token shares of 14.8% and 8.1%.
Both constructions thus place greater training weight on exploring solution paths and checking intermediate reasoning. Appendix § 11 provides the analysis details.
Figure 4 illustrates how this supervision acts on tokens that support intermediate calculations and logical checks. In the paint-coverage example, quantization increases the target probabilities of a digit in the coverage calculation and the negation not, reinforcing the conclusion that the proposed amount of paint is insufficient. In the algebra example, pruning increases the target probability of 0 in an intermediate result, supporting the exclusion of a candidate root that makes the original divisor zero. These cases show how the contrast reinforces tokens that express numerical results and their logical consequences, supplying supervision for the local decisions that support correct reasoning.
Figure 4. Token-level effects of WISD. Original-model trajectories illustrate a coverage check with quantization (a) and a zero-divisor check with pruning (b). Blue and orange indicate increased and decreased target probability relative to the behavior distribution. Quantization reinforces tokens supporting the coverage calculation and the conclusion that ten gallons are insufficient, while pruning reinforces the intermediate zero used to exclude an invalid root. These examples illustrate how weak-model contrasts provide local supervision for numerical checks and the logical decisions they support.
Conclusion
We introduced WISD, a self-distillation framework that improves reasoning models without privileged information. The core idea is to construct a weaker counterpart of the original model and turn their token-level log-probability contrast into dense supervision on self-generated trajectories. We instantiate this idea with low-bit quantization and magnitude pruning, enabling training from the original checkpoint and unlabeled prompts. Experiments across diverse reasoning models and benchmarks demonstrate broad accuracy gains. Our analyses show that weak-model contrasts emphasize exploration and verification while providing training directions beyond confidence reinforcement. These results establish model weakening as an effective source of supervision for improving reasoning through self-distillation.
Experimental Details
Training Data and Optimization
We train separate mathematics and code students using 3,200 prompts from Skywork-OR1-RL-Data ((He et al., 2025)) and KlearReasoner-CodeSub-15K ((Su et al., 2026)), respectively. Each original model samples four responses per prompt, producing 12,800 cached trajectories per domain. Students initialize from their original checkpoints and use Lightning Weave’s offline DOPD procedure ((Wu et al., 2026c)) with the frozen original-to-weak contrast. Table 5 summarizes the shared configuration.
| Rollout parameter | Value | Training parameter | Value |
| Prompts per domain | 3,200 | Distillation coefficient | 2 |
| Responses per prompt | 4 | Learning rate | , constant |
| Trajectories per domain | 12,800 | Global batch size | 64 |
| Temperature / top- | 1.0 / 1.0 | Optimizer updates | 200 |
| Default response limit | 2,048 tokens | Student precision | BF16 |
| Rollout seed | 42 | Training seed | 1234 |
Table 5. Training configuration for WISD. Mathematics and code students use separate prompt sets and cached trajectories.
Evaluation and Published Baselines
Benchmarks and metrics. AIME 2024, AIME 2025, and HMMT 2025 each contain 30 problems, evaluated with 32 responses per problem. LiveCodeBench v5 and v6 contain 279 and 131 problems, respectively, evaluated with four responses per problem. Avg@ is the fraction of correct responses across all problems and their samples. Math Avg. equally weights the three mathematics benchmarks, Code Avg. equally weights the two coding benchmarks, and the final Avg. equally weights all five. We compute averages from unrounded scores. AIME 2024 also serves as the development benchmark for exploring weak-model constructions.
Generation settings. We use each model’s native chat template with thinking enabled, temperature 0.6, top- = 0.95, and top- disabled. Our main-table evaluations use a 40,960-token output limit and a 49,152-token context window. Mean response length counts generated tokens, excluding the prompt.
Published results. OPSD and PW-OPSD mathematics results come from Table 4 of Liu et al. [33], with the Moderate schedule for PW-OPSD. These use Avg@12 averaged over three evaluation seeds, temperature 1.0, top- = 0.95, and a 38,912-token output limit. Qwen3-4B SDPO mathematics results come from Table 1 of Wu et al. (2026a), also using Avg@12, temperature 1.0, top- = 0.95, and a 38,912-token output limit. OPSD, SDPO, and LOPD code results come from Table 2 of Zhang et al. [70], using pass@1 on the same LCB tasks, temperature 0.7, top- = 0.95, top- = 20, and a 16,384-token output limit.
| Method | Read | Analyze | Plan | Implement | Explore | Verify | Monitor | Answer | Formatting |
| All tokens | 9.1 | 24.3 | 6.6 | 28.2 | 14.8 | 8.1 | 1.4 | 1.8 | 5.6 |
| Quantization | 7.6 | 27.1 | 8.4 | 16.0 | 22.3 | 11.2 | 2.4 | 2.0 | 3.0 |
| Pruning | 7.8 | 26.7 | 8.3 | 15.9 | 22.1 | 11.4 | 2.5 | 2.1 | 3.2 |
Table 4. Distribution of initial training signals across reasoning roles (%). The first row gives token frequencies. Remaining rows give shares of logit-gradient L1 magnitude. Bold marks shares above token frequency. Quantization and pruning allocate about 22% of the signal to exploration and 11% to verification, exceeding these roles’ token shares of 14.8% and 8.1%. Both constructions thus place greater training weight on exploring solution paths and checking intermediate reasoning.
Evaluation Prompts and Answer Extraction
Mathematics prompt. Before application of the model’s native chat template, each mathematics example is represented exactly as
Question: {Problem}
Answer:
We enable the model’s native reasoning mode where available and stop on its end-of-sequence or end-of-turn token. For every problem we independently sample 64 responses at temperature 0.6 and top- = 0.95, allowing at most 32,768 generated tokens. We extract the last balanced \boxed{...} expression, remove superficial formatting such as whitespace, delimiters, and units, and canonicalize integer answers before exact comparison with the reference. We do not use a computer-algebra system to grant additional symbolic equivalences. A length-truncated response is still scored if it contains a valid extracted answer.
LiveCodeBench prompt. We use LiveCodeBench’s CodeQwenInstruct generation format. Its user message begins with:
@page 14/20 starts_mid=0 ends_mid=1
Experimental Details
Training Data and Optimization
We train separate mathematics and code students using 3,200 prompts from Skywork-OR1-RL-Data ((He et al., 2025)) and KlearReasoner-CodeSub-15K ((Su et al., 2026)), respectively. Each original model samples four responses per prompt, producing 12,800 cached trajectories per domain. Students initialize from their original checkpoints and use Lightning Weave’s offline DOPD procedure ((Wu et al., 2026c)) with the frozen original-to-weak contrast. Table 5 summarizes the shared configuration.
| Rollout parameter | Value | Training parameter | Value |
| Prompts per domain | 3,200 | Distillation coefficient | 2 |
| Responses per prompt | 4 | Learning rate | , constant |
| Trajectories per domain | 12,800 | Global batch size | 64 |
| Temperature / top- | 1.0 / 1.0 | Optimizer updates | 200 |
| Default response limit | 2,048 tokens | Student precision | BF16 |
| Rollout seed | 42 | Training seed | 1234 |
Table 5 (PDF p. 14). Training configuration for WISD. Mathematics and code students use separate prompt sets and cached trajectories.
Evaluation and Published Baselines
Benchmarks and metrics. AIME 2024, AIME 2025, and HMMT 2025 each contain 30 problems, evaluated with 32 responses per problem. LiveCodeBench v5 and v6 contain 279 and 131 problems, respectively, evaluated with four responses per problem. Avg@ is the fraction of correct responses across all problems and their samples. Math Avg. equally weights the three mathematics benchmarks, Code Avg. equally weights the two coding benchmarks, and the final Avg. equally weights all five. We compute averages from unrounded scores. AIME 2024 also serves as the development benchmark for exploring weak-model constructions.
Generation settings. We use each model’s native chat template with thinking enabled, temperature 0.6, top- = 0.95, and top- disabled. Our main-table evaluations use a 40,960-token output limit and a 49,152-token context window. Mean response length counts generated tokens, excluding the prompt.
Published results. OPSD and PW-OPSD mathematics results come from Table 4 of Liu et al. [33], with the Moderate schedule for PW-OPSD. These use Avg@12 averaged over three evaluation seeds, temperature 1.0, top- = 0.95, and a 38,912-token output limit. Qwen3-4B SDPO mathematics results come from Table 1 of Wu et al. (2026a), also using Avg@12, temperature 1.0, top- = 0.95, and a 38,912-token output limit. OPSD, SDPO, and LOPD code results come from Table 2 of Zhang et al. [70], using pass@1 on the same LCB tasks, temperature 0.7, top- = 0.95, top- = 20, and a 16,384-token output limit.
Evaluation Prompts and Answer Extraction
Mathematics prompt. Before application of the model’s native chat template, each mathematics example is represented exactly as
Question: {Problem}
Answer:
We enable the model’s native reasoning mode where available and stop on its end-of-sequence or end-of-turn token. For every problem we independently sample 64 responses at temperature 0.6 and top- = 0.95, allowing at most 32,768 generated tokens. We extract the last balanced \boxed{...} expression, remove superficial formatting such as whitespace, delimiters, and units, and canonicalize integer answers before exact comparison with the reference. We do not use a computer-algebra system to grant additional symbolic equivalences. A length-truncated response is still scored if it contains a valid extracted answer.
LiveCodeBench prompt. We use LiveCodeBench’s CodeQwenInstruct generation format. Its user message begins with:
You will be given a question (problem specification) and will generate a correct
Python program that matches the specification and passes all tests. You will NOT
return anything except for the program.
Question: {question_content}
For problems with starter code, the message then asks the model to complete the supplied code and enclose the answer in code delimiters. Otherwise it instructs the model to read from standard input, write to standard output, and return the program inside a Python code block initialized with # YOUR CODE HERE. The official system wrapper is You are a helpful assistant., expressed with the Qwen instruction delimiters. We sample four responses per problem at temperature 0.6 and top-, with a maximum of 40,960 generated tokens.
We use LiveCodeBench’s official code extraction and test execution. A sample is correct only if its extracted program passes every test for that problem. Tests run in isolated, read-only containers with the benchmark’s fast-test mode and a six-second timeout per test. Runtime errors, timeouts, extraction failures, and incomplete programs are scored as incorrect.
Weak-Model Construction Details
Quantization. RTN uses symmetric group-wise quantization with 128 input coordinates per output-row group, except for the group-32 variant. The signed grid has levels, so 2-bit RTN uses . W4A8 and W4A4 combine 4-bit RTN weights with per-token activation quantization at 8 and 4 bits, respectively. Smooth W4A4 applies SmoothQuant-style input-channel and weight rescaling with smoothing exponent 0.5 before quantization [60]. GPTQ uses 3-bit or 2-bit weights, group size 128, and damping 0.01 [9].
Pruning. Our default applies the group-relative threshold and restores each complete output row’s norm, as defined in § 3.3. The additional per-row magnitude variants remove the smallest 20% or 40% of weights in each row. Wanda ranks weights by magnitude times the clean-model input-activation norm, using either per-row sparsity or a 2:4 pattern [50]. SparseGPT uses input covariance statistics with damping 0.01, at 50% sparsity or with a 2:4 pattern [8]. MLP channel pruning removes the lowest-ranked 25% of channels according to the product of the down-projection column norm and its input-activation norm, jointly masking the corresponding gate/up rows and down columns.
Calibration and scoring. The calibrated alternatives use 128 cached training sequences from the corresponding domain, with up to 2,048 tokens per sequence. Calibration statistics are collected from the unchanged original model. GPTQ and SparseGPT accumulate and factorize their covariance matrices in FP64. The Qwen3-4B construction studies use FP32 scorer forwards and BF16 student training. The Qwen3.5-4B sweep uses BF16 scorers, except for the default pruning student, which uses the FP32-scored run from the main comparison. These constructions modify the frozen weak scorer and retain the student’s original architecture.
Simple Baselines
We use two additional signals derived from the original model for the comparison in Table 3. Self-enhancing uses its token log-probability directly:
Temperature weak uses the contrast with a softened output distribution:
Here denotes the original model’s logits. Both signals use full-vocabulary-normalized probabilities on the same cached token candidates and the training configuration in Table 5. Both assign zero reward to OTHer. We train separate mathematics and code students from Qwen3-4B and evaluate their final checkpoints on AIME24 and LCB v5. AIME24 and LCB v5 use a 40,960-token output limit and 49,152-token context.
Additional Experimental Results
Alternative Weak-Model Constructions
Table 6 extends the construction comparison in § 6 with additional precisions, group sizes, sparsity patterns, and MLP channel pruning. All students initialize from Qwen3-4B, use the configuration in Table 5, and are evaluated on AIME24 with Avg@32.
| Quantization | Pruning | ||||
| Construction | Setting | Acc. (%) | Construction | Setting | Acc. (%) |
| Qwen3-4B | — | 73.4 | Qwen3-4B | — | 73.4 |
| RTN | 6-bit, | 73.0 | Magnitude pruning | 20% per row | 74.3 |
| RTN | 4-bit, | 72.0 | Magnitude pruning | 40% per row | 74.4 |
| RTN | 4-bit, | 71.0 | Wanda | 20% per row | 72.3 |
| GPTQ | 3-bit, | 72.0 | Wanda | 40% per row | 74.4 |
| GPTQ | 2-bit, | 70.9 | Wanda | 2:4 | 74.4 |
| W4A8 | 72.4 | SparseGPT | 50% | 73.3 | |
| W4A4 | 70.0 | SparseGPT | 2:4 | 73.5 | |
| Smooth W4A4 | 75.3 | MLP channel pruning | 25% | 73.5 | |
| RTN | 3-bit, | 75.4 | Magnitude pruning | 75.8 |
Table 6. Alternative constructions on Qwen3-4B and AIME24 (Avg@32). Default RTN and magnitude pruning (shaded) achieve the highest accuracy in their families. denotes group size. Alternatives include GPTQ [9], Smooth W4A4 [60], Wanda [50], and SparseGPT [8].
Smooth W4A4 improves on plain W4A4 at the same weight and activation precision. Per-row magnitude pruning and Wanda both improve accuracy at 40% sparsity, while the default group-relative magnitude rule gives the strongest pruning result.
Row-Norm Restoration
We compare magnitude pruning with and without the row-norm restoration in Eq. (7). Both constructions use group size 128 and , with the same pruning mask, cached trajectories, student initialization, and training recipe. The paired scorers use FP32 forwards. Table 7 reports student accuracy on Qwen3-4B with AIME25 and Qwen3.5-4B with HMMT25, using Avg@32, a 40,960-token output limit, and a 49,152-token context.
| Construction | Qwen3-4B AIME25 | Qwen3.5-4B HMMT25 |
| Pruning w/o row-norm restoration | 65.4 | 70.0 |
| Pruning w/ row-norm restoration | 66.0 | 70.5 |
Table 7. Effect of row-norm restoration on the pruning construction. Accuracy (%) is measured with Avg@32. The default with restoration (shaded) gives a small additional gain on both models.
Row-norm restoration adds 0.6 and 0.5 percentage points on the two models. We retain it in our default construction, following prior work on rescaling retained weights after pruning [15]. Restoring each row’s original norm preserves its weight scale while retaining the directional change introduced by pruning.
Training-Signal Analysis
Token-Level Training Signal
At each state , the cache retains 16 original-model token candidates and aggregates the remaining vocabulary into an OTHER bucket. Let be the cached behavior distribution over these 17 buckets and . Scorer probabilities are normalized over the full vocabulary before gathering the candidates. We set for retained candidates and .
The offline implementation uses the tilted target with behavior-weighted log-probability regression:
where is the student’s bucket distribution. At , the initial gradient with respect to the bucket logits is
This expression centers each candidate’s contrast against the behavior-weighted mean. For each position , we measure the signal magnitude by . The share assigned to a reasoning role is
The token-share baseline is the fraction of positions assigned to that role. Quantization and pruning are evaluated on the same prefixes, token candidates, and behavior probabilities.
Contextual Reasoning Roles
We select every 200th response from the 12,800 Qwen3-4B mathematics training trajectories, obtaining 64 responses and 124,923 active positions. Response segments are labeled by their function in the surrounding reasoning using the eight-role ThinkARM taxonomy (Li et al., 2026a). Table 8 summarizes the roles, together with a Formatting category for structural tokens and whitespace.
| Role | Function |
| Read | Restates the given facts, conditions, or requested result. |
| Analyze | Explains a concept, builds a representation, or makes a logical deduction. |
| Plan | Commits to an action before carrying it out. |
| Implement | Executes calculations, substitutions, or other concrete operations. |
| Explore | Proposes a tentative approach or uncertain possibility. |
| Verify | Checks an existing result or approach against the problem’s conditions. |
| Monitor | Comments briefly on the reasoning process. |
| Answer | States a proposed or final answer to the original question. |
| Formatting | Marks structural tokens or whitespace-only spans. |
Table 8. Contextual roles used for the training-signal analysis. The eight reasoning roles follow ThinkARM (Li et al., 2026a). Labels reflect each segment’s function in the response.
Three assistant annotators label 6,648 content segments using the problem, surrounding response, and a shared codebook, without access to model scores or construction identities. An independent assistant reviews 128 sampled segments, with 84.4% agreement before adjudication. The labels are finalized before aggregating signal statistics. A token receives the label of the segment overlapping the largest number of its non-whitespace UTF-8 bytes, with ties assigned to the earlier segment.
Case Studies
Reasoning Improvements After Self-Distillation
Figure 5 and Figure 6 compare incorrect original-model responses with correct student responses to the same evaluation prompts, using matched sampling seeds. The mathematics examples show two changes in reasoning. Quantization-based training corrects double counting in a symmetric divisor argument, while pruning-based training yields a formulation that preserves the distinction between reusing an edge and revisiting a vertex. The code examples show improvements in algorithm design and constraint checking. The students recover the correct deletion-time invariant in Gravity and enforce both initial nonadjacency conditions in Switch Seats. Each code example includes a recorded test that exposes the original program’s error and is correctly handled by the student’s program.

Figure 5. Reasoning improvements after self-distillation. On HMMT25, the quantization-trained Qwen3.5-4B student counts each symmetric divisor pair once, correcting the original model’s double counting (a). The pruning-trained student models the door constraint as an Eulerian circuit, allowing repeated visits to cells while traversing each selected door once (b). Excerpts are taken from the original and trained models’ responses to the same questions, with omissions marked by [. . .].

Figure 6. Figure 6. Code excerpts before and after self-distillation on LiveCodeBench v6. On Gravity (a), quantization-based training replaces an incorrect accumulation of inter-block gaps with the maximum initial height at each rank. On Switch Seats (b), pruning-based training preserves both nonadjacency conditions when translating the problem into code. Both post-training programs pass the corresponding test suites. The examples illustrate improved algorithmic reasoning and constraint checking.
(a) Counting each symmetric pair once
Question. Compute
Original (incorrect)
Thus, there are positive divisors in the range. Similarly, there are 14 negative divisors in the range (since ). Total number of valid values is . These correspond to 28 pairs where the sum is 0. The remaining number of pairs is . These pairs sum to . So the sum over pairs is .
[. . .]
The total sum is:
Answer:
WISD (Quantization, correct)
We restrict our attention to . The only divisor not in this set is 2025 itself (since ). All other 14 divisors are and thus included. So, there are 14 values of for which is an integer. For these 14 pairs, the contribution is 0. The total number of pairs formed this way corresponds to the size of , which is . The number of pairs where the contribution is is .
[. . .]
Answer:
(b) Preserving the edge constraint
Question. In an grid, adjacent cells share a door. Find the maximum number of doors in a closed walk that never reuses a door.
Original (incorrect)
The problem asks for the maximum number of doors Karthik can walk through in an grid, starting and ending at the same cell, without reusing any door. This is equivalent to finding the length of the longest cycle in the grid graph .
[. . .]
The graph is bipartite, which implies that any cycle must have an even length. Furthermore, a cycle of length must visit vertices from set and vertices from set . Therefore, the length of any cycle satisfies , which implies .
[. . .]
Answer:
WISD (Pruning, correct)
The problem asks for the maximum number of doors (edges) Karthik can traverse in an Eulerian circuit (a closed walk visiting every traversed door exactly once) in an grid graph. This is equivalent to finding a subgraph of the grid graph that is connected and has all vertices of even degree, maximizing the number of edges .
[. . .]
Total number of removed edges .
[. . .]
Total number of doors (edges) in an grid is . Maximum doors Karthik can walk = Total edges - Minimum removed edges
[. . .]
Answer:
(a) Recovering the deletion-time invariant. Qwen3.6-35B-A3B, quantization
Problem. At each time step, remove a full bottom row, then process blocks from bottom to top, moving each down one cell if the cell below is empty. Determine whether a queried block still exists.
Original (incorrect)
for m in range(1, K_max + 1):
max_gap = 0
for g_list in gaps:
gap = g_list[m-1]
if gap > max_gap:
max_gap = gap
current_T += max_gap
T[m] = current_T
WISD (correct)
removal_times = list(col_ys[0][:M])
for ys in col_ys[1:]:
for r in range(M):
if ys[r] > removal_times[r]:
removal_times[r] = ys[r]
Failing test. Column heights are (31, 39, 43, 48, 50) and (2, 35, 39, 44). For the second block in column 2, the original predicts deletion at 31 + max(8, 33) = 64, while the student obtains max(39, 35) = 39. At time 48.5, the answers are therefore Yes (incorrect) and No (correct).
(b) Enforcing both initial conditions. Qwen3.5-4B, pruning
Problem. Each couple appears twice in a seating array. Count pairs of couples whose members are initially nonadjacent and can each become adjacent by swapping their four seats.
Original (incorrect)
for i in range(2 * N - 1):
u = A[i]
v = A[i+1]
if u != v:
[...]
groups[key].append(i)
[...]
for j in range(n_indices):
[...]
if k >= 0:
current_count += (k + 1)
ans += current_count
WISD (correct)
for a in range(1, N + 1):
if pos[a][1] - pos[a][0] <= 1:
continue
[...]
if abs(other_pos_b - p2) == 1:
if b_val not in local_seen:
local_seen.add(b_val)
[...]
if pos[b_val][1] - pos[b_val][0] > 1 and
b_val > a:
ans += 1
Failing test. For A = [2, 1, 1, 2], the original counts the two disjoint mixed-couple edges and returns 1. Couple 1 is already adjacent, so this pair is invalid. The student checks both couples and returns the correct answer, 0.
Local Supervision from Weak-Model Contrasts
Figure 7 extends the token-level examples in Figure 4 with two more Qwen3-4B training trajectories. In the quantization example, the contrast reinforces the negative sign in an inadmissible prime candidate and the subsequent decision to discard it. In the pruning example, it reinforces the zero required by a feasible variable assignment and the comparison with a lower-valued alternative. These examples show how the training signal emphasizes intermediate calculations and the decisions that follow from them.
Figure 7. Weak-model contrasts reinforce local reasoning steps. Blue and orange indicate increased and decreased target probability relative to the behavior distribution, with underlines marking the tokens discussed in the text. Quantization reinforces the negative sign in and the rejection of the resulting nonprime candidates (a). Pruning reinforces the zero used when substituting and all other variables equal to zero, together with the comparison identifying a uniform four-variable allocation as worse (b). The highlighted steps connect numerical calculations to candidate rejection and comparisons between feasible assignments.
References
- [1]Agarwal, R., Vieillard, N., Zhou, Y., Stanczyk, P., Ramos, Garea, S., Geist, M., and Bachem, O. On-policy distillation of language models: Learning from self-generated mistakes. In Kim, B., Yue, Y., Chaudhuri, S., Fragkiadaki, K., Khan, M., and Sun, Y. (eds.), International Conference on Learning Representations, volume 2024, pp. 21264–21263, 2024. URL https://proceedings.iclr.cc/paper_files/paper/2024/file/5be69a584901a26c521c2b51e40a4c20-Paper-Conference.pdf.arxiv.org/abs/2306.13649
- [2]Ahn, D., Cho, H., Min, J., Jang, W., Kim, J., Kim, S., Park, H. H., Jin, K. H., and Kim, S. Self-rectifying diffusion sampling with perturbed-attention guidance. In Leonardis, A., Ricci, E., Roth, S., Roussakovsky, O., Sattler, T., and Varol, G. (eds.), Computer Vision – ECCV 2024, pp. 1–17, Cham, 2025. Springer Nature Switzerland. ISBN 978-3-031-73464-9.arxiv.org/abs/2403.17377
- [3]Armandpour, M., Ilhan, F., Harrison, D., Jaiswal, A., Hoang, D. N. M., Faghri, F., Zhang, Y., Cho, M., and Farajatbar, M. Unmasking on-policy distillation: Where it helps, where it hurts, and why, 2026. URL https://arxiv.org/abs/2605.10889.
- [4]Chuang, Y.-S., Xie, Y., Luo, H., Kim, Y., Glass, J. R., and He, P. DoLa: Decoding by contrasting layers improves factuality in large language models. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=Th6NyL07na.arxiv.org/abs/2309.03883
- [5]DeepSeek-AI, Xu, A., Lin, B., Xue, B., Wang, B., Xu, B., Wu, B., Zhang, B., Lin, C., Dong, C., Ling, C., Lu, C., Zhao, C., Deng, C., Hou, C., Xu, C., Shao, C., Ruan, C., Sun, C., Dai, D., Guo, D., Yang, D., Chen, D., Li, D., Ji, D., Li, E., Wei, F., Lin, F., Yuan, F., Xia, F., Dai, F., Hao, G., Chen, G., Cao, G., Meng, G., Li, G., Yu, H., Zhang, H., Xu, H., Li, H., Liang, H., Zhang, H., Luo, H., Wei, H., Yuan, H., Zhang, H., Luo, H., Chen, H., Ji, H., Zhang, H., Ding, H., Tang, H., Cao, H., Gao, H., Qu, H., Zeng, H., Yang, J., Zhu, J., Luo, J., Song, J., Yu, J., Huang, J., Cai, J., Liang, J., Zhou, J., Ye, J., Li, J., Xu, J., Hu, J., Yang, J., Chen, J., Yan, J., Chen, J., Zhou, J., Xiang, J., Yuan, J., Cheng, J., Zhou, J., Zhu, J., Yu, J., Sun, J., Ran, J., Jiang, J., Qiu, J., Li, J., Zheng, J., Song, J., Dong, K., Gao, K., Guan, K., Zhou, K., Huang, K., Yu, K., Wang, L., Zhang, L., Wang, L., Xia, L., Zhang, L., Zhao, L., Guo, L., Luo, L., Ma, L., Zhu, L., Wang, L., Cai, L., Zhang, L., Chen, L., Di, M., Xu, M., Mei, M., Wang, M., Zhang, M., Zhang, M., Tang, M., Li, M., Zhou, M., Han, M., Wang, N., Huang, P., Wang, P., Cong, P., Wang, P., Zhang, P., Wang, Q., Zhu, Q., Li, Q., Chen, Q., Du, Q., Jiang, Q., Tian, R., Xu, R., Lu, R., Xu, R., Ge, R., Zhang, R., Pan, R., Wang, R., Chen, R., Yin, R., Xu, R., Shen, R., Zhang, R., Chen, R., Liu, S., Lu, S., Sun, S., Zhou, S., Chen, S., Cai, S., Nie, S., Wu, S., Chen, S., Hu, S., Liu, S., Hu, S., Ma, S., Wang, S., Yu, S., Zhou, S., Pan, S., Yu, S., Zhou, S., Ni, T., Yun, T., Jin, T., Pei, T., Ye, T., Lin, T., Ji, T., Cui, T., Yue, T., Yu, T., Wang, T., Zhang, W., Xiao, W., Zeng, W., An, W., Zhao, W., Liu, W., Liang, W., Pang, W., Luo, W., Yao, W., Gao, W., Yang, W., Huang, W., Hou, W., Zhang, W., Ma, W., Gao, X., He, X., Wang, X., Wang, X., Bi, X., Liu, X., Wang, X., Chen, X., Zhang, X., Nie, X., Sun, X., Wang, X., Cheng, X., Liu, X., Xie, X., Liu, X., Liu, X., Yu, X., Li, X., Yang, X., Zhang, X., Chen, X., Wang, X., Su, X., Chen, X., Lin, X., Fu, X., Yan, Y., Wang, Y., Ma, Y., Luo, Y., Zhang, Y., Xu, Y., Ma, Y., Huang, Y., Li, Y., Li, Y., Xu, Y., Zhao, Y., Sun, Y., Wang, Y., Qian, Y., Shao, Y., Yu, Y., Zhang, Y., Ding, Y., Shi, Y., Wu, Y., Xiong, Y., Ma, Y., He, Y., Tang, Y., Zhou, Y., Luo, Y., Zhong, Y., Piao, Y., Wang, Y., Zhang, Y., Chen, Y., Tan, Y., Wei, Y., Ma, Y., Liu, Y., Yang, Y., Guo, Y., Wu, Y., Wu, Y., Li, Y., Cheng, Y., Ou, Y., Xu, Y., Li, Y., Wang, Y., Yang, Y., Xu, Y., Wu, Y., Meng, Y., Zou, Y., Zha, Y., Xiong, Y., Chen, Y., Lin, Y., Cao, Y., Wang, Y., Zhang, Y., Yan, Y., Lin, Y., Gu, Y., Luo, Y., You, Y., Liu, Y., Zhou, Y., Zhou, Y., Huang, Y., Wu, Z., Wang, Z., Zhao, Z., Ren, Z., Zhang, Z., Sha, Z., Fu, Z., Ju, Z., Xu, Z., Xie, Z., Zhang, Z., Gao, Z., Hao, Z., Guo, Z., Ma, Z., Yan, Z., Shao, Z., Huang, Z., Chen, Z., Wu, Z., Ren, Z., Wu, Z., Li, Z., Zhang, Z., Xu, Z., Wang, Z., Qu, Z., Gu, Z., Zhu, Z., Li, Z., Zhang, Z., Xie, Z., Gao, Z., Wan, Z., Pan, Z., and Yao, Z. DeepSeek-V3: Towards highly efficient million-token context intelligence, 2026. URL https://arxiv.org/abs/2606.19348.
- [6]Ding, Y. and Zhang, R. Does on-policy distillation really distill? from noisy teacher to self-improvement, 2026. URL https://arxiv.org/abs/2608.31046.
- [7]Feng, S., Gao, H.-a., Chi, H., Wu, H., Zhang, Z., Jiang, Z., He, B., Ma, W.-Y., Zhang, Y.-Q., and Zhou, H. Weak-to-strong generalization via direct on-policy distillation, 2026. URL https://arxiv.org/abs/2607.05394.
- [8]Frantar, E. and Alistarh, D. SparseGPT: Massive language models can be accurately pruned in one-shot. In Proceedings of the 40th International Conference on Machine Learning, volume 202 of Proceedings of Machine Learning Research, pp. 10323–10337. PMLR, 2023. URL https://proceedings.mlr.press/v202/frantar23a.html.arxiv.org/abs/2301.00774
- [9]Frantar, E., Ashkboos, S., Hoefler, T., and Alistarh, D. GPTQ: Accurate post-training quantization for generative pre-trained transformers. In The Eleventh International Conference on Learning Representations, 2023. URL https://openreview.net/forum?id=tcbBPnfwxS.arxiv.org/abs/2210.17323
- [11]Gera, A., Friedman, R., Arviv, O., Gunasekara, C., Sznajder, B., Slonim, N., and Shnarch, E. The benefits of bad advice: Autocontrastive decoding across model layers. In Rogers, A., Boyd-Graber, J., and Okazaki, N. (eds.), Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 10406–10420. Toronto, Canada, July 2023. Association for Computational Linguistics. doi: 10.18653/v1/2023.acl-long.580. URL https://aclanthology.org/2023.acl-long.580/.DOI
- [14]Harvard–MIT Mathematics Tournament. Archive of February 2025, 2025. URL https://www.hmmt.org/www/archive/282.
- [15]Hayou, S., Ton, J.-F., Doucet, A., and Teh, Y. W. Robust pruning at initialization. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=vXj_ucZQ4hA.arxiv.org/abs/2002.08797
- [19]Hong, S., Lee, G., Jang, W., and Kim, S. Improving sample quality of diffusion models using self-attention guidance. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pp. 7462–7471, October 2023.arxiv.org/abs/2210.00939
- [20]Hübbötter, J., Lübeck, F., Behric, L., Baumann, A., Bagatella, M., Marta, D., Hakimi, I., Shenfeld, I., Buening, T. K., Guestrin, C., and Krause, A. Reinforcement learning via self-distillation. In Proceedings of the 43rd International Conference on Machine Learning, 2026. URL https://icml.cc/virtual/2026/poster/64121.
- [21]Jain, N., Han, K., Gu, A., Li, W.-D., Yan, F., Zhang, T., Wang, S., Solar-Lezama, A., Sen, K., and Stoica, I. LiveCodeBench: Holistic and contamination free evaluation of large language models for code. In Yue, Y., Garg, A., Peng, N., Sha, F., and Yu, R. (eds.), International Conference on Learning Representations, volume 2025, pp. 58791–58831, 2025. URL https://proceedings.iclr.cc/paper_files/paper/2025/file/94074dd5a072d28ff75a76dabed43767-Paper-Conference.pdf.arxiv.org/abs/2403.07974
- [22]Jiang, X., Ye, H., Zhu, Y., Zheng, X., Chen, Z., and Gong, J. HICD: Hallucination-inducing via attention dispersion for contrastive decoding to mitigate hallucinations in large language models. In Che, W., Nabende, J., Shutova, E., and Pilehvar, M. T. (eds.), Findings of the Association for Computational Linguistics: ACL 2025, pp. 7764–7786, Vienna, Austria, July 2025. Association for Computational Linguistics. ISBN 979-8-89176-256-5. doi: 10.18653/v1/2025.findings-acl.405. URL https://aclanthology.org/2025.findings-acl.405/.
- [23]Jiang, Z., Chen, T., Mortazavi, B. J., and Wang, Z. Self-damaging contrastive learning. In Meila, M. and Zhang, T. (eds.), Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp. 4927–4939. PMLR, 18–24 Jul 2021. URL https://proceedings.mlr.press/v139/jiang21a.html.arxiv.org/abs/2106.02990
- [24]Jin, W., Min, T., Yang, Y., Wei, D., Zhou, Y., Kadhe, S. R., Baracaldo, N., and Lee, K. Entropy-aware on-policy distillation of language models. In Zhang, T., Dudik, M., Jaggi, M., Agarwal, A., Li, S., Schuurmans, D., Zhu, J., Berkenkamp, F., Dong, H., and Bietti, A. (eds.), Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 53926–53943. PMLR, 06–11 Jul 2026. URL https://proceedings.mlr.press/v306/jin26e.html.arxiv.org/abs/2603.07079
- [25]Karras, T., Aittala, M., Kynkäänniemi, T., Lehtinen, J., Aila, T., and Laine, S. Guiding a diffusion model with a bad version of itself. In Advances in Neural Information Processing Systems, volume 37, 2024. URL https://arxiv.org/abs/2406.02507. arXiv:2406.02507.
- [30]Liang, Y., Tian, Y., Li, Y., Jia, Y., Huang, F., Zhou, T., and Fu, D. Visual, abstractive self-distillation, 2026. URL https://arxiv.org/abs/2607.21556.
- [31]Lin, M., Cai, C., Xu, L., Wei, Y., and Han, L. DreOPD: Degraded-reference extrapolative on-policy distillation for flow-matching models, 2026. URL https://arxiv.org/abs/2608.09233.
- [32]Liu, A., Han, X., Wang, Y., Tsvetkov, Y., Choi, Y., and Smith, N. A. Tuning language models by proxy. In First Conference on Language Modeling, 2024. URL https://arxiv.org/abs/2401.08565. arXiv:2401.08565.
- [33]Liu, X., Wang, X., Ma, Y., Zhang, Y., and Xiao, C. When are teacher tokens reliable? position-weighted on-policy self-distillation for reasoning, 2026. URL https://arxiv.org/abs/2605.21606.
- [35]Mathematical Association of America. MAA Invitational Competitions, 2026. URL https://maa.org/maa-invitational-competitions/.
- [36]Mitchell, E., Rafailov, R., Sharma, A., Finn, C., and Manning, C. D. An emulator for fine-tuning large language models using small language models. In The Twelfth International Conference on Learning Representations, 2024. URL https://arxiv.org/abs/2310.12962. arXiv:2310.12962.
- [37]O’Brien, S. and Lewis, M. Contrastive decoding improves reasoning in large language models, 2023. URL https://arxiv.org/abs/2309.09117.
- [38]Pei, R., Wei, Z., Xu, S., Zhu, X., Chen, W.-L., and Meng, Y. Negative self-distillation: Learning to reason by avoiding flaws, 2026. URL https://arxiv.org/abs/2609.11699.
- [39]Penaloza, E., Vattikonda, D., Gontier, N., Lacoste, A., Charlin, L., and Caccia, M. Privileged information distillation for language models. In Proceedings of the 43rd International Conference on Machine Learning, 2026. URL https://icml.cc/virtual/2026/poster/62658.arxiv.org/abs/2602.04942
- [40]Phan, P., Tran, H., and Phan, L. Distillation contrastive decoding: Improving LLMs reasoning with contrastive decoding and distillation, 2024. URL https://arxiv.org/abs/2402.14874.
- [41]Qwen Team. Qwen3.6-27B: Flagship-level coding in a 27B dense model, April 2026a. URL https://qwen.ai/blog?id=qwen3.6-27b.
- [42]Qwen Team. Qwen3.6-35B-A3B: Agentic coding power, now open to all, April 2026b. URL https://qwen.ai/blog?id=qwen3.6-35b-a3b.
- [43]Qwen Team. Qwen3.5: Towards native multimodal agents, February 2026. URL https://qwen.ai/blog?id=qwen3.5.
- [44]Ruan, J., Tang, J., Yuan, W., Liu, T., Bai, S., Liu, D., Yang, Z., and Fu, Y. Contrastive on-policy distillation, 2026. URL https://arxiv.org/abs/2607.19046.
- [45]Shao, Z., Wang, P., Zhu, Q., Xu, R., Song, J., Bi, X., Zhang, H., Zhang, M., Li, Y. K., Wu, Y., and Guo, D. DeepSeekMath: Pushing the limits of mathematical reasoning in open language models, 2024. URL https://arxiv.org/abs/2402.03300.
- [46]Shen, Z., Tong, J., Yan, S., Shen, C., Chen, H., Ye, W., Hu, X., Miao, R., Wang, H., Zhao, J., Chen, G., and Ye, J. Purified OPSD: On-policy self-distillation without losing how to think, 2026. URL https://arxiv.org/abs/2607.02234.
- [47]Shenfeld, I., Damani, M., Hübotter, J., and Agrawal, P. Self-distillation enables continual learning. In Proceedings of the 43rd International Conference on Machine Learning, 2026. URL https://icml.cc/virtual/2026/poster/61434.arxiv.org/abs/2601.19897
- [48]Shi, W., Han, X., Lewis, M., Tsvetkov, Y., Zettlemoyer, L., and Yih, W.-t. Trusting your evidence: Hallucinate less with context-aware decoding. In Duh, K., Gomez, H., and Bethard, S. (eds.), Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 2: Short Papers), pp. 783–791, Mexico City, Mexico, June 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.naacl-short.69. URL https://aclanthology.org/2024.naacl-short.69/.DOI
- [50]Sun, M., Liu, Z., Bair, A., and Kolter, J. Z. A simple and effective pruning approach for large language models. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=PxoFut3dWW.arxiv.org/abs/2306.11695
- [51]Sun, Z., Li, E., Zhao, Y., Cheng, X., Yuan, W., Li, K., Liu, C., Liu, H., He, B., Zhang, X., Zhu, H. B. H., and Zeng, L. SR-OPSD: Self-referenced on-policy self-distillation, 2026. URL https://arxiv.org/abs/2608.09745.
- [52]Tan, Z. and Hong, Y. Self-supervised on-policy distillation for reasoning language models, 2026. URL https://arxiv.org/abs/2605.17497.
- [53]Team, C., Xiao, B., Xia, B., Yang, B., Gao, B., Shen, B., Zhang, C., He, C., Lou, C., Luo, F., Wang, G., Xie, G., Zhang, H., Lv, H., Li, H., Chen, H., Xu, H., Zhang, H., Liu, H., Duo, J., Wei, J., Xiao, J., Dong, J., Shi, J., Hu, J., Bao, K., Zhou, K., Li, L., Zhao, L., Zhang, L., Li, P., Chen, Q., Liu, S., Yu, S., Cao, S., Chen, S., Yu, S., Liu, S., Zhou, T., Su, W., Wang, W., Ma, W., Deng, X., Mao, B., Ye, B., Cai, C., Wang, C., Zhu, C., Ma, C., Chen, C., Li, C., Zhu, D., Xiao, D., Zhang, D., Zhang, D., Liu, F., Yang, F., Shi, F., Wang, G., Tian, H., Wu, H., Qu, H., Yi, H., An, H., Guan, H., Zhang, X., Song, Y., Yan, Y., Zhao, Y., Lai, Y., Gao, Y., Cheng, Y., Tian, Y., Wang, Y., Tang, Z., Tang, Z., Wen, Z., Song, Z., Zheng, Z., Jiang, Z., Wen, J., Sun, J., Li, J., Xue, J., Xia, J., Fang, K., Zhu, M., Chen, N., Tu, Q., Zhang, Q., Wang, Q., Li, R., Ma, R., Zhang, S., Wang, S., Li, S., Gu, S., Ren, S., Deng, S., Guo, T., Lu, T., Zhuang, W., Zhang, W., Xiong, W., Huang, W., Yang, W., Zhang, X., Yong, X., Wang, X., Xie, X., Jiang, Y., Yang, Y., He, Y., Tu, Y., Dong, Y., Liu, Y., Yu, Y., Ma, Y., Yu, Y., Xiang, Y., Huang, Z., Lin, Z., Xu, Z., Chen, Z., Deng, Z., Zhang, Z., and Yue, Z. MiMo-V2-Flash technical report, 2026. URL https://arxiv.org/abs/2601.02780.
- [54]Team Olmo, Ettinger, A., Bertsch, A., Kuehl, B., Graham, D., Heineman, D., Groeneveld, D., Brahman, F., Timbers, F., Ivison, H., Morrison, J., Poznanski, J., Lo, K., Soldaini, L., Jordan, M., Chen, M., Nezhurich, M., Lambert, N., Walsh, P., Dasigi, P., Berry, R., Malik, S., Shah, S., Geng, S., Arora, S., Gupta, S., Anderson, T., Xiao, T., Murray, T., Romero, T., Graf, V., Asai, A., Bhagavatula, A., Wetig, A., Liu, A., Rangapur, A., Anastasiades, C., Huang, C., Schwenk, D., Trivedi, H., Magnusson, I., Lochner, J., Liu, J., Miranda, L. J. V., Sap, M., Morgan, M., Schmitz, M., Guerquin, M., Wilson, M., Huff, R., Bras, R. L., Xin, R., Shao, R., Sjønsberg, S., Shen, S. Z., Li, S. S., Wilde, T., Pyatkin, V., Merrill, W., Chang, Y., Gu, Y., Zeng, Z., Sabharwal, A., Zettlemoyer, L., Koh, P. W., Farhadi, A., Smith, N. A., and Hajishirzi, H. Olmo 3, 2026. URL https://arxiv.org/abs/2512.13961.
- [60]Xiao, G., Lin, J., Seznec, M., Wu, H., Demouth, J., and Han, S. SmoothQuant: Accurate and efficient post-training quantization for large language models. In Proceedings of the 40th International Conference on Machine Learning, volume 202 of Proceedings of Machine Learning Research, pp. 38087–38099. PMLR, 2023. URL https://proceedings.mlr.press/v202/x iao23c.html.
- [63]Yang, A., Li, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Gao, C., Huang, C., Lv, C., Zheng, C., Liu, D., Zhou, F., Huang, F., Hu, F., Ge, H., Wei, H., Lin, H., Tang, J., Yang, J., Tu, J., Zhang, J., Yang, J., Yang, J., Zhou, J., Zhou, J., Lin, J., Dang, K., Bao, K., Yang, K., Yu, L., Deng, L., Li, M., Xue, M., Li, M., Zhang, P., Wang, P., Zhu, Q., Men, R., Gao, R., Liu, S., Luo, S., Li, T., Tang, T., Yin, W., Ren, X., Wang, X., Zhang, X., Ren, X., Fan, Y., Su, Y., Zhang, Y., Zhang, Y., Wan, Y., Liu, Y., Wang, Z., Cui, Z., Zhang, Z., Zhou, Z., and Qiu, Z. Qwen3 technical report, 2025. URL https://arxiv.org/abs/2505.09388.
- [64]Yang, C., Qin, C., Si, Q., Chen, M., Gu, N., Yao, D., Lin, Z., Wang, W., Wang, J., and Duan, N. Self-distilled RLVR, 2026a. URL https://arxiv.org/abs/2604.03128.
- [65]Yang, W., Liu, W., Xie, R., Yang, K., Yang, S., and Lin, Y. Learning beyond teacher: Generalized on-policy distillation with reward extrapolation, 2026b. URL https://arxiv.org/abs/2602.12125.
- [66]Yang, Y., Wang, X., and Zhang, W. OGLS-SD: On-policy self-distillation with outcome-guided logit steering for LLM reasoning, 2026c. URL https://arxiv.org/abs/2605.12400.
- [67]Yang, Z., Liu, Z., Chen, Y., Dai, W., Wang, B., Lin, S.-C., Lee, C., Chen, Y., Jiang, D., He, J., Pi, R., Lam, G., Lee, N., Bukharin, A., Shoeybi, M., Catanzaro, B., and Ping, W. Nemotron-Cascade 2: Post-training LLMs with cascade RL and multi-domain on-policy distillation, 2026d. URL https://arxiv.org/abs/2603.19220.
- [70]Zhang, G., Lyu, J., Sun, R., Yu, X., Zhao, H., Ren, Q., and Yan, S. Latent on-policy self-distillation, 2026a. URL https://arxiv.org/abs/2608.13040.
- [71]Zhang, J., Juan, D.-C., Rashtchian, C., Ferng, C.-S., Jiang, H., and Chen, Y. SLED: Self logits evolution decoding for improving factuality in large language models. In Globerson, A., Mackey, L., Belgrave, D., Fan, A., Paquet, U., Tomczak, J., and Zhang, C. (eds.), Advances in Neural Information Processing Systems, volume 37, pp. 5188–5209. Curran Associates, Inc., 2024. doi: 10.5220/079017-0168. URL https://proceedings.neurips.cc/paper_files/paper/2024/file/0939f13ffce3ff487509d902ddba4571-Paper-Conference.pdf.arxiv.org/abs/2411.02433
- [72]Zhang, R., Bai, R. H., Zheng, H., Jaitly, N., Collobert, R., and Zhang, Y. Embarrassingly simple self-distillation improves code generation, 2026b. URL https://arxiv.org/abs/2604.01193.
- [73]Zhang, Y., Cui, L., Bi, W., and Shi, S. Alleviating hallucinations of large language models through induced hallucinations. In Chiruzzo, L., Ritter, A., and Wang, L. (eds.), Findings of the Association for Computational Linguistics: NAACL 2025, pp. 8233–8247, Albuquerque, New Mexico, April 2025. Association for Computational Linguistics. ISBN 979-8-89176-195-7. doi: 10.18653/v1/2025.findings-naacl.459. URL https://aclanthology.org/2025.findings-naacl.459/.DOI
- [74]Zhao, S., Xie, Z., Liu, M., Huang, J., Pang, G., Chen, F., and Grover, A. Self-distilled reasoner: On-policy self-distillation for large language models. In Proceedings of the 43rd International Conference on Machine Learning, 2026. URL https://icml.cc/virtual/2026/poster/64784.arxiv.org/abs/2601.18734



