acceptodds
Under review as a conference paper at ICLR 2027

Controlling representation sharing in multilingual transformers: a mechanistic study

Abstract

Understanding the mechanism through which transformers represent shared concepts across languages is a central problem in the study of multilingual large language models. Building on previous work, we find further evidence that multilingual LLMs encode the same concepts with similar representations across languages. To precisely understand shared representations in transformers, we analyze a single-layer transformer trained on a multilingual modular addition task, in which distinct vocabularies express the same underlying numerical concepts. We provide a mechanistic explanation of how these models implement arithmetic using shared Fourier representations across languages. We design a task-specific intervention on the training process of the multilingual modular addition model. This label-based intervention encourages representation sharing across languages and substantially improves cross-lingual generalization.

Primary area:
interpretability and explainable AI
Keywords:
mechanistic interpretability, multilingual language models, representation sharing, modular addition, cross-lingual generalization, training interventions

Reviews

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

The paper studies cross-lingual sharing in transformers using a toy single-layer transformer trained on multilingual modular addition task, where several disjoint token vocabularies (languages) all encode the same task. The authors find that standard-trained toy models transfer across languages and share circuits (the sets of weights and activation directions that carry out this computation), yet use largely unshared representations. They propose warm-up, an initial training phase with labels aggregated across all languages, which induces shared representations and significantly improves generalisation.

Critical strengths
  • The experimental setting is clean and well-motivated. The task isolates cross-lingual transfer well and is generally easy to understand.
  • The proposed warm-up algorithm is simple and empirically interpretable, showing promising results on the task.
Critical weaknesses
  • The paper covers only a toy LLM scenario, but it would be interesting to see how this generalises to actual transofrmers (at least the circuit sharing part)
Questions for authors

General comment: The notation in the equations is a bit inconsistent. The paper introduces the symbol n_(ℓ) in the sentence after the equation, but defines it formally only a paragraph later, and the equation itself never uses n, which makes it a bit cnfusing when reading. Using the already present notation "a(l) and b(l) represent the numbers in language l" and then introducing the general notation ("which we generalise to n(l) in the following text") or moving the definition up would be much easier to follow

2 comments

Thank you for your comments and for reading our paper.


The notation in the equations is a bit inconsistent. The paper introduces the symbol n_(ℓ) in the sentence after the equation, but defines it formally only a paragraph later, and the equation itself never uses n, which makes it a bit cnfusing when reading. Using the already present notation "a(l) and b(l) represent the numbers in language l" and then introducing the general notation ("which we generalise to n(l) in the following text") or moving the definition up would be much easier to follow

We have modified the notation as you suggested to make Section 3 easier to follow.


The paper covers only a toy LLM scenario, but it would be interesting to see how this generalises to actual transofrmers (at least the circuit sharing part)

(Whether our findings hold in LLMs was the most common question across reviews, so we've answered it once and included the same response for each reviewer who raised it.)

We're interested in a couple of ways to potentially extend the results to LLMs, which we now discuss in the paper in Section 8.

One is to estimate an analogue of the aggregated labels for LLMs to try to make training faster and yield more interpretable models, in the sense of encouraging similar representations for concepts that use similar circuits. We have several ideas for an analogue of warm-up for LLMs. Here is one such idea: at each token in the training corpus, have a cheap model decide whether a new word has just started. If so, pick a random real-world language ℓ\ell, and give an existing LLM the full context of the current training sample with preamble instructions to predict what the next word would be if the next word was instead in language ℓ\ell. Then, assign loss using the first token of the translated next word instead of the true next word. (You could also translate to several random languages and assign loss using the mean over the languages of the first token.) Do this procedure for some amount of epochs, and then swap to usual training as in our method.

As a first step toward this, we have tested a version of this in the toy model, where each warm-up label is the correct sum in one randomly chosen language, instead of the aggregated label over all languages. This is the kind of supervision a translation-based warm-up would provide in an LLM. We find that this random-language label regime performs nearly as well as warm-up (60/67 runs grok with random-language labels vs 62/67 runs in warm-up, see Table 5). Because random-language labels work nearly as well as aggregated labels, that would suggest a translation-based warm-up for LLMs is worth trying. It would also let us study questions that the toy model cannot answer, such as whether pretrained LLMs already share as much representation across languages as would help their minority languages. We are interested in pursuing this translation-based warm-up for LLMs in future work, as well as other ideas for extending warm-up to LLMs.

We are also interested in extending our mechanistic analysis to LLMs and developing methods to understand if LLMs can also share circuits without sharing representations: the distinction between shared circuits and shared representations in our toy models is a good demonstration that many common tools used for mechanistic interpretation (like cosine similarity for example), can only detect shared representations and not shared circuits. A cosine similarity of zero on an actual LLM, for example, would not be enough to conclude with certainty that circuits aren't shared.

Another idea is to try to extend the language ℓ\ell subspace method used for the ablations in the toy models to LLMs to examine cross-lingual circuit sharing in larger models, possibly using MMMLU.

Thank you for the response and addressing the notation confusion. I would be interested to see in how the ideas transfer to LLMs in future! I would like to keep my score and remain supportive of acceptance.

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

This paper asks what multlingual transformers share across languages, using a toy model to learn modular addition in artificial languages. They find that training on the four languages makes the low-resourced language setting easier to learn, although the numbers are represented different across languages. They find that the circuits are shared although the representations are not. They then conducted an intervention by forcing the models to predict the averaged label to form a shared repreesntation and they find that models show more similar representations across languages and more reliable grokking.

Critical strengths

The finding is very interesting and the experiment design is elegant. This paper does not focus on those multilingual LLMs but uses toy transformers with clear control in language, tokens, and task, and the show clear evidence that shared representation does not guarantee shared circuits. I really like the design that each language does not share tokens with each other. This can clearly capture the representation similarity between languages.

Critical weaknesses

The major concern I have is in Section 5 where models are trained on averaged labels. How certain are the authors that the improvements or more consistent grokking is caused by shared representation or just more training data because in this case the models are essentially using the whole data to do one shared task rather than four sub-tasks. I understand this is tricky to disentangle, but some controls might help. For example, the authors can train a transformer on one language and compare the performance. At minimum, the authors should add a discussion on the alternative possible explanation.

The paper is hard to follow with a lot of long sentences and without appropriate previous work introduction. I think it would be nice if the authors can add a background section to help readers to better follow the flow of the paper.

Questions for authors

In the limitation section, the authors mention that the aggregated labels require token-level alignment between languages which is very different from LLMs. I wonder if authors have some thoughts on addressing this limitation because I think it's still quite crucial for the impact of this work.

4 comments

Thank you for your review, and for the kind words about the experimental design. We have revised the paper to address some of your comments, and all changes are marked in blue. We also hope to address some of your concerns below.


Although in the literal sense the model is not given more training data during warm-up, we agree that warm-up allows the model to use the data more effectively. We think that the way that warm-up does this is by inducing shared circuits, which lets the model "use the whole data to do one shared task rather than four sub-tasks." (We have changed the motivation section to clarify this. Warm-up also produces shared representations, but we do not think these improve generalization beyond the improvement from shared circuits.) The model solves a single shared task only once it uses a shared circuit, because then the data in every language can help every other language despite disjoint tokens. In other words, we don't think that sharing circuits and using the data for one shared task are competing explanations for the improved performance of warm-up. Instead, we argue sharing circuits is the mechanism by which the model is able to use the data for one shared task.

This also means we expect warm-up to help only when a shared circuit can exist. In particular, if our network architecture was set up such that neurons from different languages in the embedding layer did not connect to the same neurons in the hidden layer, (essentially training each language block in the embedding matrix on its own transformer with shared final logits) we would not expect warm-up to improve cross-lingual transfer. We therefore see the causal chain as warm-up →\to shared circuits →\to better generalization. The fact that warm-up improves the rate at which models grok (Section 5.1, Appendix F) and that grokked runs always share circuits (Section 6, Appendix C) suggests this causal chain. We have added footnote 11 to the paper to clarify this.


The paper is hard to follow with a lot of long sentences and without appropriate previous work introduction. I think it would be nice if the authors can add a background section to help readers to better follow the flow of the paper.

We have split long sentences throughout and tried to make the paper easier to follow. We have also edited Section 3 to now have a background (3.1) before moving on to describe our setting (3.2). We have also added more details to Appendix B which formalizes our setting.


In the limitation section, the authors mention that the aggregated labels require token-level alignment between languages which is very different from LLMs. I wonder if authors have some thoughts on addressing this limitation because I think it's still quite crucial for the impact of this work.

We agree that this is the main obstacle to applying warm-up to LLMs. We're interested in a couple of ways to potentially extend the results to LLMs, which we now discuss in the paper in Section 8.

One is to estimate an analogue of the aggregated labels for LLMs to try to make training faster and yield more interpretable models, in the sense of encouraging similar representations for concepts that use similar circuits. We have several ideas for an analogue of warm-up for LLMs. Here is one such idea: at each token in the training corpus, have a cheap model decide whether a new word has just started. If so, pick a random real-world language ℓ\ell, and give an existing LLM the full context of the current training sample with preamble instructions to predict what the next word would be if the next word was instead in language ℓ\ell. Then, assign loss using the first token of the translated next word instead of the true next word. (You could also translate to several random languages and assign loss using the mean over the languages of the first token.) Do this procedure for some amount of epochs, and then swap to usual training as in our method.

As a first step toward this, we have tested a version of this in the toy model, where each warm-up label is the correct sum in one randomly chosen language, instead of the aggregated label over all languages. This is the kind of supervision a translation-based warm-up would provide in an LLM. We find that this random-language label regime performs nearly as well as warm-up (60/67 runs grok with random-language labels vs 62/67 runs in warm-up, see Table 5). Because random-language labels work nearly as well as aggregated labels, that would suggest a translation-based warm-up for LLMs is worth trying. It would also let us study questions that the toy model cannot answer, such as whether pretrained LLMs already share as much representation across languages as would help their minority languages. We are interested in pursuing this translation-based warm-up for LLMs in future work, as well as other ideas for extending warm-up to LLMs.

We are also interested in extending our mechanistic analysis to LLMs and developing methods to understand if LLMs can also share circuits without sharing representations: the distinction between shared circuits and shared representations in our toy models is a good demonstration that many common tools used for mechanistic interpretation (like cosine similarity for example), can only detect shared representations and not shared circuits. A cosine similarity of zero on an actual LLM, for example, would not be enough to conclude with certainty that circuits aren't shared.

Another idea is to try to extend the language ℓ\ell subspace method used for the ablations in the toy models to LLMs to examine cross-lingual circuit sharing in larger models, possibly using MMMLU.

(Whether our findings hold in LLMs was the most common question across reviews, so we've answered it once and included the same response for each reviewer who raised it.)

We have now finished running the control to test whether cross-lingual circuit sharing or using “effectively” more data causes the increase in grokking rates that we mentioned in the last comment (training each language block in the embedding matrix on its own transformer with shared final logits). We found that grokking rates do not improve with warm-up if we remove the possibility of cross-lingual sharing. Without partitioning the model into separate language blocks, 0/12 runs grok with standard-training and 7/12 runs grok with warm-up, but if we partition the model to prevent cross-lingual sharing, 0/25 runs grok with standard training and 0/25 grok with warm-up. We see this as evidence that the effect of warm-up is mediated by circuit sharing, confirming the causal chain proposed in the last comment (warm-up -> shared circuits -> better generalization). We have added a section at line 1392 discussing this experiment, its result, and the alternative explanation you proposed.

Thank you for pointing out this possibility. Your comments have been very helpful to us in improving the paper!

Thank you for your detailed response! The results are interesting, and I look forward to reading the updated version! I think 3 is a fair assessment and I'll maintain the score.

Reviewer_afWqOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3(+1)
Read review
Paper summary

Motivated by a plethora of recent work suggesting that frontier LLMs reuse internal representations across languages, the authors ask the following questions: How do models share representations and circuits across languages? How does this sharing affect generalization and interpretability? Under what conditions does sharing emerge during training?

This is fairly ambitious, so the authors focus on studying the toy setting of a single-layer transformer trained on multilingual modular arithmetic. Here, languages are disjoint vocabularies used for the same modular addition task. They first establish behavioral evidence of cross-lingual transfer by comparing multilingual training with training only on a low-data language, finding that multilingual training enables generalization where training on that language alone fails. Even so, standard-trained models have weakly aligned representations across languages (Figure 1). Nevertheless, via ablation experiments they find that models still share computational mechanisms: removing numerical subspaces identified from one language’s activations causes similar accuracy drops across languages, while control ablations have little effect.

The authors then introduce a two-stage intervention that encourages representation alignment. During the initial warm-up phase, each hard label (the one-hot target for the correct sum in the input’s language) is replaced with an aggregated label, which places probability 1/L on the correct sum in each of the L languages. After a fixed number of epochs, training switches back to the hard labels. Under this intervention, they report more reliable generalization across seeds and hyperparameter settings. Additionally, cross-lingual cosine similarities show stronger representation alignment, while Fourier spectra show greater agreement in key frequencies across languages. Overall, the paper provides some evidence that, in this controlled setting, circuit sharing and representation alignment across languages can be distinct. It also proposes a training intervention that the authors report improves both alignment and generalization.

Critical strengths

The multilingual modular addition setting is a nice controlled testbed for studying cross-lingual sharing. Since languages do not share any tokens, any transfer between them can be attributed to non-local generalization. And, since modular addition has been extensively studied mechanistically (Nanda et al., 2023), the authors can use existing tools like Fourier analysis to probe what the model is doing.

The distinction between circuit sharing and representation sharing is an interesting idea. In this toy setting, the paper provides some evidence that the two can come apart. Standard-trained models appear to share circuits under ablation despite low cross-lingual cosine similarity, while warmed-up models show both high cosine similarity and matching key frequencies across languages.

Finally, I thought that the warm-up intervention was simple and intuitive to understand.

Critical weaknesses

The main weakness of the paper is a general lack of clarity and rigor, i.e. I'm unsure how to interpret key pieces of evidence, and whether the paper is presenting a "just-so" story. Many key results are only stated in the text without plots or tables (even in the appendix), claims are often supported only qualitatively, there are inconsistencies between the text and figures, and the organization is messy. Together, these make it hard to assess whether the main claims are sound. Some examples:

  • Results across random seeds and hyperparameter settings are simply summarized in the text, with no tables or plots (e.g. L307–313).
  • The Section 6 ablation results are similarly reported, with vague language like "Inputs in the other languages lose about the same amount"
  • Figures 5 and 6 show single qualitative examples. It would be more convincing to show metrics across seeds.
  • Section 5 claims that standard-trained models have nearly orthogonal representations across languages, but this is only supported qualitatively, by the heatmaps and spectra in Figures 5 and 6. And these figures are not explicitly used as evidence for the claim.
  • Figure 1(d, e) shows cosine similarity for the toy model with and without warm-up. This is arguably the most direct evidence for representation alignment, but it isn't discussed in the text.
  • Figure 4 is also never referenced in the text.
  • Section 6 constructs the relabeled model at the start, but only uses it in the final paragraph, as a check that the ablation test can detect sharing. The organization could be improved.
  • The text says warm-up lasts 10,000 epochs, but in Figure 4 the swap to hard labels occurs at 25,000 epochs.
  • The number of languages used in the main experiments is never stated explicitly.

I also think the paper overclaims in several places:

  • The introduction says that “whenever multilingual modular addition models generalize, we observe the emergence of shared circuits that internally perform the same computations regardless of language, with language-specific translation occurring only in the first and last layers.” The only direct support is the Section 6 ablation, and the paper doesn’t show where language-specific processing happens in standard-trained models.
  • The introduction also says that warm-up allows “for easier mechanistic analysis,” but there’s no analysis that shows this.
  • Later in the introduction, it’s claimed that “after our intervention, shared circuits stay intact even after extended training with the original data,” and Section 5.1.1 says something similar about representations. However, the authors don't actually do any analysis of how circuits or representations change during training, e.g. by looking at model checkpoints.
  • In Section 5.1.1, matching key frequencies are used as evidence for “shared representations of numerical concepts across languages” (see below).

The authors interpret matching key frequencies as evidence for "shared representations of numerical concepts across languages." But this is not necessarily true. For example, consider two languages AA and BB that both encode each number nn using the same frequency kk, with θn=2πknP\theta_n=\frac{2\pi kn}{P}, but in different coordinates of the hidden space:

e_B(n)=(0,0,\cos\theta_n,\sin\theta_n).$$ These have identical Fourier power spectra, even though the languages occupy orthogonal subspaces, and $e_A(n)$ and $e_B(n)$ have zero cosine similarity for every $n$. So I would not interpret the shared frequencies across languages as evidence of shared representations, without other pieces of evidence, like cosine similarity. The warm-up results in Figure 4 are also hard to interpret. My main confusion is that it looks like the standard-trained model never generalizes. This is inconsistent with Section 4, which reports that standard-trained models achieve strong generalization. Since this figure is the main comparison between standard and warmed-up training, it makes it hard to interpret what is being claimed. I also find the warmed-up model results strange, specifically the claim of "sudden generalization" after switching to hard labels. The authors note that the warmed-up model already reaches ~100% numerical accuracy before the switch to hard labels. Given this, I wouldn’t call what happens after the switch generalization, since the model only needs to learn the label space, i.e. which language to answer in. Additionally, in Appendix D, the authors show that the “=” token is what determines the output language in warmed-up models. So concretely, to test whether the jump after the switch simply reflects learning the label space, they could track when the “=” token takes on this role across checkpoints, and see if corresponds with the soft->hard label switch. If this is the case, it explains the "sudden generalization" observed by the authors.
Questions for authors
  1. In the Section 4 transfer experiment, how much data does the minority-only model see? Is it trained on the same total amount of data as the multilingual model, or only on the minority-language portion (i.e. a much smaller fraction)? If the latter, then even with the same number of epochs, the minority-only model sees far less data and possibly takes fewer gradient steps, so this would not be a fair comparison.
  2. In Figure 4, the standard-trained model doesn’t generalize, with near-zero test accuracy throughout training, while Section 4 reports that standard-trained models reach >99% validation accuracy in 23 of 25 seeds. Could the authors clarify the setup for Figure 4, and how it differs from what is reported in Section 4?
  3. The setting is very toy, and it’s unclear whether these findings would hold in larger models with different architectures and training. Have the authors considered ways to connect the toy results back to LLMs?
5 comments

We greatly appreciate your detailed feedback and in-depth reading of our paper. We have taken your comments into account and made several additions to the paper to address your concerns and make our writing clearer and more rigorous. All the changes are marked in blue.


Results across random seeds and hyperparameter settings are simply summarized in the text, with no tables or plots (e.g. L307–313).

We have added Appendix F with details on all of our runs across seeds and hyperparameter settings. We can clearly see multilingual training improves generalization over unilingual training and that warm-up even further improves generalization.


The Section 6 ablation results are similarly reported, with vague language like "Inputs in the other languages lose about the same amount"

We have added Table 1 and Table 2 in Appendix C showing the details of the Section 6 ablation results across all of our seeds and hyperparameters. We've also made the language in Section 6 more precise and fully detailed the experiment in the appendix. The detailed results in the appendix now fully support our claims in the paper.


Figures 5 and 6 show single qualitative examples. It would be more convincing to show metrics across seeds.

We believe that these figures are easier to understand when focusing on the results of individual runs, but we have included aggregate metrics in Appendix E. The detailed results in the appendix now fully support our claims in the paper.


Section 5 claims that standard-trained models have nearly orthogonal representations across languages, but this is only supported qualitatively, by the heatmaps and spectra in Figures 5 and 6. And these figures are not explicitly used as evidence for the claim.

In the aggregated results that we have added in Appendix E, we show that grokked standard-trained models have an average cosine similarity not significantly different from 0 at the final checkpoint, which demonstrates that representations are orthogonal across languages. The detailed results in the appendix now fully support our claims in the paper.


Figure 1(d, e) shows cosine similarity for the toy model with and without warm-up. This is arguably the most direct evidence for representation alignment, but it isn't discussed in the text.

We have added a paragraph in Section 5 at L318 discussing Figure 1(d, e) and referencing the aggregated figures in Appendix E. The detailed results in the appendix provide solid evidence that warmed-up models have more aligned representations and standard-trained models have nearly orthogonal representations.


Figure 4 is also never referenced in the text.

It is now referenced at L304 in Section 5.1.


Section 6 constructs the relabeled model at the start, but only uses it in the final paragraph, as a check that the ablation test can detect sharing. The organization could be improved.

We've edited and reorganized this section to be easier to follow.


The text says warm-up lasts 10,000 epochs, but in Figure 4 the swap to hard labels occurs at 25,000 epochs.

In a majority of our experiments warm-up only lasts 10,000 epochs, but in others we do switch at 25,000. In our new appendices, we specify which runs swap at 10,000 vs 25,000. In general, we swap later in models where the hyperparameters make it hard to grok. We have added an explanation in more detail in Appendix F (see the caption of Table 9) and mention it briefly in the main text in footnote 7 on page 5.


The number of languages used in the main experiments is never stated explicitly.

The number of languages in our multilingual experiments is always 4. This is now mentioned in the paper in footnote 4 at L209.


The introduction says that "whenever multilingual modular addition models generalize, we observe the emergence of shared circuits that internally perform the same computations regardless of language, with language-specific translation occurring only in the first and last layers." The only direct support is the Section 6 ablation, and the paper doesn't show where language-specific processing happens in standard-trained models.

In the newly added results in Appendix C, we see that all multilingual grokked runs (independent of training regime) share circuits as verified by the Section 6 ablation test. Although we do believe that the translation happens mainly in the first and the last layer, this is not the main focus of the paper and we don't have enough evidence to confirm this yet, which is why we have removed it from the paper.


The introduction also says that warm-up allows "for easier mechanistic analysis," but there's no analysis that shows this.

We mean to say that warming-up models cause their representations to reflect the structure of their circuits, in the sense that warmed-up grokked models have shared representations reflecting their shared circuits, while standard-trained grokked models have unshared representations despite shared circuits. Common representation-level mechanistic analyses would come to the wrong conclusion on standard-trained models, but would easily find cross-lingual sharing in warmed-up models. We have changed the phrase from "for easier mechanistic analysis" to "ensuring that representation-level analyses reflect shared circuits if they exist" to be more clear about what we mean.


Later in the introduction, it's claimed that "after our intervention, shared circuits stay intact even after extended training with the original data," and Section 5.1.1 says something similar about representations. However, the authors don't actually do any analysis of how circuits or representations change during training, e.g. by looking at model checkpoints.

We have edited the paper to say "shared representations" instead of "shared circuits." When we say that representations stay intact we mean that once a model has shared key frequencies across languages, this does not change even with extended training using the original data. In the newly added Appendix F, we plot cosine similarity across languages over the course of model training to demonstrate that switching back to hard labels does not destroy shared representations or shared circuits. We think that shared representations always imply shared circuits (but not always the other way around).


In Section 5.1.1, matching key frequencies are used as evidence for "shared representations of numerical concepts across languages" (see below).

The newly added Figure 7 in Appendix E shows that for all models where frequencies are shared across languages (i.e. grokked warmed-up models), cross-lingual cosine similarity is also high, and hence we can say with confidence that two languages encode the same number using the same frequency and in the same coordinates of the hidden space.


The authors note that … "sudden generalization" observed by the authors.

If one defines "generalization" as high accuracy on unseen test samples, then the generalization suddenly improves directly after warm-up. However, we fully agree that if one defines "generalization" as "the model internally discovers the general abstract pattern to a large extent", then this already happens during the training on aggregated labels. In other words, during training with aggregated labels, the model generalizes to the language-translation-invariant warm-up distribution (not the original language-translation-equivariant distribution), and very quickly after the switch to hard labels the model adapts to generalize to the original distribution.


Questions

1. In the Section 4 transfer experiment, how much data does the minority-only model see? Is it trained on the same total amount of data as the multilingual model, or only on the minority-language portion (i.e. a much smaller fraction)? If the latter, then even with the same number of epochs, the minority-only model sees far less data and possibly takes fewer gradient steps, so this would not be a fair comparison.

The latter: the minority-only model sees only the minority-language portion, so the same amount of minority-language data as the multilingual model, but much less data in total. Based on your comments we have run two additional minority-only experiments to make the comparison more fair (see Table 4, Figure 9 in Appendix F) and changed Section 4 on cross-lingual transfer to refer to these new, fairer experiments.

  • New experiment 1: We change the batch size in the minority-only model such that the number of gradient steps (total and per epoch) exactly matches the multilingual models and the number of minority-language samples in each batch matches the multilingual models in expectation.
  • New experiment 2: We run the multilingual model but change the labels in the majority languages to 0, while leaving the minority-language labels intact.

Both new experiments still show much poorer generalization (13 out of 67 seed/hyperparameter combinations grok in the best minority-only control vs 37 out of 67 with the standard-trained multilingual model). Thank you for this comment! It was very helpful in sharpening our experiments.


2. In Figure 4, the standard-trained model doesn't generalize, with near-zero test accuracy throughout training, while Section 4 reports that standard-trained models reach >99% validation accuracy in 23 of 25 seeds. Could the authors clarify the setup for Figure 4, and how it differs from what is reported in Section 4?

Changing the hyperparameters yields different behavior, which you can now see more clearly in our tables and plots in Appendix F. For example, higher train fraction yields a higher rate of grokking. What is consistent across hyperparameter settings is that (1) grokking occurs more often among warmed-up runs than standard multilingual runs with the same hyperparameters; and (2) multilingual runs grok the minority language more often than minority-only runs.

The main change in the setup in Figure 4 is that we allow the input sequence-length to vary from only 3 (a,b,=a, b, =) to either 3, 4, or 5, so the model is trained to compute a+b+ca + b + c and a+b+c+da + b + c + d in addition to only a+ba + b. We now detail this setting in Appendix B. This setting is ideal for comparing warm-up to standard training because the task becomes very difficult, so not even the majority language has enough data to grok in standard training, while warm-up can still sometimes grok.


3. The setting is very toy, and it's unclear whether these findings would hold in larger models with different architectures and training. Have the authors considered ways to connect the toy results back to LLMs?

Whether our findings hold in LLMs was the most common question across reviews, so we've answered it once and included the same response for each reviewer who raised it.

We're interested in a couple of ways to potentially extend the results to LLMs, which we now discuss in the paper in Section 8.

One is to estimate an analogue of the aggregated labels for LLMs to try to make training faster and yield more interpretable models, in the sense of encouraging similar representations for concepts that use similar circuits. We have several ideas for an analogue of warm-up for LLMs. Here is one such idea: at each token in the training corpus, have a cheap model decide whether a new word has just started. If so, pick a random real-world language ℓ\ell, and give an existing LLM the full context of the current training sample with preamble instructions to predict what the next word would be if the next word was instead in language ℓ\ell. Then, assign loss using the first token of the translated next word instead of the true next word. (You could also translate to several random languages and assign loss using the mean over the languages of the first token.) Do this procedure for some amount of epochs, and then swap to usual training as in our method.

Another idea is to try to extend the language-ℓ\ell subspace method used for the ablations in the toy models to LLMs to examine cross-lingual circuit sharing in larger models, possibly using MMMLU.

The distinction between shared circuits and shared representations in our toy models is also a good demonstration that many common tools used for mechanistic interpretation (like cosine similarity, for example) can only detect shared representations and not shared circuits, so a null result on an actual LLM would not be enough to conclude that circuits aren't shared.

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

The paper presents a mechanistic study of multilingual modular addition as a toy setting for understanding representation sharing in multilingual models. The authors design a warm-up procedure that encourages representation sharing across languages and significantly improves performance. They also distinguish between circuit sharing and representation sharing through this setup.

Critical strengths

The problem is interesting and the toy setup is nice and clean for understanding how representation is shared and emerged with training.

Critical weaknesses
  • The definition of “shared representation” is unclear. How does this reconcile with prior work showing multilingual representations can occupy parallel/aligned subspaces?
  • The warm-up seems to bake in a strong inductive bias toward representation sharing. It is unclear what this tells us beyond the controlled setting or how this translates to realistic language-model training.
  • There are some missing references in the natural language spaces that are quite relevant to the study.
    • The Geometry of Multilingual Language Model Representations, Chang et al. 2022.
    • The Same but Different: Structural Similarities and Differences in Multilingual Language Modeling, Zhang et al., 2025
    • Cross-Lingual Alignment Without Joint Training: Do Monolingual Language Models Converge on Universal Representations?, Zhou et al., 2026
Questions for authors
  • What would be the analogue of this warm-up procedure in realistic multilingual LLM training?
  • The results suggest that greater representation sharing is beneficial in the toy setting in multilingual training, prior work suggests that some multilingual knowledge may be language-specific. How do the authors think about the tradeoff between shared and language-specific representations?
3 comments

Thank you for your review and for the helpful references. We have revised the paper to address your comments, and all changes are marked in blue.


The definition of "shared representation" is unclear. How does this reconcile with prior work showing multilingual representations can occupy parallel/aligned subspaces?

By shared representations we mean high cosine similarity between the activations (or embeddings) of the same input in different languages, after centering each language by its own mean (Section 2, L115). We have added a sentence to the paper that states this definition explicitly at L113. We distinguish this from shared circuits, and say that a model shares circuits if inputs in different languages are routed through the same subspaces of the hidden layer and reuse the same computations, which we test with the ablation experiment in Section 6.

Our definition is closely related to the prior work you mention. Chang et al. (2022) find that languages in XLM-R occupy similar linear subspaces after mean-centering, offset from each other along language-sensitive axes. Our matched mean cosine similarity removes this per-language offset in the same way. Zhou et al. (2026) find that even independently trained monolingual models can be aligned by a single rotation, which is a looser notion of sharing than ours. Warm-up models meet our stricter definition, since we see that matched mean cosine similarity exceeds 0.9 at every stage of the forward pass (Figure 1e), and all languages use the same key frequencies (high spectral cosine similarity, Table 3).

Standard-trained multilingual modular addition models surprisingly do not share representations even in the looser sense. Their languages put their Fourier power on mostly different frequencies (spectral cosine similarity close to 0, Table 3). A rotation of the representation space cannot move power from one frequency to another, so no single rotation can make the languages' embeddings match closely. Nevertheless, every grokked standard-trained run shares circuits across languages (Section 6, Table 1). Our toy model therefore shows that shared circuits do not require shared, or even alignable, representations. This complements Zhang et al. (2025), who also find shared circuits across languages in real LLMs.

The comparison to Zhou et al. (2026) is also related to our setting. Independently trained unilingual modular addition models learn the same type of geometry (circles at a few key frequencies), differing only in which frequencies they use. When multiple languages are trained together, data from the majority languages helps the minority language pick up this shared structure more cleanly than it would alone (Section 4), and warm-up helps even more (Section 5.1). So to summarize, on an abstract level Zhou's observations on LLMs agree with our multilingual modular addition models (some geometric principles are shared across models), but on a more concrete level, Zhou's observations differ from ours, as for a modular addition model trained without warm-up, representations cannot be simply translated by a rotation.


The warm-up seems to bake in a strong inductive bias toward representation sharing. It is unclear what this tells us beyond the controlled setting or how this translates to realistic language-model training.

We see the main takeaway as theoretical rather than methodological. Standard training already has some inductive bias towards a shared solution for this equivariant task, since every standard-trained run that groks shares circuits across languages (Section 6). But gradient descent often struggles to find this solution, which is why standard training groks inconsistently at low training fractions. With a little help at the start, the shared solution is much easier to find, and once found it is very stable, as the shared representations induced by warm-up remain intact for thousands of epochs after we switch back to hard labels (Figure 7, Appendix E).

We also think that there is a more general pattern here, that a task that is invariant to the language may be easier to learn than one that is equivariant to it, so first training on an invariant version of a task and then switching to the equivariant one could make learning easier in general. Warm-up is one instance of this. We also find that the benefit does not depend on the exact form of the aggregated labels, since warm-up with one-hot labels in a randomly chosen language performs nearly as well (60/67 vs. 62/67 runs grok the minority language, Table 5), which is closer to what a translation-based warm-up for LLMs would provide (see our answer to Question 1 below).


There are some missing references in the natural language spaces that are quite relevant to the study.

Thank you for these references. We have added all three to the related work in Appendix A.1.

What would be the analogue of this warm-up procedure in realistic multilingual LLM training?

(Whether our findings hold in LLMs was the most common question across reviews, so we've answered it once and included the same response for each reviewer who raised it.)

We're interested in a couple of ways to potentially extend the results to LLMs, which we now discuss in the paper in Section 8.

One is to estimate an analogue of the aggregated labels for LLMs to try to make training faster and yield more interpretable models, in the sense of encouraging similar representations for concepts that use similar circuits. We have several ideas for an analogue of warm-up for LLMs. Here is one such idea: at each token in the training corpus, have a cheap model decide whether a new word has just started. If so, pick a random real-world language ℓ\ell, and give an existing LLM the full context of the current training sample with preamble instructions to predict what the next word would be if the next word was instead in language ℓ\ell. Then, assign loss using the first token of the translated next word instead of the true next word. (You could also translate to several random languages and assign loss using the mean over the languages of the first token.) Do this procedure for some amount of epochs, and then swap to usual training as in our method.

As a first step toward this, we have tested a version of this in the toy model, where each warm-up label is the correct sum in one randomly chosen language, instead of the aggregated label over all languages. This is the kind of supervision a translation-based warm-up would provide in an LLM. We find that this random-language label regime performs nearly as well as warm-up (60/67 runs grok with random-language labels vs 62/67 runs in warm-up, see Table 5). Because random-language labels work nearly as well as aggregated labels, that would suggest a translation-based warm-up for LLMs is worth trying. It would also let us study questions that the toy model cannot answer, such as whether pretrained LLMs already share as much representation across languages as would help their minority languages. We are interested in pursuing this translation-based warm-up for LLMs in future work, as well as other ideas for extending warm-up to LLMs.

We are also interested in extending our mechanistic analysis to LLMs and developing methods to understand if LLMs can also share circuits without sharing representations: the distinction between shared circuits and shared representations in our toy models is a good demonstration that many common tools used for mechanistic interpretation (like cosine similarity for example), can only detect shared representations and not shared circuits. A cosine similarity of zero on an actual LLM, for example, would not be enough to conclude with certainty that circuits aren't shared.

Another idea is to try to extend the language ℓ\ell subspace method used for the ablations in the toy models to LLMs to examine cross-lingual circuit sharing in larger models, possibly using MMMLU.


The results suggest that greater representation sharing is beneficial in the toy setting in multilingual training, prior work suggests that some multilingual knowledge may be language-specific. How do the authors think about the tradeoff between shared and language-specific representations?

In this paper we focus on a perfectly equivariant setting, where the mathematics does not depend on the language and sharing is only beneficial. Many real-world tasks are partly language-specific. For those, an inductive bias to abstract the language away could cause a model to miss language-specific nuances. However, we expect that training with sufficiently large datasets and architectures leads models to learn additional circuits for these language-specific exceptions on top of the shared ones. This matches Zhang et al.'s observation that in real LLMs models reuse the same circuit for a process that is shared across languages, and use language-specific components only for processes that exist in some languages but not others. In future work, we want to study this tradeoff in toy settings that are still simple enough to interpret but rich enough to contain language-specific structure. In this paper, we focused on the cleanest and simplest case.

Thank you for your detailed response. I maintain my original positive score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.