README.md

---
license: apache-2.0
tags:
- model-merging
- alignment
- polypythia
- goldfish
- multilingual
- blimp
---

# Compose-audit: putting the alignment map and the merging payoff on the SAME real models

_Generated 2026-08-26 23:25 UTC · training-free · code: `/root/compose-audit` · operators/aligners/metrics imported unmodified from `mergeschool.core` (`/root/mergeability`, treated as read-only)._

## Read this first: what substrate, and what metric

| | SET 1 | SET 4 |
|---|---|---|
| **Substrate** | `EleutherAI/pythia-{14m,31m,70m,160m,410m}-seed{1..9}` (PolyPythia) — real reseeded LMs | `goldfish-models/eng_latn_1000mb` × `{nld,spa,ell,pol}_*_1000mb` — the real bilingual-composition models, GPT-2 arch, 125M |
| **What varies between the two parents** | the init/data-order **seed only**. Same data, same architecture, same tokenizer → the merge obstruction is *purely coordinate* | the **language** and the **tokenizer**. Independently initialised, independently trained |
| **Held-out corpus** | FLORES-200 devtest `eng_Latn` | FLORES-200 devtest, `eng_Latn` + the partner language |
| **Metric** | Δfloor in **nats/token** vs the better parent; **BLiMP accuracy** on the same merges | Δfloor in **nats per UTF-8 byte** vs the better parent (bytes, because the two parents use different tokenizers and nats/token is not comparable across them); **MultiBLiMP 1.0 accuracy** on the same merges |
| **What the metric is** | Δfloor is a **likelihood** metric; BLiMP is an **accuracy** metric | Δfloor is a **likelihood** metric; MultiBLiMP is an **accuracy** metric |

> **Δfloor is a likelihood metric, not benchmark accuracy — and here they come apart.** The audit's
> sharpest point is that a likelihood rescue has not been shown to transfer to accuracy. We tested
> that transfer directly, on the same merges, with BLiMP (SET 1) and MultiBLiMP 1.0 (SET 4), and it
> **does not hold in either direction**: in SET 1 a ~70% Δfloor rescue buys ~0.03 BLiMP accuracy over
> the naive merge, and in SET 4 a merge whose Δfloor says it is destroyed still scores 0.68 on
> MultiBLiMP-English. Neither metric may be reported as a proxy for the other. Every table below
> states which one it is.


## Headline findings

1. **Naive averaging of two seed-only-different real LMs is catastrophic, at every size.** Δfloor 14m: +32.4 · 31m: +20.4 · 70m: +20.2 · 160m: +9.0 · 410m: +6.5 nats/token against parent floors of 3–4.4 nats/token, i.e. above the uniform-over-vocabulary reference of 10.8 for all but the largest. n = 36 / 36 / 36 / 36 / 15 pairs.
2. **Unit alignment removes a large fraction of that gap and still does not produce a usable model.** The exactly function-preserving permutation rung removes 14m: 70% · 31m: 48% · 70m: 44% · 160m: 23% · 410m: 8% — leaving 9.6 · 9.6 · 11.0 · 6.8 · 6.0 nats/token above the better parent, i.e. an absolute 14.0 · 13.5 · 14.6 · 10.0 · 8.9 nats/token against parent floors of 3.0–4.4 and a uniform-over-vocabulary reference of 10.8. At 14m, 31m, 70m the aligned merge is still *worse than predicting uniformly over the vocabulary*; at the larger sizes it is below that line but still 2–3x the parent's loss. (A Procrustes rung is also reported, but it is **not** function-preserving on LayerNorm transformers — see Validation — so the coordinate claim rests on the permutation rung.)
3. **The rescue shrinks monotonically with scale** (14m: 70% → 410m: 8% on the exact rung) while the naive gap shrinks too — so the coordinate-removable share of the obstruction is falling in exactly the direction the field is scaling. (Per-size n is listed in (1); the largest sizes carry the fewest pairs, so read the trend from the sizes with complete 36-pair grids and treat the largest as directional.)
4. **The likelihood rescue does not transfer to accuracy — and this is the sharpest result here.** Same merges, scored on BLiMP. On pythia-14m (n=36) parents average 0.652, the naive merge 0.518 and the aligned merge 0.544, against chance 0.500 — a ~70% Δfloor rescue buys ~0.026 accuracy, and pair by pair the two rescues are uncorrelated. Across the ladder the merged model scores 14m 0.547 · 31m 0.550 · 70m 0.554 · 160m 0.553 · 410m 0.556 — it retains 29%→19% of the parents' above-chance margin — while the likelihood rescue over the same range falls from ~70% to ~8%. The accuracy the merge keeps is essentially independent of how much likelihood alignment recovered.
5. **On the real bilingual-composition models the merge fails and alignment does not rescue it.** Goldfish eng×{nld,spa,ell,pol}: naive Δfloor on English text +0.91 nats/byte against a 0.81 floor; the best M1 rung +0.90. The binding constraint is the **vocabulary**, not the coordinate frame — the English tokenizer UNK-s 45% of Greek and 11% of Polish, and no permutation or rotation can address that. Anchoring on the partner language instead (whose tokenizers handle English at <0.1% UNK) removes that wall and the merge still fails.
5b. **Give alignment a shared vocabulary and it finally does something — still not enough.** Merging two *bilingual* B-GPT models of the same language pair (~94% tokenizer overlap instead of 13–28%), vocabulary transport plus unit alignment moves MultiBLiMP from 0.618 to 0.655 and Δfloor from +1.04 to +0.87 nats/byte. The parents are at 0.96 and Δfloor 0. This is the clean decomposition: vocabulary is the wall in SET 4, and independent training is the wall behind it.
6. **…and the accuracy dissociation runs the other way there.** The same likelihood-destroyed Goldfish merges retain 0.68 on MultiBLiMP-English (parent 0.96, chance 0.50). Δfloor and benchmark accuracy dissociate in **both** directions; neither implies the other.
7. **P0-2: the pre-merge predictors do not reliably predict the realised rescue.** Held out by seed pair, with a seed-cluster permutation null and BH within the five-predictor family the audit brief itself names: **0 of 25 cells significant**. The strongest predictor is the coordinate share — AUROC 0.81 at pythia-70m with a raw permutation p of 0.002 — and its held-out AUROC across the substrates is 14m: 0.48 · 31m: 0.71 · 70m: 0.81 · 160m: 0.61 · 410m: 0.45 — i.e. it does not replicate. Nothing survives BH across the wider exploratory family either. Reported as the negative transfer result it is.
8. **The residual obstruction is not coordinate.** A same-basin control (the 160M Pythia data-seed / weight-seed ablations, weight cosine 0.56 against 0.02 for two PolyPythia seeds) still pays ~3.1 nats/token to a naive average, and alignment removes only a few percent of it — correctly, since there is no coordinate mismatch left. Merging is not free even inside a basin, and what remains after alignment is not something the permutation group describes.
9. **This is not an under-trying artifact.** REPAIR-style statistics correction on top of the alignment — the strongest training-free merge here — improves the likelihood further and still leaves BLiMP near chance.


## SET 1 · PolyPythia seed-merge (the pure-coordinate ceiling)

C(9,2) = 36 seed pairs per size. Predictors are computed **before** any merge; the alignment factors (residual basis map fitted from activations on the shared corpus, free MLP hidden axis, attention heads) are each accepted only if they do not increase the scale-free block-normalised weight distance.


### pythia-14m — 36 seed pairs · mean parent floor **4.375** nats/token · uniform-over-vocabulary reference **10.826** nats/token

| rung | n | mean nats/tok | mean Δfloor | median Δfloor | best Δfloor | beats naive | % of naive Δfloor removed |
|---|---|---|---|---|---|---|---|
| M0_naive_avg | 36 | 36.80 | 32.43 | 30.89 | 23.07 | 0/36 | 0.0% |
| M1_perm_avg | 36 | 13.98 | 9.61 | 9.01 | 5.27 | 36/36 | 69.9% |
| M1_orth_avg | 36 | 20.38 | 16.01 | 14.07 | 6.63 | 35/36 | 50.5% |
| M2_task_arith | 36 | 151.17 | 146.80 | 141.85 | 93.41 | 0/36 | -358.6% |
| M3_ties | 36 | 245.90 | 241.52 | 236.11 | 126.48 | 0/36 | -651.2% |

Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **34.14**, permutation-aligned **10.18** nats/token.


### pythia-31m — 36 seed pairs · mean parent floor **3.938** nats/token · uniform-over-vocabulary reference **10.826** nats/token

| rung | n | mean nats/tok | mean Δfloor | median Δfloor | best Δfloor | beats naive | % of naive Δfloor removed |
|---|---|---|---|---|---|---|---|
| M0_naive_avg | 36 | 24.29 | 20.35 | 20.09 | 10.28 | 0/36 | 0.0% |
| M1_perm_avg | 36 | 13.54 | 9.60 | 8.87 | 5.68 | 35/36 | 47.7% |
| M1_orth_avg | 36 | 14.45 | 10.51 | 9.72 | 5.91 | 35/36 | 46.4% |
| M2_task_arith | 36 | 97.24 | 93.30 | 89.81 | 46.94 | 0/36 | -366.7% |
| M3_ties | 36 | 95.22 | 91.28 | 91.86 | 32.78 | 0/36 | -357.9% |

Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **20.30**, permutation-aligned **9.56** nats/token.


### pythia-70m — 36 seed pairs · mean parent floor **3.626** nats/token · uniform-over-vocabulary reference **10.826** nats/token

| rung | n | mean nats/tok | mean Δfloor | median Δfloor | best Δfloor | beats naive | % of naive Δfloor removed |
|---|---|---|---|---|---|---|---|
| M0_naive_avg | 36 | 23.79 | 20.16 | 18.93 | 13.88 | 0/36 | 0.0% |
| M1_perm_avg | 36 | 14.62 | 10.99 | 8.77 | 6.69 | 31/36 | 43.9% |
| M1_orth_avg | 36 | 13.32 | 9.70 | 9.90 | 6.30 | 36/36 | 50.4% |
| M2_task_arith | 36 | 95.14 | 91.52 | 90.58 | 45.14 | 0/36 | -357.8% |
| M3_ties | 36 | 151.39 | 147.77 | 147.75 | 112.97 | 0/36 | -650.7% |

Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **20.17**, permutation-aligned **10.98** nats/token.


### pythia-160m — 36 seed pairs · mean parent floor **3.252** nats/token · uniform-over-vocabulary reference **10.826** nats/token

| rung | n | mean nats/tok | mean Δfloor | median Δfloor | best Δfloor | beats naive | % of naive Δfloor removed |
|---|---|---|---|---|---|---|---|
| M0_naive_avg | 36 | 12.25 | 8.99 | 8.47 | 6.88 | 0/36 | 0.0% |
| M1_perm_avg | 36 | 10.02 | 6.77 | 6.44 | 5.50 | 33/36 | 23.5% |
| M1_orth_avg | 36 | 9.44 | 6.19 | 6.22 | 5.13 | 36/36 | 30.3% |
| M2_task_arith | 36 | 30.85 | 27.60 | 27.55 | 17.88 | 0/36 | -205.3% |
| M3_ties | 36 | 61.55 | 58.29 | 57.97 | 49.30 | 0/36 | -557.4% |

Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **8.99**, permutation-aligned **6.76** nats/token.


### pythia-410m — 15 seed pairs · mean parent floor **2.984** nats/token · uniform-over-vocabulary reference **10.826** nats/token

| rung | n | mean nats/tok | mean Δfloor | median Δfloor | best Δfloor | beats naive | % of naive Δfloor removed |
|---|---|---|---|---|---|---|---|
| M0_naive_avg | 15 | 9.51 | 6.53 | 6.50 | 5.95 | 0/15 | 0.0% |
| M1_perm_avg | 15 | 8.94 | 5.96 | 5.82 | 5.56 | 12/15 | 8.3% |
| M1_orth_avg | 15 | 9.01 | 6.03 | 6.04 | 5.44 | 13/15 | 7.4% |
| M2_task_arith | 15 | 14.15 | 11.17 | 10.69 | 5.28 | 1/15 | -71.5% |
| M3_ties | 15 | 13.04 | 10.06 | 10.17 | 9.32 | 0/15 | -54.7% |

Linear-mode-connectivity barrier (`eval.merge_barrier`): naive **6.54**, permutation-aligned **5.93** nats/token.


**What this says.**

1. **Naive averaging of two same-data, same-architecture, same-tokenizer models that differ only in
   seed is catastrophic.** The merged model's loss is tens of nats/token above the better parent —
   far above the uniform-over-vocabulary reference, i.e. the merge is not a degraded model, it is a
   destroyed one. This is the pure-coordinate case: there is no data, architecture or tokenizer
   difference left to blame.
2. **Unit alignment removes a large, highly consistent fraction of that gap** — the permutation rung
   beats naive on essentially every pair — **and still does not produce a usable model.** At 14m/31m/70m
   the aligned merge is still *worse than predicting uniformly over the vocabulary*; at 160m/410m it
   drops below that line but still sits at 2–3× the better parent's loss. So on real LMs at this
   scale, alignment *predicts and reduces* the obstruction without *enabling* the merge. Reporting
   the reduction as "merging works once you align" would be wrong.
3. **Task-arithmetic and TIES are not applicable here and the numbers show it.** PolyPythia seeds are
   independent re-initialisations: `EleutherAI/pythia-<size>` is *not* a shared ancestor, so the
   "task vectors" those operators subtract are not task vectors. Their rows are reported only to
   document that the shared-base family degenerates when the base is not shared.
4. **There is no interpolation coefficient that helps.** Across every linear-mode-connectivity curve
   computed here — 302 of them, naive and aligned, over all five sizes — **not one has an interior
   minimum**. The best point on the path is always an endpoint, i.e. one of the parents. Tuning the
   merge weight is not a way out.


### Validation: is the alignment actually function-preserving? (One rung is not.)

Every M1 rung is only an *alignment* if `g.θ_B` computes exactly what `θ_B` computes. This was checked
empirically rather than assumed: take a parent, apply the map, and re-evaluate.


| substrate | map | change in the parent's nats/token | verdict |
|---|---|---|---|
| set1_pythia14m | permutation_residual+mlp | +3.026e-06 | EXACT |
| set1_pythia14m | permutation_full(+heads) | +5.893e-06 | EXACT |
| set1_pythia14m | orthogonal_residual+mlp | +27.262 | **NOT function-preserving** |
| set4_goldfish_nld | perm_residual_only | +0.000e+00 | EXACT |
| set4_goldfish_nld | mlp_only | +0.000e+00 | EXACT |
| set4_goldfish_nld | heads_only | +0.000e+00 | EXACT |
| set4_goldfish_nld | perm_full | +0.000e+00 | EXACT |
| set4_goldfish_nld | orth_full | +0.069 | negligible |

**The permutation family is exact** — residual basis, free MLP hidden axis and attention heads, on
both architectures, to float32 noise. Those rungs are genuine alignments.

**The orthogonal/Procrustes residual map is not**, and on GPTNeoX it is badly not: applying it to a
PolyPythia parent costs that parent **+27 nats/token on its own**. The reason is structural rather
than a bug — LayerNorm subtracts the mean over the residual axis and applies a learned elementwise
gain, and neither commutes with a general rotation (an RMSNorm model would be much closer to safe).
On the GPT-2 Goldfish models the same map costs only +0.07 nats/token, so the defect is
architecture-specific in magnitude.

**Internal consistency.** The BLiMP, REPAIR and SLERP arms each re-derive the alignment and the
merges from scratch, in separate processes, from the raw checkpoints. On the pairs they share with
the main SET 1 grid they reproduce its `M0` and `M1` Δfloor values to **machine precision** (max
absolute difference 0.0000 over 116 and 18 overlapping pairs respectively). The rungs compared across
sections are the same objects, not merely the same recipe.

**Consequence for the tables.** The `M1_orth` / `M1c` / `M1e` rows are still *real measurements of a
merged model's loss* — a merge is a merge, and the number is what it is — but they must **not** be
read as "how much of the obstruction is coordinate". On SET 1 they merge parent A with a *damaged*
copy of parent B, and any apparent rescue is partly the arithmetic of averaging toward one parent.
The coordinate claim in this report rests on the **permutation** rung, which is exact. Where the two
disagree, believe the permutation rung. This is flagged again at every table that contains an
orthogonal row.


### The scale trend — alignment's coordinate rescue WEAKENS with model size

| substrate | n pairs | parent floor | naive Δfloor | rescue, permutation | rescue, Procrustes | rescue, best of the two | unaligned CKA | aligned CKA | weight coordinate share |
|---|---|---|---|---|---|---|---|---|---|
| pythia-14m | 36 | 4.38 | 32.43 | 69.9% | 50.5% | 72.0% | 0.588 | 0.374 | 0.0652 |
| pythia-31m | 36 | 3.94 | 20.35 | 47.7% | 46.4% | 57.4% | 0.632 | 0.380 | 0.0645 |
| pythia-70m | 36 | 3.63 | 20.16 | 43.9% | 50.4% | 55.1% | 0.671 | 0.428 | 0.0793 |
| pythia-160m | 36 | 3.25 | 8.99 | 23.5% | 30.3% | 32.0% | 0.747 | 0.761 | 0.0867 |
| pythia-410m | 15 | 2.98 | 6.53 | 8.3% | 7.4% | 10.4% | 0.463 | 0.412 | 0.0355 |

Read the **permutation** column: it is the one that is exactly function-preserving (see Validation
above). The Procrustes column is shown for completeness but on GPTNeoX that map damages the model it
is applied to, so its "rescue" is not a clean coordinate measurement.

The coordinator flagged this trend from the first two pairs and asked whether it survives the full
grid. **It does, monotonically, across every size we ran, on the exact rung alone.** The naive merge's Δfloor shrinks with scale
*and* the share of it that alignment can remove shrinks faster. Two things are worth separating:

- The **naive** merge gets less catastrophic with scale, which on its own would be an encouraging
  trend for merging.
- The **alignment rescue** shrinks at the same time. So the improvement at larger scale is not
  something the coordinate story is buying; the coordinate-removable component of the obstruction is
  a *decreasing* fraction of the total. Whatever is left over at 160m is not a coordinate problem,
  and the same aligners that recover most of the 14m gap recover a quarter of it.

That is a caution for the manuscript's central thesis, not a confirmation of it: alignment predicts
and reduces the obstruction most where the obstruction matters least, and its purchase falls away in
exactly the direction the field is scaling.


## SET 4 · Goldfish monolingual → bilingual merge (the real composition models)


**Tokenizer diagnostic — read this before any SET 4 number.** The merged model lives in the *English* parent's token-id space, so partner-language text must be tokenized with the English tokenizer. It cannot represent much of that text:

| text | UNK rate, English tokenizer | UNK rate, own tokenizer | UNK rate, partner tokenizer on ENGLISH text | bytes/token, English tok | bytes/token, own tok |
|---|---|---|---|---|---|
| eng_Latn | 0.1% | 0.1% | — | 4.92 | 4.92 |
| nld_Latn | 0.3% | 0.1% | 0.1% | 2.71 | 5.09 |
| spa_Latn | 5.3% | 0.1% | 0.0% | 2.83 | 5.01 |
| ell_Grek | 46.5% | 0.0% | 0.1% | 5.73 | 8.92 |
| pol_Latn | 11.4% | 0.0% | 0.1% | 2.24 | 5.15 |

**The wall is one-directional.** Every partner tokenizer handles English at under 0.1% UNK; the English tokenizer cannot represent Greek or Polish. At a 46.5% UNK rate the English parent's *apparent* likelihood on Greek text is an artifact — it is confidently predicting `<unk>`, not modelling Greek — so it is not used as a floor. The partner-language floor below is the partner parent evaluated with its **own** tokenizer. The **English-side** column is the clean one (0.07% UNK) and is the primary SET 4 number.

Uniform-over-vocabulary reference (a model that has learned nothing), mean over the two languages, in the same units: **eng-nld_Latn** 3.093, **eng-spa_Latn** 2.920, **eng-ell_Grek** 2.964, **eng-pol_Latn** 3.221 nats/byte.


**PRIMARY — Δfloor on ENGLISH text vs the English parent (nats/UTF-8 byte).** This cell has no tokenizer artifact: the merge is asked only to retain what the English parent already had.

| pair | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1d_vocab_perm_forced | M1e_vocab_orth_forced | M1g_emb_procrustes | M1h_emb_proc_units | M1f_perm_novocab |
|---|---|---|---|---|---|---|---|---|---|
| eng–nld_Latn | 0.889 | 1.056 | 1.058 | 1.058 | 1.167 | 0.990 | 1.085 | 0.975 | 0.891 |
| eng–spa_Latn | 0.892 | 1.034 | 1.033 | 1.033 | 1.131 | 1.054 | 0.973 | 0.970 | 0.891 |
| eng–ell_Grek | 0.983 | 1.054 | 1.054 | 1.054 | 1.080 | 1.041 | 0.965 | 1.006 | 0.983 |
| eng–pol_Latn | 0.859 | 0.976 | 0.976 | 0.976 | 1.093 | 0.985 | 1.057 | 0.972 | 0.859 |
| **mean of the 4** | **0.906** | **1.030** | **1.030** | **1.030** | **1.118** | **1.018** | **1.020** | **0.981** | **0.906** |

**On the clean English cell, every M1 rung is *worse* than the naive merge**: naive 0.906,
best M1 0.906 nats/byte averaged over the four pairs. Averaged over both languages the best M1
rung removes 1.4% of the naive Δfloor — within noise of zero. For contrast,
on SET 1, where the two parents share data, architecture and tokenizer and differ only in seed, the
same family of aligners removes ~70% at 14M. **The Goldfish obstruction is not the kind of
obstruction alignment addresses.** The rest of this section establishes why: the binding constraint
is the vocabulary, and it lives on an axis the alignment group does not act on.


**Δfloor vs the better parent, mean over the two languages, nats/UTF-8 byte** (lower is better; 0 would mean the merge matches the better parent):

| pair | vocab overlap | floor eng | floor X (own tok) | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1d_vocab_perm_forced | M1e_vocab_orth_forced | M1g_emb_procrustes | M1h_emb_proc_units | M1f_perm_novocab |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| eng–nld_Latn | 27.8% | 0.811 | 0.792 | 1.689 | 1.763 | 1.766 | 1.766 | 2.004 | 1.601 | 1.732 | 1.559 | 1.691 |
| eng–spa_Latn | 23.1% | 0.811 | 0.746 | 1.643 | 1.637 | 1.635 | 1.635 | 1.831 | 1.632 | 1.503 | 1.426 | 1.643 |
| eng–ell_Grek | 12.9% | 0.811 | 0.428 | 0.844 | 0.942 | 0.943 | 0.943 | 1.491 | 1.353 | 1.078 | 1.202 | 0.844 |
| eng–pol_Latn | 15.5% | 0.811 | 0.799 | 1.789 | 1.687 | 1.687 | 1.687 | 2.065 | 1.656 | 1.693 | 1.693 | 1.789 |

**Split by language, and Δ vs naive:**

| pair | rung | Δfloor eng | Δfloor X | Δ vs naive (mean) |
|---|---|---|---|---|
| eng–nld_Latn | M0_naive_avg | 0.889 | 2.489 | 0.000 |
| eng–nld_Latn | M1a_vocab_avg | 1.056 | 2.471 | 0.074 |
| eng–nld_Latn | M1b_vocab_perm_avg | 1.058 | 2.474 | 0.077 |
| eng–nld_Latn | M1c_vocab_orth_avg | 1.058 | 2.474 | 0.077 |
| eng–nld_Latn | M1d_vocab_perm_forced | 1.167 | 2.840 | 0.314 |
| eng–nld_Latn | M1e_vocab_orth_forced | 0.990 | 2.211 | -0.089 |
| eng–nld_Latn | M1g_emb_procrustes | 1.085 | 2.380 | 0.043 |
| eng–nld_Latn | M1h_emb_proc_units | 0.975 | 2.143 | -0.130 |
| eng–nld_Latn | M1f_perm_novocab | 0.891 | 2.491 | 0.002 |
| eng–spa_Latn | M0_naive_avg | 0.892 | 2.395 | 0.000 |
| eng–spa_Latn | M1a_vocab_avg | 1.034 | 2.240 | -0.007 |
| eng–spa_Latn | M1b_vocab_perm_avg | 1.033 | 2.238 | -0.008 |
| eng–spa_Latn | M1c_vocab_orth_avg | 1.033 | 2.238 | -0.008 |
| eng–spa_Latn | M1d_vocab_perm_forced | 1.131 | 2.531 | 0.187 |
| eng–spa_Latn | M1e_vocab_orth_forced | 1.054 | 2.210 | -0.011 |
| eng–spa_Latn | M1g_emb_procrustes | 0.973 | 2.032 | -0.141 |
| eng–spa_Latn | M1h_emb_proc_units | 0.970 | 1.883 | -0.217 |
| eng–spa_Latn | M1f_perm_novocab | 0.891 | 2.396 | -0.000 |
| eng–ell_Grek | M0_naive_avg | 0.983 | 0.706 | 0.000 |
| eng–ell_Grek | M1a_vocab_avg | 1.054 | 0.829 | 0.097 |
| eng–ell_Grek | M1b_vocab_perm_avg | 1.054 | 0.831 | 0.098 |
| eng–ell_Grek | M1c_vocab_orth_avg | 1.054 | 0.831 | 0.098 |
| eng–ell_Grek | M1d_vocab_perm_forced | 1.080 | 1.901 | 0.646 |
| eng–ell_Grek | M1e_vocab_orth_forced | 1.041 | 1.665 | 0.509 |
| eng–ell_Grek | M1g_emb_procrustes | 0.965 | 1.191 | 0.234 |
| eng–ell_Grek | M1h_emb_proc_units | 1.006 | 1.397 | 0.358 |
| eng–ell_Grek | M1f_perm_novocab | 0.983 | 0.704 | -0.001 |
| eng–pol_Latn | M0_naive_avg | 0.859 | 2.719 | 0.000 |
| eng–pol_Latn | M1a_vocab_avg | 0.976 | 2.399 | -0.101 |
| eng–pol_Latn | M1b_vocab_perm_avg | 0.976 | 2.399 | -0.101 |
| eng–pol_Latn | M1c_vocab_orth_avg | 0.976 | 2.399 | -0.101 |
| eng–pol_Latn | M1d_vocab_perm_forced | 1.093 | 3.037 | 0.276 |
| eng–pol_Latn | M1e_vocab_orth_forced | 0.985 | 2.327 | -0.133 |
| eng–pol_Latn | M1g_emb_procrustes | 1.057 | 2.329 | -0.096 |
| eng–pol_Latn | M1h_emb_proc_units | 0.972 | 2.414 | -0.096 |
| eng–pol_Latn | M1f_perm_novocab | 0.859 | 2.719 | 0.000 |

**Rungs.** `M0_naive_avg` = straight weight average in raw index space (the merge the manuscript
reports as failing). `M1a_vocab_avg` = English/partner embedding + unembedding rows transported into
the English tokenizer's id space over shared surface forms, ids absent from the partner vocabulary
left at English's own row so the average over them is a no-op. `M1b/M1c` add the unit alignment
(residual-basis map fitted from **parallel** FLORES sentence representations — rows matched across
languages by sentence id — plus the free MLP hidden axis and the attention-head permutation), under
permutation and under Procrustes respectively, each factor accepted only if it does not increase the
block-normalised weight distance. `M1d/M1e` force the residual factor in regardless of that test.
`M1f_perm_novocab` isolates the unit alignment with **no** vocabulary transport.


## The accuracy test · does the likelihood rescue transfer? (BLiMP, SET 1)

PolyPythia parents are English LMs, so BLiMP applies directly to SET 1's merges. Scoring is the standard minimal-pair comparison: total log p over the sentence, correct when the grammatical member scores higher. **Chance = 0.500.** Same merges, same alignment, same pairs as the Δfloor tables above. Item budget is 200 minimal pairs per paradigm at 14M/31M/70M, 150 at 160M and 100 at 410M — 6,700–13,400 pairs per evaluation, which puts the binomial standard error on each cell below 0.006.

| substrate | n pairs | mean parent acc | better-parent ceiling | M0 naive | M1 permutation | M1 Procrustes | best rung, % of the parents' above-chance margin retained |
|---|---|---|---|---|---|---|---|
| pythia-14m | 36 | 0.652 | 0.664 | 0.518 | 0.533 | 0.530 | 28.5% |
| pythia-31m | 36 | 0.691 | 0.698 | 0.526 | 0.536 | 0.537 | 25.2% |
| pythia-70m | 36 | 0.717 | 0.722 | 0.516 | 0.541 | 0.542 | 24.4% |
| pythia-160m | 36 | 0.772 | 0.776 | 0.532 | 0.537 | 0.539 | 19.3% |
| pythia-410m | 15 | 0.789 | 0.802 | 0.535 | 0.543 | 0.543 | 18.5% |

**This is the result the audit asked for, and it is negative.** On pythia-14m the permutation
alignment removes ~70% of the naive merge's Δfloor in nats/token — and the merged model still scores
near chance on BLiMP, against parents at ~0.65. A large, consistent, statistically obvious
*likelihood* rescue buys essentially **no** grammatical competence back. "Recovery is not success"
is not a caveat to add to a positive result here; on this substrate it is the result.

**And the two quantities are flat against each other across the whole scale ladder.** The share of
the naive Δfloor that alignment removes falls from ~70% at 14M to ~11% at 410M — a sixfold change.
The share of the parents' above-chance BLiMP margin the merged model retains barely moves over the
same range: 28% → 25% → 24% → 19% → 19%. The merged model scores between 0.52 and 0.54 at *every*
size, whether alignment recovered three quarters of the likelihood gap or a tenth of it. Whatever
the likelihood rescue is buying, it is not this benchmark, and the amount of it makes almost no
difference.


Pair by pair, does the size of the likelihood rescue predict the size of the accuracy rescue? (Spearman, over seed pairs within a size.)

| substrate | n | Spearman(Δfloor rescue, BLiMP rescue) | mean Δfloor rescue (nats/tok) | mean BLiMP rescue (acc) |
|---|---|---|---|---|
| pythia-14m | 36 | 0.139 | 23.44 | 0.0257 |
| pythia-31m | 36 | -0.166 | 12.25 | 0.0211 |
| pythia-70m | 36 | 0.169 | 11.43 | 0.0361 |
| pythia-160m | 36 | 0.051 | 2.97 | 0.0179 |
| pythia-410m | 15 | 0.225 | 0.70 | 0.0165 |

## Did we try hard enough? · REPAIR on top of the alignment

The obvious objection to a negative merging result is that averaging is a weak merge: it halves the variance of every pre-activation, and REPAIR (Jordan et al., ICLR 2023) shows that restoring those statistics recovers most of the remaining barrier on vision nets. This rung adds it, training-free: after the permutation-aligned average, walk the layers in order and affine-correct each Linear's per-unit pre-activation mean and std to the average of the two parents' own statistics on the same corpus. `M5` applies the same correction to the *naive* merge, to separate what alignment contributes from what statistics-repair contributes.

| substrate | n pairs | rung | mean Δfloor (nats/tok) | median Δfloor | BLiMP accuracy | % of the parents' above-chance margin retained |
|---|---|---|---|---|---|---|
| pythia-14m | 36 | M0_naive_avg | 32.43 | 30.89 | 0.518 | 11.0% |
| pythia-14m | 36 | M1_perm_avg | 9.61 | 9.01 | 0.533 | 19.9% |
| pythia-14m | 36 | M4_perm_repair | 7.88 | 7.41 | 0.527 | 16.7% |
| pythia-14m | 36 | M5_naive_repair | 32.50 | 31.10 | 0.512 | 7.2% |
| pythia-14m | 36 | **parents** | 0.00 | 0.00 | 0.664 | 100.0% |
| pythia-31m | 36 | M0_naive_avg | 20.35 | 20.09 | 0.526 | 13.0% |
| pythia-31m | 36 | M1_perm_avg | 9.60 | 8.87 | 0.536 | 18.3% |
| pythia-31m | 36 | M4_perm_repair | 8.48 | 7.47 | 0.532 | 16.2% |
| pythia-31m | 36 | M5_naive_repair | 19.90 | 19.64 | 0.520 | 10.3% |
| pythia-31m | 36 | **parents** | 0.00 | 0.00 | 0.698 | 100.0% |
| pythia-70m | 36 | M0_naive_avg | 20.16 | 18.93 | 0.516 | 7.1% |
| pythia-70m | 36 | M1_perm_avg | 10.99 | 8.77 | 0.541 | 18.5% |
| pythia-70m | 36 | M4_perm_repair | 10.68 | 8.23 | 0.537 | 16.7% |
| pythia-70m | 36 | M5_naive_repair | 19.52 | 18.99 | 0.516 | 7.2% |
| pythia-70m | 36 | **parents** | 0.00 | 0.00 | 0.722 | 100.0% |
| pythia-160m | 36 | M0_naive_avg | 8.99 | 8.47 | 0.532 | 11.5% |
| pythia-160m | 36 | M1_perm_avg | 6.77 | 6.44 | 0.537 | 13.6% |
| pythia-160m | 36 | M4_perm_repair | 6.89 | 6.39 | 0.534 | 12.1% |
| pythia-160m | 36 | M5_naive_repair | 8.69 | 8.54 | 0.524 | 8.8% |
| pythia-160m | 36 | **parents** | 0.00 | 0.00 | 0.776 | 100.0% |

REPAIR does help the likelihood — it is the best training-free merge in this report, taking a further
bite out of the aligned merge's Δfloor (on pythia-14m, 9.61 → 7.88 nats/token, a further 18%). **And
BLiMP does not follow it at all**: 0.533 → 0.527, i.e. flat, and slightly *down*. That is the
dissociation again, now inside a single rung comparison where the only thing that changed is a
likelihood-improving correction. It does **not** change the conclusion. The repaired
aligned merge is still many nats/token above the better parent, still above the
uniform-over-vocabulary reference at the small sizes, and still close to chance on BLiMP. Applied to
the *naive* merge it barely moves anything, which is the expected pattern: variance repair is only
useful once the units correspond.

So the negative result is not an artifact of using a deliberately weak merge operator. Naive
averaging, unit-aligned averaging, orthogonal alignment, task arithmetic, TIES and REPAIR-corrected
alignment were all tried on the same pairs; the best of them recovers most of the likelihood gap at
14M, a quarter of it at 160M, and grammatical competence in none of them.


### Robustness: is the Δfloor an artifact of the held-out corpus?

The main SET 1 tables score on FLORES-200 English devtest — genuinely held out from PolyPythia training, but out-of-domain for the Pile. The obvious objection is that the merge penalty is inflated by domain shift. The same pairs and the same merges, re-scored on a **Pile sample** (`NeelNanda/pile-10k`, in-distribution for Pythia) and on **WikiText-103 validation**:

| substrate | n pairs | corpus | parent floor | naive Δfloor | Δfloor permutation-aligned | rescue |
|---|---|---|---|---|---|---|
| pythia-14m | 36 | flores_eng | 4.38 | 32.43 | 9.61 | 69.9% |
| pythia-14m | 36 | pile_10k | 4.19 | 32.95 | 10.23 | 68.4% |
| pythia-14m | 36 | wikitext103_val | 4.98 | 32.95 | 10.48 | 67.7% |
| pythia-160m | 36 | flores_eng | 3.25 | 8.99 | 6.77 | 23.5% |
| pythia-160m | 36 | pile_10k | 3.14 | 9.35 | 7.51 | 18.4% |
| pythia-160m | 36 | wikitext103_val | 3.24 | 9.59 | 8.11 | 14.4% |

**It is not a corpus artifact.** Parent floors move with domain, as they should. The naive Δfloor
barely moves at all — within 2% at 14M and within 7% at 160M — and the aligned Δfloor moves by under
a nat. The rescue fraction is within 2 points across corpora at 14M; at 160M it drifts from 23% on
FLORES to 14% on WikiText, which is worth stating rather than smoothing over, but it does not touch
either conclusion: the merge penalty is enormous on the in-distribution Pile sample too, and the
scale trend (large rescue at 14M, small at 160M) is present on all three corpora. The penalty is a
property of the merge, not of the evaluation set.


## The operator practitioners actually use · SLERP

Every rung above is a lab operator. A census of community merges on the Hub finds SLERP on about a quarter of them — more than TIES, DARE-TIES and task arithmetic combined — and unlike those it needs **no shared base**, which is exactly why it gets reached for when two models have no common ancestor. That is the PolyPythia seed case. Here it is, on the same pairs, before and after unit alignment, with both metrics.

| substrate | n pairs | rung | mean Δfloor (nats/tok) | BLiMP accuracy |
|---|---|---|---|---|
| pythia-14m | 36 | M0_naive_avg | 32.43 | 0.518 |
| pythia-14m | 36 | M1_perm_avg | 9.61 | 0.533 |
| pythia-14m | 36 | M6_slerp | 58.29 | 0.516 |
| pythia-14m | 36 | M7_perm_slerp | 11.77 | 0.524 |
| pythia-14m | 36 | **parents** | 0.00 | 0.664 |
| pythia-31m | 36 | M0_naive_avg | 20.35 | 0.526 |
| pythia-31m | 36 | M1_perm_avg | 9.60 | 0.536 |
| pythia-31m | 36 | M6_slerp | 41.38 | 0.521 |
| pythia-31m | 36 | M7_perm_slerp | 19.32 | 0.529 |
| pythia-31m | 36 | **parents** | 0.00 | 0.698 |
| pythia-70m | 36 | M0_naive_avg | 20.16 | 0.516 |
| pythia-70m | 36 | M1_perm_avg | 10.99 | 0.541 |
| pythia-70m | 36 | M6_slerp | 35.05 | 0.513 |
| pythia-70m | 36 | M7_perm_slerp | 14.24 | 0.541 |
| pythia-70m | 36 | **parents** | 0.00 | 0.722 |
| pythia-160m | 36 | M0_naive_avg | 8.99 | 0.532 |
| pythia-160m | 36 | M1_perm_avg | 6.77 | 0.537 |
| pythia-160m | 36 | M6_slerp | 13.76 | 0.529 |
| pythia-160m | 36 | M7_perm_slerp | 9.60 | 0.534 |
| pythia-160m | 36 | **parents** | 0.00 | 0.776 |

**SLERP is worse than a plain average here, not better.** Walking the great circle between two
parameter sets that are essentially orthogonal interpolates their *directions*, and between two
independently initialised networks there is no meaningful direction to interpolate — so it inherits
the naive merge's failure and roughly doubles it. Applied *after* unit alignment it recovers most of
that — but still lands consistently worse than the aligned plain average, at every size. Two things
follow. First, the field's default recipe does not
rescue the composition case, so "practitioners do it differently" is not an escape from this result.
Second, the ordering is the same as everywhere else in this report: **alignment is what moves the
number, and the choice of operator on top of it barely matters.**


## SET 4 · the accuracy arm (MultiBLiMP 1.0)

`jumelet/multiblimp` covers exactly the four partner languages plus English. Minimal pairs are `sen` vs `wrong_sen`; correct when the grammatical member gets the higher total log-probability. **Chance = 0.500.** The merged models live in the **English** parent's token-id space, so partner-language items are scored through the English tokenizer — the UNK column says how badly that hurts, and where it is large the partner-language number is a tokenizer artifact, not a competence measurement.

**Parents** (each on its own tokenizer except the last column):

| pair | n items (partner) | UNK rate, English tok on partner items | English parent, MultiBLiMP-eng | partner parent, MultiBLiMP-partner | English parent, MultiBLiMP-partner |
|---|---|---|---|---|---|
| eng–nld_Latn | 1200 | 0.2% | 0.962 | 0.970 | 0.598 |
| eng–spa_Latn | 1200 | 5.1% | 0.962 | 0.926 | 0.502 |
| eng–ell_Grek | 1096 | 45.1% | 0.962 | 0.987 | 0.029 |
| eng–pol_Latn | 1200 | 11.2% | 0.962 | 0.963 | 0.494 |

**Merged models, MultiBLiMP-English accuracy** (the clean cell — 0.04% UNK; English parent ceiling in the first column):

| pair | English parent | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1e_vocab_orth_forced | M1g_emb_procrustes | M1h_emb_proc_units |
|---|---|---|---|---|---|---|---|---|
| eng–nld_Latn | 0.962 | 0.673 | 0.601 | 0.596 | 0.596 | 0.662 | 0.668 | 0.635 |
| eng–spa_Latn | 0.962 | 0.677 | 0.727 | 0.726 | 0.726 | 0.682 | 0.661 | 0.631 |
| eng–ell_Grek | 0.962 | 0.688 | 0.599 | 0.600 | 0.600 | 0.687 | 0.656 | 0.657 |
| eng–pol_Latn | 0.962 | 0.682 | 0.656 | 0.656 | 0.656 | 0.653 | 0.653 | 0.655 |

**Merged models, MultiBLiMP-partner accuracy** (partner parent ceiling in the first column; rows with a high UNK rate are struck through in interpretation, not in the numbers):

| pair | partner parent | UNK | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1e_vocab_orth_forced | M1g_emb_procrustes | M1h_emb_proc_units |
|---|---|---|---|---|---|---|---|---|---|
| eng–nld_Latn | 0.970 | 0% | 0.655 | 0.646 | 0.644 | 0.644 | 0.602 | 0.653 | 0.583 |
| eng–spa_Latn | 0.926 | 5% | 0.500 | 0.532 | 0.535 | 0.535 | 0.477 | 0.525 | 0.537 |
| eng–ell_Grek | 0.987 | 45% | 0.029 | 0.029 | 0.029 | 0.029 | 0.014 | 0.029 | 0.029 |
| eng–pol_Latn | 0.963 | 11% | 0.454 | 0.462 | 0.462 | 0.462 | 0.501 | 0.491 | 0.490 |

**What the accuracy arm adds, and it cuts the other way from SET 1.**

- The English-side accuracy of the naive merge (mean 0.680, parent 0.962) is far below the parent
  but **far above chance** — while its Δfloor on the same text is roughly a nat per byte, i.e. by the likelihood
  metric the model is destroyed. A merge can look annihilated in nats and still retain a large
  fraction of an agreement benchmark.
- The unit-aligned rungs are a **wash** against the naive merge on accuracy. Averaged over the four
  pairs the naive merge scores 0.680 on MultiBLiMP-English against 0.645–0.671 for the aligned rungs,
  and 0.536 on the partner side (Greek excluded) against 0.527–0.556. Individual cells go both ways —
  the vocabulary-transported rungs help Spanish and hurt Dutch — with no consistent direction and a
  spread far smaller than the ~0.30 gap to the parents. Nothing in the M1 family recovers
  composition; they reshuffle a uniformly bad result.
- Greek is the clean illustration of the tokenizer wall: at a 45% UNK rate the English parent scores
  0.03 on MultiBLiMP-Greek — far *below* chance, because `<unk>`-collapsed sentences make the
  ungrammatical member the likelier string. Nothing about Greek grammar is being measured there. Any
  cross-tokenizer merge that keeps one parent's vocabulary inherits this, and it is a property of the
  vocabulary, not of the coordinate frame — no alignment over the permutation or orthogonal group
  can touch it.
- Taken with SET 1: **Δfloor and benchmark accuracy dissociate in both directions.** In SET 1 a large
  likelihood rescue buys almost no accuracy. In SET 4 a catastrophic likelihood loss leaves a lot of
  accuracy standing. Whichever of the two you report, the other does not follow from it.


## SET 4 · what would SUCCESS look like? The jointly-trained bilingual ceiling

A merge that fails is only interpretable against what a bilingual model of the same budget actually achieves. B-GPT (Arnett et al.) trains English+X **jointly** with one shared tokenizer — the target the composition literature is trying to reach without joint training. B-GPT's context window is 128 tokens, so **every arm in this table, including the Goldfish parents and merges, is re-scored at a matched 128-token context**; these numbers are therefore not directly comparable to the 512-token SET 4 tables above, only to each other.


**nats/byte, English**  (lower is better)

| pair | bgpt_joint_bilingual | goldfish_eng_parent | goldfish_partner_parent | merge_M0_naive | merge_M1a_vocab |
|---|---|---|---|---|---|
| eng–nld_Latn | 0.871 | 0.848 | 1.473 | 1.697 | 1.835 |
| eng–spa_Latn | 0.872 | 0.848 | 1.609 | 1.685 | 1.834 |
| eng–ell_Grek | 0.875 | 0.848 | 1.521 | 1.748 | 1.838 |
| eng–pol_Latn | 0.881 | 0.848 | 1.610 | 1.647 | 1.767 |

**nats/byte, partner**  (lower is better)

| pair | bgpt_joint_bilingual | goldfish_eng_parent | goldfish_partner_parent | merge_M0_naive | merge_M1a_vocab |
|---|---|---|---|---|---|
| eng–nld_Latn | 0.898 | 2.336 | 0.823 | 3.281 | 3.302 |
| eng–spa_Latn | 0.889 | 1.940 | 0.777 | 3.126 | 2.969 |
| eng–ell_Grek | 0.582 | 0.209 | 0.446 | 1.114 | 1.170 |
| eng–pol_Latn | 1.070 | 2.430 | 0.830 | 3.460 | 3.213 |

**MultiBLiMP-English**  (higher is better, chance 0.500)

| pair | bgpt_joint_bilingual | goldfish_eng_parent | goldfish_partner_parent | merge_M0_naive | merge_M1a_vocab |
|---|---|---|---|---|---|
| eng–nld_Latn | 0.966 | 0.962 | 0.694 | 0.673 | 0.601 |
| eng–spa_Latn | 0.968 | 0.962 | 0.656 | 0.677 | 0.727 |
| eng–ell_Grek | 0.968 | 0.962 | 0.631 | 0.688 | 0.599 |
| eng–pol_Latn | 0.973 | 0.962 | 0.610 | 0.682 | 0.656 |

**MultiBLiMP-partner**  (higher is better, chance 0.500)

| pair | bgpt_joint_bilingual | goldfish_eng_parent | goldfish_partner_parent | merge_M0_naive | merge_M1a_vocab |
|---|---|---|---|---|---|
| eng–nld_Latn | 0.952 | 0.598 | 0.970 | 0.655 | 0.646 |
| eng–spa_Latn | 0.879 | 0.502 | 0.926 | 0.500 | 0.532 |
| eng–ell_Grek | 0.927 | 0.029 | 0.987 | 0.029 | 0.029 |
| eng–pol_Latn | 0.892 | 0.494 | 0.963 | 0.454 | 0.462 |

This is the cleanest single statement the audit can make about SET 4. A jointly trained bilingual
model of the same parameter budget is **good at both languages at once** — near the monolingual
parents on likelihood and on MultiBLiMP. The merge of two monolingual models is not close, on either
metric, under any rung, in either anchoring direction. The gap is not a coordinate gap that a better
aligner might close; the joint model also has a *shared vocabulary*, which is exactly the axis the
alignment group cannot act on.


## SET 4c · merging two BILINGUAL models of the same language pair

SET 4 confounds two obstructions: the parents were trained independently, **and** they
have almost disjoint token-id spaces. This cell separates them. `B-GPT_en_X_simultaneous` and
`B-GPT_X_en_simultaneous` are trained on the same two languages with the same recipe, and their
tokenizers share ~94% of their surface forms — against 13–28% for two monolingual Goldfish
tokenizers. Vocabulary transport is therefore nearly lossless here, and what is left between the two
parents is an independent training run. If merging works anywhere in the composition setting, this is
where it should work. (Scored at B-GPT's 128-token context; MultiBLiMP chance = 0.500.)

| pair | vocab overlap | parent A / B, nats/byte (eng, X) | parent A / B, MultiBLiMP (eng, X) |
|---|---|---|---|
| en–nld | 94% | 0.87/0.90 · 0.93/0.83 | 0.97/0.95 · 0.95/0.97 |
| en–spa | 94% | 0.87/0.89 · 0.95/0.82 | 0.97/0.88 · 0.95/0.91 |
| en–ell | 91% | 0.88/0.58 · 0.99/0.48 | 0.97/0.93 · 0.94/0.94 |
| en–pol | 92% | 0.88/1.07 · 0.94/0.91 | 0.97/0.89 · 0.95/0.95 |

**Δfloor, mean over the two languages (nats/UTF-8 byte, lower better):**

| pair | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1g_emb_procrustes |
|---|---|---|---|---|---|
| en–nld | 0.907 | 0.852 | 0.862 | 0.862 | 0.837 |
| en–spa | 1.000 | 0.945 | 0.962 | 0.962 | 0.846 |
| en–ell | 1.012 | 0.838 | 0.837 | 0.837 | 0.800 |
| en–pol | 1.222 | 1.163 | 1.145 | 1.145 | 0.984 |
| **mean** | **1.035** | **0.950** | **0.952** | **0.952** | **0.866** |

**MultiBLiMP, mean over the two languages (accuracy, higher better; parent ceiling in the last column):**

| pair | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1g_emb_procrustes | parent ceiling |
|---|---|---|---|---|---|---|
| en–nld | 0.630 | 0.681 | 0.695 | 0.695 | 0.664 | 0.967 |
| en–spa | 0.623 | 0.682 | 0.680 | 0.680 | 0.702 | 0.938 |
| en–ell | 0.592 | 0.624 | 0.627 | 0.627 | 0.615 | 0.955 |
| en–pol | 0.626 | 0.621 | 0.620 | 0.620 | 0.632 | 0.961 |
| **mean** | **0.618** | **0.652** | **0.655** | **0.655** | **0.653** | **0.955** |

**This is the one place in SET 4 where alignment does something measurable, and it is still not
enough.** With the vocabulary obstruction largely removed, transport plus unit alignment moves
MultiBLiMP from 0.618 (naive) to 0.655 (best M1) and Δfloor from +1.035 to +0.866
nats/byte. Both move in the right direction, and both leave the merge far from parents that sit near
0.96 on MultiBLiMP and at Δfloor 0 by construction.

Read against the monolingual Goldfish cells, this is the cleanest decomposition the report offers:

- With **13–28% vocabulary overlap** (monolingual Goldfish), alignment does nothing at all — the
  binding constraint is the vocabulary and no map over the permutation or orthogonal group touches it.
- With **~94% overlap** (two bilinguals of the same pair), alignment finally has purchase and delivers
  a real but modest gain.
- Even then the merge does not approach either parent, because the parents are still two independent
  training runs — which is exactly what SET 1 isolates, and exactly what SET 1 shows alignment only
  partly removes.


## SET 4 · reverse direction (the partner language is the anchor)

Identical rungs, but the merged model lives in the **partner** language's tokenizer and residual basis and English is transported into it. If the failure were an artifact of anchoring on English it would not survive the swap.

| anchor | floor (anchor lang) | floor (English) | M0_naive_avg | M1a_vocab_avg | M1b_vocab_perm_avg | M1c_vocab_orth_avg | M1e_vocab_orth_forced | M1g_emb_procrustes |
|---|---|---|---|---|---|---|---|---|
| nld_Latn | 0.792 | 0.811 | 1.342 | 1.335 | 1.337 | 1.337 | 1.384 | 1.425 |
| spa_Latn | 0.746 | 0.811 | 1.527 | 1.619 | 1.619 | 1.619 | 1.611 | 1.476 |
| ell_Grek | 0.428 | 0.811 | 1.494 | 1.568 | 1.569 | 1.569 | 1.555 | 1.322 |
| pol_Latn | 0.799 | 0.811 | 1.591 | 1.622 | 1.622 | 1.622 | 1.580 | 1.678 |

Δfloor, mean over the two languages, nats/UTF-8 byte.


**The failure is symmetric, and that matters more than it looks.** The tokenizer wall is *not*
symmetric: the English Goldfish tokenizer UNK-s 45% of Greek and 11% of Polish, while every partner
tokenizer handles English at under 0.1% UNK (`results/set4_tokenizer_diag.json`). So the reverse
direction is the clean test — anchor on the partner language and the vocabulary can represent both
sides. The merge still fails, by the same margin, and the M1 rungs still do nothing. Two conclusions
follow that the English-anchored direction alone could not support:

1. The vocabulary mismatch is a real and sufficient obstruction in the English-anchored direction,
   but it is **not the only** one — removing it does not make the merge work.
2. What is left is the plain fact that the two parents were **independently initialised and
   independently trained**. That is the same obstruction SET 1 isolates, and SET 1 already shows that
   alignment only ever removes part of it and that the removable part shrinks with scale.


## P0-2 · Do the pre-merge predictors predict the realised rescue?

### The confirmatory test

Outcome = **realised rescue**: the fraction of the naive merge's Δfloor that the best M1 rung removes.
Label = above the within-substrate median. **Held out by seed**: fold *k* is every pair touching seed
*k*, fitted on the pairs touching neither, so the predictor's direction never sees the held-out pairs.
Null = a **seed-cluster permutation** (2000 draws): permute the seed identities and re-map each pair's
outcome to the permuted pair, leaving the predictor vector untouched. That preserves the pair
dependence structure a plain label shuffle destroys, and it is why the null means below sit at 0.50
rather than drifting.

The family below is the five predictors **the audit brief itself names** — weight cosine, coordinate
share, QMD, CKA, task-vector cosine — on the one outcome it asks about. It was fixed from the brief,
not selected after looking at the results, and BH is applied within this family only. The larger
exploratory table follows it.


| substrate | predictor | n | Spearman | AUROC (held out by seed) | null mean | perm p | BH q (within family) |
|---|---|---|---|---|---|---|---|
| pythia-14m | weight cosine | 36 | 0.095 | 0.549 | 0.501 | 0.316 | 0.648 |
| pythia-14m | coordinate share (block-normalised / permutation) | 36 | -0.009 | 0.478 | 0.503 | 0.596 | 0.745 |
| pythia-14m | CKA (mean over layers / unaligned) | 36 | -0.013 | 0.605 | 0.499 | 0.151 | 0.473 |
| pythia-14m | QMD (quotient_residual / permutation) | 36 | -0.207 | 0.657 | 0.500 | 0.055 | 0.275 |
| pythia-14m | task-vector cosine | 36 | 0.131 | 0.580 | 0.498 | 0.223 | 0.558 |
| pythia-160m | weight cosine | 36 | 0.451 | 0.704 | 0.501 | 0.037 | 0.234 |
| pythia-160m | coordinate share (block-normalised / permutation) | 36 | -0.015 | 0.614 | 0.501 | 0.176 | 0.489 |
| pythia-160m | CKA (mean over layers / unaligned) | 36 | 0.008 | 0.256 | 0.498 | 0.987 | 0.987 |
| pythia-160m | QMD (quotient_residual / permutation) | 36 | -0.060 | 0.525 | 0.500 | 0.415 | 0.648 |
| pythia-160m | task-vector cosine | 36 | 0.049 | 0.454 | 0.502 | 0.657 | 0.757 |
| pythia-31m | weight cosine | 36 | 0.274 | 0.704 | 0.504 | 0.029 | 0.234 |
| pythia-31m | coordinate share (block-normalised / permutation) | 36 | 0.427 | 0.710 | 0.505 | 0.025 | 0.234 |
| pythia-31m | CKA (mean over layers / unaligned) | 36 | 0.100 | 0.546 | 0.503 | 0.345 | 0.648 |
| pythia-31m | QMD (quotient_residual / permutation) | 36 | -0.060 | 0.444 | 0.500 | 0.722 | 0.785 |
| pythia-31m | task-vector cosine | 36 | -0.123 | 0.481 | 0.499 | 0.577 | 0.745 |
| pythia-410m | weight cosine | 15 | 0.043 | 0.464 | 0.504 | 0.583 | 0.745 |
| pythia-410m | coordinate share (block-normalised / permutation) | 15 | 0.164 | 0.446 | 0.499 | 0.666 | 0.757 |
| pythia-410m | CKA (mean over layers / unaligned) | 15 | 0.025 | 0.321 | 0.497 | 0.901 | 0.939 |
| pythia-410m | QMD (quotient_residual / permutation) | 15 | -0.107 | 0.554 | 0.503 | 0.369 | 0.648 |
| pythia-410m | task-vector cosine | 15 | 0.014 | 0.571 | 0.501 | 0.350 | 0.648 |
| pythia-70m | weight cosine | 36 | 0.089 | 0.491 | 0.500 | 0.517 | 0.745 |
| pythia-70m | coordinate share (block-normalised / permutation) | 36 | 0.462 | 0.806 | 0.500 | 0.002 | 0.062 |
| pythia-70m | CKA (mean over layers / unaligned) | 36 | 0.495 | 0.654 | 0.501 | 0.113 | 0.403 |
| pythia-70m | QMD (quotient_residual / permutation) | 36 | -0.494 | 0.676 | 0.501 | 0.089 | 0.373 |
| pythia-70m | task-vector cosine | 36 | 0.071 | 0.543 | 0.502 | 0.390 | 0.648 |

### The exploratory table

Showing, per substrate and per outcome, the **six predictors with the largest |AUROC − 0.5|** plus the multivariate ridge. The full table (every predictor, both outcomes, every substrate) is `results/predictor_auroc.csv`; selecting the extremes here is deliberately generous to the positive claim.

| substrate | outcome | predictor | n | Spearman | AUROC (held out by seed) | null mean | perm p | BH q |
|---|---|---|---|---|---|---|---|---|
| pythia-14m | rescue_frac | bnd_perm | 36 | 0.012 | 0.296 | 0.497 | 0.981 | 1.000 |
| pythia-14m | rescue_frac | qmd_orth | 36 | 0.093 | 0.676 | 0.497 | 0.037 | 0.373 |
| pythia-14m | rescue_frac | qmd_perm | 36 | 0.077 | 0.664 | 0.498 | 0.051 | 0.373 |
| pythia-14m | rescue_frac | qmd_act_perm | 36 | -0.207 | 0.657 | 0.500 | 0.055 | 0.373 |
| pythia-14m | rescue_frac | qmd_act_procrustes | 36 | -0.207 | 0.657 | 0.500 | 0.055 | 0.373 |
| pythia-14m | rescue_frac | cka_last | 36 | -0.478 | 0.651 | 0.499 | 0.067 | 0.391 |
| pythia-14m | rescue_frac | MULTIVARIATE_ridge_all | 36 | 0.254 | 0.620 | 0.501 | 0.114 | 0.391 |
| pythia-31m | rescue_frac | bnd_perm | 36 | -0.490 | 0.750 | 0.506 | 0.011 | 0.373 |
| pythia-31m | rescue_frac | coord_share_bnd_perm | 36 | 0.427 | 0.710 | 0.505 | 0.025 | 0.373 |
| pythia-31m | rescue_frac | weight_cosine | 36 | 0.274 | 0.704 | 0.504 | 0.029 | 0.373 |
| pythia-31m | rescue_frac | d_raw | 36 | -0.321 | 0.704 | 0.505 | 0.025 | 0.373 |
| pythia-31m | rescue_frac | bnd_raw | 36 | -0.391 | 0.701 | 0.506 | 0.032 | 0.373 |
| pythia-31m | rescue_frac | qmd_perm | 36 | -0.493 | 0.691 | 0.505 | 0.048 | 0.373 |
| pythia-31m | rescue_frac | MULTIVARIATE_ridge_all | 36 | 0.403 | 0.707 | 0.505 | 0.035 | 0.373 |
| pythia-70m | rescue_frac | coord_share_bnd_perm | 36 | 0.462 | 0.806 | 0.500 | 0.002 | 0.222 |
| pythia-70m | rescue_frac | bnd_perm | 36 | -0.404 | 0.787 | 0.501 | 0.003 | 0.222 |
| pythia-70m | rescue_frac | coord_share_orth | 36 | 0.341 | 0.722 | 0.497 | 0.033 | 0.373 |
| pythia-70m | rescue_frac | qmd_orth | 36 | -0.373 | 0.713 | 0.497 | 0.067 | 0.391 |
| pythia-70m | rescue_frac | coord_share_perm | 36 | 0.356 | 0.698 | 0.500 | 0.065 | 0.391 |
| pythia-70m | rescue_frac | qmd_perm | 36 | -0.357 | 0.688 | 0.500 | 0.084 | 0.391 |
| pythia-70m | rescue_frac | MULTIVARIATE_ridge_all | 36 | 0.387 | 0.688 | 0.499 | 0.080 | 0.391 |
| pythia-160m | rescue_frac | bnd_raw | 36 | 0.083 | 0.250 | 0.496 | 0.984 | 1.000 |
| pythia-160m | rescue_frac | bnd_perm | 36 | 0.040 | 0.253 | 0.496 | 0.974 | 1.000 |
| pythia-160m | rescue_frac | cka_mean | 36 | 0.008 | 0.256 | 0.498 | 0.987 | 1.000 |
| pythia-160m | rescue_frac | weight_cosine | 36 | 0.451 | 0.704 | 0.501 | 0.037 | 0.373 |
| pythia-160m | rescue_frac | qmd_orth | 36 | -0.439 | 0.704 | 0.498 | 0.052 | 0.373 |
| pythia-160m | rescue_frac | bnd_orth | 36 | -0.047 | 0.306 | 0.497 | 0.925 | 0.976 |
| pythia-160m | rescue_frac | MULTIVARIATE_ridge_all | 36 | 0.331 | 0.642 | 0.499 | 0.130 | 0.398 |
| pythia-410m | rescue_frac | weight_cosine_bn | 15 | -0.250 | 0.679 | 0.504 | 0.158 | 0.423 |
| pythia-410m | rescue_frac | cka_mean | 15 | 0.025 | 0.321 | 0.497 | 0.901 | 0.962 |
| pythia-410m | rescue_frac | qmd_perm | 15 | 0.125 | 0.661 | 0.499 | 0.167 | 0.424 |
| pythia-410m | rescue_frac | qmd_orth | 15 | 0.096 | 0.643 | 0.499 | 0.187 | 0.438 |
| pythia-410m | rescue_frac | coord_share_bnd_orth | 15 | 0.107 | 0.393 | 0.499 | 0.765 | 0.859 |
| pythia-410m | rescue_frac | d_raw | 15 | 0.054 | 0.607 | 0.499 | 0.280 | 0.499 |
| pythia-410m | rescue_frac | MULTIVARIATE_ridge_all | 15 | -0.643 | 0.196 | 0.500 | 0.994 | 1.000 |
| pythia-14m | dfloor_M1best | bnd_orth | 36 | -0.000 | 0.204 | 0.502 | 1.000 | 1.000 |
| pythia-14m | dfloor_M1best | bnd_perm | 36 | -0.002 | 0.222 | 0.502 | 0.997 | 1.000 |
| pythia-14m | dfloor_M1best | coord_share_orth | 36 | -0.457 | 0.738 | 0.495 | 0.015 | 0.373 |
| pythia-14m | dfloor_M1best | coord_share_perm | 36 | -0.445 | 0.735 | 0.495 | 0.016 | 0.373 |
| pythia-14m | dfloor_M1best | qmd_orth | 36 | 0.438 | 0.725 | 0.496 | 0.021 | 0.373 |
| pythia-14m | dfloor_M1best | coord_share_bnd_perm | 36 | -0.155 | 0.290 | 0.503 | 0.977 | 1.000 |
| pythia-14m | dfloor_M1best | MULTIVARIATE_ridge_all | 36 | 0.539 | 0.778 | 0.497 | 0.003 | 0.222 |
| pythia-31m | dfloor_M1best | qmd_orth | 36 | 0.289 | 0.670 | 0.502 | 0.101 | 0.391 |
| pythia-31m | dfloor_M1best | coord_share_orth | 36 | -0.271 | 0.670 | 0.503 | 0.103 | 0.391 |
| pythia-31m | dfloor_M1best | qmd_perm | 36 | 0.243 | 0.633 | 0.503 | 0.166 | 0.424 |
| pythia-31m | dfloor_M1best | coord_share_perm | 36 | -0.230 | 0.633 | 0.503 | 0.166 | 0.424 |
| pythia-31m | dfloor_M1best | bnd_raw | 36 | 0.163 | 0.633 | 0.503 | 0.132 | 0.398 |
| pythia-31m | dfloor_M1best | bnd_orth | 36 | 0.114 | 0.611 | 0.501 | 0.186 | 0.438 |
| pythia-31m | dfloor_M1best | MULTIVARIATE_ridge_all | 36 | -0.111 | 0.500 | 0.501 | 0.516 | 0.668 |
| pythia-70m | dfloor_M1best | coord_share_bnd_perm | 36 | 0.529 | 0.713 | 0.501 | 0.037 | 0.373 |
| pythia-70m | dfloor_M1best | bnd_perm | 36 | -0.485 | 0.704 | 0.502 | 0.033 | 0.373 |
| pythia-70m | dfloor_M1best | cka_last | 36 | 0.476 | 0.691 | 0.499 | 0.090 | 0.391 |
| pythia-70m | dfloor_M1best | cka_mean | 36 | 0.427 | 0.667 | 0.501 | 0.105 | 0.391 |
| pythia-70m | dfloor_M1best | qmd_act_perm | 36 | -0.433 | 0.667 | 0.501 | 0.103 | 0.391 |
| pythia-70m | dfloor_M1best | qmd_act_procrustes | 36 | -0.433 | 0.667 | 0.501 | 0.103 | 0.391 |
| pythia-70m | dfloor_M1best | MULTIVARIATE_ridge_all | 36 | 0.386 | 0.599 | 0.500 | 0.207 | 0.438 |
| pythia-160m | dfloor_M1best | weight_cosine | 36 | -0.195 | 0.284 | 0.504 | 0.962 | 1.000 |
| pythia-160m | dfloor_M1best | cka_last | 36 | 0.476 | 0.701 | 0.497 | 0.040 | 0.373 |
| pythia-160m | dfloor_M1best | cka_mean | 36 | -0.270 | 0.685 | 0.500 | 0.111 | 0.391 |
| pythia-160m | dfloor_M1best | bnd_orth | 36 | -0.371 | 0.660 | 0.500 | 0.081 | 0.391 |
| pythia-160m | dfloor_M1best | d_raw | 36 | 0.273 | 0.349 | 0.503 | 0.910 | 0.965 |
| pythia-160m | dfloor_M1best | bnd_raw | 36 | -0.278 | 0.648 | 0.501 | 0.119 | 0.391 |
| pythia-160m | dfloor_M1best | MULTIVARIATE_ridge_all | 36 | 0.584 | 0.759 | 0.497 | 0.018 | 0.373 |
| pythia-410m | dfloor_M1best | cka_mean | 15 | -0.364 | 0.714 | 0.501 | 0.116 | 0.391 |
| pythia-410m | dfloor_M1best | qmd_act_ot | 15 | 0.432 | 0.714 | 0.502 | 0.148 | 0.407 |
| pythia-410m | dfloor_M1best | qmd_act_perm | 15 | 0.371 | 0.679 | 0.502 | 0.214 | 0.438 |
| pythia-410m | dfloor_M1best | qmd_act_procrustes | 15 | 0.371 | 0.679 | 0.502 | 0.214 | 0.438 |
| pythia-410m | dfloor_M1best | qmd_orth | 15 | -0.257 | 0.625 | 0.503 | 0.244 | 0.474 |
| pythia-410m | dfloor_M1best | cka_last | 15 | 0.100 | 0.375 | 0.494 | 0.775 | 0.859 |
| pythia-410m | dfloor_M1best | MULTIVARIATE_ridge_all | 15 | 0.300 | 0.589 | 0.506 | 0.335 | 0.549 |

### Does a predictor fitted on one substrate transfer to another?

Leave-one-**size**-out. Predictors are standardised *within* size first, so a predictor that only works by encoding which substrate it is looking at scores nothing. The sign (and the ridge coefficients) come from the other sizes only. Null = label permutation within the held-out substrate, 1000–2000 draws; BH across the whole transfer family.

| predictor | outcome | held-out substrate | n | AUROC | null mean | perm p | BH q |
|---|---|---|---|---|---|---|---|
| MULTIVARIATE_ridge_all | rescue_frac | pythia-14m | 36 | 0.426 | 0.500 | 0.775 | 0.966 |
| MULTIVARIATE_ridge_all | rescue_frac | pythia-160m | 36 | 0.657 | 0.499 | 0.044 | 0.223 |
| MULTIVARIATE_ridge_all | rescue_frac | pythia-31m | 36 | 0.679 | 0.495 | 0.028 | 0.203 |
| MULTIVARIATE_ridge_all | rescue_frac | pythia-410m | 15 | 0.393 | 0.499 | 0.773 | 0.966 |
| MULTIVARIATE_ridge_all | rescue_frac | pythia-70m | 36 | 0.556 | 0.502 | 0.289 | 0.689 |
| coord_share_bnd_perm | rescue_frac | pythia-14m | 36 | 0.515 | 0.500 | 0.462 | 0.777 |
| coord_share_bnd_perm | rescue_frac | pythia-160m | 36 | 0.506 | 0.500 | 0.473 | 0.777 |
| coord_share_bnd_perm | rescue_frac | pythia-31m | 36 | 0.710 | 0.502 | 0.017 | 0.142 |
| coord_share_bnd_perm | rescue_frac | pythia-410m | 15 | 0.482 | 0.497 | 0.549 | 0.829 |
| coord_share_bnd_perm | rescue_frac | pythia-70m | 36 | 0.806 | 0.498 | 0.003 | 0.142 |
| qmd_act_perm | rescue_frac | pythia-14m | 36 | 0.657 | 0.496 | 0.044 | 0.223 |
| qmd_act_perm | rescue_frac | pythia-160m | 36 | 0.512 | 0.498 | 0.450 | 0.777 |
| qmd_act_perm | rescue_frac | pythia-31m | 36 | 0.525 | 0.505 | 0.440 | 0.777 |
| qmd_act_perm | rescue_frac | pythia-410m | 15 | 0.571 | 0.508 | 0.370 | 0.739 |
| qmd_act_perm | rescue_frac | pythia-70m | 36 | 0.676 | 0.500 | 0.045 | 0.223 |
| cka_mean | rescue_frac | pythia-14m | 36 | 0.599 | 0.497 | 0.147 | 0.516 |
| cka_mean | rescue_frac | pythia-160m | 36 | 0.478 | 0.497 | 0.568 | 0.829 |
| cka_mean | rescue_frac | pythia-31m | 36 | 0.540 | 0.501 | 0.364 | 0.739 |
| cka_mean | rescue_frac | pythia-410m | 15 | 0.571 | 0.496 | 0.337 | 0.739 |
| cka_mean | rescue_frac | pythia-70m | 36 | 0.346 | 0.498 | 0.952 | 0.971 |
| weight_cosine | rescue_frac | pythia-14m | 36 | 0.580 | 0.497 | 0.204 | 0.637 |
| weight_cosine | rescue_frac | pythia-160m | 36 | 0.704 | 0.495 | 0.012 | 0.142 |
| weight_cosine | rescue_frac | pythia-31m | 36 | 0.704 | 0.499 | 0.013 | 0.142 |
| weight_cosine | rescue_frac | pythia-410m | 15 | 0.625 | 0.507 | 0.241 | 0.669 |
| weight_cosine | rescue_frac | pythia-70m | 36 | 0.494 | 0.499 | 0.535 | 0.829 |

**SET 4, held out by language pair.** n = 4 language pairs. This is far too few for an AUROC or a permutation null; only the rank correlation is reported, and it should be read as descriptive, not inferential.

| predictor | Spearman vs realised rescue |
|---|---|
| weight_cosine | -0.400 |
| d_raw | 0.400 |
| qmd_perm | 0.400 |
| coord_share_perm | 0.800 |
| qmd_orth | 0.400 |
| coord_share_orth | 0.800 |
| bnd_raw | 0.800 |
| bnd_perm | 0.800 |
| bnd_orth | 0.800 |
| coord_share_bnd_perm | 0.800 |
| coord_share_bnd_orth | 0.800 |
| cka_mean | -0.400 |
| cka_last | -0.400 |
| qmd_act_perm | 0.400 |
| qmd_act_procrustes | 0.400 |
| qmd_act_ot | 0.400 |
| vocab_overlap | -0.800 |
| weight_cosine_body | -0.800 |

### What P0-2 comes to

**The confirmatory family gives 0 significant cells out of
25 tested** (BH q under 0.05 within the family).

The strongest single cell is the coordinate share at pythia-70m — held-out AUROC 0.81, raw
permutation p = 0.002 — which is a real effect and worth naming rather than burying. It does not
survive correction across the family, and the reason it does not is instructive: the same predictor
on the same outcome, measured on four other complete grids of the same model family, lands at 0.45,
0.48, 0.61 and 0.71. The honest summary is:


- **It does not replicate across substrates.** Held-out AUROC for the coordinate share, on five
  complete grids of the *same* model family differing only in size: 14m 0.48 · 31m 0.71 · 70m 0.81 · 160m 0.61 · 410m 0.45. A quantity that lands
  anywhere between "slightly the wrong way" and 0.81 depending on which substrate you happen to test
  is not a validated instrument for "representational alignment predicts merging", however
  encouraging its best cell looks.
- **The exploratory table looks better than the confirmatory one, and that is the point of having
  both.** Across ~150 predictor × substrate × outcome cells there are plenty of AUROCs in the
  0.70–0.81 range with raw permutation p below 0.05; none survives BH across that family. Quoting
  the best of them would be exactly the error the audit exists to catch.
- **Across-substrate transfer fails outright under correction.** Fitting on the other sizes and
  testing on a held-out one, the coordinate share reaches AUROC 0.81 on 70m and 0.71 on 31m with raw
  permutation p of 0.003 and 0.016 — and 0.51 on both 14m and 160m. Across the 20-cell transfer
  family **not one cell survives BH** (smallest q = 0.11). The multivariate ridge over all predictors
  does no better than its best single member.

One thing worth noticing before concluding, because it is partly a power story rather than a signal
story: **detectability tracks how much the outcome varies at all.** The within-substrate standard
deviation of the realised rescue is 0.067 at 14m, 0.143 at 31m, 0.127 at 70m and 0.095 at 160m
(against a between-substrate spread of 0.143 in the means). 14m — where the rescue is both largest
and most uniform across pairs — is the substrate where nothing predicts, and 70m, with roughly twice
the spread, is where the one significant cell appears. So part of the null is that at some sizes
every pair is rescued by nearly the same amount and there is very little left to rank. That is a
caveat in the predictors' favour and it does not rescue the positive claim: a predictor that only
resolves when the outcome happens to be dispersed is not the instrument the thesis needs.

Against them: the seed-cluster null is
conservative by construction, but so is the design that needs it; these are 36 pairs built from 9
seeds, not 36 independent observations, and any analysis that treats them as independent will
overstate its significance.

**Verdict, stated as the audit asks.** On real reseeded LMs, the pre-merge alignment predictors do
not reliably predict how much of the merge obstruction alignment will actually remove. The one
substrate where the coordinate share does predict it does not generalise to the others. This is a
negative transfer result from the synthetic/S3 setting to real models, and it is reported as one.


## Control · same-basin vs different-basin pairs

SET 1's main grid uses `pythia-<size>-seed{n}` (PolyPythia), which reseeds
initialisation and data order together. `pythia-160m-weight-seed{1,2,3}` and
`pythia-160m-data-seed{1,2,3}` are the older Pythia ablations that were intended to vary one of those
at a time. **They do not give the init-only control they look like they give**, and the weight cosine
column below is how we know: pairs from either ablation family have parameter vectors that are still
*strongly correlated*, while main-grid pairs are essentially orthogonal. Whatever the ablation seeds
vary, both families stay in the same basin.

That makes them useful as something else — a **same-basin reference** — so they are reported as one.

| pairs | n | weight cosine | d_raw | CKA | coordinate share | naive Δfloor | Δfloor perm | rescue |
|---|---|---|---|---|---|---|---|---|
| `pythia-160m-data-seed{1,2,3}` | 3 | 0.550 | 0.949 | 0.828 | 0.0139 | 3.13 | 3.00 | 3.9% |
| `pythia-160m-weight-seed{1,2,3}` | 3 | 0.570 | 0.942 | 0.789 | 0.0123 | 3.10 | 2.79 | 10.0% |
| `pythia-160m-seed{1..9}` (main grid) | 36 | 0.021 | 1.401 | 0.747 | 0.0867 | 8.99 | 6.77 | 23.5% |

**What this actually shows.**

1. **The main grid really is the different-basin case.** Weight cosine ~0.02 between two PolyPythia
   seeds: after training, two independently initialised 160M models are as good as orthogonal in
   parameter space. Everything SET 1 reports is about that regime.
2. **Same-basin models still cannot be naively averaged for free.** The ablation pairs are strongly
   correlated in weight space (cosine ~0.55–0.57) and their naive merge is still ~3 nats/token above
   the better parent — roughly a third of the different-basin penalty, on a parent floor of 3.3.
   Merging is not a solved problem inside a basin either.
3. **Alignment does almost nothing for them, and that is the right behaviour.** Their coordinate share
   is ~0.013 against ~0.087 for the main grid, and the permutation rung removes only a few percent of
   their Δfloor. There is no coordinate mismatch left to remove, so the aligner correctly declines to
   find one. That is a useful negative control on the aligner itself: it is not manufacturing rescue
   out of noise.
4. **The residual is therefore not coordinate.** Whatever costs a same-basin pair 3 nats/token, and
   whatever is left after alignment on a different-basin pair, is something the permutation group does
   not describe.

**Caveat.** n = 3 pairs per ablation family, and these repos come from a different release than the
PolyPythia `-seed{n}` set, so a training-configuration difference cannot be excluded as a partial
explanation for their closeness. The claim being made here is the measured one — these particular
pairs are same-basin and behave as described — not a claim about what "varying the init seed" does in
general.


## Coverage — what ran and what did not

| cell | n | status | what was measured |
|---|---|---|---|
| SET 1 Δfloor · pythia-14m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
| SET 1 Δfloor · pythia-31m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
| SET 1 Δfloor · pythia-70m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
| SET 1 Δfloor · pythia-160m | 36/36 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
| SET 1 Δfloor · pythia-410m | 15/15 seed pairs | complete | M0 naive · M1 permutation · M1 Procrustes · M2 task-arithmetic · M3 TIES; LMC barrier for M0 and M1-perm |
| SET 1 control · pythia-160m-data | 3/3 pairs | complete | init-seed-only vs data-order-only, same rungs |
| SET 1 control · pythia-160m-weight | 3/3 pairs | complete | init-seed-only vs data-order-only, same rungs |
| SET 1 accuracy · BLiMP | pythia-14m: 36/36, pythia-31m: 36/36, pythia-70m: 36/36, pythia-160m: 36/36, pythia-410m: 15/36 | RAN | 67 paradigms from `nyu-mll/blimp`, minimal-pair sentence-logprob scoring, on the SAME merges |
| SET 1 · corpus robustness | pythia-14m: 36/36, pythia-160m: 36/36 | RAN | same pairs and merges re-scored on FLORES-200 eng, NeelNanda/pile-10k and WikiText-103 validation |
| SET 1 · SLERP rung | pythia-14m: 36/36, pythia-31m: 36/36, pythia-70m: 36/36, pythia-160m: 36/36 | RAN | M6 SLERP and M7 permutation-aligned SLERP on the same pairs; Δfloor and BLiMP |
| SET 1 · REPAIR rung | pythia-14m: 36/36, pythia-31m: 36/36, pythia-70m: 36/36, pythia-160m: 36/36 | RAN | M4 = permutation-aligned average + pre-activation statistics repair; M5 = naive + repair; Δfloor and BLiMP on the same merges |
| SET 4 Δfloor · English-anchored | 4/4 language pairs (nld_Latn, spa_Latn, ell_Grek, pol_Latn) | complete | M0 naive · M1a vocab-transport · M1b/c vocab+unit-aligned · M1d/e forced-residual · M1f units-only · M1g/h embedding-row Procrustes |
| SET 4 Δfloor · partner-anchored (reverse) | 4/4 language pairs | complete | same rungs, roles swapped |
| SET 4 accuracy · MultiBLiMP 1.0 | 4/4 language pairs | RAN | `jumelet/multiblimp`, English + partner, on the SAME merges; UNK rate reported per cell |
| SET 4 · jointly-trained bilingual ceiling | 4/4 language pairs | RAN | `catherinearnett/B-GPT_en_X_simultaneous` vs the Goldfish parents and merges, all scored at a matched 128-token context |
| SET 4c · bilingual×bilingual merge (B-GPT en_X × X_en) | 4/4 language pairs | RAN | M0 naive · M1a vocab-transport · M1b/c +unit-aligned · M1g embedding-row Procrustes; Δfloor AND MultiBLiMP on the same merges. ~94% vocabulary overlap, so this cell isolates independent training from the vocabulary wall |
| Validation · is each alignment function-preserving? | 2 substrates x 5 maps | RAN | parent re-evaluated after applying the map; permutation exact to float32 noise, orthogonal NOT (see Validation) |
| SET 4 · task-arithmetic / TIES | 0 | **NOT APPLICABLE** | Both operators need a shared ancestor. Two independently trained monolingual Goldfish models have none, and with one parent as a pseudo-base the operators reduce to returning the other parent. Excluded on definition, not on time. |
| SET 1 · pythia-410m full grid | 15/36 possible pairs | partial | 6 seeds only (15 possible pairs) and a reduced eval budget; the per-pair alignment cost is ~9 min at this width. Treat 410m as directional. |
| Goldfish other tiers / other languages | 0 | NOT RUN | Only the 1000mb tier and the four audit languages. |
| Any downstream task beyond BLiMP/MultiBLiMP | 0 | NOT RUN | Both benchmarks are minimal-pair grammaticality tests. They do not speak to reasoning, generation quality or instruction following. |

## Threats to validity, stated plainly

- **Likelihood ≠ accuracy.** Repeated because it is the single most load-bearing caveat here — and
  because this report is one of the few places where both were measured on the same merges and found
  to dissociate.
- **BLiMP and MultiBLiMP are minimal-pair grammaticality benchmarks.** They are a real accuracy
  measurement and they are not a general one. A merge that scores 0.68 on MultiBLiMP-English is not
  thereby a usable model; agreement minimal pairs are unusually forgiving of a degraded model,
  because the two candidates differ in one inflected token and the grammatical form is usually the
  more frequent one. Read "retains accuracy" as "retains *this* accuracy", not as "works".
- **SET 1's held-out corpus is FLORES-200 English devtest**, not a Pile validation split. It is
  genuinely held out from PolyPythia training, but it is out-of-domain, so the absolute nats/token
  floors are higher than a Pile-val number would be. Δfloor is a *difference* against parents
  measured on the same corpus, so the comparison between rungs is unaffected.
- **SET 1's `-seed{n}` repos reseed initialisation AND data order together.** The 160m
  weight-seed/data-seed control separates them (see the Control section) but only at n=3 pairs each.
  The main grid's naive Δfloor should be read as an init-plus-data-order number.
- **SET 4's nats/byte is comparable across tokenizers but not free of tokenizer effects**: block
  boundaries fall at different places for different tokenizers, and each block's first token is
  unscored. With ~30k tokens per evaluation this is a sub-1% effect. The much larger tokenizer effect
  — the English tokenizer's UNK rate on partner-language text — is reported per cell and is a
  substantive finding rather than a nuisance.
- **The alignment search is over the permutation group (residual basis, MLP hidden axis, attention
  heads) and its orthogonal relaxation, plus embedding-row Procrustes for the cross-tokenizer case.**
  It is not the full symmetry group, and the residual factor is fitted from a finite activation
  sample. A better aligner could raise the M1 rungs; nothing here bounds how far. What *is* bounded
  is the claim that the aligners already in `mergeschool.core` do the job on these substrates.
- **The largest SET 1 sizes carry the fewest pairs.** 14m/31m/70m are complete 36-pair grids; 160m
  and 410m are partial. The scale trend is monotone across all five but its right-hand end is thin.
- **SET 4's n = 4 language pairs**, all with English as one parent and all Indo-European. Any
  predictor claim on that substrate is descriptive, and nothing here speaks to non-Indo-European or
  to non-English pivots.
- **Everything here is training-free by construction.** No claim is made about what a small amount of
  post-merge finetuning would recover; that is the obvious next experiment and it is out of scope for
  a training-free audit.


## Files

```
results/set1_{14m,31m,70m,160m,410m}.jsonl  SET 1 per-pair records (predictors, rungs, barriers)
results/set1x_410m.jsonl                    second 410m worker (disjoint pairs; deduped on load)
results/set1_pairs.csv                      SET 1 per-pair flat table
results/abl_160m-{weight,data}.jsonl        same-basin control (Pythia data-seed / weight-seed)
results/alignment_health.json               is each map function-preserving? measured, both substrates
results/blimp_{size}.jsonl, blimp_pairs.csv SET 1 BLiMP accuracy, per pair and per rung
results/repair_{size}.jsonl                 REPAIR rung (Δfloor + BLiMP on the same merges)
results/slerp_{size}.jsonl                  SLERP and permutation-aligned SLERP rungs
results/corpus_{size}.jsonl                 same merges re-scored on Pile-10k and WikiText-103
results/set4_goldfish.jsonl, set4_pairs.csv SET 4 Δfloor, English-anchored
results/set4_reverse.jsonl                  SET 4 Δfloor, partner-language-anchored
results/set4_multiblimp.jsonl               SET 4 MultiBLiMP accuracy
results/set4_tokenizer_diag.json            UNK rates / bytes-per-token per (tokenizer, language)
results/bgpt_ceiling.jsonl                  jointly-trained bilingual ceiling, matched context
results/bgpt_merge.jsonl                    bilingual x bilingual merge (~94% vocabulary overlap)
results/rung_summary.csv                    rung x substrate x metric summary
results/predictor_confirmatory.csv          P0-2 confirmatory family (5 predictors, BH within family)
results/predictor_auroc.csv                 P0-2 exploratory: every predictor x substrate x outcome
results/predictor_transfer_across_size.csv  P0-2: leave-one-substrate-out transfer
results/set4_predictors.csv                 P0-2 on SET 4 (n=4, descriptive only)
figs/set1_dfloor_by_rung.png                Δfloor by rung, per size
figs/set1_scale_trend.png                   obstruction and rescue vs model size
figs/set1_rescue_vs_predictor.png           realised rescue vs coordinate share / CKA
figs/set1_roc.png                           held-out-by-seed ROC, confirmatory predictor
figs/set1_blimp_dissociation.png            likelihood rescue vs accuracy rescue
figs/set4_dfloor.png                        Δfloor by rung, Goldfish
figs/set4_joint_ceiling.png                 B-GPT joint bilingual vs parents vs merges
figs/set4_likelihood_vs_accuracy.png        SET 4 Δfloor against MultiBLiMP, per rung
code/*.py, code/*.sh                        every script and launcher that produced the above
```

**Reproducing.** `common.py` holds the corpora and evaluation; `gpt2_align.py` holds the GPT-2
(Conv1D) symmetry factors that `mergeschool.core.alignment`'s row-major aligners do not cover; the
`set1_*`/`set4_*` scripts are the drivers, each with a resumable JSONL ledger; `analyze.py` builds
the tables and figures and `make_report.py` writes this document. Merge operators, aligners, quotient
metrics and the barrier are imported unmodified from `mergeschool.core`.