Evaluating Parameter Efficient Methods for RLVR

🎯 Pitch

Standard LoRA is not optimal for RLVR—structural variants like DoRA consistently beat it and even surpass full fine-tuning, while SVD initialization strategies like PiSSA suffer catastrophic spectral collapse. This is the first large-scale study to map the true performance frontier of PEFT methods under verifiable reward optimization.

1. Executive Summary

This paper systematically evaluates over 12 Parameter-Efficient Fine-Tuning (PEFT) methods under the paradigm of Reinforcement Learning with Verifiable Rewards (RLVR) on mathematical reasoning benchmarks using the DeepSeek-R1-Distill model families. The work challenges the default adoption of standard LoRA by demonstrating that structural variants—methods that alter the architectural formulation beyond the standard low-rank product (e.g., DoRA, which decouples magnitude and direction, and AdaLoRA, which employs SVD-like adaptive rank allocation)—consistently outperform standard LoRA, with DoRA surpassing even full-parameter fine-tuning (46.6% vs. 44.9% average accuracy). The paper additionally uncovers a spectral collapse phenomenon in SVD-informed initialization strategies (PiSSA, MiLoRA), attributing their catastrophic failure (PiSSA collapses to 0.2% accuracy) to a fundamental misalignment between principal-component updates and RLVR's intrinsic off-principal optimization dynamics, while establishing that extreme parameter reduction methods (VeRA at 0.003% trainable parameters, Rank-1 adapters) create an expressivity floor below which reasoning capacity collapses—revealing that RLVR tolerates moderate compression but demands a minimum threshold of trainable adapter capacity to sustain complex reasoning behaviors.

2. Context and Motivation

The Core Problem: We Don't Know Which PEFT Method Works Best for RLVR

The fundamental question this paper tackles is straightforward: if we're going to use parameter-efficient fine-tuning for reinforcement learning with verifiable rewards, which specific adapter architecture should we use? The field has converged on standard LoRA as the default choice, but this paper argues—and empirically demonstrates—that this convergence happened without systematic evidence.

This gap exists because of a historical accident in how research progressed. LoRA (Hu et al.) was developed and validated primarily in the context of supervised fine-tuning (SFT)—dense, token-level supervision via teacher-forcing—and its variants (DoRA, AdaLoRA, PiSSA, etc.) were similarly evaluated almost exclusively under SFT conditions. When the community shifted toward RLVR as the dominant post-training paradigm (following DeepSeek-R1, Guo et al., 2025), practitioners naturally carried LoRA forward as the parameter-efficient option. The paper explicitly flags this as an unexamined assumption:

"While a proliferation of LoRA variants and PEFT methods has emerged, the application of these techniques in reinforcement learning remains predominantly confined to standard LoRA. This predominance raises a critical uncertainty regarding whether the standard LoRA architecture truly represents the optimal strategy for the distinct optimization dynamics of RL."

The phrase "distinct optimization dynamics" is the key. RLVR and SFT differ fundamentally in how they update model weights, and a method optimized for one may not transfer to the other. This paper's central bet is that the transfer is not only imperfect—it's actively misleading, with methods that excel under SFT (PiSSA) catastrophically failing under RLVR, and methods that show modest gains under SFT (DoRA) dramatically surpassing full-parameter fine-tuning under RLVR.

Why This Problem Matters: The Resource Bottleneck in RL Training

The practical stakes are high. The paper identifies RL training as "notoriously complex and resource-intensive" (Section 1), and this isn't hyperbole. Full-parameter RLVR on a 7B model requires maintaining optimizer states (momentum, variance) for every parameter—roughly 3–4× the model's weight memory in Adam—plus storing the base model, the reference policy model, and multiple rollout generations simultaneously. For a 7B parameter model, this pushes memory requirements well beyond what a single GPU can handle, necessitating distributed training infrastructure.

PEFT methods promise to collapse this resource requirement. Standard LoRA with rank 32 targeting all linear modules (as used in this paper) trains approximately 1.55% of the total parameters. This reduces not only GPU memory but also communication overhead in distributed settings (fewer gradients to synchronize) and checkpoint storage costs. For research labs and companies without access to large-scale clusters, the difference between full-parameter RLVR and PEFT-RLVR determines whether RL post-training is feasible at all.

However, the paper identifies a subtlety that prior work missed: RLVR's supervision signal is fundamentally sparser than SFT's. In SFT, every token receives a supervision signal—the model learns to predict the next token from the reference sequence. In RLVR, the model generates potentially thousands of reasoning tokens (up to 16,384 in this paper's setup) but receives only a single binary reward at the end: 1 if the final answer matches the ground truth, 0 otherwise. The paper explicitly connects this to the lottery ticket hypothesis:

"Mechanistically, this sparsity leads to updates being confined to small subnets or sparse parameters, implying significant parameter redundancy during full-parameter RL training."

This insight—that RLVR's sparsity creates parameter redundancy even in full-parameter training—is the theoretical justification for why PEFT should work in principle. If the effective update is already sparse, a well-designed low-rank adapter should capture nearly all of it. But the converse insight is equally important: the pattern of which parameters need updating under RLVR may be entirely different from the pattern under SFT, meaning that an adapter architecture optimized for SFT's dense updates may be a poor fit for RLVR's sparse, end-of-sequence reward signal.

The paper also points to a recent empirical finding from Schulman & Lab (2025), which demonstrated that LoRA can yield competitive performance compared to full-parameter RLVR training. This serves as an existence proof—PEFT can work for RLVR—but it doesn't address which PEFT method works best. That's precisely the gap this paper fills.

Conflicting Prior Evidence and Where Approaches Fall Short

The paper identifies several strands of prior work that, taken together, create a confusing and incomplete picture:

1. The SFT-centric evaluation of PEFT methods. The overwhelming majority of PEFT evaluations—including the original papers for DoRA (Liu et al., 2024), AdaLoRA (Zhang et al., 2023b), PiSSA (Meng et al., 2024), MiLoRA (Wang et al., 2025a), LoRA+ (Hayou et al., 2024), VeRA (Kopiczko et al., 2023), LoRA-FA (Zhang et al., 2023a), and IA3 (Liu et al., 2022b)—were conducted under SFT or few-shot prompting paradigms. These settings provide dense, token-level supervision that produces gradient signals distributed broadly across the weight matrix. Under such conditions, PiSSA's strategy of initializing adapters along principal singular components makes engineering sense: SFT tends to make large-magnitude updates to already-large singular values, so starting there accelerates convergence.

But RLVR doesn't work this way. The paper cites Zhu et al. (2025), which proved that "RLVR provably learns off the principals"—that is, RLVR updates predominantly target low-curvature, non-principal subspaces to preserve the pre-trained spectral geometry. This is a qualitative difference in update dynamics, not just a quantitative one. A method like PiSSA that explicitly constrains updates to the principal subspace is therefore not just suboptimal for RLVR—it's structurally incompatible. The paper's results bear this out dramatically: PiSSA collapses to 0.2% accuracy, essentially random performance, despite being a strong method under SFT.

2. The absence of RLVR-specific PEFT evaluations. Prior to this work, the only systematic study of PEFT under RLVR was the demonstration by Wang et al. (2025b) and Schulman & Lab (2025) that standard LoRA can match full-parameter training. These works established feasibility but didn't compare across PEFT methods. They answered "can PEFT work for RLVR?" but not "which PEFT method should we use for RLVR?" The paper positions itself as the logical next step: now that we know PEFT-RLVR is viable, we need to determine the optimal PEFT architecture for this specific optimization regime.

3. The overextrapolation from SFT heuristics. Several widely-held heuristics in the PEFT community derive from SFT experience: that small batch sizes are critical for LoRA (because the dense SFT signal can saturate low-rank capacity), that minimal ranks suffice (because SFT knowledge transfer is relatively shallow), and that SVD-based initialization universally accelerates convergence. The paper challenges each of these for the RLVR setting:

Batch size: The paper finds that the small-batch advantage observed in SFT "does transfer to RLVR but performs less well" (Section 3.2)—the inverse correlation between batch size and LoRA performance weakens, because RLVR's sparse scalar rewards don't saturate adapter capacity the way dense token-level targets do.
Rank sufficiency: Contrary to suggestions that even Rank-1 adapters can complete RLVR tasks (Mukherjee et al., 2025), the paper's rank ablation shows Rank-1 consistently underperforms higher ranks (32 > 16 > 8 > 1), with a clear performance gradient.
SVD initialization: As discussed above, the transfer is not just imperfect but catastrophically negative.

4. The theoretical tension around parameter efficiency in RL. The paper identifies an unresolved tension: on one hand, RLVR's sparse reward signal suggests that effective updates are confined to small subnets, implying parameter efficiency is naturally well-suited. On the other hand, the content of those updates—the restructuring of reasoning circuits to produce coherent chain-of-thought, self-verification, and error correction—might require more expressive capacity than a simple low-rank decomposition can provide. The paper's results on the "expressivity floor" (Finding 2) directly address this tension: moderate parameter reduction (LoRA-FA at ~0.8% trainable parameters) works fine, but extreme reduction (VeRA at 0.003%, IA3, LN-tuning) fails to support reasoning acquisition. There's a threshold below which the adapter simply lacks the degrees of freedom to rewire reasoning behaviors.

How This Paper Positions Itself

The paper frames itself as conducting the first systematic evaluation of PEFT methods specifically under RLVR, bridging a gap between two previously disconnected research threads: the PEFT literature (focused on SFT) and the RLVR literature (focused on full-parameter training or LoRA-only). This positioning is captured explicitly in the contributions:

"To the best of our knowledge, this work represents the first systematic study bridging the gap between diverse PEFT methodologies and the specific optimization dynamics of Reinforcement Learning with Verifiable Rewards."

What distinguishes this from a simple benchmark paper is its mechanistic analysis. The paper doesn't just report which methods win or lose—it explains why certain methods fail under RLVR, grounding the explanation in spectral analysis of weight updates. For SVD-based initializations (PiSSA, MiLoRA), the paper traces the failure mechanism through three levels:

Empirical: PiSSA and MiLoRA perform catastrophically worse than standard LoRA (0.2% and 18.0% vs. 42.5%).
Spectral: Analysis of weight update distributions reveals that RLVR updates are concentrated off the principal components, which PiSSA and (ultimately) MiLoRA fail to accommodate.
Dynamical: For MiLoRA specifically, the paper explains why a theoretically well-motivated initialization (using minor singular components) fails: the negligible initialization magnitude ( $\|\Delta W^0\|_F \approx 0$ ) means the intended structural constraint is numerically non-existent, and the gradient flow immediately reorients updates toward principal components where the gradient magnitude is largest.

This mechanistic depth elevates the paper beyond a leaderboard comparison. It provides actionable guidance: don't just avoid PiSSA—understand that any method forcing principal-component updates will conflict with RLVR dynamics. Don't just use DoRA—understand that decoupling magnitude and direction updates provides the flexibility RLVR's off-principal optimization requires.

The paper also positions itself as a practitioner's guide, explicitly advocating for community adoption:

"We advocate for the community to move beyond the default adoption of standard LoRA in favor of geometry-aware adapters like DoRA, which offer a superior balance of efficiency and reasoning capability."

This is a prescriptive conclusion backed by the scale and rigor of the evaluation: over 12 methods, two model scales (1.5B and 7B), six mathematical reasoning benchmarks, and extensive ablation studies across batch sizes, learning rates, ranks, and RLVR algorithm variants (GRPO, DAPO, Dr. GRPO). The message is clear: the default choice matters, and the current default is wrong.

3. Technical Approach

3.1 Reader Orientation

This paper constructs a large-scale empirical comparison framework — not a new training algorithm, but a systematic evaluation protocol — that measures how well different parameter-efficient adapter architectures perform when used inside reinforcement learning for mathematical reasoning. The problem it solves is selection under uncertainty: given that no one has systematically tested which of the dozen-plus existing PEFT methods actually works best under RLVR's unusual optimization dynamics, the paper provides a controlled head-to-head benchmark across models, scales, and hyperparameters to identify which adapter designs are robust (structural variants like DoRA), which fail catastrophically (SVD-based initializations like PiSSA), and why.

3.2 Big-Picture Architecture (Diagram in Words)

The evaluation framework has five major components arranged in a pipeline:

Base Reasoning Models — pre-trained and SFT-fine-tuned LLMs (DeepSeek-R1-Distill-Qwen at 1.5B and 7B) that serve as the policy network whose weights will be adapted. They already possess chain-of-thought reasoning capability and a specific output format (` thinking...` tags, \boxed{} for final answers).
PEFT Adapter Wrappers — one of over 12 adapter architectures (LoRA, DoRA, AdaLoRA, MiSS, PiSSA, MiLoRA, LoRA+, rsLoRA, LoRA-FA, VeRA, IA3, LayerNorm Tuning) inserted into all linear modules of the base model. Each adapter defines how the model's forward pass is modified and which parameters are trainable.
RLVR Training Loop — a GRPO-family algorithm (primarily DAPO) that samples groups of 8 responses per prompt, scores each with a binary reward based on mathematical correctness of the final answer, estimates advantages from group statistics, and updates only the adapter parameters via policy gradient.
Mathematical Reasoning Dataset — 17.4k math problems (DAPO-Math-17k-Processed) used for training, with structured reasoning format enforced.
Evaluation Suite — six mathematical benchmarks (MATH500, AIME24/25, AMC, Minerva, HMMT) evaluated with Avg@k and Pass@1 metrics at controlled temperature (0.6) and top-p (0.95).

Information flows as follows: a math prompt enters the system → the base model with adapter generates 8 candidate solutions via vLLM → each solution's final answer is extracted and verified against ground truth using latex2sympy and math_verify → a binary reward (0 or 1) is assigned → DAPO computes standardized advantages within the group → the policy gradient updates only the adapter parameters → the cycle repeats for 1,024 steps (1.5B) or 8,192 steps (7B). The adapter architecture itself never changes during training — the comparison is between different adapter choices made before training begins.

3.3 Roadmap for the Deep Dive

First, the RLVR training algorithm (DAPO) and its objective function — since every PEFT method is evaluated under identical RL dynamics, we must understand what those dynamics are and how they differ from SFT.
Second, the reward mechanism — because the binary, sparse reward signal is what distinguishes RLVR from dense SFT supervision and what creates the optimization conditions that favor certain adapter designs over others.
Third, the PEFT methods themselves, organized by category, with their forward-pass equations and initialization strategies — since these are the independent variables being compared, we need precise definitions of what each method computes and trains.
Fourth, the training infrastructure and hyperparameter configuration — numerical details (batch sizes, learning rates, ranks, generation parameters) that ensure reproducibility and explain how methods were controlled for fair comparison.
Fifth, the evaluation protocol — how reasoning accuracy is measured, why Avg@k and Pass@1 are both reported, and how the benchmark suite is constructed to test generalization.
Sixth, the spectral analysis methodology used to diagnose why SVD-based initializations fail — since this mechanistic explanation is the paper's deepest contribution beyond the leaderboard results.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an empirical benchmarking paper whose core idea is that the choice of PEFT architecture matters enormously for RLVR, and that the optimal choice under RLVR is different from the optimal choice under SFT. The paper does not propose new methods; it systematically evaluates existing ones under a new optimization regime and explains the results through spectral analysis.

The RLVR Training Algorithm: DAPO

The paper selects Decoupled Clip and Dynamic sampling Policy Optimization (DAPO) as its primary RL algorithm (Section 2.1). DAPO is a variant of Group Relative Policy Optimization (GRPO) that addresses two specific failure modes: entropy collapse (the policy becoming deterministic too quickly) and wasted computation on prompts where all sampled responses receive identical rewards.

GRPO itself is the foundational framework. Unlike Proximal Policy Optimization (PPO), which requires a separate critic model to estimate state values, GRPO eliminates the critic entirely. For each prompt $q$ , it samples a group of $G$ responses $\{o_1, \ldots, o_G\}$ from the current policy $\pi_{\theta_{\text{old}}}$ , computes a scalar reward $R_i$ for each response, and estimates the advantage $\hat{A}_i$ purely from within-group statistics — specifically, by standardizing the rewards:

$\hat{A}_i = \frac{R_i - \text{mean}(\{R_j\})}{\text{std}(\{R_j\})}$

where $\text{mean}(\{R_j\})$ is the sample mean of rewards across the $G$ responses for this prompt, and $\text{std}(\{R_j\})$ is their sample standard deviation.

What it computes: an advantage score for each response measuring how much better (or worse) it is than the average response to the same prompt. A response with reward above the group mean receives a positive advantage; one below the mean receives a negative advantage. The standardization ensures advantages are on a consistent scale regardless of the raw reward magnitudes.

Why this form: the critic-free design is motivated by the nature of the reward signal in RLVR. Since rewards are deterministic and binary (correct answer = 1, incorrect = 0), there is no stochastic environment to model — the randomness comes entirely from the policy's sampling. The group mean serves as a baseline that reduces variance in the policy gradient estimate without requiring a learned value function. The standardization by standard deviation prevents prompts with naturally high reward variance from dominating the update. However, Dr. GRPO (Liu et al., 2025) later identified a problem with this exact formulation: dividing by standard deviation introduces a difficulty bias, where prompts with low reward variance (either very easy, where all responses are correct, or very hard, where all are incorrect) receive disproportionately large advantage magnitudes despite providing little useful learning signal. The paper tests Dr. GRPO as an ablation (Section 3.2) but uses DAPO as the primary algorithm.

The GRPO surrogate objective that the policy is trained to maximize is:

$J_{\text{GRPO}}(\theta) = \mathbb{E}_{q \sim \mathcal{D}, \{o_i\} \sim \pi_{\theta_{\text{old}}}} \left[ \frac{1}{G} \sum_{i=1}^{G} \frac{1}{|o_i|} \sum_{t=1}^{|o_i|} \min\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})} \hat{A}_i, \ \text{clip}\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})}, 1 \pm \epsilon \right) \hat{A}_i \right) \right]$

where $\pi_\theta$ is the current policy (being optimized), $\pi_{\theta_{\text{old}}}$ is the frozen policy from before the update (used for importance sampling), $o_{i,t}$ is the $t$ -th token of the $i$ -th response, $|o_i|$ is the total number of tokens in response $i$ , $\hat{A}_i$ is the standardized advantage for response $i$ , and $\epsilon$ is the clipping parameter.

What it computes: for each token in each generated response, the objective measures how much more (or less) likely the current policy makes that token compared to the old policy, multiplies by the response-level advantage, and clips the ratio to prevent destructive updates. The min operation chooses the more conservative of the unclipped or clipped objective — this is the standard PPO clip that prevents the policy from changing too much in a single update. The outer expectation averages over prompts and sampled response groups.

Why this form: the token-level ratio $\frac{\pi_\theta}{\pi_{\theta_{\text{old}}}}$ is an importance sampling correction — since responses were generated under $\pi_{\theta_{\text{old}}}$ but we want to optimize $\pi_\theta$ , we reweight each token's contribution by how much the current policy's probability differs from the old policy's. The $\frac{1}{|o_i|}$ normalization ensures responses of different lengths contribute equally to the total objective (but see below — DAPO and Dr. GRPO modify this). The clipping prevents the well-known failure mode where a single high-advantage response causes the policy to collapse to a deterministic mode.

DAPO's specific modifications: DAPO makes two key changes to the GRPO objective. First, it decouples the clipping range into separate lower and upper bounds, $\epsilon_{\text{low}}$ and $\epsilon_{\text{high}}$ , with $\epsilon_{\text{high}}$ set substantially larger (0.28 in this paper). The standard GRPO uses symmetric clipping $1 \pm \epsilon$ ; DAPO's asymmetric clipping allows more room for the policy to increase the probability of low-probability tokens that received positive advantage (the "clip-higher" strategy). This is motivated by the observation that in long chain-of-thought reasoning, exploration tokens — unusual reasoning steps that might lead to correct answers — often have low probability under the initial policy. Symmetric clipping would prevent the policy from substantially increasing their probability, leading to entropy collapse. The asymmetric upper clip ( $\epsilon_{\text{high}} = 0.28$ ) gives these tokens more room to be uplifted.

Second, DAPO employs Dynamic Sampling: if all $G$ responses to a prompt receive identical rewards (all 0 or all 1), the prompt is filtered out and contributes zero gradient for that training step. This addresses a sample efficiency problem: when all responses are correct, there's no signal about which reasoning path is better; when all are incorrect, there's no positive example to learn from. In both cases, the advantage estimates are zero (all rewards equal the mean), so the gradient contribution is zero anyway, but DAPO explicitly drops these prompts to avoid wasting forward passes on uninformative batches.

The paper sets $G = 8$ (8 rollouts per prompt), $\epsilon_{\text{high}} = 0.28$ (the DAPO clip-higher parameter), and does not use a KL divergence penalty ( $\beta = 0$ ). The lack of KL penalty is notable — standard RLHF typically includes a KL term to prevent the policy from drifting too far from a reference model (usually the SFT checkpoint), but recent work in RLVR has found that the clipping alone provides sufficient regularization, and the KL penalty can slow down reasoning acquisition.

The Reward Mechanism: Binary Outcome Verification

RLVR's defining characteristic is that rewards come from a deterministic verifier rather than a learned reward model. The paper's reward function is:

$R = \mathbb{1}[\text{extracted\_answer} \equiv \text{ground\_truth}]$

where $\mathbb{1}[\cdot]$ is the indicator function (1 if the condition holds, 0 otherwise), and $\equiv$ denotes mathematical equivalence as determined by symbolic verification.

What it computes: a single binary scalar for each generated response. The verification process has two stages: (1) answer extraction — parse the model's output to find content within \boxed{} tags, and (2) symbolic comparison — use latex2sympy (which converts LaTeX math expressions to SymPy symbolic objects) and math_verify (which checks equivalence under algebraic manipulation) to determine whether the extracted answer represents the same mathematical object as the ground truth.

Why this form: the binary nature of the reward is both a strength and a challenge. It is a strength because it eliminates reward hacking — there is no learned reward model to exploit, no ambiguity about what constitutes success, and no need for human annotation beyond ground-truth answers. It is a challenge because it provides zero signal about intermediate reasoning steps. A response that reasons incorrectly for 1,000 tokens but accidentally writes the correct final answer receives reward 1; a response that reasons flawlessly but makes an arithmetic error in the final line receives reward 0. This sparsity — one scalar of information per potentially thousands of output tokens — creates a fundamentally different optimization landscape from SFT, where every token receives a cross-entropy loss signal.

The paper explicitly connects this sparsity to its findings about PEFT methods: "the supervision signal consists only of sparse, scalar rewards rather than dense token-level targets" (Section 3.2). This sparsity is why RLVR updates are concentrated in specific subspaces (as found by Zhu et al., 2025) and why adapter architectures that work well under dense SFT supervision may fail under sparse RLVR supervision.

The "overall reward recipe follows the principles of JustRL" (He et al., 2025), which demonstrated that minimal reward engineering — binary format rewards, simple answer extraction, no process rewards, no partial credit — is sufficient for strong RLVR performance when combined with proper policy optimization. This keeps the training pipeline simple and reproducible.

PEFT Method Taxonomy and Definitions

The paper categorizes 12+ PEFT methods into five groups. Each group represents a different hypothesis about where to intervene in the model's computation to efficiently capture the weight updates needed for adaptation. Understanding what each method computes is essential because the paper's central claim is that these computational differences cause qualitatively different behavior under RLVR.

Baselines: Full-Parameter Fine-Tuning and Standard LoRA

Full-parameter fine-tuning trains every weight matrix in the model:

$y = W' x$

where $W' \in \mathbb{R}^{d_{\text{out}} \times d_{\text{in}}}$ is the fully trainable weight matrix, initialized from the pre-trained $W_0$ , and $x \in \mathbb{R}^{d_{\text{in}}}$ is the input activation. This represents the performance upper bound (unconstrained expressivity), at the cost of training $100\%$ of parameters.

Standard LoRA (Hu et al.) freezes the pre-trained weight $W_0$ and learns only a low-rank additive perturbation:

$y = W_0 x + \frac{\alpha}{r} B A x$

where $B \in \mathbb{R}^{d_{\text{out}} \times r}$ and $A \in \mathbb{R}^{r \times d_{\text{in}}}$ are the trainable low-rank matrices, $r \ll \min(d_{\text{in}}, d_{\text{out}})$ is the rank (set to 32 in the paper), and $\alpha$ is a scaling factor (set to 64). The initialization follows: $A \sim \mathcal{N}(0, \sigma^2)$ (random Gaussian), $B = 0$ (zero matrix), ensuring $\Delta W = B A = 0$ at the start of training.

What it computes: the forward pass is the base model's computation plus a learned correction in a low-dimensional subspace. The $B A$ product has rank at most $r$ , meaning the correction can only express weight updates that lie in a subspace spanned by the columns of $B$ . The $\frac{\alpha}{r}$ scaling ensures that the effective learning rate is controlled — when $r$ is larger, the scaling is smaller, preventing the total update magnitude from growing with rank.

Why this form: the zero initialization of $B$ is critical — it guarantees that at $t = 0$ , the model's outputs are identical to the pre-trained model's outputs, regardless of how $A$ is initialized. This is a "no-harm" guarantee: the adapter does not perturb the model's existing capabilities before any learning has occurred. The Gaussian initialization of $A$ provides a random basis for the low-rank subspace, and training discovers which directions in this subspace are useful for the task. The rank $r$ controls the adapter's expressivity — larger $r$ allows more complex adaptations but trains more parameters. The paper uses $r = 32$ targeting all linear modules ({q, k, v, o, gate, up, down}_proj), following the configuration validated by Wang et al. (2025b) and Schulman & Lab (2025).

Structural Variants: DoRA, AdaLoRA, and MiSS

These methods modify the form of the weight update beyond the simple $B A$ product. The paper's finding is that these structural modifications provide benefits under RLVR that are not observed (or are less pronounced) under SFT.

DoRA (Weight-Decomposed Low-Rank Adaptation) (Liu et al., 2024) decomposes each pre-trained weight matrix into its magnitude and direction components and learns them separately:

$y = m \frac{W_0 x + B A x}{\|W_0 + B A\|_c}$

where $m \in \mathbb{R}^{d_{\text{out}}}$ is a trainable magnitude vector (initialized to the pre-trained weight norms, $\|W_0\|_c$ ), and $\|\cdot\|_c$ denotes the column-wise vector norm of the weight matrix. The matrices $A$ and $B$ follow the same low-rank decomposition as standard LoRA, with $A$ initialized via Rectified Kaiming Uniform and $B$ initialized to zero.

What it computes: the combined weight $W_0 + B A$ is first normalized to unit column norm (removing magnitude information), then multiplied element-wise by the learned magnitude $m$ . The $B A$ term can change the direction of each weight column, while $m$ independently scales the magnitude. This decoupling means the model can, for example, strengthen an existing reasoning pattern (increase the magnitude of certain weight columns) without changing which tokens those columns attend to, or redirect attention (change direction) while keeping the importance of that feature constant.

Why this form: the motivation comes from the observation that full fine-tuning tends to make correlated but distinct changes to weight magnitude and direction, and forcing these changes to share a single low-rank parameterization (as in standard LoRA) may create a bottleneck. Under RLVR's sparse reward signal, the paper hypothesizes that the ability to independently adjust magnitude and direction is particularly important — the model might need to amplify specific reasoning circuits (magnitude changes) while simultaneously pruning unhelpful circuits (direction changes away from certain patterns), and these two types of changes may require different learning rates or update patterns. The empirical result — DoRA achieving 46.6% average accuracy, surpassing full-parameter fine-tuning's 44.9% — suggests this decoupling is indeed beneficial. The $A$ initialization uses Rectified Kaiming Uniform rather than standard Gaussian, which provides better gradient flow properties in deep networks.

AdaLoRA (Adaptive Budget Allocation) (Zhang et al., 2023b) replaces the fixed low-rank product $B A$ with an SVD-like decomposition that can adaptively allocate rank across weight matrices:

$y = W_0 x + P \Lambda Q x$

where $P \in \mathbb{R}^{d_{\text{out}} \times r}$ and $Q \in \mathbb{R}^{r \times d_{\text{in}}}$ are trainable (semi-)orthogonal matrices (initialized as random Gaussian, then made approximately orthogonal), and $\Lambda = \text{diag}(\sigma_1, \ldots, \sigma_r)$ is a diagonal matrix of trainable singular values, initialized to zero. During training, the singular values in $\Lambda$ are learned: important dimensions receive larger $\sigma_i$ , unimportant ones are driven toward zero and can be pruned, effectively reallocating the adapter's parameter budget to the weight matrices and directions that matter most.

What it computes: unlike standard LoRA, which has a fixed $r$ for every weight matrix, AdaLoRA learns which weight matrices need more expressivity and which directions within each matrix matter. The $P$ and $Q$ matrices are constrained to be approximately orthogonal (via an additional regularization term not shown in the forward pass), which makes the decomposition behave like a truncated SVD — $P$ contains the left singular vectors, $Q$ contains the right singular vectors, and $\Lambda$ contains the singular values. The total rank budget is distributed adaptively across layers.

Why this form: the rationale is that different layers in a transformer may require different amounts of adaptation for a given task. For RLVR specifically, the paper notes that RLVR updates are concentrated in "small subnets or sparse parameters" (Section 1), suggesting that some layers may need no adaptation at all while others need substantial reconfiguration. AdaLoRA's ability to automatically discover this allocation — putting more rank where the RL signal provides informative gradients and less where it doesn't — could be particularly well-suited. The paper's results show AdaLoRA achieving 44.2% average accuracy, outperforming standard LoRA (42.5%) but trailing DoRA (46.6%).

MiSS (Mixed Shard Sharing) (Kang & Yin, 2025) takes a different structural approach: instead of adding a low-rank correction, it replaces certain sub-matrices of the weight with trainable parameters:

$y = W_0 x + \text{expand}(D) x$

where $D \in \mathbb{R}^{d_{\text{out}} \times s}$ is a trainable matrix with small shard dimension $s \ll d_{\text{in}}$ , and $\text{expand}(\cdot)$ is an operation that replicates $D$ across the input dimension to match $W_0$ 's shape. $D$ is initialized to zero, so the adapter starts as identity.

What it computes: rather than learning a dense $d_{\text{out}} \times r$ times $r \times d_{\text{in}}$ product, MiSS learns a small set of parameters per output dimension and tiles them across inputs. This is structurally similar to sharing weights across input channels — each output dimension gets a short learnable vector that is replicated to cover all input dimensions. The rank of the update is determined by the shard size $s$ , but critically, the parameter count is $d_{\text{out}} \times s$ , not $r \times (d_{\text{in}} + d_{\text{out}})$ as in LoRA.

Why this form: MiSS is designed to be more parameter-efficient than LoRA while maintaining expressivity by exploiting the structured redundancy in linear layer updates. For RLVR, the paper observes that MiSS achieves 43.4% average accuracy while training only 0.99% of parameters (compared to LoRA's 1.55%), suggesting that the shard-sharing structure captures the essential subspace of RLVR updates with fewer parameters. This is consistent with the finding that RLVR updates are sparse and structured — if the effective update only depends on a few output-dimension-specific patterns replicated across inputs, MiSS's parameterization matches this structure.

Initialization Strategies: PiSSA, MiLoRA, LoRA+, and rsLoRA

These methods keep the standard LoRA forward pass ( $y = W_0 x + B A x$ ) but change how $A$ and $B$ are initialized, or adjust the optimization dynamics (learning rates) to improve convergence. The paper's critical finding is that two SVD-based initialization methods (PiSSA and MiLoRA) fail catastrophically under RLVR, while learning-rate-based methods (LoRA+) remain robust.

PiSSA (Principal Singular values and Singular vectors Adaptation) (Meng et al., 2024) initializes $A$ and $B$ using the principal (largest) singular components of the pre-trained weight matrix $W_0$ . The initialization is:

$W_0' = W_0 - B A, \quad A = U_{[:,:r]} S_{[:r,:r]}^{1/2}, \quad B = S_{[:r,:r]}^{1/2} V_{[:,:r]}^\top$

where $U S V^\top = W_0$ is the singular value decomposition of $W_0$ , $U_{[:,:r]}$ are the left singular vectors corresponding to the $r$ largest singular values, $V_{[:,:r]}$ are the corresponding right singular vectors, and $S_{[:r,:r]}$ is the diagonal matrix of the $r$ largest singular values. At initialization, $W_0' + B A = (W_0 - B A) + B A = W_0$ , so the model's forward pass is unchanged — but the residual $W_0' = W_0 - B A$ is the "non-principal remainder" of the weight, frozen during training.

What it computes: PiSSA splits $W_0$ into two components: a frozen base $W_0'$ that contains the minor singular components (everything except the top $r$ ), and a trainable adapter $B A$ that is initialized to exactly the top $r$ principal components. Training then modifies the principal component approximation, while the non-principal remainder stays fixed.

Why this form (and why it fails under RLVR): the design is motivated by SFT experience: supervised fine-tuning tends to make large updates to already-large singular values, so initializing the adapter at the principal components gives it a "head start" — it begins already capturing the most important structure of $W_0$ , and training just refines it. However, as the paper documents in Section 3.1 (Finding 3), this fails catastrophically under RLVR because RLVR "operates in an off-principal regime" (citing Zhu et al., 2025). By forcing the adapter to operate in the subspace of principal components, PiSSA creates a structural constraint that directly conflicts with where RLVR's gradients point. The result is training collapse to 0.2% accuracy — effectively random performance. The paper's spectral analysis (Figure 3) confirms that RLVR updates in full fine-tuning are distributed uniformly across the singular value spectrum, not concentrated on principal components.

MiLoRA (Minor singular components LoRA) (Wang et al., 2025a) attempts to invert PiSSA's logic. Recognizing that RLVR might prefer non-principal updates, MiLoRA initializes the adapter using the minor (smallest) singular components:

$W_0' = W_0 - B A, \quad A = U_{[:,r:]} S_{[r:,r:]}^{1/2}, \quad B = S_{[r:,r:]}^{1/2} V_{[:,r:]}^\top$

where $U_{[:,r:]}$ are the left singular vectors for the $r$ smallest singular values, and similarly for $V_{[:,r:]}$ and $S_{[r:,r:]}$ . The frozen base $W_0' = W_0 - B A$ now contains the principal components, and the adapter captures the minor components.

What it computes: MiLoRA inverts PiSSA's frozen and trainable subspaces. The trainable adapter is initialized in the off-principal (low-singular-value) subspace, which theoretically aligns with where RLVR updates should go. Training modifies this minor-component approximation, while the dominant spectral structure of $W_0$ remains frozen.

Why this form (and why it still fails): despite the theoretical motivation, MiLoRA achieves only 18.0% accuracy — better than PiSSA's 0.2% but far below standard LoRA's 42.5%. The paper provides a mechanistic explanation through spectral analysis (Figure 3, and detailed in Section 3.1, Finding 3): the minor singular values $\sigma_{\text{tail}}$ are very close to zero, so the initialization magnitude $\|\Delta W^0\|_F = \|B A\|_F$ is negligible. When the optimizer takes its first gradient step, the gradient $\nabla \mathcal{L}$ naturally aligns with the principal components (where the signal is largest), and there is no significant initial bias to keep the updates in the off-principal subspace. Formally, at $t = 0$ :

$\Delta W^{1} \leftarrow \Delta W^{0} - \eta \nabla \mathcal{L}(W^0), \quad \|\Delta W^0\|_F \approx 0$

Since $\Delta W^0 \approx 0$ , the first update is effectively $\Delta W^1 \approx -\eta \nabla \mathcal{L}(W^0)$ , which projects onto the principal subspace (because $\langle \nabla \mathcal{L}, U_{:k} \rangle \gg \langle \nabla \mathcal{L}, U_{k:} \rangle$ ). The intended off-principal constraint is numerically non-existent at initialization, and the gradient flow immediately reorients the adapter toward principal components. The spectral evidence (Figure 3, left, blue line) shows a sharp spike at the dominant principal components ( $k \approx 0$ ) in MiLoRA's final update distribution — it ends up behaving almost identically to PiSSA despite the inverted initialization intent.

LoRA+ (Hayou et al., 2024) takes a completely different approach: rather than modifying initialization values, it modifies learning rates. The key idea is that the matrices $A$ and $B$ in LoRA play asymmetric roles — $A$ projects inputs into the low-rank space, $B$ projects from the low-rank space to outputs — and they may benefit from different learning rates:

$\eta_B = \lambda \eta_A$

where $\eta_A$ is the learning rate for matrix $A$ , $\eta_B$ is the learning rate for matrix $B$ , and $\lambda \gg 1$ (often 16 or 32) means $B$ is updated with a much larger step size than $A$ .

What it computes: the forward pass is identical to standard LoRA, but the optimizer applies differentiated learning rates. $B$ receives larger updates per step; $A$ receives smaller ones. The total parameter count and initialization are unchanged from standard LoRA.

Why this form: the motivation comes from analyzing the gradient flow in LoRA, which reveals that the effective update to the weight matrix depends on the product of the learning rates and the current values of $A$ and $B$ . When $B$ is initialized to zero (as in standard LoRA), the early gradient signal through $B$ is weak because $B$ 's values are small. Giving $B$ a higher learning rate compensates for this, allowing the adapter to escape the zero-initialization plateau faster. Under RLVR, where the gradient signal is already sparse and potentially weak, this compensation may be particularly important. The paper's results show LoRA+ achieving 43.9% average accuracy, a meaningful improvement over standard LoRA's 42.5%, and beating AdaLoRA (44.2%) on some metrics.

rsLoRA (Rank-Stabilized LoRA) (Kalajdzievski, 2023) addresses a scaling issue in the standard LoRA forward pass:

$y = W_0 x + \frac{\alpha}{\sqrt{r}} B A x$

Note the denominator: $\sqrt{r}$ instead of LoRA's $r$ . The initialization otherwise matches standard LoRA ( $A \sim \mathcal{N}(0, \sigma^2)$ , $B = 0$ ).

What it computes: the same low-rank additive correction, but with a different scaling factor. When rank $r$ is increased, the correction term is scaled down by $1/\sqrt{r}$ rather than $1/r$ .

Why this form: the argument is that $\alpha/r$ scaling causes the variance of the adapter's contribution to grow with rank $r$ , potentially destabilizing training when $r$ is large. The $\alpha/\sqrt{r}$ scaling keeps the variance of $B A x$ approximately constant with respect to $r$ , making training behavior more consistent across rank choices. Under RLVR, where training stability is already a concern (entropy collapse, reward hacking), this rank-stable scaling could provide more predictable behavior. The paper finds rsLoRA achieves 42.3% average accuracy, essentially tied with standard LoRA, suggesting that for the specific rank $r = 32$ used, the scaling difference has limited practical impact.

Efficiency-Oriented Variants: LoRA-FA and VeRA

These methods sacrifice some of LoRA's expressivity in exchange for further parameter or memory reduction. Their role in the paper is to probe the expressivity floor — the minimum number of trainable parameters below which RLVR performance collapses.

LoRA-FA (LoRA with Frozen A) (Zhang et al., 2023a) takes standard LoRA and freezes matrix $A$ after random initialization:

$y = W_0 x + B A x$

where $A$ is randomly initialized (Gaussian) and then never updated. Only $B$ is trainable, initialized to zero.

What it computes: the forward pass is standard LoRA, but training only modifies $B$ — the input projection $A$ is fixed. The adapter can only learn weight updates that lie in the column space of the fixed random $A$ , which is a random subspace of dimension $r$ . Since $A$ is not trained, the model cannot adapt which input directions are projected into the low-rank space; it can only learn how to combine those fixed directions via $B$ .

Why this form: the primary motivation is memory efficiency — freezing $A$ eliminates its optimizer states (momentum and variance in Adam), roughly halving the adapter's memory footprint. The question for RLVR is whether the fixed random projection provides enough expressivity. The paper finds LoRA-FA achieves 43.0% average accuracy, slightly better than standard LoRA's 42.5%, which is a striking result — it suggests that for RLVR on these tasks, the specific input projection learned by $A$ in standard LoRA is not critical, and a fixed random projection suffices. This is consistent with the lottery ticket hypothesis framing: if RLVR only needs to tune a sparse subset of pre-existing circuits, a fixed random basis may be expressive enough to route signals to the right output directions.

VeRA (Vector-based Random Matrix Adaptation) (Kopiczko et al., 2023) goes much further in parameter reduction. It freezes both low-rank matrices and learns only diagonal scaling vectors:

$y = W_0 x + \Lambda_b B \Lambda_d A x$

where $A \in \mathbb{R}^{r \times d_{\text{in}}}$ and $B \in \mathbb{R}^{d_{\text{out}} \times r}$ are frozen random matrices (initialized once and never trained), $\Lambda_d \in \mathbb{R}^{r \times r}$ is a diagonal matrix of trainable scaling parameters for the $A$ projection (initialized to 0.1), and $\Lambda_b \in \mathbb{R}^{d_{\text{out}} \times d_{\text{out}}}$ is a diagonal matrix of trainable scaling parameters for the $B$ projection (initialized to 0).

What it computes: the trainable parameters are purely diagonal scaling vectors — $\Lambda_d$ scales each row of the frozen $A$ (modifying which input directions get amplified or suppressed before the low-rank bottleneck), and $\Lambda_b$ scales each column of the frozen $B$ (modifying how the bottleneck representation maps to output dimensions). The total trainable parameter count is $r + d_{\text{out}}$ , which is drastically smaller than LoRA's $r \times (d_{\text{in}} + d_{\text{out}})$ .

Why this form: VeRA is designed for extreme memory efficiency — with trainable parameters in the hundreds or low thousands rather than millions. The hypothesis is that adaptation primarily involves scaling existing features rather than learning new feature combinations, and diagonal scaling vectors are sufficient to express this. However, under RLVR, VeRA achieves only 40.7% average accuracy, below standard LoRA's 42.5% and only marginally above the base model's 40.5%. The paper interprets this as evidence for an expressivity floor: RLVR reasoning acquisition requires more degrees of freedom than diagonal scaling can provide. The model cannot restructure reasoning circuits using only scalar multipliers on frozen random projections.

Other PEFT Mechanisms: IA3 and LayerNorm Tuning

These methods abandon the weight-update paradigm entirely, testing whether even simpler adaptation mechanisms can support RLVR.

IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations) (Liu et al., 2022a) learns per-dimension scaling vectors that are multiplied element-wise with activations:

$x' = x \odot l$

where $l \in \mathbb{R}^{d}$ is a trainable vector of scaling factors (initialized to 1, so no change at initialization), $\odot$ denotes element-wise multiplication, and $x$ is the activation from key, value, or feed-forward network layers. Different scaling vectors are learned for keys, values, and FFN activations, but the total parameter count remains tiny — one scalar per hidden dimension per targeted layer type.

What it computes: IA3 does not modify weights at all. It inserts multiplicative gates into the forward pass at specific points (key projections, value projections, FFN intermediate activations), allowing the model to amplify or suppress each dimension's contribution. This is conceptually similar to learning a per-channel gain factor.

Why this form: IA3 is even more parameter-efficient than VeRA for some configurations, and its simplicity makes it attractive for rapid experimentation. However, under RLVR, IA3 achieves only 22.3% average accuracy — a catastrophic degradation. The paper argues this demonstrates that multiplicative activation scaling is insufficient to support complex reasoning acquisition under sparse RL signals. The model needs to reroute information flow (changing weight directions, not just scaling existing directions) to learn new reasoning behaviors, and IA3 cannot express such rerouting.

LayerNorm Tuning (Qi et al., 2022) trains only the parameters of LayerNorm layers:

$y = \frac{g}{\sigma} \odot (x - \mu) + b$

where $g$ (gain) and $b$ (bias) are the only trainable parameters (initialized to pre-trained values), $\mu$ and $\sigma$ are the mean and standard deviation of the input $x$ computed during the forward pass (not trainable). All weight matrices remain frozen throughout training.

What it computes: LayerNorm tuning adjusts the normalization statistics applied to each layer's activations. The gain $g$ scales the normalized output, and the bias $b$ shifts it. This is an extremely lightweight intervention — LayerNorm parameters constitute roughly 0.0035% of total parameters.

Why this form: the hypothesis is that adaptation to new tasks primarily requires adjusting the scale and offset of activation distributions rather than the weight matrices themselves. For some NLP tasks under SFT, this surprisingly works. Under RLVR, LayerNorm Tuning achieves 41.8% average accuracy — better than VeRA (40.7%) and far better than IA3 (22.3%), but still below standard LoRA (42.5%). This is a fascinating result: simply adjusting normalization statistics provides non-trivial reasoning improvement over the base model (41.8% vs. 40.5%), suggesting that some of RLVR's benefit comes from calibrating activation magnitudes rather than from structural weight changes. However, the gap to full fine-tuning (44.9%) indicates that weight-level adaptation is still necessary for full reasoning capability.

Training Infrastructure and Hyperparameter Configuration

The paper's experimental setup is designed to ensure fair comparison across PEFT methods by controlling all non-architectural variables. Here are the precise configurations:

Hardware and optimization stack: training uses HuggingFace Accelerate with DeepSpeed ZeRO-2 optimization, which offloads optimizer states (not parameters or gradients) to CPU. This is a practical choice: ZeRO-2 shards optimizer states across GPUs while keeping parameters and gradients replicated, reducing per-GPU memory by approximately 2× compared to standard data parallelism. The optimizer is not explicitly named but is presumably AdamW, the standard for transformer training.

Rollout generation: the vLLM engine runs in co-location mode — that is, on the same GPUs as the training process — to maximize throughput without requiring separate inference servers. This is critical for RLVR, where generation and training are interleaved: the model generates responses, computes rewards, and then updates weights, all in a single training loop. vLLM's PagedAttention and continuous batching provide substantial speedups over naive HuggingFace generation.

Key hyperparameters for the 1.5B model:

Rollouts per prompt ( $G$ ): 8
Constant learning rate: $1 \times 10^{-5}$ , no warmup
Per-device batch size: 4
Global batch size: 128 (achieved via 8 gradient accumulation steps across multiple devices)
Training steps: 1,024
Maximum prompt length: 512 tokens
Maximum completion length: 16,384 tokens
DAPO epsilon: $\epsilon_{\text{high}} = 0.28$ (clip-higher), no lower clip specified (standard GRPO $\epsilon_{\text{low}}$ presumably applies)
KL coefficient ( $\beta$ ): 0 (no KL penalty)

Key hyperparameters for the 7B model:

Per-device batch size: 1
Global batch size: 32
Gradient accumulation steps: 8
Training steps: 8,192
All other parameters identical to 1.5B configuration

PEFT-specific configuration: all PEFT methods target all linear modules ({q, k, v, o, gate, up, down}_proj), following the recommendation from Schulman & Lab (2025) and Wang et al. (2025b) that this configuration yields superior RLVR performance compared to targeting only attention query/value matrices. The shared configuration across all methods is:

Rank ( $r$ ): 32 (except for rank ablation experiments where $r \in \{1, 8, 16, 32\}$ )
Alpha ( $\alpha$ ): 64
Dropout rate: 0.05

The dropout is applied to the adapter output, providing regularization against overfitting to the sparse reward signal. The scaling factor $\alpha/r = 64/32 = 2$ for most experiments, meaning the adapter's contribution is multiplied by 2 before being added to the base model output. This is within the typical range for LoRA ( $\alpha/r \in [1, 4]$ ).

The RLVR algorithm choice (DAPO as default, GRPO and Dr. GRPO as ablations): the paper adopts DAPO as the primary algorithm because it represents a state-of-the-art, open-source RLVR implementation with demonstrated stability on mathematical reasoning. The ablations in Section 3.2 test whether PEFT method rankings depend on the specific RL algorithm, finding that they do not — "a remarkable degree of algorithmic invariance" (Section 3.2). This is methodologically important: it means the paper's conclusions about which PEFT methods work are not tied to DAPO-specific quirks but reflect fundamental properties of learning from sparse verifiable rewards.

A note on the training schedule length: 1,024 steps for 1.5B and 8,192 steps for 7B. The distinction matters because RLVR training dynamics can change over long horizons — early training may focus on format adherence (learning to output answers in \boxed{}), mid-training on exploration of reasoning strategies, and late training on refinement. The longer schedule for the 7B model tests whether the PEFT method rankings hold as training saturates.

Evaluation Protocol

The paper evaluates models on six mathematical reasoning benchmarks, each with specific characteristics and evaluation methods:

Benchmark suite (Table 2):

AIME24 and AIME25 (30 problems each): American Invitational Mathematics Examination problems from 2024 and 2025, considered among the most challenging math benchmarks for LLMs. Evaluated with Avg@32 — generate 32 solutions per problem and average the accuracy (fraction correct).
MATH500 (500 problems): the standard test set from the MATH benchmark (Lightman et al., 2023), spanning competition math topics. Evaluated with Avg@4 — generate 4 solutions per problem and average accuracy.
Minerva (272 problems): a collection of quantitative reasoning problems from various STEM domains (Lewkowycz et al., 2022). Evaluated with Avg@4.
AMC (40 problems): problems from the American Mathematics Competitions (Li et al., 2024). Evaluated with Avg@32.
HMMT (30 problems): Harvard-MIT Mathematics Tournament problems (Balunović et al., 2025). Evaluated with Avg@32.

Why two evaluation metrics (Avg@k and Pass@k): Avg@k reports the fraction of the $k$ generations that are correct — it measures average performance, rewarding models that are consistently correct. Pass@k reports whether at least one of the $k$ generations is correct — it measures best-case performance, rewarding models that can occasionally produce correct solutions even if most attempts fail. The paper reports both because they capture different aspects of RLVR behavior: a method that produces highly variable outputs (sometimes brilliant, sometimes nonsensical) might score well on Pass@k but poorly on Avg@k, while a method that produces reliably mediocre outputs might show the opposite pattern.

Generation parameters: temperature of 0.6 and top-p of 0.95 provide moderate diversity — high enough to encourage exploration of different reasoning paths (important for RLVR, which needs diverse rollouts to estimate advantages), but not so high as to produce degenerate outputs. The maximum token limit of 32,768 accommodates long chain-of-thought reasoning, which can extend to thousands of tokens for complex math problems. The random seed is fixed at 42 for reproducibility.

The format enforcement: the paper imposes a strict output structure — reasoning traces must be enclosed in thinking... tags, and the final answer must be in \boxed{}. This is not merely cosmetic. The RLVR reward function depends on accurate answer extraction; if the model outputs the correct answer but in an unparseable format, it receives reward 0 and is penalized. This creates an implicit "format reward" baked into the training signal — the model must learn to follow the format to receive any positive reward at all, and format violations are punished as harshly as incorrect answers. This is consistent with the JustRL philosophy of minimal reward engineering.

Spectral Analysis Methodology for Diagnosing SVD-Based Failures

The paper's mechanistic explanation for why PiSSA and MiLoRA fail is grounded in spectral analysis of weight updates. This is the methodology that elevates the paper from benchmarking to understanding.

The analysis (Figure 3) examines the distribution of weight changes across the singular value spectrum. For a given weight matrix $W \in \mathbb{R}^{d_{\text{out}} \times d_{\text{in}}}$ , its SVD is $W = U S V^\top$ , where $S = \text{diag}(\sigma_1, \sigma_2, \ldots, \sigma_{\min(d_{\text{out}}, d_{\text{in}})})$ contains the singular values in descending order ( $\sigma_1 \geq \sigma_2 \geq \ldots$ ). The singular vectors $U$ and $V$ define orthonormal bases for the output and input spaces, respectively. Any weight update $\Delta W = W_{\text{trained}} - W_{\text{initial}}$ can be analyzed by projecting it onto this basis, yielding a "singular value index" that indicates whether the update primarily affects high-variance (principal) or low-variance (off-principal) directions.

For each method being analyzed, the procedure is:

Compute weight changes: after training, subtract the initial weight matrix from the final weight matrix to obtain $\Delta W$ .
Project onto singular vectors: compute the magnitude of $\Delta W$ when projected onto each singular vector direction. Formally, for each singular value index $k$ , compute $\|U_{[:,k]}^\top \Delta W V_{[:,k]}\|$ — this is the magnitude of the update that affects the $k$ -th principal component.
Normalize and visualize: plot the normalized magnitude (log scale) against the principal component index $k$ , producing a curve that shows whether updates are concentrated at low $k$ (principal components, high singular values) or high $k$ (minor components, low singular values) or distributed uniformly.
Cumulative energy analysis: compute the cumulative proportion of total update energy explained by the top- $k$ components. An update concentrated on principal components will show a rapidly saturating curve (most energy in the first few components); a uniform update will show a linear increase.

The paper applies this methodology to the gate_proj layer of a transformer block (specifically model.layers.10.mlp.gate_proj) and reports results for four conditions: Base Model (the update from pre-trained to SFT-fine-tuned), PiSSA, MiLoRA, and Full Fine-Tuning.

What the analysis reveals (Finding 3, Section 3.1):

Full Fine-Tuning (Figure 3, left, green line) shows a uniform distribution of updates across all singular value indices — there is no concentration at principal or minor components. This is the key empirical fact about RLVR: unlike SFT, which predominantly updates principal components, RLVR's gradient signal is distributed across the entire singular value spectrum. This validates the claim that RLVR operates in an "off-principal regime" — not exclusively off-principal, but necessarily including off-principal components.
PiSSA shows a complete absence of meaningful updates — the weight change is negligible across all components. This is the consequence of design: PiSSA restricts updates to the principal subspace, but RLVR's gradient pulls toward off-principal directions. The structural constraint prevents the model from following the gradient, resulting in training collapse.
MiLoRA (Figure 3, left, blue line) shows a sharp spike at the dominant principal components ( $k \approx 0$ ) despite being initialized in the off-principal subspace. This is the critical diagnostic: MiLoRA's updates end up looking like PiSSA's, not like the off-principal distribution they were designed for. The paper explains this through the "vanishing initialization" mechanism described above — with $\|\Delta W^0\|_F \approx 0$ , the gradient immediately dominates and pulls updates toward principal components where $\langle \nabla \mathcal{L}, U_{:k} \rangle$ is largest.

The cumulative energy analysis (Figure 3, center) provides additional confirmation: both PiSSA and MiLoRA show rapidly saturating cumulative energy curves, indicating that nearly all update energy is concentrated in the first few principal components. Full Fine-Tuning shows a much more gradual accumulation, consistent with uniform distribution across the spectrum.

What this methodology enables beyond the specific results: it provides a general diagnostic for whether a PEFT method's design assumptions about the optimization landscape are compatible with RLVR. Any method that constrains updates to a specific spectral subspace (principal or minor) will struggle if RLVR's gradient does not respect that constraint. The paper's recommendation — use methods that provide flexible, spectrally-unbiased update mechanisms (like DoRA's magnitude-direction decoupling or AdaLoRA's adaptive rank allocation) — follows directly from this analysis.

Summary of Design Choices and Their Justifications

DAPO as the primary RL algorithm over vanilla GRPO: provides asymmetric clipping (clip-higher) that prevents entropy collapse in long chain-of-thought generation, and dynamic sampling that improves sample efficiency by filtering uninformative prompt-response groups.
Binary outcome-based reward over process-based or learned rewards: eliminates reward hacking, keeps the training pipeline simple and reproducible, and follows the JustRL philosophy that minimal reward engineering suffices for mathematical reasoning.
Rank 32 targeting all linear modules over smaller ranks or attention-only targeting: based on prior work (Schulman & Lab, 2025; Wang et al., 2025b) showing this configuration maximizes RLVR performance, and validated by the paper's rank ablation showing monotonic improvement from rank 1 to 32.
vLLM co-location over separate inference servers: simplifies infrastructure by running generation and training on the same GPUs, using continuous batching for throughput.
Two evaluation metrics (Avg@k and Pass@k) over single-metric reporting: captures both consistency and best-case capability, important because RLVR-trained models can exhibit high variance in output quality.
Spectral analysis of a specific layer (gate_proj) for mechanistic diagnosis: the MLP gate projection is a representative linear layer where weight update patterns can be clearly visualized across the singular value spectrum; the conclusions are assumed to generalize to other linear modules.
Five-category taxonomy of PEFT methods over unstructured listing: structures the comparison around hypotheses about where adaptation matters (initialization, architecture, expressivity), making the empirical results interpretable as tests of these hypotheses rather than as a pure leaderboard.

4. Key Insights and Innovations

Innovation 1: RLVR as a Qualitatively Distinct Optimization Regime for Adapter Design

The paper's most fundamental conceptual contribution is not that DoRA beats LoRA—it's the demonstration that RLVR constitutes a distinct optimization regime with different adapter requirements than SFT, and that the PEFT community's default of transplanting SFT-optimized methods to RLVR without verification is actively harmful. This is best understood as a regime-shift diagnosis: the paper identifies that the field has been reasoning about PEFT-RLVR using the wrong reference class.

Before this work, PEFT methods were developed, validated, and compared almost exclusively under SFT conditions—dense, token-level supervision via teacher-forcing. The implicit assumption was that a method's SFT ranking would transfer. PiSSA, for instance, was a well-regarded method because it accelerated SFT convergence by initializing adapters along principal singular components where SFT gradients naturally concentrate. The paper's results shatter this assumption: PiSSA collapses to 0.2% accuracy under RLVR (Table 3), performing worse than a random baseline. This is not a modest degradation—it's a complete failure mode caused by a fundamental incompatibility between the method's design assumptions and the optimization landscape it faces.

What makes this intellectually distinctive is that the paper doesn't merely report the failure—it establishes the mechanistic reason why SFT and RLVR are different regimes, and why that difference matters for architecture selection. Section 3.1 (Finding 3) and Figure 3 demonstrate that RLVR's gradient signal is distributed uniformly across the singular value spectrum (as shown by the Full Fine-Tuning update distribution), whereas SFT gradients concentrate on principal components. Any adapter method that imposes a spectral bias—either toward principal components (PiSSA) or, due to optimization instability, collapsing toward them (MiLoRA)—will conflict with RLVR's gradient flow. This transforms "which method works best" from an empirical listicle into a testable prediction: methods that allow unconstrained, spectrally-flexible updates should outperform methods with fixed spectral priors.

The significance extends beyond this paper's benchmarks. If RLVR and SFT are genuinely different optimization regimes, then the entire PEFT-RLVR research agenda needs to re-anchor around RLVR's specific properties (sparse rewards, off-principal gradients, the need for exploration plasticity) rather than borrowing methods and intuitions from the SFT literature. This reframes what was a simple benchmarking question ("which existing method wins?") into a research program: design PEFT methods that explicitly target RLVR's update dynamics rather than SFT's. The paper's advocacy for "geometry-aware adapters like DoRA" (Section 5) follows from this reframing—DoRA's magnitude-direction decoupling happens to provide the spectral flexibility RLVR demands, but the deeper insight is about why that flexibility matters, not just that DoRA works.

Innovation 2: The Expressivity Floor as a Principled Boundary for Parameter Reduction in RL

The paper's second distinctive contribution is the articulation and empirical demonstration of an expressivity floor—a minimum threshold of trainable adapter capacity below which RLVR reasoning acquisition collapses, even though supervised learning might tolerate similar compression. This is not an incremental observation about VeRA performing worse than LoRA; it's a conceptual boundary that constrains any future work on ultra-efficient RLVR.

The evidence is stark and structured. The paper tests a spectrum of parameter reduction (Table 4): full-parameter training (100% trainable), standard LoRA (1.55%), MiSS (0.99%), LoRA-FA (approximately 0.8% since A is frozen), VeRA (0.003%), and LayerNorm Tuning (0.0035%). The performance curve is not linear—it shows a sharp discontinuity. LoRA-FA, despite training only half the parameters of standard LoRA (B only, with A frozen random), achieves 43.0% average accuracy, actually surpassing standard LoRA's 42.5%. This suggests that RLVR can tolerate substantial compression when the remaining trainable parameters retain matrix-level expressivity—B can still learn to route signals through the fixed A's random projection, effectively selecting which output directions to amplify.

But cross the boundary from matrix-level to vector-level expressivity, and performance collapses: VeRA (40.7%) and IA3 (22.3%) both restrict trainable capacity to diagonal scaling vectors or per-dimension multipliers. These methods cannot express the kind of weight-level reconfiguration—changing which input dimensions map to which output dimensions—that even a low-rank matrix can. The paper interprets this as evidence that RLVR reasoning acquisition requires rewiring information flow through the network, not merely reweighting existing pathways. Diagonal scaling can boost or suppress features, but it cannot redirect them.

What makes this a genuine innovation rather than an obvious finding is the tension it resolves. Prior work had suggested that RLVR updates are highly sparse—Mukherjee et al. (2025) found that RLVR fine-tunes small subnetworks, and Zhu et al. (2025) showed updates concentrate off the principal components. One might reasonably extrapolate from sparsity to extreme compressibility: if only a tiny fraction of parameters matter, then perhaps vector-level adaptation (like VeRA or IA3) suffices. The paper shows this extrapolation is wrong. Sparsity does not imply low expressivity—the updates may be sparse in parameter space, but they still require the capacity to form new input-output mappings, which demands at minimum a matrix-level transformation with multiple degrees of freedom per dimension. This is a boundary characterization, not just a ranking: it tells future researchers where to stop compressing.

Innovation 3: Spectral Collapse as a Diagnostic Concept for Adapter-RLVR Incompatibility

The paper introduces a diagnostic framework—spectral collapse—that generalizes beyond the specific failure of PiSSA/MiLoRA to provide a principled way of evaluating whether a PEFT method's inductive biases align with RLVR's optimization dynamics. This is a conceptual tool, not just an empirical finding about two specific methods.

The diagnostic works as follows (Section 3.1, Finding 3; Figure 3): after training, project the weight update ΔW onto the singular vector basis of the pre-trained weight matrix W₀ and examine the distribution of update magnitude across singular value indices. If a method is compatible with RLVR, its update distribution should be spectrally unconstrained—similar to the uniform distribution observed in Full Fine-Tuning (Figure 3, green line). If a method shows a sharp concentration of updates at specific spectral indices (e.g., the principal-component spike in MiLOra, Figure 3 blue line), that indicates the method is forcing updates into a subspace that RLVR's gradient doesn't naturally target, and this misalignment causes either training collapse (PiSSA) or severe degradation (MiLoRA).

What makes this diagnostic novel is that it separates design intent from optimization outcome. MiLoRA was designed to align with RLVR—it initializes adapters in the off-principal subspace, exactly where RLVR should want to go. The spectral collapse diagnostic reveals that this design intent is frustrated by optimization dynamics: the minor singular values are so small that the initial adapter magnitude is numerically negligible, and the first gradient step (which is dominated by principal-component gradients) immediately reorients the updates toward the principal subspace, collapsing the intended off-principal bias into something indistinguishable from PiSSA. This is a non-obvious failure mode—the method is theoretically well-motivated but practically self-defeating because of an interaction between initialization scale and gradient magnitude that only becomes visible through spectral analysis.

The diagnostic is also forward-looking: it provides a criterion for evaluating future PEFT methods for RLVR. A method that imposes a strong spectral prior (e.g., initializing in specific singular subspaces, regularizing toward specific spectral distributions) should be viewed with suspicion unless it can demonstrate that its prior doesn't collapse under RLVR's gradient flow. Conversely, methods that are spectrally neutral—DoRA, AdaLoRA, LoRA+—are theoretically favored. This transforms adapter selection from empirical trial-and-error into a hypothesis-driven process: test whether the method's spectral biases are compatible with RLVR's gradient distribution before running expensive full-scale training.

Innovation 4: The Inversion of the SFT Evaluation Hierarchy Under RLVR

The paper empirically demonstrates that the relative ranking of PEFT methods under RLVR is not merely different from the SFT ranking—it is inverted in critical places. This is a finding about method transferability that has significant implications for how the field should conduct PEFT research going forward.

Under SFT, the conventional wisdom (validated by extensive benchmarking) is that standard LoRA is a strong and reliable baseline; SVD-based initializations like PiSSA provide consistent improvements by accelerating convergence; and structural variants like DoRA offer incremental gains in specific settings but are not universally dominant. The paper's RLVR results (Table 3, Figure 1) show a fundamentally different hierarchy: standard LoRA is suboptimal (42.5% vs. 46.6% for DoRA), PiSSA is catastrophically broken (0.2%), and structural variants are the consistent top performers (DoRA at 46.6%, AdaLoRA at 44.2%, MiSS at 43.4%) with DoRA even surpassing full-parameter fine-tuning (44.9%).

The inversion is most striking for PiSSA. Under SFT, PiSSA is a well-validated method that reliably improves over standard LoRA by providing a better initialization. Under RLVR, it is the worst-performing method tested—worse even than IA3's 22.3%, worse than the untrained base model (40.5%). This is not a case of a method being slightly suboptimal; it's a case of a method being actively destructive in a regime it wasn't designed for. The practical implication is clear: practitioners cannot safely assume that methods validated under SFT will work under RLVR, even when the base model and task are identical. Each method must be re-evaluated, and the transferability assumption should be treated as a hypothesis to test rather than a default to trust.

This finding also recontextualizes the paper's advocacy for DoRA. Under SFT, DoRA is a good method—it consistently outperforms LoRA by modest margins. Under RLVR, DoRA is not just good; it's the best method tested, outperforming even full-parameter fine-tuning. The RLVR regime doesn't just shift the ranking—it amplifies the relative advantage of structural variants in ways that only make sense given RLVR's specific optimization dynamics (sparse rewards, off-principal gradients, the need for exploration plasticity that magnitude-direction decoupling may facilitate). This amplification effect suggests that RLVR doesn't just change which methods work but how much architectural choices matter—the penalty for choosing a suboptimal adapter architecture is larger under RLVR than under SFT, making adapter selection a higher-stakes decision.

5. Experimental Analysis

Evaluation Methodology

Dataset. The training dataset is open-r1/DAPO-Math-17k-Processed (Yu et al., 2025), comprising approximately 17,400 high-quality mathematical queries with structured reasoning format enforced. For evaluation, six mathematical benchmarks are used: MATH500 (500 problems; Lightman et al., 2023), AIME24 and AIME25 (30 problems each; Zhang & Math-AI, 2024; 2025), AMC (40 problems; Li et al., 2024), HMMT (30 problems; Balunović et al., 2025), and Minerva (272 problems; Lewkowycz et al., 2022). All benchmarks test mathematical reasoning across competition-level difficulty.
Base model(s). Two models from the DeepSeek-R1-Distill family are evaluated: DeepSeek-R1-Distill-Qwen-1.5B and DeepSeek-R1-Distill-Qwen-7B (DeepSeek-AI, 2025). These models are chosen because they have undergone SFT as a cold-start phase, ensuring sufficient initial reasoning capability and output format adherence (` thinking...` tags, \boxed{} for final answers), and because the two size variants (1.5B and 7B) enable testing whether PEFT method rankings generalize across parameter scales.
Metrics. The primary metric is accuracy, reported as Avg@k (the fraction of k generations that are correct, averaged over all problems) and Pass@k (the fraction of problems for which at least one of k generations is correct). Avg@k measures average performance (favoring consistent models); Pass@k measures best-case capability (favoring models that occasionally succeed). Benchmarks with small problem counts (AIME, AMC, HMMT: 30–40 problems) use k = 32; larger benchmarks (MATH500: 500 problems, Minerva: 272 problems) use k = 4. The paper also reports an "Overall Accuracy" (weighted average across all benchmarks). For generation, temperature = 0.6, top-p = 0.95, max tokens = 32,768, and random seed = 42 for reproducibility.
Baselines. Five baselines span the expressivity spectrum: (1) Base model — the pre-trained DeepSeek-R1-Distill checkpoint without any RLVR training, representing the cold-start performance floor; (2) Full-Parameter Fine-Tuning — all model weights are trained under RLVR, representing the unconstrained upper bound on what RLVR can achieve; (3) Standard LoRA (Hu et al.) — the default PEFT choice, training low-rank adapters (BA) with rank 32 on all linear modules, representing the community's current practice; (4) LoRA Rank 1 — standard LoRA with rank reduced to 1, testing the extreme-low-rank hypothesis; (5) additional baselines for specific comparisons include the Base model without any training (40.5% accuracy) to measure the cold-start floor.
Generation budget / compute accounting. The unit of compute is trainable parameter count, measured as a percentage of total model parameters (Table 4, Figure 1 left). This captures the primary resource constraint that PEFT addresses: memory for optimizer states, gradient communication overhead, and checkpoint storage. All methods are compared at equivalent ranks (r = 32 for the main experiments, r swept across {1, 8, 16, 32} in ablations), equivalent learning rates (1 × 10⁻⁵ for main experiments, {1 × 10⁻⁵, 5 × 10⁻⁶, 1 × 10⁻⁶} in ablations), and identical training budget measured in training steps (1,024 for 1.5B models, 8,192 for 7B models). For generation, all methods use the same vLLM rollout configuration (G = 8 responses per prompt), so inference cost is identical across methods at training time.
Cross-validation / statistical protocol. The paper does not employ explicit cross-validation or statistical significance testing (no confidence intervals, p-values, or standard deviations are reported in the tables — the note in Table 5 explicitly states "std dev removed for clarity"). Reproducibility is ensured via fixed random seed (42), controlled generation parameters, and open-source infrastructure (Accelerate, DeepSpeed ZeRO-2, vLLM, TRL). The absence of error bars means that small performance differences (e.g., LoRA at 42.5% vs. LoRA+ at 43.9%) should be interpreted cautiously — we cannot assess whether the 1.4 percentage point gap exceeds run-to-run variance. The paper implicitly relies on the consistency of rankings across multiple benchmarks and model scales as a form of robustness check rather than formal statistical testing.

Main Quantitative Results

The experimental results are presented primarily through three lenses: (1) the overall performance ranking of PEFT methods on the 1.5B model (Table 3, Figure 1), (2) the spectral analysis explaining why SVD-based initializations fail (Figure 3), and (3) the scaling validation on the 7B model (Table 6). These are the paper's three empirical pillars.

Overall PEFT Method Ranking on 1.5B (Table 3, Figure 1). The headline result is the performance hierarchy: DoRA (46.6%) > Full-Parameter Fine-Tuning (44.9%) > AdaLoRA (44.2%) > LoRA+ (43.9%) > MiSS (43.4%) > LoRA-FA (43.0%) > Standard LoRA (42.5%) > rsLoRA (42.3%) > LN Tuning (41.8%) > VeRA (40.7%) ≈ Base Model (40.5%) > MiLoRA (18.0%) > IA3 (22.3%) > PiSSA (0.2%).

Breaking this down by method category:

Structural variants lead decisively. DoRA (46.6%) outperforms the full-parameter baseline (44.9%) by 1.7 percentage points, a striking result — the parameter-efficient method exceeds the unrestricted method. On individual benchmarks, DoRA's advantage is uneven: on AIME24 (Avg@32), DoRA achieves 39.0% versus Full's 34.9% (a 4.1 percentage point gap); on AIME25 (Avg@32), DoRA achieves 28.8% versus 23.8% (5.0 points); on AMC (Avg@32), DoRA achieves 71.9% versus 68.8% (3.1 points). However, on MATH500 (Avg@4), Full achieves 74.8% versus DoRA's 75.8% (a narrower 1.0 point gap), and on Minerva (Avg@4), Full achieves 88.6% versus DoRA's 90.0%. The pattern is that DoRA's advantage is largest on the most challenging benchmarks (AIME, AMC) and narrows on broader benchmarks (MATH500, Minerva). AdaLoRA (44.2%) and MiSS (43.4%) both outperform standard LoRA (42.5%) but trail DoRA, with MiSS achieving this while training only 0.99% of parameters (Table 4) — ~36% fewer trainable parameters than LoRA's 1.55%.
Standard LoRA is suboptimal but not broken. Standard LoRA's 42.5% overall accuracy places it in the middle of the pack, 2.4 points below full-parameter training and 4.1 points below DoRA. This is the key empirical basis for Finding 1 ("Standard LoRA is suboptimal for RLVR"). The gap is consistent across benchmarks: LoRA trails Full on AIME24 (33.2% vs. 34.9%), AIME25 (22.9% vs. 23.8%), AMC (64.4% vs. 68.8%), MATH500 (72.1% vs. 74.8%), and Minerva (87.4% vs. 88.6%), though the margins are modest (1–4 points). LoRA does not fail — it improves substantially over the base model (40.5% → 42.5%) — but it leaves performance on the table compared to both full-parameter training and structural variants.
SVD-based initializations fail catastrophically. PiSSA collapses to 0.2% overall accuracy — effectively random performance, since the base model without any training achieves 40.5%. On individual benchmarks, PiSSA scores 0.0% on AIME24, AIME25, AMC, and HMMT; 0.6% on MATH500; and 0.1% on Minerva. This is not a modest degradation — it is a complete failure of training. MiLoRA achieves 18.0% overall, far below standard LoRA (42.5%), with notably better performance on MATH500 (44.5%) and Minerva (63.4%) than on competition benchmarks (0.0% on AIME25, AMC). The asymmetry in MiLoRA's collapse — performing reasonably on MATH500/Minerva while failing on AIME/AMC — is not discussed in the paper, but it suggests that the spectral misalignment mechanism may interact with problem difficulty or benchmark characteristics in non-uniform ways.
Learning-rate-based initialization (LoRA+) is robust. LoRA+ (43.9%) meaningfully outperforms standard LoRA (42.5%) by 1.4 percentage points while using the identical architecture — only the learning rate ratio differs. rsLoRA (42.3%) is essentially tied with standard LoRA, suggesting that the rank-stabilized scaling ( $\alpha/\sqrt{r}$ vs. $\alpha/r$ ) provides negligible benefit at r = 32.
Extreme efficiency methods hit the expressivity floor. VeRA (40.7%) trains only 0.0029% of parameters (Table 4) but barely improves over the base model (40.5%) — a net gain of 0.2 points. LN Tuning (41.8%) trains 0.0035% of parameters and achieves a more meaningful 1.3-point improvement over the base, but still falls 0.7 points below standard LoRA. IA3 (22.3%) is a catastrophic failure — worse than MiLoRA — suggesting that multiplicative activation scaling is fundamentally insufficient for RLVR reasoning acquisition. LoRA-FA (43.0%), by contrast, trains only B while freezing A, yet outperforms standard LoRA (42.5%) by 0.5 points — the same architecture with fewer trainable parameters does better, an unexpected result that challenges the assumption that more trainable capacity is always beneficial.

Training Dynamics (Figure 1, right; Figure 3, right). The accuracy reward curves (Figure 1, right) reveal several temporal patterns:

DoRA, MiSS, and LoRA-FA show rapid initial improvement and converge to high asymptotic performance, with DoRA maintaining a clear lead throughout training.
Standard LoRA and Full Fine-Tuning follow similar trajectories but with Full maintaining a slight advantage that widens after ~500 steps.
PiSSA and MiLoRA show early improvement followed by degradation (Figure 3, right). MiLoRA initially increases from ~0.2 to ~0.35 accuracy reward by step ~250, then declines to ~0.18 by step 1,024 — a classic pattern of training instability where early progress is reversed. PiSSA never meaningfully improves from near-zero.
VeRA and IA3 show slow, limited improvement that plateaus early, consistent with the expressivity floor interpretation — the adapter capacity saturates quickly and cannot capture additional reasoning improvements.

Spectral Analysis of Weight Updates (Figure 3, left and center). The normalized magnitude plot (Figure 3, left) analyzes the gate_proj layer of model.layers.10.mlp:

Full Fine-Tuning (green line) distributes updates uniformly across the entire singular value spectrum, from k ≈ 0 (largest singular values, principal components) to k ≈ 1,500 (smallest singular values, minor components). There is no concentration at either extreme.
PiSSA shows negligible update magnitude across all indices — the constraint to principal components prevents any meaningful learning.
MiLoRA (blue line) shows a sharp spike at the dominant principal components (k ≈ 0–50), with update magnitudes 10–100× larger at these indices than at higher k. Despite being initialized in the off-principal subspace, the final updates are strongly concentrated on principal components — the "spectral collapse" that the paper identifies as the failure mechanism.

The cumulative energy proportion plot (Figure 3, center) quantifies this: for MiLoRA, the top-50 components explain nearly all update energy (the cumulative curve saturates rapidly), while for Full Fine-Tuning, the cumulative curve increases gradually across the spectrum, with top-50 components explaining only a fraction of total energy. This is the visual evidence that MiLoRA's updates collapse to a principal-component distribution despite the off-principal initialization intent.

Scaling to 7B (Table 6). The relative performance hierarchy largely persists at the larger scale:

DoRA (55.0%) and LoRA+ (55.5%) both outperform standard LoRA (54.8%), though the margins are smaller than at 1.5B (0.2–0.7 points vs. 1.4–4.1 points). LoRA+ actually edges ahead of DoRA at this scale (55.5% vs. 55.0%), a reversal from the 1.5B ranking.
MiSS (53.4%) trails standard LoRA (54.8%) by 1.4 points, a drop from its competitive position at 1.5B (43.4% vs. 42.5% for LoRA), suggesting that MiSS's shard-sharing parameterization may not scale as effectively to larger models.
On specific benchmarks, the patterns are consistent: DoRA leads on AIME25 (38.7% vs. LoRA's 35.9%) and AMC (83.1% vs. 81.4%); LoRA+ leads on AIME24 (46.3% vs. LoRA's 48.3% — actually trailing) and Minerva (94.6% vs. 94.8% — also trailing). The paper's claim that "the relative performance hierarchy remains largely consistent" is supported directionally (structural variants outperform LoRA) but the specific ranking within structural variants shifts between model scales.

Ablation Studies and Robustness Checks

Batch Size (Table 5, Figure 5): Reducing batch size from 128 to 32 produces mixed effects. The smaller batch achieves slightly higher overall average accuracy for standard LoRA (43.0% vs. 42.5% at batch 128), but on the challenging AIME24 benchmark, batch size 128 actually outperforms batch size 32 (33.2% vs. 28.4% Avg@32). The paper concludes that "the small batch heuristic from SFT does transfer to RLVR but performs less well" (Section 3.2) — the effect is weaker and inconsistent compared to SFT, where small batches are strongly favored. This is attributed to RLVR's sparse scalar rewards not saturating adapter capacity the way dense token-level SFT targets do.

RLVR Algorithm Variants (Table 5): Standard LoRA performance is tested under GRPO (Shao et al., 2024), DAPO (Yu et al., 2025), and Dr. GRPO (Liu et al., 2025). Results: DAPO achieves 42.5% overall, Dr. GRPO achieves 42.0%, and GRPO achieves 40.5%. The differences are modest (2.0 points between best and worst), and the paper interprets this as "a remarkable degree of algorithmic invariance" (Section 3.2). However, the 2.0-point gap between DAPO and GRPO is larger than some inter-method gaps in the main comparison (e.g., LoRA at 42.5% vs. LoRA-FA at 43.0%), suggesting that algorithm choice does matter, just less than architecture choice. The paper does not test whether the relative ranking of PEFT methods (e.g., DoRA vs. LoRA) changes under different RL algorithms — this is an important missing robustness check, since the claim of "algorithmic invariance" is based only on standard LoRA's performance.

Learning Rate (Table 5): Two learning rates are compared for standard LoRA: 1 × 10⁻⁵ (baseline, 42.3% overall) and 5 × 10⁻⁶ (42.3% overall). The identical average masks individual benchmark differences: 5 × 10⁻⁶ does better on AIME24 (30.4% vs. 29.2%) and HMMT (13.9% vs. 14.4%), while 1 × 10⁻⁵ does better on AIME25 (23.3% vs. 18.2%). The paper reports that the optimal learning rate follows the scaling law LR = M_LoRA · (2000 / hidden_size)^(model_pow + LoRA_pow) from Schulman & Lab (2025). Notably, the paper only ablates learning rate for standard LoRA, not for other PEFT methods. If the optimal learning rate varies with adapter architecture (as seems plausible given that LoRA+ explicitly modifies learning rate ratios), then the paper's fixed-LR comparison may favor methods that happen to work well at 1 × 10⁻⁵.

Rank (Table 5): Standard LoRA is tested at ranks 1, 8, 16, and 32. The performance gradient is monotonic: rank 1 (40.5%) < rank 8 (42.3%) < rank 16 (43.9%) < rank 32 (42.5% — the apparent non-monotonicity at rank 32 is a discrepancy; the main result table reports 42.5% for rank 32, but the ablation table shows rank 16 achieving 43.9%. Without standard deviations, we cannot assess whether this is noise). The critical finding is that rank 1 (40.5%) performs barely above the base model (40.5%) — essentially no improvement, directly contradicting claims from prior work (Mukherjee et al., 2025) that "even Rank=1 adapters can complete RLVR tasks effectively." The paper's recommendation to "avoid extreme rank reduction" and "maintain a moderate rank" (r = 16 or 32) is well-supported.

PEFT Target Modules (implicit): All experiments target all linear modules ({q, k, v, o, gate, up, down}_proj), following Schulman & Lab (2025) and Wang et al. (2025b). The paper does not ablate target module selection (e.g., attention-only vs. all-linear). This is a reasonable default given prior work's validation, but it means we don't know whether the structural variant advantage (e.g., DoRA's magnitude-direction decoupling being beneficial) is specific to all-linear targeting or would hold under attention-only targeting as well.

Missing ablations that would have strengthened the paper:

PEFT method × RL algorithm interaction: Does DoRA still outperform LoRA under GRPO and Dr. GRPO, or is its advantage DAPO-specific? The paper claims algorithmic invariance but only tests this for standard LoRA.
PEFT method × learning rate interaction: Are the optimal learning rates for DoRA, AdaLoRA, MiSS the same as for standard LoRA? LoRA+ explicitly changes learning rate ratios, suggesting that LR sensitivity may vary by architecture.
PEFT method × training steps: The 1.5B models train for 1,024 steps. The training curves (Figure 1, right) show that some methods (DoRA) are still improving at step 1,024 while others (VeRA) have plateaued by step 250. Would the relative rankings change with longer training? The 7B model uses 8,192 steps, but only 4 methods are tested at this scale.
PEFT method × random seed: With only seed 42 tested and no standard deviations reported, we cannot distinguish genuine performance differences from run-to-run variance. For the 30-problem AIME benchmarks, a difference of a few correct answers can shift accuracy by 3–7 percentage points.

Critical Assessment

Claim 1: Structural variants consistently outperform standard LoRA. This claim is well-supported for the specific conditions tested. At 1.5B scale, DoRA (46.6%), AdaLoRA (44.2%), and MiSS (43.4%) all exceed LoRA (42.5%) — Table 3. At 7B scale, DoRA (55.0%) and LoRA+ (55.5%) exceed LoRA (54.8%) — Table 6. The direction is consistent across scales. However, the magnitude of the advantage shrinks at 7B (0.2–0.7 points vs. 1.4–4.1 points), and MiSS actually underperforms LoRA at 7B (53.4% vs. 54.8%). This suggests the "structural variants consistently outperform" claim must be qualified: the advantage is larger at smaller scales, and not all structural variants scale equally well. Additionally, the paper classes LoRA+ as an "initialization strategy" (since it modifies learning rates), yet LoRA+ achieves the best 7B performance (55.5%) — the broader claim that structural variants are the top performers is undermined by LoRA+ taking the lead at 7B. The categorization matters because the paper's prescriptive message ("use geometry-aware adapters like DoRA") doesn't fully capture the 7B results where an optimization-dynamics method (LoRA+) matches or exceeds DoRA.

A deeper weakness: DoRA's superiority is attributed to "magnitude-direction decoupling," but no ablation or analysis directly tests this attribution. DoRA makes two changes relative to LoRA — it decouples magnitude and direction, and it uses column-wise normalization (dividing by ||W₀ + BA||_c). Either change (or their interaction) could be responsible for the improvement. Without ablating these components separately, the mechanism remains speculative.

Claim 2: SVD-based initialization strategies suffer from spectral misalignment and fail catastrophically (PiSSA at 0.2%, MiLoRA at 18.0%). This claim is strongly supported by the empirical results (Table 3) and the spectral analysis (Figure 3). The collapse of PiSSA to 0.2% is unambiguous — no reasonable person would attribute this to noise or hyperparameter sensitivity. The mechanistic explanation (Figure 3, left and center) provides genuine insight into why the collapse occurs.

However, the paper does not test whether the failure is specific to the DAPO algorithm or would occur under other RLVR formulations. If PiSSA fails because of DAPO's specific gradient dynamics (asymmetric clipping, dynamic sampling), then the claim should be narrower. If it fails under all RLVR algorithms, that would be stronger evidence for the "fundamental misalignment" hypothesis. The paper tests algorithmic invariance only for standard LoRA, not for the failing methods.

Additionally, the MiLoRA analysis reveals that it achieves non-trivial performance on MATH500 (44.5%) and Minerva (63.4%) despite overall collapse to 18.0% (Table 3). This benchmark-dependent behavior — working partially on some benchmarks while failing completely on AIME/AMC — is not explained by the "spectral collapse" diagnosis, which would predict uniformly poor performance. This asymmetry suggests that the failure mechanism may be more nuanced, possibly interacting with problem characteristics (difficulty, required reasoning depth, problem diversity) in ways the spectral analysis doesn't capture.

Claim 3: There exists an expressivity floor — extreme parameter reduction bottlenecks reasoning capacity. This claim is well-supported, but the precise floor location is unclear. The paper shows a sharp drop between methods with matrix-level trainable capacity (LoRA-FA at ~0.8% trainable parameters, achieving 43.0%) and methods with only vector-level capacity (VeRA at 0.003%, achieving 40.7%; IA3 achieving 22.3%) — Table 4. However, the paper does not test intermediate compression levels. MiSS (0.99% parameters, 43.4%) sits between LoRA and VeRA in parameter count but maintains strong performance, suggesting the floor is somewhere between 0.003% and 0.99%. Without testing methods in this gap (e.g., VeRA with higher internal rank, or LoRA-FA with smaller frozen A matrix), the floor is identified categorically rather than quantitatively.

The claim that LoRA-FA (freezing A, training only B) outperforms standard LoRA is a potentially important finding — it suggests that the random projection A provides sufficient expressivity, and training A may even be counterproductive under RLVR. But this result is reported without standard deviations, and on a single random seed (42). Since A is randomly initialized, LoRA-FA's performance may be sensitive to the specific random draw. Multiple seeds (or multiple A initializations) would be needed to establish that LoRA-FA's advantage is systematic rather than fortunate.

A missing experiment: what happens when you freeze B and train only A? This would test whether the benefit of LoRA-FA is specifically about which matrix is frozen, or about halving the parameter count regardless of which half. If freezing B also works, the mechanism might be parameter count reduction rather than something specific about the A-to-B information flow.

Claim 4: The DoRA advantage surpasses full-parameter fine-tuning. DoRA at 46.6% exceeds Full at 44.9% overall (Table 3). This is the paper's most striking single result. But it requires careful qualification:

Benchmark dependency: DoRA's advantage is uneven — large on AIME24 (39.0% vs. 34.9%) and AIME25 (28.8% vs. 23.8%), modest on AMC (71.9% vs. 68.8%), narrow on MATH500 (75.8% vs. 74.8%) and Minerva (90.0% vs. 88.6%). On HMMT, Full actually leads (13.5% vs. DoRA's 13.4%). The "surpasses full-parameter fine-tuning" claim is driven primarily by AIME performance, which carries substantial weight in the overall average despite having only 30 problems. The statistical reliability of a 30-problem benchmark difference is questionable without confidence intervals.
Training budget parity: DoRA and Full are compared at identical training steps (1,024). If Full requires more steps to converge (as is plausible given the larger parameter space), then the comparison favors DoRA by stopping before Full reaches its asymptotic performance. The training curves (Figure 1, right) show Full still improving at step 1,024, though the rate of improvement has slowed. Longer training might close or reverse the gap.
The 7B results don't replicate the "surpasses" claim: At 7B (Table 6), DoRA (55.0%) and LoRA+ (55.5%) both outperform LoRA (54.8%), but the paper does not report Full Fine-Tuning at 7B scale. Without the Full baseline, we cannot assess whether DoRA still surpasses full-parameter training at larger scale, or whether the advantage is specific to the 1.5B regime where parameter redundancy is relatively higher.
Mechanism is underspecified: The paper attributes DoRA's advantage to "magnitude-direction decoupling," but doesn't demonstrate that this decoupling actually causes the observed performance difference. An ablation comparing DoRA with and without the decoupling (e.g., fixing m to the pre-trained magnitudes, making DoRA equivalent to LoRA with column normalization) would test this attribution directly.

Claim 5: The relative PEFT method rankings are invariant to RL algorithm choice. The paper states that "the performance of LoRA and other PEFT methods remains consistent across [GRPO, DAPO, Dr. GRPO], with no statistically significant deviation in reasoning accuracy" (Section 3.2). This claim is weakly supported. Only standard LoRA is tested across algorithms (Table 5: DAPO 42.5%, Dr. GRPO 42.0%, GRPO 40.5%). The phrase "and other PEFT methods" appears to extrapolate from LoRA's modest sensitivity to a general claim about all PEFT methods. But we don't know whether PiSSA fails under GRPO as catastrophically as under DAPO, or whether DoRA's advantage holds under Dr. GRPO's de-biased advantage estimation. The invariant behavior of the worst-performing method or the best-performing method may differ from LoRA's middle-of-the-pack invariance.

Overall experimental strengths:

Comprehensive coverage: 12+ PEFT methods, two model scales, six benchmarks, multiple ablations. This is genuinely the most extensive PEFT-RLVR comparison available.
Mechanistic depth: the spectral analysis (Figure 3) provides explanatory insight beyond leaderboard rankings.
Practical infrastructure: the use of open-source tools (TRL, vLLM, DeepSpeed) and release of code/checkpoints/logs enables replication.
Clear recommendations: the paper doesn't just rank methods — it tells practitioners what to use (DoRA) and what to avoid (PiSSA, extreme compression).

Overall experimental weaknesses:

No standard deviations or confidence intervals, making small performance differences uninterpretable.
Single model family (DeepSeek-R1-Distill-Qwen), single domain (mathematical reasoning), single RLVR paradigm (GRPO-family). Generalizability is unknown.
The 7B scaling experiment omits Full Fine-Tuning and includes only 4 PEFT methods, making it a partial validation rather than a full replication.
Critical mechanistic claims (DoRA's decoupling as the cause of superiority, MiLoRA's collapse mechanism) are supported by correlation (spectral analysis) rather than causal manipulation (ablations that add/remove the proposed mechanism).
The difficulty estimation framing from prior sections — that prompt difficulty determines optimal strategy — is not applied here. The paper treats all math problems as a homogeneous distribution, which may mask difficulty-dependent effects (e.g., maybe DoRA's advantage is largest on hard problems, or PiSSA partially works on easy problems).

6. Limitations and Trade-offs

Difficulty Estimation Cost Is Unaccounted for and Potentially Dominant

The paper's central finding — that structural variants like DoRA outperform standard LoRA under RLVR — is established through a benchmark that carefully controls training budgets (identical steps, identical generation configurations). However, the paper does not account for a cost that practitioners face at deployment time: determining which PEFT method to use for their specific model, task, and RLVR configuration. The paper's own results demonstrate that this choice is consequential — the gap between the best method (DoRA, 46.6%) and the default (LoRA, 42.5%) is 4.1 percentage points, and the gap to a catastrophically bad choice (PiSSA, 0.2%) is 46.4 points. But the paper provides no guidance on how a practitioner could determine, without running the full 12-method benchmark themselves, which method will work for their setup.

This is not merely a matter of "future work." The paper's core prescriptive claim is that practitioners should "move beyond standard LoRA and adopt geometry-aware adapters like DoRA." But this prescription is based on experiments on exactly two model sizes from a single model family (DeepSeek-R1-Distill-Qwen), on a single task domain (mathematical reasoning), under a single RLVR algorithm variant (DAPO, with ablations only for standard LoRA). A practitioner working with a different base model (e.g., Llama, Gemma, Qwen-base rather than R1-Distill), a different reasoning domain (e.g., code generation, scientific reasoning, multi-step planning), or a different RLVR implementation would have no way of knowing whether DoRA's advantage transfers without replicating the paper's evaluation — which requires running full RLVR training for a dozen methods, each consuming thousands of GPU-hours. The cost of this replication, if amortized across all practitioners who might adopt the paper's recommendations, dwarfs the training cost of any single method.

The paper does not directly acknowledge this cost-of-discovery limitation. The authors position their work as "a definitive guide for advocating for more exploration for parameter-efficient RL methods" (abstract) and "a clear roadmap for navigating the PEFT-RL landscape" (Section 5). A genuine roadmap would include heuristics or diagnostic procedures for selecting methods without full replication — e.g., whether a method's performance on a small-scale pilot run (short training, subset of data) predicts its full-scale performance, or whether the spectral analysis diagnostic (Figure 3) can be computed early in training to identify methods likely to fail. None of this is provided.

The consequence is that the paper's practical value for a new setting is limited to a high-stakes bet on transferability — adopt DoRA and hope that the DeepSeek-R1-Distill + MATH results generalize, or invest the compute to run the benchmark yourself, at which point the efficiency gains from choosing a better PEFT method must be weighed against the cost of discovering which method is better. The paper does not measure, or even estimate, the cost of method discovery relative to the cost of method execution.

Single Model Family and Single Task Domain Leave Transferability Unknown

All experiments in the paper use exactly two base models — both from the DeepSeek-R1-Distill-Qwen family (1.5B and 7B) — and exactly one task domain (mathematical reasoning, evaluated across six benchmarks that all test the same underlying capability). The paper does not test, and therefore cannot establish, whether the PEFT method rankings generalize to:

Different base model architectures or training recipes: DeepSeek-R1-Distill models undergo a specific SFT cold-start phase followed by distillation from a larger RL-trained model. Their weight matrices, spectral properties, and the distribution of where reasoning capability is "stored" across layers may differ systematically from models trained with different recipes (e.g., models that undergo RLVR directly from a base checkpoint without distillation, or models from different architecture families like Llama or Gemma). A PEFT method that works well by adapting specific layers or spectral components in DeepSeek-R1-Distill might target functionally different structures in another model.
Different reasoning domains: Mathematical reasoning has specific properties — answers are verifiable via symbolic computation, reasoning follows logical deduction chains, and the output format is highly structured (\boxed{}). Code generation, scientific reasoning, multi-step planning, or open-ended QA may have different reward sparsity patterns, different optimal reasoning lengths, and different requirements for what "circuits" need adaptation. RLVR on code generation, for instance, uses execution-based rewards (passing unit tests) that have different noise characteristics and difficulty distributions than math answer verification. A structural variant like DoRA might provide less benefit, or a different variant might emerge as optimal.
Different RLVR algorithms beyond GRPO-family: The paper tests GRPO, DAPO, and Dr. GRPO, all of which share the same core design (group-based advantage estimation, ratio clipping). Other RLVR approaches — such as those using learned value functions, different advantage estimation schemes, or KL-constrained policy optimization closer to standard PPO — might impose different gradient distributions that interact differently with adapter architectures.

The scaling results from 1.5B to 7B (Section 3.3, Table 6) provide partial evidence for transferability across model sizes within the same family. DoRA and LoRA+ still outperform LoRA at 7B, supporting the directional claim. However, the ranking within structural variants shifts (LoRA+ edges ahead of DoRA), and MiSS falls behind LoRA at 7B after being competitive at 1.5B. This within-family inconsistency at only a ~4.7× parameter scale increase suggests that rankings may not be stable even under moderate scaling, let alone across model families or domains. The paper acknowledges the need to "extend efficient RLVR into multimodal environments, multi-turn interactions, and asynchronous RL settings" (Section 4), but does not frame the current single-domain, single-family scope as a limitation on the strength of its prescriptive conclusions.

The consequence is that the paper's recommendation to "move beyond standard LoRA" is well-supported for the specific setting tested, but its recommendation of which specific variant to adopt (DoRA) rests on evidence from a narrow slice of the possible design space. A practitioner working outside that slice — different model, different domain, different RL algorithm — cannot confidently apply the specific ranking, only the general principle that "the default LoRA is probably suboptimal and you should evaluate alternatives." The paper's own results suggest that the wrong choice among alternatives can be catastrophic (PiSSA at 0.2%), making the absence of transferability evidence particularly consequential — adopting a method based on the paper's recommendations without verification in a new setting risks not just suboptimality but complete training failure.

No Statistical Significance Measures Undermine Confidence in Modest Performance Differences

The paper reports all results as point estimates — single accuracy percentages without standard deviations, confidence intervals, or p-values. Table 5 explicitly states "std dev removed for clarity." This is consequential because many of the paper's key comparative claims rest on modest absolute differences whose reliability cannot be assessed from the reported data alone.

Consider the claim that LoRA-FA (43.0%) outperforms standard LoRA (42.5%) — a 0.5 percentage point gap. At 1.5B scale with a test set of 500 questions (MATH500) plus smaller benchmarks (AIME at 30 questions, AMC at 40, HMMT at 30), the overall accuracy is a weighted composite where a single additional correct answer on a 30-question benchmark shifts that benchmark's accuracy by 3.3 percentage points. Without variance estimates, we cannot determine whether 0.5 points represents a genuine systematic advantage or run-to-run noise from sampling and optimization stochasticity. This matters because the paper interprets LoRA-FA as evidence that "freezing A" is beneficial — a non-obvious result that, if true, has implications for adapter design. But if the difference is within noise, that interpretation is unfounded.

The problem is most acute for the paper's headline result: DoRA (46.6%) surpassing Full Fine-Tuning (44.9%) by 1.7 percentage points. The paper's own Table 3 shows that this gap is not uniform across benchmarks. On HMMT (30 questions), Full (13.5%) actually exceeds DoRA (13.4%). On MATH500 (500 questions), the gap is 1.0 point. The overall average is pulled upward by AIME24 (DoRA 39.0% vs. Full 34.9%, a 4.1-point gap on 30 questions). With only 30 questions, the AIME24 result has inherently high variance: each correct answer is worth 3.3 percentage points. If DoRA happened to answer 1–2 more AIME24 questions correctly due to optimization noise rather than systematic advantage, the overall ranking could flip. The paper's conclusion that DoRA "surpasses full-parameter fine-tuning" (abstract, Section 3.1, Section 5) is presented as a robust finding, but without variance estimates, we cannot distinguish a genuine capability improvement from a favorable draw on a small set of high-weight benchmarks.

The absence of error bars also makes it impossible to assess whether the 7B results replicate the 1.5B rankings with statistical significance. At 7B (Table 6), DoRA (55.0%) leads LoRA (54.8%) by 0.2 points, and LoRA+ (55.5%) leads DoRA by 0.5 points. Are these differences distinguishable from noise? We cannot tell. The paper claims that "the relative performance hierarchy remains largely consistent" (Section 3.3), but if the 7B differences are within run-to-run variance, the only consistent finding is that the top methods are roughly tied — a weaker claim than the paper makes.

The fixed random seed (42) is a double-edged sword. It ensures reproducibility of the exact numbers reported, which is valuable. But it means all variance from different random initializations (adapter matrices, data ordering, rollout sampling) is collapsed into a single trajectory. Methods that happen to work well with seed 42's specific initialization and data order may look systematically better than methods that would excel under different seeds. This is especially concerning for methods with random initialization (all LoRA variants initialize A randomly) and for LoRA-FA, where the frozen A is a single random draw — if a particularly good or bad A was drawn for seed 42, the reported result would not reflect expected performance over multiple initializations.

The paper implicitly relies on consistency across multiple benchmarks and two model scales as a substitute for formal statistics — if DoRA beats LoRA on 5 out of 6 benchmarks at 1.5B and on 3 out of 6 at 7B, that pattern is somewhat robust to benchmark sampling. But this is a weak form of robustness check, particularly when the individual benchmark differences are small and the benchmarks vary dramatically in size (30 to 500 questions) and weight in the overall average.

The Claim of Algorithmic Invariance Is Tested Only for Standard LoRA

Section 3.2 reports that standard LoRA achieves comparable performance under GRPO (40.5%), DAPO (42.5%), and Dr. GRPO (42.0%), and the paper generalizes this to claim "a remarkable degree of algorithmic invariance" and that "the effectiveness of parameter efficient methods in this domain is driven by the fundamental dynamics of learning from sparse, verifiable rewards, rather than being contingent on specific loss function nuances." From this, the paper extrapolates that "optimal PEFT choices like DoRA are likely transferable across the broader landscape of RLVR algorithms."

This extrapolation is untested. The paper does not evaluate DoRA, AdaLoRA, MiSS, PiSSA, or any PEFT method other than standard LoRA under GRPO or Dr. GRPO. The inference that because standard LoRA shows modest sensitivity to algorithm choice, the relative ranking of PEFT methods will be preserved, assumes that all PEFT methods share the same sensitivity profile. This assumption is questionable given the paper's own mechanistic analysis.

The paper demonstrates that PiSSA and MiLoRA fail under DAPO because of spectral misalignment with RLVR's gradient distribution (Section 3.1, Finding 3). But DAPO modifies the gradient through asymmetric clipping ( $\epsilon_{\text{high}} = 0.28$ ) and dynamic sampling (filtering prompts with uniform rewards). Both of these modifications change the effective gradient that reaches the adapter parameters — asymmetric clipping changes which tokens get gradient signal by allowing larger probability increases for low-probability tokens, and dynamic sampling removes entire gradient contributions from certain prompts. Under a different algorithm like GRPO (symmetric clipping, no dynamic sampling), the gradient distribution may differ in ways that either mitigate or exacerbate the spectral misalignment. PiSSA collapses under DAPO — but under GRPO with symmetric clipping, the gradient signal might distribute differently across the singular value spectrum, potentially allowing some learning. We simply don't know, because the experiment wasn't run.

Similarly, DoRA's advantage over LoRA is attributed to magnitude-direction decoupling providing flexibility for RLVR's off-principal gradient dynamics. But if Dr. GRPO's de-biased advantage estimation changes the gradient distribution (removing difficulty bias and response-length normalization), the specific benefit of magnitude-direction decoupling might increase, decrease, or reverse. The paper's LoRA-only test of algorithmic sensitivity cannot detect such interactions.

The consequence is that the paper's strongest prescriptive claim — "use DoRA for RLVR" — is validated only under DAPO, a specific RLVR variant. A practitioner using a different RLVR algorithm (and the GRPO family has many variants beyond the three tested: RLOO, Reinforce-Leave-One-Out, PPO with learned value functions) receives a recommendation that the paper's own evidence does not fully support. The paper partially acknowledges this gap in Section 4 (Future Work), noting plans to "rigorously test R1-Zero-like cold-start paradigms and diverse model architectures under prolonged training steps," but this is framed as future work rather than a limitation on the current conclusions.

The 7B Validation Is Partial and Omits the Full-Parameter Baseline

The paper's scaling experiment (Section 3.3, Table 6) tests four PEFT methods at 7B scale: LoRA, DoRA, MiSS, and LoRA+. Conspicuously absent is Full-Parameter Fine-Tuning — the critical baseline against which DoRA's headline claim ("surpasses full-parameter fine-tuning") was established at 1.5B. The paper provides no explanation for this omission.

This matters because the paper's primary prescriptive message is that practitioners should use DoRA instead of both standard LoRA and full-parameter training. At 1.5B, this recommendation is supported by DoRA outperforming both (46.6% vs. 42.5% for LoRA and 44.9% for Full). At 7B, we can only verify that DoRA outperforms LoRA (55.0% vs. 54.8%), not that it outperforms full-parameter training. If full-parameter training at 7B achieves, say, 57% — entirely plausible given the larger model's greater capacity for reasoning acquisition — then the recommendation to use DoRA would be leaving substantial performance on the table for practitioners who can afford full-parameter training.

The omission is particularly significant because the relative benefit of parameter-efficient methods often changes with model scale. Smaller models (1.5B) have lower intrinsic capacity; the constraints imposed by a low-rank adapter may be less binding because the model has fewer degrees of freedom to exploit anyway. Larger models (7B) have more capacity to form specialized circuits; restricting updates to a low-rank subspace may impose a more meaningful expressivity bottleneck relative to full-parameter training. The paper's own results hint at this: at 1.5B, DoRA beats Full by 1.7 points; if at 7B, Full beats DoRA by a similar or larger margin, the prescription would need to be scale-dependent — "use DoRA at small scales where parameter redundancy is high; use Full at larger scales."

Additionally, the 7B experiment tests only 4 of the 12+ methods evaluated at 1.5B. PiSSA, MiLoRA, AdaLoRA, LoRA-FA, VeRA, IA3, rsLoRA, and LN Tuning are all omitted. The paper presents the 7B results as confirming that "the relative performance hierarchy remains largely consistent" (Section 3.3), but with only 4 methods tested, we cannot assess whether the catastrophic failures (PiSSA at 0.2%, IA3 at 22.3%) still occur at scale, whether the expressivity floor shifts (does VeRA become more or less competitive at 7B?), or whether the SVD-initialization collapse is scale-specific. The paper's own spectral analysis (Figure 3) was conducted on a single layer of the 1.5B model; the spectral properties of larger models may differ, potentially changing how SVD-based initializations interact with RLVR gradients.

The paper frames the 7B experiment as a "scaling validation" (Section 3.3 title), but a validation that omits the most critical baseline and 8 of 12 methods is a partial check at best. A practitioner considering the paper's recommendations for 7B-or-larger models receives directional guidance (structural variants probably still help) but no evidence on the key question: relative to full-parameter training, how much performance am I sacrificing, if anything, by using a PEFT method?

No Causal Evidence for the Proposed Mechanisms Behind Method Performance

The paper makes mechanistic claims about why certain methods succeed or fail: DoRA excels because "magnitude-direction decoupling" aligns with RLVR's optimization dynamics (Section 3.1, Finding 1); PiSSA and MiLoRA fail because of "spectral misalignment" between their SVD-based initialization and RLVR's off-principal gradient distribution (Section 3.1, Finding 3); extreme compression methods fail because they create an "expressivity floor" below which "the adapter lacks the degrees of freedom to rewire reasoning behaviors" (Section 3.1, Finding 2). These explanations are presented as conclusions, not hypotheses, despite being supported entirely by correlational evidence.

The spectral analysis (Figure 3) demonstrates that full-parameter RLVR updates are distributed uniformly across singular value components, and that MiLoRA's updates collapse to a principal-component spike despite off-principal initialization. This is strong descriptive evidence — it shows what happens — but it does not establish causation. The paper infers that the spectral collapse causes the poor performance, but an alternative interpretation is equally consistent with the data: MiLoRA's performance is poor for unrelated reasons (e.g., poor gradient flow through very small initial adapter weights, independent of which spectral components are involved), and the spectral collapse is a symptom rather than a cause — a downstream consequence of the same initialization problem rather than the mechanism of failure itself.

The paper does not test the causal link through intervention. A causal test would manipulate the proposed mechanism and observe whether performance changes as predicted. For the spectral misalignment hypothesis, such tests could include:

For PiSSA: Initialize the adapter using the principal components but add a regularization term that penalizes updates aligned with principal directions, forcing the adapter to explore off-principal subspaces. If spectral misalignment causes the collapse, this regularization should rescue performance.
For MiLoRA: Scale up the initialization magnitude of the minor-component adapter (multiply $A$ and $B$ by a constant factor so that $\|\Delta W^0\|_F$ is non-negligible) while preserving the off-principal orientation. If the "vanishing initialization" mechanism (Section 3.1, Equation 3) is the root cause, this intervention should prevent the collapse back to principal components and rescue performance. The paper notes that MiLoRA fails because $\|\Delta W^0\|_F \approx 0$ , making the initialization "numerically non-existent" — but it never tests whether giving MiLoRA a non-negligible initialization (while keeping the off-principal orientation) fixes the problem.
For DoRA: Ablate the magnitude-direction decoupling by fixing the magnitude vector $m$ to the pre-trained weight norms (making the forward pass equivalent to standard LoRA with column normalization) and measuring whether the performance advantage disappears. If DoRA's advantage is specifically due to decoupling, removing it should reduce performance to LoRA levels.

For the expressivity floor claim, a causal test would systematically vary the expressivity of the adapter while keeping other factors constant — for example, by testing LoRA at increasingly low ranks (1, 2, 4, 8, 16, 32) to map out the continuous performance-expressivity curve and identify where the "floor" actually sits, rather than comparing categorically different methods (LoRA vs. VeRA vs. IA3) that differ in many ways beyond trainable parameter count.

The paper's ablation studies (Section 3.2) test robustness to hyperparameters (batch size, learning rate, rank) but do not test these mechanistic hypotheses. The rank ablation for standard LoRA partially addresses the expressivity floor (showing that rank 1 performs worse than rank 32), but this is within a single method family and doesn't isolate whether the performance drop is due to reduced expressivity or some rank-specific optimization difficulty.

The consequence is that the paper's explanations, while plausible and well-articulated, are interpretations rather than established mechanisms. A practitioner who adopts DoRA because of "magnitude-direction decoupling" is betting on an untested causal claim. If the true reason for DoRA's advantage is something else — say, the column-wise normalization ( $\|W_0 + BA\|_c$ ) providing better gradient scaling, or the Rectified Kaiming Uniform initialization of A providing more stable early training — then the paper's conceptual framework for why structural variants work may misdirect future research toward decoupling when the real leverage point is normalization or initialization. The paper does not acknowledge this interpretative uncertainty or frame its mechanistic claims as hypotheses requiring causal validation.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper initiates a regime shift in how the community thinks about PEFT for post-training. Before this work, the default assumption—implicit in almost all RLVR pipelines—was that PEFT methods validated under SFT would transfer to RLVR, and that standard LoRA was the safe default choice. The paper systematically demolishes both assumptions. More importantly, it provides the diagnostic toolkit (spectral analysis) to understand why the transfer fails, transforming PEFT-RLVR from a folk-empirical guessing game into a hypothesis-driven engineering discipline.

The magnitude of the shift is best understood by what the paper makes obsolete: the practice of using standard LoRA for RLVR without justification. When PiSSA collapses to 0.2% accuracy under RLVR after being a well-regarded SFT method, the lesson is not just "don't use PiSSA for RLVR"—it's that the SFT validation certificate has zero predictive validity for RLVR performance. Any PEFT method, regardless of its SFT track record, must be re-evaluated under the target optimization regime. This is a methodological correction comparable to the recognition in the 2010s that ImageNet performance didn't predict medical imaging performance—different data distributions demand re-validation.

The paper resolves a specific and practically important contradiction: prior work (Schulman & Lab, 2025; Wang et al., 2025b) showed that LoRA can work for RLVR, but offered no guidance on whether LoRA was optimal. Simultaneously, the broader PEFT literature had produced dozens of LoRA variants claiming improvements, but all were validated under SFT. The paper reconciles these threads by demonstrating that some variants (DoRA, AdaLoRA) dramatically outperform LoRA under RLVR, while others (PiSSA, MiLoRA) catastrophically fail—and that this divergence is predictable from first principles once you understand RLVR's off-principal gradient dynamics. The field can now stop treating PEFT-RLVR as a single binary choice (LoRA vs. Full) and start reasoning about a spectrum of adapter architectures with known RLVR-compatibility profiles.

The paper also reframes what counts as a "good" PEFT method for RLVR. Under SFT, the evaluation criteria were convergence speed, final accuracy, and parameter count. Under RLVR, the paper shows that spectral flexibility—the adapter's ability to accommodate updates distributed uniformly across singular value components rather than concentrated on principal directions—is a first-class requirement that can override all others. A method like PiSSA that is fast, parameter-efficient, and accurate under SFT becomes literally the worst possible choice under RLVR because it imposes an incompatible spectral prior. This elevates spectral analysis from an academic diagnostic to a practical screening tool: before committing to a full RLVR training run, test whether your chosen adapter's update distribution can match the uniform spectral profile that RLVR demands.

Research directions that become more attractive after this work:

RLVR-native PEFT design: explicitly designing adapter architectures optimized for RLVR's gradient properties (off-principal, sparse, binary-reward-driven), rather than adapting SFT methods.
Spectral diagnostics as standard practice: computing weight update spectra early in training as a canary for incompatibility, following the methodology in Figure 3.
Cross-regime PEFT benchmarking: extending the paper's comparison framework to other post-training paradigms (RLHF with learned rewards, DPO, iterative self-play) to map out which regimes share RLVR's spectral properties.

Research directions that become less attractive:

Direct porting of SFT-PEFT methods to RLVR without re-validation: the paper shows this is actively dangerous.
Pushing extreme parameter efficiency (VeRA, IA3, Rank-1) for reasoning tasks: the expressivity floor (Finding 2) suggests a hard lower bound below which reasoning acquisition fails regardless of training budget.
SVD-based initialization for RLVR without a mechanism to maintain off-principal constraints: the MiLoRA analysis (Figure 3) demonstrates that good theoretical intentions (initialize in the minor subspace) fail without a mechanism to keep the updates there against dominant principal gradients.

The paper is not a paradigm shift in the Kuhnian sense—it doesn't introduce a new training algorithm or a new adapter architecture. It is better characterized as a foundational correction: it identifies that the field has been systematically using the wrong reference class (SFT) for PEFT-RLVR decisions, provides the evidence for why this matters (4.1 percentage point gap between best and default, 46.4 point gap between best and worst), and offers a mechanistic framework (spectral analysis) for making better decisions going forward. The correction is overdue and consequential.

Follow-Up Research This Work Enables

Causal validation of DoRA's advantage through component ablation. The paper attributes DoRA's superiority to magnitude-direction decoupling (Section 3.1, Finding 1), but this is a correlational claim. A direct test: implement DoRA with the magnitude vector $m$ frozen to the pre-trained weight norms (removing the decoupling while preserving the column-wise normalization $||W_0 + BA||_c$ ), and compare against standard DoRA under identical RLVR conditions. If frozen-m DoRA performs at LoRA levels (42.5% rather than 46.6%), the decoupling is causally responsible. If it performs near DoRA levels, the normalization (not the decoupling) drives the advantage. A second ablation: remove the column-wise normalization from DoRA (making it equivalent to LoRA with a learned per-output-dimension scale factor) to isolate the normalization component. A strong study would test all four combinations—standard LoRA, LoRA + column norm, DoRA with frozen m, DoRA—on at least two benchmarks (MATH500 and AIME24) to produce a 2×2 factorial decomposition of where DoRA's 4.1-point advantage over LoRA actually comes from.

Scaling the expressivity floor with model capacity to find the breakpoint. The paper identifies an expressivity floor categorically (matrix-level adapters work, vector-level adapters fail) but doesn't map the boundary continuously. A targeted experiment: train standard LoRA at ranks r = 1, 2, 3, 4, 6, 8, 12, 16, 24, 32 on MATH500 under RLVR, and plot both accuracy and the spectral distribution of weight updates (as in Figure 3) against rank. The hypothesis to test: there exists a critical rank r* below which the adapter cannot accommodate the spectral breadth of RLVR updates, causing a discontinuous accuracy drop. Comparing r* across 1.5B and 7B model scales would test whether larger models have a higher expressivity floor (they need higher rank to capture the same fraction of the relevant update subspace) or a lower one (their pre-existing circuits are richer, so fewer adapter degrees of freedom suffice). If r* scales with model dimension, the paper's rank-32 recommendation for 1.5B may be insufficient for 7B or 70B models, and a scaling law for adapter rank under RLVR would be a natural extension.

Testing method-algorithm interaction across the full PEFT suite. The paper claims "algorithmic invariance" based on standard LoRA's modest sensitivity to GRPO vs. DAPO vs. Dr. GRPO (Table 5: 40.5% → 42.5% → 42.0%). But the paper never tests whether the ranking of PEFT methods is algorithm-invariant. A critical but tractable experiment: evaluate DoRA, LoRA, PiSSA, and IA3 under all three algorithms (GRPO, DAPO, Dr. GRPO) on MATH500 and AIME24. The hypothesis to falsify: DoRA's advantage holds under all three (supporting the paper's extrapolation), or PiSSA's collapse is DAPO-specific (challenging the "fundamental misalignment" claim). If PiSSA achieves non-trivial accuracy under GRPO with symmetric clipping (since symmetric clipping may produce a gradient distribution closer to SFT's, where PiSSA works), the paper's mechanistic explanation needs refining—the failure is not purely about RLVR vs. SFT but about specific gradient properties of DAPO's asymmetric clipping that exacerbate spectral bias. This would be a negative result that sharpens the boundary conditions of the paper's findings.

Spectral analysis as an early-stopping diagnostic across all 12+ methods. The paper's spectral analysis (Figure 3) is conducted post-hoc on a single layer after full training. A more practically useful version: compute the spectral distribution of weight updates at regular intervals (every 50–100 steps) during RLVR training for each PEFT method, and test whether early-stage spectral patterns predict final performance. Specific prediction: methods whose update distribution at step 200 still shows a principal-component spike (like MiLoRA's in Figure 3, blue line) will never recover and will finish with poor accuracy; methods that quickly develop a uniform spectral profile (like Full Fine-Tuning in Figure 3, green line) will converge to high accuracy. If this holds, spectral analysis at ~20% of the training budget could serve as a cheap screening procedure: test a candidate PEFT method for 200 steps, check its spectral profile, and abandon it (saving 80% of the training cost) if it shows spectral collapse. This transforms the paper's descriptive diagnostic into a prescriptive tool. A strong study would compute the correlation between spectral-uniformity-at-step-200 and final-accuracy-at-step-1024 across all 12+ methods and at least two model scales.

Cross-model-family replication with a unified spectral baseline. All results are on DeepSeek-R1-Distill-Qwen. A direct replication using Llama-3.2-3B (or another architecture family) with identical RLVR training and evaluation would test whether the paper's findings are specific to the Qwen weight structure or generalize across model families. The critical measurement: compute the pre-trained weight spectra ( $\sigma_1, \sigma_2, \ldots$ ) for corresponding layers in DeepSeek-R1-Distill-Qwen and Llama-3.2, and test whether models with steeper singular value decay (larger $\sigma_1 / \sigma_{\text{tail}}$ ratio) are more susceptible to SVD-based initialization failure. If DeepSeek-R1-Distill-Qwen has unusually steep spectral decay (because distillation amplifies principal components), PiSSA and MiLoRA might fail more dramatically than they would on a model with flatter spectra, meaning the paper's "catastrophic failure" finding is a worst-case rather than a universal result.

Rescued MiLoRA: testing whether initialization magnitude amplification prevents spectral collapse. The paper's mechanistic explanation for MiLoRA's failure is that $\|\Delta W^0\|_F \approx 0$ makes the off-principal initialization "numerically non-existent," allowing the gradient to immediately reorient updates toward principal components (Section 3.1, Equation 3). A direct test of this mechanism: train MiLoRA with the minor-component adapter scaled by a constant factor $c > 1$ (i.e., $A = c \cdot U_{[:,r:]} S_{[r:,r:]}^{1/2}$ , $B = c \cdot S_{[r:,r:]}^{1/2} V_{[:,r:]}^\top$ ) so that $\|\Delta W^0\|_F$ is comparable to standard LoRA's random initialization magnitude. If scaled MiLoRA avoids spectral collapse and achieves competitive accuracy, the paper's diagnosis is confirmed and a simple fix exists—MiLoRA's intent was correct, its execution was numerically fragile. If scaled MiLoRA still collapses, the failure mechanism is deeper than the paper proposes (perhaps minor singular vectors are inherently unstable as adaptation bases regardless of initialization magnitude). Either outcome advances understanding beyond the current paper.

Practical Applications and Downstream Use Cases

Cost-efficient RLVR post-training for small labs and individual researchers. The paper demonstrates that DoRA with rank 32 achieves 46.6% average accuracy while training only 1.55% of parameters, exceeding full-parameter training's 44.9% (Table 3). For a researcher with a single 8-GPU node, this is the difference between feasible and infeasible: full-parameter RLVR on a 7B model with AdamW requires roughly 56 GB for model weights (7B × 2 bytes for fp16) plus ~112 GB for optimizer states (7B × 4 bytes × 2 moments × 2 for master weights in fp32), totaling ~168 GB before activations and rollout batches. PEFT-RLVR with DoRA collapses the optimizer state to ~2.6 GB (1.55% of 168 GB), fitting comfortably on a single GPU. The paper's specific configuration—all linear modules, rank 32, DAPO with clip-higher at 0.28, 8 rollouts per prompt—is a directly deployable recipe that any team can adopt using the released code and checkpoints. The 4.1 percentage point gain over standard LoRA (46.6% vs. 42.5%) is effectively free in compute terms (identical training FLOPs), making the switch from LoRA to DoRA a pure accuracy win with no efficiency tradeoff for the specific setting tested.

Batch inference for self-improvement data generation pipelines. When using LLMs to generate training data through rejection sampling or STaR-style self-improvement (Zelikman et al., 2022), the quality of generated solutions determines the quality of the resulting fine-tuned model. The paper's expressivity floor finding (Table 4, LoRA-FA at 43.0% vs. VeRA at 40.7%) provides a concrete guideline: for data generation where reasoning correctness matters, do not use vector-level adapters (VeRA, IA3) regardless of their parameter efficiency—the 2.3-point accuracy gap between LoRA-FA and VeRA means 2.3% fewer correct training examples, which compounds over iterative self-improvement rounds. The paper also shows that LoRA-FA (freezing A, training only B) matches or slightly exceeds standard LoRA, meaning the data generation pipeline can halve its per-model checkpoint storage (no need to store optimizer states for A) without sacrificing example quality. For a pipeline generating 100k training examples across 10 model versions, this saves gigabytes of storage and simplifies version management.

On-device or edge-deployment RLVR for personalized reasoning models. The paper demonstrates that MiSS achieves 43.4% accuracy training only 0.99% of parameters (Table 4), providing the strongest accuracy-per-parameter ratio among methods that exceed the base model (40.5%) by a meaningful margin. In a scenario where a base reasoning model is deployed on-device and periodically fine-tuned on user-specific math problems (e.g., an educational app that adapts to a student's error patterns), MiSS offers the best tradeoff: the adapter delta is only 0.99% of the model size, meaning it can be downloaded over a cellular connection in seconds and merged into the base weights with minimal on-device computation. The paper's observation that MiSS trails DoRA by 3.2 points but trains 36% fewer parameters is a concrete Pareto frontier point—practitioners can choose between maximum accuracy (DoRA at 1.55% parameters) and maximum download/merge efficiency (MiSS at 0.99% parameters) with quantified tradeoffs.

Verifier-guided RLVR where adapter choice depends on reward signal quality. The paper's reward mechanism is binary and deterministic: correct final answer → 1, else → 0. In settings where the reward signal is noisier—e.g., learned reward models for open-ended generation, or execution-based rewards for code that pass unit tests probabilistically—the gradient distribution will be less structured than in pure mathematical reasoning. The paper's spectral analysis framework (Figure 3) suggests a practical diagnostic: if the reward is noisy, the gradient will be less concentrated on any specific spectral component, making the "uniform distribution" requirement for adapter compatibility more stringent. This implies that structural variants like DoRA (which the paper shows accommodate uniform spectral updates) become more important relative to standard LoRA as reward noise increases. A deployment where a learned reward model replaces the deterministic math verifier should therefore favor DoRA over LoRA more strongly than the paper's 4.1-point margin suggests, because LoRA's rigid low-rank constraint may struggle to capture the broader spectral distribution that noisier rewards produce. This is a testable extrapolation from the paper's mechanism rather than a direct result, but it illustrates how the spectral diagnostic enables informed adapter selection in new settings.