acceptodds
Under review as a conference paper at ICLR 2027

From Anti-Generalization to Grokking: Train–Test Representation Kernel Dynamics in Modular Addition

Abstract

Grokking is a phenomenon in which a model generalizes long after fitting the training data. It is commonly attributed to delayed feature learning, yet a quantitative explanation linking evolving hidden representations to generalization remains incomplete. We develop a quantitative framework based on evolving train–train and train–test representation kernels, which directly connect hidden representations to training and test logits. An approximately label-aligned residual persists after fitting and sustains slow feature learning under weight decay. Within this framework, we show that early random-feature structure actively drives anti-generalization, pushing test accuracy from chance to nearly zero through spurious train–test correlations, whereas subsequent feature learning reorganizes the cross-kernel toward task-aligned structure and drives generalization. The sharp transition is controlled by finite-width fluctuations associated with the effective number of feature-aligned neurons. At late-time equilibrium, the learned feature-kernel geometry further predicts the cross-entropy loss through a mean-field scaling law in weight decay and problem size. Together, these results provide a quantitative representation-level account of grokking from early anti-generalization to late generalization.

Primary area:
learning theory
Keywords:
Grokking, Anti-Generalization, Feature Learning, Representation Kernels, Generalization, Cross-Entropy, Modular Arithmetic

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_97FrOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The authors analyze a two-layer ReLU network trained on modular addition. They explain why test accuracy initially falls below chance through the similarity between training and test inputs. They then study how learned Fourier-like features change this behavior, derive an approximate final-loss law, and relate the sharpness of grokking to the number of contributing neurons.

Critical strengths
  1. The explanation of early anti-generalization is the main strength. Section 3.1 shows why input collisions give some incorrect labels larger expected scores than the correct label. This is a specific, testable mechanism supported by the authors' experiments. I verified these results by rerunning some of the experiments myself.

  2. The final-loss prediction in Section 4.1 is also useful. Under the stated feature and equilibrium assumptions, it gives a loss of approximately 5λp5\lambda p, where λ\lambda is regularization strength and pp is the modulus, which matches their Fig. 3.

Critical weaknesses
  1. The paper does not predict the timing of the grokking transition. The late-time calculation assumes properties of the residuals and learned features whose development is not predicted. Figure 16 shows that the approximate kernel model generalizes substantially later than the network. Improving the onset estimate requires measurements of the evolved state. The analysis explains early failure and conditional final loss, but does not predict the transition from initialization.

  2. The effective-width argument is mainly an independence approximation. A constructed check during this review makes the limitation explicit. In this bias-free ReLU network, replace each neuron by rr identical copies, scaling both layers by 1/r1/\sqrt r. This leaves the network function and SGD dynamics unchanged while multiplying the proposed participation ratio by rr. The copies violate the paper's independence assumption, so this does not refute the conditional calculation. It does show why that assumption needs checking in learned features before the ratio can explain transition sharpness.

Questions for authors
  1. Can the authors explain the discrepancy in Figure 16 and measure correlations between neuron contributions during the transition? Please also identify which experiments use the Gaussian initialization assumed in the theory and which use the trainer's default uniform initialization.

  2. I believe some existing relevant works are missing from the related work section:

4 comments

We thank the reviewer for the careful evaluation and for independently reproducing our early anti-generalization results. We appreciate the positive assessment of our input-collision mechanism and equilibrium loss prediction. We address the concerns below and clarify the scope of our analytical results and their relationship to the numerical observations.

W1. Scope of the transition analysis and the discrepancy in Figure 16

We agree that our framework does not provide an a priori closed-form prediction of the absolute grokking time from initialization. In particular, the intermediate crossover rate ralign=datv/dtr_{\mathrm{align}}=da_{tv}/dt is governed by non-stationary dynamics, which we identify as an open problem in Sections 5.3 and 6. Our framework does not predict the entire trajectory from t=0t=0 but connects the early and late regimes through two analytical characterizations.

(i) Relative early- and late-stage feature-learning drives. The relative scaling of the corresponding label-aligned gradient prefactors is characterized by κ˙=λ/ϵ2\dot{\kappa}=\lambda/\epsilon^2 (Section 2.2, Eq. 5). Its quantitative agreement with the measured neuron-direction changing rates (Appendix B.2, Figure 13, κth˙=0.0686\dot{\kappa_{\rm th}}=0.0686 versus κreal˙=0.0680\dot{\kappa_{\rm real}}=0.0680) provides a consistency check for the relative feature-learning drive and explains the slow post-fit feature-learning timescale under weight decay. Importantly, our analysis characterizes the relative scaling of the two gradient contributions at two stages, while predicting the absolute transition time is beyond this scope.

(ii) Positive onset alignment and collision-induced competition. We identify a positive onset alignment atv(t0)>0a_{tv}(t_0)>0 at the transition, whose characteristic scale can be related to competition from two-collision wrong-label blocks under the assumptions in Section 5.1 and Appendix B.3.2 (Eq. 98). This provides an analytical characterization of the onset condition instead of a prediction of when the condition will be reached from initialization.

We therefore distinguish these analytical characterizations from our empirical characterization of the transition dynamics.

Regarding Figure 16, the comparison among the actual network (solid), the residual-based kernel prediction StKtvS_tK_{tv} (dash-dotted), and the label-based kernel prediction Yt~Ktv\tilde{Y_t}K_{tv} (dashed) reveals two distinct sources of discrepancy.

Why Yt~Ktv\tilde{Y_t}K_{tv} lags behind StKtvS_tK_{tv} and the actual network. The label-based prediction invokes the uniform residual-field ansatz St≃ϵYt~S_t\simeq\epsilon\tilde{Y_t}. This approximation involves two assumptions: the residual of each training sample is approximately aligned with its label vector, and the residual magnitudes are sufficiently concentrated across samples to be represented by a common coefficient ϵ\epsilon. More generally, the sample-wise residual can be written approximately as S:μ≃ϵμyμ~S_{:\mu}\simeq\epsilon_\mu\tilde{y_\mu}, with potentially different ϵμ\epsilon_\mu.

The residual-based prediction retains these sample-dependent weights through StKtvS_tK_{tv}, whereas the label-based prediction replaces them with a common coefficient. Consequently, training samples with larger residual contributions receive greater weight in StKtvS_tK_{tv}, while Yt~Ktv\tilde{Y_t}K_{tv} weights the corresponding label contributions uniformly. This can dilute emerging task-aligned signals and provides a natural explanation for the larger discrepancy of the label-based prediction.

The discrepancy between these two predictions becomes substantially smaller as the width increases from N=512N=512 (Figure 16a) to N=2048N=2048 (Figure 16b), consistent with reduced finite-width residual heterogeneity.

Why the actual network slightly lags behind StKtvS_tK_{tv}. The residual-based kernel prediction assumes instantaneous readout locking, $ V(t)\simeq \frac{1}{\lambda M}S_t(t)F_t(t)^\top. $ However, the actual readout follows $ \dot V=\frac{1}{M}S_tF_t^\top-\lambda V. $ Its exact solution is $ V(t)=e^{-\lambda t}V(0) +\frac{1}{M}\int_0^t e^{-\lambda(t-s)} S_sF_s^\top,ds. $ Thus, the readout retains an exponentially weighted memory of earlier residual-feature correlations and does not respond instantaneously to the current representation. When the representation evolves during the transition, this finite relaxation time can cause the actual network to lag behind the instantaneous residual-based prediction. The characteristic readout relaxation timescale is λ−1\lambda^{-1}.

These two effects distinguish the residual-field approximation from the finite response time of the readout, and clarify why the kernel approximation does not reproduce the complete transition trajectory.

W2. Effective width, the neuron-duplication counterexample, and neuron correlations

We thank the reviewer for the insightful counterexample. We agree that NeffFN_{\mathrm{eff}}^F is an energy participation ratio, not a parameterization-invariant count of independent neurons. Replacing each ReLU neuron by kk copies with incoming and outgoing weights scaled by k−1/2k^{-1/2} preserves the network function but multiplies NeffFN_{\mathrm{eff}}^F by kk at corresponding parameter states. The copies are perfectly correlated: their off-diagonal covariances exactly compensate for the reduced diagonal variance sum, leaving the total margin fluctuation unchanged. We therefore clarify that the (NeffF)−1/2(N_{\mathrm{eff}}^F)^{-1/2} relation is an empirical, conditional scaling estimate requiring control of cross-neuron covariances, not a universal consequence of participation alone.

We tested this construction on modular addition (p=59,q=29p=59,q=29), comparing a width-256 base network, its fourfold-duplicated width-1024 counterpart, and an independently initialized width-1024 network. The base and duplicate were trained independently without parameter tying, using identical minibatches and hyperparameters. Their accuracy trajectories closely track one another, whereas the independently initialized width-1024 network generalizes earlier. This directly illustrates why width obtained by exact copying is not equivalent to independently initialized width.

We also measured off-diagonal Pearson correlations of neuron-level kernel-score contributions across test samples, using both centered score differences and maximum-wrong-class margins at grokking onset and test accuracies 0.5 and 0.9. The base and independently initialized networks have distributions concentrated near zero, while the duplicate has an additional peak at correlation +1+1 from identical copies. These measurements distinguish duplication but do not establish independence or negligible aggregate covariance: many small correlations can accumulate, and perfectly correlated copies can be diluted in global averages.

The construction, variance decomposition, experimental settings, and correlation results are now presented in Appendix B.3.4. We have correspondingly qualified the effective-width interpretation.

Q1. Initialization settings: uniform versus Gaussian

We thank the reviewer for prompting this clarification. The random-initialization kernel analysis uses independent Gaussian first-layer weights wjk∼N(0,1/2)w_{jk}\sim\mathcal N(0,1/2) and V(0)=0V(0)=0. In contrast, the standard modular-addition training experiments, including the duplication experiment, use PyTorch's default uniform initialization, Wjk∼U[−1/2p,1/2p]W_{jk}\sim\mathcal U[-1/\sqrt{2p},1/\sqrt{2p}], with zero-initialized readout. Direct kernel visualizations and Fourier-initialization experiments use their explicitly specified feature ensembles. We now distinguish these settings in the manuscript.

We have added an exact uniform-initialization ReLU calculation in Appendix A.3.6. At matched weight variance, its diagonal, collision, and background coefficients are (1/2,3/10,1/6)(1/2,3/10,1/6), close to their Gaussian counterparts (1/2,0.304,0.159)(1/2,0.304,0.159). Both preserve κdiag>κcoll>κbg=κfeat\kappa_{\mathrm{diag}}>\kappa_{\mathrm{coll}}>\kappa_{\mathrm{bg}}=\kappa_{\mathrm{feat}}, so the input-collision anti-generalization mechanism is unchanged. The smaller variance of PyTorch's default uniform initialization rescales the kernel without changing this ordering.

Finally, the late-time equilibrium loss relation is conditional on the learned Fourier/square-wave feature statistics and radial weight-decay balance. It has no explicit dependence on the initialization distribution once that regime is reached, although initialization can still affect the preceding dynamics or accessibility of that regime.

Q2. Related works

We thank the reviewer for identifying these omissions. We have expanded the related-work discussion to include Prieto et al. (2025), Levi et al. (2024), Beck et al. (2025), and Xu et al. (2026), which establish several complementary mechanisms underlying delayed generalization in the Introduction.

In particular, Prieto et al. (2025) identify the role of softmax numerical stability and naive loss minimization. Levi et al. (2024) and Beck et al. (2025) demonstrate delayed generalization in analytically tractable linear or fixed-feature classification settings, showing that nonlinear representation learning is not a necessary condition for all forms of grokking. Xu et al. (2026) further establish quantitative bounds on grokking time in ridge regression and examine their applicability to nonlinear networks.

These works provide important complementary perspectives on grokking. In contrast, our work focuses on the evolving hidden-representation kernels in two-layer ReLU networks, explicitly connecting early input-collision-induced anti-generalization, late feature-kernel reorganization, and finite-width transition behavior.

Dear reviewer,

Have the authors address your concerns in their replies?

I thank the reviewers for their detailed response. I believe the scope and contribution of the paper allows me to retain my positive score, but not to raise it.

Reviewer_k6BgOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This work concerns grokking in modular arithmetic tasks. It asks what keeps changing after the model fits the training data, using train–train and train–test hidden-representation kernels. It aims to explain the interesting early anti-generalization behavior and subsequent generalization.

The authors approximate early dynamics using a first-order Taylor expansion and late dynamics using an output-layer ~ equilibrium assumption and a label-aligned residual ansatz. Fig 1c is used to showcase the hypothesis, however, epochs extends well beyond the main test-improvement period. Although the overall alignment is high, it appears lower and still changing around epochs 1k to 5k, when most test improvement occurs.

Nonetheless, the initial approximation provides a theoretical account, supported empirically, of anti-generalization with zero-initialized (V) and Gaussian (W) that shared-input correlations favor incorrect answers and Fourier-feature kernel favors generalization.

Section 4 predicts equilibrium-loss scaling with \lambda and problem size. This is interesting but feels less connected to grokking itself, as does Section 5’s discussion of width. Alignment evolution feels more relevant, but its increase during generalization is demonstrated only empirically. Although the early section identified a persistent feature-learning signal after training loss becomes small, it did not derive how this drives increasing train–test alignment (a_tv over time). Therefore the claim of “explaining how late-stage kernel reorganization drives a sharp accuracy transition associated with finite-width fluctuations” in the paper still feels insufficiently established.

Critical strengths
  1. Uses train–test representation kernels to study grokking, which I think is novel.

  2. Provides an explanation of early anti-generalization (both empirical and with analytical support)

Critical weaknesses
  1. The anti-generalization mechanism depends on the paper’s setup, and its broader implications remain unclear to me. Grokking in other domains need not exhibit this pattern either. The behavior also depends on activation and initialization choices, e.g., as illustrated by the differences with quadratic activations and Fourier initialization, which further make the scope feel limited.

  2. For the more central phenomenon of delayed generalization, the paper lacks firm evidence that the late-stage output-layer equilibrium approximation holds during the main generalization period. The key question of what drives increasing train–test alignment after training loss becomes small remains unanswered analytically. Moreover, increasing alignment does not automatically imply generalization. These gaps limit the paper’s explanation of delayed generalization.

Questions for authors
  1. Is weight decay applied to both W and V?
  2. Have the authors tested whether anti-generalization persists when both W and V non zero initialization?
4 comments

We thank the reviewer for the helpful comments and questions. We address the concerns below.

The anti-generalization mechanism depends on the paper’s setup, and its broader implications remain unclear to me. Grokking in other domains need not exhibit this pattern either. The behavior also depends on activation and initialization choices, e.g., as illustrated by the differences with quadratic activations and Fourier initialization, which further make the scope feel limited.

We have clarified the scope in the main text (Subsection 3.3) and expanded the supporting experiments in Appendix C. Early anti-generalization is observed for the tested ReLU, tanh, GeLU, and quadratic networks, as well as the tested Transformer and LSTM models. The duration varies across settings and is shorter for quadratic activation. These observations support robustness across the tested configurations.

Our proposed anti-generalization mechanism requires train–test input correlations that systematically favor incorrect class scores. It therefore depends on the task, data split, and initialization. The added graph-metric experiments illustrate this dependence directly. Early anti-generalization appears for the tested path and cycle tasks, while it is absent for the cylinder and hypercube tasks. We also report it for modular multiplication, modular square, permutation composition in S5S_5, and a designed chirality task. We have clarified that early anti-generalization is a possible initial stage of grokking and that delayed generalization can also occur without it.

The Fourier-initialization experiment is consistent with the class-score mechanism. Its initial representation already contains task-aligned features, and generalization appears promptly once the initially zero readout becomes nonzero.

For the more central phenomenon of delayed generalization, the paper lacks firm evidence that the late-stage output-layer equilibrium approximation holds during the main generalization period.

The cosine similarity between VV and SFt⊤SF_t^\top increases toward one after approximately 300 epochs. It is approximately 0.97 at the onset of grokking and 0.99 when test accuracy reaches 0.9, indicating sustained strong directional alignment with only a small change during the main generalization period. We have added the evolution of ∥W∥F\|W\|_F, ∥V∥F\|V\|_F, and the norm ratio λM∥V∥F/∥SFt⊤∥F\lambda M\|V\|_F/\|SF_t^\top\|_F in Appendix B.6. The ratio remains close to the locking prediction of one over this period. Together, the directional and norm diagnostics support the use of approximate output-layer locking during generalization. The cosine similarity dynamics are similar across other modular tasks as shown in Appendix C.2.

We further compare the model accuracy with predictions from Yt~Ktv\tilde{Y_t} K_{tv} and StKtvS_t K_{tv}, StS_t being the real-time training residual. The predictions from StKtvS_tK_{tv} correspond to network with VV replaced by the instantaneous locked value Vlock=(λM)−1StFt⊤V_{\rm lock}=(\lambda M)^{-1}S_t F_t^\top. Their improved agreement with the actual model during the main generalization period provides further support for the output-layer locking approximation (Appendix B.3.1).

The key question of what drives increasing train–test alignment after training loss becomes small remains unanswered analytically.

We have clarified the analytical scope of the dynamics in Section 4. Under the two ansatzes, the residual gradient remains nonzero after fitting and promotes neuron energy E0,j\mathcal E_{0,j}. The identity Att=2∑jE0,jA_{tt}=2\sum_j\mathcal E_{0,j} connects this energy to training-kernel alignment. The Fourier-kernel calculation then shows how task-aligned feature blocks improve test class scores. These results provide a mechanism linking neuron-level feature acquisition to training-kernel alignment and the emergence of test-aligned feature structure, while a closed evolution equation for atv(t)a_{tv}(t) and an a priori prediction of transition time remain open. The transition analysis is therefore presented as a characterization of the measured alignment trajectory and its finite-width score fluctuations.

Moreover, increasing alignment does not automatically imply generalization. These gaps limit the paper’s explanation of delayed generalization.

We agree that increasing scalar alignment alone does not guarantee correct classification. The cross-kernel alignment atva_{tv} measures an aggregate advantage of correct-label scores over incorrect-label scores, whereas classification requires the correct-label score to exceed the strongest competing class for each test sample. The main text Section 3 defines class scores Rg(ν)=∑μ:[μ]=gKμνtvR_g(\nu)=\sum_{\mu:[\mu]=g}K_{\mu\nu}^{tv} and states the classification condition Rhν(ν)>max⁡g≠hνRg(ν)R_{h_\nu}(\nu)>\max_{g\ne h_\nu}R_g(\nu) under the kernel approximation. The onset analysis explains why positive average alignment may be needed to overcome the strongest wrong-class competitors. In Appendix B.3.2 and B.3.3, we discuss in detail how the increase of alignment atva_{tv} is related to the test accuracy from both empirical and theoretical perspectives. Our interpretation of the transition therefore combines the alignment measure with class-score competition.

Is weight decay applied to both W and V?

Yes. The same L2L^2 weight-decay coefficient λ\lambda is applied to both WW and VV, and we now state this explicitly in the problem settings.

Have the authors tested whether anti-generalization persists when both W and V non zero initialization?

Yes. We have added an experiment with default PyTorch initialization, including nonzero WW and VV in Appendix B.7 (Figure 27). Early anti-generalization persists, although test accuracy does not fall to exactly zero after the first epoch.

I appreciate the revisions and additional experiments, which address my questions. My main concern remains whether the framework explains delayed generalization, ie, grokking. To me, explaining the progression from anti-generalization to generalization is not the same as explaining why test performance remains poor or near chance for a long time before improving. Early anti-generalization is interesting, but I find the proposed spurious-correlation mechanism relatively straightforward; explaining it does not resolve the question of delayed generalization.

Even accepting the two ansatzs, the analysis connects neuron energy to training-kernel alignment, but does not establish how this produces test-aligned feature structure during training or explains the delay. The Fourier-kernel calculation shows why an assumed learned representation supports generalization, rather than how that representation emerges. The revised scope is clearer, but this missing connection still limits the explanatory contribution for me.

We thank the reviewer for the follow-up and for acknowledging that our revisions have addressed the specific questions.

We respectfully disagree that our framework offers no explanation for delayed generalization. It identifies a structural source of the initial delay in modular addition and related tasks exhibiting adverse train–test input correlations, and also explains why generalization could eventually happen. As shown in Section 3, the initial training kernel has a strong diagonal structure that supports fitting, whereas the train–test kernel systematically favors incorrect labels. Thus, training set initially improves fitting while driving test predictions in the wrong direction. Before the eventual generalization, the network must first overcome this adverse initial bias, so generalization necessarily lags behind the initial learning process in this setting. Section 2 further characterizes the different early- and late-stage feature-learning drives, while Section 5 identifies the positive cross-kernel alignment threshold associated with the onset of generalization. Our analysis explains why generalization is initially delayed, though the duration of grokking plateau is not derived. In summary, these results explain why test performance initially remains poor before improving: the network must overcome the adverse initial bias and develop sufficient task-aligned cross-kernel structure to reach the grokking-onset threshold. We would appreciate clarification on whether the reviewer's remaining concern is specifically the absence of a quantitative prediction for the plateau duration, or whether the structural mechanism identified above is also considered insufficient to explain the initial delay.

We also disagree that our calculation does not present the emergence of kernel representation. Under the residual-field and output-layer locking ansatzes, the neuron dynamics favor feature directions with higher training-label energy. Full energy (defined on the whole data set) plots in Figure 15 also shows feature emergence of neurons. For modular addition, the Fourier-like features associated with the task's group structure have higher training-label alignment, and our kernel calculations show that these same features also improve test class scores. This provides a connection between the neuron-level feature learning and the emergence of generalizing representations, although the full feature-learning dynamics remain unresolved. We have added a paragraph in Section 4 to clarify this connection.

Our main results are the analytical prediction of early anti-generalization and the demonstration of how learned feature structure can reverse the initial class-score bias. These results explain why fitting the training set need not lead to immediate generalization, even though predicting the duration of the delay remains an open problem.

We thank the reviewer for the follow-up and for acknowledging that our revisions have addressed the specific questions.

Reviewer_EYCkOpenReview ↗
Rating
2(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Authors tackle grokking in two layer networks using empirical and instantaneous kernels between train-train and train-test examples. This reveals a bunch of interesting observations. Early in training, spurious correlations worsen generalization, then subsequently some feature learning introduces task alignment and improves generalization.

Critical strengths
  1. The kernel picture is both clever and natural. It leads to interpretable results about the nature of grokking.
  2. The setting allows some analytical treatment, which again gives interpretable results.
Critical weaknesses
  1. The literature review is inadequate, especially on many works that study kernel-target alignment for generalization, and final kernels.
  2. Setting is limited to two layer networks, a certain initialization scheme, and gradient flow. How general are these results? There are some sections in the appendix on other tasks, multilayer networks etc. Authors should discuss the results of these experiments in the main text and state what portion of their results are general, and what portion are specific to the setting that they study. For example, on page 36: "The normalized cross-kernel alignment atv initially dips for modular multiplication but not for modular square, suggesting that this dip may not be universal across modular tasks." This is a very important observation, it should not be buried in the appendix.
  3. The paper reads more like a patch of calculations rather than trying to give a main message.
  4. Every calculation has a different assumption that goes into it. Assumptions are fine, but at some point I could not follow what result applies to when.
Questions for authors
  1. I guess my main question is what else could it be? Was there an alternative hypotheses about how the kernels would behave?
  2. What is the point of Figure 1d? What does color represent in this figure?
  3. In what sense the mean-field dynamics is mean field? This section is generally opaque, and would benefit from significant rewriting. As far as I understand, the point of this section is to show that late time kernel geometry predicts loss scaling. There are, again, many results in the literature that show that final kernel predicts neural network performance. More strongly, Lauditi et al showed recently that under weight-decay, in mean-field regime, neural networks are kernel predictors with the final kernel. Can the authors discuss these results as well?
3 comments

We thank the reviewer for the constructive feedback. We have revised the presentation, clarified the assumptions and scope, and added numerical checks addressing the concerns below.

The literature review is inadequate, especially on many works that study kernel-target alignment for generalization, and final kernels.

We thank the reviewer for highlighting this omission. We have substantially expanded the Introduction to discuss kernel–target alignment and spectral theories of generalization, including Cristianini et al., Cortes et al., Bordelon et al., and Canatar et al. We also discuss studies of evolving kernel alignment during feature learning, including Fort et al., Baratin et al., Shan et al., and Lou et al., together with silent alignment and final or adaptive kernel predictors studied by Atanasov et al., Rubin et al., and Lauditi et al. These additions place our work within the broader literature connecting learned kernel geometry to generalization. We have clarified that our focus is on train–train and train–test hidden-representation kernels in grokking, particularly the class-score mechanism of early anti-generalization and the conditional equilibrium CE-loss law obtained from learned feature structure.

Setting is limited to two layer networks, a certain initialization scheme, and gradient flow. How general are these results? There are some sections in the appendix on other tasks, multilayer networks etc. Authors should discuss the results of these experiments in the main text and state what portion of their results are general, and what portion are specific to the setting that they study. For example, on page 36: "The normalized cross-kernel alignment atv initially dips for modular multiplication but not for modular square, suggesting that this dip may not be universal across modular tasks." This is a very important observation, it should not be buried in the appendix.

We have added a subsection, Subsection 3.3: Anti-generalization in Multilayer Network and Other Tasks, to the main text. It explains how the input-collision mechanism extends to wide, randomly initialized multilayer ReLU networks and summarizes the observations for other activations, architectures, and tasks. The corresponding experiments are reported in Appendix C. Our analytical treatment of post-fit feature learning and equilibrium loss remains focused on two-layer ReLU networks trained with CE loss and weight decay.

We have also moved the observation about the initial alignment dip into the main-text discussion (Section 5) of the transition onset. In the modular-square experiment, early anti-generalization occurs without an initial dip in atva_{tv}. This clarifies that below-chance initial accuracy can be caused by the initialization kernel without requiring an initial decrease in kernel alignment.

The paper reads more like a patch of calculations rather than trying to give a main message.

We have reorganized the presentation around how the train–train and train–test representation kernels distinguish fitting from generalization. The random-initialization kernel explains why input collisions favor incorrect test labels, while the feature-kernel calculation shows how learned task structure reverses this score ordering. The analysis on the reduced-neuron dynamics connects training-kernel alignment to neuron energy and yields a conditional equilibrium CE-loss prediction which is also verified by experiments. The finite-width section characterizes the observed accuracy transition through class scores, alignment gaps, and effective neuron participation. We have revised the section introductions and moved intermediate alignment calculations to the appendix to make these connections more explicit.

Every calculation has a different assumption that goes into it. Assumptions are fine, but at some point I could not follow what result applies to when.

We have explicitly labeled the residual-field and output-layer locking assumptions as Ansatz 1 and Ansatz 2 (in Section 2) and indicated where they enter the analysis. The initial anti-generalization calculation uses the short-time expansion with zero-initialized readout. The low-loss representation-kernel description uses the two ansatzes, while the Fourier-kernel calculation specifies a reference feature ensemble and its large-pp background approximation. The equilibrium-loss prediction additionally uses ReLU homogeneity and radial balance, which are properties of model setting and equilibrium. The finite-width scaling argument is presented as an empirical fluctuation estimate supported by the tested experiments. The usage of ansatzes have been explicitly explained in the main text (Section 3 and 4). The use of mean-field dynamics is also explicitly explained in Section 4.

I guess my main question is what else could it be? Was there an alternative hypotheses about how the kernels would behave?

We agree that the emergence of task-aligned representations in a generalizing network is not surprising by itself. However, our framework makes more specific predictions about the train-train and train–test kernel structures. In particular, the initial Gaussian representation kernel systematically favors incorrect labels due to input collisions, leading to early anti-generalization. This behavior is not implied by the eventual emergence of generalizing features.

Moreover, strong alignment of the train–train kernel KttK_{tt} does not necessarily imply task-aligned structure in the train–test kernel KtvK_{tv}. An alternative scenario is that training-set alignment improves without corresponding alignment on unseen data, resulting in memorization without generalization. More broadly, stronger feature learning does not necessarily improve generalization (Yeom et al., 2026), while delayed generalization can also arise without nonlinear feature learning (Xu et al., 2026). These possibilities highlight why the separate evolution of KttK_{tt} and KtvK_{tv} is important.

By examining the train–train and train–test kernels separately, our framework helps distinguish these scenarios. It also highlights the difference between early-stage train–test kernel dynamics, which can systematically favor incorrect labels, and the learned kernel structure associated with eventual generalization.

What is the point of Figure 1d? What does color represent in this figure?

The original panel displayed neuron-wise feature acquisition, with color encoding energy at a reference epoch. We have removed it from Figure 1 because its interpretation required concepts introduced later, and related early- and late-stage neuron-learning discussions are kept in Appendix B.2. Figure 1 now focuses on accuracy, loss, and the field-alignment diagnostics.

In what sense the mean-field dynamics is mean field? This section is generally opaque, and would benefit from significant rewriting. As far as I understand, the point of this section is to show that late time kernel geometry predicts loss scaling. There are, again, many results in the literature that show that final kernel predicts neural network performance. More strongly, Lauditi et al showed recently that under weight-decay, in mean-field regime, neural networks are kernel predictors with the final kernel. Can the authors discuss these results as well?

We have clarified the mean-field interpretation and renamed the section Section 4: Kernel Dynamics and Loss Scaling Law. The residual S(t)S(t) is treated as a self-consistent mean field, neglecting the influence of any individual neuron in the large-width approximation. Holding SS fixed refers to differentiating the single-neuron energy with respect to that neuron's weights. We have added this explanation and a citation to Lauditi et al. in the main text. Appendix A.2 also explains how the evolving residual enters the reduced dynamics.

We also add discussion about adaptive and final-kernel predictors in the Introduction, including Lauditi et al. Their work provides an infinite-width description of feature-learning networks with weight decay, but does not directly yield the explicit CE-loss law for modular addition studied here. We further use the hidden-representation Gram matrices KttK_{tt} and KtvK_{tv} to characterize class-score competition, explaining early anti-generalization through the initialization kernel and generalization through task-aligned feature structure. Our analysis also makes the neuron–kernel connection explicit through the energy function. Under the reduced dynamics, the data gradient ascends this energy, whose sum equals half the training-kernel alignment, Att=2∑jE0,jA_{tt}=2\sum_j\mathcal E_{0,j}. Combining this identity with radial balance and the computed feature-kernel coefficients yields the equilibrium CE-loss law.

Reference

Mingyue Xu, Gal Vardi, and Itay Safran. To grok grokking: Provable grokking in ridge regression. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pp. 141965–141987. PMLR, 2026

I thank the reviewers for their substantial revision. I raise my score.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.