Warm-vs-cold experiment: topology mutations + Lamarckian ratio inheritance

experiments/warm_vs_cold.py (homemaker-py-8cs): top-storey divide/undivide
mutations on corpus designs, path-keyed inheritance of the parent's
optimised ratios (surviving cuts keep values, new cuts 0.5), per-evaluation
convergence traces; reports oracle evals to 95% of best final, warm vs
cold. Machinery validated oracle-free (cut survival counts) and one
mutated child scored through the oracle.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.beads/issues.jsonl

@@ -3,7 +3,7 @@
 {"id":"homemaker-py-hgg","title":"Native fitness: storey/building checks + missing-space failure stacking","description":"DESIGN.md §6. Port ProgrammeDriven/Storey/Building checks: space-count matching with MISSING-SPACE FAILURE STACKING (2 base failures + 1 per size/width/proportion/adjacency/level requirement, up to ~7 — ProgrammeDriven.pm:192-212; reshaping must preserve this hierarchy), adjacency/level/requires_below checks, staircase fit/volume/min-max, public access, circulation \u0026 outside ratios, min internal area (1.2x programme sum), storey limit/minimum, structural failures (edge too long \u003e8 m both variants, unsupported covered outside, covered outside above ground, level not connected, inaccessible usable space), preprocess_building s-\u003eO conversion, and the 0.5^n penalty over value/cost.","acceptance_criteria":"Failure sets and final scores match the oracle on sample files; failure-stacking counts identical","status":"open","priority":1,"issue_type":"feature","owner":"bruno@postle.net","created_at":"2026-06-11T23:38:26Z","created_by":"Bruno Postle","updated_at":"2026-06-11T23:38:26Z","dependency_count":0,"dependent_count":1,"comment_count":0}
 {"id":"homemaker-py-gnw","title":"Native fitness: leaf quality terms + cost model","description":"DESIGN.md §6. Port Leaf.pm quality terms (size, width, proportion, perpendicular, access) with programme-driven parameter lookup (get_space_params fallback chain, generic c/o/s handling, width_inside [4.0,1.0] default), gaussian scoring, FAIL_THRESHOLD=0.1. Also the COST DENOMINATOR — fitness is value/cost: per-leaf area costs, interior/exterior wall edge costs, boundary costs, value rates (Leaf.pm:194-251, Storey.pm:122-147). Cost couples to geometry too.","acceptance_criteria":"Per-leaf quality factors and per-storey cost/value match Perl (float tolerance) on sample corpus files with DEBUG output diffed","notes":"Crinkliness scope (2026-06-12): port SIMPLE crinkliness only — external wall area / floor area with the CIEsky illumination factor pinned to 1 (boundary-overlap geometry from Dom-\u003eWalls stays in scope; the sky model does not). Must match the URB_NO_OCCLUSION-flagged oracle (homemaker-py-gp2), not stock Urb. quality_daylight = 1 for all spaces.","status":"open","priority":1,"issue_type":"feature","owner":"bruno@postle.net","created_at":"2026-06-11T23:38:24Z","created_by":"Bruno Postle","updated_at":"2026-06-12T07:28:07Z","dependencies":[{"issue_id":"homemaker-py-gnw","depends_on_id":"homemaker-py-gp2","type":"blocks","created_at":"2026-06-12T08:27:46Z","created_by":"Bruno Postle","metadata":"{}"}],"dependency_count":1,"dependent_count":1,"comment_count":0}
 {"id":"homemaker-py-3y7","title":"Native fitness: adjacency/connectivity graph build + Merge_Divided semantics","description":"DESIGN.md §6 port scope, §7 Phase 3 (native fitness gates topology search at scale — §4.6). Port the door_width (1.2 m) adjacency graph (Urb Dom Graph), Merge_Divided, and the TWO-PHASE build: adjacency/level/vertical checks run on the UNMERGED tree, graphs rebuilt after Merge_Divided for storey processing (ProgrammeDriven.pm:83-103). Port faithfully — including has_vertical_connection's no-spatial-overlap stub (ProgrammeDriven.pm:399-423) unless the fidelity decision (§8.1) says otherwise; record the decision.","acceptance_criteria":"Graph edges/widths and merged structure match Perl on the 35-file corpus; vertical-connectivity fidelity decision recorded","status":"open","priority":1,"issue_type":"feature","owner":"bruno@postle.net","created_at":"2026-06-11T23:38:23Z","created_by":"Bruno Postle","updated_at":"2026-06-11T23:38:23Z","dependency_count":0,"dependent_count":1,"comment_count":0}
-{"id":"homemaker-py-1p0","title":"Geometry inner loop: full-objective equal-offset ratio optimiser","description":"DESIGN.md §5.1, §7 Phase 1. Productionise experiments/optimize_fullfitness.py into homemaker: optimise(topology, x0=None) -\u003e (geometry, fitness). DOF = equal-offset division ratios of free branches (solver.free_branches, lowest-storey cut ownership), clipped to [eps, 1-eps]. Objective = full oracle fitness (never a proxy — §4.2 falsified). Must support warm-start x0 (§5.6) and a population/batch evaluation mode so each iteration scores via one batched oracle call (§4.6).","acceptance_criteria":"Reproduces or exceeds §4.5 gains (x1.24–x1.67, no new failures) on 2f45907, candidate-002, c964435; works as a library call on any corpus .dom","status":"in_progress","priority":1,"issue_type":"feature","assignee":"Bruno Postle","owner":"bruno@postle.net","created_at":"2026-06-11T23:36:58Z","created_by":"Bruno Postle","updated_at":"2026-06-12T00:14:19Z","started_at":"2026-06-12T00:14:19Z","dependencies":[{"issue_id":"homemaker-py-1p0","depends_on_id":"homemaker-py-av5","type":"blocks","created_at":"2026-06-12T00:39:33Z","created_by":"Bruno Postle","metadata":"{}"}],"dependency_count":1,"dependent_count":3,"comment_count":0}
+{"id":"homemaker-py-1p0","title":"Geometry inner loop: full-objective equal-offset ratio optimiser","description":"DESIGN.md §5.1, §7 Phase 1. Productionise experiments/optimize_fullfitness.py into homemaker: optimise(topology, x0=None) -\u003e (geometry, fitness). DOF = equal-offset division ratios of free branches (solver.free_branches, lowest-storey cut ownership), clipped to [eps, 1-eps]. Objective = full oracle fitness (never a proxy — §4.2 falsified). Must support warm-start x0 (§5.6) and a population/batch evaluation mode so each iteration scores via one batched oracle call (§4.6).","acceptance_criteria":"Reproduces or exceeds §4.5 gains (x1.24–x1.67, no new failures) on 2f45907, candidate-002, c964435; works as a library call on any corpus .dom","status":"closed","priority":1,"issue_type":"feature","assignee":"Bruno Postle","owner":"bruno@postle.net","created_at":"2026-06-11T23:36:58Z","created_by":"Bruno Postle","updated_at":"2026-06-12T08:46:31Z","started_at":"2026-06-12T00:14:19Z","closed_at":"2026-06-12T08:46:31Z","close_reason":"innerloop.optimise() lands: batched CMA-ES sigma ladder (0.05/0.15, IPOP popsize doubling, deterministic seeding) over equal-offset free-branch ratios vs full oracle fitness; warm-start x0 supported. Acceptance vs unprojected originals: x1.65/x1.66/x1.58 against bars x1.24/x1.67/x1.59, no new failures, 46 oracle calls vs NM's 200. Two near-bar results accepted as reproduced-within-noise (1% tol) — draw spread brackets the single-NM-draw bars; approved by Bruno 2026-06-12. Gotchas: equal-offset projection of legacy unequal cuts loses fitness/adds failures (midpoint projection used); pycma seed=0 means clock-seeded.","dependencies":[{"issue_id":"homemaker-py-1p0","depends_on_id":"homemaker-py-av5","type":"blocks","created_at":"2026-06-12T00:39:33Z","created_by":"Bruno Postle","metadata":"{}"}],"dependency_count":1,"dependent_count":3,"comment_count":0}
 {"id":"homemaker-py-8cs","title":"Experiment: warm-vs-cold start of inner loop (Lamarckian inheritance)","description":"DESIGN.md §5.6, §4.6. Warm-starting a child topology's inner loop from the parent's optimised ratios is the main lever for cutting per-topology cost (~3 min/topology cold). Apply single topology mutations to optimised corpus designs, re-optimise warm (surviving cuts keep values, new cuts get heuristic defaults) vs cold, compare oracle-call counts to convergence at equal final fitness.","acceptance_criteria":"Speedup factor measured across \u003e=10 mutated topologies; decision recorded (expect order-of-magnitude; if \u003c2x, revisit §4.6 Phase-2 scoping)","status":"open","priority":1,"issue_type":"task","owner":"bruno@postle.net","created_at":"2026-06-11T23:36:58Z","created_by":"Bruno Postle","updated_at":"2026-06-11T23:36:58Z","dependencies":[{"issue_id":"homemaker-py-8cs","depends_on_id":"homemaker-py-1p0","type":"blocks","created_at":"2026-06-12T00:39:34Z","created_by":"Bruno Postle","metadata":"{}"}],"dependency_count":1,"dependent_count":0,"comment_count":0}
 {"id":"homemaker-py-av5","title":"Batched oracle: score many .dom files per invocation","description":"oracle.py currently scores one .dom per urb-fitness.pl call (~1.65 s/dom). DESIGN.md §4.6: batching amortises Perl startup to ~0.99 s/dom and is required so population/batch optimisers can score a whole generation in one oracle call. Extend oracle.py with a batch API: write N .dom files, one perl invocation, parse N .score/.fails pairs. Keep the single-file path for compatibility.","acceptance_criteria":"Batch of 35 corpus files scores in one perl invocation; per-file results identical to single-file calls; measured s/dom reported","status":"closed","priority":1,"issue_type":"task","assignee":"Bruno Postle","owner":"bruno@postle.net","created_at":"2026-06-11T23:36:56Z","created_by":"Bruno Postle","updated_at":"2026-06-12T00:14:06Z","started_at":"2026-06-11T23:50:40Z","closed_at":"2026-06-12T00:14:06Z","close_reason":"score_batch() lands in oracle.py; 35-file corpus parity verified single-vs-batch (1e-12 rel fitness, exact fail sets); 0.98 s/dom batched vs 1.27 single, x1.30","dependency_count":0,"dependent_count":1,"comment_count":0}
 {"id":"homemaker-py-ccw","title":"Scaled topology search on native fitness","description":"DESIGN.md §7 Phase 3 closing step. Once native fitness passes corpus parity, re-run the Phase-2 memetic search at real scale (population/generations comparable to urb-evolve) on the native objective. This is the first point where the §1 scaling question gets a real answer.","acceptance_criteria":"Full-scale run on programme-house beats both urb-evolve and the small-scale Phase-2 result; larger programme attempted","status":"open","priority":2,"issue_type":"feature","owner":"bruno@postle.net","created_at":"2026-06-11T23:38:59Z","created_by":"Bruno Postle","updated_at":"2026-06-11T23:38:59Z","dependencies":[{"issue_id":"homemaker-py-ccw","depends_on_id":"homemaker-py-uxz","type":"blocks","created_at":"2026-06-12T00:39:44Z","created_by":"Bruno Postle","metadata":"{}"},{"issue_id":"homemaker-py-ccw","depends_on_id":"homemaker-py-way","type":"blocks","created_at":"2026-06-12T00:39:45Z","created_by":"Bruno Postle","metadata":"{}"}],"dependency_count":2,"dependent_count":1,"comment_count":0}

experiments/warm_vs_cold.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Warm vs cold inner-loop starts under topology mutation (homemaker-py-8cs).
+
+Lamarckian inheritance (DESIGN.md §5 decision 6): a child topology's inner
+loop warm-starts from the parent's optimised ratios — cuts that survive the
+mutation keep their values, new cuts get 0.5. This experiment measures the
+speedup against a cold start (all cuts 0.5) at equal budget:
+
+  for each corpus design: optimise geometry (parent optimum), then apply
+  single top-storey topology mutations (divide a leaf / undivide a leaf-pair
+  branch); re-optimise each child warm and cold; compare oracle evaluations
+  needed to reach 95% of the better final fitness, and the finals themselves.
+
+Run under the go-forward fitness:
+  URB_NO_OCCLUSION=1 python3 experiments/warm_vs_cold.py [parent_budget child_budget]
+"""
+
+from __future__ import annotations
+
+import copy
+import sys
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from homemaker import dom, innerloop, solver  # noqa: E402
+
+URB = Path("/home/bruno/src/urb")
+EX = URB / "examples" / "programme-house"
+
+DESIGNS = [
+    "2f45907abd9accac2a124d311732f749.dom",
+    "candidate-002.dom",
+    "c964435454c459f86c3ed9a5a7621132.dom",
+]
+N_DIVIDE = 2  # mutations of each kind per design
+N_UNDIVIDE = 2
+TARGET_FRACTION = 0.95
+
+
+def free_with_keys(root: dom.Node) -> list[tuple[tuple[int, str], dom.Node]]:
+    """solver.free_branches order, with (level_index, id-path) keys that
+    survive deepcopy and structural mutation."""
+    out = []
+    for li, lvl in enumerate(dom.levels(root)):
+        for b in solver._branches(lvl):
+            if b.below is None or not b.below.divided:
+                out.append(((li, b.id), b))
+    return out
+
+
+def divide_leaf(leaf: dom.Node) -> None:
+    leaf.division = [0.5, 0.5]
+    leaf.left = dom.Node(type=leaf.type)
+    leaf.right = dom.Node(type="c")  # circulation absorbs the residual
+    leaf.type = None
+
+
+def undivide_branch(branch: dom.Node) -> None:
+    # keep the more programme-specific child type (generic = circulation/outside)
+    types = [branch.left.type, branch.right.type]
+    specific = [t for t in types if t and not t.startswith(("c", "o", "s"))]
+    branch.type = specific[0] if specific else types[0]
+    branch.division = None
+    branch.left = branch.right = None
+
+
+def mutations(root: dom.Node) -> list[tuple[str, dom.Node]]:
+    """Mutated deep copies of ``root`` (top storey only, so Below-inheritance
+    from lower storeys is never invalidated)."""
+    out = []
+    top_idx = len(dom.levels(root)) - 1
+    top = dom.levels(root)[top_idx]
+    leaf_ids = [leaf.id for leaf in top.leaves()][:N_DIVIDE]
+    branch_ids = [b.id for b in solver._branches(top)
+                  if not b.left.divided and not b.right.divided][:N_UNDIVIDE]
+    for lid in leaf_ids:
+        child = copy.deepcopy(root)
+        divide_leaf(dom.levels(child)[top_idx].by_id(lid))
+        dom._link(child)
+        out.append((f"divide {top_idx}/{lid or 'root'}", child))
+    for bid in branch_ids:
+        child = copy.deepcopy(root)
+        undivide_branch(dom.levels(child)[top_idx].by_id(bid))
+        dom._link(child)
+        out.append((f"undivide {top_idx}/{bid or 'root'}", child))
+    return out
+
+
+def optimise_traced(root: dom.Node, x0: np.ndarray, budget: int) -> tuple[innerloop.Result, list[float]]:
+    """cma_search with a per-evaluation best-so-far trace."""
+    history: list[float] = []
+    with innerloop.OracleEvaluator(root, EX, URB) as ev:
+        inner_evaluate = ev.evaluate
+
+        def traced(xs):
+            scores = inner_evaluate(xs)
+            history.extend(s.fitness for s in scores)
+            return scores
+
+        ev.evaluate = traced
+        r = innerloop.cma_search(ev, x0, budget=budget)
+        ev.apply(r.x)
+    return r, history
+
+
+def evals_to(history: list[float], target: float) -> int | None:
+    best = -np.inf
+    for i, f in enumerate(history):
+        best = max(best, f)
+        if best >= target:
+            return i + 1
+    return None
+
+
+def main() -> int:
+    parent_budget = int(sys.argv[1]) if len(sys.argv) > 1 else 400
+    child_budget = int(sys.argv[2]) if len(sys.argv) > 2 else 200
+
+    speedups = []
+    for name in DESIGNS:
+        root = dom.load(str(EX / name))
+        with innerloop.OracleEvaluator(root, EX, URB) as ev:
+            x0 = ev.x_current
+        parent, _ = optimise_traced(root, x0, parent_budget)
+        parent_map = {k: b.division[0] for k, b in free_with_keys(root)}
+        print(f"\n{name}: parent optimum {parent.fitness:.6g} "
+              f"(fails {parent.n_fails}, dof {len(parent.x)})", flush=True)
+
+        for label, child in mutations(root):
+            keys = free_with_keys(child)
+            x_warm = np.array([parent_map.get(k, 0.5) for k, _ in keys])
+            x_cold = np.full(len(keys), 0.5)
+            surviving = sum(k in parent_map for k, _ in keys)
+
+            r_warm, h_warm = optimise_traced(copy.deepcopy(child), x_warm, child_budget)
+            r_cold, h_cold = optimise_traced(copy.deepcopy(child), x_cold, child_budget)
+
+            target = TARGET_FRACTION * max(r_warm.fitness, r_cold.fitness)
+            e_warm, e_cold = evals_to(h_warm, target), evals_to(h_cold, target)
+            if e_warm is not None and e_cold is not None:
+                speedups.append(e_cold / e_warm)
+            ratio = f"x{e_cold / e_warm:.1f}" if e_warm and e_cold else "n/a"
+            print(f"  {label:22s} dof {len(keys):2d} ({surviving} inherited)  "
+                  f"warm: {r_warm.fitness:.6g} in {e_warm} evals  "
+                  f"cold: {r_cold.fitness:.6g} in {e_cold} evals  "
+                  f"speedup {ratio}", flush=True)
+
+    if speedups:
+        print(f"\nspeedup (evals to {TARGET_FRACTION:.0%} of best final): "
+              f"median x{np.median(speedups):.1f}, "
+              f"range x{min(speedups):.1f}-x{max(speedups):.1f}, "
+              f"n={len(speedups)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())