E14: mating systems — monogamy vs promiscuity (mate-pool breadth)

A new analytic experiment on an orthogonal evolution-of-sex axis: not the
recombination RATE (E9) but the population's mating STRUCTURE. Agents on a
ring recombine with a second parent drawn from a window of breadth b
(b->0 monogamous/isolation-by-distance, b=1 promiscuous/panmictic), under
local selection, swept against NK ruggedness K.

Finding: the optimal mate-pool breadth SHRINKS as skills get more
entangled. Wide/promiscuous merging wins the champion on additive
landscapes (K<=3, b=0.6), but on rugged ones (K>=6) it prematurely
converges to a worse champion and an intermediate breadth (b~0.35) wins;
pure monogamy over-fragments. Throughout, promiscuity monotonically lifts
the population MEAN but destroys diversity and parallel exploration. The
design rule extends E9: merge widely for additive skills, keep
island-structured sub-populations for entangled ones — a merging-native
axis the panmixia-assuming literature lacks.

- src/knowledge/mating_system.py + experiment.py dispatch (kind: mating_system)
- configs/layer1/E14.yaml (breadth x K sweep, 20 reps, bitwise-reproducible)
- figures/plot_E14.py; results/E14/ (figure, README, manifest, resolved config)
- tests/test_mating_system.py (+5, 147 green); make layer1 wired
- folded into both papers (full + accessible) as the third §5 result

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

paper/the-evolution-of-sex-for-ai-accessible.md

@@ -187,6 +187,18 @@ only worked as a whole. Biologists call this **outbreeding depression**, and we
 gets. The design rule: *combine freely when skills are independent; combine sparingly and carefully when
 they're tangled.*
 
+**How *widely* you mate matters too.** That last point was about *how much* to mix; a separate knob is
+*who mixes with whom*. **Monogamy** = each model only ever combines within a small, fixed circle;
+**promiscuity** = any model can combine with any other. Almost all model-merging today is promiscuous by
+default — throw everything in one pot. But there's a catch: wide mixing spreads good traits fast, but it
+also makes the whole population converge to the *same thing*, killing variety. Narrow, local mixing keeps
+separate sub-groups exploring different solutions. We tested this against tangledness, and the best answer
+*moves*: on simple (independent-skill) problems, wide promiscuous merging is best; but the more tangled
+the skills, the more you want to *narrow* it — full promiscuity converges too fast onto one mediocre
+solution and finds a *worse* champion, while keeping structured sub-groups preserves the variety a hard
+problem needs. So the rule extends: *merge widely for independent skills; keep separate sub-populations
+("island" merging) for tangled ones.*
+
 **AI can do sex better than biology can.** Biology is stuck with two parents, mating more or less at
 random, and can't inspect a child before it's born. AI has none of those limits. It can combine **many**
 parents at once; it can **choose** which parents to combine, for complementary skills; and it can
@@ -449,6 +461,12 @@ real language models. Here's the shape of the evidence (a separate document has
   level off below. On *tangled* problems, blind combining instead produces below-parent children
   (outbreeding depression) — and *directed* combining (choose mates, screen offspring, many parents)
   reliably fixes it.
+- **Monogamy vs promiscuity.** Sweeping how *widely* models merge — from local/monogamous to
+  everyone-with-everyone/promiscuous — against how tangled the skills are, the best breadth **shrinks as
+  the skills get more tangled**: wide promiscuous merging wins when skills are independent, but on tangled
+  problems it converges too fast onto one mediocre solution and finds a worse champion, so keeping
+  structured sub-populations wins. (Promiscuity always lifts the *typical* model but always destroys
+  variety.) A merging design knob the field, which throws everything in one pot, doesn't currently have.
 - **The combining claims, in real language models — with a sharp condition.** Merging fine-tuned Qwen
   models (up to 7B on a GPU cluster) produces a generalist that beats every specialist parent; and
   keeping parents separate and *routing*, or *breeding and screening* offspring, beats the plain average