giorgio/MachineSex
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

society: the dynamic Lamarckian society — the vertical claim (E11 / C3)

Browse source 
The culmination. A finite population of agents (genotypes, L loci) evolves
on a rugged NK landscape that IS reality (knowledge/dynamic_society.py),
composing the four operators the whole study built toward: grounding,
directed recombination (sex), quality-diversity selection, and mutation.
Grounding is made load-bearing via the consensus-conformity (self-
consumption) mechanism (GG decision): selection acts on
g*true_fitness + (1-g)*conformity, where conformity = agreement with the
population's own consensus, so at g=0 the society optimises fitting-the-
crowd rather than reality.

4-arm ablation (12 reps), each breaking distinctly, only the full society
climbing (global_opt ~ 0.79):
- full         0.78  climbs to the optimum, diversity maintained longest
- no_sex       0.77  can't recombine to escape local optima
- no_diversity 0.74  greedy: collapses diversity fastest, worse local optimum
- no_grounding 0.48  self-consumption collapse to an unfit consensus
                     (trains on the crowd -> confident-but-wrong mean;
                      conformity-true gap ~ 0.5)

This integrates E1-E6 + the learning kernel + E7-E10 into one system and
shows the Lamarckian society needs ALL of grounding + directed sex +
diversity: on a rugged landscape you need diversity to explore basins, sex
to recombine them, and grounding to select on reality -- remove any one and
you fail differently. Closes the C3 vertical claim analytically; the LLM
rung remains the eventual empirical instantiation.

New: knowledge/dynamic_society.py, configs/layer1/E11.yaml, figures/
plot_E11.py, README, tests/test_dynamic_society.py (+5). kind:
dynamic_society dispatch; make layer1 wired. 122 tests green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Giorgio Gilestro 2026-07-05 12:34:01 +01:00
parent 48181a1c84
commit 0f7b775ae5
13 changed files with 460 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

143
src/knowledge/dynamic_society.py Normal file
View file

@ -0,0 +1,143 @@
"""The dynamic Lamarckian society — the vertical claim (E11 / C3).
A finite population of ``N`` agents (genotypes of ``L`` biallelic loci) evolves on a Kauffman NK
landscape that *is* reality. The society climbs in real capability by composing the four operators the
whole study built toward — **grounding**, **directed recombination (sex)**, **quality-diversity
selection**, and mutation — and an ablation shows each is load-bearing.
The crux is what happens WITHOUT grounding. A plain genetic algorithm on true fitness would just
improve, so grounding must corrupt the *selection signal* to cause collapse. Here selection acts on a
**grounded score** ``g·true_fitness + (1−g)·conformity``, where conformity is agreement with the
population's own consensus (modal genotype). At ``g=0`` selection rewards fitting the crowd rather
than reality — self-consumption — and the society drifts to a fit-looking but actually-poor consensus,
losing diversity: the direct analogue of training on the majority of AI-generated outputs.
Four ablation arms, each breaking distinctly (only ``full`` avoids all three failures):
``full`` (climbs) · ``no_grounding`` (conformity collapse) · ``no_sex`` (stuck at local optima) ·
``no_diversity`` (collapses to one lineage, recombination starves).
"""
from __future__ import annotations
from typing import Any, Mapping
import numpy as np
import pandas as pd
from .genotype import bits_to_index, crossover, genotype_bits, nk_fitness
def _consensus(pop_bits: np.ndarray) -> np.ndarray:
"""Population consensus genotype: the modal allele at each locus (majority vote)."""
return (pop_bits.mean(axis=0) >= 0.5).astype(pop_bits.dtype)
def _conformity(pop_bits: np.ndarray, consensus: np.ndarray) -> np.ndarray:
"""Per-agent agreement with the consensus (fraction of loci matching the majority)."""
return (pop_bits == consensus[None, :]).mean(axis=1)
def _novelty(pop_bits: np.ndarray) -> np.ndarray:
"""Per-agent novelty: mean Hamming distance to the rest of the population (diversity signal)."""
N, L = pop_bits.shape
if N < 2:
return np.zeros(N)
# pairwise Hamming via allele agreement: distance_ij = L - matches; mean over j != i.
match = (pop_bits[:, None, :] == pop_bits[None, :, :]).sum(axis=2) # (N, N) matches
ham = L - match
return (ham.sum(axis=1) / (N - 1)) / L # normalised to [0,1]
def _directed_offspring(pop_bits, fitness, n_off, rate, rng):
"""Directed sex: make ``n_off`` recombinants from the whole population, return them ranked-ready.
Unbounded-parent crossover (the AI move); offspring selection happens in the survival step, so
here we just generate the candidate offspring bit-matrix.
"""
return np.stack([crossover(pop_bits, rate, rng) for _ in range(n_off)])
def run_dynamic_society(cfg: Mapping[str, Any], seed: int) -> pd.DataFrame:
"""Run one dynamic-society lineage; return per-generation metrics.
Args:
cfg (Mapping): Config with a ``society`` block (``L``, ``K`` landscape ruggedness, ``N``
population, ``g`` grounding, ``mu`` mutation, ``novelty`` QD weight, ``n_off`` offspring
pool, ``recomb_rate``, ``sex`` on/off, ``select`` in {``qd``, ``greedy``}) and
``generations``.
seed (int): Replicate seed; the landscape and the run are a pure function of it.
Returns:
pd.DataFrame: One row per generation with ``best_fitness`` (real), ``mean_fitness`` (real),
``diversity`` (mean normalised pairwise Hamming), ``consensus_fitness``,
``conformity_true_gap`` (mean conformity − mean true fitness; exposes the no-grounding
collapse), and ``global_opt``.
"""
soc = cfg["society"]
L, K, N = int(soc["L"]), int(soc["K"]), int(soc["N"])
g = float(soc.get("g", 1.0))
mu = float(soc.get("mu", 0.02))
novelty_w = float(soc.get("novelty", 0.0))
n_off = int(soc.get("n_off", N))
rate = float(soc.get("recomb_rate", 0.2))
sex = bool(soc.get("sex", True))
select = soc.get("select", "qd")
generations = int(cfg.get("generations", 100))
fitness = nk_fitness(L, K, seed) # reality
global_opt = float(fitness.max())
all_bits = genotype_bits(L)
rng = np.random.default_rng(seed)
# Initialise a diverse population of random genotypes.
pop = rng.integers(0, 2, size=(N, L)).astype(all_bits.dtype)
def true_fit(bits):
return np.array([fitness[bits_to_index(b)] for b in bits])
rows: list[dict] = []
def record(t: int) -> None:
tf = true_fit(pop)
cons = _consensus(pop)
conf = _conformity(pop, cons)
rows.append({
"generation": t,
"best_fitness": float(tf.max()),
"mean_fitness": float(tf.mean()),
"diversity": float(_novelty(pop).mean()),
"consensus_fitness": float(fitness[bits_to_index(cons)]),
"conformity_true_gap": float(conf.mean() - tf.mean()),
"global_opt": global_opt,
})
record(0)
for t in range(1, generations + 1):
# (1) candidate pool = current population + directed offspring (sex) or mutated clones.
if sex:
offspring = _directed_offspring(pop, fitness, n_off, rate, rng)
else: # asexual: offspring are mutated copies
idx = rng.integers(0, N, size=n_off)
offspring = pop[idx].copy()
# mutation on the offspring
flip = rng.random(offspring.shape) < mu
offspring = np.where(flip, 1 - offspring, offspring).astype(pop.dtype)
pool = np.concatenate([pop, offspring], axis=0)
# (2) grounded score: g*true_fitness + (1-g)*conformity (conformity vs the *current* consensus).
cons = _consensus(pop)
tf = true_fit(pool)
conf = _conformity(pool, cons)
score = g * tf + (1.0 - g) * conf
# (3) survival: QD (score + novelty) keeps diverse high-scorers; greedy keeps top score only.
if select == "qd" and novelty_w > 0.0:
nov = _novelty(pool)
merit = score + novelty_w * nov
else:
merit = score
keep = np.argsort(merit)[-N:] # elitist truncation survival
pop = pool[keep]
record(t)
return pd.DataFrame(rows)

42
src/knowledge/experiment.py
View file

@ -167,6 +167,46 @@ def run_genotype_experiment(cfg: dict) -> pd.DataFrame:
return out
_DYNAMIC_KEYS = ("society", "generations")
def run_dynamic_experiment(cfg: dict) -> pd.DataFrame:
"""Run the dynamic society across an ``arm`` ablation sweep x replicates (E11).
Mirrors ``run_genotype_experiment`` but assembles the base from the ``society``/``generations``
blocks and calls ``run_dynamic_society``. Arms are named override bundles (reuse ``_apply_param``
``arm`` handling), e.g. ``no_grounding`` sets ``society.g=0``.
"""
from .dynamic_society import run_dynamic_society
base = {k: copy.deepcopy(cfg[k]) for k in _DYNAMIC_KEYS if k in cfg}
sweeps = cfg.get("sweep", [])
if isinstance(sweeps, dict):
sweeps = [sweeps]
params = [s["param"] for s in sweeps]
value_lists = [list(s["values"]) for s in sweeps]
combos = [({}, base)] if not sweeps else []
for values in itertools.product(*value_lists):
lin = copy.deepcopy(base)
label: dict = {}
for param, val in zip(params, values):
label.update(_apply_param(lin, param, val))
combos.append((label, lin))
seeds = spawn_seeds(int(cfg["seed"]), int(cfg["n_replicates"]))
frames: list[pd.DataFrame] = []
for label, lin in combos:
for rep, ss in enumerate(seeds):
df = run_dynamic_society(lin, int(ss.generate_state(1)[0]))
for col, val in label.items():
df[col] = val
df["replicate"] = rep
frames.append(df)
out = pd.concat(frames, ignore_index=True)
out.insert(0, "experiment", cfg["experiment"])
return out
def run_coverage(cfg: dict) -> pd.DataFrame:
"""E4 runner: multi-teacher recombination coverage (blueprint 2.5-E4 / 2.7.1).
@ -332,6 +372,8 @@ def run_and_save(config_path: str | Path) -> Path:
elif kind == "directed_sex":
from .society import run_directed_sex # E10: directed sex beats biology
df = run_directed_sex(cfg)
elif kind == "dynamic_society":
df = run_dynamic_experiment(cfg) # E11: the dynamic society (C3)
else:
df = run_experiment(cfg)
save_artifacts(cfg, df, out_dir)