betaFeedback

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.

MethodDense Learning SignalNo External TeacherNo Reference SolutionsNo Environment Feedback
GRPO ([45])✗✓✓✗
OPD ([1])✓✗✓✓
OPSD ([74])✓✓✗✓
SDPO ([20])✓✓✓✗
WISD (ours)✓✓✓✓

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 cc, 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 πθ\pi_{\theta} be an autoregressive student, x∼Dx \sim\mathcal{D} a prompt, and y∼πθ(⋅∣x)y \sim\pi_{\theta}(\cdot\mid x) a generated response. At position tt, the state st=(x,y<t)s_t = (x, y_{<t}) determines a distribution over next-token actions a∈Va \in\mathcal{V}. OPD supervises the student on the states it visits during generation. Writing dπθd_{\pi_{\theta}} for this state distribution, a common objective matches the student to a teacher πT\pi_T through reverse KL ([1] (Gu et al. 2024)):

LOPD(θ)=Es∼dπθ[DKL(πθ(⋅∣s) ∥ πT(⋅∣s))].(1)\mathcal{L}_{\mathrm{OPD}}(\theta) = \mathbb{E}_{s \sim d_{\pi_{\theta}}} \left[ D_{\mathrm{KL}}\left(\pi_{\theta}(\cdot\mid s) \,\middle\|\, \pi_T(\cdot\mid s)\right) \right]. \tag*{(1)}

DOPD ([7]) represents supervision through a pair of frozen models (π+,π−)(\pi^+,\pi^-), typically a post-trained model and its checkpoint before post-training. Their token-level log-probability difference defines a policy shift:

r(a∣s)=log⁡π+(a∣s)−log⁡π−(a∣s).(2)r(a \mid s) = \log\pi^+(a \mid s) - \log\pi^-(a \mid s). \tag*{(2)}

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 π\pi and privileged information cc, these approaches construct a more informed self-teacher π(⋅∣s,c)\pi(\cdot\mid s,c) 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 π(⋅∣s)\pi(\cdot\mid s) is the weaker member, while its context-conditioned counterpart is the stronger member. These two roles can be written as π−(a∣s)=π(a∣s)\pi^{-}(a \mid s) = \pi(a \mid s) and π+(a∣s)=π(a∣s,c)\pi^{+}(a \mid s) = \pi(a \mid s,c). The student encounters the task without cc, 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 π0=πθ0\pi_0 = \pi_{\theta_0} denote the original model and πw=πW(θ0)\pi_w = \pi_{\mathcal{W}(\theta_0)} its copy under a weakening operator W\mathcal{W}. Setting (π+,π−)=(π0,πw)(\pi^{+},\pi^{-}) = (\pi_0,\pi_w) in Eq. (2) gives

rw(a∣s)=log⁡π0(a∣s)−log⁡πw(a∣s).(3)r_w(a \mid s) = \log\pi_0(a \mid s) - \log\pi_w(a \mid s). \tag*{(3)}

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

qw(a∣s)=π0(a∣s)exp⁡(rw(a∣s)/α)∑a′π0(a′∣s)exp⁡(rw(a′∣s)/α).(4)q_w(a \mid s) = \frac{\pi_0(a \mid s)\exp(r_w(a \mid s)/\alpha)}{\sum_{a'} \pi_0(a' \mid s)\exp(r_w(a' \mid s)/\alpha)}. \tag*{(4)}
LTT(θ)=αEs∼dπ0[DKL(πθ(⋅∣s) ∥ qw(⋅∣s))].(5)\mathcal{L}_{\mathrm{TT}}(\theta) = \alpha\mathbb{E}_{s \sim d_{\pi_0}}\left[D_{\mathrm{KL}}\left(\pi_\theta(\cdot\mid s) \,\|\, q_w(\cdot\mid s)\right)\right]. \tag*{(5)}

Here α>0\alpha> 0 is the distillation coefficient which controls how strongly the contrast rwr_w tilts the target away from π0\pi_0 and scales the objective accordingly. The original model generates trajectories on unlabeled prompts, and the frozen pair (π0,πw)(\pi_0,\pi_w) scores their states to provide cached supervision. A student initialized from θ0\theta_0 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 W\mathcal{W} 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 WW, we divide every output row into groups GG of 128 input columns and write MG=max⁡j∈G∣Wij∣M_G = \max_{j \in G} \lvert W_{ij}\rvert.

Low-bit quantization. For an integer bit width b≥2b \ge2, let qb=2b−1−1q_b = 2^{b-1} - 1. Symmetric round-to-nearest quantization gives

W^ij=ΔGclip⁡(round⁡(WijΔG),−qb,qb),(6)\widehat{W}_{ij} = \Delta_G \operatorname{clip}\left(\operatorname{round}\left(\frac{W_{ij}}{\Delta_G}\right),-q_b,q_b\right), \tag*{(6)}

where ΔG=MG/qb\Delta_G = M_G/q_b. The group maximum adapts the step size to the local weight scale. The quantization grid contains 2b−12^b - 1 levels, including zero. We dequantize the resulting weights for scoring with the original model architecture. Our default uses b=3b = 3.

Magnitude pruning. For a group-relative threshold τ∈(0,1)\tau\in(0,1), we remove weights at or below τMG\tau M_G within each group, then restore the original ℓ2\ell_2 norm of each complete output row:

W~ij=Wij 1[∣Wij∣>τMG],\widetilde{W}_{ij} = W_{ij}\,1[|W_{ij}| > \tau M_G],
W^i,:=W~i,:∥Wi,:∥2∥W~i,:∥2.(7)\widehat{W}_{i,:} = \widetilde{W}_{i,:}\frac{\|W_{i,:}\|_2}{\|\widetilde{W}_{i,:}\|_2}. \tag*{(7)}

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 τ=1/6\tau= 1/6. 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 b=3b = 3 for quantization and τ=1/6\tau= 1/6 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 10−610^{-6}, global batch size 64, and distillation coefficient α=2\alpha= 2. 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.

MethodMath ReasoningCode GenerationAvg.
AIME24AIME25HMMT25Avg.LCB v5LCB v6Avg.
Qwen3-4B
Original73.465.641.160.0753.046.849.8655.98
OPSD ([74])75.266.743.961.9242.735.138.8852.70
SDPO ([20])70.662.840.858.0640.934.437.6149.88
PW-OPSD ([33])76.267.843.362.44————
LOPD ([70])————50.545.047.79—
WISD (Quantization)75.465.842.861.3556.449.252.8057.93
WISD (Pruning)75.866.045.262.3655.750.252.9658.60
Qwen3.5-4B
Original74.367.057.766.3241.739.140.3955.95
WISD (Quantization)80.272.168.173.4760.855.057.8667.23
WISD (Pruning)78.876.870.575.3564.056.760.3369.34
OLMo-3-7B-Think
Original74.065.345.261.4952.147.349.7156.78
OPSD ([74])72.867.443.961.3644.145.044.5754.64
SDPO ([20])————49.843.546.67—
PW-OPSD ([33])72.669.643.862.01————
LOPD ([70])————53.445.849.61—
WISD (Quantization)74.667.444.562.1552.949.451.1557.75
WISD (Pruning)72.769.147.262.9952.149.250.6558.05
Qwen3.6-27B
Original86.878.875.180.2173.269.171.1576.58
WISD (Quantization)85.178.973.279.0676.567.772.1476.29
WISD (Pruning)88.884.482.585.2180.173.176.6081.76
Qwen3.6-35B-A3B
Original83.374.368.575.3871.161.866.4971.82
WISD (Quantization)85.981.974.680.8076.669.573.0477.69
WISD (Pruning)86.380.871.779.5876.369.372.7676.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 bb and τ\tau to control the strength of quantization and pruning respectively while keeping all other settings the same as 4.1. The sweeps cover b∈{8,6,4,3,2}b \in\{8, 6, 4, 3, 2\} and τ∈{1/16,1/8,1/6,1/4,1/2}\tau\in\{1/16, 1/8, 1/6, 1/4, 1/2\}. 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 b=3b = 3 giving the best result in this sweep and serving as our default.

Ablations of weak-model construction showing accuracy and generated length for weight quantization and magnitude pruning

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 b=3b = 3 and τ=1/6\tau= 1/6. 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 τ=1/16\tau= 1/16 to 69.38% at τ=1/8\tau= 1/8 and 70.52% at the default τ=1/6\tau= 1/6, then falls to 54.79% and 49.58% at τ=1/4\tau= 1/4 and 1/21/2. 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 τ=1/6\tau= 1/6 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.

MethodAIME24LCB v5
Qwen3-4B73.453.0
Quantization
GPTQ (3-bit) (Frantar et al., [9])72.053.4
W4A470.053.0
Smooth W4A4 (Xiao et al., [60])75.355.2
RTN (3-bit)75.456.4
Pruning
Wanda (Sun et al., [50])74.455.6
SparseGPT (Frantar & Alistarh, [8])73.555.7
Magnitude pruning75.855.7
Simple baselines
Self-enhancing72.853.6
Temperature weak (T=2T = 2)73.153.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 T=2T = 2, 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 parameterValueTraining parameterValue
Prompts per domain3,200Distillation coefficient α\alpha2
Responses per prompt4Learning rate10−610^{-6}, constant
Trajectories per domain12,800Global batch size64
Temperature / top-pp1.0 / 1.0Optimizer updates200
Default response limit2,048 tokensStudent precisionBF16
Rollout seed42Training seed1234

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@nn is the fraction of correct responses across all problems and their nn 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-pp = 0.95, and top-kk 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-pp = 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-pp = 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-pp = 0.95, top-kk = 20, and a 16,384-token output limit.

MethodReadAnalyzePlanImplementExploreVerifyMonitorAnswerFormatting
All tokens9.124.36.628.214.88.11.41.85.6
Quantization7.627.18.416.022.311.22.42.03.0
Pruning7.826.78.315.922.111.42.52.13.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-pp = 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 parameterValueTraining parameterValue
Prompts per domain3,200Distillation coefficient α\alpha2
Responses per prompt4Learning rate10−610^{-6}, constant
Trajectories per domain12,800Global batch size64
Temperature / top-pp1.0 / 1.0Optimizer updates200
Default response limit2,048 tokensStudent precisionBF16
Rollout seed42Training seed1234

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@nn is the fraction of correct responses across all problems and their nn 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-pp = 0.95, and top-kk 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-pp = 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-pp = 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-pp = 0.95, top-kk = 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-pp = 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-p=0.95p = 0.95, 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 2b−12^b - 1 levels, so 2-bit RTN uses {−1,0,1}\{-1, 0, 1\}. 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 τ=1/6\tau= 1/6 and restores each complete output row’s ℓ2\ell_2 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:

rself(a∣s)=log⁡π0(a∣s).(8)r_{\mathrm{self}}(a \mid s) = \log\pi_0(a \mid s). \tag*{(8)}

Temperature weak uses the contrast with a softened output distribution:

rT(a∣s)=log⁡π0(a∣s)−log⁡π0,T(a∣s),π0,T(⋅∣s)=softmax⁡(z0(s)/T),T=2.(9)r_T(a \mid s) = \log\pi_0(a \mid s) - \log\pi_{0,T}(a \mid s), \qquad\pi_{0,T}(\cdot\mid s) = \operatorname{softmax}(z_0(s)/T), \qquad T = 2. \tag*{(9)}

Here z0z_0 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.

QuantizationPruning
ConstructionSettingAcc. (%)ConstructionSettingAcc. (%)
Qwen3-4B—73.4Qwen3-4B—73.4
RTN6-bit, g=128g = 12873.0Magnitude pruning20% per row74.3
RTN4-bit, g=128g = 12872.0Magnitude pruning40% per row74.4
RTN4-bit, g=32g = 3271.0Wanda20% per row72.3
GPTQ3-bit, g=128g = 12872.0Wanda40% per row74.4
GPTQ2-bit, g=128g = 12870.9Wanda2:474.4
W4A8g=128g = 12872.4SparseGPT50%73.3
W4A4g=128g = 12870.0SparseGPT2:473.5
Smooth W4A4g=128g = 12875.3MLP channel pruning25%73.5
RTN3-bit, g=128g = 12875.4Magnitude pruningτ=1/6,g=128\tau= 1/6, g = 12875.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. gg 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 τ=1/6\tau= 1/6, 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.

ConstructionQwen3-4B AIME25Qwen3.5-4B HMMT25
Pruning w/o row-norm restoration65.470.0
Pruning w/ row-norm restoration66.070.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 ℓ2\ell_2 norm preserves its weight scale while retaining the directional change introduced by pruning.

Training-Signal Analysis

Token-Level Training Signal

At each state ss, the cache retains 16 original-model token candidates SS and aggregates the remaining vocabulary into an OTHER bucket. Let bb be the cached behavior distribution over these 17 buckets and m=∑j∈Sbjm = \sum_{j \in S} b_j. Scorer probabilities are normalized over the full vocabulary before gathering the candidates. We set rj=rw(aj∣s)r_j = r_w(a_j \mid s) for retained candidates and rOTHER=0r_{\mathrm{OTHER}} = 0.

The offline implementation uses the tilted target with behavior-weighted log-probability regression:

qj=bjexp⁡(rj/α)∑kbkexp⁡(rk/α),ℓ(p)=α2m∑jbj(log⁡pj−log⁡qj)2,(10)q_j = \frac{b_j \exp(r_j/\alpha)}{\sum_k b_k \exp(r_k/\alpha)}, \qquad\ell(p) = \frac{\alpha}{2m} \sum_j b_j \left(\log p_j - \log q_j\right)^2, \tag*{(10)}

where p=softmax⁡(z)p = \operatorname{softmax}(z) is the student’s bucket distribution. At p=bp = b, the initial gradient with respect to the bucket logits is

gj=∂ℓ∂zj∣p=b=−bjm(rj−∑kbkrk).(11)g_j = \left.\frac{\partial\ell}{\partial z_j}\right|_{p=b} = -\frac{b_j}{m}\left(r_j - \sum_k b_k r_k\right). \tag*{(11)}

This expression centers each candidate’s contrast against the behavior-weighted mean. For each position tt, we measure the signal magnitude by st=∥gt∥1s_t = \lVert g_t\rVert_1. The share assigned to a reasoning role CC is

SignalShare⁡(C)=100∑t∈Cst∑tst.(12)\operatorname{SignalShare}(C) = 100 \frac{\sum_{t \in C} s_t}{\sum_t s_t}. \tag*{(12)}

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.

RoleFunction
ReadRestates the given facts, conditions, or requested result.
AnalyzeExplains a concept, builds a representation, or makes a logical deduction.
PlanCommits to an action before carrying it out.
ImplementExecutes calculations, substitutions, or other concrete operations.
ExploreProposes a tentative approach or uncertain possibility.
VerifyChecks an existing result or approach against the problem’s conditions.
MonitorComments briefly on the reasoning process.
AnswerStates a proposed or final answer to the original question.
FormattingMarks 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.

Reasoning improvements after self-distillation

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 [. . .].

Code excerpts before and after self-distillation on LiveCodeBench v6

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

∑j=−10001000⌊2025j+0.5⌋\sum_{j=-1000}^{1000}\left\lfloor\frac{2025}{j+0.5}\right\rfloor

Original (incorrect)

Thus, there are 15−1=1415-1=14 positive divisors in the range. Similarly, there are 14 negative divisors in the range (since −2025<−1999-2025<-1999). Total number of valid mm values is 14+14=2814+14=28. These correspond to 28 pairs where the sum is 0. The remaining number of pairs is 1000−28=9721000-28=972. These pairs sum to −1-1. So the sum over pairs is 28×0+972×(−1)=−97228\times0+972\times(-1)=-972.

[. . .]

The total sum is:

S=−972+2=−970S=-972+2=-970

Answer: −970\boxed{-970}

WISD (Quantization, correct)

We restrict our attention to k∈P′={1,3,…,1999}k\in P'=\{1,3,\ldots,1999\}. The only divisor not in this set is 2025 itself (since 2025>19992025>1999). All other 14 divisors are ≤675<1999\le675<1999 and thus included. So, there are 14 values of kk for which 4050k\frac{4050}{k} is an integer. For these 14 pairs, the contribution is 0. The total number of pairs formed this way corresponds to the size of P′P', which is 1999−12+1=1000\frac{1999-1}{2}+1=1000. The number of pairs where the contribution is −1-1 is 1000−14=9861000-14=986.

[. . .]

S=−986+2=−984.S=-986+2=-984.

Answer: −984\boxed{-984}

(b) Preserving the edge constraint

Question. In an 11×1111\times11 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 11×1111\times11 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 G11,11G_{11,11}.

[. . .]

The graph is bipartite, which implies that any cycle must have an even length. Furthermore, a cycle of length LL must visit L/2L/2 vertices from set AA and L/2L/2 vertices from set BB. Therefore, the length of any cycle LL satisfies L/2≤∣B∣=60L/2\le|B|=60, which implies L≤120L\le120.

[. . .]

Answer: 120\boxed{120}

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 11×1111\times11 grid graph. This is equivalent to finding a subgraph HH of the grid graph GG that is connected and has all vertices of even degree, maximizing the number of edges ∣E(H)∣|E(H)|.

[. . .]

Total number of removed edges ∣F∣=16(internal)+4(cross)=20|F|=16(\text{internal})+4(\text{cross})=20.

[. . .]

Total number of doors (edges) in an 11×1111\times11 grid is 2×11×(11−1)=2202\times11\times(11-1)=220. Maximum doors Karthik can walk = Total edges - Minimum removed edges

220−20=200.220-20=200.

[. . .]

Answer: 200\boxed{200}

(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 p=−5p=-5 and the rejection of the resulting nonprime candidates (a). Pruning reinforces the zero used when substituting x2=x3=1/2x_2=x_3=1/2 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. [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. [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. [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. [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. [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. [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. [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. [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. [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
  10. [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
  11. [14]Harvard–MIT Mathematics Tournament. Archive of February 2025, 2025. URL https://www.hmmt.org/www/archive/282.
  12. [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
  13. [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
  14. [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.
  15. [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
  16. [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/.
  17. [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
  18. [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
  19. [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.
  20. [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.
  21. [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.
  22. [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.
  23. [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.
  24. [35]Mathematical Association of America. MAA Invitational Competitions, 2026. URL https://maa.org/maa-invitational-competitions/.
  25. [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.
  26. [37]O’Brien, S. and Lewis, M. Contrastive decoding improves reasoning in large language models, 2023. URL https://arxiv.org/abs/2309.09117.
  27. [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.
  28. [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
  29. [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.
  30. [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.
  31. [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.
  32. [43]Qwen Team. Qwen3.5: Towards native multimodal agents, February 2026. URL https://qwen.ai/blog?id=qwen3.5.
  33. [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.
  34. [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.
  35. [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.
  36. [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
  37. [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
  38. [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
  39. [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.
  40. [52]Tan, Z. and Hong, Y. Self-supervised on-policy distillation for reasoning language models, 2026. URL https://arxiv.org/abs/2605.17497.
  41. [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.
  42. [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.
  43. [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.
  44. [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.
  45. [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.
  46. [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.
  47. [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.
  48. [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.
  49. [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.
  50. [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
  51. [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.
  52. [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
  53. [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

Paper details

vlnc:W_g85rufqh
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 14

downloads · 0

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