Mergeability-2/aim-activation-informed-merging

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

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.

Complete: 20/20 matched pairs on both the mechanism test and the property panel. Published at 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

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.

6. Tables

Every table is also a CSV under results/aim/tables/ and on the Hub at 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.

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.

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.

---

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