llm_moe: the union operator (route/max-merge) vs fusion — and the regime flips at scale

Adds the union-preserving recombination operator that llm_merge lacked (E8's max,
not mean): keep each specialist LoRA intact and SELECT the right one per prompt
(MoE router: oracle, or training-free nearest-centroid over base embeddings) or
per module (max_merge = winner-take-all by delta norm). src/llm/moe.py, kind
llm_moe, reuses the cached specialists.

Result — a clean regime boundary for "merge, don't average":
- 0.5B: union wins. Routing 0.74 / worst-family 0.43 > soup 0.64 / 0.26, with no
  dilution (recovers each specialist's own-family peak). E8's max > mean in real
  weights, because at a weak base averaging dilutes.
- 7B (Imperial CX3, L40S, 9 min): the ordering INVERTS. Fusion wins — soup 0.87 >
  routing 0.84 > max_merge 0.78. Routing is capped at the best parent per family;
  fusion blends and, given a capable base, COMPOSES beyond any parent (soup lists
  0.62 > spec 0.57). Selection can't synthesise better than its best component;
  averaging-that-composes can.

So "merge, don't average" (E4/E8) is a weak-parent / small-model law, not
universal: union wins under dilution, fusion wins under composition. Refines E8
(its additive-landscape max>mean assumed no compositional headroom). The operator
to want is fusion-that-composes + offspring selection = the directed-sex ideal
(E10) — the natural next experiment.

Honest riders: the learned router is trivially perfect (lexically-distinct
families), and router-free max_merge is the weakest union (not input-adaptive).
+2 router unit tests (127 green). Results in results/llm_moe{,_hpc}/ (parquet
gitignored per the reproducibility contract).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

configs/llm/moe.yaml

@@ -0,0 +1,25 @@
+experiment: llm_moe
+kind: llm_moe
+seed: 1
+n_replicates: 1
+
+# Layer 2 / LLM — module-level, UNION-PRESERVING recombination (the real-weight image of E8's *max*).
+# Reuses the specialist adapters trained by configs/llm/merge.yaml (models/llm/spec_*) and contrasts
+# two families of recombination operator on the same held-out mixed test set:
+#   FUSION (blend the deltas):   soup = mean(Δ_k);  ties = sign-reconciled union.
+#   UNION  (never average):      moe_oracle / moe_learned = keep every specialist intact and ROUTE each
+#                                prompt to one (MoE-over-experts); max_merge = per-module winner-take-all.
+# Prediction (E8, "merge don't average"): union beats fusion exactly where fusion DILUTES — pronounced
+# at a weak base (0.5B), narrowing once a capable base lets fusion compose (7B). Falsifier: fusion
+# matches or beats the routing ceiling (moe_oracle) at 0.5B, i.e. averaging never dilutes.
+
+base_model: Qwen/Qwen2.5-0.5B-Instruct   # reuses the same cached specialists as llm_merge
+families: [lists, strings, arith]
+n_train: 700          # only used if the cached specialists are absent
+n_test: 100
+n_route: 32           # labelled prompts per family for the learned router's centroids
+epochs: 3
+lora: {r: 16, alpha: 32}
+operators: [soup, ties, moe_oracle, moe_learned, max_merge]
+
+output: {dir: results/llm_moe}