Datasets:

Mergeability-2
/

aim-activation-informed-merging

	---
	license: apache-2.0
	language:
	- en
	tags:
	- model-merging
	- activation-informed-merging
	- mergeability
	- llama-2
	- interpretability
	pretty_name: AIM — what activation-informed merging actually does
	size_categories:
	- n<1K
	configs:
	- config_name: mechanism
	data_files: tables/T4_mechanism.csv
	- config_name: paired_per_checkpoint
	data_files: tables/T1_paired_per_checkpoint.csv
	- config_name: published_outcome
	data_files: tables/T0_published_outcome_paired.csv
	- config_name: coverage
	data_files: tables/T5_coverage.csv
	---

	# AIM: does activation-informed merging change what makes a merge work?

	<!-- AIM-HEADLINE:BEGIN -->
	## Headline

	**AIM does exactly what it claims, the targeting is what makes it work — and it changes
	nothing about what predicts a good merge.**

	1. AIM is exactly what it says on the tin, and that is verifiable from public artefacts alone.
	The published with-AIM checkpoints are recovered, to R² = 0.9992, as a closed-form
	per-input-channel shrinkage of their baseline twins toward the base model, with ω̂ = 0.400
	against the paper's stated 0.4, and a salience vector that correlates r = 0.996 with the
	base model's activation scale measured independently on pile-val. No merge, no calibration run
	and no benchmark was needed to establish that (§2, 20/20 pairs).

	2. In weight space AIM barely does anything. It removes 8.0% of the merge's task
	vector, keeps cosine 0.9994 with the baseline delta, exempts the embedding table entirely,
	and a single activation-agnostic scalar per tensor reproduces its weight change to
	R² = 0.99882 (§2.3). Its strength varies five-fold across module types purely because the
	salience is normalised by its maximum, so in practice it is mostly an MLP-input intervention
	(§2.4).

	3. But the targeting is real, and it is what does the work. Against a control that makes the
	same per-tensor Frobenius move toward the base model with the activation information deleted,
	AIM preserves the base model's activations **4.1× more efficiently per unit of weight
	changed** (§3.2). The activation-agnostic control removes 3.4% of the activation
	deviation for that 8.0% weight move; AIM removes 14.1%. Positive on
	20/20 pairs. So the sliver of weight change that the per-channel profile
	adds on top of a uniform shrink — a third of a 0.12% residual — carries most of
	the representational effect.

	4. AIM's published benefit is real and consistent, and we did not re-measure it: paired across
	all 20 matched checkpoints, the endpoint-scaled benchmark mean rises +0.219
	(18/20 positive, Wilcoxon p = 9.5e-06) (§6 T0).

	5. But it does not change what makes a merge work. The F8 property suite, computed on (merged model, base model) for both arms of all 20 pairs, shows 12 of 18 properties moving significantly and all of them toward the base model (`F8b_AIM_property_deltas.png`) — the representation family 4.3× further than the weight-space family, the same leverage as (3). But not one of the 216 property-vs-outcome correlation cells survives multiplicity correction, and the with-minus-without change in those correlations (mean \|Δr\| = 0.32) is inside the noise band you get from re-splitting the same benchmarks within one arm ([+0.24, +0.98]). Verdict: no detectable change (§3.3).

	Coverage: mechanism 20/20 matched pairs, property panel 20/20. Regenerated
	2026-08-27 00:13 UTC.
	<!-- AIM-HEADLINE:END -->
	Complete: 20/20 matched pairs on both the mechanism test and the property panel. Published at
	[`Mergeability-2/aim-activation-informed-merging`](https://huggingface.co/datasets/Mergeability-2/aim-activation-informed-merging)
	— every CSV, every figure, and this report as the dataset card. Namespaced to `results/aim/`,
	`figures/aim/`, `scripts/aim/` — nothing here touches the MergeBench analysis.

	Substrate. `ahn1376/aim-merged-checkpoints-with-aim` and
	`ahn1376/aim-merged-checkpoints-baseline-w-o-aim`, 20 merged 13B checkpoints each (each collection
	also lists the arXiv id `2502.02421`, which is not a model), perfectly matched on
	operator × task combination: {TaskArithmetic, Ties, DARETaskArithmetic, DARETies, WIDEN} ×
	{Code-Math, Code-Instruction_Tuned, Math-Instruction_Tuned, Code-Math-Instruction_Tuned}.
	Base model `unsloth/llama-2-13b`; parents WizardLM-13B-V1.2, WizardMath-13B-V1.0,
	llama-2-13b-code-alpaca. ω = 0.4, the paper's setting.

	No benchmark was run. The merge-outcome column is the AIM paper's own published table,
	transcribed from the method repo's README into `results/aim/published_scores.csv`: six benchmarks
	(HumanEval, MBPP, MMLU, MATH, GSM8K, IFEval) plus the paper's HV gain, for all 40 merged
	checkpoints and the four endpoints. Coverage of these checkpoints is complete, so the fallback
	in the brief was not needed.


	## 1. What AIM is, exactly

	Read off `MergeModels/ActivationMerging/_utils.py::relax_on_merged` in the method repo. For every
	weight matrix that is not an embedding table:

	```
	s_j = base model's mean \|input activation\| on input channel j (pile-val, 256 samples x 512 tok)
	a_j = \|s_j\| / max_j \|s_j\| in [0, 1]
	r_j = 1 - a_j (1 - omega) in [omega, 1]
	W_AIM = W_base + (W_merged - W_base) * r_j broadcast over output rows
	```

	Three things follow immediately, and they frame everything below.

	- AIM does not change the merge. It is a post-hoc, closed-form shrinkage of the *already
	merged* model back toward the base model. `performAIM.py` takes a finished merged checkpoint as
	input. Whatever operator produced `W_merged` is irrelevant to the transform.
	- It is a per-input-channel rescaling, not a per-weight one: `r` is a vector of length
	`in_features`, constant down each column.
	- `model.embed_tokens` is exempt (the `'embed' not in name` guard), so the merged embedding
	table survives untouched. `lm_head` is not exempt and is shrunk.

	## 2. What AIM does to the weights (mechanism, 20/20 pairs, complete)

	### 2.1 The published checkpoints are exactly the closed form — recovered from public artefacts

	`scripts/aim/aim_weight_mechanism.py` streams the three checkpoints (base, baseline merge, AIM
	twin) tensor by tensor out of the safetensors shards and fits, per input channel, the
	least-squares gain carrying `W_merged - W_base` to `W_AIM - W_base`. (Least squares, not
	elementwise ratios: the checkpoints are stored in bf16, so the deltas carry ~2^-8 relative
	quantisation noise that makes elementwise ratios meaningless while leaving the projection well
	determined.)

	Across all 20 matched pairs (median over the 20, and over the ~360 tensors of each):

	\| quantity \| predicted by the stated rule \| recovered \| range over the 20 pairs \|
	\|---\|---\|---\|---\|
	\| min over channels of `r_j` \| ω = 0.4 exactly \| 0.3998 \| 0.372 – 0.400 \|
	\| max over channels of `r_j` \| 1.0 exactly \| 0.9953 \| 0.993 – 1.002 \|
	\| variance of `W_AIM − W_base` explained by a per-input-channel gain \| 1.0 \| R² = 0.9992 \| 0.990 – 0.9995 \|
	\| `model.embed_tokens` Frobenius ratio \| 1.0 (exempt by the `'embed' not in name` guard) \| 1.0000 \| 1.0000 – 1.0019 \|

	Nothing about ω was assumed: 0.3998 is measured from the checkpoints and lands on the paper's
	stated 0.4. The residual 0.08% is bf16 quantisation, not model error.

	### 2.2 The shrinkage is keyed to the base model's activations — confirmed independently

	`scripts/aim/aim_salience_check.py` measures `s` itself: the same forward hook AIM uses, on the
	base model, on pile-val (135 blocks × 512 tokens), and compares the salience **implied by the
	published checkpoint pair, `â_j = (1 - r_j)/(1 - ω)`, against the salience measured from the
	base model**.

	Over 5620 (checkpoint, module) pairs — all 20 matched pairs × ~280 modules each:

	- median Pearson r = 0.9956 (5th percentile 0.952, minimum 0.684)
	- median absolute error 0.0088 on a 0–1 scale, median fitted slope 1.04

	So AIM's claim — that it preserves the weights the base model's activations single out — is
	true as stated, and verifiable without running the merge, the calibration, or a benchmark.

	### 2.3 But the intervention is far smaller, and far more concentrated, than the framing suggests

	This is where the interesting part is.

	- Total weight change removed: 8.0%. Summed over every non-embedding tensor,
	`‖ΔW_AIM‖_F / ‖ΔW_merge‖_F = 0.920` (median over the 20 pairs; range 0.917–0.935). AIM keeps
	92% of the merge's task vector. Cosine between the AIM delta and the baseline delta is
	0.9994 (median per tensor).
	- The protection lands on almost nothing. Because `a_j` is normalised by its maximum and
	LLaMA's residual stream has massive activation outliers, the salience vector is extremely
	peaked. Median fraction of input channels with `a_j > 0.5` (i.e. delta cut by more than 30%):

	\| module \| frac. channels `a > 0.1` \| frac. `a > 0.5` \|
	\|---\|---\|---\|
	\| `self_attn.{q,k,v}_proj` \| 0.0098 \| 0.0021 \|
	\| `self_attn.o_proj` \| 0.399 \| 0.0018 \|
	\| `mlp.{gate,up}_proj` \| 0.9998 \| 0.0031 \|
	\| `mlp.down_proj` \| 0.272 \| 0.0005 \|
	\| `lm_head` \| 0.012 \| 0.0008 \|

	Across all modules, 0.2% of input channels carry `a_j > 0.5`, and only 0.84% are
	protected enough to lose more than a tenth of their delta (`r_j < 0.9`; range 0.66–0.86% over
	the 20 pairs).

	- A single scalar per tensor reproduces AIM's weights to 99.88%. Fitting one
	activation-agnostic scalar per tensor instead of the full per-channel profile explains
	R² = 0.99882 of `W_AIM − W_base`, against R² = 0.99918 for the full profile. In weight space the
	activation-informed targeting accounts for barely a third of an already-tiny residual — which is
	exactly why §3.2's control is the test that matters, and why its result is a surprise.

	That last line is the reason §3's control exists. If a magnitude-matched uniform shrink
	reproduces 99.88% of what AIM does to the weights, then the burden is on the activation-informed
	part to show it does something in activation space that the uniform control does not — which is
	exactly AIM's claim, and exactly what a with/without benchmark comparison cannot separate.
	It does: see §3.2.

	### 2.4 Where the protection lands: AIM is mostly an MLP-input intervention

	`a_j` is normalised by the maximum channel, not the mean, so how much AIM does to a weight
	matrix is decided by how outlier-heavy that matrix's input is. LLaMA's residual stream has a few
	massive activation channels; the layers that read it therefore get almost no protection anywhere
	except on those channels, while the layers whose input is flatter get broad shrinkage.

	Measured on the base model (`results/aim/base_calib_scale.npz`), median over the 40 blocks:

	\| module \| max/mean salience ratio \| frac. channels `a>0.1` \| mean `a` \| implied mean gain `r` \| measured `‖ΔW_AIM‖/‖ΔW_merge‖` \|
	\|---\|---\|---\|---\|---\|---\|
	\| `mlp.gate_proj` / `mlp.up_proj` \| 5.0 \| 1.000 \| 0.199 \| 0.881 \| 0.891 \|
	\| `self_attn.o_proj` \| 9.4 \| 0.399 \| 0.107 \| 0.936 \| 0.956 \|
	\| `mlp.down_proj` \| 10.0 \| 0.272 \| 0.100 \| 0.940 \| 0.958 \|
	\| `self_attn.{q,k,v}_proj` \| 15.0 \| 0.010 \| 0.067 \| 0.960 \| 0.980 \|
	\| `lm_head` \| 23.9 \| 0.012 \| 0.042 \| 0.975 \| 0.981 \|
	\| `model.embed_tokens` \| — \| — \| — \| exempt \| 1.000 \|

	So AIM at ω = 0.4 removes about 11% of the merge's delta on the MLP gate and up projections and
	about 2% on attention Q/K/V, and nothing at all from the embedding table. Calling it "preserving
	the base model's salient weights" is accurate but undersells how uneven the result is: the same
	hyperparameter buys a five-fold different intervention depending on how outlier-heavy the input to
	a given matrix happens to be.

	The protected residual-stream channels are the expected ones and are stable with depth — channels
	{31, 110, 359, 371, 1160, 1419, 1554, 2200, 3837, 4283, 4923} carry `a > 0.5` in at least half the
	blocks, and the top-8 sets of two randomly chosen blocks overlap 62% on average.

	## 3. The activation-space test, and the property panel

	Two phases, chained per shard (`scripts/aim/chain_aim.sh`, GPUs 6 and 7, one matched pair on disk
	at a time, resumable ledger at `results/aim/ledger_s*.json`). Phase `mech` — the test of AIM's own
	claim, §3.1–3.2 — ran first and is complete, 20/20; it costs no gradients and no property
	columns and took ~85 s a pair. Phase `panel` — the F8 property suite, §3.3 — then covers as many
	pairs as fit before its wall-clock deadline. `scripts/aim/autopilot_aim.sh` rebuilds every table
	and figure and pushes to the Hub every 15 minutes, so partial coverage is always visible and
	always labelled.

	### 3.1 The test AIM's claim actually needs — and its control

	AIM is closer to the base model than its baseline twin by construction: the delta is multiplied
	by something in [ω, 1]. So "with-AIM merges stay closer to base" is not a finding, it is arithmetic,
	and it is not what the paper claims either. The claim is that keying that shrink to the base
	model's activations is what preserves the base model's behaviour.

	That claim has a control, and section 2.3 is the reason it is needed: a **single scalar per tensor
	reproduces AIM's weight change to R² = 0.9985**. So the sweep builds, for every baseline merge,

	W_uniform = W_base + c_t · (W_merge − W_base), c_t = ‖ΔW_AIM‖_F / ‖ΔW_merge‖_F per tensor t

	— the same weight-space move, the same distance from base on every tensor, with the activation
	information deleted. AIM and its control sit on the same sphere around the base model. All three
	arms (baseline merge, uniform control, with-AIM) are then run forward on the same 4096
	calibration token positions from pile-val — AIM's own calibration source, which is the setting most
	favourable to it — and compared to the base model's activations layer by layer:

	ρ_W = ‖ΔW_AIM‖ / ‖ΔW_merge‖ weight-space shrink
	ρ_A(x) = ‖H_x − H_base‖_F / ‖H_merge − H_base‖_F activation-space shrink, per layer

	If the targeting does anything, ρ_A(AIM) < ρ_A(uniform). If the two coincide, AIM's activation
	information is doing nothing beyond choosing how far to pull the merge back toward the base — which
	would mean the published gains are a shrinkage effect, reachable without any calibration set.
	This needs no benchmark run.

	### 3.2 RESULT — the targeting is real, and it is roughly four times more efficient than shrinkage alone

	Coverage at the time of writing: 20/20 matched pairs. The numbers below are refreshed
	automatically as more land (`scripts/aim/autopilot_aim.sh`), and the current table is always §6 T4
	and `results/aim/tables/T4_mechanism.csv`.

	Averaged over the 20 pairs measured so far, on 4096 pile-val token positions and 40 layers:

	\| quantity \| value \| reading \|
	\|---\|---\|---\|
	\| `rho_W` — weight-space shrink `‖ΔW_AIM‖/‖ΔW_merge‖` \| 0.921 \| AIM removes 7.9% of the merge's task vector \|
	\| `rho_A(uniform)` — activation shrink, activation-agnostic control \| 0.966 \| removing that much weight the wrong way removes only 3.4% of the activation deviation \|
	\| `rho_A(AIM)` — activation shrink, activation-informed \| 0.859 \| removing the same amount the right way removes 14.1% \|
	\| `aim_advantage` = `rho_A(uniform) − rho_A(AIM)` \| +0.107 \| positive in 20/20 pairs \|
	\| leverage `(1−rho_A)/(1−rho_W)` — activation deviation removed per unit of weight change \| AIM 1.79 vs uniform 0.43 \| AIM is ~4.1x more efficient \|

	Paired test. The advantage is positive on every pair measured
	(20/20), median +0.1071, Wilcoxon signed rank p = 1.907e-06. It is not an average over a mixed
	bag; no operator and no task combination is an exception.

	So the answer to the question in the section title is **yes, AIM does what it claims, and the
	claim is not trivial**. The control makes that precise. Both models are, tensor for tensor, exactly
	the same Frobenius distance from the base model; the only difference is which input channels the
	delta was taken out of. Taking it out of the channels the base model's activations single out
	removes about four times as much activation-space deviation per unit of weight moved as taking it
	out uniformly. An activation-agnostic shrink of the same size (`rho_A(uniform)` ≈
	0.97) barely moves the representation at all — it is less effective in
	activation space than in weight space, which is what you would expect from perturbing directions
	the model does not use.

	Two things this rules out, both of which the paper's own with/without benchmark comparison cannot:

	- It is not just shrinkage. Section 2.3 showed a single scalar per tensor reproduces AIM's
	weights to R² = 0.9985. That turns out to be the wrong place to look: the 0.15% of the weight
	change that the per-channel profile adds is doing most of the representational work, because it
	is concentrated on the channels that carry the activations.
	- It is not an artefact of measuring "closer to base". With-AIM is closer to base by
	construction; the control is closer by exactly as much, and still loses.

	The depth profile (panel (c) of `figures/aim/F9_AIM_mechanism.png`) shows where: the three arms are
	indistinguishable through the first ~10 blocks and separate monotonically after, with the gap
	largest at the last layer. AIM is a late-layer intervention in effect even though it is applied
	uniformly across depth.

	Caveat, stated plainly. The activations are measured on pile-val, which is AIM's own
	calibration source. That is the setting most favourable to the method — a preserved activation on
	the distribution you selected the weights from is the easiest version of the claim. It does not
	follow that the preserved activations are the ones that matter for HumanEval or GSM8K, and §3.3
	(the property panel against the published outcome) is where that link would have to be made.

	And a caution about which part of AIM predicts the benefit. Correlated against the paper's own
	published gain over the 20 pairs, it is the size of the pullback that tracks the outcome best,
	not the quality of the targeting:

	\| predictor \| Pearson r with the published AIM gain \|
	\|---\|---\|
	\| weight-space pullback `1 − rho_W` \| +0.562 \|
	\| activation-space pullback `1 − rho_A(AIM)` \| +0.517 \|
	\| targeting advantage over the control \| +0.491 \|

	Both readings are true and they are not in tension: the targeting is what makes a given weight-space
	pullback cheap in activation space (that is the result above, and it is unanimous), but across
	checkpoints what varies most with the benchmark gain is simply how much of the merge got pulled
	back. On 20 points none of these correlations is individually distinguishable from zero, so this
	is a direction to look, not a claim.
	### 3.3 RESULT — AIM moves the merge toward the base model in every family, and changes nothing about what predicts the outcome

	Coverage: 20/20 matched pairs, both arms. Two figures, and they say different things.

	`figures/aim/F8b_AIM_property_deltas.png` — what AIM moves. The paired with-minus-without
	difference in each property, over the 20 matched pairs, in units of that property's
	across-checkpoint SD. **12 of the 18 measurable
	properties survive Benjamini–Hochberg** across the panel, and every one of them moves in the same
	direction: the with-AIM merge is closer to the base model. Nothing moves the other way.

	\| family \| properties \| survive BH \| mean abs paired delta (SD) \|
	\|:---------------\|-------------:\|-------------:\|:-----------------------------\|
	\| weight space \| 4 \| 1 \| 0.122 \|
	\| representation \| 5 \| 5 \| 0.522 \|
	\| retrieval \| 0 \| 0 \| — (not identified) \|
	\| gradient \| 4 \| 2 \| 0.239 \|
	\| behaviour \| 5 \| 4 \| 0.310 \|

	That table is the §3.2 result again, from an independent direction and with an independent
	estimator. AIM's weight-space distance from base (`qmd_raw`) falls by 0.22 SD;
	its representation geometry moves 4.3× further. The intervention is small in the
	space it is applied to and large in the space it is aimed at, which is exactly what an
	activation-informed method is supposed to buy and exactly what the magnitude-matched control in
	§3.2 shows a uniform shrink does not.

	This does not depend on the small probe. §6 T6 recomputes the same properties on a
	512-sentence probe — 16x the observations, from the same forward pass — for half the matched pairs.
	Every representation column keeps its sign, its magnitude to within a few hundredths of an SD and
	its sign-test p, and the per-pair differences correlate at \|r\| ≥ 0.93 on four of the five. The
	32-sentence estimate is rank-degenerate in absolute terms, and it is nevertheless ranking these
	checkpoints the way a probe sixteen times larger does.

	The one family that does not move is retrieval — and T6 shows that is a measurement limit, not
	a finding. On 32 sentences the fitted-map columns return an exactly zero paired difference,
	because p@1 saturates at 1.0 for every checkpoint when 13 test rows sit in a 5120-dimensional
	space; on 512 sentences the same columns move consistently and significantly (sign test p = 0.002).
	The blank retrieval block in the figure is the probe failing to measure, not AIM failing to move.

	*`figures/aim/F8_AIM_metric_families.png` — what AIM does not* change.** Panels (a) and (b) are
	the F8 grammar applied to each arm: operators on the rows, the same 23 properties in the same five
	families on the columns, cells the signed Pearson r of the property with the published
	endpoint-scaled benchmark mean. Panel (c) is (a) − (b).

	All 216 correlation cells in panels (a) and (b) are struck through: not one survives Benjamini–Hochberg.
	That is the honest arithmetic of the design rather than a failure of the method — each operator has
	four task combinations, so a per-operator correlation has n = 4 and its exact permutation p cannot
	fall below 1/12; the pooled row has 20 checkpoints but only four independent task combinations to
	permute.

	So panel (c) has to be read as a magnitude, not a test. It is small: the mean absolute change in
	r across the 18 measurable properties is 0.32, against a
	noise floor established by splitting the six published benchmarks into two disjoint halves and
	asking how well the property ranking agrees with itself within one arm. Those within-arm
	split-half agreements are +0.24 and +0.98 (Spearman over properties); the cross-arm
	agreement is +0.64 — inside the band.

	Verdict: no detectable change. Re-splitting the same benchmarks within one arm perturbs the property
	ranking at least as much as swapping the arm does. On this design, activation-informed merging
	does not detectably change which properties track the merge outcome.

	That is a clean null on a well-matched design, and it is consistent with the mechanism: AIM never
	touches the merge operator, never touches the parents, and appreciably rescales under 1% of input
	channels (§2.3). It moves a merged model — measurably, in a direction that is the same for every
	operator and every task combination — without changing the relationship between a merge's
	properties and how good it is.
	### 3.4 How the property panel was computed

	The F8 suite (`figures/final/F8_metric_families.png`'s 23 properties in five families, same
	estimators, same 32-sentence probe) computed on (merged model, base model) rather than on a
	parent pair. The parent set is constant within a task combination, so a pre-merge property cannot
	vary across the 20 cells; the object that does vary is the merge's own relation to the base it was
	built from.

	Two caveats stated up front, because they decide how the figure may be read.

	- Four points per operator. Each operator has four task combinations, so a per-operator
	correlation has n = 4 and its exact permutation p cannot go below 1/12. Every per-operator cell
	in `figures/aim/F8_AIM_metric_families.png` is struck through; that is the honest result, not a
	bug. The bottom row pools all pairs after within-operator centring and uses an exact
	combo-clustered permutation.
	- `F8b_AIM_property_deltas` is the panel with power: the paired with-minus-without difference
	in each property over the matched pairs, Wilcoxon signed rank on the pooled row. Note that a
	shift toward the base model is expected there by construction (§3.1); what the panel adds is
	which families move more than the weight-space shrink alone would predict.

	## 4. What did not run, and why

	**Everything the brief asked for ran to full coverage: 20/20 matched pairs on the mechanism test
	and 20/20 on the property panel, both arms.** What follows is what was deliberately not measured.

	- No benchmark evaluation. Ruled out on time grounds; the AIM paper's published numbers cover
	all 40 checkpoints and all six benchmarks, so nothing was lost. Every outcome number in this
	report is transcribed, never re-measured.
	- `qmd` / `coordinate_gap` / `coord_fraction` are recorded NaN, and kept as columns with the
	reason attached rather than dropped. Every checkpoint here is `W_base + Δ`, so no permutation
	symmetry was ever broken between a merged model and its base: the residual-basis map is the
	identity by construction and the coordinate component is zero a priori. Measuring it would
	measure nothing. (Same reasoning as the MergeBench sweep.) `qmd_raw` is measured, exactly,
	from the norms the weight pass already accumulates.
	- *The extended 512-sentence probe (`geoX_`, `retX_`) was dropped.* It is the robustness
	check on the n/d problem — 32 mean-pooled observations against d = 5120 — not the figure, which
	uses the canonical 32-sentence probe so its columns mean the same thing as the Beetle F8's. On
	this box (load average ~330, three brain-preprocessing jobs and a second merge sweep sharing the
	CPU) the 41-layer Procrustes/SVCCA geometry on 512x5120 was taking longer than every other part
	of a pair combined, and would have pushed the sweep past the time the user has. The n/d caveat
	therefore stood unquantified for most of this run. It was measured in the end — §6 T6 runs
	the extended probe on 10 of the 20 pairs and finds the representation family's paired differences
	essentially unchanged (per-pair correlation \|r\| >= 0.93 on four of five columns), so §3.3's
	conclusion does not rest on the small probe. The remaining 10 pairs were not re-run on it.
	- The retrieval family is reported but not identified — now demonstrated, not asserted (§6 T6). `ret_procrustes_`, `ret_ridge_` and
	`ret_gain_over_identity` fit a map from d = 5120 to d = 5120 on the 19 training rows of a
	32-sentence probe. The map is rank-deficient by a factor of ~270 and the orthogonal Procrustes
	factor is determined only up to an arbitrary completion of its null space, so those columns
	measure the completion as much as the models. They are computed, plotted and struck through
	rather than silently dropped, and no conclusion in §3.3 rests on them. `ret_identity_p_at_*`
	fits nothing and is sound. T6 makes the failure concrete: on the canonical probe every fitted-map
	retrieval column returns an exactly zero paired difference across all 10 pairs measured, and on a
	512-sentence probe the same columns move consistently (sign test p = 0.002).
	- The local working tree was reset out from under this run at 22:33–22:42 UTC by another
	process on the box (a repository mirror commit followed by a sync that removed untracked files;
	it took `src/mergeschool/`'s 395 modules with it, not only this analysis). Nothing was lost:
	every artefact had been pushed to the Hub dataset at 22:37, the scripts were recoverable from
	the repository history, and the whole pipeline was re-run from the restored state and reproduced
	every number in this report bit for bit — 324/324 struck-through correlation cells, 96/108 on
	the delta panel, cross-arm agreement +0.65 inside the [+0.24, +0.98] band. It is recorded here
	because the published dataset is the primary copy of this work, not a convenience export, and a
	reader should know the local tree is the derived one.
	- AIM's ω is not swept. Only ω = 0.4 checkpoints are published, and building others would
	mean running the merges ourselves. Section 2 gives the closed form, so the ω-dependence of the
	weight-space intervention is analytic; its effect on benchmarks is not measurable from public
	artefacts.

	## 5. How to reproduce

	```bash
	source /root/.ms_hf_env # HF token; never echoed or committed
	export PYTHONPATH=/root/mergeability/src

	# (2.2) the salience correspondence test -- needs only the base model
	CUDA_VISIBLE_DEVICES=7 /root/venvs/mergeability/bin/python \
	scripts/aim/aim_salience_check.py --device cuda:0

	# (2.1, 3) the sweep: one matched pair on disk at a time, resumable via results/aim/ledger*.json
	bash scripts/aim/run_aim.sh 6 --shard 0 --n-shards 2
	bash scripts/aim/run_aim.sh 7 --shard 1 --n-shards 2
	setsid nohup bash scripts/aim/autopilot_aim.sh > logs/aim/autopilot.log 2>&1 < /dev/null &

	# everything downstream (safe on partial coverage)
	bash scripts/aim/finish_aim.sh
	```

	\| file \| what it is \|
	\|---\|---\|
	\| `scripts/aim/make_published_scores.py` \| transcribes the AIM repo's benchmark tables → `results/aim/published_scores.csv` \|
	\| `scripts/aim/aim_weight_mechanism.py` \| recovers AIM's per-channel gain from a published (base, merge, AIM) triple, streamed from safetensors \|
	\| `scripts/aim/aim_salience_check.py` \| measures the base model's activation scale independently and compares it to the recovered salience \|
	\| `scripts/aim/aim_run.py` \| the sweep: property panel + activation-space mechanism test + the uniform control \|
	\| `scripts/aim/aim_mechanism_report.py` \| `results/aim/mechanism_summary.csv`, `figures/aim/F9_AIM_mechanism.png` \|
	\| `scripts/aim/aim_figures.py` \| `figures/aim/F8_AIM_metric_families.png`, `F8b_AIM_property_deltas.png`, `results/aim/panel_stats.json` \|

	Reused rather than reimplemented, as instructed: `mergeschool.controlled.bridge_sweep`
	(`_forward`, `geometry_block`, `retrieval_block`, `behaviour_block`, the 32-sentence probe) and
	`mergeschool.mergebench.sweep` (`gradient_block_cached`, `weight_block`, `spectral_pair`,
	`_ext_probe`) supply every property column; `report.final_figures.METRIC_FAMILIES` and
	`geometry.gf_style` supply the F8 layout and colour conventions. Nothing under
	`figures/mergebench/` or `RESULTS_MERGEBENCH.md` was touched.

	<!-- AIM-TABLES:BEGIN -->

	## 6. Tables

	Every table is also a CSV under `results/aim/tables/` and on the Hub at [`Mergeability-2/aim-activation-informed-merging`](https://huggingface.co/datasets/Mergeability-2/aim-activation-informed-merging). The design is matched 20/20 on (operator x task combination), so every difference below is paired: a with-AIM value, its baseline twin, and the difference on the same row. Group means of the two arms are never reported on their own.

	### T4 — Mechanism: distance from the base model, paired

	The direct test of AIM's claim. Needs no benchmark scores. `rho_W` is the weight-space shrink `‖ΔW_AIM‖/‖ΔW_merge‖`; `rho_A_` is the same ratio measured on activations (4096 pile-val token positions, mean over layers); `aim_advantage = rho_A_uniform − rho_A_aim` is positive when the activation-informed shrink preserves the base model's activations better than an activation-agnostic shrink of exactly the same weight-space size*. `omega_hat` and `col_r2_median` are the recovered closed form; `salience_recovery_r` is the correlation between the salience implied by the published checkpoint pair and the salience measured independently from the base model.

	\| operator_label \| combo \| omega_hat \| col_r2_median \| scalar_r2_median \| salience_recovery_r \| rho_W \| rel_dev_merge \| rel_dev_uniform \| rel_dev_aim \| rho_A_uniform \| rho_A_aim \| aim_advantage \| leverage_uniform \| leverage_aim \|
	\|:-----------------\|:----------------------------\|------------:\|----------------:\|-------------------:\|----------------------:\|--------:\|----------------:\|------------------:\|--------------:\|----------------:\|------------:\|----------------:\|-------------------:\|---------------:\|
	\| DARE Linear \| Code-Instruction_Tuned \| 0.3998 \| 0.9992 \| 0.9988 \| 0.998 \| 0.9176 \| 0.3269 \| 0.3151 \| 0.2772 \| 0.9639 \| 0.848 \| 0.1158 \| 0.4386 \| 1.845 \|
	\| DARE Linear \| Code-Math \| 0.3971 \| 0.9955 \| 0.9949 \| 0.9934 \| 0.9239 \| 0.209 \| 0.2017 \| 0.1832 \| 0.9652 \| 0.8767 \| 0.08843 \| 0.4579 \| 1.62 \|
	\| DARE Linear \| Code-Math-Instruction_Tuned \| 0.3999 \| 0.9992 \| 0.9988 \| 0.9981 \| 0.9174 \| 0.414 \| 0.3971 \| 0.3468 \| 0.9592 \| 0.8379 \| 0.1213 \| 0.4943 \| 1.963 \|
	\| DARE Linear \| Math-Instruction_Tuned \| 0.3999 \| 0.9992 \| 0.9988 \| 0.9981 \| 0.9174 \| 0.3977 \| 0.3833 \| 0.3409 \| 0.9637 \| 0.8571 \| 0.1066 \| 0.4403 \| 1.731 \|
	\| DARE TIES \| Code-Instruction_Tuned \| 0.3999 \| 0.9995 \| 0.9991 \| 0.9976 \| 0.9181 \| 0.3221 \| 0.3109 \| 0.2707 \| 0.9653 \| 0.8404 \| 0.1248 \| 0.424 \| 1.948 \|
	\| DARE TIES \| Code-Math \| 0.3961 \| 0.9989 \| 0.9984 \| 0.9923 \| 0.9256 \| 0.2114 \| 0.2053 \| 0.1847 \| 0.971 \| 0.8739 \| 0.09717 \| 0.3893 \| 1.695 \|
	\| DARE TIES \| Code-Math-Instruction_Tuned \| 0.4 \| 0.9995 \| 0.9992 \| 0.9978 \| 0.9171 \| 0.4174 \| 0.4051 \| 0.3448 \| 0.9704 \| 0.826 \| 0.1444 \| 0.3578 \| 2.101 \|
	\| DARE TIES \| Math-Instruction_Tuned \| 0.4 \| 0.9995 \| 0.9992 \| 0.9978 \| 0.9175 \| 0.4002 \| 0.3856 \| 0.3405 \| 0.9635 \| 0.8508 \| 0.1127 \| 0.4421 \| 1.809 \|
	\| Task Arithmetic \| Code-Instruction_Tuned \| 0.3999 \| 0.9995 \| 0.9991 \| 0.9976 \| 0.9185 \| 0.319 \| 0.3071 \| 0.2704 \| 0.9626 \| 0.8475 \| 0.1151 \| 0.4592 \| 1.871 \|
	\| Task Arithmetic \| Code-Math \| 0.3958 \| 0.9988 \| 0.9985 \| 0.9921 \| 0.9266 \| 0.2079 \| 0.2019 \| 0.1835 \| 0.9711 \| 0.8828 \| 0.08823 \| 0.3946 \| 1.597 \|
	\| Task Arithmetic \| Code-Math-Instruction_Tuned \| 0.3999 \| 0.9995 \| 0.9991 \| 0.9978 \| 0.9178 \| 0.4056 \| 0.3942 \| 0.3436 \| 0.9717 \| 0.847 \| 0.1247 \| 0.344 \| 1.862 \|
	\| Task Arithmetic \| Math-Instruction_Tuned \| 0.3999 \| 0.9995 \| 0.9991 \| 0.9978 \| 0.9179 \| 0.3921 \| 0.3748 \| 0.3381 \| 0.956 \| 0.8622 \| 0.09375 \| 0.5363 \| 1.678 \|
	\| TIES \| Code-Instruction_Tuned \| 0.3998 \| 0.9994 \| 0.999 \| 0.9972 \| 0.9208 \| 0.2675 \| 0.2573 \| 0.2259 \| 0.9618 \| 0.8445 \| 0.1174 \| 0.4817 \| 1.963 \|
	\| TIES \| Code-Math \| 0.3939 \| 0.9988 \| 0.9984 \| 0.99 \| 0.9308 \| 0.1834 \| 0.1784 \| 0.1624 \| 0.9729 \| 0.8855 \| 0.08738 \| 0.392 \| 1.654 \|
	\| TIES \| Code-Math-Instruction_Tuned \| 0.4001 \| 0.9992 \| 0.9988 \| 0.9965 \| 0.9219 \| 0.2203 \| 0.2121 \| 0.1892 \| 0.9627 \| 0.8586 \| 0.1041 \| 0.4771 \| 1.81 \|
	\| TIES \| Math-Instruction_Tuned \| 0.4 \| 0.9993 \| 0.9989 \| 0.9971 \| 0.9196 \| 0.2414 \| 0.2327 \| 0.2053 \| 0.964 \| 0.8504 \| 0.1136 \| 0.448 \| 1.862 \|
	\| WIDEN \| Code-Instruction_Tuned \| 0.3957 \| 0.998 \| 0.9977 \| 0.9792 \| 0.9213 \| 0.2152 \| 0.2062 \| 0.1898 \| 0.958 \| 0.8819 \| 0.07616 \| 0.5335 \| 1.501 \|
	\| WIDEN \| Code-Math \| 0.3717 \| 0.9899 \| 0.9894 \| 0.9428 \| 0.9352 \| 0.15 \| 0.1468 \| 0.1333 \| 0.9791 \| 0.889 \| 0.09009 \| 0.3227 \| 1.713 \|
	\| WIDEN \| Code-Math-Instruction_Tuned \| 0.3955 \| 0.998 \| 0.9977 \| 0.9715 \| 0.9211 \| 0.2454 \| 0.2365 \| 0.2111 \| 0.9641 \| 0.8603 \| 0.1038 \| 0.4551 \| 1.77 \|
	\| WIDEN \| Math-Instruction_Tuned \| 0.3987 \| 0.9983 \| 0.9979 \| 0.9892 \| 0.9205 \| 0.272 \| 0.2634 \| 0.2342 \| 0.9687 \| 0.8611 \| 0.1076 \| 0.3941 \| 1.747 \|


	Paired test of the targeting advantage over the magnitude-matched uniform control, across the 20 matched pairs: mean +0.10666, median +0.10708, 20/20 positive, Wilcoxon signed rank p = 1.91e-06, sign test p = 1.91e-06.


	### T0 — The merge outcome, paired (published numbers, nothing re-run)

	Transcribed from the AIM repo's benchmark tables (arXiv:2502.02421). `endpoint_scaled` is the mean of the six benchmarks after each is put on the endpoint scale (0 = base model, 1 = best single parent).

	\| operator_label \| combo \| endpoint_scaled__without_aim \| endpoint_scaled__with_aim \| endpoint_scaled__diff \| HV__without_aim \| HV__with_aim \| HV__diff \|
	\|:-----------------\|:----------------------------\|-------------------------------:\|----------------------------:\|------------------------:\|------------------:\|---------------:\|-----------:\|
	\| DARE Linear \| Code-Instruction_Tuned \| 0.8677 \| 1.013 \| 0.1453 \| 0.27 \| 0.28 \| 0.01 \|
	\| DARE Linear \| Code-Math \| 0.3075 \| 0.3864 \| 0.07898 \| 0.23 \| 0.23 \| 0 \|
	\| DARE Linear \| Code-Math-Instruction_Tuned \| -0.08486 \| 0.4756 \| 0.5605 \| 0.16 \| 0.23 \| 0.07 \|
	\| DARE Linear \| Math-Instruction_Tuned \| -0.1676 \| 0.4478 \| 0.6154 \| 0.18 \| 0.26 \| 0.08 \|
	\| DARE TIES \| Code-Instruction_Tuned \| 0.9333 \| 1.057 \| 0.1232 \| 0.28 \| 0.29 \| 0.01 \|
	\| DARE TIES \| Code-Math \| 0.2859 \| 0.4103 \| 0.1244 \| 0.23 \| 0.24 \| 0.01 \|
	\| DARE TIES \| Code-Math-Instruction_Tuned \| 0.05984 \| 0.6035 \| 0.5437 \| 0.17 \| 0.24 \| 0.07 \|
	\| DARE TIES \| Math-Instruction_Tuned \| 0.05639 \| 0.6078 \| 0.5514 \| 0.2 \| 0.26 \| 0.06 \|
	\| Task Arithmetic \| Code-Instruction_Tuned \| 0.8608 \| 1.005 \| 0.1444 \| 0.28 \| 0.28 \| 0 \|
	\| Task Arithmetic \| Code-Math \| 0.3548 \| 0.4036 \| 0.0488 \| 0.24 \| 0.24 \| 0 \|
	\| Task Arithmetic \| Code-Math-Instruction_Tuned \| -0.0403 \| 0.4746 \| 0.5149 \| 0.16 \| 0.22 \| 0.06 \|
	\| Task Arithmetic \| Math-Instruction_Tuned \| -0.117 \| 0.3636 \| 0.4806 \| 0.18 \| 0.24 \| 0.06 \|
	\| TIES \| Code-Instruction_Tuned \| -0.01921 \| 0.007883 \| 0.02709 \| 0 \| 0.05 \| 0.05 \|
	\| TIES \| Code-Math \| 0.2174 \| 0.3515 \| 0.1341 \| 0.2 \| 0.23 \| 0.03 \|
	\| TIES \| Code-Math-Instruction_Tuned \| 0.5291 \| 0.5451 \| 0.01592 \| 0.11 \| 0.11 \| 0 \|
	\| TIES \| Math-Instruction_Tuned \| 1.028 \| 1.087 \| 0.05813 \| 0.23 \| 0.25 \| 0.02 \|
	\| WIDEN \| Code-Instruction_Tuned \| 1.02 \| 1.01 \| -0.01021 \| 0.27 \| 0.26 \| -0.01 \|
	\| WIDEN \| Code-Math \| 0.5438 \| 0.5435 \| -0.0003216 \| 0.24 \| 0.24 \| 0 \|
	\| WIDEN \| Code-Math-Instruction_Tuned \| 1.043 \| 1.153 \| 0.1092 \| 0.29 \| 0.3 \| 0.01 \|
	\| WIDEN \| Math-Instruction_Tuned \| 0.9253 \| 1.039 \| 0.1139 \| 0.3 \| 0.31 \| 0.01 \|


	Paired: endpoint-scaled mean gain +0.2190 (18/20 positive, Wilcoxon p = 9.54e-06); HV gain +0.0270 (14/20 positive, Wilcoxon p = 0.00157). AIM's published benefit is real and consistent — which is what makes the question of what causes it worth asking.


	Per benchmark, paired across the 20 matched pairs:

	\| benchmark \| mean_diff \| n_positive \| n_pairs \| p_wilcoxon \|
	\|:------------\|------------:\|-------------:\|----------:\|-------------:\|
	\| HumanEval \| 1.645 \| 10 \| 20 \| 0.05947 \|
	\| MBPP \| 2.8 \| 17 \| 20 \| 0.0005757 \|
	\| MMLU \| 0.7655 \| 20 \| 20 \| 1.907e-06 \|
	\| MATH \| 0.915 \| 12 \| 20 \| 0.02418 \|
	\| GSM8K \| 1.84 \| 12 \| 20 \| 0.06728 \|
	\| IFEval \| 0.1645 \| 11 \| 20 \| 0.3603 \|


	### T2 — Does AIM's effect differ by merge operator?

	\| operator \| n_metrics \| n_moved_q<0.05 \| mean_\|diff\| (SD units) \| largest movers \|
	\|:-------------------\|------------:\|-----------------:\|-------------------------:\|:---------------------------------------------------------------------------------------------------\|
	\| ALL \| 49 \| 25 \| 0.3632 \| geo_procrustes_peak_depth (+0.83), ret_procrustes_p_at_5 (+0.78), geo_svcca_peak_depth (-0.61) \|
	\| DARETaskArithmetic \| 49 \| 0 \| 0.4439 \| geo_procrustes_peak_depth (+1.45), geo_cka_peak_depth (-0.87), ret_procrustes_p_at_5 (+0.87) \|
	\| DARETies \| 49 \| 0 \| 0.4886 \| geo_svcca_late_minus_early (+1.36), geo_procrustes_peak_depth (+1.34), geo_cka_peak_depth (-1.09) \|
	\| TaskArithmetic \| 49 \| 0 \| 0.5017 \| ret_procrustes_p_at_5 (+1.73), subspace_overlap (+1.66), geo_procrustes_peak_depth (+1.34) \|
	\| Ties \| 49 \| 0 \| 0.2425 \| subspace_overlap (+0.66), geo_cka_late_minus_early (+0.56), geo_svcca_peak_depth (-0.53) \|
	\| WIDEN \| 49 \| 0 \| 0.3423 \| geo_subspace_overlap_peak_depth (+1.58), geo_cka_peak_depth (+0.87), ret_procrustes_p_at_5 (+0.87) \|


	Full table: `results/aim/tables/T2_per_operator.csv` (294 rows: every metric x every level, with the paired mean difference in SD units, the count of positive differences, Wilcoxon/sign p and BH q).


	### T3 — Does it differ by which domains were merged?

	\| combo \| n_metrics \| n_moved_q<0.05 \| mean_\|diff\| (SD units) \| largest movers \|
	\|:----------------------------\|------------:\|-----------------:\|-------------------------:\|:----------------------------------------------------------------------------------------------------\|
	\| ALL \| 49 \| 25 \| 0.3632 \| geo_procrustes_peak_depth (+0.83), ret_procrustes_p_at_5 (+0.78), geo_svcca_peak_depth (-0.61) \|
	\| Code-Instruction_Tuned \| 49 \| 0 \| 0.3395 \| geo_subspace_overlap_peak_depth (+1.26), grad_l2 (-0.80), geo_svcca_peak_depth (-0.74) \|
	\| Code-Math \| 49 \| 0 \| 0.1911 \| subspace_overlap (-0.66), geo_cka_late_minus_early (+0.66), geo_procrustes_late_minus_early (-0.54) \|
	\| Code-Math-Instruction_Tuned \| 49 \| 0 \| 0.5143 \| geo_procrustes_peak_depth (+1.68), ret_procrustes_p_at_5 (+1.04), cka_to_base (+0.93) \|
	\| Math-Instruction_Tuned \| 49 \| 0 \| 0.5161 \| ret_procrustes_p_at_5 (+1.73), geo_procrustes_peak_depth (+1.63), geo_svcca_mean (+0.89) \|


	Full table: `results/aim/tables/T3_per_combo.csv` (245 rows: every metric x every level, with the paired mean difference in SD units, the count of positive differences, Wilcoxon/sign p and BH q).


	### T1 — Paired per-checkpoint table

	One row per (operator, task combination, property): the with-AIM value, its baseline twin's value, the raw difference and the difference in SD units, joined to the published outcome for that pair. `results/aim/tables/T1_paired_per_checkpoint.csv`. This is the core artefact of the matched design; it is too large to render inline (20 pairs x ~70 properties).


	### F8 / F8b — the property panels, pooled row

	`figures/aim/F8_AIM_metric_families.png` panels (a)/(b)/(c) and `figures/aim/F8b_AIM_property_deltas.png`, bottom row (`all (within-op.)`, n = 20 pairs). Correlations are against the endpoint-scaled published benchmark mean.

	\| property \| family \| r with AIM \| r baseline \| delta r \| paired delta property (SD) \| q (BH) \|
	\|:--------------------------\|:---------------\|:-------------\|:-------------\|:----------\|:-----------------------------\|:----------\|
	\| weight_cosine \| weight space \| -0.3263 \| 0.04417 \| -0.3705 \| 1.549e-05 \| 0.1849 \|
	\| qmd_raw \| weight space \| 0.3543 \| -0.02069 \| 0.3749 \| -0.2204 \| 2.503e-05 \|
	\| coord_fraction \| weight space \| — \| — \| — \| — \| — \|
	\| subspace_overlap \| weight space \| 0.1779 \| -0.3726 \| 0.5505 \| 0.2656 \| 0.4485 \|
	\| spectral_overcounting \| weight space \| -0.4281 \| -0.1548 \| -0.2733 \| 0.001196 \| 0.6212 \|
	\| geo_cka_mean \| representation \| 0.1309 \| 0.4916 \| -0.3607 \| 0.5648 \| 2.503e-05 \|
	\| geo_procrustes_mean \| representation \| -0.1913 \| -0.5677 \| 0.3763 \| -0.5539 \| 2.503e-05 \|
	\| geo_subspace_overlap_mean \| representation \| 0.2967 \| 0.6692 \| -0.3725 \| 0.425 \| 2.503e-05 \|
	\| geo_svcca_mean \| representation \| 0.1751 \| 0.6714 \| -0.4963 \| 0.5149 \| 0.0001113 \|
	\| geo_cka_late_minus_early \| representation \| 0.2585 \| 0.4179 \| -0.1594 \| 0.5537 \| 2.503e-05 \|
	\| ret_identity_p_at_1 \| retrieval \| — \| — \| — \| — \| — \|
	\| ret_procrustes_p_at_1 \| retrieval \| — \| — \| — \| — \| — \|
	\| ret_ridge_p_at_1 \| retrieval \| — \| — \| — \| — \| — \|
	\| ret_gain_over_identity \| retrieval \| — \| — \| — \| — \| — \|
	\| grad_cosine \| gradient \| -0.1334 \| 0.1461 \| -0.2795 \| 0.3867 \| 0.0002003 \|
	\| grad_l2 \| gradient \| -0.2863 \| -0.2413 \| -0.04494 \| -0.4187 \| 0.04883 \|
	\| grad_norm_ratio \| gradient \| -0.3615 \| -0.1257 \| -0.2358 \| 0.01775 \| 1 \|
	\| grad_cosine_layer_min \| gradient \| -0.4962 \| -0.3037 \| -0.1925 \| 0.1309 \| 0.358 \|
	\| beh_js \| behaviour \| -0.2728 \| -0.6451 \| 0.3723 \| -0.2395 \| 2.503e-05 \|
	\| beh_logit_cosine \| behaviour \| 0.2548 \| 0.6439 \| -0.3891 \| 0.4425 \| 2.503e-05 \|
	\| beh_topk_overlap \| behaviour \| 0.4404 \| 0.6939 \| -0.2535 \| 0.327 \| 0.0008383 \|
	\| beh_rank_corr \| behaviour \| 0.2513 \| 0.6428 \| -0.3915 \| 0.4338 \| 2.503e-05 \|
	\| beh_entropy_gap \| behaviour \| 0.2796 \| 0.6307 \| -0.3511 \| 0.1068 \| 0.05893 \|


	Does AIM change which properties track the outcome? The cross-arm agreement of the property ranking is compared against a within-arm split-half ceiling (the six published benchmarks split into two disjoint halves), because with four task combinations per operator an agreement near zero could equally mean 'the ranking changed' or 'four points cannot pin down a correlation'.

	\| quantity \| Spearman over properties \|
	\|:-------------------------------\|---------------------------:\|
	\| within_arm_split_half_baseline \| 0.9835 \|
	\| within_arm_split_half_aim \| 0.2446 \|
	\| cross_arm_full_outcome \| 0.645 \|
	\| cross_arm_h1 \| 0.872 \|
	\| cross_arm_h2 \| 0.02786 \|
	\| within_arm_mean \| 0.614 \|
	\| cross_arm_mean \| 0.4499 \|


	Verdict: no detectable change.


	<!-- AIM-EXT:BEGIN -->
	### T6 — Probe-size robustness of the representation family

	The canonical panel uses the Beetle F8's 32-sentence probe, which at d = 5120 solves a
	5120-dimensional geometry from 32 mean-pooled observations. This table recomputes the same
	properties on a 512-sentence probe — 16x the observations, from the same forward pass in the
	same run, so nothing but sample size differs — for 10 of the 20 matched pairs (one task
	combination of every operator, plus a second combination where time allowed).

	The question is whether §3.3's conclusion depends on the small probe. It does not. Across the
	5 properties both probes can measure, the paired with-minus-without difference keeps
	its sign on 5/5, keeps its magnitude to within a few hundredths of an SD,
	and keeps the same sign test p. In the representation family — the one that carries §3.3's result —
	the per-pair differences correlate at \|r\| ≥ 0.9 on 4 of 5 properties: the
	32-sentence probe is not merely getting the average right, it is ranking the individual checkpoints
	the same way a 16x larger probe does.

	The retrieval family behaves completely differently, and that is the point of including it. On the
	32-sentence probe every fitted-map column returns an exactly zero paired difference — p@1
	saturates at 1.0 for every checkpoint, because 13 test rows in a 5120-dimensional space are
	trivially separable. On 512 sentences the same columns show a consistent, significant shift
	(+0.53 SD on average, sign test p = 0.002). So the blank retrieval
	block in `F8b_AIM_property_deltas.png` is not AIM failing to move retrieval; it is the canonical
	probe being unable to measure it. §4 records this as a limitation rather than a result.

	\| property \| n_pairs \| delta_32 (SD) \| delta_512 (SD) \| same sign \| pos_32 \| pos_512 \| p_sign_32 \| p_sign_512 \| corr of per-pair deltas \|
	\|:--------------------------\|----------:\|:----------------\|-----------------:\|------------:\|---------:\|----------:\|:------------\|-------------:\|:--------------------------\|
	\| geo_cka_mean \| 10 \| 0.4901 \| 0.5124 \| 1 \| 10 \| 10 \| 0.001953 \| 0.001953 \| 0.9677 \|
	\| geo_procrustes_mean \| 10 \| -0.4956 \| -0.4787 \| 1 \| 0 \| 0 \| 0.001953 \| 0.001953 \| 0.999 \|
	\| geo_subspace_overlap_mean \| 10 \| 0.4256 \| 0.4088 \| 1 \| 10 \| 10 \| 0.001953 \| 0.001953 \| 0.9892 \|
	\| geo_svcca_mean \| 10 \| 0.5732 \| 0.4013 \| 1 \| 10 \| 10 \| 0.001953 \| 0.001953 \| 0.9255 \|
	\| geo_cka_late_minus_early \| 10 \| 0.5933 \| 0.6237 \| 1 \| 10 \| 10 \| 0.001953 \| 0.001953 \| -0.6146 \|
	\| ret_identity_p_at_1 \| 10 \| — \| 0.629 \| 0 \| 0 \| 2 \| — \| 0.5 \| — \|
	\| ret_procrustes_p_at_1 \| 10 \| — \| 0.4857 \| 0 \| 0 \| 10 \| — \| 0.001953 \| — \|
	\| ret_ridge_p_at_1 \| 10 \| — \| 0.5381 \| 0 \| 0 \| 9 \| — \| 0.003906 \| — \|
	\| ret_gain_over_identity \| 10 \| — \| 0.4776 \| 0 \| 0 \| 10 \| — \| 0.001953 \| — \|

	`delta_*` columns are the mean paired difference in units of that estimate's own across-checkpoint
	SD, so the two probes are comparable despite estimating different quantities. `corr of per-pair
	deltas` is the correlation between the two probes' per-pair differences: high means the small probe
	is ranking the checkpoints the same way, not merely getting the average sign right.
	<!-- AIM-EXT:END -->

	### T5 — Coverage and provenance

	Mechanism (§3.2): 20/20 matched pairs. Property panel (§3.3): 20/20. Published benchmark scores cover 20/20 — they were transcribed, not measured. A pair with `panel_status = not-run` was not reached before the panel phase's wall-clock deadline; its mechanism result is unaffected.

	\| operator_label \| combo \| mech_status \| panel_status \| weight_mechanism \| activation_mechanism \| property_panel_both_arms \| published_benchmarks \|
	\|:-----------------\|:----------------------------\|:--------------\|:---------------\|:-------------------\|:-----------------------\|:---------------------------\|:-----------------------\|
	\| Task Arithmetic \| Code-Math \| ok \| ok \| True \| True \| True \| True \|
	\| Task Arithmetic \| Code-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| Task Arithmetic \| Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| Task Arithmetic \| Code-Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| TIES \| Code-Math \| ok \| ok \| True \| True \| True \| True \|
	\| TIES \| Code-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| TIES \| Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| TIES \| Code-Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| DARE Linear \| Code-Math \| ok \| ok \| True \| True \| True \| True \|
	\| DARE Linear \| Code-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| DARE Linear \| Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| DARE Linear \| Code-Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| DARE TIES \| Code-Math \| ok \| ok \| True \| True \| True \| True \|
	\| DARE TIES \| Code-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| DARE TIES \| Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| DARE TIES \| Code-Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| WIDEN \| Code-Math \| ok \| ok \| True \| True \| True \| True \|
	\| WIDEN \| Code-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| WIDEN \| Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|
	\| WIDEN \| Code-Math-Instruction_Tuned \| ok \| ok \| True \| True \| True \| True \|


	F8 property columns, and the reason for any that are empty. NaN-by-construction columns are kept rather than dropped.

	\| column \| family \| in_F8 \| populated \| reason_if_not \|
	\|:--------------------------\|:---------------\|:--------\|:------------\|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\|
	\| weight_cosine \| weight space \| True \| True \| nan \|
	\| qmd_raw \| weight space \| True \| False \| sweep incomplete \|
	\| coord_fraction \| weight space \| True \| False \| NaN by construction: coordinate_gap / qmd_raw with a zero numerator. \|
	\| subspace_overlap \| weight space \| True \| True \| nan \|
	\| spectral_overcounting \| weight space \| True \| True \| nan \|
	\| geo_cka_mean \| representation \| True \| True \| nan \|
	\| geo_procrustes_mean \| representation \| True \| True \| nan \|
	\| geo_subspace_overlap_mean \| representation \| True \| True \| nan \|
	\| geo_svcca_mean \| representation \| True \| True \| nan \|
	\| geo_cka_late_minus_early \| representation \| True \| True \| nan \|
	\| ret_identity_p_at_1 \| retrieval \| True \| True \| nan \|
	\| ret_procrustes_p_at_1 \| retrieval \| True \| True \| nan \|
	\| ret_ridge_p_at_1 \| retrieval \| True \| True \| nan \|
	\| ret_gain_over_identity \| retrieval \| True \| True \| nan \|
	\| grad_cosine \| gradient \| True \| True \| nan \|
	\| grad_l2 \| gradient \| True \| True \| nan \|
	\| grad_norm_ratio \| gradient \| True \| True \| nan \|
	\| grad_cosine_layer_min \| gradient \| True \| True \| nan \|
	\| beh_js \| behaviour \| True \| True \| nan \|
	\| beh_logit_cosine \| behaviour \| True \| True \| nan \|
	\| beh_topk_overlap \| behaviour \| True \| True \| nan \|
	\| beh_rank_corr \| behaviour \| True \| True \| nan \|
	\| beh_entropy_gap \| behaviour \| True \| True \| nan \|
	\| geoX_* \| representation \| False \| False \| extended 512-sentence probe not run: it is the robustness check on the n/d problem, not the figure, and the 41-layer Procrustes/SVCCA geometry at 512x5120 dominated the sweep's cost on a contended box. \|
	\| retX_* \| retrieval \| False \| False \| extended 512-sentence probe not run: it is the robustness check on the n/d problem, not the figure, and the 41-layer Procrustes/SVCCA geometry at 512x5120 dominated the sweep's cost on a contended box. \|


	<!-- AIM-TABLES:END -->
	---

	## Appendix: raw output of the downstream analysis

	Produced by `scripts/aim/finish_aim.sh` at 2026-08-26T22:37:48Z.
	```
	== ledger ==
	40/20 cells complete
	== mechanism ==
	corr(weight shrink 1-rho_W, published AIM gain) = +0.562 (n=20)
	corr(activation shrink 1-rho_A(AIM), published AIM gain) = +0.517 (n=20)
	corr(targeting advantage, published AIM gain) = +0.491 (n=20)
	wrote /root/mergeability/results/aim/mechanism_summary.csv (20 pairs)
	AIM advantage over the magnitude-matched uniform control: median +0.10708 (n=20, Wilcoxon p=0.0000, 20/20 positive)
	operator combo rho_W rho_A_aim rho_A_uniform aim_advantage leverage_aim leverage_uniform
	DARETaskArithmetic Code-Instruction_Tuned 0.91765 0.84803 0.96388 0.11585 1.84539 0.43865
	DARETaskArithmetic Code-Math 0.92390 0.87672 0.96515 0.08843 1.61997 0.45793
	DARETaskArithmetic Code-Math-Instruction_Tuned 0.91739 0.83786 0.95917 0.12131 1.96277 0.49430
	DARETaskArithmetic Math-Instruction_Tuned 0.91744 0.85708 0.96365 0.10657 1.73112 0.44027
	DARETies Code-Instruction_Tuned 0.91810 0.84043 0.96527 0.12484 1.94836 0.42404
	DARETies Code-Math 0.92557 0.87385 0.97102 0.09717 1.69488 0.38933
	DARETies Code-Math-Instruction_Tuned 0.91714 0.82595 0.97035 0.14440 2.10055 0.35778
	DARETies Math-Instruction_Tuned 0.91754 0.85084 0.96354 0.11270 1.80878 0.44212
	TaskArithmetic Code-Instruction_Tuned 0.91847 0.84749 0.96256 0.11507 1.87066 0.45923
	TaskArithmetic Code-Math 0.92664 0.88282 0.97105 0.08823 1.59729 0.39457
	TaskArithmetic Code-Math-Instruction_Tuned 0.91783 0.84701 0.97174 0.12473 1.86191 0.34397
	TaskArithmetic Math-Instruction_Tuned 0.91789 0.86221 0.95596 0.09375 1.67806 0.53631
	Ties Code-Instruction_Tuned 0.92078 0.84445 0.96183 0.11738 1.96340 0.48174
	Ties Code-Math 0.93077 0.88548 0.97286 0.08738 1.65426 0.39200
	Ties Code-Math-Instruction_Tuned 0.92188 0.85861 0.96273 0.10412 1.80991 0.47713
	Ties Math-Instruction_Tuned 0.91965 0.85041 0.96400 0.11360 1.86171 0.44799
	WIDEN Code-Instruction_Tuned 0.92133 0.88188 0.95803 0.07616 1.50147 0.53346
	WIDEN Code-Math 0.93521 0.88900 0.97909 0.09009 1.71324 0.32273
	WIDEN Code-Math-Instruction_Tuned 0.92107 0.86029 0.96408 0.10379 1.77000 0.45506
	WIDEN Math-Instruction_Tuned 0.92050 0.86108 0.96867 0.10759 1.74748 0.39412
	wrote /root/mergeability/figures/aim/F9_AIM_mechanism.png
	== panels ==
	panel rows: 40 checkpoints, {0: 20, 1: 20}
	wrote /root/mergeability/figures/aim/F8_AIM_metric_families.png (324/324 struck through)
	wrote /root/mergeability/figures/aim/F8b_AIM_property_deltas.png (96/108 struck through)
	property-ranking agreement, Task Arithmetic: Spearman +0.847 Pearson +0.801 mean\|dr\| 0.381 (18 properties)
	property-ranking agreement, TIES: Spearman +0.501 Pearson +0.576 mean\|dr\| 0.262 (18 properties)
	property-ranking agreement, DARE Linear: Spearman +0.816 Pearson +0.740 mean\|dr\| 0.442 (18 properties)
	property-ranking agreement, DARE TIES: Spearman +0.443 Pearson +0.415 mean\|dr\| 0.519 (18 properties)
	property-ranking agreement, WIDEN: Spearman +0.798 Pearson +0.929 mean\|dr\| 0.139 (18 properties)
	property-ranking agreement, all (within-op.): Spearman +0.645 Pearson +0.723 mean\|dr\| 0.325 (18 properties)
	noise ceiling on the pooled property ranking (Spearman over properties):
	within_arm_split_half_baseline: +0.983
	within_arm_split_half_aim: +0.245
	cross_arm_full_outcome: +0.645
	cross_arm_h1: +0.872
	cross_arm_h2: +0.028
	-> cross-arm agreement +0.645 lies INSIDE the within-arm split-half band [+0.245, +0.983]: no detectable change in which properties track the outcome
	wrote /root/mergeability/results/aim/panel_stats.json
	== tables ==
	wrote §3.3 (12 properties surviving BH, mean \|dr\| = 0.325)
	T4 paired test of the AIM targeting advantage over the magnitude-matched control: mean +0.10666, 20/20 positive, Wilcoxon p=1.9073486328125e-06
	T0 published outcome, paired: mean endpoint-scaled gain +0.2190, 18/20 positive, Wilcoxon p=9.5367431640625e-06
	wrote tables/T4_mechanism.csv (20 rows)
	wrote tables/T1b_paired_mechanism_per_checkpoint.csv (100 rows)
	wrote tables/T1_paired_per_checkpoint.csv (980 rows)
	wrote tables/T2_per_operator.csv (294 rows)
	wrote tables/T3_per_combo.csv (245 rows)
	wrote tables/T0_published_outcome_paired.csv (20 rows)
	wrote tables/T5_coverage.csv (20 rows)
	wrote tables/T5b_column_provenance.csv (25 rows)
	rendered tables into /root/mergeability/RESULTS_AIM.md
	```