Archive experiment updates 2026-10-06 (3/8)

File-level snapshot; code revision f298768b6843c8e53a0009b3adc0291eda5fea2c. Weights and Docker images remain local.

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_model.py

@@ -0,0 +1,339 @@
+"""FP32 Qwen adapter. All CE/KL reductions preserve per-sequence weighting."""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import os
+import time
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList
+
+from .hebbian_data import TEMPLATE, score_answer
+from .hebbian_learning import ARTIFACTS, DATA, config, now, read_json, write_json
+
+
+def tensor_hash(tensor):
+    return hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest()
+
+
+def state_hashes(model):
+    return {name: tensor_hash(p) for name, p in model.state_dict().items()}
+
+
+def aggregate_hash(hashes):
+    return hashlib.sha256(
+        "\n".join(f"{k}:{v}" for k, v in sorted(hashes.items())).encode()
+    ).hexdigest()
+
+
+def set_determinism(seed=0):
+    os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8")
+    torch.set_num_threads(4)
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    torch.backends.cudnn.benchmark = False
+    torch.use_deterministic_algorithms(True)
+
+
+class QwenExperiment:
+    def __init__(self, device="cuda:3"):
+        set_determinism()
+        self.cfg = config()
+        self.device = torch.device(device)
+        source = DATA / "source/qwen3-0.6b-base"
+        self.tokenizer = AutoTokenizer.from_pretrained(source, local_files_only=True)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+        self.model = (
+            AutoModelForCausalLM.from_pretrained(
+                source,
+                local_files_only=True,
+                torch_dtype=torch.float32,
+                attn_implementation=self.cfg["model"]["attention"],
+            )
+            .to(self.device)
+            .eval()
+        )
+        self.model.requires_grad_(False)
+        self.layer = self.model.model.layers[self.cfg["model"]["layer"]]
+        self.mlp = self.layer.mlp
+        assert self.mlp.down_proj.weight.shape == (1024, 3072)
+        assert self.mlp.up_proj.weight.numel() + self.mlp.gate_proj.weight.numel() == 6291456
+        self.base_local = {n: p.detach().clone() for n, p in self.mlp.named_parameters()}
+        self.reference = None
+
+    def restore_base(self):
+        with torch.no_grad():
+            for n, p in self.mlp.named_parameters():
+                p.copy_(self.base_local[n])
+
+    def configure_trainable(self, phase):
+        self.model.requires_grad_(False)
+        names = ["down_proj.weight"] if phase == "adapt" else ["up_proj.weight", "gate_proj.weight"]
+        for name, p in self.mlp.named_parameters():
+            p.requires_grad_(name in names)
+        return [p for p in self.model.parameters() if p.requires_grad]
+
+    def make_reference(self):
+        self.reference = copy.deepcopy(self.model).eval().requires_grad_(False)
+
+    def rows(self, records, views=(0,)):
+        return [(r, v, r["encoded"][v]) for r in records for v in views]
+
+    def batch(self, encoded, prompt_only=False):
+        sequences = [
+            x["input_ids"][: x["answer_start"]] if prompt_only else x["input_ids"] for x in encoded
+        ]
+        width = max(map(len, sequences))
+        ids = torch.full(
+            (len(sequences), width),
+            self.tokenizer.pad_token_id,
+            dtype=torch.long,
+            device=self.device,
+        )
+        attention = torch.zeros_like(ids)
+        answer = torch.zeros_like(ids, dtype=torch.bool)
+        for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)):
+            ids[i, : len(seq)] = torch.tensor(seq, device=self.device)
+            attention[i, : len(seq)] = 1
+            if not prompt_only:
+                answer[i, : len(seq)] = torch.tensor(enc["loss_mask"], device=self.device).bool()
+        return ids, attention, answer
+
+    def hidden(self, ids, attention, model=None):
+        return (
+            (model or self.model)
+            .model(input_ids=ids, attention_mask=attention, use_cache=False)
+            .last_hidden_state
+        )
+
+    def ce(self, encoded, model=None):
+        ids, attention, mask = self.batch(encoded)
+        hidden = self.hidden(ids, attention, model)
+        b, t = torch.where(mask[:, 1:])
+        logits = (model or self.model).lm_head(hidden[b, t])
+        losses = F.cross_entropy(logits, ids[b, t + 1], reduction="none")
+        sums = torch.zeros(len(encoded), device=self.device).scatter_add_(0, b, losses)
+        counts = torch.bincount(b, minlength=len(encoded))
+        return sums / counts
+
+    def kl(self, encoded):
+        if self.reference is None:
+            raise RuntimeError("An episode-specific parent reference is required")
+        ids, attention, mask = self.batch(encoded)
+        b, t = torch.where(mask[:, 1:])
+        with torch.no_grad():
+            ref_hidden = self.hidden(ids, attention, self.reference)
+            ref_log = F.log_softmax(self.reference.lm_head(ref_hidden[b, t]), dim=-1)
+        logits = self.model.lm_head(self.hidden(ids, attention)[b, t])
+        losses = F.kl_div(
+            F.log_softmax(logits, dim=-1), ref_log, reduction="none", log_target=True
+        ).sum(-1)
+        sums = torch.zeros(len(encoded), device=self.device).scatter_add_(0, b, losses)
+        return sums / torch.bincount(b, minlength=len(encoded))
+
+    def features(self, encoded, detach=True):
+        captured = {}
+
+        def capture(module, args):
+            captured["phi"] = args[0]
+
+        def capture_input(module, args):
+            captured["x"] = args[0]
+
+        handle = self.mlp.down_proj.register_forward_pre_hook(capture)
+        input_handle = self.mlp.register_forward_pre_hook(capture_input)
+        try:
+            ids, attention, _ = self.batch(encoded, prompt_only=True)
+            if detach:
+                with torch.no_grad():
+                    hidden = self.hidden(ids, attention)
+                    positions = attention.sum(1) - 1
+                    self.last_prompt_logits = self.model.lm_head(
+                        hidden[torch.arange(len(encoded), device=self.device), positions]
+                    ).detach()
+                    x = captured["x"][torch.arange(len(encoded), device=self.device), positions]
+                    self.last_layer_inputs = x.detach()
+                    self.original_features = (
+                        F.linear(x, self.base_local["up_proj.weight"])
+                        * F.silu(F.linear(x, self.base_local["gate_proj.weight"]))
+                    ).detach()
+            else:
+                self.hidden(ids, attention)
+            phi = captured["phi"][
+                torch.arange(len(encoded), device=self.device), attention.sum(1) - 1
+            ]
+            return phi.detach() if detach else phi
+        finally:
+            handle.remove()
+            input_handle.remove()
+
+    @torch.no_grad()
+    def generate(self, prompts, max_new_tokens=24):
+        # Left-padding generation; positions are computed from the attention mask.
+        self.tokenizer.padding_side = "left"
+        inputs = self.tokenizer(
+            prompts, padding=True, return_tensors="pt", add_special_tokens=False
+        ).to(self.device)
+        prompt_width = inputs.input_ids.shape[1]
+        tokenizer = self.tokenizer
+
+        class StopAtNewline(StoppingCriteria):
+            def __call__(self, input_ids, scores, **kwargs):
+                texts = tokenizer.batch_decode(
+                    input_ids[:, prompt_width:], skip_special_tokens=True
+                )
+                return torch.tensor(["\n" in text for text in texts], device=input_ids.device)
+
+        output = self.model.generate(
+            **inputs,
+            do_sample=False,
+            max_new_tokens=max_new_tokens,
+            pad_token_id=self.tokenizer.pad_token_id,
+            eos_token_id=self.tokenizer.eos_token_id,
+            use_cache=True,
+            logits_to_keep=1,
+            stopping_criteria=StoppingCriteriaList([StopAtNewline()]),
+        )
+        tail = output[:, inputs.input_ids.shape[1] :]
+        predictions = self.tokenizer.batch_decode(tail, skip_special_tokens=True)
+        # Padding after a newline stop is not evidence of the model emitting EOS.
+        eos_emitted = []
+        for row in tail:
+            emitted = False
+            for length, token in enumerate(row, 1):
+                if int(token) == self.tokenizer.eos_token_id:
+                    emitted = True
+                    break
+                if "\n" in self.tokenizer.decode(row[:length], skip_special_tokens=True):
+                    break
+            eos_emitted.append(emitted)
+        return predictions, eos_emitted
+
+    @torch.no_grad()
+    def evaluate(self, records, views=(0, 1, 2), batch_size=24):
+        rows = self.rows(records, views)
+        result = []
+        for start in range(0, len(rows), batch_size):
+            chunk = rows[start : start + batch_size]
+            encoded = [x[2] for x in chunk]
+            losses = self.ce(encoded).tolist()
+            predictions, eos = self.generate([TEMPLATE.format(r["views"][v]) for r, v, _ in chunk])
+            phi = self.features(encoded)
+            for i, (r, v, enc) in enumerate(chunk):
+                prediction = predictions[i]
+                first_token = enc["input_ids"][enc["answer_start"]]
+                logits = self.last_prompt_logits[i]
+                competitor_logits = logits.clone()
+                competitor_logits[first_token] = -torch.inf
+                competitor = int(competitor_logits.argmax())
+                result.append(
+                    {
+                        "case_id": r["case_id"],
+                        "relation_id": r["relation_id"],
+                        "subject_group": r["subject_group"],
+                        "view_id": v,
+                        "answer_nll": losses[i],
+                        "prediction": prediction,
+                        "answer_em": score_answer(prediction, r.get("aliases", [r["answer"]])),
+                        "eos_emitted": eos[i],
+                        "feature_norm": float(phi[i].norm()),
+                        "first_answer_nll": float(-logits.log_softmax(-1)[first_token]),
+                        "first_answer_margin": float(logits[first_token] - logits[competitor]),
+                        "current_competitor_token": competitor,
+                        "answer_tokens": enc["answer_tokens"],
+                        "prompt_tokens": enc["prompt_tokens"],
+                    }
+                )
+        return result
+
+    def gradient(self, encoded):
+        loss = self.ce([encoded]).mean()
+        grad = torch.autograd.grad(loss, self.mlp.down_proj.weight)[0]
+        return grad.detach(), float(loss.detach())
+
+    def verify_hooks_and_gradients(self, encoded):
+        self.configure_trainable("adapt")
+        captured = {}
+
+        def capture_input(module, args):
+            captured["x"] = args[0].detach()
+
+        def capture_down(module, args, output):
+            captured["phi"] = args[0].detach()
+            output.retain_grad()
+            captured["output"] = output
+
+        handles = [
+            self.mlp.register_forward_pre_hook(capture_input),
+            self.mlp.down_proj.register_forward_hook(capture_down),
+        ]
+        try:
+            self.model.zero_grad(set_to_none=True)
+            self.ce([encoded]).mean().backward()
+            with torch.no_grad():
+                expected_phi = self.mlp.up_proj(captured["x"]) * F.silu(
+                    self.mlp.gate_proj(captured["x"])
+                )
+                phi_error = float((expected_phi - captured["phi"]).abs().max())
+                delta = captured["output"].grad.double().flatten(0, 1)
+                phi = captured["phi"].double().flatten(0, 1)
+                reconstructed = delta.T @ phi
+                actual = self.mlp.down_proj.weight.grad.double()
+                grad_error = float((reconstructed - actual).norm() / actual.norm())
+                nonanswer_positions = encoded["answer_start"] - 1
+                prompt_grad_norm = float(delta[:nonanswer_positions].norm())
+            assert phi_error == 0.0
+            assert grad_error < 1e-5
+            return {
+                "phi_max_absolute_error": phi_error,
+                "gradient_relative_error": grad_error,
+                "earlier_prompt_delta_norm": prompt_grad_norm,
+                "all_positions_used": True,
+                "trainable_parameters": sum(
+                    p.numel() for p in self.model.parameters() if p.requires_grad
+                ),
+                "pass": True,
+            }
+        finally:
+            for handle in handles:
+                handle.remove()
+            self.model.zero_grad(set_to_none=True)
+
+
+def run_baseline(device, shard=0, shards=1):
+    engine = QwenExperiment(device)
+    candidates = read_json(DATA / "candidates.json")[shard::shards]
+    out = DATA / f"baseline-shard-{shard}.jsonl"
+    finished = {}
+    if out.exists():
+        for line in out.read_text().splitlines():
+            row = __import__("json").loads(line)
+            finished[row["case_id"]] = row
+    candidates = [r for r in candidates if r["case_id"] not in finished]
+    start_time = time.monotonic()
+    for start in range(0, len(candidates), 8):
+        chunk = candidates[start : start + 8]
+        rows = engine.evaluate(chunk)
+        with out.open("a") as f:
+            for record in chunk:
+                item = {
+                    "case_id": record["case_id"],
+                    "views": [r for r in rows if r["case_id"] == record["case_id"]],
+                }
+                f.write(__import__("json").dumps(item, ensure_ascii=False) + "\n")
+        if start % 80 == 0:
+            print(
+                f"baseline shard={shard} {start + len(chunk)}/{len(candidates)} "
+                f"elapsed={time.monotonic() - start_time:.1f}s",
+                flush=True,
+            )
+    write_json(
+        ARTIFACTS / f"baseline-shard-{shard}-complete.json",
+        {"time": now(), "rows": len(candidates) + len(finished), "shards": shards},
+    )

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_statistics.py

@@ -0,0 +1,168 @@
+"""Development-only predictor fitting and episode-cluster paired inference."""
+
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+from .hebbian_learning import (
+    ARTIFACTS,
+    DATA,
+    RESULTS,
+    config,
+    now,
+    q_auc,
+    read_json,
+    sha256,
+    write_json,
+)
+
+
+def fit_ridge(x, y, alpha):
+    mean, scale = x.mean(0), x.std(0)
+    scale = np.where(scale > 1e-12, scale, 1)
+    z = (x - mean) / scale
+    intercept = float(y.mean())
+    coef = np.linalg.solve(z.T @ z + alpha * np.eye(z.shape[1]), z.T @ (y - intercept))
+    return {
+        "mean": mean.tolist(),
+        "scale": scale.tolist(),
+        "coefficients": coef.tolist(),
+        "intercept": intercept,
+        "alpha": alpha,
+        "n_features": x.shape[1],
+    }
+
+
+def predict(model, x):
+    x = x[:, : model["n_features"]]
+    return ((x - model["mean"]) / model["scale"]) @ np.array(model["coefficients"]) + model[
+        "intercept"
+    ]
+
+
+def fact_trajectories(path):
+    evaluations = [read_json(p) for p in sorted(path.glob("evaluation-*.json"))]
+    nodes = [e["rows"][0]["step"] for e in evaluations]
+    by_node = [{(r["case_id"], r["view_id"]): r for r in e["rows"]} for e in evaluations]
+    cases = sorted({r["case_id"] for r in evaluations[0]["rows"]})
+    result = []
+    for case in cases:
+        rewrite = [np.mean([rows[case, v]["answer_em"] for v in [1, 2]]) for rows in by_node]
+        standard = [rows[case, 0]["answer_em"] for rows in by_node]
+        all_correct = [all(rows[case, v]["answer_em"] for v in range(3)) for rows in by_node]
+        sustained = next(
+            (i for i in range(len(nodes) - 1) if all_correct[i] and all_correct[i + 1]), None
+        )
+        first = by_node[0][case, 0]
+        result.append(
+            {
+                "case_id": case,
+                "q_auc": float(q_auc(rewrite, nodes)),
+                "q_gain_auc": float(q_auc(np.array(rewrite) - rewrite[0], nodes)),
+                "standard_auc": float(q_auc(standard, nodes)),
+                "nodes": nodes,
+                "rewrite_accuracy": rewrite,
+                "standard_accuracy": standard,
+                "sustained_step": nodes[sustained] if sustained is not None else None,
+                "sustained_exposures": by_node[sustained][case, 0]["exposures"]
+                if sustained is not None
+                else None,
+                "endpoint_first_success": sustained is None and all_correct[-1],
+                "right_censored": sustained is None,
+                "relation_id": first["relation_id"],
+            }
+        )
+    return result
+
+
+def freeze_b():
+    from .hebbian_train import frozen_training_sources, run_summary, select_config
+
+    episodes = read_json(DATA / "episodes.json")["B_dev"]
+    candidates = []
+    for lr in config()["adapt"]["learning_rates"]:
+        summaries = [run_summary(RESULTS / f"B/dev-lr{lr:g}-e{i}") for i in range(len(episodes))]
+        candidates.append(
+            {
+                "learning_rate": lr,
+                "q_auc": float(np.mean([s["q_auc"] for s in summaries])),
+                "keep_damage": float(np.mean([s["keep_damage"] for s in summaries])),
+                "episodes": summaries,
+            }
+        )
+    chosen = select_config(candidates, "q_auc", True)
+    lr = chosen["learning_rate"]
+    x, y, groups = [], [], []
+    for episode in range(len(episodes)):
+        path = RESULTS / f"B/dev-lr{lr:g}-e{episode}"
+        if not (path / "complete.json").exists():
+            raise RuntimeError("All B_dev runs must have completion receipts")
+        outcomes = {r["case_id"]: r["q_auc"] for r in fact_trajectories(path)}
+        for row in read_json(path / "prospective-features.json")["rows"]:
+            x.append(row["features"])
+            y.append(outcomes[row["case_id"]])
+            groups.append(episode)
+    x, y, groups = np.array(x), np.array(y), np.array(groups)
+    predictors = {}
+    for name, width in [("P0", 4), ("P1", 8), ("P2", 10)]:
+        scores = {}
+        for alpha in config()["statistics"]["ridge_grid"]:
+            errors = []
+            for group in np.unique(groups):
+                train = groups != group
+                model = fit_ridge(x[train, :width], y[train], alpha)
+                errors.append(np.mean(np.abs(predict(model, x[~train]) - y[~train])))
+            scores[alpha] = float(np.mean(errors))
+        best_alpha = min(scores, key=scores.get)
+        predictors[name] = {**fit_ridge(x[:, :width], y, best_alpha), "cv_mae": scores}
+    write_json(
+        ARTIFACTS / "B-lock.json",
+        {
+            "time": now(),
+            "status": "locked",
+            "learning_rate": lr,
+            "lr_candidates": candidates,
+            "predictors": predictors,
+            "source_hashes": frozen_training_sources(),
+            "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"),
+            "fitting_scope": "B_dev only; fold-specific training standardization in episode CV",
+        },
+    )
+
+
+def paired_inference(differences):
+    differences = np.asarray(differences, dtype=np.float64)
+    rng = np.random.default_rng(config()["statistics"]["seed"])
+    n = len(differences)
+    samples = differences[rng.integers(0, n, (10000, n))].mean(1)
+    observed = float(differences.mean())
+    signs = np.array(list(itertools.product([-1, 1], repeat=n)))
+    p = float(np.mean(np.abs((signs * differences).mean(1)) >= abs(observed) - 1e-14))
+    return {
+        "mean": observed,
+        "ci95": np.quantile(samples, [0.025, 0.975]).tolist(),
+        "exact_two_sided_sign_p": p,
+        "episode_differences": differences.tolist(),
+        "n_episodes": n,
+    }
+
+
+def rankdata(values):
+    values = np.asarray(values)
+    order = np.argsort(values, kind="stable")
+    ranked = np.empty(len(values), dtype=float)
+    i = 0
+    while i < len(values):
+        j = i + 1
+        while j < len(values) and values[order[j]] == values[order[i]]:
+            j += 1
+        ranked[order[i:j]] = (i + j - 1) / 2
+        i = j
+    return ranked
+
+
+def spearman(x, y):
+    a, b = rankdata(x), rankdata(y)
+    return float(np.corrcoef(a, b)[0, 1]) if a.std() and b.std() else None

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_train.py

@@ -0,0 +1,811 @@
+"""Paired formation/adaptation, prospective diagnostics and exact state resumption."""
+
+from __future__ import annotations
+
+import itertools
+import json
+import random
+import time
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from .hebbian_learning import (
+    ARTIFACTS,
+    CONFIG_PATH,
+    DATA,
+    RESULTS,
+    ROOT,
+    config,
+    effective_rank,
+    now,
+    q_auc,
+    read_json,
+    sha256,
+    write_json,
+)
+from .hebbian_model import (
+    QwenExperiment,
+    aggregate_hash,
+    set_determinism,
+    state_hashes,
+)
+
+
+def grouping(records, seed):
+    """Exact minimum-cost derangements; random seeded ties, real CE labels unchanged."""
+    n = len(records)
+    rng = np.random.default_rng(seed)
+    permutations = [
+        p for p in itertools.permutations(range(n)) if all(i != j for i, j in enumerate(p))
+    ]
+
+    def cost(p):
+        return sum(
+            10 * (records[i]["target_id"] == records[j]["target_id"])
+            + (records[i]["relation_id"] != records[j]["relation_id"])
+            for i, j in enumerate(p)
+        )
+
+    costs = np.array([cost(p) for p in permutations])
+    best = np.flatnonzero(costs == costs.min())
+    p1, p2 = [permutations[int(rng.choice(best))] for _ in range(2)]
+    groups = [(3 * i, 3 * p1[i] + 1, 3 * p2[i] + 2) for i in range(n)]
+    return groups
+
+
+def contrastive_loss(features, target_ids, groups, tau=0.1):
+    z = F.normalize(features, dim=-1, eps=1e-8)
+    similarities = z @ z.T / tau
+    positive = torch.zeros_like(similarities, dtype=torch.bool)
+    for group in groups:
+        for i in group:
+            for j in group:
+                if i != j:
+                    positive[i, j] = True
+    negative = torch.tensor([[a != b for b in target_ids] for a in target_ids], device=z.device)
+    negative &= ~positive
+    negative.fill_diagonal_(False)
+    assert torch.all(positive.sum(1) == 2)
+    assert torch.all(negative.sum(1) >= 1)
+    allowed = positive | negative
+    log_denominator = similarities.masked_fill(~allowed, -torch.inf).logsumexp(1)
+    loss = (log_denominator - (similarities * positive).sum(1) / positive.sum(1)).mean()
+    return loss, {"positive_pairs": int(positive.sum()), "negative_pairs": int(negative.sum())}
+
+
+def optimizer(parameters, lr):
+    cfg = config()["optimizer"]
+    return torch.optim.AdamW(
+        parameters,
+        lr=lr,
+        betas=tuple(cfg["betas"]),
+        eps=cfg["eps"],
+        weight_decay=cfg["weight_decay"],
+    )
+
+
+def replay_batch(pools, texts, step):
+    facts = pools["R_keep"]
+    return [facts[(step * 6 + i) % len(facts)]["encoded"][0] for i in range(6)] + [
+        texts["train"][(step * 2 + i) % len(texts["train"])] for i in range(2)
+    ]
+
+
+def frozen_training_sources():
+    paths = [CONFIG_PATH] + sorted((ROOT / "src/llm_memory_editability").glob("hebbian*.py"))
+    paths += [ROOT / "scripts/run_hebbian_learning.py"]
+    return {str(p.relative_to(ROOT)): sha256(p) for p in paths}
+
+
+def save_checkpoint(path, engine, opt, step, meta, ledger):
+    state = {
+        "parameters": {n: p.detach().cpu().clone() for n, p in engine.mlp.named_parameters()},
+        "optimizer": opt.state_dict(),
+        "step": step,
+        "data_cursor": step,
+        "torch_rng": torch.get_rng_state(),
+        "cuda_rng": torch.cuda.get_rng_state(engine.device)
+        if engine.device.type == "cuda"
+        else None,
+        "numpy_rng": np.random.get_state(),
+        "python_rng": random.getstate(),
+        "meta": meta,
+        "ledger": ledger,
+    }
+    tmp = path.with_name(path.name + ".tmp")
+    torch.save(state, tmp)
+    tmp.replace(path)
+
+
+def restore_checkpoint(path, engine, opt, meta):
+    state = torch.load(path, map_location="cpu", weights_only=False)
+    if state["meta"] != meta:
+        raise RuntimeError(f"Checkpoint contract differs: {path}")
+    with torch.no_grad():
+        for n, p in engine.mlp.named_parameters():
+            p.copy_(state["parameters"][n])
+    opt.load_state_dict(state["optimizer"])
+    torch.set_rng_state(state["torch_rng"])
+    if state["cuda_rng"] is not None:
+        torch.cuda.set_rng_state(state["cuda_rng"], engine.device)
+    np.random.set_state(state["numpy_rng"])
+    random.setstate(state["python_rng"])
+    return state["step"], state["ledger"]
+
+
+def load_parent(engine, parent_path=None):
+    engine.restore_base()
+    if parent_path is not None:
+        state = torch.load(parent_path, map_location="cpu", weights_only=False)
+        with torch.no_grad():
+            for n, p in engine.mlp.named_parameters():
+                p.copy_(state["parameters"][n])
+
+
+def gradient_cos(a, b):
+    a, b = a.double(), b.double()
+    return float((a * b).sum() / (a.norm() * b.norm()).clamp_min(1e-30))
+
+
+def diagnose_episode(engine, records, replay, lr, out):
+    """Saved before the learning trajectory; Adam candidate uses training data only."""
+    engine.configure_trainable("adapt")
+    p = engine.mlp.down_proj.weight
+    original = p.detach().clone()
+    encoded = [r["encoded"][v] for r in records for v in range(3)]
+    features = engine.features(encoded).double().cpu().numpy().reshape(len(records), 3, -1)
+    unit = features / np.maximum(np.linalg.norm(features, axis=-1, keepdims=True), 1e-8)
+    p0_gram = unit[:, 0] @ unit[:, 0].T
+    rank = effective_rank(features[:, 0])
+    opt = optimizer([p], lr)
+    opt.zero_grad(set_to_none=True)
+    (engine.ce([r["encoded"][0] for r in records[:8]]).mean() + engine.kl(replay).mean()).backward()
+    torch.nn.utils.clip_grad_norm_([p], 1.0)
+    opt.step()
+    delta = (p.detach() - original).clone()
+    with torch.no_grad():
+        p.copy_(original)
+    torch.save(
+        {"delta_B": delta.cpu(), "phi": torch.from_numpy(features)}, out / "initial-diagnostics.pt"
+    )
+    diagnostic = []
+    for i, record in enumerate(records):
+        grads, losses = zip(*(engine.gradient(enc) for enc in record["encoded"]), strict=True)
+        other = [
+            p0_gram[i, j] for j, r in enumerate(records) if r["target_id"] != record["target_id"]
+        ]
+        if not other:
+            raise ValueError("Each episode needs different-answer facts")
+        norms = np.linalg.norm(features[i], axis=1)
+        feature_values = [
+            losses[0],
+            record["encoded"][0]["answer_tokens"],
+            record["encoded"][0]["prompt_tokens"],
+            float(grads[0].double().norm()),
+            float(np.mean(unit[i, 1:] @ unit[i, 0])),
+            float(max(other)),
+            float(norms[1:].mean() / norms[0]),
+            rank,
+            float(np.mean([gradient_cos(grads[0], g) for g in grads[1:]])),
+            float(np.mean([float((g.double() * delta.double()).sum()) for g in grads[1:]])),
+        ]
+        diagnostic.append(
+            {
+                "case_id": record["case_id"],
+                "features": feature_values,
+                "p0_p1_cos": float(unit[i, 0] @ unit[i, 1]),
+                "p0_p2_cos": float(unit[i, 0] @ unit[i, 2]),
+                "feature_norms": norms.tolist(),
+                "initial_nll": list(losses),
+            }
+        )
+    engine.model.zero_grad(set_to_none=True)
+    assert torch.equal(p, original)
+    write_json(
+        out / "prospective-features.json",
+        {
+            "saved_at": now(),
+            "rows": diagnostic,
+            "information": {
+                "P0": "initial answer NLL, lengths, labeled training gradient norm",
+                "P1": "P0 plus prompt-only phi geometry",
+                "P2": "P1 plus labeled evaluation gradients and training-only Adam candidate",
+            },
+        },
+    )
+    return diagnostic
+
+
+def first_order_calibration(engine, record, out):
+    parameter = engine.mlp.down_proj.weight
+    initial = parameter.detach().clone()
+    source_grad, _ = engine.gradient(record["encoded"][0])
+    rows = []
+    for view in [1, 2]:
+        encoded = record["encoded"][view]
+        grad, nll0 = engine.gradient(encoded)
+        ids, attention, _ = engine.batch([encoded], prompt_only=True)
+        answer_token = encoded["input_ids"][encoded["answer_start"]]
+        logits = engine.model.lm_head(engine.hidden(ids, attention)[0, -1])
+        competitor_logits = logits.detach().clone()
+        competitor_logits[answer_token] = -torch.inf
+        competitor = int(competitor_logits.argmax())
+        margin = logits[answer_token] - logits[competitor]
+        margin_grad = torch.autograd.grad(margin, parameter)[0].detach()
+        margin0 = float(margin.detach())
+        for relative_step in [1e-5, 1e-4]:
+            proposal = (
+                -source_grad
+                * (relative_step * initial.double().norm() / source_grad.double().norm()).float()
+            )
+            with torch.no_grad():
+                parameter.copy_(initial + proposal)
+                actual_delta = parameter - initial
+                actual_nll = float(engine.ce([encoded])[0]) - nll0
+                new_logits = engine.model.lm_head(engine.hidden(ids, attention)[0, -1])
+                actual_margin = float(new_logits[answer_token] - new_logits[competitor]) - margin0
+                predicted_nll = float((grad.double() * actual_delta.double()).sum())
+                predicted_margin = float((margin_grad.double() * actual_delta.double()).sum())
+                parameter.copy_(initial)
+            entry = {
+                "case_id": record["case_id"],
+                "view_id": view,
+                "relative_step": relative_step,
+                "competitor_token": competitor,
+                "actual_nll_change": actual_nll,
+                "predicted_nll_change": predicted_nll,
+                "actual_margin_change": actual_margin,
+                "predicted_margin_change": predicted_margin,
+            }
+            for name, actual, predicted in [
+                ("nll", actual_nll, predicted_nll),
+                ("margin", actual_margin, predicted_margin),
+            ]:
+                entry[name + "_absolute_error"] = abs(actual - predicted)
+                entry[name + "_relative_error"] = abs(actual - predicted) / max(
+                    abs(predicted), 1e-6
+                )
+                entry[name + "_sign_match"] = bool(np.sign(actual) == np.sign(predicted))
+            rows.append(entry)
+    assert torch.equal(parameter, initial)
+    write_json(out / "first-order-calibration.json", rows)
+
+
+def geometry_rows(engine, records):
+    encoded = [r["encoded"][v] for r in records for v in range(3)]
+    features, originals = [], []
+    for start in range(0, len(encoded), 24):
+        features.append(engine.features(encoded[start : start + 24]).double().cpu())
+        originals.append(engine.original_features.double().cpu())
+    phi = torch.cat(features).reshape(len(records), 3, -1)
+    unit = F.normalize(phi, dim=-1)
+    original = torch.cat(originals).reshape(len(records), 3, -1)
+    original_cos = (unit * F.normalize(original, dim=-1)).sum(-1)
+    gram = unit[:, 0] @ unit[:, 0].T
+    rank = float(gram.trace().square() / gram.square().sum())
+    result = {}
+    for i, r in enumerate(records):
+        others = [
+            float(gram[i, j])
+            for j, other in enumerate(records)
+            if other["target_id"] != r["target_id"]
+        ]
+        result[r["case_id"]] = {
+            "same_fact_cos": float((unit[i, 1:] @ unit[i, 0]).mean()),
+            "other_fact_cos": max(others) if others else None,
+            "effective_rank": rank,
+            "cosine_to_original_phi": float(original_cos[i].mean()),
+            "dimension_variance": float(phi[:, 0].var(0, unbiased=False).mean()),
+        }
+    return result
+
+
+def evaluate_node(engine, records, keep, texts, step, metadata, out, exposures, full_keep):
+    rows = engine.evaluate(records)
+    geometry = geometry_rows(engine, records)
+    for row in rows:
+        row.update(
+            metadata,
+            step=step,
+            exposures=exposures.get(row["case_id"], 0),
+            **geometry[row["case_id"]],
+        )
+    payload = {"rows": rows}
+    if full_keep:
+        payload["keep"] = engine.evaluate(keep, views=(0,))
+        with torch.no_grad():
+            text_losses = []
+            for i in range(0, len(texts["test"]), 8):
+                text_losses.extend(engine.ce(texts["test"][i : i + 8]).tolist())
+        payload["text_nll"] = float(np.mean(text_losses))
+        payload["text_ppl"] = float(np.exp(payload["text_nll"]))
+    write_json(out / f"evaluation-{step:04d}.json", payload)
+    return payload
+
+
+def train_run(
+    engine,
+    phase,
+    records,
+    pools,
+    texts,
+    condition,
+    seed,
+    episode_id,
+    split,
+    lr,
+    steps,
+    run_id,
+    lambda_geo=0.0,
+    parent_path=None,
+    diagnostics=False,
+):
+    cfg = config()
+    out = RESULTS / run_id
+    out.mkdir(parents=True, exist_ok=True)
+    load_parent(engine, parent_path)
+    parent_hashes = state_hashes(engine.model)
+    parent_hash = aggregate_hash(parent_hashes)
+    parameters = engine.configure_trainable(phase)
+    trainable = [n for n, p in engine.model.named_parameters() if p.requires_grad]
+    meta = {
+        "phase": phase,
+        "split": split,
+        "condition": condition,
+        "seed": seed,
+        "episode_id": episode_id,
+        "parent_hash": parent_hash,
+        "parent_path": str(parent_path) if parent_path else None,
+        "source_hashes": frozen_training_sources(),
+        "config_sha256": sha256(CONFIG_PATH),
+        "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"),
+        "trainable_names": trainable,
+        "lr": lr,
+        "lambda_geo": lambda_geo,
+        "steps": steps,
+        "case_ids": [r["case_id"] for r in records],
+    }
+    if (out / "complete.json").exists():
+        receipt = read_json(out / "complete.json")
+        if receipt["meta"] != meta:
+            raise RuntimeError(f"Completed run contract changed: {run_id}")
+        return receipt
+    engine.make_reference()
+    set_determinism(seed)
+    random.seed(seed)
+    opt = optimizer(parameters, lr)
+    write_json(out / "contract.json", meta)
+    ledger = {
+        "answer_tokens": 0,
+        "answer_input_tokens": 0,
+        "replay_tokens": 0,
+        "replay_input_tokens": 0,
+        "geometry_input_tokens": 0,
+        "forward_sequences": 0,
+        "backward_sequences": 0,
+        "optimizer_steps": 0,
+        "wall_seconds": 0.0,
+    }
+    nodes = [n for n in cfg["form" if phase == "form" else "adapt"]["nodes"] if n <= steps]
+    if steps not in nodes:
+        nodes.append(steps)
+    keep = pools["V_keep" if split == "dev" else "U_keep"]
+    evaluate_records = pools["V_form"] if phase == "form" and split == "dev" else records
+    rng = np.random.default_rng(seed)
+    order = rng.permutation(len(records)).tolist() if phase == "form" else list(range(len(records)))
+    exposures = {r["case_id"]: 0 for r in records}
+    batch_table = []
+    for step in range(steps):
+        batch = [records[order[(step * 8 + i) % len(order)]] for i in range(8)]
+        groups = (
+            grouping(batch, seed * 100000 + step)
+            if condition == "C2"
+            else [tuple(range(3 * i, 3 * i + 3)) for i in range(8)]
+        )
+        batch_table.append({"case_ids": [r["case_id"] for r in batch], "groups": groups})
+    write_json(out / "batch-manifest.json", batch_table)
+    checkpoints = sorted(out.glob("checkpoint-*.pt"))
+    start = 0
+    if checkpoints:
+        start, ledger = restore_checkpoint(checkpoints[-1], engine, opt, meta)
+        for item in batch_table[:start]:
+            for case_id in item["case_ids"]:
+                exposures[case_id] += 1
+    elif diagnostics:
+        diagnostic = diagnose_episode(engine, records, replay_batch(pools, texts, 0), lr, out)
+        if split == "eval":
+            from .hebbian_statistics import predict
+
+            predictors = read_json(ARTIFACTS / "B-lock.json")["predictors"]
+            write_json(
+                out / "prospective-predictions.json",
+                {
+                    "saved_at": now(),
+                    "parent_hash": parent_hash,
+                    "predictions": [
+                        {
+                            "case_id": r["case_id"],
+                            "values": {
+                                name: float(predict(model, np.array(r["features"])[None])[0])
+                                for name, model in predictors.items()
+                            },
+                        }
+                        for r in diagnostic
+                    ],
+                },
+            )
+            first_order_calibration(engine, min(records, key=lambda r: r["case_id"]), out)
+    metadata = {
+        k: meta[k] for k in ["phase", "split", "condition", "seed", "episode_id", "parent_hash"]
+    }
+    if start == 0:
+        save_checkpoint(out / "checkpoint-0000.pt", engine, opt, 0, meta, ledger)
+    for step in range(start, steps + 1):
+        if step in nodes:
+            evaluate_node(
+                engine,
+                evaluate_records,
+                keep,
+                texts,
+                step,
+                metadata,
+                out,
+                exposures,
+                full_keep=(phase == "form" or step in [0, 16, 64, 128]),
+            )
+            if phase == "adapt" and condition.startswith("C") and step in [0, 16, 128]:
+                gradients = []
+                for r in sorted(records, key=lambda r: r["case_id"])[:4]:
+                    grads = [engine.gradient(e)[0] for e in r["encoded"]]
+                    gradients.append(
+                        {
+                            "case_id": r["case_id"],
+                            "p0_p1_gradient_cos": gradient_cos(grads[0], grads[1]),
+                            "p0_p2_gradient_cos": gradient_cos(grads[0], grads[2]),
+                        }
+                    )
+                write_json(out / f"gradients-{step:04d}.json", gradients)
+            if step in [0, 16, 64, 128, 256]:
+                save_checkpoint(out / f"checkpoint-{step:04d}.pt", engine, opt, step, meta, ledger)
+        if step == steps:
+            break
+        batch = [records[order[(step * 8 + i) % len(order)]] for i in range(8)]
+        encoded = [r["encoded"][v] for r in batch for v in (range(3) if phase == "form" else [0])]
+        replay = replay_batch(pools, texts, step)
+        torch.cuda.synchronize(engine.device)
+        begin = time.monotonic()
+        opt.zero_grad(set_to_none=True)
+        ce = engine.ce(encoded).mean()
+        ce.backward()
+        kl = engine.kl(replay).mean()
+        kl.backward()
+        geo_value, pair_counts = 0.0, None
+        if phase == "form":
+            features = engine.features(encoded, detach=False)
+            targets = [r["target_id"] for r in batch for _ in range(3)]
+            geo, pair_counts = contrastive_loss(features, targets, batch_table[step]["groups"])
+            if lambda_geo:
+                (lambda_geo * geo).backward()
+            geo_value = float(geo.detach())
+        norm = torch.nn.utils.clip_grad_norm_(parameters, cfg["optimizer"]["clip"])
+        opt.step()
+        torch.cuda.synchronize(engine.device)
+        ledger["wall_seconds"] += time.monotonic() - begin
+        ledger["answer_tokens"] += sum(sum(e["loss_mask"]) for e in encoded)
+        ledger["answer_input_tokens"] += sum(len(e["input_ids"]) for e in encoded)
+        ledger["replay_tokens"] += sum(sum(e["loss_mask"]) for e in replay)
+        ledger["replay_input_tokens"] += sum(len(e["input_ids"]) for e in replay)
+        if phase == "form":
+            ledger["geometry_input_tokens"] += sum(e["answer_start"] for e in encoded)
+        ledger["forward_sequences"] += (
+            len(encoded) + 2 * len(replay) + (len(encoded) if phase == "form" else 0)
+        )
+        ledger["backward_sequences"] += (
+            len(encoded) + len(replay) + (len(encoded) if lambda_geo else 0)
+        )
+        ledger["optimizer_steps"] += 1
+        for r in batch:
+            exposures[r["case_id"]] += 1
+        with (out / "training.jsonl").open("a") as f:
+            f.write(
+                json.dumps(
+                    {
+                        "step": step + 1,
+                        "ce": float(ce.detach()),
+                        "kl": float(kl.detach()),
+                        "geo": geo_value,
+                        "gradient_norm": float(norm),
+                        "pairs": pair_counts,
+                    }
+                )
+                + "\n"
+            )
+        write_json(
+            out / "status.json", {"step": step + 1, "steps": steps, "time": now(), "ledger": ledger}
+        )
+        if (step + 1) % 16 == 0:
+            print(
+                run_id,
+                step + 1,
+                "ce",
+                float(ce.detach()),
+                "wall",
+                ledger["wall_seconds"],
+                flush=True,
+            )
+    final_hashes = state_hashes(engine.model)
+    unchanged = all(
+        final_hashes[n] == digest for n, digest in parent_hashes.items() if n not in trainable
+    )
+    assert unchanged, "A parameter outside the intervention scope changed"
+    receipt = {
+        "meta": meta,
+        "completed_at": now(),
+        "ledger": ledger,
+        "unchanged_outside_scope": unchanged,
+        "final_hashes": final_hashes,
+        "final_model_hash": aggregate_hash(final_hashes),
+        "exposures": exposures,
+        "trainable_parameters": sum(p.numel() for p in parameters),
+        "estimated_dense_full_backprop_flops_upper_bound": (
+            sum(p.numel() for p in engine.model.parameters())
+            * (
+                6 * ledger["answer_input_tokens"]
+                + 8 * ledger["replay_input_tokens"]
+                + (6 if lambda_geo else 2) * ledger["geometry_input_tokens"]
+            )
+        ),
+    }
+    write_json(out / "complete.json", receipt)
+    return receipt
+
+
+def run_summary(path):
+    evaluations = [read_json(p) for p in sorted(path.glob("evaluation-*.json"))]
+    nodes = [e["rows"][0]["step"] for e in evaluations]
+    rewrite = [
+        np.mean([r["answer_em"] for r in e["rows"] if r["view_id"] in [1, 2]]) for e in evaluations
+    ]
+    keep0 = np.mean([r["answer_em"] for r in evaluations[0]["keep"]])
+    keep1 = np.mean([r["answer_em"] for r in evaluations[-1]["keep"]])
+    return {
+        "q_auc": float(q_auc(rewrite, nodes)),
+        "keep_damage": float(keep0 - keep1),
+        "answer_nll": float(np.mean([r["answer_nll"] for r in evaluations[-1]["rows"]])),
+    }
+
+
+def select_config(candidates, metric, maximize):
+    safe = [
+        r for r in candidates if r["keep_damage"] <= config()["statistics"]["keep_damage_reference"]
+    ]
+    if safe:
+        return sorted(safe, key=lambda r: (-1 if maximize else 1) * r[metric])[0]
+    return sorted(
+        candidates, key=lambda r: (r["keep_damage"], (-1 if maximize else 1) * r[metric])
+    )[0]
+
+
+def preflight(engine, pools, texts):
+    records = pools["B_dev"][:8]
+    audit = engine.verify_hooks_and_gradients(records[0]["encoded"][0])
+    before = state_hashes(engine.model)
+    parameters = engine.configure_trainable("adapt")
+    engine.make_reference()
+    opt = optimizer(parameters, 1e-5)
+    torch.cuda.reset_peak_memory_stats(engine.device)
+    torch.cuda.synchronize(engine.device)
+    start = time.monotonic()
+    for step in range(3):
+        opt.zero_grad(set_to_none=True)
+        engine.ce([r["encoded"][0] for r in records]).mean().backward()
+        engine.kl(replay_batch(pools, texts, step)).mean().backward()
+        torch.nn.utils.clip_grad_norm_(parameters, 1.0)
+        opt.step()
+    torch.cuda.synchronize(engine.device)
+    seconds = (time.monotonic() - start) / 3
+    engine.restore_base()
+    assert before == state_hashes(engine.model)
+    estimate = {
+        "time": now(),
+        "device": str(engine.device),
+        "adapt_step_seconds": seconds,
+        "peak_memory_bytes": torch.cuda.max_memory_allocated(engine.device),
+        "formal_adapt_steps": 11264,
+        "formal_adapt_gpu_hours": seconds * 11264 / 3600,
+        "formation_estimate_factor": 3,
+        "formal_formation_gpu_hours_estimate": seconds * 3 * 2304 / 3600,
+        "excludes": [
+            "generation and NLL evaluation",
+            "gradient diagnostics",
+            "development",
+            "disk IO",
+        ],
+        "microbatch_answer": 8,
+        "microbatch_replay": 8,
+        "reference_parent_restored": True,
+    }
+    write_json(ARTIFACTS / "estimate.json", estimate)
+    write_json(ARTIFACTS / "qwen-interface-audit.json", audit)
+    print(estimate, flush=True)
+
+
+def dispatch(args):
+    if not (ARTIFACTS / "data-lock.json").exists():
+        raise RuntimeError("data-lock is required before development or evaluation")
+    data_lock = read_json(ARTIFACTS / "data-lock.json")
+    for name, digest in data_lock["files"].items():
+        if sha256(DATA / name) != digest:
+            raise RuntimeError(f"Frozen data changed: {name}")
+    if not read_json(ARTIFACTS / "A/audit.json")["pass"]:
+        raise RuntimeError("Stage A must pass before model training")
+    pools = read_json(DATA / "pools.json")
+    texts = read_json(DATA / "text.json")
+    episodes = read_json(DATA / "episodes.json")
+    by_id = {r["case_id"]: r for rows in pools.values() for r in rows}
+    engine = QwenExperiment(args.device)
+    if args.command == "preflight":
+        return preflight(engine, pools, texts)
+    if args.command == "diagnose":
+        if args.split == "dev":
+            learning_rates = config()["adapt"]["learning_rates"]
+        else:
+            learning_rates = [read_json(ARTIFACTS / "B-lock.json")["learning_rate"]]
+        tasks = list(itertools.product(learning_rates, enumerate(episodes["B_" + args.split])))
+        for lr, (episode, ids) in tasks[args.shard :: args.shards]:
+            run_id = f"B/{args.split}-lr{lr:g}-e{episode}"
+            train_run(
+                engine,
+                "adapt",
+                [by_id[i] for i in ids],
+                pools,
+                texts,
+                "B",
+                0,
+                episode,
+                args.split,
+                lr,
+                128,
+                run_id,
+                diagnostics=True,
+            )
+        return
+    b_lr = read_json(ARTIFACTS / "B-lock.json")["learning_rate"]
+    if args.command == "form" and args.split == "dev":
+        candidates = []
+        for lr in config()["form"]["learning_rates"]:
+            run_id = f"C/dev-C0-lr{lr:g}"
+            train_run(
+                engine, "form", pools["F_form"], pools, texts, "C0", 10, -1, "dev", lr, 256, run_id
+            )
+            candidates.append(
+                {"learning_rate": lr, "run_id": run_id, **run_summary(RESULTS / run_id)}
+            )
+        chosen = select_config(candidates, "answer_nll", False)
+        lr = chosen["learning_rate"]
+        formation_candidates = [{"condition": "C0", "lambda_geo": 0.0, **chosen}]
+        for lam in config()["form"]["lambdas"]:
+            run_id = f"C/dev-C1-lambda{lam:g}"
+            train_run(
+                engine,
+                "form",
+                pools["F_form"],
+                pools,
+                texts,
+                "C1",
+                10,
+                -1,
+                "dev",
+                lr,
+                256,
+                run_id,
+                lambda_geo=lam,
+            )
+            formation_candidates.append(
+                {
+                    "condition": "C1",
+                    "lambda_geo": lam,
+                    "run_id": run_id,
+                    **run_summary(RESULTS / run_id),
+                }
+            )
+        for item in formation_candidates:
+            adapt_results = []
+            for episode, ids in enumerate(episodes["C_dev"]):
+                run_id = f"C/adapt-dev-{item['condition']}-lambda{item['lambda_geo']:g}-e{episode}"
+                train_run(
+                    engine,
+                    "adapt",
+                    [by_id[i] for i in ids],
+                    pools,
+                    texts,
+                    item["condition"],
+                    10,
+                    episode,
+                    "dev",
+                    b_lr,
+                    64,
+                    run_id,
+                    parent_path=RESULTS / item["run_id"] / "checkpoint-0256.pt",
+                )
+                adapt_results.append(run_summary(RESULTS / run_id))
+            item["future_q_auc"] = float(np.mean([r["q_auc"] for r in adapt_results]))
+            item["adapt_results"] = adapt_results
+        best = select_config(
+            [r for r in formation_candidates if r["condition"] == "C1"], "future_q_auc", True
+        )
+        lam = best["lambda_geo"]
+        train_run(
+            engine,
+            "form",
+            pools["F_form"],
+            pools,
+            texts,
+            "C2",
+            10,
+            -1,
+            "dev",
+            lr,
+            256,
+            "C/dev-C2-engineering",
+            lambda_geo=lam,
+        )
+        write_json(
+            ARTIFACTS / "C-lock.json",
+            {
+                "time": now(),
+                "learning_rate": lr,
+                "lambda_geo": lam,
+                "adapt_learning_rate": b_lr,
+                "lr_candidates": candidates,
+                "formation_candidates": formation_candidates,
+                "source_hashes": frozen_training_sources(),
+                "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"),
+                "seeds": [0, 1, 2],
+                "conditions": ["C0", "C1", "C2"],
+                "episodes": episodes["C_eval"],
+                "status": "locked",
+            },
+        )
+        return
+    c_lock = read_json(ARTIFACTS / "C-lock.json")
+    if args.command == "form":
+        tasks = list(itertools.product(["C0", "C1", "C2"], [0, 1, 2]))
+        for condition, seed in tasks[args.shard :: args.shards]:
+            train_run(
+                engine,
+                "form",
+                pools["F_form"],
+                pools,
+                texts,
+                condition,
+                seed,
+                -1,
+                "eval",
+                c_lock["learning_rate"],
+                256,
+                f"C/form-{condition}-s{seed}",
+                lambda_geo=0.0 if condition == "C0" else c_lock["lambda_geo"],
+            )
+    elif args.command == "adapt":
+        tasks = list(
+            itertools.product(["C0", "C1", "C2"], [0, 1, 2], enumerate(episodes["C_eval"]))
+        )
+        for condition, seed, (episode, ids) in tasks[args.shard :: args.shards]:
+            train_run(
+                engine,
+                "adapt",
+                [by_id[i] for i in ids],
+                pools,
+                texts,
+                condition,
+                seed,
+                episode,
+                "eval",
+                b_lr,
+                128,
+                f"C/adapt-{condition}-s{seed}-e{episode}",
+                parent_path=RESULTS / f"C/form-{condition}-s{seed}/checkpoint-0256.pt",
+            )

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_editing.py

@@ -0,0 +1,759 @@
+"""Local factual updates and downstream composition in existing aligned GPTs.
+
+Cases are selected from the graph alone, before loading any model predictions.
+Every edit has a same-budget old-fact sham, fresh optimizer, and frozen parent
+replay reference. No composition labels or intermediate-state targets enter
+optimization. Finite replay KL is a regularizer, not exact preservation.
+"""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import os
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from .grok_depth import utc, write_json
+from .latent_scaling import build_world, model_digest
+from .representation_alignment import new_model
+from .storage_composition import data_digest, file_hash, generate_rows, pack_sentences
+
+ROLES = ("first", "second")
+STRATA = ("familiar", "strict")
+DEFAULT_NODES = (0, 32, 128, 512)
+
+
+def _rows(values, width):
+    return np.asarray(values, dtype=np.int64).reshape(-1, width)
+
+
+def _unique(values, width):
+    return _rows(sorted(set(map(tuple, _rows(values, width)))), width)
+
+
+def _hash_json(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+
+def _batch_hash(batch):
+    digest = hashlib.sha256()
+    for tensor in batch:
+        array = tensor.detach().cpu().numpy()
+        digest.update(str(array.dtype).encode())
+        digest.update(str(array.shape).encode())
+        digest.update(array.tobytes())
+    return digest.hexdigest()
+
+
+def learned_atoms(world):
+    """Only atomics actually supervised in the representation parent."""
+    return _unique(np.concatenate([world["common_atomic"], world["anchor_atomic"]]), 3)
+
+
+def composition_pools(world):
+    """All legal untrained queries, plus the original holdout and training sets."""
+    trained = set(map(tuple, world["train_composite"]))
+    full = _unique(np.concatenate([world["available_composite"], world["familiar_test"]]), 5)
+    familiar = _rows([r for r in full if tuple(r) not in trained], 5)
+    return {
+        "familiar": familiar,
+        "strict": world["strict_test"].copy(),
+        "registered_familiar": world["familiar_test"].copy(),
+        "train": world["train_composite"].copy(),
+    }
+
+
+def affected(rows, fact, role):
+    """Whether a query uses this factual address, independently of its answer."""
+    columns = (0, 1) if role == "first" else (2, 3)
+    return (rows[:, columns[0]] == fact[0]) & (rows[:, columns[1]] == fact[1])
+
+
+def rewrite(rows, old_fact, new_fact, role, lookup):
+    result = rows.copy()
+    mask = affected(rows, old_fact, role)
+    if role == "first":
+        result[mask, 2] = new_fact[2]
+        for index in np.flatnonzero(mask):
+            result[index, 4] = lookup[int(new_fact[2]), int(rows[index, 3])]
+    else:
+        result[mask, 4] = new_fact[2]
+    return result
+
+
+def graph_cases(parent_spec, *, seed=780011, per_cell=2, replay_n=32):
+    """Return JSON-compatible selected cases and graph-only eligibility counts.
+
+    Each distinct atomic address receives at most one counterfactual per role.
+    First-hop replacements stay in the original familiar/strict bridge group and
+        change at least one affected untrained composition answer. Strict cases never
+    borrow a bridge with composition experience from the familiar group.
+    """
+    if per_cell < 1 or replay_n < 1:
+        raise ValueError("Positive case and replay counts are required")
+    world = build_world(parent_spec)
+    atoms = learned_atoms(world)
+    lookup = {(int(h), int(r)): int(t) for h, r, t in atoms}
+    pools = composition_pools(world)
+    rng = np.random.default_rng(seed + int(parent_spec["world"]))
+    candidates, qualification = [], {}
+    for role in ROLES:
+        for stratum in STRATA:
+            rows = pools[stratum]
+            addresses = _unique(rows[:, [0, 1, 2] if role == "first" else [2, 3, 4]], 3)
+            bridges = np.unique(rows[:, 2])
+            # Include all trained bridges in that group, even if the holdout
+            # happens not to visit them (strict rows enumerate all chains).
+            group = world["background_atomic"] if stratum == "familiar" else world["common_atomic"]
+            group_bridges = np.unique(group[group[:, 1] >= 17, 0])
+            if stratum == "strict":
+                familiar_bridges = world["background_atomic"]
+                familiar_bridges = familiar_bridges[familiar_bridges[:, 1] >= 17, 0]
+                group_bridges = np.setdiff1d(group_bridges, familiar_bridges)
+            bridges = np.union1d(bridges, group_bridges)
+            tails = np.unique(atoms[atoms[:, 1] >= 17, 2])
+            eligible, replacement_count = [], 0
+            for old in addresses:
+                impacted = rows[affected(rows, old, role)]
+                choices = []
+                for value in bridges if role == "first" else tails:
+                    if value == old[2]:
+                        continue
+                    new = [int(old[0]), int(old[1]), int(value)]
+                    updated = rewrite(impacted, old, new, role, lookup)
+                    if np.any(updated[:, -1] != impacted[:, -1]):
+                        choices.append(new)
+                replacement_count += len(choices)
+                if choices:
+                    eligible.append((old.tolist(), choices))
+            key = f"{role}_{stratum}"
+            qualification[key] = {
+                "candidate_addresses": len(addresses),
+                "eligible_addresses": len(eligible),
+                "eligible_replacements": replacement_count,
+                "untrained_queries": len(rows),
+            }
+            if len(eligible) < per_cell:
+                raise ValueError(f"Insufficient graph-qualified {key} cases: {qualification[key]}")
+            order = rng.permutation(len(eligible))[:per_cell]
+            for serial, index in enumerate(order):
+                old, choices = eligible[index]
+                new = choices[int(rng.integers(len(choices)))]
+                candidates.append(
+                    {
+                        "case_id": f"{key}-{serial:02d}",
+                        "role": role,
+                        "stratum": stratum,
+                        "old_fact": old,
+                        "new_fact": new,
+                    }
+                )
+    for case in candidates:
+        tasks, originals = case_tasks(world, case, replay_indices=None)
+        necessary = set(map(tuple, tasks["necessary_atomic"]))
+        allowed = [
+            i
+            for i, row in enumerate(atoms)
+            if tuple(row) != tuple(case["old_fact"]) and tuple(row) not in necessary
+        ]
+        if len(allowed) < replay_n:
+            raise ValueError("Insufficient independent replay atomics")
+        case["replay_indices"] = sorted(map(int, rng.choice(allowed, replay_n, replace=False)))
+        case["affected_untrained_n"] = {name: len(rows) for name, rows in originals.items()}
+    return candidates, qualification
+
+
+def case_tasks(world, case, replay_indices=None):
+    """Construct E/R/U/D with address-based exclusions and recomputed truth."""
+    atoms = learned_atoms(world)
+    lookup = {(int(h), int(r)): int(t) for h, r, t in atoms}
+    old, new, role = case["old_fact"], case["new_fact"], case["role"]
+    if lookup[tuple(old[:2])] != old[2] or old[:2] != new[:2] or old[2] == new[2]:
+        raise ValueError("An edit must replace one existing factual value")
+    tasks = {"E_old": _rows([old], 3), "E_new": _rows([new], 3)}
+    originals, necessary = {}, []
+    for stratum, rows in composition_pools(world).items():
+        mask = affected(rows, old, role)
+        tasks[f"U_{stratum}"] = rows[~mask].copy()
+        old_rows = rows[mask].copy()
+        new_rows = rewrite(old_rows, old, new, role, lookup)
+        changed = old_rows[:, -1] != new_rows[:, -1]
+        if stratum == "train":
+            # Training-query transfer is reported separately from held-out D.
+            name = f"T_{role}_train"
+            originals[name] = old_rows
+            tasks[name] = new_rows
+        else:
+            name = f"D_{role}_{stratum}"
+            originals[name] = old_rows[changed]
+            tasks[name] = new_rows[changed]
+            same = f"S_same_answer_{role}_{stratum}"
+            originals[same] = old_rows[~changed]
+            tasks[same] = new_rows[~changed]
+        if stratum in STRATA:
+            for h, r1, b, r2, t in tasks[name]:
+                prerequisite = (b, r2, t) if role == "first" else (h, r1, b)
+                necessary.append(prerequisite)
+    tasks["necessary_atomic"] = _unique(necessary, 3)
+    replay = case.get("replay_indices", []) if replay_indices is None else replay_indices
+    if len(set(replay)) != len(replay):
+        raise ValueError("Replay indices must be unique")
+    target = np.flatnonzero(np.all(atoms == np.asarray(old), axis=1))
+    if len(target) != 1 or int(target[0]) in replay:
+        raise ValueError("Replay cannot contain the edited address")
+    tasks["R_atomic"] = atoms[replay].copy()
+    tasks["U_atomic"] = np.delete(atoms, [int(target[0]), *replay], axis=0)
+    return tasks, originals
+
+
+def answer_batch(rows, device):
+    """Only answer, punctuation and EOS labels; no prefix or bridge labels."""
+    tokens, labels = pack_sentences(_rows(rows, 3))
+    positions = np.tile([4, 5, 6], (len(rows), 1))
+    targets = labels[np.arange(len(rows))[:, None], positions]
+    expected = np.column_stack([np.asarray(rows)[:, 2], np.full(len(rows), 5), np.ones(len(rows))])
+    np.testing.assert_array_equal(targets, expected)
+    return tuple(torch.as_tensor(x, device=device) for x in (tokens, positions, targets))
+
+
+def edit_objective(model, target_batch, replay_batch, parent_log, replay_weight=1.0):
+    target = model(target_batch[0], positions=target_batch[1])
+    ce = F.cross_entropy(target.flatten(0, 1), target_batch[2].flatten())
+    replay = model(replay_batch[0], positions=replay_batch[1]).log_softmax(-1)
+    if parent_log.requires_grad:
+        raise ValueError("Replay reference must be detached")
+    kl = F.kl_div(replay, parent_log, log_target=True, reduction="none").sum(-1).mean()
+    return ce + replay_weight * kl, ce, kl
+
+
+def _generate(model, rows, device, batch_size):
+    if len(rows):
+        return generate_rows(model, rows, device, batch_size=batch_size)
+    return (
+        {"n": 0, "accuracy": None, "answer_accuracy": None, "answer_nll": None},
+        {
+            "generated": np.empty((0, 3), dtype=np.int64),
+            "correct": np.empty(0, dtype=bool),
+            "answer_nll": np.empty(0),
+        },
+    )
+
+
+def evaluate_case(model, tasks, originals, parent_correct, role, device, batch_size=512):
+    """Full-pool scores and separately labelled prerequisite/parent subsets."""
+    metrics, raw = {}, {}
+    for name, rows in tasks.items():
+        values, predictions = _generate(model, rows, device, batch_size)
+        raw.update({f"{name}__{k}": v for k, v in predictions.items()})
+        if name in originals:
+            old = originals[name]
+            generated = predictions["generated"]
+            changed = old[:, -1] != rows[:, -1]
+            old_correct = (generated[:, 0] == old[:, -1]) & np.all(
+                generated[:, 1:] == [5, 1], axis=1
+            )
+            prerequisite = rows[:, [2, 3, 4] if role == "first" else [0, 1, 2]]
+            _m, needed = _generate(model, prerequisite, device, batch_size)
+            edited_ok = metrics["E_new"]["accuracy"] == 1.0
+            covered = needed["correct"] & edited_ok
+            baseline = parent_correct[name]
+            valid_parent = baseline & changed
+            correct = predictions["correct"]
+            values.update(
+                {
+                    "changed_answer_n": int(changed.sum()),
+                    "old_answer_accuracy": float(old_correct.mean()) if len(rows) else None,
+                    "parent_correct_n": int(baseline.sum()),
+                    "parent_correct_coverage": float(baseline.mean()) if len(rows) else None,
+                    "new_following_parent_correct": float(correct[valid_parent].mean())
+                    if valid_parent.any()
+                    else None,
+                    "old_retained_parent_correct": float(old_correct[valid_parent].mean())
+                    if valid_parent.any()
+                    else None,
+                    "direct_edit_success": edited_ok,
+                    "necessary_atomic_correct_n": int(needed["correct"].sum()),
+                    "operation_correct_n": int(covered.sum()),
+                    "operation_correct_coverage": float(covered.mean()) if len(rows) else None,
+                    "new_following_operation_correct": float(correct[covered].mean())
+                    if covered.any()
+                    else None,
+                }
+            )
+            raw[f"{name}__parent_correct"] = baseline
+            raw[f"{name}__operation_correct"] = covered
+            raw[f"{name}__old_correct"] = old_correct
+            raw[f"{name}__necessary_generated"] = needed["generated"]
+            raw[f"{name}__new_rows"] = rows
+            raw[f"{name}__old_rows"] = old
+        metrics[name] = values
+    return metrics, raw
+
+
+def editable_parameters(model, scope="mlp", block_index=0):
+    prefix = f"blocks.{block_index}.mlp."
+    selected = [
+        name
+        for name, _ in model.named_parameters()
+        if name.startswith(prefix) and (scope == "mlp" or name == prefix + "down.weight")
+    ]
+    if scope not in {"mlp", "down"} or not selected:
+        raise ValueError("Unknown or empty local parameter scope")
+    for name, parameter in model.named_parameters():
+        parameter.requires_grad_(name in selected)
+        parameter.grad = None
+    return selected
+
+
+def _configure(device):
+    device = torch.device(device)
+    torch.set_num_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    if device.type == "cuda":
+        torch.cuda.set_device(device)
+    return device
+
+
+def _load_parent(parent_dir, device):
+    path = Path(parent_dir) / "model.pt"
+    payload = torch.load(path, map_location="cpu", weights_only=False)
+    model = new_model(payload["spec"], device).eval()
+    model.load_state_dict(payload["model"])
+    world = build_world(payload["spec"])
+    if (Path(parent_dir) / "world.npz").exists():
+        with np.load(Path(parent_dir) / "world.npz") as saved:
+            for name, rows in world.items():
+                np.testing.assert_array_equal(rows, saved[name])
+    return model, world, payload["spec"]
+
+
+def _parent_masks(parent, originals, device, batch_size):
+    return {
+        name: _generate(parent, rows, device, batch_size)[1]["correct"]
+        for name, rows in originals.items()
+    }
+
+
+def run(spec, out, device="cuda:0"):
+    """Execute one parent, a graph-selected case set and optional development lr grid.
+
+    The caller owns source freezing, resource allocation and W&B startup. Each
+    branch has run/learning/complete artifacts. Root ``step`` is a strictly
+    increasing evaluation index, including every branch's unchanged node zero;
+    ``optimizer_updates`` separately records cumulative optimization work.
+    Target labels and replay KL positions have separate exposure counters.
+    ``status.json`` retains completed-branch progress, explicitly labelled in
+    the manifest; it does not define the tracking series' step axis.
+    """
+    device = _configure(device)
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "run.json").exists() or (out / "complete.json").exists():
+        raise FileExistsError(f"Do not overwrite an existing attempt: {out}")
+    nodes = spec.get("nodes", list(DEFAULT_NODES))
+    if not nodes or nodes[0] != 0 or nodes != sorted(set(nodes)) or nodes[-1] <= 0:
+        raise ValueError("Nodes must increase from zero to a positive fixed endpoint")
+    rates = spec.get("learning_rates", [spec.get("lr", 1e-4)])
+    if not rates or any(lr <= 0 for lr in rates) or len(set(rates)) != len(rates):
+        raise ValueError("Learning rates must be positive and unique")
+    if spec.get("phase") not in {"development", "engineering"} and len(rates) > 1:
+        raise ValueError("Learning-rate grids are development-only")
+    arms = spec.get("arms", ["edit", "sham"])
+    if sorted(arms) != ["edit", "sham"]:
+        raise ValueError("Every case requires paired edit and sham branches")
+    parent, world, parent_spec = _load_parent(spec["parent_dir"], device)
+    parent_hash = model_digest(parent)
+    cases, qualification = graph_cases(
+        parent_spec,
+        seed=spec.get("candidate_seed", 780011),
+        per_cell=spec.get("per_cell", 2),
+        replay_n=spec.get("replay_n", 32),
+    )
+    if "case_ids" in spec:
+        requested = set(spec["case_ids"])
+        if not requested or not requested <= {c["case_id"] for c in cases}:
+            raise ValueError("Unknown/empty fixed graph-selected case subset")
+        cases = [c for c in cases if c["case_id"] in requested]
+    manifest = {
+        "spec": spec,
+        "parent_spec": parent_spec,
+        "cases": cases,
+        "qualification": qualification,
+        "case_sha256": _hash_json(cases),
+        "parent_file_sha256": file_hash(Path(spec["parent_dir"]) / "model.pt"),
+        "parent_model_sha256": parent_hash,
+        "world_sha256": data_digest(world),
+        "created_utc": utc(),
+        "dtype": "float32",
+        "allow_tf32": True,
+        "pid": os.getpid(),
+        "gpu": device.index if device.type == "cuda" else None,
+        "branches": len(cases) * len(rates) * len(arms),
+        "planned_updates": len(cases) * len(rates) * len(arms) * nodes[-1],
+        "planned_evaluations": len(cases) * len(rates) * len(arms) * len(nodes),
+        "learning_step_unit": "evaluation_index",
+        "status_step_unit": "completed_branches",
+        "scope_warning": "The selected MLP is shared across all repeated executions",
+    }
+    write_json(out / "run.json", manifest)
+    write_json(out / "cases.json", cases)
+    np.savez_compressed(out / "world.npz", **world)
+    root_learning, branch_summaries, completed_steps = [], [], 0
+    started = time.perf_counter()
+    training_seconds = 0.0
+    batch_size = spec.get("eval_batch_size", 512)
+    for case in cases:
+        tasks, originals = case_tasks(world, case)
+        parent_correct = _parent_masks(parent, originals, device, batch_size)
+        parent_metrics, parent_predictions = evaluate_case(
+            parent,
+            tasks,
+            originals,
+            parent_correct,
+            case["role"],
+            device,
+            batch_size,
+        )
+        case_out = out / case["case_id"]
+        case_out.mkdir()
+        np.savez_compressed(case_out / "parent-predictions.npz", **parent_predictions)
+        write_json(case_out / "parent-metrics.json", parent_metrics)
+        np.savez_compressed(case_out / "tasks.npz", **tasks)
+        replay_batch = answer_batch(tasks["R_atomic"], device)
+        with torch.no_grad():
+            parent_log = parent(replay_batch[0], positions=replay_batch[1]).log_softmax(-1).detach()
+        for lr in rates:
+            for arm in arms:
+                branch_name = f"lr{lr:.8g}-{arm}"
+                branch_out = case_out / branch_name
+                branch_out.mkdir()
+                model = copy.deepcopy(parent).eval()
+                selected = editable_parameters(
+                    model,
+                    spec.get("parameter_scope", "mlp"),
+                    spec.get("block_index", 0),
+                )
+                parameters = dict(model.named_parameters())
+                optimizer = torch.optim.Adam([parameters[n] for n in selected], lr=lr)
+                target = tasks["E_new" if arm == "edit" else "E_old"]
+                target_batch = answer_batch(target, device)
+                write_json(
+                    branch_out / "run.json",
+                    {
+                        "case_id": case["case_id"],
+                        "arm": arm,
+                        "lr": lr,
+                        "parent_model_sha256": parent_hash,
+                        "editable_parameters": selected,
+                        "optimizer": "Adam, fresh state, zero weight decay",
+                        "sampling": "same fixed full replay batch on every update; no dropout",
+                        "old_fact_sha256": _hash_json(case["old_fact"]),
+                        "new_fact_sha256": _hash_json(case["new_fact"]),
+                        "target_batch_sha256": _batch_hash(target_batch),
+                        "replay_batch_sha256": _batch_hash(replay_batch),
+                        "parent_reference_sha256": _batch_hash((parent_log,)),
+                        "nodes": nodes,
+                    },
+                )
+                np.savez_compressed(
+                    branch_out / "replay-reference.npz", log_probabilities=parent_log.cpu().numpy()
+                )
+                step, losses, history = 0, [], []
+                for node in nodes:
+                    if device.type == "cuda":
+                        torch.cuda.synchronize(device)
+                    began = time.perf_counter()
+                    while step < node:
+                        optimizer.zero_grad(set_to_none=True)
+                        loss, ce, kl = edit_objective(
+                            model,
+                            target_batch,
+                            replay_batch,
+                            parent_log,
+                            spec.get("replay_weight", 1.0),
+                        )
+                        if not torch.isfinite(loss):
+                            raise FloatingPointError(f"Nonfinite edit loss at {step}")
+                        loss.backward()
+                        gradient_norm = torch.nn.utils.clip_grad_norm_(
+                            [parameters[n] for n in selected],
+                            spec.get("clip_norm", 1.0),
+                        )
+                        optimizer.step()
+                        step += 1
+                        losses.append(
+                            {
+                                "step": step,
+                                "loss": float(loss.detach()),
+                                "target_ce": float(ce.detach()),
+                                "replay_kl": float(kl.detach()),
+                                "gradient_norm": float(gradient_norm),
+                            }
+                        )
+                    if device.type == "cuda":
+                        torch.cuda.synchronize(device)
+                    training_seconds += time.perf_counter() - began
+                    metrics, predictions = evaluate_case(
+                        model,
+                        tasks,
+                        originals,
+                        parent_correct,
+                        case["role"],
+                        device,
+                        batch_size,
+                    )
+                    current_hash = model_digest(model)
+                    record = {
+                        "step": step,
+                        "metrics": metrics,
+                        "model_sha256": current_hash,
+                        "target_success": metrics["E_new" if arm == "edit" else "E_old"]["accuracy"]
+                        == 1,
+                        "U_atomic_at_least_95": metrics["U_atomic"]["accuracy"] >= 0.95,
+                        "loss": losses[-1] if losses else None,
+                    }
+                    history.append(record)
+                    write_json(branch_out / "learning.json", history)
+                    write_json(branch_out / "losses.json", losses)
+                    np.savez_compressed(branch_out / f"predictions-{step:06d}.npz", **predictions)
+                    torch.save(
+                        {
+                            "edited_tensors": {
+                                n: parameters[n].detach().cpu().clone() for n in selected
+                            },
+                            "model_sha256": current_hash,
+                            "step": step,
+                        },
+                        branch_out / f"tensors-{step:06d}.pt",
+                    )
+                    root_learning.append(
+                        {
+                            "step": len(root_learning),
+                            "branch_step": step,
+                            "completed_branches": len(branch_summaries) + int(step == nodes[-1]),
+                            "optimizer_updates": completed_steps + step,
+                            "case_id": case["case_id"],
+                            "arm": arm,
+                            "lr": lr,
+                            "metrics": metrics,
+                            "training_seconds": training_seconds,
+                            "wall_seconds": time.perf_counter() - started,
+                            "examples": (completed_steps + step) * (1 + len(tasks["R_atomic"])),
+                            "target_supervised_tokens": (completed_steps + step) * 3,
+                            "replay_distillation_positions": (completed_steps + step)
+                            * len(tasks["R_atomic"])
+                            * 3,
+                        }
+                    )
+                    write_json(out / "learning.json", root_learning)
+                    write_json(
+                        out / "status.json",
+                        {
+                            "state": "running",
+                            "step": len(branch_summaries),
+                            "optimizer_updates": completed_steps + step,
+                            "budget": manifest["branches"],
+                            "case_id": case["case_id"],
+                            "arm": arm,
+                            "lr": lr,
+                        },
+                    )
+                changed = [
+                    n
+                    for n, t in model.state_dict().items()
+                    if not torch.equal(t, parent.state_dict()[n])
+                ]
+                if set(changed) - set(selected) or model_digest(parent) != parent_hash:
+                    raise AssertionError("A frozen parameter or the parent changed")
+                complete = {
+                    "case_id": case["case_id"],
+                    "role": case["role"],
+                    "stratum": case["stratum"],
+                    "lr": lr,
+                    "arm": arm,
+                    "path": str(branch_out.relative_to(out)),
+                    "metrics": metrics,
+                    "steps": step,
+                    "changed_tensors": changed,
+                    "parent_model_sha256": parent_hash,
+                    "final_model_sha256": current_hash,
+                    "delta_l2": float(
+                        torch.sqrt(
+                            sum(
+                                (parameters[n] - dict(parent.named_parameters())[n]).square().sum()
+                                for n in selected
+                            )
+                        ).detach()
+                    ),
+                    "tensor_file_sha256": file_hash(branch_out / f"tensors-{step:06d}.pt"),
+                }
+                write_json(branch_out / "complete.json", complete)
+                branch_summaries.append(complete)
+                completed_steps += step
+    result = {
+        "status": "complete",
+        "branches": branch_summaries,
+        "updates": completed_steps,
+        "training_seconds": training_seconds,
+        "wall_seconds": time.perf_counter() - started,
+        "finished_utc": utc(),
+        "case_sha256": manifest["case_sha256"],
+    }
+    write_json(out / "complete.json", result)
+    write_json(
+        out / "status.json",
+        {
+            "state": "complete",
+            "step": len(branch_summaries),
+            "optimizer_updates": completed_steps,
+            "budget": manifest["branches"],
+        },
+    )
+    return result
+
+
+def audit(out, device="cuda:0"):
+    """Reload every saved node from parent plus exact tensors and re-score it."""
+    device, out = _configure(device), Path(out)
+    manifest = json.loads((out / "run.json").read_text())
+    spec = manifest["spec"]
+    if file_hash(Path(spec["parent_dir"]) / "model.pt") != manifest["parent_file_sha256"]:
+        raise AssertionError("Parent checkpoint hash changed")
+    parent, world, parent_spec = _load_parent(spec["parent_dir"], device)
+    if model_digest(parent) != manifest["parent_model_sha256"]:
+        raise AssertionError("Parent model digest changed")
+    cases, qualification = graph_cases(
+        parent_spec,
+        seed=spec.get("candidate_seed", 780011),
+        per_cell=spec.get("per_cell", 2),
+        replay_n=spec.get("replay_n", 32),
+    )
+    if "case_ids" in spec:
+        cases = [c for c in cases if c["case_id"] in spec["case_ids"]]
+    if cases != manifest["cases"] or _hash_json(cases) != manifest["case_sha256"]:
+        raise AssertionError("Graph-selected cases changed")
+    if qualification != manifest["qualification"] or data_digest(world) != manifest["world_sha256"]:
+        raise AssertionError("World qualification changed")
+    summary = json.loads((out / "complete.json").read_text())
+    rates = spec.get("learning_rates", [spec.get("lr", 1e-4)])
+    expected_branches = {
+        (c["case_id"], lr, arm) for c in cases for lr in rates for arm in ("edit", "sham")
+    }
+    actual_branches = [(b["case_id"], b["lr"], b["arm"]) for b in summary["branches"]]
+    if len(actual_branches) != len(expected_branches) or set(actual_branches) != expected_branches:
+        raise AssertionError("The fixed paired branch matrix is incomplete")
+    root_learning = json.loads((out / "learning.json").read_text())
+    nodes = spec.get("nodes", list(DEFAULT_NODES))
+    expected_evaluations = len(actual_branches) * len(nodes)
+    if len(root_learning) != expected_evaluations or [row["step"] for row in root_learning] != list(
+        range(expected_evaluations)
+    ):
+        raise AssertionError("Root learning evaluation indices are incomplete or repeated")
+    for index, row in enumerate(root_learning):
+        branch_index, node_index = divmod(index, len(nodes))
+        updates = branch_index * nodes[-1] + nodes[node_index]
+        if (
+            (row["case_id"], row["lr"], row["arm"]) != actual_branches[branch_index]
+            or row["branch_step"] != nodes[node_index]
+            or row["optimizer_updates"] != updates
+            or row["target_supervised_tokens"] != updates * 3
+            or row["replay_distillation_positions"] != updates * spec.get("replay_n", 32) * 3
+            or "supervised_tokens" in row
+        ):
+            raise AssertionError("Root learning optimizer or exposure accounting changed")
+    batch_size = spec.get("eval_batch_size", 512)
+    checked_nodes, checked_predictions, max_error = 0, 0, 0.0
+    for case in cases:
+        tasks, originals = case_tasks(world, case)
+        parent_correct = _parent_masks(parent, originals, device, batch_size)
+        for branch in summary["branches"]:
+            if branch["case_id"] != case["case_id"]:
+                continue
+            directory = out / branch["path"]
+            branch_spec = json.loads((directory / "run.json").read_text())
+            target = tasks["E_new" if branch["arm"] == "edit" else "E_old"]
+            target_batch = answer_batch(target, device)
+            replay_batch = answer_batch(tasks["R_atomic"], device)
+            with torch.no_grad():
+                reference = parent(replay_batch[0], positions=replay_batch[1]).log_softmax(-1)
+            expected_hashes = {
+                "old_fact_sha256": _hash_json(case["old_fact"]),
+                "new_fact_sha256": _hash_json(case["new_fact"]),
+                "target_batch_sha256": _batch_hash(target_batch),
+                "replay_batch_sha256": _batch_hash(replay_batch),
+                "parent_reference_sha256": _batch_hash((reference,)),
+            }
+            if any(branch_spec[key] != value for key, value in expected_hashes.items()):
+                raise AssertionError("Target or paired replay provenance changed")
+            history = json.loads((directory / "learning.json").read_text())
+            if [record["step"] for record in history] != spec.get("nodes", list(DEFAULT_NODES)):
+                raise AssertionError("Saved edit node matrix is incomplete")
+            if (
+                file_hash(directory / f"tensors-{history[-1]['step']:06d}.pt")
+                != branch["tensor_file_sha256"]
+            ):
+                raise AssertionError("Final exact tensor file hash changed")
+            for record in history:
+                state = torch.load(
+                    directory / f"tensors-{record['step']:06d}.pt",
+                    map_location="cpu",
+                    weights_only=True,
+                )
+                model = copy.deepcopy(parent).eval()
+                selected = editable_parameters(
+                    model, spec.get("parameter_scope", "mlp"), spec.get("block_index", 0)
+                )
+                if set(state["edited_tensors"]) != set(selected):
+                    raise AssertionError("Unexpected edited tensor scope")
+                merged = model.state_dict()
+                merged.update(state["edited_tensors"])
+                model.load_state_dict(merged)
+                if model_digest(model) != record["model_sha256"]:
+                    raise AssertionError("Exact saved tensors did not reconstruct the model")
+                metrics, predictions = evaluate_case(
+                    model,
+                    tasks,
+                    originals,
+                    parent_correct,
+                    case["role"],
+                    device,
+                    batch_size,
+                )
+                with np.load(directory / f"predictions-{record['step']:06d}.npz") as saved:
+                    if set(saved.files) != set(predictions):
+                        raise AssertionError("Prediction keys changed")
+                    for name, actual in predictions.items():
+                        if name.endswith("answer_nll"):
+                            np.testing.assert_allclose(actual, saved[name], rtol=1e-5, atol=1e-5)
+                            if len(actual):
+                                max_error = max(
+                                    max_error, float(np.max(np.abs(actual - saved[name])))
+                                )
+                        else:
+                            np.testing.assert_array_equal(actual, saved[name])
+                        checked_predictions += actual.size
+                for name, values in metrics.items():
+                    for key, value in values.items():
+                        expected = record["metrics"][name][key]
+                        if key == "answer_nll" and value is not None:
+                            np.testing.assert_allclose(value, expected, rtol=1e-5, atol=1e-5)
+                        elif value != expected:
+                            raise AssertionError(f"Re-scoring mismatch: {name}/{key}")
+                checked_nodes += 1
+    result = {
+        "passed": True,
+        "nodes": checked_nodes,
+        "array_elements": checked_predictions,
+        "max_nll_error": max_error,
+        "case_sha256": manifest["case_sha256"],
+        "finished_utc": utc(),
+    }
+    write_json(out / "audit.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_tracking.py

@@ -0,0 +1,199 @@
+"""Use the existing W&B sidecar, finishing only after the independent audit."""
+
+import argparse
+import fcntl
+import importlib
+import json
+import os
+import time
+from pathlib import Path
+
+from . import experiment_tracking as tracking
+
+
+class ContainerSDK:
+    def __init__(self, sdk, runtime):
+        self.sdk, self.runtime = sdk, runtime
+
+    def __getattr__(self, name):
+        return getattr(self.sdk, name)
+
+    def Settings(self, **options):
+        options.pop("x_stats_pid", None)
+        if self.runtime:
+            options["x_stats_pid"] = self.runtime["host_pid"]
+            options["x_stats_gpu_device_ids"] = (self.runtime["physical_gpu"],)
+        return self.sdk.Settings(**options)
+
+
+class AuditedRunTracker(tracking.ArtifactRunTracker):
+    def __init__(self, sdk, batch, path, settings):
+        runtime_path = path / "container-runtime.json"
+        runtime = tracking.read_json(runtime_path)
+        super().__init__(ContainerSDK(sdk, runtime), batch, path, settings)
+        self.run.config.update(
+            {
+                key: self.metadata[key]
+                for key in (
+                    "parent_spec",
+                    "cases",
+                    "learning_step_unit",
+                    "status_step_unit",
+                )
+                if key in self.metadata
+            }
+        )
+        if runtime:
+            self.run.config.update({"container_runtime": runtime})
+
+    def poll(self):
+        history = tracking.read_json(self.path / "learning.json")
+        previous = None
+        for record in history:
+            step = int(record["step"])
+            if step > self.cursor:
+                metrics = tracking.learning_metrics(record, previous)
+                for key in ("case", "case_id", "condition", "variant", "arm"):
+                    if key in record:
+                        metrics["condition/" + key] = record[key]
+                if "optimizer_updates" in record:
+                    metrics["evaluation/index"] = step
+                    metrics["condition/step_unit"] = "evaluation_index"
+                    metrics.pop("perf/updates_per_second", None)
+                    metrics.pop("perf/training_ms_per_update", None)
+                    if previous is not None:
+                        seconds = record.get("wall_seconds", 0) - previous.get("wall_seconds", 0)
+                        updates = record["optimizer_updates"] - previous.get("optimizer_updates", 0)
+                        if seconds > 0:
+                            metrics["perf/updates_per_second"] = updates / seconds
+                self.run.log(metrics, step=step)
+                self.cursor = step
+                self.state["last_logged_step"] = step
+                tracking.write_json(self.state_path, self.state)
+            previous = record
+        status_path = self.path / "status.json"
+        if status_path.exists():
+            self.run.summary["training_state"] = tracking.read_json(status_path).get("state")
+        failed = (self.path / "failure.json").exists()
+        audit_path = self.path / "audit.json"
+        audit = tracking.read_json(audit_path) if audit_path.exists() else {}
+        audited = audit.get("passed") is True
+        complete = (self.path / "complete.json").exists() and audited
+        self.run.summary["has_failure_record"] = failed
+        self.run.summary["independently_reloaded"] = audited
+        if complete or failed:
+            self.run.summary["scientific_final_step"] = self.cursor
+            self.run.finish(exit_code=1 if failed else 0)
+            # Preserve the authoritative resume cursor even when every point
+            # was already on the server and this process logged no new points.
+            self.state["last_logged_step"] = self.cursor
+            tracking.write_json(self.state_path, self.state)
+            return True
+        return False
+
+
+def discover_runs(runs_dir):
+    return {
+        path
+        for path in Path(runs_dir).glob("*")
+        if (path / "run.json").exists() and (path / "learning.json").exists()
+    }
+
+
+def final_step(path):
+    history = tracking.read_json(path / "learning.json")
+    return max((int(record["step"]) for record in history), default=-1)
+
+
+def drain_runs(sdk, root, runs_dir, settings, *, once=False, tracker_factory=None):
+    """Drain late-created runs and late final nodes before terminal exit.
+
+    SDK initialization and uploads may take longer than an entire scientific
+    run. Consequently, a scan made before those calls is never an exit proof.
+    Finished runs stay in this process's cursor map and are reopened only if
+    their saved learning trajectory acquired an unlogged final node.
+    """
+    root, runs_dir = Path(root), Path(runs_dir)
+    tracker_factory = tracker_factory or AuditedRunTracker
+    active, finished = {}, {}
+    try:
+        while True:
+            for path in sorted(discover_runs(runs_dir)):
+                if path in active or path in finished:
+                    continue
+                active[path] = tracker_factory(sdk, root, path, settings)
+                print(json.dumps({"run": path.name, "url": active[path].run.url}), flush=True)
+            for path, tracker in list(active.items()):
+                current = tracking.read_json(path / "run.json")
+                if current.get("pid") != tracker.metadata.get("pid"):
+                    tracker.close()
+                    tracker = tracker_factory(sdk, root, path, settings)
+                    active[path] = tracker
+                if tracker.poll():
+                    finished[path] = tracker.cursor
+                    del active[path]
+            if once:
+                return {str(path): cursor for path, cursor in finished.items()}
+            manifest = root / "controller-state.json"
+            state = tracking.read_json(manifest) if manifest.exists() else {}
+            terminal = state.get("state") in {"complete", "finished_with_failures"}
+            # Rescan AFTER all SDK calls and after reading the controller's
+            # terminal state, so runs born during initialization cannot vanish.
+            fresh = discover_runs(runs_dir)
+            stale = {path for path, cursor in finished.items() if final_step(path) > cursor}
+            for path in stale:
+                del finished[path]
+            if terminal and not active:
+                expected = {runs_dir / name for name in state.get("completed", [])}
+                if missing := expected - fresh:
+                    raise RuntimeError(f"Completed runs lack logging artifacts: {sorted(missing)}")
+                if fresh <= finished.keys():
+                    result = {
+                        "passed": True,
+                        "registered_runs": len(finished),
+                        "runs": {
+                            path.name: {
+                                "last_logged_step": finished[path],
+                                "final_step": final_step(path),
+                            }
+                            for path in sorted(fresh)
+                        },
+                    }
+                    tracking.write_json(root / "tracking-completion.json", result)
+                    return result
+            if fresh - (active.keys() | finished.keys()):
+                continue
+            time.sleep(settings["poll_seconds"])
+    finally:
+        for tracker in active.values():
+            tracker.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, required=True)
+    parser.add_argument("--runs-dir", type=Path)
+    parser.add_argument("--defaults", type=Path, default=tracking.DEFAULTS)
+    parser.add_argument("--entity")
+    parser.add_argument("--project")
+    parser.add_argument("--mode", choices=("online", "offline"))
+    parser.add_argument("--once", action="store_true")
+    args = parser.parse_args()
+    settings = tracking.read_json(args.defaults)
+    for key in ("entity", "project", "mode"):
+        settings[key] = (
+            getattr(args, key) or os.environ.get(f"WANDB_{key.upper()}") or settings[key]
+        )
+    if not settings["enabled"]:
+        raise SystemExit("Experiment tracking is disabled in the selected defaults")
+    local = args.root / "tracking-wandb"
+    local.mkdir(parents=True, exist_ok=True)
+    sdk = importlib.import_module("wandb")
+    with (local / "tracker.lock").open("w") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        tracking.write_json(args.root / "tracking-ready.json", {"sdk_version": sdk.__version__})
+        drain_runs(sdk, args.root, args.runs_dir or args.root / "runs", settings, once=args.once)
+
+
+if __name__ == "__main__":
+    main()

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_scaling.py

@@ -0,0 +1,311 @@
+"""Scaling knowledge use in ordinary GPT blocks with fixed facts and tests.
+
+Independent composition examples and optimization time are separate axes. All
+blocks retain learned embeddings, causal attention, residuals and 4x GELU MLPs.
+Historical experiments and their frozen implementations are left untouched.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from .bios_model import ModelConfig
+from .grok_depth import EpochStream, make_optimizer, utc, write_json
+from .grok_loop_model import LoopGPT, flops
+from .storage_composition import FullTokenStep, data_digest, evaluate, file_hash, pack_sentences
+from .storage_composition import build_world as historical_world
+from .storage_frontier import SOURCE_FILES as STABILITY_SOURCES
+from .storage_frontier import learning_rate
+from .text_pretrain import WORDS
+
+SOURCE_FILES = [
+    *STABILITY_SOURCES,
+    "src/llm_memory_editability/latent_scaling.py",
+    "scripts/run_latent_scaling.py",
+    "tests/test_latent_scaling.py",
+]
+
+
+def build_world(spec):
+    world = historical_world(spec)
+    pool = world["train_composite"]
+    order = np.random.default_rng(spec["world"] + 880000).permutation(len(pool))
+    count = spec["composition_count"]
+    count = len(pool) if count == "all" else count
+    if isinstance(count, bool) or not isinstance(count, int) or not 0 < count <= len(pool):
+        raise ValueError("Composition count must be a positive prefix of the fixed pool")
+    world["available_composite"] = pool[order]
+    world["train_composite"] = world["available_composite"][:count].copy()
+    return world
+
+
+def construct(spec, device):
+    config = ModelConfig(
+        vocab_size=len(WORDS) + spec["heads_n"] + spec["bridges_n"] + spec["tails_n"],
+        width=spec["width"],
+        layers=spec["layers"],
+        heads=spec["heads"],
+        context=16,
+    )
+    torch.manual_seed(spec["initialization"])
+    # R=1 is ordinary GPT. The wrapper permits the same trained single block to
+    # be evaluated at other R, including the R=1 training baseline.
+    return LoopGPT(config, spec["repeats"], spec["dropout"], "legacy_unique").to(device)
+
+
+def model_digest(model):
+    digest = hashlib.sha256()
+    for key, value in sorted(model.state_dict().items()):
+        digest.update(key.encode())
+        digest.update(value.detach().cpu().numpy().tobytes())
+    return digest.hexdigest()
+
+
+def run_name(spec):
+    return (
+        f"w{spec['world']}-i{spec['initialization']}-d{spec['width']}"
+        f"-l{spec['layers']}-r{spec['repeats']}-n{spec['composition_count']}-s{spec['steps']}"
+    )
+
+
+def role_coverage(world):
+    first = {(int(h), int(r)) for h, r, _b, _r2, _t in world["train_composite"]}
+    second = {(int(b), int(r)) for _h, _r1, b, r, _t in world["train_composite"]}
+    rows = world["familiar_test"]
+    return {
+        "first_atoms_used": len(first),
+        "second_atoms_used": len(second),
+        "familiar_both_composition_roles": float(
+            np.mean(
+                [
+                    (int(h), int(r1)) in first and (int(b), int(r2)) in second
+                    for h, r1, b, r2, _t in rows
+                ]
+            )
+        ),
+    }
+
+
+def train(spec, out, source, device="cuda:0"):
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "latest.pt").exists() or (out / "complete.json").exists():
+        raise FileExistsError(f"Do not overwrite a training attempt: {out}")
+    if spec["nodes"][0] != 0 or spec["nodes"][-1] != spec["steps"]:
+        raise ValueError("Nodes must include initialization and the fixed endpoint")
+    if spec["nodes"] != sorted(set(spec["nodes"])) or spec["batch_size"] % 3:
+        raise ValueError("Nodes must increase and the batch must divide into three streams")
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_device(torch.device(device))
+    process_start = time.perf_counter()
+    world = build_world(spec)
+    np.savez_compressed(out / "world.npz", **world)
+    digest = data_digest(world)
+    write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest})
+    model = construct(spec, device)
+    initial_digest = model_digest(model)
+    lr = torch.tensor(spec["lr"], device=device)
+    optimizer = make_optimizer(model, lr, spec["weight_decay"])
+    strata = [world["common_atomic"], world["train_composite"], world["anchor_atomic"]]
+    table = tuple(
+        torch.as_tensor(np.concatenate(parts), device=device)
+        for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True)
+    )
+    sizes = [len(rows) for rows in strata]
+    offsets = np.cumsum([0, *sizes[:-1]])
+    streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)]
+    counts = [np.zeros(size, dtype=np.int64) for size in sizes]
+    batch = spec["batch_size"]
+    graph = FullTokenStep(model, optimizer, table, batch)
+    flop_step = flops(model.config, spec["repeats"], batch, 9, output_positions=9)
+    history, repeat_metrics, training_seconds, step = [], {}, 0.0, 0
+
+    def measure(loss=None):
+        metrics, predictions = evaluate(model, world, "low", device)
+        row = {
+            "step": step,
+            "lr": learning_rate(spec, step) if step else 0.0,
+            "metrics": metrics,
+            "loss": loss,
+            "training_seconds": training_seconds,
+            "estimated_training_flops": step * flop_step,
+            "composition_epochs": step * batch / 3 / sizes[1],
+        }
+        history.append(row)
+        write_json(out / "learning.json", history)
+        np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions)
+        if step in spec["repeat_nodes"]:
+            repeat_metrics[str(step)] = {}
+            for repeat in spec["test_repeats"]:
+                m, p = evaluate(model, world, "low", device, repeat)
+                repeat_metrics[str(step)][str(repeat)] = m
+                np.savez_compressed(out / f"repeat-{step:06d}-r{repeat:02d}.npz", **p)
+            write_json(out / "repeat-metrics.json", repeat_metrics)
+        state = {
+            "spec": spec,
+            "step": step,
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "streams": [s.state_dict() for s in streams],
+            "counts": counts,
+            "cpu_rng": torch.get_rng_state(),
+            "cuda_rng": torch.cuda.get_rng_state(device),
+            "source": source,
+            "data_sha256": digest,
+        }
+        torch.save(state, out / "latest.tmp.pt")
+        (out / "latest.tmp.pt").replace(out / "latest.pt")
+        if step in spec["checkpoint_nodes"]:
+            torch.save(
+                {"spec": spec, "step": step, "model": model.state_dict()},
+                out / f"model-{step:06d}.pt",
+            )
+        write_json(out / "status.json", {"step": step, "budget": spec["steps"]})
+        print(
+            json.dumps(
+                {
+                    "run": run_name(spec),
+                    "step": step,
+                    "atomic": metrics["common_atomic"]["accuracy"],
+                    "train": metrics["train_composite"]["accuracy"],
+                    "test": metrics["familiar_test"]["accuracy"],
+                }
+            ),
+            flush=True,
+        )
+        return row
+
+    measure()
+    for end in spec["nodes"][1:]:
+        torch.cuda.synchronize()
+        started = time.perf_counter()
+        while step < end:
+            n = min(128, end - step)
+            indices = []
+            for i, stream in enumerate(streams):
+                drawn = stream.take(n * batch // 3).reshape(n, batch // 3)
+                counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i])
+                indices.append(drawn + offsets[i])
+            indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device)
+            for j in range(n):
+                lr.fill_(learning_rate(spec, step + j + 1))
+                loss = graph(indices[j])
+            step += n
+        torch.cuda.synchronize()
+        training_seconds += time.perf_counter() - started
+        loss = float(loss)
+        if not np.isfinite(loss):
+            raise FloatingPointError(f"Nonfinite training loss at {step}")
+        endpoint = measure(loss)
+    np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)})
+    result = {
+        "spec": spec,
+        "source": source,
+        "data_sha256": digest,
+        "initial_model_sha256": initial_digest,
+        "checkpoint_sha256": file_hash(out / "latest.pt"),
+        "finished_utc": utc(),
+        "parameters": sum(p.numel() for p in model.parameters()),
+        "independent_facts": sizes[0] + sizes[2],
+        "composition_examples": sizes[1],
+        "role_coverage": role_coverage(world),
+        "endpoint": endpoint,
+        "repeat_metrics": repeat_metrics,
+        "training_seconds": training_seconds,
+        "process_seconds": time.perf_counter() - process_start,
+        "supervised_tokens": step * batch * 23 // 3,
+        "padded_input_tokens": step * batch * 9,
+        "environment": {
+            "torch": torch.__version__,
+            "numpy": np.__version__,
+            "cuda": torch.version.cuda,
+            "gpu": torch.cuda.get_device_name(device),
+            "tf32": True,
+        },
+    }
+    write_json(out / "complete.json", result)
+    return result
+
+
+def compare_predictions(actual, saved):
+    maximum = 0.0
+    assert set(actual) == set(saved.files)
+    for key, value in actual.items():
+        if key.endswith("answer_nll"):
+            maximum = max(maximum, float(np.abs(value - saved[key]).max()))
+            np.testing.assert_allclose(value, saved[key], rtol=1e-5, atol=1e-5)
+        else:
+            np.testing.assert_array_equal(value, saved[key])
+    return maximum
+
+
+def compare_metrics(actual, saved):
+    for task, values in actual.items():
+        for key, value in values.items():
+            if key == "answer_nll":
+                np.testing.assert_allclose(value, saved[task][key], rtol=1e-5, atol=1e-5)
+            else:
+                assert value == saved[task][key]
+
+
+def audit(out, device="cuda:0"):
+    out = Path(out)
+    torch.set_num_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_device(torch.device(device))
+    result = json.loads((out / "complete.json").read_text())
+    assert file_hash(out / "latest.pt") == result["checkpoint_sha256"]
+    saved = torch.load(out / "latest.pt", map_location=device, weights_only=False)
+    spec = saved["spec"]
+    world = build_world(spec)
+    assert data_digest(world) == result["data_sha256"] == saved["data_sha256"]
+    assert saved["step"] == spec["steps"]
+    model = construct(spec, device)
+    model.load_state_dict(saved["model"])
+    metrics, predictions = evaluate(model, world, "low", device)
+    compare_metrics(metrics, result["endpoint"]["metrics"])
+    maximum = compare_predictions(
+        predictions, np.load(out / f"predictions-{spec['steps']:06d}.npz")
+    )
+    repeat_checks = 0
+    for node, repeats in result["repeat_metrics"].items():
+        checkpoint = torch.load(
+            out / f"model-{int(node):06d}.pt", map_location=device, weights_only=False
+        )
+        model.load_state_dict(checkpoint["model"])
+        for repeat, expected in repeats.items():
+            actual, pred = evaluate(model, world, "low", device, int(repeat))
+            compare_metrics(actual, expected)
+            maximum = max(
+                maximum,
+                compare_predictions(
+                    pred, np.load(out / f"repeat-{int(node):06d}-r{int(repeat):02d}.npz")
+                ),
+            )
+            repeat_checks += 1
+    exposures = np.load(out / "exposures.npz")
+    for i in range(3):
+        np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i])
+        assert exposures[f"stratum{i}"].sum() == spec["steps"] * spec["batch_size"] // 3
+        assert np.ptp(exposures[f"stratum{i}"]) <= 1
+    checked = {
+        "passed": True,
+        "endpoint_tokens_exact": True,
+        "repeat_checks": repeat_checks,
+        "max_nll_difference": maximum,
+        "nll_rtol": 1e-5,
+        "nll_atol": 1e-5,
+        "utc": utc(),
+    }
+    write_json(out / "audit.json", checked)
+    return checked

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_support.py

@@ -0,0 +1,363 @@
+"""Degree-matched support follow-up with isolated training and audit entry points.
+
+The train/audit bodies are copied from latent_scaling.py at batch creation so
+historical sources retain their frozen hashes. Architecture, optimizer, sentence
+packing, evaluation and streams are reused; only build_world selects support.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from .grok_depth import EpochStream, make_optimizer, utc, write_json
+from .grok_loop_model import flops
+from .latent_scaling import (
+    SOURCE_FILES as HISTORICAL_SOURCES,
+)
+from .latent_scaling import (
+    build_world as scaling_world,
+)
+from .latent_scaling import (
+    compare_metrics,
+    compare_predictions,
+    construct,
+    model_digest,
+    role_coverage,
+)
+from .latent_scaling import (
+    run_name as scaling_run_name,
+)
+from .storage_composition import (
+    FullTokenStep,
+    audit_world,
+    data_digest,
+    evaluate,
+    file_hash,
+    pack_sentences,
+)
+from .storage_frontier import learning_rate
+
+SOURCE_FILES = [*HISTORICAL_SOURCES, "src/llm_memory_editability/latent_support.py"]
+
+
+def run_name(spec):
+    return scaling_run_name(spec) + "-support-" + spec["support"]
+
+
+def build_world(spec):
+    """Select frozen legal edges; never use model scores or test pairs to choose."""
+    if spec.get("support") not in ("connected", "split"):
+        raise ValueError("Unknown frozen support arm")
+    indices = spec.get("composition_indices", [])
+    if (
+        len(indices) != 512
+        or any(isinstance(i, bool) or not isinstance(i, int) for i in indices)
+        or len(set(indices)) != 512
+        or indices != sorted(indices)
+        or spec.get("composition_count") != 512
+    ):
+        raise ValueError("Support must contain 512 unique sorted integer indices")
+    world = scaling_world(dict(spec, composition_count="all"))
+    pool = world["available_composite"]
+    if indices[0] < 0 or indices[-1] >= len(pool):
+        raise ValueError("Support index outside the fixed available pool")
+    world["train_composite"] = pool[indices].copy()
+    if len(set(map(tuple, world["train_composite"]))) != 512:
+        raise ValueError("Support contains duplicate training chains")
+    audit_world(world)
+    expected = spec.get("frozen_data_sha256")
+    if expected is not None and data_digest(world) != expected:
+        raise RuntimeError("Rebuilt support data differ from the frozen digest")
+    return world
+
+
+def exposure_signature(world, counts=None):
+    """Count actual sampled roles and column marginals, independently of streams."""
+    rows = world["train_composite"]
+    if counts is None:
+        counts = np.ones(len(rows), dtype=np.int64)
+    if len(counts) != len(rows):
+        raise ValueError("Exposure counter does not match the support")
+    first, second = Counter(), Counter()
+    columns = [Counter() for _ in range(5)]
+    for row, count in zip(rows, counts, strict=True):
+        h, r1, b, r2, _t = map(int, row)
+        first[f"{h}:{r1}"] += int(count)
+        second[f"{b}:{r2}"] += int(count)
+        for col, value in enumerate(row):
+            columns[col][str(int(value))] += int(count)
+    return {
+        "first_roles": dict(sorted(first.items())),
+        "second_roles": dict(sorted(second.items())),
+        "columns": [dict(sorted(c.items())) for c in columns],
+    }
+
+
+def support_components(world):
+    """Independent adjacency traversal, including all available training roles."""
+    adjacency = {}
+    for h, r1, b, r2, _t in world["available_composite"]:
+        adjacency.setdefault(("l", int(h), int(r1)), set())
+        adjacency.setdefault(("r", int(b), int(r2)), set())
+    for h, r1, b, r2, _t in world["train_composite"]:
+        left, right = ("l", int(h), int(r1)), ("r", int(b), int(r2))
+        adjacency[left].add(right)
+        adjacency[right].add(left)
+    seen, components = set(), 0
+    for root in adjacency:
+        if root in seen:
+            continue
+        components += 1
+        stack = [root]
+        seen.add(root)
+        while stack:
+            for neighbour in adjacency[stack.pop()]:
+                if neighbour not in seen:
+                    seen.add(neighbour)
+                    stack.append(neighbour)
+    return {
+        "roles": len(adjacency),
+        "components": components,
+        "isolated_roles": sum(not neighbours for neighbours in adjacency.values()),
+    }
+
+
+def validate_nodes(spec):
+    if spec["batch_size"] != 192 or any(node % 8 for node in spec["nodes"]):
+        raise ValueError("Every measurement must complete the 512-chain epochs")
+    if not set(spec["repeat_nodes"]) <= set(spec["checkpoint_nodes"]) <= set(spec["nodes"]):
+        raise ValueError("Scans and checkpoints must use recorded learning nodes")
+
+
+def train(spec, out, source, device="cuda:0"):
+    validate_nodes(spec)
+    if "frozen_data_sha256" not in spec:
+        raise ValueError("Training requires a frozen data digest")
+    if any(file_hash(path) != digest for path, digest in source.items()):
+        raise RuntimeError("Training source differs from its frozen digest")
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "latest.pt").exists() or (out / "complete.json").exists():
+        raise FileExistsError(f"Do not overwrite a training attempt: {out}")
+    if spec["nodes"][0] != 0 or spec["nodes"][-1] != spec["steps"]:
+        raise ValueError("Nodes must include initialization and the fixed endpoint")
+    if spec["nodes"] != sorted(set(spec["nodes"])) or spec["batch_size"] % 3:
+        raise ValueError("Nodes must increase and the batch must divide into three streams")
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_device(torch.device(device))
+    process_start = time.perf_counter()
+    world = build_world(spec)
+    np.savez_compressed(out / "world.npz", **world)
+    digest = data_digest(world)
+    write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest})
+    model = construct(spec, device)
+    initial_digest = model_digest(model)
+    lr = torch.tensor(spec["lr"], device=device)
+    optimizer = make_optimizer(model, lr, spec["weight_decay"])
+    strata = [world["common_atomic"], world["train_composite"], world["anchor_atomic"]]
+    table = tuple(
+        torch.as_tensor(np.concatenate(parts), device=device)
+        for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True)
+    )
+    sizes = [len(rows) for rows in strata]
+    offsets = np.cumsum([0, *sizes[:-1]])
+    streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)]
+    counts = [np.zeros(size, dtype=np.int64) for size in sizes]
+    batch = spec["batch_size"]
+    graph = FullTokenStep(model, optimizer, table, batch)
+    flop_step = flops(model.config, spec["repeats"], batch, 9, output_positions=9)
+    history, repeat_metrics, training_seconds, step = [], {}, 0.0, 0
+
+    def measure(loss=None):
+        if step and not np.all(counts[1] == step * batch // 3 // 512):
+            raise RuntimeError("Composition exposures must be exact complete epochs")
+        metrics, predictions = evaluate(model, world, "low", device)
+        row = {
+            "step": step,
+            "lr": learning_rate(spec, step) if step else 0.0,
+            "metrics": metrics,
+            "loss": loss,
+            "training_seconds": training_seconds,
+            "estimated_training_flops": step * flop_step,
+            "composition_epochs": step * batch / 3 / sizes[1],
+        }
+        history.append(row)
+        write_json(out / "learning.json", history)
+        np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions)
+        if step in spec["repeat_nodes"]:
+            repeat_metrics[str(step)] = {}
+            for repeat in spec["test_repeats"]:
+                m, p = evaluate(model, world, "low", device, repeat)
+                repeat_metrics[str(step)][str(repeat)] = m
+                np.savez_compressed(out / f"repeat-{step:06d}-r{repeat:02d}.npz", **p)
+            write_json(out / "repeat-metrics.json", repeat_metrics)
+        state = {
+            "spec": spec,
+            "step": step,
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "streams": [s.state_dict() for s in streams],
+            "counts": counts,
+            "cpu_rng": torch.get_rng_state(),
+            "cuda_rng": torch.cuda.get_rng_state(device),
+            "source": source,
+            "data_sha256": digest,
+        }
+        torch.save(state, out / "latest.tmp.pt")
+        (out / "latest.tmp.pt").replace(out / "latest.pt")
+        if step in spec["checkpoint_nodes"]:
+            torch.save(
+                {"spec": spec, "step": step, "model": model.state_dict()},
+                out / f"model-{step:06d}.pt",
+            )
+        write_json(out / "status.json", {"step": step, "budget": spec["steps"]})
+        print(
+            json.dumps(
+                {
+                    "run": run_name(spec),
+                    "step": step,
+                    "atomic": metrics["common_atomic"]["accuracy"],
+                    "train": metrics["train_composite"]["accuracy"],
+                    "test": metrics["familiar_test"]["accuracy"],
+                }
+            ),
+            flush=True,
+        )
+        return row
+
+    measure()
+    for end in spec["nodes"][1:]:
+        torch.cuda.synchronize()
+        started = time.perf_counter()
+        while step < end:
+            n = min(128, end - step)
+            indices = []
+            for i, stream in enumerate(streams):
+                drawn = stream.take(n * batch // 3).reshape(n, batch // 3)
+                counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i])
+                indices.append(drawn + offsets[i])
+            indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device)
+            for j in range(n):
+                lr.fill_(learning_rate(spec, step + j + 1))
+                loss = graph(indices[j])
+            step += n
+        torch.cuda.synchronize()
+        training_seconds += time.perf_counter() - started
+        loss = float(loss)
+        if not np.isfinite(loss):
+            raise FloatingPointError(f"Nonfinite training loss at {step}")
+        endpoint = measure(loss)
+    np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)})
+    result = {
+        "spec": spec,
+        "source": source,
+        "data_sha256": digest,
+        "initial_model_sha256": initial_digest,
+        "checkpoint_sha256": file_hash(out / "latest.pt"),
+        "finished_utc": utc(),
+        "parameters": sum(p.numel() for p in model.parameters()),
+        "independent_facts": sizes[0] + sizes[2],
+        "composition_examples": sizes[1],
+        "role_coverage": role_coverage(world),
+        "support_components": support_components(world),
+        "support_exposures": exposure_signature(world, counts[1]),
+        "endpoint": endpoint,
+        "repeat_metrics": repeat_metrics,
+        "training_seconds": training_seconds,
+        "process_seconds": time.perf_counter() - process_start,
+        "supervised_tokens": step * batch * 23 // 3,
+        "padded_input_tokens": step * batch * 9,
+        "environment": {
+            "torch": torch.__version__,
+            "numpy": np.__version__,
+            "cuda": torch.version.cuda,
+            "gpu": torch.cuda.get_device_name(device),
+            "tf32": True,
+        },
+    }
+    write_json(out / "complete.json", result)
+    return result
+
+
+def audit(out, device="cuda:0"):
+    out = Path(out)
+    torch.set_num_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_device(torch.device(device))
+    result = json.loads((out / "complete.json").read_text())
+    assert file_hash(out / "latest.pt") == result["checkpoint_sha256"]
+    saved = torch.load(out / "latest.pt", map_location=device, weights_only=False)
+    recorded = json.loads((out / "spec.json").read_text())
+    assert saved["spec"] == result["spec"] == recorded["spec"]
+    assert saved["source"] == result["source"] == recorded["source"]
+    assert all(file_hash(path) == digest for path, digest in result["source"].items())
+    spec = saved["spec"]
+    validate_nodes(spec)
+    assert "frozen_data_sha256" in spec
+    world = build_world(spec)
+    assert data_digest(world) == result["data_sha256"] == saved["data_sha256"]
+    assert data_digest(world) == recorded["data_sha256"] == spec["frozen_data_sha256"]
+    with np.load(out / "world.npz") as archived:
+        assert set(archived.files) == set(world)
+        for key, rows in world.items():
+            np.testing.assert_array_equal(rows, archived[key])
+    assert saved["step"] == spec["steps"]
+    model = construct(spec, device)
+    assert model_digest(model) == result["initial_model_sha256"]
+    model.load_state_dict(saved["model"])
+    metrics, predictions = evaluate(model, world, "low", device)
+    compare_metrics(metrics, result["endpoint"]["metrics"])
+    maximum = compare_predictions(
+        predictions, np.load(out / f"predictions-{spec['steps']:06d}.npz")
+    )
+    repeat_checks = 0
+    for node, repeats in result["repeat_metrics"].items():
+        checkpoint = torch.load(
+            out / f"model-{int(node):06d}.pt", map_location=device, weights_only=False
+        )
+        assert checkpoint["spec"] == spec and checkpoint["step"] == int(node)
+        model.load_state_dict(checkpoint["model"])
+        for repeat, expected in repeats.items():
+            actual, pred = evaluate(model, world, "low", device, int(repeat))
+            compare_metrics(actual, expected)
+            maximum = max(
+                maximum,
+                compare_predictions(
+                    pred, np.load(out / f"repeat-{int(node):06d}-r{int(repeat):02d}.npz")
+                ),
+            )
+            repeat_checks += 1
+    exposures = np.load(out / "exposures.npz")
+    for i in range(3):
+        np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i])
+        assert exposures[f"stratum{i}"].sum() == spec["steps"] * spec["batch_size"] // 3
+        assert np.ptp(exposures[f"stratum{i}"]) <= 1
+    composition_counts = exposures["stratum1"]
+    assert np.all(composition_counts == spec["steps"] * spec["batch_size"] // 3 // 512)
+    assert exposure_signature(world, composition_counts) == result["support_exposures"]
+    assert support_components(world) == result["support_components"]
+    checked = {
+        "frozen_data_exact": True,
+        "archived_world_exact": True,
+        "composition_complete_epochs": True,
+        "role_exposures_exact": True,
+        "passed": True,
+        "endpoint_tokens_exact": True,
+        "repeat_checks": repeat_checks,
+        "max_nll_difference": maximum,
+        "nll_rtol": 1e-5,
+        "nll_atol": 1e-5,
+        "utc": utc(),
+    }
+    write_json(out / "audit.json", checked)
+    return checked

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/low_rank.py

@@ -0,0 +1,138 @@
+"""Fully observed matrix representability; no training or editing algorithm.
+
+The best approximation minimizes unweighted Frobenius error over *all* entries.
+It need not preserve unchanged facts exactly or prioritize requested edits.
+Numerical rank uses an absolute singular-value threshold, not an exact-rank proof.
+"""
+
+from numbers import Integral, Real
+from typing import Any
+
+import numpy as np
+
+
+def _matrix(value: Any, name: str = "matrix") -> np.ndarray:
+    """Convert a nonempty, finite, real numeric matrix to float64."""
+    try:
+        raw = np.asarray(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{name} must be a rectangular real numeric matrix") from exc
+    if raw.ndim != 2 or 0 in raw.shape:
+        raise ValueError(f"{name} must be a nonempty two-dimensional matrix")
+    if raw.dtype.kind not in "iuf":
+        raise ValueError(f"{name} must contain real numeric values")
+    with np.errstate(over="ignore", invalid="ignore"):
+        result = raw.astype(np.float64)
+    if not np.isfinite(result).all():
+        raise ValueError(f"{name} must contain finite float64 values")
+    return result
+
+
+def _rank(value: Any, shape: tuple[int, int]) -> int:
+    if isinstance(value, (bool, np.bool_)) or not isinstance(value, Integral):
+        raise ValueError("rank must be a nonnegative integer")
+    if not 0 <= value <= min(shape):
+        raise ValueError(f"rank must be between 0 and {min(shape)}")
+    return int(value)
+
+
+def _tolerance(value: Any) -> float:
+    if isinstance(value, (bool, np.bool_)) or not isinstance(value, Real):
+        raise ValueError("atol must be a finite positive real number")
+    value = float(value)
+    if not np.isfinite(value) or value <= 0:
+        raise ValueError("atol must be a finite positive real number")
+    return value
+
+
+def numerical_rank(matrix: Any, atol: float = 1e-10) -> int:
+    """Count singular values strictly greater than the absolute tolerance."""
+    array = _matrix(matrix)
+    tolerance = _tolerance(atol)
+    return int(np.count_nonzero(np.linalg.svd(array, compute_uv=False) > tolerance))
+
+
+def best_rank_approximation(matrix: Any, rank: int) -> np.ndarray:
+    """Return a best rank-at-most-``rank`` Frobenius approximation using SVD.
+
+    ``rank`` may be zero and may not exceed the smaller matrix dimension.
+    The returned matrix is independent of the input. Tied singular values can
+    make the optimum nonunique; NumPy's SVD selects one such optimum.
+    """
+    array = _matrix(matrix)
+    budget = _rank(rank, array.shape)
+    left, values, right = np.linalg.svd(array, full_matrices=False)
+    return (left[:, :budget] * values[:budget]) @ right[:budget, :]
+
+
+def representation_gap(matrix: Any, rank: int, atol: float = 1e-10) -> int:
+    """Return max(0, numerical target rank minus the available rank budget)."""
+    array = _matrix(matrix)
+    budget = _rank(rank, array.shape)
+    return max(0, numerical_rank(array, atol=atol) - budget)
+
+
+def evaluate_update(original: Any, target: Any, rank: int, atol: float = 1e-10) -> dict[str, Any]:
+    """Report an update's analytical optimum under a fixed total rank budget.
+
+    ``original`` and ``target`` must have identical shapes. The target is fitted
+    directly, with no optimization path or restriction on the update rank.
+    ``squared_error_lower_bound`` is the sum of discarded squared singular
+    values (Eckart–Young–Mirsky); floating-point residuals may differ slightly.
+
+    Edited entries are exactly those where original and target differ. ``atol``
+    affects rank estimates only. RMSE is measured against the target separately
+    on edited and retained entries; an empty group is represented by ``None``.
+    The retained-entry metric measures collateral error at this global optimum,
+    not the side effects of a learned editing algorithm.
+    """
+    before = _matrix(original, "original")
+    after = _matrix(target, "target")
+    if before.shape != after.shape:
+        raise ValueError("original and target must have identical shapes")
+    budget = _rank(rank, after.shape)
+    tolerance = _tolerance(atol)
+    with np.errstate(over="ignore", invalid="ignore"):
+        delta = _matrix(after - before, "target - original")
+    left, values, right = np.linalg.svd(after, full_matrices=False)
+    reconstruction = (left[:, :budget] * values[:budget]) @ right[:budget, :]
+    residual = reconstruction - after
+    edited = before != after
+    target_rank = int(np.count_nonzero(values > tolerance))
+    gap = max(0, target_rank - budget)
+    error = float(np.linalg.norm(residual, ord="fro"))
+    lower_bound = float(np.sum(values[budget:] ** 2))
+
+    def group_rmse(mask: np.ndarray) -> float | None:
+        return float(np.linalg.norm(residual[mask]) / np.sqrt(mask.sum())) if mask.any() else None
+
+    report = {
+        "rank_budget": budget,
+        "atol": tolerance,
+        "original_rank": numerical_rank(before, tolerance),
+        "target_rank": target_rank,
+        "delta_rank": numerical_rank(delta, tolerance),
+        "representation_gap": gap,
+        "representable_within_rank_tolerance": gap == 0,
+        "edit_count": int(edited.sum()),
+        "original": before.tolist(),
+        "target": after.tolist(),
+        "delta": delta.tolist(),
+        "reconstruction": reconstruction.tolist(),
+        "singular_values": values.tolist(),
+        "frobenius_error": error,
+        "squared_frobenius_error": error**2,
+        "squared_error_lower_bound": lower_bound,
+        "edited_entry_rmse": group_rmse(edited),
+        "retained_entry_rmse": group_rmse(~edited),
+    }
+    metrics = [
+        error,
+        error**2,
+        lower_bound,
+        report["edited_entry_rmse"],
+        report["retained_entry_rmse"],
+    ]
+    if not all(value is None or np.isfinite(value) for value in metrics):
+        raise ValueError("matrix scale exceeds finite float64 error metrics; rescale the inputs")
+    return report

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/memory_reuse.py

@@ -0,0 +1,469 @@
+"""Learned two-hop retrieval followed by an independently fitted memory swap.
+
+The pinned author implementation supplies the SwiGLU memory and GPT blocks.
+Only attention Q/K are learned by the reader. Replacement facts are never used
+by its optimizer, and all evaluation uses continuous intermediate states.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from llm_memory_editability import hebbian_interface as interface
+
+ARMS = ("ce", "aligned")
+
+
+def sha(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def write_json(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n")
+    temporary.replace(path)
+
+
+def cpu_state(model):
+    return {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
+
+
+def hash_state(model, *, reader_only=False):
+    return interface.tensor_hash(
+        {k: v for k, v in model.state_dict().items() if not reader_only or ".mlp." not in k}
+    )
+
+
+def build_world(spec, seed):
+    """Geometry, content and held-out heads use independent local random streams."""
+    n, d, j = spec["num_entities"], spec["d_model"], spec["junk_vocab_size"]
+    rng = np.random.default_rng(seed)
+    embeddings = rng.standard_normal((n + j + 1, d)).astype(np.float32)
+    embeddings /= np.linalg.norm(embeddings, axis=-1, keepdims=True)
+    mapping_a = np.arange(n + j + 1, dtype=np.int64)
+    mapping_b = mapping_a.copy()
+    mapping_a[:n] = rng.permutation(n)
+    for _ in range(10000):
+        candidate = rng.permutation(n)
+        if np.all(candidate != mapping_a[:n]):
+            mapping_b[:n] = candidate
+            break
+    else:
+        raise RuntimeError("Failed to draw a changed independent permutation")
+    order = np.random.default_rng(seed + 20000).permutation(n)
+    n_train = int(n * spec["train_head_fraction"])
+    if not 0 < n_train <= n:
+        raise ValueError("Composition-training head fraction must lie in (0, 1]")
+    train_mask = np.zeros(n, dtype=bool)
+    train_mask[order[:n_train]] = True
+    return {
+        "embeddings": embeddings,
+        "mapping_A": mapping_a,
+        "mapping_B": mapping_b,
+        "train_mask": train_mask,
+        "seed": np.asarray(seed),
+    }
+
+
+def data_audit(spec, world):
+    n, j = spec["num_entities"], spec["junk_vocab_size"]
+    for name in ("A", "B"):
+        mapping = world[f"mapping_{name}"]
+        assert np.array_equal(np.sort(mapping[:n]), np.arange(n))
+        assert np.array_equal(mapping[n:], np.arange(n, n + j + 1))
+    assert np.all(world["mapping_A"][:n] != world["mapping_B"][:n])
+    np.testing.assert_allclose(np.linalg.norm(world["embeddings"], axis=-1), 1, atol=2e-7)
+    assert world["train_mask"].sum() == int(n * spec["train_head_fraction"])
+    a, b = world["mapping_A"], world["mapping_B"]
+    return {
+        "entities": n,
+        "neutral_tokens": j + 1,
+        "A_composition_training_heads": int(world["train_mask"].sum()),
+        "A_composition_heldout_heads": int((~world["train_mask"]).sum()),
+        "changed_atomic_facts": int((a[:n] != b[:n]).sum()),
+        "changed_composite_answers": int((a[a[:n]] != b[b[:n]]).sum()),
+        "passed": True,
+    }
+
+
+def make_inputs(spec, repeats, seed):
+    """Each head occurs once per repeat; contexts contain only neutral tokens."""
+    n, j, length = spec["num_entities"], spec["junk_vocab_size"], spec["junk_length"]
+    rng = np.random.default_rng(seed)
+    keys = np.tile(np.arange(n, dtype=np.int64), repeats)
+    inputs = rng.integers(n, n + j, (len(keys), length + 2), dtype=np.int64)
+    positions = rng.integers(0, length + 1, len(keys))
+    inputs[np.arange(len(keys)), positions] = keys
+    inputs[:, -1] = n + j
+    return inputs, keys
+
+
+def new_memory(spec, init, device):
+    cfg = {**interface.DEFAULT_SPEC, **spec}
+    interface._source(cfg)
+    torch.manual_seed(init)
+    return interface._new_memory(cfg, device)
+
+
+class TwoHopReader(torch.nn.Module):
+    """Two causal attention blocks with one shared, frozen fact MLP."""
+
+    def __init__(self, spec, embeddings, memory, init, device):
+        super().__init__()
+        interface._source(spec)
+        from hebbian.transformer.model import GPT, GPTConfig
+
+        torch.manual_seed(init + 100000)
+        cfg = GPTConfig(
+            block_size=spec["junk_length"] + 2,
+            vocab_size=len(embeddings),
+            n_layer=2,
+            n_head=1,
+            n_embd=spec["d_model"],
+            dropout=0.0,
+            bias=False,
+            mlp_residual=False,
+            attn_residual=False,
+            use_rope=False,
+            no_positional_encoding=True,
+            mlp_norm_type="unit_rmsnorm",
+            attn_norm_type="rmsnorm",
+            lm_head_norm_type="unit_rmsnorm",
+            tie_embeddings=True,
+            freeze_value_dense_identity=True,
+            use_identity_mlp=True,
+        )
+        self.gpt = GPT(cfg).to(device)
+        with torch.no_grad():
+            self.gpt.transformer.wte.weight.copy_(torch.as_tensor(embeddings, device=device))
+        self.install(memory)
+        self.gpt.requires_grad_(False)
+        for block in self.gpt.transformer.h:
+            block.attn.c_q.requires_grad_(True)
+            block.attn.c_k.requires_grad_(True)
+        self.scale = spec["readout_scale"]
+
+    def install(self, memory):
+        memory.requires_grad_(False)
+        for block in self.gpt.transformer.h:
+            block.mlp = memory
+
+    def forward(self, inputs):
+        x = self.gpt.transformer.wte(inputs)
+        logits = []
+        for block in self.gpt.transformer.h:
+            x = block(x)
+            z = self.gpt.transformer.ln_f(x[:, -1])
+            logits.append(self.scale * self.gpt.lm_head(z))
+        return torch.stack(logits, dim=1)
+
+
+def memory_objective(output, embeddings, labels, arm, alignment_weight):
+    ce = F.cross_entropy(output @ embeddings.T, labels)
+    alignment = (output - embeddings[labels]).square().sum(-1).mean()
+    return ce + (alignment_weight if arm == "aligned" else 0.0) * alignment
+
+
+@torch.no_grad()
+def clean_memory(memory, embeddings, mapping, n):
+    output = memory(embeddings)
+    cosine = F.normalize(output, dim=-1) @ embeddings.T
+    pred = cosine.argmax(-1)
+    return {
+        "atomic_accuracy": float(pred[:n].eq(mapping[:n]).float().mean()),
+        "neutral_accuracy": float(pred[n:].eq(mapping[n:]).float().mean()),
+        "target_cosine": float(cosine[torch.arange(n, device=mapping.device), mapping[:n]].mean()),
+        "output_norm": float(output[:n].norm(dim=-1).mean()),
+        "vector_squared_error": float(
+            (output[:n] - embeddings[mapping[:n]]).square().sum(-1).mean()
+        ),
+    }
+
+
+def fit_memory(spec, world, mapping_name, arm, init, device, output_dir):
+    """Only atomic labels appear here, including for the replacement memory."""
+    path = output_dir / f"memory-{mapping_name}.pt"
+    if path.exists():
+        payload = torch.load(path, map_location="cpu", weights_only=True)
+        model = new_memory(spec, init, device)
+        model.load_state_dict(payload["state_dict"])
+        record = dict(payload["record"], reused_checkpoint=True)
+        return model.requires_grad_(False).eval(), record
+    memory = new_memory(spec, init, device)
+    embeddings = torch.as_tensor(world["embeddings"], device=device)
+    labels = torch.as_tensor(world[f"mapping_{mapping_name}"], device=device)
+    optimizer = torch.optim.Adam(memory.parameters(), lr=spec["memory_lr"], foreach=False)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+        optimizer, spec["memory_steps"], eta_min=spec["memory_min_lr"]
+    )
+    initial_hash = hash_state(memory)
+    curve = []
+    began = time.perf_counter()
+    for step in range(spec["memory_steps"] + 1):
+        if step in spec["memory_nodes"]:
+            metrics = clean_memory(memory, embeddings, labels, spec["num_entities"])
+            metrics.update(step=step, seconds=time.perf_counter() - began)
+            curve.append(metrics)
+            write_json(output_dir / f"memory-{mapping_name}-curve.json", curve)
+            print(json.dumps(dict(stage=f"memory-{mapping_name}", arm=arm, **metrics)), flush=True)
+        if step == spec["memory_steps"]:
+            break
+        memory.train()
+        optimizer.zero_grad(set_to_none=True)
+        loss = memory_objective(
+            memory(embeddings), embeddings, labels, arm, spec["alignment_weight"]
+        )
+        loss.backward()
+        optimizer.step()
+        scheduler.step()
+    if device.type == "cuda":
+        torch.cuda.synchronize(device)
+    memory.eval().requires_grad_(False)
+    record = dict(
+        initial_hash=initial_hash,
+        final_hash=hash_state(memory),
+        steps=spec["memory_steps"],
+        seconds=time.perf_counter() - began,
+        metrics=clean_memory(memory, embeddings, labels, spec["num_entities"]),
+    )
+    torch.save(dict(state_dict=cpu_state(memory), record=record), path)
+    return memory, record
+
+
+@torch.no_grad()
+def evaluate(reader, inputs, device, batch_size):
+    reader.eval()
+    return np.concatenate(
+        [
+            reader(torch.as_tensor(inputs[start : start + batch_size], device=device)).cpu().numpy()
+            for start in range(0, len(inputs), batch_size)
+        ]
+    )
+
+
+def accuracy(pred, target, mask=None):
+    correct = pred == target
+    if mask is not None:
+        correct = correct[mask]
+    return float(correct.mean()) if len(correct) else None
+
+
+def score_logits(logits, world, keys, mapping_name):
+    """Full-pool scores and explicitly labelled prerequisite/changed subsets."""
+    pred = logits.argmax(-1)
+    mapping = world[f"mapping_{mapping_name}"]
+    y1, y2 = mapping[keys], mapping[mapping[keys]]
+    train = world["train_mask"][keys]
+    a, b = world["mapping_A"], world["mapping_B"]
+    changed = a[a[keys]] != b[b[keys]]
+    n = len(world["train_mask"])
+    # Inputs are arranged as complete n-head repeats; find each actual successor.
+    successor_row = np.arange(len(keys)) // n * n + mapping[keys]
+    assert np.array_equal(keys[successor_row], mapping[keys])
+    known = (pred[:, 0] == y1) & (pred[successor_row, 0] == mapping[mapping[keys]])
+    return {
+        "n": len(keys),
+        "one_hop": accuracy(pred[:, 0], y1),
+        "two_hop": accuracy(pred[:, 1], y2),
+        "two_hop_A_training_heads": accuracy(pred[:, 1], y2, train),
+        "two_hop_A_heldout_heads": accuracy(pred[:, 1], y2, ~train),
+        "two_hop_changed": accuracy(pred[:, 1], y2, changed),
+        "changed_n": int(changed.sum()),
+        "two_hop_both_atoms_correct": accuracy(pred[:, 1], y2, known),
+        "both_atoms_correct_n": int(known.sum()),
+        "both_atoms_correct_coverage": float(known.mean()),
+    }
+
+
+def reader_loss(logits, targets, train_mask):
+    return (
+        F.cross_entropy(logits[:, 0], targets[:, 0])
+        + F.cross_entropy(logits[train_mask, 1], targets[train_mask, 1])
+    ) / 2
+
+
+def fit_reader(spec, world, memory, init, device, output_dir):
+    reader = TwoHopReader(spec, world["embeddings"], memory, init, device)
+    path = output_dir / "reader-A.pt"
+    if path.exists():
+        payload = torch.load(path, map_location="cpu", weights_only=True)
+        reader.load_state_dict(payload["state_dict"])
+        return reader.eval(), payload["record"]
+    initial_hash = hash_state(reader, reader_only=True)
+    frozen_before = interface.tensor_hash(
+        {k: p for k, p in reader.named_parameters() if not p.requires_grad}
+    )
+    n = spec["num_entities"]
+    seed = int(world["seed"])
+    train_inputs, _ = make_inputs(spec, spec["reader_steps"], seed + 30000)
+    stream_hash = hashlib.sha256(train_inputs.tobytes()).hexdigest()
+    train_inputs = torch.as_tensor(
+        train_inputs.reshape(-1, n, spec["junk_length"] + 2), device=device
+    )
+    mapping = torch.as_tensor(world["mapping_A"], device=device)
+    targets = torch.stack((mapping[:n], mapping[mapping[:n]]), dim=1)
+    train_mask = torch.as_tensor(world["train_mask"], device=device)
+    eval_inputs, eval_keys = make_inputs(spec, spec["eval_repeats"], seed + 40000)
+    parameters = [p for p in reader.parameters() if p.requires_grad]
+    optimizer = torch.optim.AdamW(
+        parameters, lr=spec["reader_lr"], weight_decay=spec["reader_weight_decay"], foreach=False
+    )
+    curve = []
+    began = time.perf_counter()
+    for step in range(spec["reader_steps"] + 1):
+        if step in spec["reader_nodes"]:
+            logits = evaluate(reader, eval_inputs, device, n)
+            metrics = score_logits(logits, world, eval_keys, "A")
+            curve.append(dict(step=step, seconds=time.perf_counter() - began, **metrics))
+            np.savez_compressed(output_dir / f"reader-node-{step:05d}.npz", logits=logits)
+            torch.save(cpu_state(reader), output_dir / f"reader-node-{step:05d}.pt")
+            write_json(output_dir / "reader-curve.json", curve)
+            print(json.dumps(dict(stage="reader", step=step, **metrics)), flush=True)
+        if step == spec["reader_steps"]:
+            break
+        reader.train()
+        optimizer.zero_grad(set_to_none=True)
+        loss = reader_loss(reader(train_inputs[step]), targets, train_mask)
+        loss.backward()
+        optimizer.step()
+    if device.type == "cuda":
+        torch.cuda.synchronize(device)
+    frozen_after = interface.tensor_hash(
+        {k: p for k, p in reader.named_parameters() if not p.requires_grad}
+    )
+    assert frozen_before == frozen_after, "Frozen facts or embeddings changed"
+    record = dict(
+        initial_hash=initial_hash,
+        final_hash=hash_state(reader, reader_only=True),
+        frozen_hash=frozen_after,
+        stream_hash=stream_hash,
+        steps=spec["reader_steps"],
+        seconds=time.perf_counter() - began,
+        trainable_names=[k for k, p in reader.named_parameters() if p.requires_grad],
+        trainable_parameters=sum(p.numel() for p in parameters),
+        total_parameters=sum(p.numel() for p in reader.parameters()),
+        metrics=curve[-1],
+    )
+    torch.save(dict(state_dict=cpu_state(reader), record=record), path)
+    return reader.eval(), record
+
+
+def run(spec, world_seed, init, arm, output_dir, device):
+    if arm not in ARMS:
+        raise ValueError(arm)
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    device = torch.device(device)
+    torch.set_num_threads(spec["cpu_threads"])
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    if device.type == "cuda":
+        torch.cuda.set_device(device)
+        torch.cuda.reset_peak_memory_stats(device)
+    world = build_world(spec, world_seed)
+    np.savez_compressed(output_dir / "world.npz", **world)
+    write_json(output_dir / "spec.json", spec)
+    audit = data_audit(spec, world)
+    started = time.perf_counter()
+    result = dict(
+        world=world_seed, init=init, arm=arm, spec=spec, data_audit=audit, status="running"
+    )
+    write_json(output_dir / "status.json", result)
+    memory_a, a_record = fit_memory(spec, world, "A", arm, init, device, output_dir)
+    reader, reader_record = fit_reader(spec, world, memory_a, init, device, output_dir)
+    # Replacement fitting happens only after the A reader has finished.
+    memory_b, b_record = fit_memory(spec, world, "B", arm, init, device, output_dir)
+    inputs, keys = make_inputs(spec, spec["eval_repeats"], world_seed + 40000)
+    logits_a = evaluate(reader, inputs, device, spec["num_entities"])
+    non_memory_hash = hash_state(reader, reader_only=True)
+    reader.requires_grad_(False)
+    reader.install(memory_b)
+    logits_b = evaluate(reader, inputs, device, spec["num_entities"])
+    assert hash_state(reader, reader_only=True) == non_memory_hash
+    assert reader.gpt.transformer.h[0].mlp is reader.gpt.transformer.h[1].mlp
+    assert hash_state(memory_b) == b_record["final_hash"]
+    embeddings = torch.as_tensor(world["embeddings"], device=device)
+    with torch.no_grad():
+        memory_arrays = {
+            f"memory_{name}_output": mem(embeddings).cpu().numpy()
+            for name, mem in (("A", memory_a), ("B", memory_b))
+        }
+    np.savez_compressed(
+        output_dir / "endpoints.npz",
+        inputs=inputs,
+        keys=keys,
+        logits_A=logits_a,
+        logits_B=logits_b,
+        **memory_arrays,
+    )
+    # Store a full swapped endpoint to permit a genuinely independent reload.
+    torch.save(dict(state_dict=cpu_state(reader)), output_dir / "reader-B.pt")
+    endpoints = {
+        "A": score_logits(logits_a, world, keys, "A"),
+        "B": score_logits(logits_b, world, keys, "B"),
+        "wrong_A_on_B": score_logits(logits_a, world, keys, "B"),
+    }
+    length, d, h, vocab = (
+        spec["junk_length"] + 2,
+        spec["d_model"],
+        spec["hidden_dim"],
+        len(embeddings),
+    )
+    # Approximate multiply-add FLOPs. Backprop through frozen MLP still costs work.
+    memory_flops = 2 * spec["memory_steps"] * (18 * vocab * d * h + 6 * vocab**2 * d)
+    reader_flops = spec["reader_steps"] * (
+        2
+        * (
+            24 * spec["num_entities"] * length * d**2
+            + 12 * spec["num_entities"] * length**2 * d
+            + 12 * spec["num_entities"] * length * d * h
+        )
+    )
+    result.update(
+        status="complete",
+        memories=dict(A=a_record, B=b_record),
+        reader=reader_record,
+        endpoints=endpoints,
+        assertions=dict(
+            frozen_reader_after_swap=True, shared_memory=True, no_B_reader_training=True
+        ),
+        seconds=time.perf_counter() - started,
+        budget=dict(
+            memory_updates=sum(
+                spec["memory_steps"]
+                for r in (a_record, b_record)
+                if not r.get("reused_checkpoint", False)
+            ),
+            reused_memory_updates=sum(
+                spec["memory_steps"]
+                for r in (a_record, b_record)
+                if r.get("reused_checkpoint", False)
+            ),
+            reader_updates=spec["reader_steps"],
+            atomic_exposures=sum(
+                spec["memory_steps"] * spec["num_entities"]
+                for r in (a_record, b_record)
+                if not r.get("reused_checkpoint", False)
+            ),
+            reader_input_tokens=spec["reader_steps"] * spec["num_entities"] * length,
+            reader_supervised_answers=spec["reader_steps"]
+            * (spec["num_entities"] + int(world["train_mask"].sum())),
+            approximate_matmul_flops=reader_flops
+            + memory_flops
+            * sum(not r.get("reused_checkpoint", False) for r in (a_record, b_record))
+            / 2,
+            peak_gpu_bytes=torch.cuda.max_memory_allocated(device) if device.type == "cuda" else 0,
+        ),
+    )
+    write_json(output_dir / "summary.json", result)
+    write_json(output_dir / "status.json", dict(status="complete", seconds=result["seconds"]))
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/multihop_scaling.py

@@ -0,0 +1,518 @@
+"""Width, composition experience and compute depth in complete causal GPT models.
+
+The data, full-token objective and generation scoring extend ``depth_step``.
+Support arms use nested training paths and identical held-out evaluation pools;
+four independent streams keep atomics and each hop length at 32 draws per step.
+"""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import time
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from . import depth_step
+from .depth_step import (  # noqa: F401 -- public interface reused by checkpoint analysis
+    BOS,
+    DATA_DEFAULTS,
+    ENTITY_OFFSET,
+    EOS,
+    EVALUATION_SPLITS,
+    HOPS,
+    PAD,
+    TRAIN_SPLITS,
+    compare_metrics,
+    compare_predictions,
+    construct,
+    data_digest,
+    evaluate,
+    generate_rows,
+    pack_rows,
+    prompt_rows,
+    truth_path_details,
+)
+from .grok_depth import EpochStream, make_optimizer, utc, write_json
+from .grok_loop_model import flops
+from .latent_scaling import model_digest
+from .storage_composition import FullTokenStep, file_hash
+from .storage_frontier import learning_rate
+
+SUPPORT_LEVELS = (1.0, 4.0)
+ARCHITECTURES = ((2, 1), (4, 1), (1, 2), (1, 4))
+COMMON_SPLITS = ("atomic",) + tuple(
+    f"{split}_{hop}" for hop in HOPS for split in ("familiar", "strict")
+)
+SOURCE_FILES = [
+    *depth_step.SOURCE_FILES,
+    "src/llm_memory_editability/multihop_scaling.py",
+    "scripts/run_multihop_scaling.py",
+    "scripts/execute_multihop_scaling.py",
+    "tests/test_multihop_scaling.py",
+]
+
+
+@lru_cache(maxsize=16)
+def _reference_world(seed, settings):
+    return depth_step.build_world({"world_seed": seed, **dict(settings), "phi": 4.0})
+
+
+def _reference(spec):
+    seed = spec.get("world_seed", spec.get("world"))
+    if seed is None:
+        raise ValueError("A fixed world_seed is required")
+    settings = tuple(
+        (key, spec.get(key, value)) for key, value in DATA_DEFAULTS.items() if key != "phi"
+    )
+    return _reference_world(int(seed), settings)
+
+
+def common_evaluation_digest(world):
+    digest = hashlib.sha256()
+    for name in COMMON_SPLITS:
+        rows = world[name]
+        digest.update(name.encode())
+        digest.update(np.asarray(rows.shape, dtype="<i8").tobytes())
+        digest.update(rows.astype("<i8", copy=False).tobytes())
+    digest.update(json.dumps(world["metadata"]["id_mask"]).encode())
+    return digest.hexdigest()
+
+
+def build_world(spec):
+    phi = float(spec.get("phi", 4.0))
+    if phi not in SUPPORT_LEVELS:
+        raise ValueError("Support phi must be 1 or 4")
+    reference = _reference(spec)
+    world = {name: reference[name].copy() for name in EVALUATION_SPLITS}
+    metadata = copy.deepcopy(reference["metadata"])
+    metadata.pop("dataset_sha256", None)
+    metadata.pop("independent_audit", None)
+    ids = sum(metadata["id_mask"])
+    selections = {}
+    for hop in HOPS:
+        name = f"train_{hop}"
+        count = min(round(phi * ids), len(reference[name]))
+        world[name] = reference[name][:count].copy()
+        selections[str(hop)] = {
+            "requested": round(phi * ids),
+            "actual": count,
+            "effective_phi": count / ids if ids else None,
+            "high_support_count": len(reference[name]),
+            "capped": round(phi * ids) > len(reference[name]),
+            "prefix_indices": list(range(count)),
+        }
+    # Preserve source lineage without duplicating descriptive source statistics.
+    metadata["source_worlds"] = {
+        hop: {
+            key: values[key]
+            for key in (
+                "seed",
+                "hops",
+                "dataset_sha256",
+                "counts",
+                "phi_requested",
+                "phi_actual",
+                "train_composite_capped",
+                "id_paths_total",
+                "all_paths_total",
+                "source_url",
+                "source_commit",
+                "source_file",
+                "source_license",
+            )
+        }
+        for hop, values in metadata["source_worlds"].items()
+    }
+    metadata.update(
+        phi=phi,
+        reference_phi=4.0,
+        reference_dataset_sha256=reference["metadata"]["dataset_sha256"],
+        composition_support=selections,
+        support_selection="Prefix of each phi=4 training array; no resampling of facts or tests",
+        exposure_contract="32 atomic + 32 each of 2/3/4-hop examples per step",
+        training_objective="All nonpadding next tokens including EOS; no intermediate targets",
+    )
+    world["metadata"] = metadata
+    metadata["common_evaluation_sha256"] = common_evaluation_digest(world)
+    checked = audit_world(world)
+    metadata["dataset_sha256"] = checked["dataset_sha256"]
+    metadata["independent_audit"] = checked
+    expected = spec.get("frozen_data_sha256")
+    if expected is not None and expected != checked["dataset_sha256"]:
+        raise ValueError("Rebuilt data differ from the frozen specification")
+    expected_common = spec.get("common_evaluation_sha256")
+    if expected_common is not None and expected_common != metadata["common_evaluation_sha256"]:
+        raise ValueError("Common evaluation pools differ from the frozen specification")
+    return world
+
+
+def audit_world(world):
+    checked = depth_step.audit_world(world)
+    metadata = world["metadata"]
+    phi = metadata["phi"]
+    if phi not in SUPPORT_LEVELS or metadata.get("reference_phi") != 4.0:
+        raise ValueError("Invalid nested support contract")
+    reference = _reference(metadata)
+    ids = sum(metadata["id_mask"])
+    for name in EVALUATION_SPLITS:
+        expected = reference[name]
+        if name.startswith("train_"):
+            expected = expected[: min(round(phi * ids), len(expected))]
+        if not np.array_equal(world[name], expected):
+            raise ValueError("Common pools/nested support differ from reference: " + name)
+    common = common_evaluation_digest(world)
+    if common != metadata["common_evaluation_sha256"]:
+        raise ValueError("Common evaluation digest differs")
+    if reference["metadata"]["dataset_sha256"] != metadata["reference_dataset_sha256"]:
+        raise ValueError("High-support reference differs")
+    return {
+        **checked,
+        "low_support_is_high_support_prefix": True,
+        "same_atomic_id_ood_and_heldout_pools_across_support": True,
+        "common_evaluation_sha256": common,
+    }
+
+
+def run_name(spec):
+    seed = spec.get("world_seed", spec.get("world"))
+    return (
+        f"w{seed}-i{spec['initialization']}-d{spec['width']}-phi{spec['phi']:g}"
+        f"-l{spec['layers']}-r{spec['repeats']}-s{spec['steps']}"
+    )
+
+
+def _validate_spec(spec):
+    depth_step._validate_spec(spec)
+    if float(spec["phi"]) not in SUPPORT_LEVELS:
+        raise ValueError("Unsupported composition support")
+    if (spec["layers"], spec["repeats"]) not in ARCHITECTURES:
+        raise ValueError("Unsupported architecture")
+
+
+def _check_source(source):
+    depth_step._check_source(source)
+    required = {"src/llm_memory_editability/multihop_scaling.py", *depth_step.SOURCE_FILES}
+    if not required <= set(source):
+        raise RuntimeError("Source lock omits experiment dependencies")
+
+
+def _validate_output(out):
+    depth_step._validate_output(out)
+
+
+def _device_setup(device):
+    device = torch.device(device)
+    torch.set_num_threads(1)
+    # Standalone workers call this once; CPU integration checks may call twice.
+    try:
+        torch.set_num_interop_threads(1)
+    except RuntimeError:
+        pass
+    if device.type == "cuda":
+        torch.cuda.set_device(device)
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+    return device
+
+
+class _CpuStep:
+    """Same objective and optimizer groups for inexpensive engineering checks."""
+
+    def __init__(self, model, optimizer, table, clip):
+        self.model, self.optimizer, self.table, self.clip = model, optimizer, table, clip
+
+    def __call__(self, indices):
+        self.optimizer.zero_grad(set_to_none=True)
+        tokens, labels = (part[indices] for part in self.table)
+        logits = self.model(tokens)
+        loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True)
+        self.optimizer.step()
+        return loss.detach()
+
+
+def _synchronize(device):
+    if device.type == "cuda":
+        torch.cuda.synchronize(device)
+
+
+def train(spec, out, source, device="cuda:0"):
+    _validate_spec(spec)
+    _check_source(source)
+    if "frozen_data_sha256" not in spec or "common_evaluation_sha256" not in spec:
+        raise ValueError("Training requires frozen data and common evaluation hashes")
+    out = Path(out)
+    _validate_output(out)
+    out.mkdir(parents=True, exist_ok=True)
+    device = _device_setup(device)
+    started_process = time.perf_counter()
+    world = build_world(spec)
+    digest = data_digest(world)
+    depth_step._save_world(out, world)
+    write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest})
+    model = construct(spec, device)
+    initial_digest = model_digest(model)
+    if spec.get("initial_model_sha256", initial_digest) != initial_digest:
+        raise AssertionError("Frozen initialization differs")
+    lr = torch.tensor(spec["lr"], device=device)
+    if device.type == "cuda":
+        optimizer = make_optimizer(model, lr, spec["weight_decay"])
+    else:
+        optimizer = torch.optim.AdamW(
+            [
+                {
+                    "params": [p for p in model.parameters() if p.ndim >= 2],
+                    "weight_decay": spec["weight_decay"],
+                },
+                {"params": [p for p in model.parameters() if p.ndim < 2], "weight_decay": 0.0},
+            ],
+            lr=lr,
+            betas=(0.9, 0.999),
+            eps=1e-8,
+        )
+    sizes = [len(world[name]) for name in TRAIN_SPLITS]
+    if any(size == 0 for size in sizes):
+        raise ValueError("Do not reroll a world with an empty sampled training stratum")
+    packed = [
+        pack_rows(world[name], separator=world["metadata"]["separator_token"])
+        for name in TRAIN_SPLITS
+    ]
+    table = tuple(
+        torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True)
+    )
+    offsets = np.cumsum([0, *sizes[:-1]])
+    streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)]
+    counts = [np.zeros(size, dtype=np.int64) for size in sizes]
+    if device.type == "cuda":
+        graph = FullTokenStep(
+            model, optimizer, table, spec["batch_size"], clip=spec.get("clip", 1.0)
+        )
+    else:
+        graph = _CpuStep(model, optimizer, table, spec.get("clip", 1.0))
+    flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 8, output_positions=8)
+    token_step = 32 * sum(int((labels[0] >= 0).sum()) for _, labels in packed)
+    history, step, training_seconds = [], 0, 0.0
+
+    def measure(loss=None):
+        metrics, predictions = evaluate(model, world, device)
+        row = {
+            "step": step,
+            "lr": learning_rate(spec, step) if step else 0.0,
+            "metrics": metrics,
+            "loss": loss,
+            "training_seconds": training_seconds,
+            "estimated_training_flops": step * flop_step,
+            "supervised_tokens": step * token_step,
+            "padded_input_tokens": step * spec["batch_size"] * 8,
+        }
+        history.append(row)
+        write_json(out / "learning.json", history)
+        np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions)
+        np.savez_compressed(
+            out / f"exposures-{step:06d}.npz",
+            **dict(zip(TRAIN_SPLITS, counts, strict=True)),
+        )
+        state = {
+            "spec": spec,
+            "step": step,
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "streams": [s.state_dict() for s in streams],
+            "counts": counts,
+            "cpu_rng": torch.get_rng_state(),
+            "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None,
+            "source": source,
+            "data_sha256": digest,
+        }
+        torch.save(state, out / "latest.tmp.pt")
+        (out / "latest.tmp.pt").replace(out / "latest.pt")
+        if step in spec["checkpoint_nodes"]:
+            torch.save(
+                {"spec": spec, "step": step, "model": model.state_dict()},
+                out / f"model-{step:06d}.pt",
+            )
+        write_json(out / "status.json", {"step": step, "budget": spec["steps"]})
+        print(
+            json.dumps(
+                {
+                    "run": run_name(spec),
+                    "step": step,
+                    "atomic": metrics["atomic"]["accuracy"],
+                    "familiar": {str(hop): metrics[f"familiar_{hop}"]["accuracy"] for hop in HOPS},
+                }
+            ),
+            flush=True,
+        )
+        return row
+
+    measure()
+    endpoint = history[0]
+    for end in spec["nodes"][1:]:
+        _synchronize(device)
+        started = time.perf_counter()
+        while step < end:
+            updates = min(128, end - step)
+            indices = []
+            for i, stream in enumerate(streams):
+                draws = stream.take(updates * 32).reshape(updates, 32)
+                counts[i] += np.bincount(draws.ravel(), minlength=sizes[i])
+                indices.append(draws + offsets[i])
+            indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device)
+            for j in range(updates):
+                lr.fill_(learning_rate(spec, step + j + 1))
+                loss = graph(indices[j])
+            step += updates
+        _synchronize(device)
+        training_seconds += time.perf_counter() - started
+        loss_value = float(loss)
+        if not np.isfinite(loss_value):
+            raise FloatingPointError("Nonfinite loss at step " + str(step))
+        endpoint = measure(loss_value)
+    np.savez_compressed(out / "exposures.npz", **dict(zip(TRAIN_SPLITS, counts, strict=True)))
+    result = {
+        "spec": spec,
+        "source": source,
+        "data_sha256": digest,
+        "common_evaluation_sha256": world["metadata"]["common_evaluation_sha256"],
+        "initial_model_sha256": initial_digest,
+        "checkpoint_sha256": file_hash(out / "latest.pt"),
+        "finished_utc": utc(),
+        "parameters": sum(p.numel() for p in model.parameters()),
+        "architecture": "loop" if spec["repeats"] > 1 else "standard",
+        "effective_depth": spec["layers"] * spec["repeats"],
+        "strata_counts": dict(zip(TRAIN_SPLITS, sizes, strict=True)),
+        "endpoint": endpoint,
+        "supervised_tokens": step * token_step,
+        "padded_input_tokens": step * spec["batch_size"] * 8,
+        "estimated_training_flops": step * flop_step,
+        "training_seconds": training_seconds,
+        "process_seconds": time.perf_counter() - started_process,
+        "environment": {
+            "torch": torch.__version__,
+            "numpy": np.__version__,
+            "cuda": torch.version.cuda,
+            "device": str(device),
+            "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None,
+            "tf32": device.type == "cuda",
+        },
+    }
+    write_json(out / "complete.json", result)
+    return result
+
+
+def audit(out, device="cuda:0"):
+    out = Path(out)
+    if (out / "audit.json").exists():
+        raise FileExistsError(out / "audit.json")
+    device = _device_setup(device)
+    result = json.loads((out / "complete.json").read_text())
+    recorded = json.loads((out / "spec.json").read_text())
+    source, spec = result["source"], result["spec"]
+    _check_source(source)
+    _validate_spec(spec)
+    if recorded["spec"] != spec or recorded["source"] != source:
+        raise AssertionError("Recorded specification/source differ")
+    if file_hash(out / "latest.pt") != result["checkpoint_sha256"]:
+        raise AssertionError("Latest checkpoint hash differs")
+    world = build_world(spec)
+    digest = data_digest(world)
+    if digest != result["data_sha256"] or digest != recorded["data_sha256"]:
+        raise AssertionError("Rebuilt data differ from records")
+    if result["common_evaluation_sha256"] != common_evaluation_digest(world):
+        raise AssertionError("Common evaluation identity differs")
+    if json.loads((out / "world-metadata.json").read_text()) != world["metadata"]:
+        raise AssertionError("Archived world metadata differ")
+    with np.load(out / "world.npz") as archived:
+        if set(archived.files) != set(EVALUATION_SPLITS):
+            raise AssertionError("Archived world keys differ")
+        for name in EVALUATION_SPLITS:
+            np.testing.assert_array_equal(archived[name], world[name])
+    model = construct(spec, device)
+    if model_digest(model) != result["initial_model_sha256"]:
+        raise AssertionError("Paired initialization differs")
+    history = json.loads((out / "learning.json").read_text())
+    if [row["step"] for row in history] != spec["nodes"]:
+        raise AssertionError("Recorded learning nodes differ")
+    by_node = {row["step"]: row for row in history}
+    if by_node[spec["steps"]] != result["endpoint"]:
+        raise AssertionError("Endpoint differs from the learning curve")
+    maximum = 0.0
+    for node in spec["checkpoint_nodes"]:
+        checkpoint = torch.load(
+            out / f"model-{node:06d}.pt", map_location=device, weights_only=False
+        )
+        if checkpoint["spec"] != spec or checkpoint["step"] != node:
+            raise AssertionError("Checkpoint specification/node differ")
+        model.load_state_dict(checkpoint["model"])
+        metrics, predictions = evaluate(model, world, device)
+        compare_metrics(metrics, by_node[node]["metrics"])
+        maximum = max(
+            maximum, compare_predictions(predictions, out / f"predictions-{node:06d}.npz")
+        )
+    saved = torch.load(out / "latest.pt", map_location=device, weights_only=False)
+    if (
+        saved["spec"] != spec
+        or saved["source"] != source
+        or saved["step"] != spec["steps"]
+        or saved["data_sha256"] != digest
+    ):
+        raise AssertionError("Latest state identity differs")
+    sizes = [len(world[name]) for name in TRAIN_SPLITS]
+    streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)]
+    counts = [np.zeros(size, dtype=np.int64) for size in sizes]
+    previous = 0
+    for node in spec["nodes"]:
+        for i, stream in enumerate(streams):
+            draws = (
+                stream.take((node - previous) * 32)
+                if node > previous
+                else np.empty(0, dtype=np.int64)
+            )
+            counts[i] += np.bincount(draws, minlength=sizes[i])
+        with np.load(out / f"exposures-{node:06d}.npz") as actual:
+            if set(actual.files) != set(TRAIN_SPLITS):
+                raise AssertionError("Exposure strata differ")
+            for name, count in zip(TRAIN_SPLITS, counts, strict=True):
+                np.testing.assert_array_equal(actual[name], count)
+        row = by_node[node]
+        if row["supervised_tokens"] != node * 832 or row["padded_input_tokens"] != node * 1024:
+            raise AssertionError("Token accounting differs")
+        previous = node
+    with np.load(out / "exposures.npz") as actual:
+        for i, (name, count) in enumerate(zip(TRAIN_SPLITS, counts, strict=True)):
+            np.testing.assert_array_equal(actual[name], count)
+            np.testing.assert_array_equal(saved["counts"][i], count)
+            if count.sum() != spec["steps"] * 32 or np.ptp(count) > 1:
+                raise AssertionError("EpochStream actual exposures are unbalanced")
+            stream = EpochStream(sizes[i], spec["stream_seed"] + i)
+            stream.load_state_dict(saved["streams"][i])
+            np.testing.assert_array_equal(stream.take(32), streams[i].take(32))
+    model.load_state_dict(saved["model"])
+    metrics, predictions = evaluate(model, world, device)
+    compare_metrics(metrics, result["endpoint"]["metrics"])
+    maximum = max(
+        maximum, compare_predictions(predictions, out / f"predictions-{spec['steps']:06d}.npz")
+    )
+    checked = {
+        "passed": True,
+        "dataset_rebuilt_and_archived_exact": True,
+        "nested_support_and_common_pools_checked": True,
+        "initial_model_exact": True,
+        "checkpoint_nodes": spec["checkpoint_nodes"],
+        "endpoint_tokens_exact": True,
+        "all_nodes_exposure_counters_exact": True,
+        "stream_state_continuation_exact": True,
+        "max_nll_difference": maximum,
+        "nll_rtol": 1e-5,
+        "nll_atol": 1e-5,
+        "utc": utc(),
+    }
+    write_json(out / "audit.json", checked)
+    return checked

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation.py

@@ -0,0 +1,687 @@
+"""Full-Qwen, nested compositional support with matched atomic supervision."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import platform
+import shutil
+import time
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from . import small_lm_composition as base
+
+FIRST = ("mentor", "advisor")
+SECOND = ("live", "birth")
+STRICT_CITIES = (
+    "Athens Prague Havana Tunis Perth Zurich Bristol Munich "
+    "Tallinn Riga Quito Dakar Nairobi Accra Calgary Warsaw"
+).split()
+ROOT = Path("docs/development-artifacts/natural-composition-confirmation-v1")
+
+
+def sha(path):
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def write(path, value):
+    base.write(path, value)
+
+
+def build_world(seed):
+    rng = np.random.default_rng(seed)
+    first_names = (
+        "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo"
+    ).split()
+    names = [
+        f"{a} {b}"
+        for a in first_names
+        for b in "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split()
+    ]
+    names = rng.permutation(names).tolist()
+    atoms, chains = [], []
+    for pool, offset, cities in (("familiar", 0, base.CITIES), ("strict", 32, STRICT_CITIES)):
+        heads, bridges = names[offset : offset + 16], names[offset + 16 : offset + 32]
+        mappings = [rng.permutation(16).tolist()]
+        mappings.append(np.roll(mappings[0], int(rng.integers(1, 16))).tolist())
+        city_maps = [rng.permutation(cities).tolist()]
+        city_maps.append(np.roll(city_maps[0], int(rng.integers(1, 16))).tolist())
+        ids = {}
+        for j, head in enumerate(heads):
+            for r, relation in enumerate(FIRST):
+                atom = dict(
+                    id=len(atoms),
+                    pool=pool,
+                    role="first",
+                    subject=head,
+                    relation=relation,
+                    answer=bridges[mappings[r][j]],
+                )
+                atoms.append(atom)
+                ids["first", j, r] = atom["id"]
+        for j, bridge in enumerate(bridges):
+            for s, relation in enumerate(SECOND):
+                atom = dict(
+                    id=len(atoms),
+                    pool=pool,
+                    role="second",
+                    subject=bridge,
+                    relation=relation,
+                    answer=city_maps[s][j],
+                )
+                atoms.append(atom)
+                ids["second", j, s] = atom["id"]
+        for j, head in enumerate(heads):
+            for r, first in enumerate(FIRST):
+                for s, second in enumerate(SECOND):
+                    bridge_index = mappings[r][j]
+                    chains.append(
+                        dict(
+                            id=len(chains),
+                            pool=pool,
+                            head_index=j,
+                            head=head,
+                            bridge=bridges[bridge_index],
+                            first=first,
+                            second=second,
+                            answer=city_maps[s][bridge_index],
+                            atom_ids=[ids["first", j, r], ids["second", bridge_index, s]],
+                            split="strict"
+                            if pool == "strict"
+                            else ("support" if r == s else "heldout"),
+                        )
+                    )
+    return dict(
+        seed=seed,
+        atoms=atoms,
+        chains=chains,
+        high_support=[c["id"] for c in chains if c["split"] == "support"],
+        low_support=[c["id"] for c in chains if c["split"] == "support" and c["head_index"] < 4],
+    )
+
+
+def question(row, variant=0, atomic=False):
+    if atomic:
+        subject, relation = row["subject"], row["relation"]
+        if row["role"] == "first":
+            templates = (
+                "Who is {subject}'s {relation}?",
+                "Who is the {relation} of {subject}?",
+                "Name the {relation} of {subject}.",
+                "Give the name of {subject}'s {relation}.",
+                "Give the name of the person serving as {subject}'s {relation}.",
+            )
+        elif relation == "live":
+            templates = (
+                "Which city does {subject} live in?",
+                "What city is {subject}'s home?",
+                "Where does {subject} live?",
+                "Name the city where {subject} lives.",
+                "In which city is {subject} living?",
+            )
+        else:
+            templates = (
+                "Which city was {subject} born in?",
+                "What is {subject}'s birth city?",
+                "Where was {subject} born?",
+                "Name the city where {subject} was born.",
+                "In which city did {subject}'s birth take place?",
+            )
+        return templates[variant].format(subject=subject, relation=relation)
+    subject = row["head"]
+    relation = row["first"]
+    if row["second"] == "live":
+        templates = (
+            "Which city does {subject}'s {relation} live in?",
+            "What city is home to {subject}'s {relation}?",
+            "Where does the {relation} of {subject} live?",
+            "Name the city where {subject}'s {relation} lives.",
+            "In which city is the person serving as {subject}'s {relation} living?",
+        )
+    else:
+        templates = (
+            "Which city was {subject}'s {relation} born in?",
+            "What is the birth city of {subject}'s {relation}?",
+            "Where was the {relation} of {subject} born?",
+            "Name the city where {subject}'s {relation} was born.",
+            "In which city did the birth of {subject}'s {relation} take place?",
+        )
+    return templates[variant].format(subject=subject, relation=relation)
+
+
+def prompt(row, variant=0, atomic=False):
+    return "Fictional registry.\nQuestion: " + question(row, variant, atomic) + "\nAnswer:"
+
+
+def record(tokenizer, row, variant, atomic):
+    # Joint text tokenization, exactly as in the calibrated full-Qwen v2 recipe.
+    ids = tokenizer.encode(
+        prompt(row, variant, atomic) + " " + row["answer"] + ".", add_special_tokens=False
+    ) + [tokenizer.eos_token_id]
+    return dict(
+        ids=ids,
+        labels=[-100, *ids[1:]],
+        id=row["id"],
+        kind="atomic" if atomic else "composition",
+        variant=variant,
+    )
+
+
+def streams(world, cfg):
+    rng = np.random.default_rng(cfg["training_seed"])
+    atomic_order, comp_order = [], {a: [] for a in cfg["arms"]}
+    batches = {a: [] for a in cfg["arms"]}
+    for _ in range(cfg["steps"]):
+        if len(atomic_order) < cfg["atomic_per_step"]:
+            atomic_order.extend(rng.permutation(len(world["atoms"])).tolist())
+        atomic = [
+            [int(atomic_order.pop(0)), int(rng.integers(4))] for _ in range(cfg["atomic_per_step"])
+        ]
+        variants = rng.integers(4, size=cfg["compositions_per_step"]).tolist()
+        for arm in cfg["arms"]:
+            support = world[arm + "_support"]
+            if len(comp_order[arm]) < cfg["compositions_per_step"]:
+                comp_order[arm].extend(rng.permutation(support).tolist())
+            comp = [[int(comp_order[arm].pop(0)), int(v)] for v in variants]
+            batches[arm].append(dict(atomic=atomic, composition=comp))
+    return batches
+
+
+def records(tokenizer, world):
+    return {
+        kind: {
+            (r["id"], v): record(tokenizer, r, v, kind == "atomic")
+            for r in world["atoms" if kind == "atomic" else "chains"]
+            for v in range(4)
+        }
+        for kind in ("atomic", "composition")
+    }
+
+
+def docs_for(rec, batch):
+    return [rec[kind][tuple(spec)] for kind in ("atomic", "composition") for spec in batch[kind]]
+
+
+def audit(world, batches, rec):
+    assert (
+        len(world["atoms"]) == 128
+        and len(world["high_support"]) == 32
+        and len(world["low_support"]) == 8
+    )
+    assert set(world["low_support"]) < set(world["high_support"])
+    familiar_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "familiar"}
+    covered = {i for j in world["high_support"] for i in world["chains"][j]["atom_ids"]}
+    assert covered == familiar_atoms
+    strict_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "strict"}
+    assert not covered & strict_atoms
+    support = [world["chains"][i] for i in world["high_support"]]
+    heldout = [c for c in world["chains"] if c["split"] == "heldout"]
+    strict = [c for c in world["chains"] if c["split"] == "strict"]
+    assert len(heldout) == 32 and len(strict) == 64
+    # No alternate trained query gives the same head/answer endpoint as a held-out chain.
+    assert not {(c["head"], c["answer"]) for c in support} & {
+        (c["head"], c["answer"]) for c in heldout
+    }
+
+    def people(pool):
+        return {a["subject"] for a in world["atoms"] if a["pool"] == pool}
+
+    assert not people("familiar") & people("strict")
+    assert not {c["answer"] for c in support} & {c["answer"] for c in strict}
+    budgets, exposure = {}, {}
+    for arm, stream in batches.items():
+        budget, atomic_counts, comp_counts = Counter(), Counter(), Counter()
+        for batch in stream:
+            docs = docs_for(rec, batch)
+            width = max(len(d["ids"]) for d in docs)
+            budget.update(
+                input_tokens=sum(len(d["ids"]) for d in docs),
+                supervised_tokens=sum(len(d["ids"]) - 1 for d in docs),
+                padded_tokens=len(docs) * width,
+                attention_cells=len(docs) * width**2,
+            )
+            atomic_counts.update(i for i, _ in batch["atomic"])
+            comp_counts.update(i for i, _ in batch["composition"])
+            assert set(comp_counts) <= set(world[arm + "_support"])
+        budgets[arm] = dict(budget)
+        exposure[arm] = dict(
+            atomic=sorted(atomic_counts.items()), composition=sorted(comp_counts.items())
+        )
+    if "low" in batches and "high" in batches:
+        assert [b["atomic"] for b in batches["low"]] == [b["atomic"] for b in batches["high"]]
+        assert exposure["low"]["atomic"] == exposure["high"]["atomic"]
+    return dict(
+        status="passed",
+        budgets=budgets,
+        exposures=exposure,
+        familiar_fact_role_coverage_high=len(covered),
+        familiar_fact_role_coverage_low=len(
+            {i for j in world["low_support"] for i in world["chains"][j]["atom_ids"]}
+        ),
+        heldout_queries=len(heldout),
+        strict_queries=len(strict),
+        target_endpoint_leakage=0,
+        exact_common_atomic_sequence=True,
+        exact_atomic_stream_loss_weight=True,
+        composition_slots_equal=True,
+    )
+
+
+def freeze(config_path):
+    cfg = base.read(config_path)
+    art = Path(cfg["artifact_root"])
+    assert not (art / "lock.json").exists(), "Preserve frozen batch."
+    tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True)
+    sources = [
+        str(config_path),
+        "src/llm_memory_editability/natural_composition_confirmation.py",
+        "src/llm_memory_editability/small_lm_composition.py",
+        "scripts/run_natural_composition_confirmation.py",
+        "tests/test_natural_composition_confirmation.py",
+        "docs/development-artifacts/natural-composition-confirmation-v1/design.md",
+    ]
+    source_hashes = {}
+    for source in sources:
+        dest = art / "source" / source
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(source, dest)
+        source_hashes[source] = sha(source)
+    data_files = {}
+    for seed in cfg["world_seeds"]:
+        world = build_world(seed)
+        batch = streams(world, cfg)
+        report = audit(world, batch, records(tokenizer, world))
+        for filename, obj in (
+            ("world.json", world),
+            ("streams.json", batch),
+            ("data-audit.json", report),
+        ):
+            path = art / f"w{seed}" / filename
+            write(path, obj)
+            data_files[str(path)] = sha(path)
+    model_files = {
+        str(p): sha(p)
+        for p in Path(cfg["model_path"]).iterdir()
+        if p.suffix in (".json", ".safetensors") or p.name in ("LICENSE", "README.md")
+    }
+    write(
+        art / "environment.json",
+        dict(
+            python=platform.python_version(),
+            executable=str(Path(__import__("sys").executable)),
+            torch=torch.__version__,
+            transformers=transformers.__version__,
+            gpu_inventory=__import__("subprocess").check_output(
+                ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total", "--format=csv"],
+                text=True,
+            ),
+        ),
+    )
+    write(
+        art / "lock.json",
+        dict(
+            status="locked_before_training",
+            utc=base.now(),
+            sources=source_hashes,
+            data_files=data_files,
+            model_files=model_files,
+            config=cfg,
+        ),
+    )
+    print(
+        json.dumps(dict(status="frozen", worlds=cfg["world_seeds"], arms=cfg["arms"])), flush=True
+    )
+
+
+def check_lock(cfg):
+    lock = base.read(Path(cfg["artifact_root"]) / "lock.json")
+    for group in ("sources", "data_files", "model_files"):
+        for path, digest in lock[group].items():
+            assert sha(path) == digest, path
+
+
+def evaluation_rows(world, extras=False):
+    rows = []
+    for view in (0, 4) if extras else (0,):
+        for atom in world["atoms"]:
+            rows.append(dict(atom, mode="atomic", view=view, prompt=prompt(atom, view, True)))
+        for chain in world["chains"]:
+            rows.append(dict(chain, mode="direct", view=view, prompt=prompt(chain, view)))
+    return rows
+
+
+@torch.inference_mode()
+def generate(model, tokenizer, rows, cfg):
+    model.eval()
+    tokenizer.padding_side = "left"
+    output = []
+    for start in range(0, len(rows), cfg["eval_batch"]):
+        chunk = rows[start : start + cfg["eval_batch"]]
+        inputs = tokenizer(
+            [r["prompt"] for r in chunk],
+            padding=True,
+            return_tensors="pt",
+            add_special_tokens=False,
+        ).to(cfg["device"])
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            tokens = model.generate(
+                **inputs,
+                do_sample=False,
+                max_new_tokens=cfg["max_new_tokens"],
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                use_cache=True,
+            )[:, inputs.input_ids.shape[1] :]
+        for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True):
+            if tokenizer.eos_token_id in tok:
+                tok = tok[: tok.index(tokenizer.eos_token_id) + 1]
+            text = tokenizer.decode(tok, skip_special_tokens=True)
+            output.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"])))
+    return output
+
+
+def evaluate(model, tokenizer, world, cfg, extras=False):
+    direct = generate(model, tokenizer, evaluation_rows(world, extras), cfg)
+    if not extras:
+        return direct
+    atoms = {a["id"]: a for a in world["atoms"]}
+    lookup = {(r["id"], r["view"]): r for r in direct if r["mode"] == "atomic"}
+    second_calls = []
+    for row in direct:
+        if row["mode"] != "direct":
+            continue
+        first = lookup[row["atom_ids"][0], row["view"]]
+        generated_bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip()
+        second = dict(atoms[row["atom_ids"][1]], subject=generated_bridge)
+        second_calls.append(
+            dict(
+                row,
+                mode="autonomous",
+                prompt=prompt(second, row["view"], True),
+                generated_bridge=generated_bridge,
+                first_tokens=first["tokens"],
+                first_correct=first["correct"],
+            )
+        )
+    return direct + generate(model, tokenizer, second_calls, cfg)
+
+
+def metrics(rows, world, arm):
+    result = {}
+    for view in sorted({r["view"] for r in rows}):
+        atomic = {r["id"]: r for r in rows if r["view"] == view and r["mode"] == "atomic"}
+        for pool in ("familiar", "strict"):
+            for role in ("first", "second"):
+                selected = [r for r in atomic.values() if r["pool"] == pool and r["role"] == role]
+                result[f"v{view}_{pool}_{role}"] = dict(
+                    correct=sum(r["correct"] for r in selected), n=len(selected)
+                )
+        for split in ("heldout", "strict", "training"):
+            ids = (
+                set(world[arm + "_support"])
+                if split == "training"
+                else {c["id"] for c in world["chains"] if c["split"] == split}
+            )
+            for mode in ("direct", "autonomous"):
+                selected = [
+                    r for r in rows if r["view"] == view and r["mode"] == mode and r["id"] in ids
+                ]
+                if selected:
+                    result[f"v{view}_{split}_{mode}"] = dict(
+                        correct=sum(r["correct"] for r in selected), n=len(selected)
+                    )
+                    mastered = [
+                        r for r in selected if all(atomic[i]["correct"] for i in r["atom_ids"])
+                    ]
+                    result[f"v{view}_{split}_{mode}_both_atomic"] = dict(
+                        correct=sum(r["correct"] for r in mastered),
+                        n=len(mastered),
+                        full_n=len(selected),
+                    )
+    return result
+
+
+def stream_loss(model, inputs, atomic_count, atomic_weight):
+    logits = model(
+        input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], use_cache=False
+    ).logits[:, :-1]
+    labels = inputs["labels"][:, 1:]
+    losses = F.cross_entropy(
+        logits.float().reshape(-1, logits.shape[-1]),
+        labels.reshape(-1),
+        reduction="none",
+        ignore_index=-100,
+    ).reshape_as(labels)
+    atomic = losses[:atomic_count].sum() / (labels[:atomic_count] != -100).sum()
+    comp = losses[atomic_count:].sum() / (labels[atomic_count:] != -100).sum()
+    return atomic_weight * atomic + (1 - atomic_weight) * comp
+
+
+def run(config_path, seed, arm):
+    cfg = base.read(config_path)
+    check_lock(cfg)
+    assert seed in cfg["world_seeds"] and arm in cfg["arms"]
+    art = Path(cfg["artifact_root"]) / f"w{seed}"
+    out = Path(cfg["output_root"]) / f"w{seed}-{arm}"
+    assert not (out / "status.json").exists(), "Preserve existing execution."
+    world, batches = base.read(art / "world.json"), base.read(art / "streams.json")[arm]
+    write(out / "status.json", dict(status="running", utc=base.now()))
+    started = time.perf_counter()
+    torch.set_num_threads(cfg["cpu_threads"])
+    torch.manual_seed(cfg["training_seed"])
+    torch.cuda.set_device(cfg["device"])
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    torch.cuda.reset_peak_memory_stats()
+    tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    def load(path):
+        return AutoModelForCausalLM.from_pretrained(
+            path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True
+        ).to(cfg["device"])
+
+    model = load(cfg["model_path"])
+    assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024
+    assert len({id(layer.mlp) for layer in model.model.layers}) == 28
+    model.requires_grad_(True)
+    samples = base.parameter_samples(model)
+    parameter_count = sum(p.numel() for p in model.parameters())
+    rec = records(tokenizer, world)
+    optimizer = torch.optim.AdamW(
+        model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"], fused=True
+    )
+    curve, budget, train_seconds = [], Counter(), 0.0
+    for step in range(cfg["steps"] + 1):
+        if step in cfg["nodes"]:
+            rows = evaluate(model, tokenizer, world, cfg, extras=step == cfg["steps"])
+            write(out / f"predictions-{step:05d}.json", rows)
+            point = dict(step=step, metrics=metrics(rows, world, arm))
+            curve.append(point)
+            write(out / "curve.json", curve)
+            print(json.dumps(dict(seed=seed, arm=arm, **point)), flush=True)
+        if step == cfg["steps"]:
+            break
+        decay = 0.5 * (
+            1
+            + math.cos(
+                math.pi * max(0, step - cfg["warmup_steps"]) / (cfg["steps"] - cfg["warmup_steps"])
+            )
+        )
+        lr = (
+            cfg["minimum_learning_rate"]
+            + (cfg["learning_rate"] - cfg["minimum_learning_rate"]) * decay
+        ) * min(1.0, (step + 1) / cfg["warmup_steps"])
+        for group in optimizer.param_groups:
+            group["lr"] = lr
+        docs = docs_for(rec, batches[step])
+        width = max(len(d["ids"]) for d in docs)
+        budget.update(
+            input_tokens=sum(len(d["ids"]) for d in docs),
+            supervised_tokens=sum(len(d["ids"]) - 1 for d in docs),
+            padded_tokens=len(docs) * width,
+            attention_cells=len(docs) * width**2,
+        )
+        inputs = base.batch_tensors(docs, tokenizer.pad_token_id, cfg["device"])
+        model.train()
+        torch.cuda.synchronize()
+        tick = time.perf_counter()
+        optimizer.zero_grad(set_to_none=True)
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            loss = stream_loss(model, inputs, cfg["atomic_per_step"], cfg["atomic_loss_weight"])
+        assert torch.isfinite(loss)
+        loss.backward()
+        if step == 0:
+            assert all(
+                p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all()
+                for p in model.parameters()
+            )
+        torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"])
+        optimizer.step()
+        torch.cuda.synchronize()
+        train_seconds += time.perf_counter() - tick
+        if (step + 1) % 64 == 0:
+            print(
+                json.dumps(
+                    dict(
+                        seed=seed,
+                        arm=arm,
+                        step=step + 1,
+                        loss=float(loss.detach()),
+                        train_seconds=train_seconds,
+                    )
+                ),
+                flush=True,
+            )
+    changed = {
+        name: not torch.equal(before, base.parameter_samples(model)[name])
+        for name, before in samples.items()
+    }
+    assert all(changed.values())
+    model.save_pretrained(out / "model", safe_serialization=True)
+    tokenizer.save_pretrained(out / "model")
+    architecture = model.config.to_dict()
+    final_rows = rows
+    del optimizer, model, samples, inputs, loss
+    torch.cuda.empty_cache()
+    again = evaluate(load(out / "model"), tokenizer, world, cfg, extras=True)
+    assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again]
+    assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again]
+    write(
+        out / "reload-audit.json",
+        dict(
+            status="passed",
+            predictions=len(again),
+            exact_generated_tokens=True,
+            exact_autonomous_prompts=True,
+        ),
+    )
+    assert dict(budget) == base.read(art / "data-audit.json")["budgets"][arm]
+    d, layers = architecture["hidden_size"], architecture["num_hidden_layers"]
+    query_width = architecture["num_attention_heads"] * architecture["head_dim"]
+    kv = architecture["num_key_value_heads"] * architecture["head_dim"]
+    per_token = (
+        layers * (2 * d * query_width + 2 * d * kv + 3 * d * architecture["intermediate_size"])
+        + d * architecture["vocab_size"]
+    )
+    flops = (
+        6 * per_token * budget["padded_tokens"]
+        + 12 * layers * query_width * budget["attention_cells"]
+    )
+    summary = dict(
+        status="complete",
+        phase=cfg["phase"],
+        utc=base.now(),
+        world_seed=seed,
+        arm=arm,
+        metrics=metrics(final_rows, world, arm),
+        updates=cfg["steps"],
+        budget=dict(budget),
+        train_seconds=train_seconds,
+        process_seconds=time.perf_counter() - started,
+        estimated_training_matrix_flops=flops,
+        peak_gpu_bytes=torch.cuda.max_memory_allocated(),
+        parameter_count=parameter_count,
+        sampled_parameters_changed=changed,
+        torch_version=torch.__version__,
+        transformers_version=transformers.__version__,
+        gpu=torch.cuda.get_device_name(),
+        tf32=False,
+        lock_sha256=sha(Path(cfg["artifact_root"]) / "lock.json"),
+        checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")},
+    )
+    write(out / "summary.json", summary)
+    write(out / "status.json", dict(status="complete", utc=base.now()))
+    print(json.dumps(summary), flush=True)
+
+
+def report(config_path):
+    cfg = base.read(config_path)
+    check_lock(cfg)
+    runs, checks = {}, 0
+    for seed in cfg["world_seeds"]:
+        world = base.read(Path(cfg["artifact_root"]) / f"w{seed}" / "world.json")
+        for arm in cfg["arms"]:
+            out = Path(cfg["output_root"]) / f"w{seed}-{arm}"
+            summary = base.read(out / "summary.json")
+            assert base.read(out / "reload-audit.json")["status"] == "passed"
+            for point in base.read(out / "curve.json"):
+                rows = base.read(out / f"predictions-{point['step']:05d}.json")
+                assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows)
+                assert point["metrics"] == metrics(rows, world, arm)
+                checks += len(rows)
+            assert summary["metrics"] == metrics(rows, world, arm)
+            runs[f"w{seed}-{arm}"] = summary
+    differences = {}
+    if len(cfg["arms"]) == 2:
+        for seed in cfg["world_seeds"]:
+            diff = {}
+            for key in runs[f"w{seed}-high"]["metrics"]:
+                high, low = [runs[f"w{seed}-{a}"]["metrics"][key] for a in ("high", "low")]
+                if key.endswith("both_atomic") or "training" in key:
+                    continue
+                diff[key] = high["correct"] / high["n"] - low["correct"] / low["n"]
+            differences[str(seed)] = diff
+    write(
+        Path(cfg["artifact_root"]) / "summary.json",
+        dict(
+            status="complete",
+            phase=cfg["phase"],
+            independent_worlds=len(cfg["world_seeds"]),
+            training_initializations=1,
+            runs=runs,
+            per_world_high_minus_low=differences,
+            independent_node_prediction_checks=checks,
+            total_updates=sum(r["updates"] for r in runs.values()),
+            total_train_seconds=sum(r["train_seconds"] for r in runs.values()),
+            total_process_seconds=sum(r["process_seconds"] for r in runs.values()),
+        ),
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=("freeze", "run", "report"))
+    parser.add_argument("--config", required=True)
+    parser.add_argument("--world", type=int)
+    parser.add_argument("--arm", choices=("low", "high"))
+    args = parser.parse_args()
+    if args.action == "run":
+        run(args.config, args.world, args.arm)
+    elif args.action == "freeze":
+        freeze(args.config)
+    else:
+        report(args.config)

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py

@@ -0,0 +1,687 @@
+"""Full-Qwen, nested compositional support with matched atomic supervision."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import platform
+import shutil
+import time
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from . import small_lm_composition as base
+
+FIRST = ("mentor", "advisor")
+SECOND = ("live", "birth")
+STRICT_CITIES = (
+    "Athens Prague Havana Tunis Perth Zurich Bristol Munich "
+    "Tallinn Riga Quito Dakar Nairobi Accra Calgary Warsaw"
+).split()
+ROOT = Path("docs/development-artifacts/natural-composition-confirmation-v1")
+
+
+def sha(path):
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def write(path, value):
+    base.write(path, value)
+
+
+def build_world(seed):
+    rng = np.random.default_rng(seed)
+    first_names = (
+        "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo"
+    ).split()
+    names = [
+        f"{a} {b}"
+        for a in first_names
+        for b in "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split()
+    ]
+    names = rng.permutation(names).tolist()
+    atoms, chains = [], []
+    for pool, offset, cities in (("familiar", 0, base.CITIES), ("strict", 32, STRICT_CITIES)):
+        heads, bridges = names[offset : offset + 16], names[offset + 16 : offset + 32]
+        mappings = [rng.permutation(16).tolist()]
+        mappings.append(np.roll(mappings[0], int(rng.choice(np.arange(2, 16, 2)))).tolist())
+        city_maps = [rng.permutation(cities).tolist()]
+        city_maps.append(np.roll(city_maps[0], int(rng.integers(1, 16))).tolist())
+        ids = {}
+        for j, head in enumerate(heads):
+            for r, relation in enumerate(FIRST):
+                atom = dict(
+                    id=len(atoms),
+                    pool=pool,
+                    role="first",
+                    subject=head,
+                    relation=relation,
+                    answer=bridges[mappings[r][j]],
+                )
+                atoms.append(atom)
+                ids["first", j, r] = atom["id"]
+        for j, bridge in enumerate(bridges):
+            for s, relation in enumerate(SECOND):
+                atom = dict(
+                    id=len(atoms),
+                    pool=pool,
+                    role="second",
+                    subject=bridge,
+                    relation=relation,
+                    answer=city_maps[s][j],
+                )
+                atoms.append(atom)
+                ids["second", j, s] = atom["id"]
+        for j, head in enumerate(heads):
+            for r, first in enumerate(FIRST):
+                for s, second in enumerate(SECOND):
+                    bridge_index = mappings[r][j]
+                    chains.append(
+                        dict(
+                            id=len(chains),
+                            pool=pool,
+                            head_index=j,
+                            head=head,
+                            bridge=bridges[bridge_index],
+                            first=first,
+                            second=second,
+                            answer=city_maps[s][bridge_index],
+                            atom_ids=[ids["first", j, r], ids["second", bridge_index, s]],
+                            split="strict"
+                            if pool == "strict"
+                            else ("support" if s == (r ^ (j % 2)) else "heldout"),
+                        )
+                    )
+    return dict(
+        seed=seed,
+        atoms=atoms,
+        chains=chains,
+        high_support=[c["id"] for c in chains if c["split"] == "support"],
+        low_support=[c["id"] for c in chains if c["split"] == "support" and c["head_index"] < 4],
+    )
+
+
+def question(row, variant=0, atomic=False):
+    if atomic:
+        subject, relation = row["subject"], row["relation"]
+        if row["role"] == "first":
+            templates = (
+                "Who is {subject}'s {relation}?",
+                "Who is the {relation} of {subject}?",
+                "Name the {relation} of {subject}.",
+                "Give the name of {subject}'s {relation}.",
+                "Give the name of the person serving as {subject}'s {relation}.",
+            )
+        elif relation == "live":
+            templates = (
+                "Which city does {subject} live in?",
+                "What city is {subject}'s home?",
+                "Where does {subject} live?",
+                "Name the city where {subject} lives.",
+                "In which city is {subject} living?",
+            )
+        else:
+            templates = (
+                "Which city was {subject} born in?",
+                "What is {subject}'s birth city?",
+                "Where was {subject} born?",
+                "Name the city where {subject} was born.",
+                "In which city did {subject}'s birth take place?",
+            )
+        return templates[variant].format(subject=subject, relation=relation)
+    subject = row["head"]
+    relation = row["first"]
+    if row["second"] == "live":
+        templates = (
+            "Which city does {subject}'s {relation} live in?",
+            "What city is home to {subject}'s {relation}?",
+            "Where does the {relation} of {subject} live?",
+            "Name the city where {subject}'s {relation} lives.",
+            "In which city is the person serving as {subject}'s {relation} living?",
+        )
+    else:
+        templates = (
+            "Which city was {subject}'s {relation} born in?",
+            "What is the birth city of {subject}'s {relation}?",
+            "Where was the {relation} of {subject} born?",
+            "Name the city where {subject}'s {relation} was born.",
+            "In which city did the birth of {subject}'s {relation} take place?",
+        )
+    return templates[variant].format(subject=subject, relation=relation)
+
+
+def prompt(row, variant=0, atomic=False):
+    return "Fictional registry.\nQuestion: " + question(row, variant, atomic) + "\nAnswer:"
+
+
+def record(tokenizer, row, variant, atomic):
+    # Joint text tokenization, exactly as in the calibrated full-Qwen v2 recipe.
+    ids = tokenizer.encode(
+        prompt(row, variant, atomic) + " " + row["answer"] + ".", add_special_tokens=False
+    ) + [tokenizer.eos_token_id]
+    return dict(
+        ids=ids,
+        labels=[-100, *ids[1:]],
+        id=row["id"],
+        kind="atomic" if atomic else "composition",
+        variant=variant,
+    )
+
+
+def streams(world, cfg):
+    rng = np.random.default_rng(cfg["training_seed"])
+    atomic_order, comp_order = [], {a: [] for a in cfg["arms"]}
+    batches = {a: [] for a in cfg["arms"]}
+    for _ in range(cfg["steps"]):
+        if len(atomic_order) < cfg["atomic_per_step"]:
+            atomic_order.extend(rng.permutation(len(world["atoms"])).tolist())
+        atomic = [
+            [int(atomic_order.pop(0)), int(rng.integers(4))] for _ in range(cfg["atomic_per_step"])
+        ]
+        variants = rng.integers(4, size=cfg["compositions_per_step"]).tolist()
+        for arm in cfg["arms"]:
+            support = world[arm + "_support"]
+            if len(comp_order[arm]) < cfg["compositions_per_step"]:
+                comp_order[arm].extend(rng.permutation(support).tolist())
+            comp = [[int(comp_order[arm].pop(0)), int(v)] for v in variants]
+            batches[arm].append(dict(atomic=atomic, composition=comp))
+    return batches
+
+
+def records(tokenizer, world):
+    return {
+        kind: {
+            (r["id"], v): record(tokenizer, r, v, kind == "atomic")
+            for r in world["atoms" if kind == "atomic" else "chains"]
+            for v in range(4)
+        }
+        for kind in ("atomic", "composition")
+    }
+
+
+def docs_for(rec, batch):
+    return [rec[kind][tuple(spec)] for kind in ("atomic", "composition") for spec in batch[kind]]
+
+
+def audit(world, batches, rec):
+    assert (
+        len(world["atoms"]) == 128
+        and len(world["high_support"]) == 32
+        and len(world["low_support"]) == 8
+    )
+    assert set(world["low_support"]) < set(world["high_support"])
+    familiar_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "familiar"}
+    covered = {i for j in world["high_support"] for i in world["chains"][j]["atom_ids"]}
+    assert covered == familiar_atoms
+    strict_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "strict"}
+    assert not covered & strict_atoms
+    support = [world["chains"][i] for i in world["high_support"]]
+    heldout = [c for c in world["chains"] if c["split"] == "heldout"]
+    strict = [c for c in world["chains"] if c["split"] == "strict"]
+    assert len(heldout) == 32 and len(strict) == 64
+    # No alternate trained query gives the same head/answer endpoint as a held-out chain.
+    assert not {(c["head"], c["answer"]) for c in support} & {
+        (c["head"], c["answer"]) for c in heldout
+    }
+
+    def people(pool):
+        return {a["subject"] for a in world["atoms"] if a["pool"] == pool}
+
+    assert not people("familiar") & people("strict")
+    assert not {c["answer"] for c in support} & {c["answer"] for c in strict}
+    budgets, exposure = {}, {}
+    for arm, stream in batches.items():
+        budget, atomic_counts, comp_counts = Counter(), Counter(), Counter()
+        for batch in stream:
+            docs = docs_for(rec, batch)
+            width = max(len(d["ids"]) for d in docs)
+            budget.update(
+                input_tokens=sum(len(d["ids"]) for d in docs),
+                supervised_tokens=sum(len(d["ids"]) - 1 for d in docs),
+                padded_tokens=len(docs) * width,
+                attention_cells=len(docs) * width**2,
+            )
+            atomic_counts.update(i for i, _ in batch["atomic"])
+            comp_counts.update(i for i, _ in batch["composition"])
+            assert set(comp_counts) <= set(world[arm + "_support"])
+        budgets[arm] = dict(budget)
+        exposure[arm] = dict(
+            atomic=sorted(atomic_counts.items()), composition=sorted(comp_counts.items())
+        )
+    if "low" in batches and "high" in batches:
+        assert [b["atomic"] for b in batches["low"]] == [b["atomic"] for b in batches["high"]]
+        assert exposure["low"]["atomic"] == exposure["high"]["atomic"]
+    return dict(
+        status="passed",
+        budgets=budgets,
+        exposures=exposure,
+        familiar_fact_role_coverage_high=len(covered),
+        familiar_fact_role_coverage_low=len(
+            {i for j in world["low_support"] for i in world["chains"][j]["atom_ids"]}
+        ),
+        heldout_queries=len(heldout),
+        strict_queries=len(strict),
+        target_endpoint_leakage=0,
+        exact_common_atomic_sequence=True,
+        exact_atomic_stream_loss_weight=True,
+        composition_slots_equal=True,
+    )
+
+
+def freeze(config_path):
+    cfg = base.read(config_path)
+    art = Path(cfg["artifact_root"])
+    assert not (art / "lock.json").exists(), "Preserve frozen batch."
+    tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True)
+    sources = [
+        str(config_path),
+        "src/llm_memory_editability/natural_composition_confirmation_v2.py",
+        "src/llm_memory_editability/small_lm_composition.py",
+        "scripts/run_natural_composition_confirmation_v2.py",
+        "tests/test_natural_composition_confirmation_v2.py",
+        "docs/development-artifacts/natural-composition-confirmation-v1/amendment-v2.md",
+    ]
+    source_hashes = {}
+    for source in sources:
+        dest = art / "source" / source
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(source, dest)
+        source_hashes[source] = sha(source)
+    data_files = {}
+    for seed in cfg["world_seeds"]:
+        world = build_world(seed)
+        batch = streams(world, cfg)
+        report = audit(world, batch, records(tokenizer, world))
+        for filename, obj in (
+            ("world.json", world),
+            ("streams.json", batch),
+            ("data-audit.json", report),
+        ):
+            path = art / f"w{seed}" / filename
+            write(path, obj)
+            data_files[str(path)] = sha(path)
+    model_files = {
+        str(p): sha(p)
+        for p in Path(cfg["model_path"]).iterdir()
+        if p.suffix in (".json", ".safetensors") or p.name in ("LICENSE", "README.md")
+    }
+    write(
+        art / "environment.json",
+        dict(
+            python=platform.python_version(),
+            executable=str(Path(__import__("sys").executable)),
+            torch=torch.__version__,
+            transformers=transformers.__version__,
+            gpu_inventory=__import__("subprocess").check_output(
+                ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total", "--format=csv"],
+                text=True,
+            ),
+        ),
+    )
+    write(
+        art / "lock.json",
+        dict(
+            status="locked_before_training",
+            utc=base.now(),
+            sources=source_hashes,
+            data_files=data_files,
+            model_files=model_files,
+            config=cfg,
+        ),
+    )
+    print(
+        json.dumps(dict(status="frozen", worlds=cfg["world_seeds"], arms=cfg["arms"])), flush=True
+    )
+
+
+def check_lock(cfg):
+    lock = base.read(Path(cfg["artifact_root"]) / "lock.json")
+    for group in ("sources", "data_files", "model_files"):
+        for path, digest in lock[group].items():
+            assert sha(path) == digest, path
+
+
+def evaluation_rows(world, extras=False):
+    rows = []
+    for view in (0, 4) if extras else (0,):
+        for atom in world["atoms"]:
+            rows.append(dict(atom, mode="atomic", view=view, prompt=prompt(atom, view, True)))
+        for chain in world["chains"]:
+            rows.append(dict(chain, mode="direct", view=view, prompt=prompt(chain, view)))
+    return rows
+
+
+@torch.inference_mode()
+def generate(model, tokenizer, rows, cfg):
+    model.eval()
+    tokenizer.padding_side = "left"
+    output = []
+    for start in range(0, len(rows), cfg["eval_batch"]):
+        chunk = rows[start : start + cfg["eval_batch"]]
+        inputs = tokenizer(
+            [r["prompt"] for r in chunk],
+            padding=True,
+            return_tensors="pt",
+            add_special_tokens=False,
+        ).to(cfg["device"])
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            tokens = model.generate(
+                **inputs,
+                do_sample=False,
+                max_new_tokens=cfg["max_new_tokens"],
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                use_cache=True,
+            )[:, inputs.input_ids.shape[1] :]
+        for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True):
+            if tokenizer.eos_token_id in tok:
+                tok = tok[: tok.index(tokenizer.eos_token_id) + 1]
+            text = tokenizer.decode(tok, skip_special_tokens=True)
+            output.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"])))
+    return output
+
+
+def evaluate(model, tokenizer, world, cfg, extras=False):
+    direct = generate(model, tokenizer, evaluation_rows(world, extras), cfg)
+    if not extras:
+        return direct
+    atoms = {a["id"]: a for a in world["atoms"]}
+    lookup = {(r["id"], r["view"]): r for r in direct if r["mode"] == "atomic"}
+    second_calls = []
+    for row in direct:
+        if row["mode"] != "direct":
+            continue
+        first = lookup[row["atom_ids"][0], row["view"]]
+        generated_bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip()
+        second = dict(atoms[row["atom_ids"][1]], subject=generated_bridge)
+        second_calls.append(
+            dict(
+                row,
+                mode="autonomous",
+                prompt=prompt(second, row["view"], True),
+                generated_bridge=generated_bridge,
+                first_tokens=first["tokens"],
+                first_correct=first["correct"],
+            )
+        )
+    return direct + generate(model, tokenizer, second_calls, cfg)
+
+
+def metrics(rows, world, arm):
+    result = {}
+    for view in sorted({r["view"] for r in rows}):
+        atomic = {r["id"]: r for r in rows if r["view"] == view and r["mode"] == "atomic"}
+        for pool in ("familiar", "strict"):
+            for role in ("first", "second"):
+                selected = [r for r in atomic.values() if r["pool"] == pool and r["role"] == role]
+                result[f"v{view}_{pool}_{role}"] = dict(
+                    correct=sum(r["correct"] for r in selected), n=len(selected)
+                )
+        for split in ("heldout", "strict", "training"):
+            ids = (
+                set(world[arm + "_support"])
+                if split == "training"
+                else {c["id"] for c in world["chains"] if c["split"] == split}
+            )
+            for mode in ("direct", "autonomous"):
+                selected = [
+                    r for r in rows if r["view"] == view and r["mode"] == mode and r["id"] in ids
+                ]
+                if selected:
+                    result[f"v{view}_{split}_{mode}"] = dict(
+                        correct=sum(r["correct"] for r in selected), n=len(selected)
+                    )
+                    mastered = [
+                        r for r in selected if all(atomic[i]["correct"] for i in r["atom_ids"])
+                    ]
+                    result[f"v{view}_{split}_{mode}_both_atomic"] = dict(
+                        correct=sum(r["correct"] for r in mastered),
+                        n=len(mastered),
+                        full_n=len(selected),
+                    )
+    return result
+
+
+def stream_loss(model, inputs, atomic_count, atomic_weight):
+    logits = model(
+        input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], use_cache=False
+    ).logits[:, :-1]
+    labels = inputs["labels"][:, 1:]
+    losses = F.cross_entropy(
+        logits.float().reshape(-1, logits.shape[-1]),
+        labels.reshape(-1),
+        reduction="none",
+        ignore_index=-100,
+    ).reshape_as(labels)
+    atomic = losses[:atomic_count].sum() / (labels[:atomic_count] != -100).sum()
+    comp = losses[atomic_count:].sum() / (labels[atomic_count:] != -100).sum()
+    return atomic_weight * atomic + (1 - atomic_weight) * comp
+
+
+def run(config_path, seed, arm):
+    cfg = base.read(config_path)
+    check_lock(cfg)
+    assert seed in cfg["world_seeds"] and arm in cfg["arms"]
+    art = Path(cfg["artifact_root"]) / f"w{seed}"
+    out = Path(cfg["output_root"]) / f"w{seed}-{arm}"
+    assert not (out / "status.json").exists(), "Preserve existing execution."
+    world, batches = base.read(art / "world.json"), base.read(art / "streams.json")[arm]
+    write(out / "status.json", dict(status="running", utc=base.now()))
+    started = time.perf_counter()
+    torch.set_num_threads(cfg["cpu_threads"])
+    torch.manual_seed(cfg["training_seed"])
+    torch.cuda.set_device(cfg["device"])
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    torch.cuda.reset_peak_memory_stats()
+    tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    def load(path):
+        return AutoModelForCausalLM.from_pretrained(
+            path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True
+        ).to(cfg["device"])
+
+    model = load(cfg["model_path"])
+    assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024
+    assert len({id(layer.mlp) for layer in model.model.layers}) == 28
+    model.requires_grad_(True)
+    samples = base.parameter_samples(model)
+    parameter_count = sum(p.numel() for p in model.parameters())
+    rec = records(tokenizer, world)
+    optimizer = torch.optim.AdamW(
+        model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"], fused=True
+    )
+    curve, budget, train_seconds = [], Counter(), 0.0
+    for step in range(cfg["steps"] + 1):
+        if step in cfg["nodes"]:
+            rows = evaluate(model, tokenizer, world, cfg, extras=step == cfg["steps"])
+            write(out / f"predictions-{step:05d}.json", rows)
+            point = dict(step=step, metrics=metrics(rows, world, arm))
+            curve.append(point)
+            write(out / "curve.json", curve)
+            print(json.dumps(dict(seed=seed, arm=arm, **point)), flush=True)
+        if step == cfg["steps"]:
+            break
+        decay = 0.5 * (
+            1
+            + math.cos(
+                math.pi * max(0, step - cfg["warmup_steps"]) / (cfg["steps"] - cfg["warmup_steps"])
+            )
+        )
+        lr = (
+            cfg["minimum_learning_rate"]
+            + (cfg["learning_rate"] - cfg["minimum_learning_rate"]) * decay
+        ) * min(1.0, (step + 1) / cfg["warmup_steps"])
+        for group in optimizer.param_groups:
+            group["lr"] = lr
+        docs = docs_for(rec, batches[step])
+        width = max(len(d["ids"]) for d in docs)
+        budget.update(
+            input_tokens=sum(len(d["ids"]) for d in docs),
+            supervised_tokens=sum(len(d["ids"]) - 1 for d in docs),
+            padded_tokens=len(docs) * width,
+            attention_cells=len(docs) * width**2,
+        )
+        inputs = base.batch_tensors(docs, tokenizer.pad_token_id, cfg["device"])
+        model.train()
+        torch.cuda.synchronize()
+        tick = time.perf_counter()
+        optimizer.zero_grad(set_to_none=True)
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            loss = stream_loss(model, inputs, cfg["atomic_per_step"], cfg["atomic_loss_weight"])
+        assert torch.isfinite(loss)
+        loss.backward()
+        if step == 0:
+            assert all(
+                p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all()
+                for p in model.parameters()
+            )
+        torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"])
+        optimizer.step()
+        torch.cuda.synchronize()
+        train_seconds += time.perf_counter() - tick
+        if (step + 1) % 64 == 0:
+            print(
+                json.dumps(
+                    dict(
+                        seed=seed,
+                        arm=arm,
+                        step=step + 1,
+                        loss=float(loss.detach()),
+                        train_seconds=train_seconds,
+                    )
+                ),
+                flush=True,
+            )
+    changed = {
+        name: not torch.equal(before, base.parameter_samples(model)[name])
+        for name, before in samples.items()
+    }
+    assert all(changed.values())
+    model.save_pretrained(out / "model", safe_serialization=True)
+    tokenizer.save_pretrained(out / "model")
+    architecture = model.config.to_dict()
+    final_rows = rows
+    del optimizer, model, samples, inputs, loss
+    torch.cuda.empty_cache()
+    again = evaluate(load(out / "model"), tokenizer, world, cfg, extras=True)
+    assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again]
+    assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again]
+    write(
+        out / "reload-audit.json",
+        dict(
+            status="passed",
+            predictions=len(again),
+            exact_generated_tokens=True,
+            exact_autonomous_prompts=True,
+        ),
+    )
+    assert dict(budget) == base.read(art / "data-audit.json")["budgets"][arm]
+    d, layers = architecture["hidden_size"], architecture["num_hidden_layers"]
+    query_width = architecture["num_attention_heads"] * architecture["head_dim"]
+    kv = architecture["num_key_value_heads"] * architecture["head_dim"]
+    per_token = (
+        layers * (2 * d * query_width + 2 * d * kv + 3 * d * architecture["intermediate_size"])
+        + d * architecture["vocab_size"]
+    )
+    flops = (
+        6 * per_token * budget["padded_tokens"]
+        + 12 * layers * query_width * budget["attention_cells"]
+    )
+    summary = dict(
+        status="complete",
+        phase=cfg["phase"],
+        utc=base.now(),
+        world_seed=seed,
+        arm=arm,
+        metrics=metrics(final_rows, world, arm),
+        updates=cfg["steps"],
+        budget=dict(budget),
+        train_seconds=train_seconds,
+        process_seconds=time.perf_counter() - started,
+        estimated_training_matrix_flops=flops,
+        peak_gpu_bytes=torch.cuda.max_memory_allocated(),
+        parameter_count=parameter_count,
+        sampled_parameters_changed=changed,
+        torch_version=torch.__version__,
+        transformers_version=transformers.__version__,
+        gpu=torch.cuda.get_device_name(),
+        tf32=False,
+        lock_sha256=sha(Path(cfg["artifact_root"]) / "lock.json"),
+        checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")},
+    )
+    write(out / "summary.json", summary)
+    write(out / "status.json", dict(status="complete", utc=base.now()))
+    print(json.dumps(summary), flush=True)
+
+
+def report(config_path):
+    cfg = base.read(config_path)
+    check_lock(cfg)
+    runs, checks = {}, 0
+    for seed in cfg["world_seeds"]:
+        world = base.read(Path(cfg["artifact_root"]) / f"w{seed}" / "world.json")
+        for arm in cfg["arms"]:
+            out = Path(cfg["output_root"]) / f"w{seed}-{arm}"
+            summary = base.read(out / "summary.json")
+            assert base.read(out / "reload-audit.json")["status"] == "passed"
+            for point in base.read(out / "curve.json"):
+                rows = base.read(out / f"predictions-{point['step']:05d}.json")
+                assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows)
+                assert point["metrics"] == metrics(rows, world, arm)
+                checks += len(rows)
+            assert summary["metrics"] == metrics(rows, world, arm)
+            runs[f"w{seed}-{arm}"] = summary
+    differences = {}
+    if len(cfg["arms"]) == 2:
+        for seed in cfg["world_seeds"]:
+            diff = {}
+            for key in runs[f"w{seed}-high"]["metrics"]:
+                high, low = [runs[f"w{seed}-{a}"]["metrics"][key] for a in ("high", "low")]
+                if key.endswith("both_atomic") or "training" in key:
+                    continue
+                diff[key] = high["correct"] / high["n"] - low["correct"] / low["n"]
+            differences[str(seed)] = diff
+    write(
+        Path(cfg["artifact_root"]) / "summary.json",
+        dict(
+            status="complete",
+            phase=cfg["phase"],
+            independent_worlds=len(cfg["world_seeds"]),
+            training_initializations=1,
+            runs=runs,
+            per_world_high_minus_low=differences,
+            independent_node_prediction_checks=checks,
+            total_updates=sum(r["updates"] for r in runs.values()),
+            total_train_seconds=sum(r["train_seconds"] for r in runs.values()),
+            total_process_seconds=sum(r["process_seconds"] for r in runs.values()),
+        ),
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=("freeze", "run", "report"))
+    parser.add_argument("--config", required=True)
+    parser.add_argument("--world", type=int)
+    parser.add_argument("--arm", choices=("low", "high"))
+    args = parser.parse_args()
+    if args.action == "run":
+        run(args.config, args.world, args.arm)
+    elif args.action == "freeze":
+        freeze(args.config)
+    else:
+        report(args.config)

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural.py

@@ -0,0 +1,328 @@
+"""Controlled nonlinear memory editing with full old-fact replay on CPU.
+
+This measures finite-budget optimization, not minimum representational capacity.
+The data generator's shared rule does not establish the model's internal mechanism.
+"""
+
+import argparse
+import copy
+import json
+import math
+import platform
+import statistics
+import subprocess
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import numpy as np
+
+try:
+    import torch
+    from torch import nn
+    from torch.nn import functional as F
+except ModuleNotFoundError as exc:
+    raise SystemExit("Neural experiments require PyTorch: pip install '.[neural]'") from exc
+
+from .neural_data import make_world
+from .neural_models import build_model, edit_parameters
+
+
+@dataclass(frozen=True)
+class NeuralConfig:
+    model: str = "mlp"
+    seeds: tuple[int, ...] = (0, 1, 2)
+    data_seed: int = 0
+    entities: int = 24
+    attributes: int = 8
+    groups: int = 3
+    answers: int = 4
+    width: int = 32
+    hidden: int = 64
+    layers: int = 2
+    heads: int = 4
+    pretrain_steps: int = 400
+    edit_steps: int = 100
+    scratch_steps: int = 400
+    lr: float = 0.01
+    retention_weight: float = 1.0
+    edit_scope: str = "ffn"
+    eval_every: int = 10
+    success_threshold: float = 0.95
+    threads: int = 1
+
+    def validate(self) -> None:
+        if self.model not in {"mlp", "transformer"} or self.edit_scope not in {"ffn", "all"}:
+            raise ValueError("unsupported model or edit scope")
+        for name in ("pretrain_steps", "edit_steps", "scratch_steps", "eval_every", "threads"):
+            value = getattr(self, name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+                raise ValueError(f"{name} must be a positive integer")
+        if not self.seeds or len(set(self.seeds)) != len(self.seeds):
+            raise ValueError("seeds must be nonempty and unique")
+        if any(isinstance(s, bool) or not isinstance(s, int) or s < 0 for s in self.seeds):
+            raise ValueError("seeds must be nonnegative integers")
+        if not math.isfinite(self.lr) or self.lr <= 0:
+            raise ValueError("lr must be finite and positive")
+        if not math.isfinite(self.retention_weight) or self.retention_weight < 0:
+            raise ValueError("retention_weight must be finite and nonnegative")
+        if not 0 < self.success_threshold <= 1:
+            raise ValueError("success_threshold must be in (0, 1]")
+
+
+@torch.no_grad()
+def evaluate(model: nn.Module, x: torch.Tensor, y: torch.Tensor, mask: torch.Tensor) -> dict:
+    """Evaluate answers against a target world, separating edits and retained facts."""
+    model.eval()
+    logits = model(x)
+    if not torch.isfinite(logits).all():
+        raise ValueError("non-finite model outputs")
+    correct = logits.argmax(dim=-1).eq(y).float()
+    target_logits = logits.gather(1, y[:, None]).squeeze(1)
+    competitors = logits.clone().scatter_(1, y[:, None], float("-inf")).max(dim=1).values
+    margins = target_logits - competitors
+    return {
+        "all_accuracy": correct.mean().item(),
+        "edit_accuracy": correct[mask].mean().item(),
+        "retain_accuracy": correct[~mask].mean().item(),
+        "edit_target_nll": F.cross_entropy(logits[mask], y[mask]).item(),
+        "edit_margin": margins[mask].mean().item(),
+        "retain_margin": margins[~mask].mean().item(),
+    }
+
+
+def fit(
+    model: nn.Module,
+    x: torch.Tensor,
+    y: torch.Tensor,
+    mask: torch.Tensor,
+    *,
+    steps: int,
+    config: NeuralConfig,
+    is_edit: bool = False,
+) -> dict:
+    """Use a fresh optimizer, fixed steps, and a documented full-batch objective."""
+    parameters = [p for p in model.parameters() if p.requires_grad]
+    optimizer = torch.optim.Adam(parameters, lr=config.lr)
+    history = []
+    first_success = None
+    started = time.perf_counter()
+    for step in range(steps + 1):
+        if step % config.eval_every == 0 or step == steps:
+            metrics = evaluate(model, x, y, mask)
+            history.append({"step": step, **metrics})
+            if (
+                first_success is None
+                and min(metrics["edit_accuracy"], metrics["retain_accuracy"])
+                >= config.success_threshold
+            ):
+                first_success = step
+        if step == steps:
+            break
+        model.train()
+        optimizer.zero_grad(set_to_none=True)
+        logits = model(x)
+        if is_edit:
+            loss = F.cross_entropy(logits[mask], y[mask])
+            if config.retention_weight:
+                loss = loss + config.retention_weight * F.cross_entropy(logits[~mask], y[~mask])
+        else:
+            loss = F.cross_entropy(logits, y)
+        if not torch.isfinite(loss):
+            raise ValueError("training diverged to a non-finite loss")
+        loss.backward()
+        optimizer.step()
+    return {
+        "steps": steps,
+        "trainable_parameters": sum(p.numel() for p in parameters),
+        "first_success_step": first_success,
+        "elapsed_seconds": time.perf_counter() - started,
+        "history": history,
+        "objective": "edit_ce + retention_weight * retained_ce" if is_edit else "full_world_ce",
+    }
+
+
+def _summary(runs: list[dict]) -> dict:
+    eligible = [run for run in runs if run["baseline_quality_passed"]]
+    result = {"eligible_seeds": [run["seed"] for run in eligible], "cases": {}}
+    for name in ("rule", "exception"):
+        result["cases"][name] = {}
+        for metric in ("edit_accuracy", "retain_accuracy"):
+            values = [run["cases"][name]["after"][metric] for run in eligible]
+            result["cases"][name][metric] = {
+                "mean": statistics.mean(values) if values else None,
+                "sample_std": statistics.stdev(values) if len(values) > 1 else None,
+                "n": len(values),
+            }
+    return result
+
+
+def _revision() -> str | None:
+    """Best-effort source revision; an installed wheel may not have a checkout."""
+    source_root = Path(__file__).resolve().parents[2]
+    if not (source_root / ".git").exists():
+        return None
+    try:
+        revision = subprocess.check_output(
+            ["git", "rev-parse", "HEAD"], cwd=source_root, text=True, stderr=subprocess.DEVNULL
+        ).strip()
+        dirty = subprocess.check_output(
+            ["git", "status", "--porcelain"], cwd=source_root, text=True
+        ).strip()
+        return revision + ("+dirty" if dirty else "")
+    except (OSError, subprocess.CalledProcessError):
+        return None
+
+
+def run_experiment(config: NeuralConfig) -> dict:
+    config.validate()
+    world = make_world(
+        n_entities=config.entities,
+        n_attributes=config.attributes,
+        n_groups=config.groups,
+        n_answers=config.answers,
+        seed=config.data_seed,
+    )
+    torch.set_num_threads(config.threads)
+    torch.use_deterministic_algorithms(True)
+    x = torch.as_tensor(world.x, dtype=torch.long)
+    original = torch.as_tensor(world.original, dtype=torch.long)
+    mask = torch.as_tensor(world.edit_mask, dtype=torch.bool)
+    runs = []
+    for seed in config.seeds:
+        torch.manual_seed(seed)
+        initial = build_model(
+            config.model,
+            config.entities,
+            config.attributes,
+            config.answers,
+            width=config.width,
+            hidden=config.hidden,
+            layers=config.layers,
+            heads=config.heads,
+        )
+        base = copy.deepcopy(initial)
+        baseline_training = fit(
+            base,
+            x,
+            original,
+            mask,
+            steps=config.pretrain_steps,
+            config=config,
+        )
+        baseline = evaluate(base, x, original, mask)
+        run = {
+            "seed": seed,
+            "parameter_count": sum(p.numel() for p in base.parameters()),
+            "baseline": baseline,
+            "baseline_quality_passed": min(baseline["edit_accuracy"], baseline["retain_accuracy"])
+            >= config.success_threshold,
+            "baseline_training": baseline_training,
+            "cases": {},
+        }
+        for name in ("rule", "exception"):
+            target = torch.as_tensor(getattr(world, name), dtype=torch.long)
+            edited = copy.deepcopy(base)
+            edit_parameters(edited, scope=config.edit_scope)
+            before = evaluate(edited, x, target, mask)
+            edit_training = fit(
+                edited,
+                x,
+                target,
+                mask,
+                steps=config.edit_steps,
+                config=config,
+                is_edit=True,
+            )
+            scratch = copy.deepcopy(initial)
+            scratch_training = fit(
+                scratch,
+                x,
+                target,
+                mask,
+                steps=config.scratch_steps,
+                config=config,
+            )
+            run["cases"][name] = {
+                "before": before,
+                "after": evaluate(edited, x, target, mask),
+                "scratch": evaluate(scratch, x, target, mask),
+                "edit_training": edit_training,
+                "scratch_training": scratch_training,
+            }
+        runs.append(run)
+    return {
+        "experiment": "nonlinear_synthetic_memory_editing",
+        "config": asdict(config),
+        "versions": {
+            "python": platform.python_version(),
+            "numpy": np.__version__,
+            "torch": torch.__version__,
+        },
+        "revision": _revision(),
+        "device": "cpu",
+        "world": world.to_metadata(),
+        "protocol": {
+            "paired_edit_initialization": "identical trained checkpoint; fresh Adam per case",
+            "paired_scratch_initialization": "identical untrained initialization; all parameters",
+            "replay": "all retained facts available; uniform CE within each edit/retain subset",
+            "success": "both edit and retain accuracy >= threshold at evaluation checkpoints",
+            "summary_filter": "only seeds passing baseline threshold on both subsets",
+            "limits": [
+                "Target surprisal is measured, not matched.",
+                "Generator structure is not a measure of learned neural degrees of freedom.",
+                "Scratch failure at finite budget is not an impossibility result.",
+                "Scratch trains all parameters; FFN-only edit failures may reflect "
+                "a restricted update space.",
+                "No natural-language paraphrases or pretrained LLM are evaluated.",
+                "Cross-platform and cross-version bitwise reproducibility is not guaranteed.",
+            ],
+        },
+        "runs": runs,
+        "summary": _summary(runs),
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", choices=("mlp", "transformer"), default="mlp")
+    parser.add_argument("--seeds", type=int, nargs="+", default=[0, 1, 2])
+    parser.add_argument("--edit-scope", choices=("ffn", "all"), default="ffn")
+    defaults = asdict(NeuralConfig())
+    for name in (
+        "data_seed",
+        "entities",
+        "attributes",
+        "groups",
+        "answers",
+        "width",
+        "hidden",
+        "layers",
+        "heads",
+        "pretrain_steps",
+        "edit_steps",
+        "scratch_steps",
+        "eval_every",
+        "threads",
+    ):
+        parser.add_argument("--" + name.replace("_", "-"), type=int, default=defaults[name])
+    for name in ("lr", "retention_weight", "success_threshold"):
+        parser.add_argument("--" + name.replace("_", "-"), type=float, default=defaults[name])
+    parser.add_argument("--output", type=Path, help="save the same JSON printed to stdout")
+    args = vars(parser.parse_args(argv))
+    output = args.pop("output")
+    args["seeds"] = tuple(args["seeds"])
+    try:
+        report = run_experiment(NeuralConfig(**args))
+        serialized = json.dumps(report, ensure_ascii=False, indent=2, allow_nan=False)
+        if output:
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_text(serialized + "\n", encoding="utf-8")
+    except (ValueError, OSError) as exc:
+        parser.error(str(exc))
+    print(serialized)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_data.py

@@ -0,0 +1,147 @@
+"""Balanced fact-table interventions, defined independently of model training."""
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class SyntheticWorld:
+    """All entity/attribute queries and two interventions on identical support."""
+
+    x: np.ndarray
+    original: np.ndarray
+    rule: np.ndarray
+    exception: np.ndarray
+    edit_mask: np.ndarray
+    group_ids: np.ndarray
+    n_entities: int
+    n_attributes: int
+    n_groups: int
+    n_answers: int
+    seed: int
+
+    def task_exceptions(self, labels: np.ndarray) -> int:
+        """Minimum overrides of a group+attribute table; not neural model degrees of freedom."""
+        labels = np.asarray(labels)
+        if labels.shape != self.original.shape:
+            raise ValueError("labels must contain one answer per fact")
+        exceptions = 0
+        for group in range(self.n_groups):
+            for attribute in range(self.n_attributes):
+                cell = labels[(self.group_ids[self.x[:, 0]] == group) & (self.x[:, 1] == attribute)]
+                exceptions += cell.size - int(np.bincount(cell, minlength=self.n_answers).max())
+        return exceptions
+
+    def to_metadata(self) -> dict[str, Any]:
+        """JSON-compatible task diagnostics, available before training or editing."""
+        return {
+            "n_entities": self.n_entities,
+            "n_attributes": self.n_attributes,
+            "n_groups": self.n_groups,
+            "n_answers": self.n_answers,
+            "seed": self.seed,
+            "n_facts": len(self.x),
+            "n_edited": int(self.edit_mask.sum()),
+            "edited_entities": np.unique(self.x[self.edit_mask, 0]).tolist(),
+            "edited_attributes": np.unique(self.x[self.edit_mask, 1]).tolist(),
+            "matched_controls": [
+                "edit support",
+                "edited fact count",
+                "entity and attribute coverage",
+                "per-entity target-answer histograms",
+            ],
+            "task_side_group_attribute_exceptions": {
+                name: self.task_exceptions(getattr(self, name))
+                for name in ("original", "rule", "exception")
+            },
+            "structure_metric_scope": (
+                "Minimum label overrides of a deterministic group+attribute answer table. "
+                "This is a task-side generator property, not neural degrees of freedom "
+                "or evidence that a trained network learned these groups."
+            ),
+        }
+
+
+def make_world(
+    n_entities: int = 24,
+    n_attributes: int = 8,
+    n_groups: int = 3,
+    n_answers: int = 4,
+    seed: int = 0,
+) -> SyntheticWorld:
+    """Generate balanced labels and conflicting exception patterns in edited group 0.
+
+    Entity targets are independently shuffled, conditioned on changing every edited
+    fact. The final row is resampled if all entities happen to share one pattern.
+    Rejection sampling is bounded, including for long attribute tables.
+    """
+    for name, value in {
+        "n_entities": n_entities,
+        "n_attributes": n_attributes,
+        "n_groups": n_groups,
+        "n_answers": n_answers,
+        "seed": seed,
+    }.items():
+        if isinstance(value, bool) or not isinstance(value, (int, np.integer)):
+            raise ValueError(f"{name} must be an integer")
+        if value < (0 if name == "seed" else 1):
+            raise ValueError(f"{name} is outside its valid range")
+    n_entities, n_attributes, n_groups, n_answers, seed = map(
+        int,
+        (n_entities, n_attributes, n_groups, n_answers, seed),
+    )
+    if n_groups < 2:
+        raise ValueError("n_groups must be >= 2 to leave retained facts outside the edit support")
+    if n_entities % n_groups or n_entities // n_groups < 2:
+        raise ValueError("n_entities must be divisible by n_groups, with >= 2 entities per group")
+    if n_answers < 3 or n_attributes % n_answers:
+        raise ValueError("n_answers must be >= 3 and divide n_attributes")
+
+    rng = np.random.default_rng(seed)
+    group_ids = np.repeat(np.arange(n_groups), n_entities // n_groups).astype(np.int64)
+    x = np.column_stack(
+        (
+            np.repeat(np.arange(n_entities), n_attributes),
+            np.tile(np.arange(n_attributes), n_entities),
+        )
+    ).astype(np.int64)
+    original = (group_ids[x[:, 0]] + x[:, 1]) % n_answers
+    edit_mask = group_ids[x[:, 0]] == 0
+    rule = original.copy()
+    rule[edit_mask] = (rule[edit_mask] + 1) % n_answers
+    exception = original.copy()
+    # Every edited entity has the same balanced original labels and rule targets.
+    old_row = original[:n_attributes]
+    edited_entities = np.flatnonzero(group_ids == 0)
+    sampled_rows = []
+    for row_index, entity in enumerate(edited_entities):
+        for _ in range(10_000):
+            candidate = rng.permutation(old_row)
+            shared_pattern = row_index == len(edited_entities) - 1 and all(
+                np.array_equal(row, candidate) for row in sampled_rows
+            )
+            if np.all(candidate != old_row) and not shared_pattern:
+                sampled_rows.append(candidate)
+                start = entity * n_attributes
+                exception[start : start + n_attributes] = candidate
+                break
+        else:
+            raise ValueError(
+                "Could not sample balanced exception patterns in 10,000 attempts; "
+                "use more answers or fewer attributes to make rejection sampling practical."
+            )
+    return SyntheticWorld(
+        x,
+        original,
+        rule,
+        exception,
+        edit_mask,
+        group_ids,
+        n_entities,
+        n_attributes,
+        n_groups,
+        n_answers,
+        seed,
+    )

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_models.py

@@ -0,0 +1,157 @@
+"""Trainable nonlinear fact models; importing this module requires PyTorch."""
+
+import torch
+from torch import nn
+
+
+class FactMLP(nn.Module):
+    """Separate entity/attribute embeddings followed by a nonlinear MLP."""
+
+    def __init__(
+        self,
+        n_entities: int,
+        n_attributes: int,
+        n_answers: int,
+        width: int,
+        hidden: int,
+        layers: int,
+    ) -> None:
+        super().__init__()
+        self.entity_embedding = nn.Embedding(n_entities, width)
+        self.attribute_embedding = nn.Embedding(n_attributes, width)
+        blocks = []
+        for layer in range(layers):
+            blocks.extend((nn.Linear(2 * width if layer == 0 else hidden, hidden), nn.GELU()))
+        self.hidden = nn.Sequential(*blocks)
+        self.answer_head = nn.Linear(hidden, n_answers)
+
+    def forward(self, facts: torch.Tensor) -> torch.Tensor:
+        _validate_facts(facts)
+        embedded = torch.cat(
+            (
+                self.entity_embedding(facts[:, 0]),
+                self.attribute_embedding(facts[:, 1]),
+            ),
+            dim=-1,
+        )
+        return self.answer_head(self.hidden(embedded))
+
+
+class FactTransformer(nn.Module):
+    """Causal [ENTITY, ATTRIBUTE, QUERY] transformer with an answer classification head."""
+
+    def __init__(
+        self,
+        n_entities: int,
+        n_attributes: int,
+        n_answers: int,
+        width: int,
+        hidden: int,
+        layers: int,
+        heads: int,
+    ) -> None:
+        super().__init__()
+        self.n_entities = n_entities
+        self.query_id = n_entities + n_attributes
+        self.token_embedding = nn.Embedding(self.query_id + 1, width)
+        self.position_embedding = nn.Embedding(3, width)
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=width,
+            nhead=heads,
+            dim_feedforward=hidden,
+            dropout=0.0,
+            activation="gelu",
+            batch_first=True,
+            norm_first=True,
+        )
+        self.encoder = nn.TransformerEncoder(
+            encoder_layer,
+            num_layers=layers,
+            norm=nn.LayerNorm(width),
+            enable_nested_tensor=False,
+        )
+        # TransformerEncoder clones its prototype; initialize each layer independently.
+        for layer in self.encoder.layers:
+            nn.init.xavier_uniform_(layer.self_attn.in_proj_weight)
+            for module in layer.modules():
+                if isinstance(module, nn.Linear):
+                    nn.init.xavier_uniform_(module.weight)
+                    if module.bias is not None:
+                        nn.init.zeros_(module.bias)
+        self.answer_head = nn.Linear(width, n_answers)
+        self.register_buffer("causal_mask", torch.triu(torch.ones(3, 3, dtype=torch.bool), 1))
+
+    def forward(self, facts: torch.Tensor) -> torch.Tensor:
+        _validate_facts(facts)
+        tokens = torch.stack(
+            (
+                facts[:, 0],
+                facts[:, 1] + self.n_entities,
+                torch.full_like(facts[:, 0], self.query_id),
+            ),
+            dim=1,
+        )
+        embedded = self.token_embedding(tokens)
+        embedded = embedded + self.position_embedding(torch.arange(3, device=facts.device))
+        encoded = self.encoder(embedded, mask=self.causal_mask)
+        return self.answer_head(encoded[:, -1])
+
+
+def _validate_facts(facts: torch.Tensor) -> None:
+    if facts.ndim != 2 or facts.shape[1] != 2 or facts.dtype != torch.long:
+        raise ValueError("facts must be an int64 tensor with shape (n_facts, 2)")
+
+
+def build_model(
+    model_type: str,
+    n_entities: int,
+    n_attributes: int,
+    n_answers: int,
+    width: int = 32,
+    hidden: int = 64,
+    layers: int = 2,
+    heads: int = 4,
+) -> nn.Module:
+    """Construct an MLP or a causal transformer; initialization uses the torch RNG."""
+    for name, value in {
+        "n_entities": n_entities,
+        "n_attributes": n_attributes,
+        "n_answers": n_answers,
+        "width": width,
+        "hidden": hidden,
+        "layers": layers,
+        "heads": heads,
+    }.items():
+        if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+            raise ValueError(f"{name} must be a positive integer")
+    if model_type == "mlp":
+        return FactMLP(n_entities, n_attributes, n_answers, width, hidden, layers)
+    if model_type == "transformer":
+        if width % heads:
+            raise ValueError("transformer width must be divisible by heads")
+        return FactTransformer(n_entities, n_attributes, n_answers, width, hidden, layers, heads)
+    raise ValueError("model_type must be 'mlp' or 'transformer'")
+
+
+def edit_parameters(model: nn.Module, scope: str = "ffn") -> list[nn.Parameter]:
+    """Freeze outside the chosen edit scope, returning the exact optimizer parameters."""
+    if scope not in {"ffn", "all"}:
+        raise ValueError("scope must be 'ffn' or 'all'")
+    if scope == "all":
+        selected = list(model.parameters())
+    elif isinstance(model, FactMLP):
+        selected = list(model.hidden.parameters())
+    elif isinstance(model, FactTransformer):
+        selected = [
+            parameter
+            for layer in model.encoder.layers
+            for linear in (layer.linear1, layer.linear2)
+            for parameter in linear.parameters()
+        ]
+    else:
+        raise ValueError("ffn scope requires a FactMLP or FactTransformer")
+    selected_ids = {id(parameter) for parameter in selected}
+    for parameter in model.parameters():
+        parameter.requires_grad_(id(parameter) in selected_ids)
+        parameter.grad = None
+    return selected

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture.py

@@ -0,0 +1,443 @@
+"""Paired GPT-2 architecture extensions for the closed-book memory experiment.
+
+Dense execution delegates to the historical ReproductionGPT without changing
+its numerical path. New modules use an independent, checkpointed initialization
+seed; the eight-block reference is always constructed before taking a prefix.
+The mHC residual convention is ``output[n] = sum_m H_res[m,n] * input[m]``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+from collections.abc import Sequence
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+from transformers import GPT2Config
+from transformers.models.gpt2.modeling_gpt2 import GPT2MLP
+
+from .grokking_reproduction import ReproductionGPT
+
+ARMS = {
+    "D4": (4, 1, "dense"),
+    "D8": (8, 1, "dense"),
+    "L4R2": (4, 2, "dense"),
+    "M8": (8, 1, "moe"),
+    "W8": (8, 1, "wide"),
+    "IHC8": (8, 1, "identity_mhc"),
+    "HC8": (8, 1, "mhc"),
+    "M4": (4, 1, "moe"),
+    "LM4R2": (4, 2, "moe"),
+}
+
+
+def sinkhorn(logits: torch.Tensor, iterations: int = 20, eps: float = 1e-6):
+    """Accepted mHC A.6: initial row softmax, then 20 column normalizations.
+
+    There are 19 intervening row normalizations. This is a finite-iteration
+    approximation, not an exact doubly stochastic projection.
+    """
+    if iterations < 1:
+        raise ValueError("Sinkhorn requires at least one iteration")
+    with torch.autocast(logits.device.type, enabled=False):
+        matrix = logits.float().softmax(dim=-1) + eps
+        matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps)
+        for _ in range(iterations - 1):
+            matrix = matrix / (matrix.sum(dim=-1, keepdim=True) + eps)
+            matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps)
+    return matrix
+
+
+def residual_mix(streams, matrix):
+    """Rows are source streams and columns are destination streams."""
+    return torch.einsum("...mn,...mc->...nc", matrix, streams)
+
+
+class ControllerRMSNorm(nn.Module):
+    def __init__(self, width):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(width))
+
+    def forward(self, x):
+        return x * torch.rsqrt(x.square().mean(dim=-1, keepdim=True) + 1e-20) * self.weight
+
+
+class HyperConnection(nn.Module):
+    """Four-stream pre/post controller with optional constrained residual map."""
+
+    def __init__(self, width, sublayer_id, streams=4, identity=False):
+        super().__init__()
+        self.streams, self.identity = streams, identity
+        count = 2 * streams + (0 if identity else streams * streams)
+        self.norm = ControllerRMSNorm(streams * width)
+        self.projection = nn.Linear(streams * width, count, bias=False)
+        nn.init.zeros_(self.projection.weight)
+        self.pre_bias = nn.Parameter(torch.full((streams,), -3.0))
+        with torch.no_grad():
+            self.pre_bias[sublayer_id % streams] = 3.0
+        self.post_bias = nn.Parameter(torch.zeros(streams))
+        self.alpha_pre = nn.Parameter(torch.tensor(0.01))
+        self.alpha_post = nn.Parameter(torch.tensor(0.01))
+        if not identity:
+            self.res_bias = nn.Parameter(6 * torch.eye(streams) - 3)
+            self.alpha_res = nn.Parameter(torch.tensor(0.01))
+
+    def coefficients(self, x):
+        n = self.streams
+        with torch.autocast(x.device.type, enabled=False):
+            dynamic = self.projection(self.norm(x.float().flatten(-2)))
+            pre = torch.sigmoid(dynamic[..., :n] * self.alpha_pre + self.pre_bias) + 1e-6
+            post = 2 * torch.sigmoid(dynamic[..., n : 2 * n] * self.alpha_post + self.post_bias)
+            res = None
+            if not self.identity:
+                logits = dynamic[..., 2 * n :].reshape(*x.shape[:-2], n, n)
+                res = sinkhorn(logits * self.alpha_res + self.res_bias)
+        return pre, post, res
+
+    def forward(self, x, sublayer):
+        pre, post, res = self.coefficients(x)
+        with torch.autocast(x.device.type, enabled=False):
+            contracted = (pre[..., None] * x.float()).sum(dim=-2)
+        y = sublayer(contracted.to(x.dtype))
+        with torch.autocast(x.device.type, enabled=False):
+            residual = x.float() if res is None else residual_mix(x.float(), res)
+            output = residual + post[..., None] * y.float().unsqueeze(-2)
+        return output.to(x.dtype)
+
+
+def _initialize_mlp(mlp, initializer_range):
+    # Eight-block GPT-2 reference residual projection scale, also for loops.
+    nn.init.normal_(mlp.c_fc.weight, std=initializer_range)
+    nn.init.normal_(mlp.c_proj.weight, std=initializer_range / math.sqrt(2 * 8))
+    nn.init.zeros_(mlp.c_fc.bias)
+    nn.init.zeros_(mlp.c_proj.bias)
+
+
+class DroplessMoE(nn.Module):
+    """Top-2 normalized routing, one output dropout, no capacity/token drops."""
+
+    def __init__(self, config, experts=8, top_k=2):
+        super().__init__()
+        self.expert_count, self.top_k = experts, top_k
+        self.router = nn.Linear(config.n_embd, experts, bias=False)
+        nn.init.normal_(self.router.weight, std=config.initializer_range)
+        self.experts = nn.ModuleList()
+        for _ in range(experts):
+            expert = GPT2MLP(2 * config.n_embd, config)
+            expert.dropout = nn.Identity()
+            _initialize_mlp(expert, config.initializer_range)
+            self.experts.append(expert)
+        self.dropout = nn.Dropout(config.resid_pdrop)
+
+    def forward(self, x, valid_mask=None):
+        flat = x.reshape(-1, x.shape[-1])
+        if valid_mask is None:
+            selected_tokens = torch.arange(len(flat), device=x.device)
+        else:
+            selected_tokens = valid_mask.flatten().nonzero(as_tuple=True)[0]
+        valid = flat.index_select(0, selected_tokens)
+        with torch.autocast(x.device.type, enabled=False):
+            probabilities = F.linear(valid.float(), self.router.weight.float()).softmax(-1)
+            top_weights, expert_ids = probabilities.topk(self.top_k, dim=-1)
+            weights = top_weights / top_weights.sum(dim=-1, keepdim=True)
+        # Accumulate selected expert outputs in FP32 for consistent BF16 routing.
+        combined = torch.zeros_like(valid, dtype=torch.float32)
+        for expert_id, expert in enumerate(self.experts):
+            token_ids, slots = (expert_ids == expert_id).nonzero(as_tuple=True)
+            if token_ids.numel():
+                values = expert(valid.index_select(0, token_ids))
+                weighted = values.float() * weights[token_ids, slots, None]
+                combined = combined.index_add(0, token_ids, weighted)
+        output = torch.zeros_like(flat).index_copy(0, selected_tokens, combined.to(flat.dtype))
+        counts = torch.bincount(expert_ids.flatten(), minlength=self.expert_count).detach()
+        n_valid = probabilities.new_tensor(len(valid))
+        stats = {
+            "assignment_counts": counts,
+            "probability_sum": probabilities.sum(dim=0),
+            "valid_tokens": n_valid,
+            "top_k": self.top_k,
+            "processed_assignments": counts.sum(),
+            "dropped_assignments": counts.new_zeros(()),
+            "entropy_sum": -(probabilities * probabilities.clamp_min(1e-30).log()).sum().detach(),
+            "selected_mass_sum": top_weights.sum().detach(),
+        }
+        return self.dropout(output.view_as(x)), stats
+
+
+def combine_router_fractions(stats_by_microbatch: Sequence[Sequence[dict]]):
+    """Combine detached counts before a replay that computes exact batch aux.
+
+    Counts are per executed block (thus distinguish Loop passes). Replay must
+    restore dropout RNG state, so its hard routes equal the counting pass.
+    """
+    if not stats_by_microbatch or not stats_by_microbatch[0]:
+        return [], 0
+    layers = len(stats_by_microbatch[0])
+    if any(len(stats) != layers for stats in stats_by_microbatch):
+        raise ValueError("All microbatches must have the same executed routing layers")
+    total = sum(stats[0]["valid_tokens"] for stats in stats_by_microbatch)
+    fractions = []
+    for layer in range(layers):
+        counts = sum(stats[layer]["assignment_counts"] for stats in stats_by_microbatch)
+        fractions.append(
+            counts.float() / (total * stats_by_microbatch[0][layer]["top_k"]).clamp_min(1)
+        )
+    return fractions, total
+
+
+def router_balance_loss(stats, assignment_fractions=None, total_valid_tokens=None):
+    """N * sum(f * p), averaged over executed layers.
+
+    With externally supplied whole-batch fractions and denominator, this returns
+    the current microbatch's additive contribution to the exact batch objective.
+    Assignment fractions are discrete and intentionally detached.
+    """
+    if not stats:
+        return torch.tensor(0.0)
+    if assignment_fractions is not None and len(assignment_fractions) != len(stats):
+        raise ValueError("One assignment-fraction vector is required per executed layer")
+    losses = []
+    for index, record in enumerate(stats):
+        count = record["valid_tokens"]
+        denominator = count if total_valid_tokens is None else total_valid_tokens
+        denominator = torch.as_tensor(denominator, device=count.device).clamp_min(1)
+        fractions = (
+            record["assignment_counts"].float() / (count * record["top_k"]).clamp_min(1)
+            if assignment_fractions is None
+            else assignment_fractions[index].detach()
+        )
+        probabilities = record["probability_sum"] / denominator
+        losses.append(probabilities.numel() * (fractions * probabilities).sum())
+    return torch.stack(losses).mean()
+
+
+class ParametricGPT(ReproductionGPT):
+    def __init__(self, config, architecture="D8", module_seed=0):
+        blocks, repeats, kind = ARMS[architecture]
+        # Always initialize the same independent eight blocks before slicing.
+        config.n_layer = 8
+        super().__init__(config, repeats=repeats)
+        self.transformer.h = nn.ModuleList(list(self.transformer.h)[:blocks])
+        self.config.n_layer = blocks
+        self.architecture, self.kind, self.module_seed = architecture, kind, module_seed
+        with torch.random.fork_rng(devices=[]):
+            torch.manual_seed(module_seed)
+            if kind in {"wide", "moe"}:
+                for block in self.transformer.h:
+                    if kind == "moe":
+                        block.mlp = DroplessMoE(config)
+                    else:
+                        block.mlp = GPT2MLP(16 * config.n_embd, config)
+                        _initialize_mlp(block.mlp, config.initializer_range)
+            elif kind in {"mhc", "identity_mhc"}:
+                self.connections = nn.ModuleList(
+                    HyperConnection(config.n_embd, index, identity=kind == "identity_mhc")
+                    for index in range(2 * blocks)
+                )
+
+    def _attention(self, block, x):
+        cfg = self.config
+        batch, length = x.shape[:2]
+        q, k, v = block.attn.c_attn(block.ln_1(x)).split(cfg.n_embd, dim=2)
+        shape = (batch, length, cfg.n_head, cfg.n_embd // cfg.n_head)
+        q, k, v = (a.view(shape).transpose(1, 2) for a in (q, k, v))
+        y = F.scaled_dot_product_attention(
+            q, k, v, is_causal=True, dropout_p=cfg.attn_pdrop if self.training else 0.0
+        )
+        y = block.attn.c_proj(y.transpose(1, 2).reshape(batch, length, cfg.n_embd))
+        return F.dropout(y, cfg.resid_pdrop, self.training)
+
+    def forward(self, tokens, positions=None, *, valid_mask=None, return_aux=False):
+        if valid_mask is not None and (
+            valid_mask.shape != tokens.shape or valid_mask.dtype != torch.bool
+        ):
+            raise ValueError("valid_mask must be boolean and have the tokens' shape")
+        if self.kind in {"dense", "wide"}:
+            logits = super().forward(tokens, positions)
+            if return_aux:
+                return logits, {"balance_loss": logits.new_zeros(()), "router_stats": []}
+            return logits
+        cfg, t = self.config, self.transformer
+        length = tokens.shape[1]
+        x = t.wte(tokens) + t.wpe(torch.arange(length, device=tokens.device))
+        x = F.dropout(x, cfg.embd_pdrop, self.training)
+        stats = []
+        if self.kind in {"mhc", "identity_mhc"}:
+            x = x.unsqueeze(-2).expand(-1, -1, 4, -1)
+        for _ in range(self.repeats):
+            for index, block in enumerate(t.h):
+                if self.kind == "moe":
+                    x = x + self._attention(block, x)
+                    y, layer_stats = block.mlp(block.ln_2(x), valid_mask)
+                    x = x + y
+                    stats.append(layer_stats)
+                else:
+                    x = self.connections[2 * index](x, lambda z, b=block: self._attention(b, z))
+                    x = self.connections[2 * index + 1](x, lambda z, b=block: b.mlp(b.ln_2(z)))
+        if self.kind in {"mhc", "identity_mhc"}:
+            x = x.mean(dim=-2)
+        x = t.ln_f(x)
+        if positions is not None:
+            x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions]
+        logits = F.linear(x, t.wte.weight)
+        if return_aux:
+            loss = router_balance_loss(stats) if stats else logits.new_zeros(())
+            return logits, {"balance_loss": loss, "router_stats": stats}
+        return logits
+
+
+def construct(config, spec, device):
+    """Historical config/spec convention, extended by ``spec['architecture']``."""
+    architecture = spec["architecture"]
+    if architecture not in ARMS:
+        raise ValueError(f"Unknown architecture: {architecture}")
+    torch.manual_seed(spec["initialization"])
+    cfg = GPT2Config(
+        vocab_size=config["vocab_size"],
+        n_positions=config.get("positions", 1024),
+        n_embd=config["hidden_size"],
+        n_head=config.get("attention_heads", config.get("heads", 12)),
+        n_layer=8,
+        resid_pdrop=config["dropout"],
+        embd_pdrop=config["dropout"],
+        attn_pdrop=config["dropout"],
+        activation_function="gelu_new",
+        use_cache=False,
+    )
+    # Separate reproducible new-shape RNG, explicitly recorded in the manifest.
+    module_seed = spec.get("module_initialization", spec["initialization"] + 1_000_003)
+    model = ParametricGPT(cfg, architecture, module_seed)
+    model.initialization_seed = spec["initialization"]
+    return model.to(device)
+
+
+def optimizer_for(model, lr, decay):
+    groups = [{"params": [], "weight_decay": decay}, {"params": [], "weight_decay": 0.0}]
+    for name, parameter in model.named_parameters():
+        if not parameter.requires_grad:
+            continue
+        exempt = any(part in name for part in ("bias", "ln"))
+        exempt |= name.startswith("connections.") and (".norm." in name or ".alpha_" in name)
+        groups[int(exempt)]["params"].append(parameter)
+    return torch.optim.AdamW(
+        groups, lr=lr, betas=(0.9, 0.999), eps=1e-8, fused=next(model.parameters()).is_cuda
+    )
+
+
+def parameter_ledger(model):
+    d, layers = model.config.n_embd, len(model.transformer.h)
+    total = sum(parameter.numel() for parameter in model.parameters())
+    expert = sum(p.numel() for n, p in model.named_parameters() if ".experts." in n)
+    controller = sum(p.numel() for n, p in model.named_parameters() if n.startswith("connections."))
+    router = sum(p.numel() for n, p in model.named_parameters() if ".router." in n)
+    fixed = (model.config.vocab_size + model.config.n_positions) * d + 2 * d
+    attention_and_norms = 4 * d * d + 8 * d
+    if model.kind == "moe":
+        per_block = attention_and_norms + 8 * (4 * d * d + 3 * d) + 8 * d
+    else:
+        width = (16 if model.kind == "wide" else 4) * d
+        per_block = attention_and_norms + 2 * d * width + width + d
+    expected_controller = 0
+    if model.kind in {"mhc", "identity_mhc"}:
+        n = 4
+        count = 2 * n + (n * n if model.kind == "mhc" else 0)
+        alphas = 3 if model.kind == "mhc" else 2
+        expected_controller = 2 * layers * (n * d * count + n * d + count + alphas)
+    if controller != expected_controller:
+        raise AssertionError(
+            f"Controller parameter mismatch: {controller} != {expected_controller}"
+        )
+    expected = fixed + layers * per_block + expected_controller
+    if total != expected:
+        raise AssertionError(f"Parameter ledger mismatch: {total} != {expected}")
+    return {
+        "architecture": model.architecture,
+        "total_parameters": total,
+        "trainable_parameters": sum(p.numel() for p in model.parameters() if p.requires_grad),
+        "expected_parameters": expected,
+        "expert_parameters": expert,
+        "router_parameters": router,
+        "controller_parameters": controller,
+        "nominal_parameters_selected_per_token": total - expert + expert // 4,
+        "active_parameter_convention": (
+            "All nonexpert parameters (including whole embedding table) plus two of eight "
+            "experts; not FLOPs or touched embedding rows."
+        ),
+        "unique_blocks": layers,
+        "repeats": model.repeats,
+        "executed_blocks": layers * model.repeats,
+        "residual_streams": 4 if controller else 1,
+        "parameter_dtype": str(next(model.parameters()).dtype),
+        "residual_dtype_under_bf16_autocast": "torch.float32 with FP32 parameters",
+        "controller_dtype": "torch.float32",
+    }
+
+
+def flop_ledger(model, *, executed_tokens, projected_positions, attention_pairs, valid_tokens=None):
+    """Leading forward matmuls with actual padding/dispatch/readout counts.
+
+    ``attention_pairs`` is sum(B*T*T) over microbatches, before block count.
+    Training 3x is explicitly an approximation; Sinkhorn autograd, scalar ops,
+    and a counting/replay pass are not silently folded into this estimate.
+    """
+    d, blocks = model.config.n_embd, len(model.transformer.h) * model.repeats
+    valid_tokens = executed_tokens if valid_tokens is None else valid_tokens
+    attention = blocks * (8 * executed_tokens * d * d + 4 * attention_pairs * d)
+    readout = 2 * projected_positions * d * model.config.vocab_size
+    router = controller = 0
+    if model.kind == "moe":
+        ffn = blocks * 4 * valid_tokens * d * (2 * 2 * d)
+        router = blocks * 2 * valid_tokens * d * 8
+    else:
+        inner = (16 if model.kind == "wide" else 4) * d
+        ffn = blocks * 4 * executed_tokens * d * inner
+    if model.kind in {"mhc", "identity_mhc"}:
+        n = 4
+        count = 2 * n + (n * n if model.kind == "mhc" else 0)
+        controller = (
+            2 * blocks * (2 * executed_tokens * n * d * count + 2 * executed_tokens * d * count)
+        )
+    forward = attention + readout + ffn + router + controller
+    return {
+        "forward_attention_matmul_flops": attention,
+        "forward_ffn_matmul_flops": ffn,
+        "forward_readout_matmul_flops": readout,
+        "forward_router_matmul_flops": router,
+        "forward_controller_matmul_flops": controller,
+        "forward_leading_matmul_flops": forward,
+        "estimated_matmul_training_flops": 3 * forward,
+        "sinkhorn_normalization_passes": 39 if model.kind == "mhc" else 0,
+        "sinkhorn_matrix_elements_per_forward": 2 * blocks * executed_tokens * 16
+        if model.kind == "mhc"
+        else 0,
+        "selected_expert_assignments": blocks * valid_tokens * 2 if model.kind == "moe" else 0,
+        "executed_input_tokens": executed_tokens,
+        "effective_input_tokens": valid_tokens,
+        "projected_positions": projected_positions,
+        "excluded_ops": (
+            "Nonlinearities, normalization, dropout, dispatch/index-add, softmax, Sinkhorn "
+            "scalar arithmetic/autograd, final mean, counting/replay and optimizer; "
+            "3x is approximate."
+        ),
+    }
+
+
+def initialization_manifest(model):
+    """CPU-byte hashes of each actual initialized tensor; no sampled hash."""
+    shared, introduced = {}, {}
+    for name, tensor in model.state_dict().items():
+        is_new = name.startswith("connections.") or (
+            model.kind in {"moe", "wide"} and ".mlp." in name
+        )
+        raw = tensor.detach().cpu().contiguous().reshape(-1).view(torch.uint8).numpy().tobytes()
+        (introduced if is_new else shared)[name] = hashlib.sha256(raw).hexdigest()
+    return {
+        "architecture": model.architecture,
+        "reference_initialization": getattr(model, "initialization_seed", None),
+        "module_initialization": model.module_seed,
+        "reference_blocks_before_slicing": 8,
+        "shared_tensor_sha256": shared,
+        "introduced_tensor_sha256": introduced,
+    }

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture_train.py

@@ -0,0 +1,626 @@
+"""Resumable, exposure-matched training for the parametric architecture study.
+
+The ordinary data stream, answer-plus-EOS objective and generated evaluator are
+shared with the historical experiment. MoE balancing is computed over the true
+effective batch using an RNG-replayed routing pass, not a sum of local products.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import random
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import transformers
+from transformers import GPT2TokenizerFast
+
+from . import realworld_composition as historical
+from .grok_depth import utc
+from .grokking_reproduction import model_digest
+from .realworld_composition_data import sha256, write_json
+
+
+def _architecture():
+    from . import parametric_architecture
+
+    return parametric_architecture
+
+
+def rng_state(device):
+    state = {
+        "python": random.getstate(),
+        "numpy": np.random.get_state(),
+        "cpu": torch.get_rng_state(),
+    }
+    if torch.device(device).type == "cuda":
+        state["cuda"] = torch.cuda.get_rng_state(device)
+    return state
+
+
+def restore_rng(state, device):
+    random.setstate(state["python"])
+    np.random.set_state(state["numpy"])
+    torch.set_rng_state(state["cpu"].cpu())
+    if "cuda" in state:
+        torch.cuda.set_rng_state(state["cuda"].cpu(), device)
+
+
+def pack(records, pad, device):
+    """EOS is a valid input token; validity comes from lengths, never token IDs."""
+    tokens, positions, labels = historical.pack(records, pad, device)
+    lengths = torch.tensor([len(r["encoded"]["input"]) for r in records], device=device)
+    valid = torch.arange(tokens.shape[1], device=device)[None] < lengths[:, None]
+    return tokens, positions, labels, valid
+
+
+def _synchronize(device):
+    if torch.device(device).type == "cuda":
+        torch.cuda.synchronize(device)
+
+
+def _finite(value, name):
+    if not math.isfinite(float(value)):
+        raise FloatingPointError(f"Nonfinite {name}; this candidate must retain its failure")
+
+
+def update(model, optimizer, records, spec, device, pad):
+    """One historical effective batch, with exact full-batch routing gradients.
+
+    Hard assignment fractions have no gradient. A no-grad pass collects their
+    global values when there are multiple microbatches; replaying the same
+    dropout RNG realizes the same routing in the differentiable pass. One
+    microbatch already contains the full objective and needs no prepass.
+    """
+    if not records:
+        raise ValueError("An update requires at least one example")
+    microbatch = int(spec["microbatch_size"])
+    if microbatch < 1:
+        raise ValueError("microbatch_size must be positive")
+    api = _architecture()
+    model.train()
+    optimizer.zero_grad(set_to_none=True)
+    chunks = [records[i : i + microbatch] for i in range(0, len(records), microbatch)]
+    is_moe = spec["architecture"] in {"M8", "M4", "LM4R2"}
+    needs_prepass = is_moe and len(chunks) > 1
+    coefficient = float(spec.get("balance_coefficient", 0.01)) if is_moe else 0.0
+    global_fractions, total_tokens, collected = None, None, []
+    if needs_prepass:
+        before = rng_state(device)
+        try:
+            with torch.no_grad():
+                for chunk in chunks:
+                    tokens, positions, _, valid = pack(chunk, pad, device)
+                    with historical.autocast(device):
+                        _, aux = model(tokens, positions, valid_mask=valid, return_aux=True)
+                    collected.append(aux["router_stats"])
+            global_fractions, total_tokens = api.combine_router_fractions(collected)
+        finally:
+            restore_rng(before, device)
+    answer_loss, balance_loss = 0.0, 0.0
+    executed, readout, attention = 0, 0, 0
+    replay_count_error = torch.zeros((), dtype=torch.int64, device=device)
+    for chunk_index, chunk in enumerate(chunks):
+        tokens, positions, labels, valid = pack(chunk, pad, device)
+        with historical.autocast(device):
+            logits, aux = model(tokens, positions, valid_mask=valid, return_aux=True)
+            answer = historical.example_losses(logits, labels).sum() / len(records)
+            balance = (
+                api.router_balance_loss(
+                    aux["router_stats"],
+                    assignment_fractions=global_fractions,
+                    total_valid_tokens=total_tokens,
+                )
+                if is_moe
+                else answer.new_zeros(())
+            )
+            loss = answer + coefficient * balance
+        if needs_prepass:
+            replay_count_error += sum(
+                (left["assignment_counts"] - right["assignment_counts"]).abs().sum()
+                for left, right in zip(collected[chunk_index], aux["router_stats"], strict=True)
+            )
+        elif is_moe:
+            collected = [aux["router_stats"]]
+            global_fractions, total_tokens = api.combine_router_fractions(collected)
+        _finite(loss.detach(), "objective")
+        loss.backward()
+        answer_loss += float(answer.detach())
+        balance_loss += float(balance.detach())
+        executed += tokens.numel()
+        readout += positions.numel()
+        attention += len(chunk) * tokens.shape[1] ** 2
+    if int(replay_count_error) != 0:
+        raise RuntimeError("MoE RNG replay did not reproduce routing assignment counts")
+    norm = torch.nn.utils.clip_grad_norm_(
+        model.parameters(), float(spec.get("clip_grad_norm", 1.0)), error_if_nonfinite=True
+    )
+    _finite(norm, "gradient norm")
+    optimizer.step()
+    effective = sum(len(r["encoded"]["input"]) for r in records)
+    result = {
+        "loss": answer_loss,
+        "answer_ce": answer_loss,
+        "balance_loss": balance_loss,
+        "balance_coefficient": coefficient,
+        "objective": answer_loss + coefficient * balance_loss,
+        "gradient_norm": float(norm),
+        "executed_input_tokens": executed,
+        "effective_input_tokens": effective,
+        "padding_input_tokens": executed - effective,
+        "readout_positions": readout,
+        "attention_token_pairs": attention,
+        "routing_prepass_executed_input_tokens": executed if needs_prepass else 0,
+        "routing_prepass_effective_input_tokens": effective if needs_prepass else 0,
+    }
+    result["compute"] = api.flop_ledger(
+        model,
+        executed_tokens=executed,
+        valid_tokens=effective,
+        projected_positions=readout,
+        attention_pairs=attention,
+    )
+    prepass = result["compute"]["forward_leading_matmul_flops"] if needs_prepass else 0
+    result["compute"]["routing_prepass_matmul_flops"] = prepass
+    result["estimated_matmul_training_flops"] = (
+        result["compute"]["estimated_matmul_training_flops"] + prepass
+    )
+    result["compute"]["estimated_total_training_matmul_flops"] = result[
+        "estimated_matmul_training_flops"
+    ]
+    if is_moe:
+        layer_count = len(global_fractions)
+        assignments = torch.stack(
+            [sum(c[layer]["assignment_counts"] for c in collected) for layer in range(layer_count)]
+        )
+        processed = torch.stack(
+            [
+                sum(c[layer]["processed_assignments"] for c in collected)
+                for layer in range(layer_count)
+            ]
+        )
+        dropped = sum(s["dropped_assignments"] for c in collected for s in c)
+        if int(dropped) != 0 or not torch.equal(processed, assignments.sum(-1)):
+            raise AssertionError("Dropless routing lost selected token assignments")
+        result["router"] = {
+            "assignment_fractions": torch.stack(global_fractions).detach().cpu().tolist(),
+            "assignment_counts": assignments.detach().cpu().tolist(),
+            "valid_tokens_per_layer": effective,
+            "selected_assignments_per_layer": assignments.sum(-1).detach().cpu().tolist(),
+            "processed_assignments_per_layer": processed.detach().cpu().tolist(),
+            "router_entropy_per_layer": torch.stack(
+                [
+                    sum(c[layer]["entropy_sum"] for c in collected) / effective
+                    for layer in range(layer_count)
+                ]
+            )
+            .detach()
+            .cpu()
+            .tolist(),
+            "selected_probability_mass_per_layer": torch.stack(
+                [
+                    sum(c[layer]["selected_mass_sum"] for c in collected) / effective
+                    for layer in range(layer_count)
+                ]
+            )
+            .detach()
+            .cpu()
+            .tolist(),
+            "dropped_assignments": int(dropped),
+            "replay_assignment_count_error": int(replay_count_error),
+            "replay_checked": needs_prepass,
+            "balance_scope": (
+                "full_effective_batch_two_pass_rng_replay"
+                if needs_prepass
+                else "full_effective_batch_single_forward"
+            ),
+        }
+    return result
+
+
+def selection_score(metrics):
+    """Frozen development panels only; no held-out-composition selection."""
+    atomic, composition = metrics["atomic"]["nll"], metrics["train_composition"]["nll"]
+    if atomic is None or composition is None:
+        raise ValueError("Both fixed development panels need answer NLL measurements")
+    value = 0.5 * atomic + 0.5 * composition
+    _finite(value, "development selection NLL")
+    return value
+
+
+def _routing_metrics(router):
+    """Expose numeric dictionaries to the existing W&B sidecar's flattening."""
+    if not router:
+        return {}
+    return {
+        "dropped_assignments": router["dropped_assignments"],
+        "replay_assignment_count_error": router["replay_assignment_count_error"],
+        "layers": {
+            str(layer): {
+                "entropy": router["router_entropy_per_layer"][layer],
+                "selected_probability_mass": router["selected_probability_mass_per_layer"][layer],
+                "expert_fraction": {str(i): value for i, value in enumerate(fractions)},
+            }
+            for layer, fractions in enumerate(router["assignment_fractions"])
+        },
+    }
+
+
+def save_checkpoint(path, model, optimizer, stream, counts, step, counters, device, **extra):
+    path = Path(path)
+    temporary = path.with_suffix(".tmp")
+    torch.save(
+        {
+            "format_version": 1,
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "stream": stream.state_dict(),
+            "counts": counts,
+            "step": step,
+            "counters": counters,
+            "rng": rng_state(device),
+            **extra,
+        },
+        temporary,
+    )
+    temporary.replace(path)
+
+
+def load_checkpoint(path, model, optimizer, stream, device):
+    state = torch.load(path, map_location="cpu", weights_only=False)
+    model.load_state_dict(state["model"])
+    optimizer.load_state_dict(state["optimizer"])
+    stream.load_state_dict(state["stream"])
+    restore_rng(state["rng"], device)
+    return state
+
+
+def _identity(config, spec):
+    payload = {
+        "model": config["model"],
+        "spec": spec,
+        "data_sha256": config["data_sha256"],
+        "tokenizer_sha256": config.get("tokenizer_sha256", config.get("tokenizer_files", {})),
+        "source_files": config.get("source_files", {}),
+    }
+    return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()
+
+
+def verify(config, config_path=None):
+    """Check the concrete execution freeze; the historical design is not mutated."""
+    if config.get("launch_enabled") is False:
+        raise ValueError("This configuration explicitly disables execution")
+    if sha256(config["data_file"]) != config["data_sha256"]:
+        raise ValueError("Frozen data changed")
+    for name, expected in config.get("tokenizer_sha256", {}).items():
+        path = Path(config["tokenizer"]) / name
+        if sha256(path) != expected:
+            raise ValueError(f"Frozen tokenizer changed: {path}")
+    for group in ("tokenizer_files", "source_files"):
+        for path, expected in config.get(group, {}).items():
+            if sha256(path) != expected:
+                raise ValueError(f"Frozen {group} changed: {path}")
+    if config.get("source_root"):
+        root = Path(config["source_root"]).resolve()
+        for module in (Path(__file__), Path(_architecture().__file__), Path(historical.__file__)):
+            if not module.resolve().is_relative_to(root):
+                raise ValueError(f"Imported code is outside the frozen source_root: {module}")
+    if config_path is not None:
+        if not config.get("execution_lock"):
+            raise ValueError("CLI requires an execution_lock with the frozen config hash")
+        lock = json.loads(Path(config["execution_lock"]).read_text())
+        if lock["config_sha256"] != sha256(config_path):
+            raise ValueError("Frozen configuration changed")
+        if "torch" in lock.get("environment", {}):
+            if str(torch.__version__) != lock["environment"]["torch"]:
+                raise ValueError("Frozen torch version changed")
+        if "transformers" in lock.get("environment", {}):
+            if transformers.__version__ != lock["environment"]["transformers"]:
+                raise ValueError("Frozen transformers version changed")
+
+
+def _setup(device, config):
+    torch.set_num_threads(int(config.get("cpu_threads", 4)))
+    if torch.device(device).type == "cuda":
+        torch.cuda.set_device(device)
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.cuda.reset_peak_memory_stats(device)
+
+
+def _resources(device):
+    if torch.device(device).type != "cuda":
+        return {"peak_gpu_memory_bytes": 0, "peak_gpu_reserved_bytes": 0}
+    return {
+        "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(device),
+        "peak_gpu_reserved_bytes": torch.cuda.max_memory_reserved(device),
+    }
+
+
+def _process_identity():
+    """Different containers can both run Python as PID 1; identify the namespace."""
+    identity = {"pid": os.getpid()}
+    if Path("/proc/self/stat").exists():
+        identity["pid_namespace"] = os.readlink("/proc/self/ns/pid")
+        identity["start_ticks"] = Path("/proc/self/stat").read_text().rsplit(")", 1)[1].split()[19]
+    return identity
+
+
+def run(config, spec, out, device="cuda:0"):
+    """Train one frozen candidate. An independent process must subsequently audit."""
+    verify(config)
+    _setup(device, config)
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "trained.json").exists():
+        trained = json.loads((out / "trained.json").read_text())
+        if trained["identity"] != _identity(config, spec):
+            raise ValueError("Existing output belongs to a different frozen training recipe")
+        return trained
+    api = _architecture()
+    data = json.loads(Path(config["data_file"]).read_text())
+    tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True)
+    records = data["atoms"] + data["train_compositions"]
+    model = api.construct(config["model"], spec, device)
+    optimizer = api.optimizer_for(model, spec["learning_rate"], spec["weight_decay"])
+    stream = historical.BatchStream(len(records), spec["sampling_seed"])
+    identity = _identity(config, spec)
+    counts = np.zeros(len(records), dtype=np.int64)
+    counters = {
+        "training_seconds": 0.0,
+        "examples": 0,
+        "supervised_tokens": 0,
+        "executed_input_tokens": 0,
+        "effective_input_tokens": 0,
+        "estimated_matmul_training_flops": 0,
+        "routing_prepass_executed_input_tokens": 0,
+    }
+    initial_step, wall_offset, history, last = 0, 0.0, [], {}
+    if (out / "latest.pt").exists():
+        saved = load_checkpoint(out / "latest.pt", model, optimizer, stream, device)
+        if saved["identity"] != identity:
+            raise ValueError("Checkpoint belongs to a different frozen training recipe")
+        counts, initial_step, counters = saved["counts"], saved["step"], saved["counters"]
+        wall_offset, last = saved.get("wall_seconds", 0.0), saved.get("last_update", {})
+        learning = out / "learning.json"
+        history = [r for r in json.loads(learning.read_text()) if r["step"] <= initial_step]
+        metadata = json.loads((out / "run.json").read_text())
+        metadata.update(pid=os.getpid(), resumed_from_step=initial_step)
+        del saved
+    else:
+        torch.manual_seed(spec["dropout_seed"])
+        random.seed(spec["dropout_seed"])
+        np.random.seed(spec["dropout_seed"])
+        metadata = {
+            "spec": spec,
+            "model": config["model"],
+            "phase": config.get("phase", "development"),
+            "evaluation_nodes": config["evaluation_nodes"],
+            "world_sha256": config["data_sha256"],
+            "initial_model_sha256": model_digest(model),
+            "initial_tensor_sha256": historical.tensor_digests(model),
+            "initialization_manifest": api.initialization_manifest(model),
+            "parameters": sum(p.numel() for p in model.parameters()),
+            "parameter_ledger": api.parameter_ledger(model),
+            "atomic_examples": len(data["atoms"]),
+            "composition_examples": len(data["train_compositions"]),
+            "vocab_size": len(tokenizer),
+            "dtype": "BF16 AMP; FP32 parameters and Adam states",
+            "device": str(device),
+            "gpu": torch.device(device).index or 0,
+            "gpu_name": torch.cuda.get_device_name(device)
+            if torch.device(device).type == "cuda"
+            else "cpu",
+            "pid": os.getpid(),
+            "job_type": config.get("phase", "development") + "-training",
+            "tracking_group": config.get("tracking", {}).get("group", config.get("experiment")),
+            "learning_step_unit": "optimizer_updates",
+            "identity": identity,
+            "selection": "0.5 atomic + 0.5 train-composition NLL on original fixed panels",
+            "selection_panel_sizes": {
+                key: len(data["panels"][key]) for key in ("atomic", "train_composition")
+            },
+            "moe_balance": (
+                "full-effective-batch; single forward when one microbatch, otherwise two-pass "
+                "RNG replay; actual prepass compute included"
+            ),
+            "learning_rate_schedule": "historical lr * min((step - 1) / warmup_steps, 1)",
+        }
+        if config.get("execution_lock"):
+            metadata["execution_lock_sha256"] = sha256(config["execution_lock"])
+    write_json(out / "run.json", metadata)
+    write_json(out / "learning.json", history)
+    nodes = set(config["evaluation_nodes"]) | {int(spec["steps"])}
+    log_interval = int(config.get("log_interval", 100))
+    checkpoint_interval = int(config.get("resume_checkpoint_interval", 1000))
+    started = time.perf_counter()
+
+    def checkpoint(step):
+        save_checkpoint(
+            out / "latest.pt",
+            model,
+            optimizer,
+            stream,
+            counts,
+            step,
+            counters,
+            device,
+            identity=identity,
+            wall_seconds=wall_offset + time.perf_counter() - started,
+            last_update=last,
+        )
+
+    for step in range(initial_step, spec["steps"] + 1):
+        if step > initial_step:
+            warmup = int(spec["warmup_steps"])
+            lr = spec["learning_rate"] * (min((step - 1) / warmup, 1.0) if warmup else 1.0)
+            for group in optimizer.param_groups:
+                group["lr"] = lr
+            ids = stream.batch(spec["batch_size"])
+            selected = [records[i] for i in ids]
+            _synchronize(device)
+            begin = time.perf_counter()
+            last = update(model, optimizer, selected, spec, device, tokenizer.eos_token_id)
+            _synchronize(device)
+            counters["training_seconds"] += time.perf_counter() - begin
+            counts[ids] += 1
+            counters["examples"] += len(ids)
+            counters["supervised_tokens"] += sum(len(r["encoded"]["target"]) for r in selected)
+            for key in (
+                "executed_input_tokens",
+                "effective_input_tokens",
+                "estimated_matmul_training_flops",
+                "routing_prepass_executed_input_tokens",
+            ):
+                counters[key] += last[key]
+        if step in nodes or step % log_interval == 0:
+            if not any(r["step"] == step for r in history):
+                metrics = {}
+                if step in nodes:
+                    metrics, predictions = historical.evaluate_dataset(
+                        model, data, tokenizer, device
+                    )
+                    write_json(out / f"predictions-{step:07d}.json", predictions)
+                    metrics["selection"] = {
+                        "mixed_answer_nll": selection_score(metrics),
+                        "atomic_n": metrics["atomic"]["nll_n"],
+                        "train_composition_n": metrics["train_composition"]["nll_n"],
+                    }
+                if last.get("router"):
+                    metrics["routing"] = _routing_metrics(last["router"])
+                record = {
+                    "step": step,
+                    "metrics": metrics,
+                    **counters,
+                    "wall_seconds": wall_offset + time.perf_counter() - started,
+                    "loss": last.get("answer_ce"),
+                    "answer_ce": last.get("answer_ce"),
+                    "balance_loss": last.get("balance_loss"),
+                    "objective": last.get("objective"),
+                    "gradient_norm": last.get("gradient_norm"),
+                    "learning_rate": optimizer.param_groups[0]["lr"],
+                    "atomic_epochs": float(counts[: len(data["atoms"])].mean()),
+                    "composition_epochs": float(counts[len(data["atoms"]) :].mean()),
+                    "router": last.get("router", {}),
+                    "compute_per_update": last.get("compute", {}),
+                    **_resources(device),
+                    "created_utc": utc(),
+                }
+                history.append(record)
+                write_json(out / "learning.json", history)
+                print(
+                    json.dumps({"step": step, "loss": record["loss"], "metrics": metrics}),
+                    flush=True,
+                )
+            write_json(
+                out / "status.json",
+                {
+                    "state": "training",
+                    "step": step,
+                    "target_step": spec["steps"],
+                    "loss": last.get("answer_ce"),
+                    **counters,
+                    "wall_seconds": wall_offset + time.perf_counter() - started,
+                    "pid": os.getpid(),
+                    "updated_utc": utc(),
+                },
+            )
+        if step in nodes or (step > initial_step and step % checkpoint_interval == 0):
+            checkpoint(step)
+            if step in nodes:
+                target = out / f"checkpoint-{step:07d}.pt"
+                temporary = target.with_suffix(".tmp")
+                torch.save(
+                    {"model": model.state_dict(), "step": step, "identity": identity}, temporary
+                )
+                temporary.replace(target)
+                np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts)
+    metrics, predictions = historical.evaluate_dataset(
+        model, data, tokenizer, device, full=True, autonomous=True
+    )
+    write_json(out / "endpoint-predictions.json", predictions)
+    write_json(out / "endpoint.json", metrics)
+    result = {
+        "state": "trained_pending_independent_reload",
+        "step": spec["steps"],
+        "pid": os.getpid(),
+        "process_identity": _process_identity(),
+        "identity": identity,
+        "model_sha256": model_digest(model),
+        "checkpoint_sha256": sha256(out / "latest.pt"),
+        **counters,
+        "selection_mixed_answer_nll": next(
+            r["metrics"]["selection"]["mixed_answer_nll"]
+            for r in reversed(history)
+            if r["step"] == spec["steps"]
+        ),
+        "wall_seconds": wall_offset + time.perf_counter() - started,
+        "completed_utc": utc(),
+    }
+    write_json(out / "trained.json", result)
+    write_json(out / "status.json", result)
+    return result
+
+
+def audit(config, spec, out, device="cuda:0"):
+    """Reconstruct and regenerate the full endpoint in an independent process."""
+    verify(config)
+    _setup(device, config)
+    out = Path(out)
+    trained = json.loads((out / "trained.json").read_text())
+    same_process = (
+        trained["process_identity"] == _process_identity()
+        if "process_identity" in trained
+        else trained["pid"] == os.getpid()
+    )
+    if same_process:
+        raise ValueError("Independent audit must run in a different process")
+    if trained["identity"] != _identity(config, spec):
+        raise ValueError("Audit recipe differs from the training freeze")
+    if sha256(out / "latest.pt") != trained["checkpoint_sha256"]:
+        raise ValueError("Training checkpoint changed")
+    model = _architecture().construct(config["model"], spec, device)
+    checkpoint = torch.load(out / "latest.pt", map_location="cpu", weights_only=False)
+    if checkpoint["step"] != spec["steps"]:
+        raise ValueError("Final checkpoint does not contain the requested endpoint")
+    model.load_state_dict(checkpoint["model"])
+    del checkpoint
+    if model_digest(model) != trained["model_sha256"]:
+        raise ValueError("Reloaded model does not match the trained endpoint")
+    data = json.loads(Path(config["data_file"]).read_text())
+    tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True)
+    metrics, predictions = historical.evaluate_dataset(
+        model, data, tokenizer, device, full=True, autonomous=True
+    )
+    if predictions != json.loads((out / "endpoint-predictions.json").read_text()):
+        raise AssertionError("Independent endpoint generation or NLL failed exact reproduction")
+    if metrics != json.loads((out / "endpoint.json").read_text()):
+        raise AssertionError("Independent endpoint metric recount failed")
+    result = {
+        "passed": True,
+        "pid": os.getpid(),
+        "source_training_pid": trained["pid"],
+        "process_identity": _process_identity(),
+        "source_process_identity": trained.get("process_identity"),
+        "checkpoint_sha256": trained["checkpoint_sha256"],
+        "model_sha256": trained["model_sha256"],
+        "predictions_recomputed": sum(len(p) for p in predictions.values()),
+        "completed_utc": utc(),
+    }
+    write_json(out / "audit.json", result)
+    write_json(
+        out / "complete.json", {**trained, "state": "complete", "independently_reloaded": True}
+    )
+    write_json(
+        out / "status.json",
+        {
+            "state": "complete",
+            "step": spec["steps"],
+            "independently_reloaded": True,
+        },
+    )
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_constraints.py

@@ -0,0 +1,94 @@
+"""Constrained response primitives; empirical scopes are recorded by the runner."""
+
+from __future__ import annotations
+
+import hashlib
+
+import torch
+
+
+def select_records(records, count, seed, role):
+    """Select before diagnostics, independently of accuracy or measured geometry."""
+    if len(records) < count:
+        raise ValueError(f"Insufficient records for {role}")
+    return sorted(
+        records,
+        key=lambda row: hashlib.sha256(f"{seed}:{role}:{row['case_id']}".encode()).hexdigest(),
+    )[:count]
+
+
+def psd_solve(gram, rhs, rtol):
+    values, vectors = torch.linalg.eigh(gram.double())
+    eligible = values > values.max().clamp_min(1e-30) * rtol
+    projected = vectors[:, eligible].T @ rhs.double()
+    result = vectors[:, eligible] @ (projected / values[eligible])
+    return result, int(eligible.sum())
+
+
+def functional_projection(target, keep, rtol):
+    """Orthogonal projection onto the numerical null space of keep gradients."""
+    g, r = target.double(), keep.double()
+    coefficients, rank = psd_solve(r @ r.T, r @ g, rtol)
+    result = g - coefficients @ r
+    denominator = g.square().sum().clamp_min(1e-30)
+    return result.to(target.dtype), {
+        "rank": rank,
+        "retained_energy": float(result.square().sum() / denominator),
+        "relative_keep_residual": float(
+            (r @ result).norm() / (r.norm() * result.norm()).clamp_min(1e-30)
+        ),
+    }
+
+
+def feature_basis(features, rtol):
+    """Rows are real token features; right singular vectors span protected keys."""
+    _, singular, vh = torch.linalg.svd(features.double(), full_matrices=False)
+    selected = singular > singular[0] * rtol
+    return vh[selected], singular
+
+
+def module_projection(gradient, basis):
+    g = gradient.double()
+    return (g - (g @ basis.T) @ basis).to(gradient.dtype)
+
+
+def local_gradients(x, up, gate, down_weight, output_derivative):
+    """All-position exact SwiGLU chain rule; no replacement of the forward model."""
+    sigmoid = torch.sigmoid(gate)
+    activated = gate * sigmoid
+    derivative = sigmoid + gate * sigmoid * (1 - sigmoid)
+    value_derivative = output_derivative @ down_weight
+    return {
+        "down": output_derivative.T @ (up * activated),
+        "up": (value_derivative * activated).T @ x,
+        "gate": (value_derivative * up * derivative).T @ x,
+    }
+
+
+def route_output(current, original, attention, route):
+    """Forward activation intervention; baseline function is identical at zero update."""
+    if route == "all":
+        return current
+    mask = torch.zeros_like(attention, dtype=torch.bool)
+    mask[torch.arange(len(mask), device=mask.device), attention.sum(1) - 1] = True
+    if route == "earlier":
+        mask = attention.bool() & ~mask
+    elif route != "last":
+        raise ValueError(route)
+    return torch.where(mask.unsqueeze(-1), current, original)
+
+
+def update_scale(direction, target_gradient, step, parameter_norm, cap, metric):
+    d_norm = direction.double().norm()
+    g_norm = target_gradient.double().norm()
+    response = target_gradient.double() @ direction.double()
+    if d_norm == 0 or response <= 0:
+        return 0.0, True
+    if metric == "equal_norm":
+        scale = step / (g_norm * d_norm)
+    elif metric == "equal_target":
+        scale = step / response
+    else:
+        raise ValueError(metric)
+    maximum = cap * parameter_norm / d_norm
+    return float(torch.minimum(scale, maximum)), bool(scale > maximum)

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_learning.py

@@ -0,0 +1,416 @@
+"""Position-routed down updates, complete-answer objectives, and audited data helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from .hebbian_data import TEMPLATE, encode_answer, score_answer
+from .hebbian_model import set_determinism, tensor_hash
+
+ROOT = Path(__file__).resolve().parents[2]
+DATA = ROOT / "data/qwen-path-learning-v1"
+ART = ROOT / "docs/development-artifacts/qwen-path-learning-v1"
+RESULTS = ROOT / "results/qwen-path-learning-v1"
+CONFIG = ROOT / "configs/qwen-path-learning-v1.json"
+GROUPS = ("S_end", "S_other", "C", "W", "L", "A")
+
+# All views ask the same original CounterFact relation; no generated answer labels.
+RELATIONS = {
+    "P19": ("{} was born in", "The birthplace of {} is", "{}'s birthplace is"),
+    "P20": ("{} died in", "The place of death of {} is", "{}'s place of death is"),
+    "P103": (
+        "The native language of {} is",
+        "The mother tongue of {} is",
+        "{}'s native language is",
+    ),
+    "P176": ("The manufacturer of {} is", "{} was manufactured by", "{}'s manufacturer is"),
+    "P178": ("The developer of {} is", "{} was developed by", "{}'s developer is"),
+    "P495": (
+        "The country of origin of {} is",
+        "{} originated in the country of",
+        "{}'s country of origin is",
+    ),
+    "P740": (
+        "{} was founded in",
+        "The place where {} was founded is",
+        "{}'s place of formation is",
+    ),
+    "P364": (
+        "The original language of {} is",
+        "{} was originally in the language",
+        "{}'s original language is",
+    ),
+    "P407": ("The language of {} is", "{} is in the language", "{}'s language is"),
+}
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def read(path):
+    return json.loads(Path(path).read_text())
+
+
+def write(path, obj):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(f".{os.getpid()}.tmp")
+    temporary.write_text(json.dumps(obj, ensure_ascii=False, indent=2, allow_nan=False) + "\n")
+    temporary.replace(path)
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def stable(value):
+    return hashlib.sha256(str(value).encode()).hexdigest()
+
+
+def encode_fact(tokenizer, subject, statement, answer, view=0, plain=False):
+    prompt = statement if plain else TEMPLATE.format(statement)
+    enc = encode_answer(tokenizer, prompt, answer)
+    offset = 0 if plain else prompt.index(statement)
+    subject_start = statement.index(subject) + offset
+    subject_end = subject_start + len(subject)
+    offsets = tokenizer(prompt, add_special_tokens=False, return_offsets_mapping=True)[
+        "offset_mapping"
+    ]
+    subject_tokens = [
+        i for i, (a, b) in enumerate(offsets) if b > subject_start and a < subject_end
+    ]
+    if not subject_tokens:
+        raise ValueError("Subject has no tokens")
+    roles = []
+    for i, (a, b) in enumerate(offsets):
+        if i == len(offsets) - 1:
+            role = "L"
+        elif i == subject_tokens[-1]:
+            role = "S_end"
+        elif i in subject_tokens:
+            role = "S_other"
+        elif b > offset and a < offset + len(statement):
+            role = "C"
+        else:
+            role = "W"
+        roles.append(role)
+    roles += ["A"] * (len(enc["input_ids"]) - len(roles))
+    return {**enc, "prompt": prompt, "roles": roles, "view": view, "plain": plain}
+
+
+def random_positions(roles, group, key, seed, bins=2, draws=16, energies=None):
+    """Disjoint count/bin-matched controls; optional local-energy matching only."""
+    n = roles.index("L") + 1
+    target = [i for i, role in enumerate(roles[: n - 1]) if role == group]
+    if not target:
+        return [], {"valid": False, "reason": "empty_group"}
+
+    def strata(i):
+        return min(bins - 1, i * bins // max(n - 1, 1))
+
+    eligible = {
+        b: [i for i in range(n - 1) if i not in target and strata(i) == b] for b in range(bins)
+    }
+    counts = {b: sum(strata(i) == b for i in target) for b in range(bins)}
+    if any(len(eligible[b]) < counts[b] for b in range(bins)):
+        return [], {"valid": False, "reason": "insufficient_disjoint_positions"}
+    rng = np.random.default_rng(int(stable(f"{key}:{group}:{seed}")[:16], 16))
+    options = []
+    for _ in range(draws if energies is not None else 1):
+        positions = sorted(
+            int(i) for b in range(bins) for i in rng.choice(eligible[b], counts[b], replace=False)
+        )
+        error = (
+            0.0
+            if energies is None
+            else abs(sum(energies[i] for i in positions) - sum(energies[i] for i in target))
+            / max(sum(energies[i] for i in target), 1e-30)
+        )
+        options.append((error, positions))
+    error, selected = min(options, key=lambda x: (x[0], x[1]))
+    return selected, {"valid": True, "relative_energy_error": error, "count": len(target)}
+
+
+def sequence_mean(values, batch_indices, count):
+    sums = values.new_zeros(count).scatter_add_(0, batch_indices, values)
+    return sums / torch.bincount(batch_indices, minlength=count).clamp_min(1)
+
+
+def fisher_quadratic(logp, response):
+    p = logp.exp()
+    return 0.5 * ((p * response.square()).sum(-1) - (p * response).sum(-1).square())
+
+
+class PathEngine:
+    def __init__(self, device, layer=None):
+        self.cfg = read(CONFIG)
+        set_determinism(self.cfg["seed"])
+        self.device = torch.device(device)
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            ROOT / self.cfg["model_source"], local_files_only=True
+        )
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+        self.model = (
+            AutoModelForCausalLM.from_pretrained(
+                ROOT / self.cfg["model_source"],
+                local_files_only=True,
+                dtype=torch.float32,
+                attn_implementation="eager",
+            )
+            .to(self.device)
+            .eval()
+            .requires_grad_(False)
+        )
+        self.layer_index = self.cfg["layer"] if layer is None else layer
+        self.down = self.model.model.layers[self.layer_index].mlp.down_proj
+        self.base_hash = tensor_hash(self.down.weight)
+        self.delta = torch.nn.Parameter(torch.zeros_like(self.down.weight))
+        self.route = "all"
+        self.route_seed = 0
+        self.route_group = None
+        self.route_positions = {}
+        self.mask = None
+        self.capture = None
+        self.handle = self.down.register_forward_hook(self._hook)
+        self.reference = {}
+        self.forward_tokens = 0
+        self.started = time.time()
+
+    def _hook(self, module, args, output):
+        increment = F.linear(args[0], self.delta)
+        if self.capture is not None:
+            self.capture.append(increment.detach().square().sum(-1).cpu())
+        if self.mask is not None:
+            increment = increment * self.mask[:, -increment.shape[1] :, None]
+        return output + increment
+
+    def mask_for(self, enc):
+        roles = enc["roles"]
+        mask = [1.0] * len(roles)
+        if self.route == "all":
+            return mask
+        if "L" not in roles:  # Unannotated natural text has no fact-position groups.
+            return mask
+        if self.route == "group":
+            positions = [i for i, x in enumerate(roles) if x == self.route_group]
+        elif self.route == "random":
+            positions, _ = random_positions(roles, self.route_group, enc["key"], self.route_seed)
+        elif self.route == "positions":
+            positions = self.route_positions.get(enc["key"], [])
+        elif self.route == "zero":
+            positions = list(range(len(roles)))
+        else:
+            raise ValueError(self.route)
+        for i in positions:
+            mask[i] = 0.0
+        return mask
+
+    def batch(self, encoded, prompt_only=False):
+        sequences = [
+            e["input_ids"][: e["answer_start"]] if prompt_only else e["input_ids"] for e in encoded
+        ]
+        width = max(map(len, sequences))
+        ids = torch.full(
+            (len(sequences), width),
+            self.tokenizer.pad_token_id,
+            device=self.device,
+            dtype=torch.long,
+        )
+        attention = torch.zeros_like(ids)
+        loss = torch.zeros_like(ids, dtype=torch.bool)
+        masks = torch.ones_like(ids, dtype=torch.float32)
+        for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)):
+            ids[i, : len(seq)] = torch.tensor(seq, device=self.device)
+            attention[i, : len(seq)] = 1
+            if not prompt_only:
+                loss[i, : len(seq)] = torch.tensor(
+                    enc["loss_mask"], device=self.device, dtype=torch.bool
+                )
+            masks[i, : len(seq)] = torch.tensor(self.mask_for(enc)[: len(seq)], device=self.device)
+        self.mask = masks
+        return ids, attention, loss
+
+    def hidden(self, ids, attention):
+        self.forward_tokens += ids.numel()
+        return self.model.model(
+            input_ids=ids, attention_mask=attention, use_cache=False
+        ).last_hidden_state
+
+    def objectives(self, encoded, include_kl=True):
+        ids, attention, mask = self.batch(encoded)
+        b, t = torch.where(mask[:, 1:])
+        hidden = self.hidden(ids, attention)
+        logits = self.model.lm_head(hidden[b, t])
+        ce = sequence_mean(
+            F.cross_entropy(logits, ids[b, t + 1], reduction="none"), b, len(encoded)
+        )
+        if not include_kl:
+            return ce, None
+        with torch.no_grad():
+            ref_hidden = torch.cat([self.reference[e["key"]] for e in encoded]).to(self.device)
+            ref_log = F.log_softmax(self.model.lm_head(ref_hidden), dim=-1)
+        divergence = (ref_log.exp() * (ref_log - F.log_softmax(logits, dim=-1))).sum(-1)
+        return ce, sequence_mean(divergence, b, len(encoded))
+
+    @torch.no_grad()
+    def cache_reference(self, encoded, batch_size=8):
+        if self.delta.count_nonzero().item():
+            raise ValueError("Reference must be cached at the parent")
+        for start in range(0, len(encoded), batch_size):
+            chunk = encoded[start : start + batch_size]
+            ids, attention, mask = self.batch(chunk)
+            b, t = torch.where(mask[:, 1:])
+            hidden = self.hidden(ids, attention)
+            for i, enc in enumerate(chunk):
+                self.reference[enc["key"]] = hidden[b[b == i], t[b == i]].detach().cpu()
+
+    @torch.no_grad()
+    def generate(self, encoded):
+        # Cached greedy decoding; routing is built from the input prompt alone.
+        sequences = [e["input_ids"][: e["answer_start"]] for e in encoded]
+        width = max(map(len, sequences))
+        ids = torch.full(
+            (len(sequences), width),
+            self.tokenizer.pad_token_id,
+            device=self.device,
+            dtype=torch.long,
+        )
+        attention = torch.zeros_like(ids)
+        route_mask = torch.ones_like(ids, dtype=torch.float32)
+        for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)):
+            ids[i, -len(seq) :] = torch.tensor(seq, device=self.device)
+            attention[i, -len(seq) :] = 1
+            route_mask[i, -len(seq) :] = torch.tensor(
+                self.mask_for(enc)[: len(seq)], device=self.device
+            )
+        tails = [[] for _ in encoded]
+        done = [False] * len(encoded)
+        cache = None
+        for step in range(self.cfg["max_new_tokens"]):
+            position = attention.cumsum(-1) - 1
+            position.masked_fill_(attention == 0, 0)
+            self.mask = (
+                route_mask
+                if step == 0
+                else torch.full(
+                    (len(encoded), 1),
+                    0.0
+                    if self.route == "zero" or (self.route == "group" and self.route_group == "A")
+                    else 1.0,
+                    device=self.device,
+                )
+            )
+            out = self.model.model(
+                input_ids=ids,
+                attention_mask=attention,
+                position_ids=position if step == 0 else position[:, -1:],
+                past_key_values=cache,
+                use_cache=True,
+            )
+            self.forward_tokens += ids.numel()
+            cache = out.past_key_values
+            next_ids = self.model.lm_head(out.last_hidden_state[:, -1]).argmax(-1)
+            for i, token in enumerate(next_ids.tolist()):
+                if not done[i]:
+                    tails[i].append(token)
+                    decoded = self.tokenizer.decode(tails[i], skip_special_tokens=True)
+                    done[i] = token == self.tokenizer.eos_token_id or "\n" in decoded
+            if all(done):
+                break
+            ids = next_ids[:, None]
+            attention = torch.cat([attention, torch.ones_like(ids)], dim=1)
+        return [
+            {
+                "prediction": self.tokenizer.decode(tail, skip_special_tokens=True),
+                "tokens": tail,
+                "eos": self.tokenizer.eos_token_id in tail,
+            }
+            for tail in tails
+        ]
+
+    @torch.no_grad()
+    def evaluate(self, records, views=(0,), batch_size=16, with_kl=True, generate=True):
+        entries = [(r, r["encoded"][v]) for r in records for v in views]
+        output = []
+        for start in range(0, len(entries), batch_size):
+            chunk = entries[start : start + batch_size]
+            encs = [e for _, e in chunk]
+            ce, kl = self.objectives(encs, include_kl=with_kl)
+            predictions = self.generate(encs) if generate else [None] * len(chunk)
+            for i, ((record, enc), prediction) in enumerate(zip(chunk, predictions, strict=True)):
+                item = {
+                    "case_id": record["case_id"],
+                    "view": enc["view"],
+                    "ce": float(ce[i]),
+                    "kl": None if kl is None else float(kl[i]),
+                }
+                if prediction is not None:
+                    item.update(prediction)
+                    item["correct"] = score_answer(prediction["prediction"], record["aliases"])
+                output.append(item)
+        return output
+
+    @torch.no_grad()
+    def evaluate_text(self, encoded):
+        result = []
+        for start in range(0, len(encoded), 2):
+            chunk = encoded[start : start + 2]
+            ce, kl = self.objectives(chunk)
+            result.extend(
+                {"key": e["key"], "ce": float(c), "kl": float(k)}
+                for e, c, k in zip(chunk, ce, kl, strict=True)
+            )
+        return result
+
+    def restore(self):
+        with torch.no_grad():
+            self.delta.zero_()
+        self.route = "all"
+        self.mask = None
+        assert tensor_hash(self.down.weight) == self.base_hash
+
+
+def mean(rows, key):
+    return float(np.mean([r[key] for r in rows])) if rows else None
+
+
+def valid_aliases(raw):
+    by_id = {}
+    for row in raw:
+        target = row["requested_rewrite"]["target_true"]
+        by_id.setdefault(target["id"], set()).add(target["str"].strip())
+    return {k: sorted(v) for k, v in by_id.items()}
+
+
+def articles_from_lines(lines):
+    articles = []
+    title, parts = None, []
+    for line in lines:
+        if re.fullmatch(r"\s*= [^=]+ =\s*", line):
+            if title and parts:
+                articles.append((title, "".join(parts)))
+            title, parts = line.strip(), []
+        elif title:
+            parts.append(line)
+    if title and parts:
+        articles.append((title, "".join(parts)))
+    return articles

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_train.py

@@ -0,0 +1,627 @@
+"""Frozen-matrix execution and development-only selection for path learning."""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import time
+
+import numpy as np
+import torch
+import transformers
+
+from .qwen_path_learning import (
+    ART,
+    CONFIG,
+    DATA,
+    RESULTS,
+    ROOT,
+    PathEngine,
+    digest,
+    encode_fact,
+    mean,
+    now,
+    random_positions,
+    read,
+    write,
+)
+
+
+def preflight(device):
+    from .hebbian_model import aggregate_hash, state_hashes
+
+    cfg = read(CONFIG)
+    old_records = read(ROOT / "data/hebbian-learning-v1/pools.json")["B_dev"][:2]
+    engine = PathEngine(device)
+    encs = []
+    for r in old_records:
+        enc = encode_fact(engine.tokenizer, r["subject"], r["views"][0], r["answer"])
+        enc["key"] = f"preflight-{r['case_id']}"
+        encs.append(enc)
+    before_hash = aggregate_hash(state_hashes(engine.model))
+    assert all(not p.requires_grad for p in engine.model.parameters())
+    assert engine.delta.numel() == 3145728
+    engine.cache_reference(encs)
+    baseline_ce, zero_kl = engine.objectives(encs)
+    baseline_ce = baseline_ce.detach()
+    checks = {
+        "parameter_count": engine.delta.numel(),
+        "zero_kl_max": float(zero_kl.detach().abs().max()),
+    }
+    assert checks["zero_kl_max"] < 1e-5
+    for group in cfg["groups"]:
+        engine.route, engine.route_group = "group", group
+        ce, _ = engine.objectives(encs)
+        assert torch.equal(ce.detach(), baseline_ce)
+    engine.route = "all"
+    with torch.no_grad():
+        engine.delta.normal_(std=1e-5)
+    ids, attention, _ = engine.batch(encs)
+    with torch.no_grad():
+        separate = engine.hidden(ids, attention)
+        delta = engine.delta.clone()
+        original_weight = engine.down.weight.clone()
+        engine.down.weight.add_(delta)
+        engine.delta.zero_()
+        fused = engine.hidden(ids, attention)
+        engine.down.weight.copy_(original_weight)
+        engine.delta.copy_(delta)
+    checks["all_vs_fused_hidden_max_error"] = float((separate - fused).abs().max())
+    assert checks["all_vs_fused_hidden_max_error"] < 1e-3
+    engine.restore()
+    opt = optimizer(engine, 1e-5)
+    begun = time.time()
+    ce, _ = engine.objectives(encs, include_kl=False)
+    ce.mean().backward()
+    checks["delta_gradient_norm"] = float(engine.delta.grad.norm())
+    torch.nn.utils.clip_grad_norm_([engine.delta], cfg["optimizer"]["clip"])
+    opt.step()
+    checks["single_old_episode_step_seconds"] = time.time() - begun
+    assert checks["delta_gradient_norm"] > 0 and torch.isfinite(engine.delta).all()
+    engine.restore()
+    assert aggregate_hash(state_hashes(engine.model)) == before_hash
+    ce, _ = engine.objectives(encs)
+    checks["restore_ce_max_error"] = float((ce.detach() - baseline_ce).abs().max())
+    assert checks["restore_ce_max_error"] == 0
+    del engine
+    torch.cuda.empty_cache()
+    final = PathEngine(device, layer=27)
+    with torch.no_grad():
+        final.delta.normal_(std=1e-4)
+        final.route = "zero"
+        parent_ce, _ = final.objectives(encs, include_kl=False)
+        # Enable only earlier-prompt increments, and disable all readout positions.
+        final.route = "positions"
+        final.route_positions = {
+            e["key"]: list(range(e["answer_start"] - 1, len(e["roles"]))) for e in encs
+        }
+        early_ce, _ = final.objectives(encs, include_kl=False)
+        checks["final_layer_earlier_ce_max_error"] = float((early_ce - parent_ce).abs().max())
+        assert checks["final_layer_earlier_ce_max_error"] == 0
+    final.restore()
+    checks["passed"] = True
+    checks["time"] = now()
+    checks["training_cases"] = "two old B_dev facts; no new developmental outcome selection"
+    checks["parent_model_sha256"] = before_hash
+    write(ART / "preflight.json", checks)
+    print(json.dumps(checks), flush=True)
+
+
+def jobs():
+    cfg = read(CONFIG)
+    return [
+        {
+            "id": f"dev-e{episode}-lr{lr:g}-b{beta}",
+            "episode": episode,
+            "lr": lr,
+            "beta": beta,
+            "seed": 0,
+            "phase": "dev",
+            "condition": "ordinary",
+        }
+        for episode in range(4)
+        for lr in cfg["learning_rates"]
+        for beta in cfg["betas_replay"]
+    ]
+
+
+def sources():
+    return [
+        "configs/qwen-path-learning-v1.json",
+        "scripts/run_qwen_path_learning.py",
+        "src/llm_memory_editability/qwen_path_learning.py",
+        "src/llm_memory_editability/qwen_path_train.py",
+        "src/llm_memory_editability/hebbian_data.py",
+        "src/llm_memory_editability/hebbian_model.py",
+        "src/llm_memory_editability/hebbian_learning.py",
+        "tests/test_qwen_path_learning.py",
+    ]
+
+
+def freeze():
+    if (ART / "execution-lock.json").exists():
+        raise RuntimeError("Execution lock exists")
+    assert read(ART / "preflight.json")["passed"]
+    assert read(ART / "selection-lock.json")["selection_sha256"] == digest(DATA / "selection.json")
+    frozen = {}
+    for relative in sources() + [
+        "docs/hebbian-learning-plan-v1.md",
+        "docs/experimental-protocol.md",
+    ]:
+        path = ROOT / relative
+        target = ART / "execution-source" / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(path, target)
+        frozen[relative] = digest(path)
+    cfg = read(CONFIG)
+    model = ROOT / cfg["model_source"] / "model.safetensors"
+    write(
+        ART / "execution-lock.json",
+        {
+            "time": now(),
+            "status": "locked_before_development_updates",
+            "sources": frozen,
+            "inputs": {
+                str(p.relative_to(ROOT)): digest(p)
+                for p in [DATA / "selection.json", DATA / "text.json", model]
+            },
+            "matrix": jobs(),
+            "environment": {
+                "python": platform.python_version(),
+                "torch": torch.__version__,
+                "transformers": transformers.__version__,
+                "numpy": np.__version__,
+            },
+            "config": cfg,
+        },
+    )
+
+
+def check_lock():
+    lock = read(ART / "execution-lock.json")
+    for relative in sources():
+        assert digest(ROOT / relative) == lock["sources"][relative], relative
+    for relative in (
+        "data/qwen-path-learning-v1/selection.json",
+        "data/qwen-path-learning-v1/text.json",
+    ):
+        assert digest(ROOT / relative) == lock["inputs"][relative]
+
+
+def optimizer(engine, lr):
+    cfg = engine.cfg["optimizer"]
+    return torch.optim.AdamW(
+        [engine.delta],
+        lr=lr,
+        betas=tuple(cfg["betas"]),
+        eps=cfg["eps"],
+        weight_decay=cfg["weight_decay"],
+    )
+
+
+def schedule(cfg, episode, seed, n_r=64, n_text=64):
+    rng = np.random.default_rng(cfg["seed"] + 1000 * episode + seed)
+    # Fixed cyclic shuffled decks give exactly equal aggregate exposure across jobs.
+    replay, text = rng.permutation(n_r), rng.permutation(n_text)
+    return [
+        {
+            "R": [int(replay[(step * 8 + i) % n_r]) for i in range(8)],
+            "text": [int(text[(step * 2 + i) % n_text]) for i in range(2)],
+        }
+        for step in range(cfg["steps"])
+    ]
+
+
+def save_checkpoint(path, engine, opt, job, step, history, ledger):
+    temporary = path.with_suffix(f".{os.getpid()}.tmp")
+    torch.save(
+        {
+            "delta": engine.delta.detach().cpu(),
+            "optimizer": opt.state_dict(),
+            "job": job,
+            "step": step,
+            "history": history,
+            "ledger": ledger,
+            "execution_lock": digest(ART / "execution-lock.json"),
+        },
+        temporary,
+    )
+    temporary.replace(path)
+
+
+def evaluate_node(engine, episode, selection, texts, step, output, full_test=False):
+    result = {
+        "step": step,
+        "time": now(),
+        "E": engine.evaluate(episode, views=(0, 1, 2, 3), with_kl=False),
+        "R": engine.evaluate(selection["R"]),
+        "V": engine.evaluate(selection["V"]),
+        "text_dev": engine.evaluate_text(texts["dev"]),
+        "delta_norm": float(engine.delta.norm()),
+        "relative_delta_norm": float(engine.delta.norm() / engine.down.weight.norm()),
+    }
+    if full_test:
+        result["U"] = engine.evaluate(selection["U"], views=(0, 1, 2, 3))
+        result["text_test"] = engine.evaluate_text(texts["test"])
+    write(output / f"node-{step:03d}.json", result)
+    return result
+
+
+def train_job(engine, job):
+    check_lock()
+    cfg = engine.cfg
+    out = RESULTS / job["id"]
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "complete.json").exists():
+        return
+    engine.restore()
+    selection, texts = read(DATA / "selection.json"), read(DATA / "text.json")
+    phase = job["phase"]
+    records = selection["E_dev" if phase == "dev" else "E_confirm"]
+    episode = records[job["episode"] * 4 : (job["episode"] + 1) * 4]
+    training_enc = [r["encoded"][0] for r in episode]
+    reference_enc = (
+        [r["encoded"][0] for role in ("R", "V") for r in selection[role]]
+        + texts["train"]
+        + texts["dev"]
+    )
+    if phase == "confirm":
+        reference_enc += [enc for r in selection["U"] for enc in r["encoded"]] + texts["test"]
+    missing = [e for e in reference_enc if e["key"] not in engine.reference]
+    engine.cache_reference(missing)
+    if job["condition"] != "ordinary":
+        engine.route = "group" if job["condition"] == "candidate" else "random"
+        engine.route_group = job["group"]
+        engine.route_seed = job["seed"]
+    opt = optimizer(engine, job["lr"])
+    batches = schedule(cfg, job["episode"], job["seed"])
+    write(out / "schedule.json", batches)
+    history, ledger, start = (
+        [],
+        {
+            "E_sequences": 0,
+            "R_sequences": 0,
+            "text_sequences": 0,
+            "supervised_E_tokens": 0,
+            "R_prediction_tokens": 0,
+            "text_prediction_tokens": 0,
+            "padded_training_tokens": 0,
+        },
+        0,
+    )
+    checkpoint = out / "latest.pt"
+    if checkpoint.exists():
+        ck = torch.load(checkpoint, map_location=engine.device, weights_only=False)
+        assert ck["job"] == job and ck["execution_lock"] == digest(ART / "execution-lock.json")
+        with torch.no_grad():
+            engine.delta.copy_(ck["delta"])
+        opt.load_state_dict(ck["optimizer"])
+        history, ledger, start = ck["history"], ck["ledger"], ck["step"]
+    else:
+        evaluate_node(engine, episode, selection, texts, 0, out, phase == "confirm")
+        save_checkpoint(out / "step-000.pt", engine, opt, job, 0, history, ledger)
+    begun = time.time()
+    torch.cuda.reset_peak_memory_stats(engine.device)
+    for index in range(start, cfg["steps"]):
+        plan = batches[index]
+        replay = [selection["R"][i]["encoded"][0] for i in plan["R"]]
+        text = [texts["train"][i] for i in plan["text"]]
+        opt.zero_grad(set_to_none=True)
+        ce, _ = engine.objectives(training_enc, include_kl=False)
+        ce.mean().backward()
+        _, rkl = engine.objectives(replay)
+        (job["beta"] * rkl.mean() / 2).backward()
+        _, tkl = engine.objectives(text)
+        (job["beta"] * tkl.mean() / 2).backward()
+        gradient_norm = torch.nn.utils.clip_grad_norm_([engine.delta], cfg["optimizer"]["clip"])
+        if not torch.isfinite(gradient_norm):
+            raise RuntimeError(f"Non-finite gradient in {job['id']} step {index + 1}")
+        opt.step()
+        history.append(
+            {
+                "step": index + 1,
+                "ce": float(ce.detach().mean()),
+                "r_kl": float(rkl.detach().mean()),
+                "text_kl": float(tkl.detach().mean()),
+                "gradient_norm_before_clip": float(gradient_norm),
+            }
+        )
+        ledger["E_sequences"] += len(training_enc)
+        ledger["R_sequences"] += len(replay)
+        ledger["text_sequences"] += len(text)
+        ledger["supervised_E_tokens"] += sum(sum(e["loss_mask"]) for e in training_enc)
+        ledger["R_prediction_tokens"] += sum(sum(e["loss_mask"]) for e in replay)
+        ledger["text_prediction_tokens"] += sum(sum(e["loss_mask"]) for e in text)
+        ledger["padded_training_tokens"] += sum(
+            len(es) * max(len(e["input_ids"]) for e in es) for es in (training_enc, replay, text)
+        )
+        step = index + 1
+        if step in cfg["nodes"]:
+            evaluate_node(engine, episode, selection, texts, step, out, phase == "confirm")
+            save_checkpoint(out / f"step-{step:03d}.pt", engine, opt, job, step, history, ledger)
+        if step % 16 == 0 or step in cfg["nodes"]:
+            save_checkpoint(checkpoint, engine, opt, job, step, history, ledger)
+            write(
+                out / "status.json",
+                {
+                    "time": now(),
+                    "state": "training",
+                    "step": step,
+                    "job": job,
+                    "device": str(engine.device),
+                    "seconds_this_attempt": time.time() - begun,
+                },
+            )
+            print(json.dumps({"job": job["id"], "step": step, "ce": history[-1]["ce"]}), flush=True)
+    write(out / "history.json", history)
+    write(
+        out / "complete.json",
+        {
+            "time": now(),
+            "job": job,
+            "steps": cfg["steps"],
+            "ledger": ledger,
+            "schedule_sha256": digest(out / "schedule.json"),
+            "seconds_this_attempt": time.time() - begun,
+            "peak_gpu_bytes": torch.cuda.max_memory_allocated(engine.device),
+            "device": str(engine.device),
+            "trainable_parameters": engine.delta.numel(),
+            "parent_down_hash": engine.base_hash,
+            "forward_tokens_engine_cumulative": engine.forward_tokens,
+            "flops_estimate": {
+                "convention": "Approximate dense 2*N per forward token plus backward through "
+                "downstream half and head; padding included, attention term omitted; "
+                "reference/evaluation costs recorded separately",
+                "value": 4
+                * sum(p.numel() for p in engine.model.parameters())
+                * ledger["padded_training_tokens"],
+                "not_hardware_counter": True,
+            },
+        },
+    )
+    engine.restore()
+
+
+def train_shard(device, shard, shards):
+    engine = PathEngine(device)
+    for index, job in enumerate(jobs()):
+        if index % shards == shard:
+            train_job(engine, job)
+
+
+def select_learning_rates():
+    cfg = read(CONFIG)
+    summaries, chosen = [], {}
+    for beta in cfg["betas_replay"]:
+        options = []
+        for lr in cfg["learning_rates"]:
+            records = []
+            for job in jobs():
+                if job["beta"] == beta and job["lr"] == lr:
+                    assert (RESULTS / job["id"] / "complete.json").exists()
+                    node = read(RESULTS / job["id"] / "node-128.json")
+                    base = read(RESULTS / job["id"] / "node-000.json")
+                    records.append(
+                        {
+                            "E": mean([r for r in node["E"] if r["view"] == 0], "correct"),
+                            "V_loss": mean(base["V"], "correct") - mean(node["V"], "correct"),
+                            "text_kl": mean(node["text_dev"], "kl"),
+                        }
+                    )
+            option = {
+                "beta": beta,
+                "lr": lr,
+                **{k: mean(records, k) for k in ("E", "V_loss", "text_kl")},
+            }
+            options.append(option)
+        eligible = [r for r in options if r["V_loss"] <= 0.05]
+        if eligible:
+            choice = min(eligible, key=lambda r: (-r["E"], r["text_kl"], r["lr"]))
+        else:
+            choice = min(options, key=lambda r: (r["V_loss"], r["text_kl"], r["lr"]))
+        chosen[str(beta)] = {**choice, "retention_condition_passed": bool(eligible)}
+        summaries.extend(options)
+    write(
+        ART / "learning-rate-selection.json",
+        {"time": now(), "node": 128, "rows": summaries, "chosen": chosen, "used_U": False},
+    )
+    return chosen
+
+
+@torch.no_grad()
+def diagnose(device, episode_index):
+    check_lock()
+    cfg = read(CONFIG)
+    chosen = read(ART / "learning-rate-selection.json")["chosen"]["1"]
+    job = next(
+        j
+        for j in jobs()
+        if j["episode"] == episode_index and j["beta"] == 1 and j["lr"] == chosen["lr"]
+    )
+    engine = PathEngine(device)
+    selection = read(DATA / "selection.json")
+    episode = selection["E_dev"][episode_index * 4 : (episode_index + 1) * 4]
+    records = episode + selection["R"]
+    encs = [r["encoded"][0] for r in records]
+    engine.cache_reference(encs)
+    output = RESULTS / job["id"] / "diagnostics"
+    output.mkdir(exist_ok=True)
+    base_E = engine.evaluate(episode)
+    zero_R = engine.evaluate(selection["R"], generate=False)
+    for step in cfg["nodes"][1:]:
+        if (output / f"step-{step:03d}.json").exists():
+            continue
+        ck = torch.load(
+            RESULTS / job["id"] / f"step-{step:03d}.pt",
+            map_location=engine.device,
+            weights_only=False,
+        )
+        engine.delta.copy_(ck["delta"])
+        engine.route = "all"
+        full_E = engine.evaluate(episode)
+        full_R = engine.evaluate(selection["R"], generate=False)
+        energies = {}
+        for start in range(0, len(encs), 8):
+            chunk = encs[start : start + 8]
+            engine.capture = []
+            engine.objectives(chunk, include_kl=False)
+            captured = engine.capture[0]
+            for i, enc in enumerate(chunk):
+                energies[enc["key"]] = captured[i, : len(enc["roles"])].tolist()
+            engine.capture = None
+        result = {
+            "step": step,
+            "episode": episode_index,
+            "job": job,
+            "base_E": base_E,
+            "zero_R": zero_R,
+            "all_E": full_E,
+            "all_R": full_R,
+            "groups": {},
+        }
+        for group in cfg["groups"] + ["L", "A"]:
+            engine.route, engine.route_group = "group", group
+            group_E = engine.evaluate(episode)
+            group_R = engine.evaluate(selection["R"], generate=False)
+            group_result = {"E": group_E, "R": group_R, "random": []}
+            if group in cfg["groups"]:
+                for seed in cfg["matching"]["diagnostic_seeds"]:
+                    positions, matches = {}, {}
+                    for enc in encs:
+                        selected, info = random_positions(
+                            enc["roles"],
+                            group,
+                            enc["key"],
+                            seed,
+                            cfg["matching"]["position_bins"],
+                            cfg["matching"]["draws"],
+                            energies[enc["key"]],
+                        )
+                        info["energy_matched"] = (
+                            info["valid"]
+                            and info["relative_energy_error"]
+                            <= cfg["matching"]["norm_relative_tolerance"]
+                        )
+                        matches[enc["key"]] = info
+                        positions[enc["key"]] = selected
+                    engine.route, engine.route_positions = "positions", positions
+                    group_result["random"].append(
+                        {
+                            "seed": seed,
+                            "matches": matches,
+                            "positions": positions,
+                            "E": engine.evaluate(episode),
+                            "R": engine.evaluate(selection["R"], generate=False),
+                        }
+                    )
+            result["groups"][group] = group_result
+        engine.route = "all"
+        recovered = engine.evaluate(episode, generate=False)
+        result["restore_max_ce_error"] = max(
+            abs(a["ce"] - b["ce"]) for a, b in zip(full_E, recovered, strict=True)
+        )
+        result["position_energy"] = energies
+        write(output / f"step-{step:03d}.json", result)
+        print(json.dumps({"diagnostic_episode": episode_index, "step": step}), flush=True)
+    engine.restore()
+
+
+def candidate_decision():
+    cfg = read(CONFIG)
+    chosen = read(ART / "learning-rate-selection.json")["chosen"]["1"]
+    rows = []
+    for job in jobs():
+        if job["beta"] != 1 or job["lr"] != chosen["lr"]:
+            continue
+        d = read(RESULTS / job["id"] / "diagnostics/step-128.json")
+        gain = mean(d["base_E"], "ce") - mean(d["all_E"], "ce")
+        risk = mean(d["all_R"], "kl")
+        noise = max(abs(r["kl"]) for r in d["zero_R"])
+        for group in cfg["groups"]:
+            g = d["groups"][group]
+            retained = None if gain <= 0 else (mean(d["base_E"], "ce") - mean(g["E"], "ce")) / gain
+            reduction = None if risk <= 0 else 1 - mean(g["R"], "kl") / risk
+            matching = []
+            for control in g["random"]:
+                matched_ids = {
+                    int(key.split("-")[1])
+                    for key, m in control["matches"].items()
+                    if m["energy_matched"]
+                }
+                e_fraction = sum(r["case_id"] in matched_ids for r in d["all_E"]) / len(d["all_E"])
+                r_fraction = sum(r["case_id"] in matched_ids for r in d["all_R"]) / len(d["all_R"])
+                all_r = [r for r in d["all_R"] if r["case_id"] in matched_ids]
+                cand_r = [r for r in g["R"] if r["case_id"] in matched_ids]
+                random_r = [r for r in control["R"] if r["case_id"] in matched_ids]
+                difference = None if not all_r else mean(random_r, "kl") - mean(cand_r, "kl")
+                matching.append(
+                    {
+                        "seed": control["seed"],
+                        "E_coverage": e_fraction,
+                        "R_coverage": r_fraction,
+                        "candidate_minus_random_improvement": difference,
+                        "valid": e_fraction >= cfg["matching"]["minimum_coverage"]
+                        and r_fraction >= cfg["matching"]["minimum_coverage"],
+                    }
+                )
+            valid = [m for m in matching if m["valid"]]
+            beats_random = (
+                bool(valid)
+                and float(np.median([m["candidate_minus_random_improvement"] for m in valid]))
+                > cfg["gate"]["noise_multiplier"] * noise
+            )
+            passes = bool(
+                gain > 0
+                and mean(d["all_E"], "correct") > mean(d["base_E"], "correct")
+                and retained >= cfg["gate"]["learning_retained"]
+                and mean(g["E"], "correct") >= mean(d["all_E"], "correct")
+                and risk >= max(cfg["gate"]["kl_floor"], cfg["gate"]["noise_multiplier"] * noise)
+                and reduction >= cfg["gate"]["kl_reduction"]
+                and beats_random
+            )
+            rows.append(
+                {
+                    "episode": job["episode"],
+                    "group": group,
+                    "E_gain": gain,
+                    "learning_retained": retained,
+                    "R_kl": risk,
+                    "R_kl_reduction": reduction,
+                    "E_correct_all": mean(d["all_E"], "correct"),
+                    "E_correct_candidate": mean(g["E"], "correct"),
+                    "noise": noise,
+                    "matching": matching,
+                    "beats_random": beats_random,
+                    "passes": passes,
+                }
+            )
+    eligible = [
+        g
+        for g in cfg["groups"]
+        if sum(r["passes"] for r in rows if r["group"] == g) >= cfg["gate"]["units_required"]
+    ]
+    winner = (
+        min(
+            eligible,
+            key=lambda g: (
+                -float(np.mean([r["R_kl_reduction"] for r in rows if r["group"] == g])),
+                cfg["groups"].index(g),
+            ),
+        )
+        if eligible
+        else None
+    )
+    result = {
+        "time": now(),
+        "rows": rows,
+        "candidate": winner,
+        "status": "eligible_for_confirmation" if winner else "stop_after_development",
+        "confirmation_started": False,
+        "selection_uses_U": False,
+        "coverage_rule": "At least 80% of E and R must have disjoint count/bin/energy matches "
+        "in a fixed random seed; compare candidate/random on identical matched records",
+    }
+    write(ART / "candidate-decision.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition.py

@@ -0,0 +1,629 @@
+"""Complete GPT/Loop training on original 2Wiki questions and atomic facts."""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import math
+import os
+import time
+from contextlib import nullcontext
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from transformers import GPT2Config, GPT2TokenizerFast
+
+from .grok_depth import utc
+from .grokking_reproduction import ReproductionGPT, model_digest
+from .realworld_composition_data import (
+    answer_scores,
+    atomic_question,
+    encode_example,
+    sha256,
+    write_json,
+)
+
+
+def construct(config, spec, device):
+    """Build the same eight-block reference before taking a shared prefix."""
+    torch.manual_seed(spec["initialization"])
+    options = {
+        "vocab_size": config["vocab_size"],
+        "n_positions": config.get("positions", 1024),
+        "n_embd": config["hidden_size"],
+        "n_head": config["attention_heads"],
+        "n_layer": 8,
+        "resid_pdrop": config["dropout"],
+        "embd_pdrop": config["dropout"],
+        "attn_pdrop": config["dropout"],
+        "activation_function": "gelu_new",
+        "use_cache": False,
+    }
+    model = ReproductionGPT(GPT2Config(**options), repeats=spec["repeats"])
+    model.transformer.h = torch.nn.ModuleList(list(model.transformer.h)[: spec["unique_layers"]])
+    model.config.n_layer = spec["unique_layers"]
+    return model.to(device)
+
+
+def shared_prefix_digest(model):
+    digest = hashlib.sha256()
+    for name, tensor in model.state_dict().items():
+        if name.startswith("transformer.h.") and int(name.split(".")[2]) >= 4:
+            continue
+        digest.update(name.encode())
+        digest.update(tensor.detach().cpu().contiguous().numpy().tobytes())
+    return digest.hexdigest()
+
+
+def tensor_digests(model):
+    return {
+        name: hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest()
+        for name, tensor in model.state_dict().items()
+    }
+
+
+class BatchStream:
+    """Keep actual incomplete epoch batches, with a complete restore state."""
+
+    def __init__(self, size, seed):
+        self.size = size
+        self.rng = np.random.default_rng(seed)
+        self.remaining = np.empty(0, dtype=np.int64)
+
+    def batch(self, size):
+        if not len(self.remaining):
+            self.remaining = self.rng.permutation(self.size)
+        chosen, self.remaining = self.remaining[:size], self.remaining[size:]
+        return chosen
+
+    def state_dict(self):
+        return {
+            "remaining": self.remaining.copy(),
+            "rng": copy.deepcopy(self.rng.bit_generator.state),
+        }
+
+    def load_state_dict(self, state):
+        self.remaining = state["remaining"].copy()
+        self.rng.bit_generator.state = copy.deepcopy(state["rng"])
+
+
+def pack(records, pad, device):
+    length = math.ceil(max(len(r["encoded"]["input"]) for r in records) / 8) * 8
+    targets = max(len(r["encoded"]["target"]) for r in records)
+    tokens = np.full((len(records), length), pad, dtype=np.int64)
+    positions = np.zeros((len(records), targets), dtype=np.int64)
+    labels = np.full((len(records), targets), -100, dtype=np.int64)
+    for i, record in enumerate(records):
+        encoded = record["encoded"]
+        tokens[i, : len(encoded["input"])] = encoded["input"]
+        n = len(encoded["target"])
+        positions[i, :n] = np.arange(len(encoded["prefix"]) - 1, len(encoded["prefix"]) - 1 + n)
+        labels[i, :n] = encoded["target"]
+    return tuple(torch.as_tensor(a, device=device) for a in (tokens, positions, labels))
+
+
+def example_losses(logits, labels):
+    valid = labels != -100
+    if not bool(valid.any(dim=1).all()):
+        raise ValueError("Every example must supervise its answer and EOS")
+    losses = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none").view_as(
+        labels
+    )
+    return losses.sum(dim=1) / valid.sum(dim=1)
+
+
+def optimizer_for(model, lr, decay):
+    params = list(model.named_parameters())
+    groups = [
+        {
+            "params": [p for n, p in params if not any(s in n for s in ["bias", "ln"])],
+            "weight_decay": decay,
+        },
+        {
+            "params": [p for n, p in params if any(s in n for s in ["bias", "ln"])],
+            "weight_decay": 0.0,
+        },
+    ]
+    return torch.optim.AdamW(
+        groups, lr=lr, betas=(0.9, 0.999), eps=1e-8, fused=next(model.parameters()).is_cuda
+    )
+
+
+def autocast(device):
+    return (
+        torch.autocast("cuda", dtype=torch.bfloat16)
+        if torch.device(device).type == "cuda"
+        else nullcontext()
+    )
+
+
+def update(model, optimizer, records, spec, device, pad):
+    model.train()
+    optimizer.zero_grad(set_to_none=True)
+    loss_total, executed, readout, attention = 0.0, 0, 0, 0
+    for start in range(0, len(records), spec["microbatch_size"]):
+        chunk = records[start : start + spec["microbatch_size"]]
+        tokens, positions, labels = pack(chunk, pad, device)
+        with autocast(device):
+            loss = example_losses(model(tokens, positions), labels).sum() / len(records)
+        loss.backward()
+        loss_total += float(loss.detach())
+        executed += tokens.numel()
+        readout += positions.numel()
+        attention += len(chunk) * tokens.shape[1] ** 2
+    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+    if not math.isfinite(loss_total) or not math.isfinite(float(norm)):
+        raise FloatingPointError("Nonfinite loss or gradient; preserve this failure")
+    optimizer.step()
+    d, blocks = model.config.n_embd, len(model.transformer.h) * model.repeats
+    flops = (
+        6 * 12 * d * d * blocks * executed
+        + 6 * d * model.config.vocab_size * readout
+        + 12 * blocks * d * attention
+    )
+    return {
+        "loss": loss_total,
+        "gradient_norm": float(norm),
+        "executed_input_tokens": executed,
+        "effective_input_tokens": sum(len(r["encoded"]["input"]) for r in records),
+        "estimated_matmul_training_flops": flops,
+    }
+
+
+@torch.no_grad()
+def generate(model, prefixes, tokenizer, device, limit=64, sequence_limit=256):
+    """Right-padded greedy generation; only the question prefix enters the model."""
+    model.eval()
+    sizes = np.array([len(p) for p in prefixes], dtype=np.int64)
+    if not len(sizes) or not (sizes > 0).all() or not (sizes <= sequence_limit).all():
+        raise ValueError("Generation requires nonempty prefixes within the sequence limit")
+    budgets = np.minimum(limit, sequence_limit - sizes)
+    tokens = torch.full(
+        (len(prefixes), min(sequence_limit, int(sizes.max()) + limit)),
+        tokenizer.eos_token_id,
+        device=device,
+        dtype=torch.long,
+    )
+    for i, prefix in enumerate(prefixes):
+        tokens[i, : len(prefix)] = torch.as_tensor(prefix, device=device)
+    output, ended = [[] for _ in prefixes], np.zeros(len(prefixes), dtype=bool)
+    for offset in range(limit):
+        active = ~ended & (offset < budgets)
+        if not active.any():
+            break
+        length = min(sequence_limit, int(sizes.max()) + offset)
+        positions = torch.as_tensor(np.minimum(sizes + offset - 1, length - 1), device=device)[
+            :, None
+        ]
+        with autocast(device):
+            selected = model(tokens[:, :length], positions)[:, 0].argmax(-1)
+        chosen = selected.cpu().tolist()
+        for i, token in enumerate(chosen):
+            if active[i]:
+                output[i].append(token)
+                ended[i] = token == tokenizer.eos_token_id
+        indices = torch.as_tensor(np.flatnonzero(active), device=device)
+        tokens[indices, torch.as_tensor(sizes[active] + offset, device=device)] = selected[indices]
+    model.train()
+    return [
+        {
+            "prediction": tokenizer.decode(
+                ids[:-1] if stop else ids, skip_special_tokens=True
+            ).strip(),
+            "generated_tokens": ids,
+            "eos": bool(stop),
+            "truncated": not bool(stop),
+            "context_limit_reached": not bool(stop) and bool(len(ids) >= sequence_limit - size),
+            "generation_limit_reached": not bool(stop) and len(ids) >= limit,
+        }
+        for ids, stop, size in zip(output, ended, sizes, strict=True)
+    ]
+
+
+def aggregate(predictions):
+    fields = ["canonical_em", "alias_em", "unambiguous_alias_em", "f1", "nll", "eos", "truncated"]
+    result = {"n": len(predictions)}
+    for key in fields:
+        values = [float(p[key]) for p in predictions if p[key] is not None]
+        result[key] = sum(values) / len(values) if values else None
+        if key == "nll":
+            result["nll_n"] = len(values)
+    eligible = [p for p in predictions if p.get("has_unambiguous_answer", True)]
+    result["unambiguous_answer_coverage"] = (
+        len(eligible) / len(predictions) if predictions else None
+    )
+    result["unambiguous_alias_em_eligible"] = (
+        sum(float(p["unambiguous_alias_em"]) for p in eligible) / len(eligible)
+        if eligible
+        else None
+    )
+    result["answer_accuracy"] = result["alias_em"]
+    return result
+
+
+@torch.no_grad()
+def evaluate(model, records, tokenizer, device, batch_size=32):
+    predictions = []
+    for start in range(0, len(records), batch_size):
+        chunk = records[start : start + batch_size]
+        generated = generate(model, [r["encoded"]["prefix"] for r in chunk], tokenizer, device)
+        model.eval()
+        tokens, positions, labels = pack(chunk, tokenizer.eos_token_id, device)
+        with autocast(device):
+            losses = example_losses(model(tokens, positions), labels).float().cpu().tolist()
+        for row, result, loss in zip(chunk, generated, losses, strict=True):
+            em, f1 = answer_scores(result["prediction"], [row["answer"], *row.get("aliases", [])])
+            unique_answers = row.get(
+                "unambiguous_answers", [row["answer"], *row.get("unambiguous_aliases", [])]
+            )
+            result.update(
+                id=row["id"],
+                canonical_em=answer_scores(result["prediction"], [row["answer"]])[0],
+                alias_em=em,
+                f1=f1,
+                nll=loss,
+                unambiguous_alias_em=answer_scores(result["prediction"], unique_answers)[0],
+                has_unambiguous_answer=bool(unique_answers),
+                canonical_answer_globally_unambiguous=row.get(
+                    "canonical_answer_globally_unambiguous", True
+                ),
+                gold=row["answer"],
+                role=row.get("role"),
+                required_role=row.get("required_role"),
+            )
+            predictions.append(result)
+    model.train()
+    return aggregate(predictions), predictions
+
+
+def evaluate_dataset(model, data, tokenizer, device, full=False, autonomous=False):
+    atoms = {r["id"]: r for r in data["atoms"]}
+    chains = {r["id"]: r for r in data["train_compositions"] + data["evaluation_compositions"]}
+    panels = data["panels"]
+    groups = {
+        "atomic": list(atoms.values()) if full else [atoms[i] for i in panels["atomic"]],
+        "train_composition": data["train_compositions"]
+        if full
+        else [chains[i] for i in panels["train_composition"]],
+    }
+    selected = (
+        data["evaluation_compositions"]
+        if full
+        else [chains[i] for name, ids in panels.items() if name.startswith("test_") for i in ids]
+    )
+    groups["test_all"] = selected
+    metrics, raw = {}, {}
+    for name, records in groups.items():
+        metrics[name], raw[name] = (
+            evaluate(model, records, tokenizer, device) if records else (aggregate([]), [])
+        )
+    lookup = {p["id"]: p for p in raw["atomic"]}
+    for role in ["II", "IO", "OI", "OO"]:
+        metrics["test_" + role.lower()] = aggregate(
+            [p for p in raw["test_all"] if p["role"] == role]
+        )
+        metrics["test_required_role_" + role.lower()] = aggregate(
+            [p for p in raw["test_all"] if p["required_role"] == role]
+        )
+    filters = {
+        "test_unambiguous_canonical_answers": lambda r: r.get(
+            "canonical_answer_globally_unambiguous", True
+        ),
+        "test_no_known_shortcut": lambda r: not r.get("known_direct_shortcut", False),
+        "test_head_tail_unseen": lambda r: not r.get(
+            "head_tail_seen_in_combination_training", False
+        ),
+        "test_seen_operation": lambda r: r.get("operation_seen", False),
+        "test_no_shortcut_seen_operation": lambda r: not r.get("known_direct_shortcut", False)
+        and r.get("operation_seen", False),
+    }
+    for name, include in filters.items():
+        ids = {r["id"] for r in selected if include(r)}
+        metrics[name] = aggregate([p for p in raw["test_all"] if p["id"] in ids])
+        metrics[name]["coverage"] = len(ids) / len(selected) if selected else None
+    for index, name in enumerate(["test_first_atom", "test_second_atom"]):
+        metrics[name] = aggregate([lookup[r["atom_ids"][index]] for r in selected])
+    metrics["gold_bridge_second"] = metrics["test_second_atom"].copy()
+    prerequisite = {r["id"] for r in selected if all(lookup[a]["alias_em"] for a in r["atom_ids"])}
+    metrics["test_prerequisites_correct"] = aggregate(
+        [p for p in raw["test_all"] if p["id"] in prerequisite]
+    )
+    metrics["test_prerequisites_correct"]["coverage"] = (
+        len(prerequisite) / len(selected) if selected else None
+    )
+    if autonomous:
+        second_calls = []
+        invalid = []
+        for row in selected:
+            bridge_prediction = lookup[row["atom_ids"][0]]["prediction"]
+            q = atomic_question(bridge_prediction, row["edges"][1][1])
+            try:
+                encoded = encode_example(tokenizer, q, row["answer"])
+            except ValueError:
+                invalid.append(row)
+                continue
+            second_calls.append(
+                {**row, "question": q, "encoded": encoded, "autonomous_bridge": bridge_prediction}
+            )
+        _, predictions = (
+            evaluate(model, second_calls, tokenizer, device) if second_calls else (None, [])
+        )
+        for row, result in zip(second_calls, predictions, strict=True):
+            result["bridge_prediction"] = row["autonomous_bridge"]
+            result["second_question"] = row["question"]
+        predictions.extend(
+            {
+                "id": row["id"],
+                "canonical_em": 0.0,
+                "alias_em": 0.0,
+                "unambiguous_alias_em": 0.0,
+                "f1": 0.0,
+                "nll": None,
+                "eos": False,
+                "truncated": True,
+                "has_unambiguous_answer": bool(row.get("unambiguous_answers", [])),
+                "canonical_answer_globally_unambiguous": row.get(
+                    "canonical_answer_globally_unambiguous", True
+                ),
+                "invalid_generated_bridge_length": True,
+            }
+            for row in invalid
+        )
+        raw["autonomous"] = predictions
+        metrics["autonomous"] = aggregate(predictions)
+        metrics["autonomous"]["invalid_bridge_prompts"] = len(invalid)
+    return metrics, raw
+
+
+def save_checkpoint(path, model, optimizer, stream, counts, step, counters, wall_seconds=None):
+    temporary = Path(path).with_suffix(".tmp")
+    torch.save(
+        {
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "stream": stream.state_dict(),
+            "counts": counts,
+            "step": step,
+            "counters": counters,
+            "wall_seconds": wall_seconds,
+            "cpu_rng": torch.get_rng_state(),
+            "cuda_rng": torch.cuda.get_rng_state(),
+        },
+        temporary,
+    )
+    temporary.replace(path)
+
+
+def worker(config, spec, gpu):
+    torch.set_num_threads(4)
+    torch.set_num_interop_threads(1)
+    torch.cuda.set_device(gpu)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    device = f"cuda:{gpu}"
+    data = json.loads(Path(config["data_file"]).read_text())
+    assert sha256(config["data_file"]) == config["data_sha256"]
+    tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True)
+    phase = config.get("phase", "development")
+    out = Path(config["results_root"]) / phase / spec["name"]
+    out.mkdir(parents=True, exist_ok=True)
+    model = construct(config["model"], spec, device)
+    optimizer = optimizer_for(model, spec["learning_rate"], spec["weight_decay"])
+    records = data["atoms"] + data["train_compositions"]
+    stream = BatchStream(len(records), spec["sampling_seed"])
+    counts = np.zeros(len(records), dtype=np.int64)
+    counters = dict(
+        training_seconds=0.0,
+        examples=0,
+        supervised_tokens=0,
+        executed_input_tokens=0,
+        effective_input_tokens=0,
+        estimated_matmul_training_flops=0,
+    )
+    history, initial_step, wall_offset = [], 0, 0.0
+    started = time.perf_counter()
+    if (out / "latest.pt").exists():
+        checkpoint = torch.load(out / "latest.pt", map_location=device, weights_only=False)
+        model.load_state_dict(checkpoint["model"])
+        optimizer.load_state_dict(checkpoint["optimizer"])
+        stream.load_state_dict(checkpoint["stream"])
+        counts, initial_step, counters = (
+            checkpoint["counts"],
+            checkpoint["step"],
+            checkpoint["counters"],
+        )
+        torch.set_rng_state(checkpoint["cpu_rng"].cpu())
+        torch.cuda.set_rng_state(checkpoint["cuda_rng"].cpu())
+        history = [
+            r for r in json.loads((out / "learning.json").read_text()) if r["step"] <= initial_step
+        ]
+        wall_offset = checkpoint.get("wall_seconds")
+        if wall_offset is None:
+            wall_offset = history[-1]["wall_seconds"] if history else 0.0
+        metadata = json.loads((out / "run.json").read_text())
+        metadata.update(pid=os.getpid(), gpu=gpu, resumed_from_step=initial_step)
+        write_json(out / "run.json", metadata)
+        del checkpoint
+    else:
+        torch.manual_seed(spec["dropout_seed"])
+        metadata = {
+            "spec": spec,
+            "model": config["model"],
+            "phase": phase,
+            "evaluation_nodes": config["evaluation_nodes"],
+            "execution_lock_sha256": sha256(config["execution_lock"]),
+            "world_sha256": config["data_sha256"],
+            "initial_model_sha256": model_digest(model),
+            "initial_tensor_sha256": tensor_digests(model),
+            "common_four_block_initial_sha256": shared_prefix_digest(model),
+            "parameters": sum(p.numel() for p in model.parameters()),
+            "atomic_examples": len(data["atoms"]),
+            "composition_examples": len(data["train_compositions"]),
+            "vocab_size": len(tokenizer),
+            "dtype": "BF16 AMP; FP32 parameters and Adam states",
+            "gpu": gpu,
+            "gpu_name": torch.cuda.get_device_name(gpu),
+            "pid": os.getpid(),
+            "job_type": phase + "-training",
+            "tracking_group": config["tracking"]["group"],
+        }
+        write_json(out / "run.json", metadata)
+        write_json(out / "learning.json", [])
+    nodes = set(config["evaluation_nodes"])
+    last_loss = None
+    for step in range(initial_step, spec["steps"] + 1):
+        if step > initial_step:
+            for group in optimizer.param_groups:
+                group["lr"] = spec["learning_rate"] * min((step - 1) / spec["warmup_steps"], 1.0)
+            ids = stream.batch(spec["batch_size"])
+            selected = [records[i] for i in ids]
+            torch.cuda.synchronize()
+            began = time.perf_counter()
+            values = update(model, optimizer, selected, spec, device, tokenizer.eos_token_id)
+            torch.cuda.synchronize()
+            counters["training_seconds"] += time.perf_counter() - began
+            last_loss = values["loss"]
+            counts[ids] += 1
+            counters["examples"] += len(ids)
+            counters["supervised_tokens"] += sum(len(r["encoded"]["target"]) for r in selected)
+            for key in [
+                "executed_input_tokens",
+                "effective_input_tokens",
+                "estimated_matmul_training_flops",
+            ]:
+                counters[key] += values[key]
+        if step % 50 == 0:
+            write_json(
+                out / "status.json",
+                {
+                    "state": "training",
+                    "step": step,
+                    "target_step": spec["steps"],
+                    "loss": last_loss,
+                    "training_seconds": counters["training_seconds"],
+                    "examples": counters["examples"],
+                    "wall_seconds": wall_offset + time.perf_counter() - started,
+                    "pid": os.getpid(),
+                    "updated_utc": utc(),
+                },
+            )
+        if step in nodes and not any(r["step"] == step for r in history):
+            metrics, predictions = evaluate_dataset(model, data, tokenizer, device)
+            write_json(out / f"predictions-{step:07d}.json", predictions)
+            history.append(
+                {
+                    "step": step,
+                    "metrics": metrics,
+                    **counters,
+                    "wall_seconds": wall_offset + time.perf_counter() - started,
+                    "loss": last_loss,
+                    "atomic_epochs": float(counts[: len(data["atoms"])].mean()),
+                    "composition_epochs": float(counts[len(data["atoms"]) :].mean()),
+                    "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(),
+                    "created_utc": utc(),
+                }
+            )
+            write_json(out / "learning.json", history)
+            save_checkpoint(
+                out / "latest.pt",
+                model,
+                optimizer,
+                stream,
+                counts,
+                step,
+                counters,
+                wall_offset + time.perf_counter() - started,
+            )
+            torch.save(
+                {"model": model.state_dict(), "step": step}, out / f"checkpoint-{step:07d}.pt"
+            )
+            np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts)
+            print(
+                json.dumps(
+                    {
+                        "step": step,
+                        "loss": last_loss,
+                        "metrics": metrics,
+                        "training_seconds": counters["training_seconds"],
+                    }
+                ),
+                flush=True,
+            )
+        elif (
+            step > initial_step and step % config.get("resume_checkpoint_interval", 1000000000) == 0
+        ):
+            save_checkpoint(
+                out / "latest.pt",
+                model,
+                optimizer,
+                stream,
+                counts,
+                step,
+                counters,
+                wall_offset + time.perf_counter() - started,
+            )
+    metrics, predictions = evaluate_dataset(
+        model, data, tokenizer, device, full=True, autonomous=True
+    )
+    write_json(out / "endpoint-predictions.json", predictions)
+    write_json(out / "endpoint.json", metrics)
+    result = {
+        "state": "trained_pending_independent_reload",
+        "step": spec["steps"],
+        "pid": os.getpid(),
+        "model_sha256": model_digest(model),
+        "checkpoint_sha256": sha256(out / "latest.pt"),
+        **counters,
+        "wall_seconds": wall_offset + time.perf_counter() - started,
+        "completed_utc": utc(),
+    }
+    write_json(out / "trained.json", result)
+    write_json(out / "status.json", result)
+
+
+def audit(config, spec, gpu):
+    torch.set_num_threads(4)
+    torch.set_num_interop_threads(1)
+    torch.cuda.set_device(gpu)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    device = f"cuda:{gpu}"
+    out = Path(config["results_root"]) / config.get("phase", "development") / spec["name"]
+    trained = json.loads((out / "trained.json").read_text())
+    assert trained["pid"] != os.getpid()
+    assert sha256(out / "latest.pt") == trained["checkpoint_sha256"]
+    assert sha256(config["data_file"]) == config["data_sha256"]
+    data = json.loads(Path(config["data_file"]).read_text())
+    tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True)
+    model = construct(config["model"], spec, device)
+    state = torch.load(out / "latest.pt", map_location="cpu", weights_only=False)
+    model.load_state_dict(state["model"])
+    assert state["step"] == spec["steps"]
+    del state
+    assert model_digest(model) == trained["model_sha256"]
+    metrics, predictions = evaluate_dataset(
+        model, data, tokenizer, device, full=True, autonomous=True
+    )
+    expected = json.loads((out / "endpoint-predictions.json").read_text())
+    assert predictions == expected, (
+        "Endpoint generation or teacher-forced scores do not independently reproduce"
+    )
+    assert metrics == json.loads((out / "endpoint.json").read_text())
+    result = {
+        "passed": True,
+        "pid": os.getpid(),
+        "source_training_pid": trained["pid"],
+        "checkpoint_sha256": trained["checkpoint_sha256"],
+        "model_sha256": trained["model_sha256"],
+        "predictions_recomputed": sum(len(p) for p in predictions.values()),
+        "completed_utc": utc(),
+    }
+    write_json(out / "audit.json", result)
+    write_json(
+        out / "complete.json", {**trained, "state": "complete", "independently_reloaded": True}
+    )
+    write_json(
+        out / "status.json",
+        {"state": "complete", "step": spec["steps"], "independently_reloaded": True},
+    )

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition_data.py

@@ -0,0 +1,270 @@
+"""Source-grounded 2Wiki closed-book data preparation, without model access.
+
+Answer normalization and alias scoring follow the pinned author's v1.1 scorer.
+The original questions and facts are retained; this is an adapted task in which
+evaluation facts may be learned separately, never with evaluation chain labels.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import string
+import zipfile
+from collections import Counter, defaultdict
+from pathlib import Path
+
+ARCHIVE_SHA = "95df2bf56fdabe034e27aebc580e02264232203cf52552f9efe8a919e5529eef"
+SPLIT_SALT = "2wiki-realworld-v1:"
+QUESTION_TEMPLATES = {
+    "father": "Who is the father of {subject}?",
+    "mother": "Who is the mother of {subject}?",
+    "child": "Who is the child of {subject}?",
+    "spouse": "Who is the spouse of {subject}?",
+    "director": "Who directed {subject}?",
+    "performer": "Who performed {subject}?",
+    "composer": "Who composed {subject}?",
+    "creator": "Who created {subject}?",
+    "editor": "Who edited {subject}?",
+    "presenter": "Who presented {subject}?",
+    "manufacturer": "Who manufactured {subject}?",
+    "publisher": "Who published {subject}?",
+    "founded by": "Who founded {subject}?",
+    "student of": "Who was the teacher of {subject}?",
+    "educated at": "Where was {subject} educated?",
+    "employer": "Who employed {subject}?",
+    "date of birth": "On what date was {subject} born?",
+    "date of death": "On what date did {subject} die?",
+    "place of birth": "Where was {subject} born?",
+    "place of death": "Where did {subject} die?",
+    "place of burial": "Where was {subject} buried?",
+    "place of detention": "Where was {subject} detained?",
+    "cause of death": "What was the cause of death of {subject}?",
+    "country of citizenship": "What is the country of citizenship of {subject}?",
+    "country": "In which country is {subject}?",
+    "inception": "On what date was {subject} established?",
+    "award received": "What award did {subject} receive?",
+    "has part": "What is a part of {subject}?",
+}
+
+
+def sha256(path):
+    result = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for block in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            result.update(block)
+    return result.hexdigest()
+
+
+def write_json(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n")
+    temporary.replace(path)
+
+
+def order(value, salt=SPLIT_SALT):
+    return hashlib.sha256((salt + str(value)).encode()).hexdigest()
+
+
+def normalize_answer(value):
+    value = "".join(c for c in value.lower() if c not in string.punctuation)
+    return " ".join(re.sub(r"\b(a|an|the)\b", " ", value).split())
+
+
+def answer_scores(prediction, answers):
+    """Max EM/F1 across the author's canonical answer and entity aliases."""
+    p = normalize_answer(prediction)
+    scores = []
+    for answer in answers:
+        a = normalize_answer(answer)
+        if (p in {"yes", "no", "noanswer"} or a in {"yes", "no", "noanswer"}) and p != a:
+            f1 = 0.0
+        else:
+            common = sum((Counter(p.split()) & Counter(a.split())).values())
+            f1 = 2 * common / (len(p.split()) + len(a.split())) if common else 0.0
+        scores.append((float(p == a), f1))
+    return max((s[0] for s in scores), default=0.0), max((s[1] for s in scores), default=0.0)
+
+
+def entity_id(identifier, surface):
+    if re.fullmatch(r"Q\d+", str(identifier)):
+        return identifier
+    return "literal:" + " ".join(str(surface).casefold().split())
+
+
+def extract_chain(row):
+    edges, surfaces = row.get("evidences_id", []), row.get("evidences", [])
+    if row.get("type") != "compositional" or len(edges) != 2 or len(surfaces) != 2:
+        return None
+    if any(len(e) != 3 for e in edges + surfaces):
+        return None
+    converted = [
+        (entity_id(e[0], s[0]), str(e[1]), entity_id(e[2], s[2]))
+        for e, s in zip(edges, surfaces, strict=True)
+    ]
+    for indices in [(0, 1), (1, 0)]:
+        first, second = [converted[i] for i in indices]
+        if first[2] == second[0] and first[0] != second[2]:
+            return (first, second), [surfaces[i] for i in indices]
+    return None
+
+
+class Components:
+    def __init__(self):
+        self.parent = {}
+
+    def find(self, node):
+        self.parent.setdefault(node, node)
+        while self.parent[node] != node:
+            self.parent[node] = self.parent[self.parent[node]]
+            node = self.parent[node]
+        return node
+
+    def union(self, first, second):
+        first, second = self.find(first), self.find(second)
+        if first != second:
+            self.parent[max(first, second)] = min(first, second)
+
+
+def support_sentences(row):
+    context = {title: sentences for title, sentences in row["context"]}
+    result = []
+    for title, index in row["supporting_facts"]:
+        if title not in context or not 0 <= index < len(context[title]):
+            result.append(
+                {"title": title, "index": index, "sentence": "", "invalid_support_reference": True}
+            )
+            continue
+        result.append({"title": title, "index": index, "sentence": context[title][index]})
+    return result
+
+
+def prior_cases(project):
+    path = Path(project) / "docs/development-artifacts/twohop-frozen-v1/case-manifest.json"
+    if not path.exists():
+        return set()
+    return {r["id"] for r in json.loads(path.read_text()) if r["dataset"] == "2wiki"}
+
+
+def extract_archive(archive, project):
+    if sha256(archive) != ARCHIVE_SHA:
+        raise ValueError("2Wiki archive differs from the pinned author data")
+    records, aliases, labels = [], {}, defaultdict(Counter)
+    groups = Components()
+    with zipfile.ZipFile(archive) as source:
+        for line in source.read("id_aliases.json").decode().splitlines():
+            entry = json.loads(line)
+            aliases[entry["Q_id"]] = entry["aliases"] + entry.get("demonyms", [])
+        for split in ("train", "dev"):
+            for row in json.loads(source.read(split + ".json")):
+                parsed = extract_chain(row)
+                if parsed is None:
+                    continue
+                edges, surfaces = parsed
+                groups.union(edges[0][0], edges[0][2])
+                for edge, surface in zip(edges, surfaces, strict=True):
+                    labels[edge[0]][surface[0]] += 1
+                    labels[edge[2]][surface[2]] += 1
+                records.append(
+                    {
+                        "id": row["_id"],
+                        "source_split": split,
+                        "question": row["question"],
+                        "answer": row["answer"],
+                        "answer_id": row.get("answer_id"),
+                        "edges": edges,
+                        "surfaces": surfaces,
+                        "support": support_sentences(row),
+                    }
+                )
+    canonical = {
+        key: sorted(counts, key=lambda s: (-counts[s], s))[0] for key, counts in labels.items()
+    }
+    alias_owners = defaultdict(set)
+    for identifier, names in aliases.items():
+        for name in names:
+            alias_owners[normalize_answer(name)].add(identifier)
+    old = prior_cases(project)
+    subject_relation = defaultdict(set)
+    for row in records:
+        for edge in row["edges"]:
+            subject_relation[edge[:2]].add(edge[2])
+    ambiguous = {key for key, values in subject_relation.items() if len(values) > 1}
+    for row in records:
+        row["group"] = groups.find(row["edges"][0][0])
+        row["development_group"] = int(order(row["group"])[:8], 16) % 5 == 0
+        row["known_prior_case"] = row["id"] in old
+        row["aliases"] = aliases.get(row["answer_id"], [])
+        row["unambiguous_aliases"] = [
+            a for a in row["aliases"] if len(alias_owners[normalize_answer(a)]) == 1
+        ]
+        row["structural_errors"] = []
+        if any(s.get("invalid_support_reference") for s in row["support"]):
+            row["structural_errors"].append("invalid_support_sentence_reference")
+        if any(edge[:2] in ambiguous for edge in row["edges"]):
+            row["structural_errors"].append("multiple_objects_for_subject_relation")
+        if row["answer_id"] and row["answer_id"] != row["edges"][1][2]:
+            row["structural_errors"].append("answer_id_does_not_match_chain")
+        if not row["answer_id"] and normalize_answer(row["answer"]) != normalize_answer(
+            row["surfaces"][1][2]
+        ):
+            row["structural_errors"].append("literal_answer_does_not_match_chain")
+        if any(edge[1] not in QUESTION_TEMPLATES for edge in row["edges"]):
+            row["structural_errors"].append("unreviewed_relation_template")
+        row["support_surface_flags"] = []
+        text = normalize_answer(" ".join(s["title"] + " " + s["sentence"] for s in row["support"]))
+        for i, (edge, surface) in enumerate(zip(row["edges"], row["surfaces"], strict=True)):
+            for j in [0, 2]:
+                choices = [surface[j], *aliases.get(edge[j], [])]
+                if not any(normalize_answer(c) in text for c in choices if normalize_answer(c)):
+                    row["support_surface_flags"].append(
+                        f"edge{i}_position{j}_not_literal_in_support"
+                    )
+    return records, aliases, canonical
+
+
+def review_sample(records, size=200):
+    """Round-robin relation pairs, then fixed hashes; independent of model scores."""
+    result = []
+    for split in ("train", "dev"):
+        by_pair = defaultdict(list)
+        for row in records:
+            if row["source_split"] == split:
+                by_pair[tuple(e[1] for e in row["edges"])].append(row)
+        for rows in by_pair.values():
+            rows.sort(key=lambda r: order(r["id"], "2wiki-semantic-review-v1:"))
+        chosen = []
+        while len(chosen) < size:
+            added = False
+            for pair in sorted(by_pair, key=lambda p: order(p, "relation-review:")):
+                if by_pair[pair]:
+                    chosen.append(by_pair[pair].pop(0))
+                    added = True
+                    if len(chosen) == size:
+                        break
+            if not added:
+                break
+        result.extend(chosen)
+    return result
+
+
+def atomic_question(subject, relation):
+    return QUESTION_TEMPLATES[relation].format(subject=subject)
+
+
+def prompt(question):
+    return "Question: " + question + "\nAnswer:"
+
+
+def encode_example(tokenizer, question, answer, limit=256, generation_limit=64):
+    prefix = tokenizer.encode(prompt(question), add_special_tokens=False)
+    target = tokenizer.encode(" " + answer, add_special_tokens=False) + [tokenizer.eos_token_id]
+    joint = tokenizer.encode(prompt(question) + " " + answer, add_special_tokens=False)
+    if joint != prefix + target[:-1]:
+        raise ValueError("Answer boundary changes joint tokenization")
+    if len(prefix) + len(target) > limit or len(target) > generation_limit:
+        raise ValueError("Example exceeds the frozen length limits; never truncate an answer")
+    return {"prefix": prefix, "target": target, "input": (prefix + target)[:-1]}

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation.py

@@ -0,0 +1,322 @@
+"""Data-only confirmation isolation and independent endpoint recounting."""
+
+from __future__ import annotations
+
+import ast
+import copy
+import json
+import re
+import statistics
+import string
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import numpy as np
+
+from .realworld_composition_data import normalize_answer, order, sha256, write_json
+
+
+def head_bridge_names(data, canonical, aliases):
+    names = defaultdict(set)
+    for row in data["train_compositions"] + data["evaluation_compositions"]:
+        for index in (0, 2):
+            identifier = row["edges"][0][index]
+            labels = [canonical[identifier], row["surfaces"][0][index]]
+            for label in labels + aliases.get(identifier, []):
+                normalized = normalize_answer(label)
+                if normalized:
+                    names[identifier].add(normalized)
+    return names
+
+
+def answer_owners(canonical, aliases):
+    owners = defaultdict(set)
+    for identifier in set(canonical) | set(aliases):
+        for name in [canonical.get(identifier, ""), *aliases.get(identifier, [])]:
+            normalized = normalize_answer(name)
+            if normalized:
+                owners[normalized].add(identifier)
+    return owners
+
+
+def isolate_confirmation(candidate, development, canonical, aliases):
+    """Exclude every chain touching a development head/bridge name, then rebuild."""
+    dev_names = set().union(*head_bridge_names(development, canonical, aliases).values())
+    formal_names = head_bridge_names(candidate, canonical, aliases)
+    excluded_entities = {e for e, names in formal_names.items() if names & dev_names}
+    excluded = {}
+    parts = {}
+    for key in ("train_compositions", "evaluation_compositions"):
+        excluded[key] = [
+            r["id"]
+            for r in candidate[key]
+            if {r["edges"][0][0], r["edges"][0][2]} & excluded_entities
+        ]
+        excluded_ids = set(excluded[key])
+        parts[key] = [copy.deepcopy(r) for r in candidate[key] if r["id"] not in excluded_ids]
+    all_chains = parts["train_compositions"] + parts["evaluation_compositions"]
+    used = {a for r in all_chains for a in r["atom_ids"]}
+    atoms = [copy.deepcopy(r) for r in candidate["atoms"] if r["id"] in used]
+    first, second = ({r["atom_ids"][i] for r in parts["train_compositions"]} for i in (0, 1))
+    seen = first | second
+    direct = {(r["edge"][0], r["edge"][2]) for r in atoms}
+    pairs = {(r["edges"][0][0], r["edges"][1][2]) for r in parts["train_compositions"]}
+    operations = {tuple(e[1] for e in r["edges"]) for r in parts["train_compositions"]}
+    owners = answer_owners(canonical, aliases)
+    for row in atoms + all_chains:
+        identifier = row["edge"][2] if "edge" in row else row["edges"][1][2]
+        row["canonical_answer_globally_unambiguous"] = owners[normalize_answer(row["answer"])] == {
+            identifier
+        }
+    for row in all_chains:
+        a, b = row["atom_ids"]
+        row["role"] = ("I" if a in seen else "O") + ("I" if b in seen else "O")
+        row["required_role"] = ("I" if a in first else "O") + ("I" if b in second else "O")
+        pair = row["edges"][0][0], row["edges"][1][2]
+        row["known_direct_shortcut"] = pair in direct
+        row["head_tail_seen_in_combination_training"] = pair in pairs
+        row["operation_seen"] = tuple(e[1] for e in row["edges"]) in operations
+    panels = {
+        "test_" + role.lower(): [
+            r["id"]
+            for r in sorted(
+                [r for r in parts["evaluation_compositions"] if r["role"] == role],
+                key=lambda r: order(r["id"], "panel:"),
+            )[:64]
+        ]
+        for role in ("II", "IO", "OI", "OO")
+    }
+    panels["train_composition"] = [
+        r["id"]
+        for r in sorted(parts["train_compositions"], key=lambda r: order(r["id"], "panel:"))[:128]
+    ]
+    selected = {i for ids in panels.values() for i in ids}
+    required = {a for r in all_chains if r["id"] in selected for a in r["atom_ids"]}
+    panels["atomic"] = sorted(
+        required
+        | {r["id"] for r in sorted(atoms, key=lambda r: order(r["id"], "atom-panel:"))[:128]}
+    )
+    data = {"atoms": atoms, **parts, "panels": panels}
+    report = {
+        "rule": (
+            "Exclude chains whose head/bridge canonical, annotated surface or official alias "
+            "name overlaps development head/bridge names after author normalization; "
+            "retain shared tails."
+        ),
+        "excluded_entities": sorted(excluded_entities),
+        "excluded_case_ids": excluded,
+        "excluded_counts": {key: len(ids) for key, ids in excluded.items()},
+        "colliding_names": sorted(dev_names & set().union(*formal_names.values())),
+        "model_results_used": False,
+    }
+    return data, report
+
+
+def audit_confirmation(data, development, canonical, aliases):
+    """Recount from the selected records rather than selection bookkeeping."""
+    atoms = {r["id"]: r for r in data["atoms"]}
+    train, held = data["train_compositions"], data["evaluation_compositions"]
+    rows = train + held
+    dev_names = head_bridge_names(development, canonical, aliases)
+    formal_names = head_bridge_names(data, canonical, aliases)
+    assert not set(dev_names) & set(formal_names)
+    assert not set().union(*dev_names.values()) & set().union(*formal_names.values())
+    assert len(atoms) == len(data["atoms"])
+    assert len({r["id"] for r in rows}) == len(rows)
+
+    def chain(row):
+        return tuple(tuple(e) for e in row["edges"])
+
+    assert not {chain(r) for r in train} & {chain(r) for r in held}
+    held_questions = {normalize_answer(r["question"]) for r in held}
+    assert not {normalize_answer(r["question"]) for r in train} & held_questions
+    assert not {normalize_answer(r["question"]) for r in atoms.values()} & held_questions
+    assert not {normalize_answer(r["question"]) for r in atoms.values()} & {
+        normalize_answer(r["question"]) for r in development["atoms"]
+    }
+    seen = {a for r in train for a in r["atom_ids"]}
+    first, second = ({r["atom_ids"][i] for r in train} for i in (0, 1))
+    owners = answer_owners(canonical, aliases)
+    for row in rows:
+        a, b = row["atom_ids"]
+        assert [atoms[a]["edge"], atoms[b]["edge"]] == row["edges"]
+        assert row["edges"][0][2] == row["edges"][1][0]
+        assert row["role"] == ("I" if a in seen else "O") + ("I" if b in seen else "O")
+        assert row["required_role"] == ("I" if a in first else "O") + ("I" if b in second else "O")
+        assert not row["structural_errors"]
+    assert not any(r["known_prior_case"] for r in held)
+    for pool in (list(atoms.values()), train, held):
+        prompt_answers = defaultdict(set)
+        for row in pool:
+            prompt_answers[normalize_answer(row["question"])].add(normalize_answer(row["answer"]))
+            identifier = row["edge"][2] if "edge" in row else row["edges"][1][2]
+            assert row["canonical_answer_globally_unambiguous"] == (
+                owners[normalize_answer(row["answer"])] == {identifier}
+            )
+            e = row["encoded"]
+            assert e["target"][-1] == 50256 and len(e["target"]) <= 64
+            assert e["input"] == (e["prefix"] + e["target"])[:-1]
+            assert len(e["prefix"]) + len(e["target"]) <= 256
+        assert all(len(answers) == 1 for answers in prompt_answers.values())
+    panel_ids = {i for name, ids in data["panels"].items() if name != "atomic" for i in ids}
+    assert {a for r in rows if r["id"] in panel_ids for a in r["atom_ids"]} <= set(
+        data["panels"]["atomic"]
+    )
+    return {
+        "passed": True,
+        "atoms": len(atoms),
+        "train_compositions": len(train),
+        "evaluation_compositions": len(held),
+        "evaluation_roles": dict(Counter(r["role"] for r in held)),
+        "required_role_counts": dict(Counter(r["required_role"] for r in held)),
+        "canonical_unambiguous_evaluation_count": sum(
+            r["canonical_answer_globally_unambiguous"] for r in held
+        ),
+        "panels": {name: len(ids) for name, ids in data["panels"].items()},
+        "head_bridge_id_overlap": 0,
+        "head_bridge_normalized_name_overlap": 0,
+        "necessary_atomic_coverage": 1.0,
+        "known_direct_shortcuts": sum(r["known_direct_shortcut"] for r in held),
+        "unseen_operations": sum(not r["operation_seen"] for r in held),
+        "max_input_tokens": max(len(r["encoded"]["input"]) for r in list(atoms.values()) + rows),
+        "atomic_relations": dict(Counter(r["edge"][1] for r in atoms.values())),
+        "train_relation_pairs": dict(Counter(" -> ".join(e[1] for e in r["edges"]) for r in train)),
+    }
+
+
+def finalize_confirmation(config):
+    """Independently score raw outputs using the pinned author's scorer functions."""
+    root, art = Path(config["results_root"]), Path(config["artifact_root"])
+    data = json.loads(Path(config["data_file"]).read_text())
+    scorer = Path(config["official_scorer"])
+    scope = dict(re=re, string=string, Counter=Counter)
+    tree = ast.parse(scorer.read_text())
+    functions = [
+        n
+        for n in tree.body
+        if isinstance(n, ast.FunctionDef) and n.name in {"normalize_answer", "exact_match_score"}
+    ]
+    exec(compile(ast.Module(body=functions, type_ignores=[]), str(scorer), "exec"), scope)
+
+    def score(prediction, row):
+        return float(
+            any(
+                scope["exact_match_score"](prediction, g)
+                for g in [row["answer"], *row.get("aliases", [])]
+            )
+        )
+
+    held = data["evaluation_compositions"]
+    summary, scores, atom_scores, exposures, metadata = {}, {}, {}, {}, {}
+    for spec in config["runs"]:
+        name = spec["name"]
+        out = root / config["phase"] / name
+        complete = json.loads((out / "complete.json").read_text())
+        assert complete["step"] == spec["steps"] and complete["independently_reloaded"]
+        raw = json.loads((out / "endpoint-predictions.json").read_text())
+        metrics = json.loads((out / "endpoint.json").read_text())
+        for group, records in [
+            ("atomic", data["atoms"]),
+            ("train_composition", data["train_compositions"]),
+            ("test_all", held),
+        ]:
+            by_id = {p["id"]: p for p in raw[group]}
+            assert len(by_id) == len(records) == len(raw[group])
+            assert set(by_id) == {r["id"] for r in records}
+            recomputed = {r["id"]: score(by_id[r["id"]]["prediction"], r) for r in records}
+            assert all(recomputed[i] == by_id[i]["alias_em"] for i in recomputed)
+            assert abs(sum(recomputed.values()) / len(records) - metrics[group]["alias_em"]) < 1e-12
+            if group == "test_all":
+                scores[name] = recomputed
+                for role in ("II", "IO", "OI", "OO"):
+                    selected = [r for r in held if r["role"] == role]
+                    assert (
+                        abs(
+                            sum(recomputed[r["id"]] for r in selected) / len(selected)
+                            - metrics["test_" + role.lower()]["alias_em"]
+                        )
+                        < 1e-12
+                    )
+            if group == "atomic":
+                atom_scores[name] = recomputed
+        summary[name] = metrics
+        exposures[name] = {
+            step: np.load(out / f"exposure-{step:07d}.npz")["counts"]
+            for step in config["evaluation_nodes"]
+        }
+        metadata[name] = json.loads((out / "run.json").read_text())
+        assert complete["checkpoint_sha256"] == sha256(out / "latest.pt")
+    comparisons = []
+    for seed in sorted({s["initialization"] for s in config["runs"]}):
+        specs = {s["architecture"]: s for s in config["runs"] if s["initialization"] == seed}
+        assert set(specs) == {"standard8", "loop4x2", "standard4"}
+        names = [s["name"] for s in specs.values()]
+        assert len({metadata[n]["common_four_block_initial_sha256"] for n in names}) == 1
+        for step in config["evaluation_nodes"]:
+            assert all(
+                np.array_equal(exposures[names[0]][step], exposures[n][step]) for n in names[1:]
+            )
+        for baseline in ("standard8", "standard4"):
+            loop, base = specs["loop4x2"]["name"], specs[baseline]["name"]
+            for role in ("all", "OO"):
+                selected = held if role == "all" else [r for r in held if r["role"] == role]
+                common = [
+                    r
+                    for r in selected
+                    if all(atom_scores[n][a] for n in (loop, base) for a in r["atom_ids"])
+                ]
+                comparisons.append(
+                    {
+                        "initialization": seed,
+                        "baseline": baseline,
+                        "pool": role,
+                        "n": len(selected),
+                        "paired_difference": sum(
+                            scores[loop][r["id"]] - scores[base][r["id"]] for r in selected
+                        )
+                        / len(selected),
+                        "both_models_necessary_atoms_correct_n": len(common),
+                        "both_models_necessary_atoms_correct_coverage": len(common) / len(selected),
+                        "conditional_paired_difference": sum(
+                            scores[loop][r["id"]] - scores[base][r["id"]] for r in common
+                        )
+                        / len(common)
+                        if common
+                        else None,
+                    }
+                )
+    means = {}
+    for architecture in ("standard8", "loop4x2", "standard4"):
+        names = [s["name"] for s in config["runs"] if s["architecture"] == architecture]
+        means[architecture] = {}
+        for group in (
+            "atomic",
+            "train_composition",
+            "test_all",
+            "test_ii",
+            "test_io",
+            "test_oi",
+            "test_oo",
+            "autonomous",
+        ):
+            values = [summary[n][group]["alias_em"] for n in names]
+            means[architecture][group] = {
+                "mean": statistics.mean(values),
+                "sample_sd": statistics.stdev(values),
+                "per_initialization": values,
+            }
+    result = {
+        "passed": True,
+        "runs": len(config["runs"]),
+        "scientific_updates": sum(s["steps"] for s in config["runs"]),
+        "independent_dataset_splits": 1,
+        "paired_initializations": 3,
+        "paired_exposures_equal_at_all_nodes": True,
+        "architecture_scores": means,
+        "paired_comparisons": comparisons,
+        "source_data_sha256": sha256(config["data_file"]),
+        "official_scorer_sha256": sha256(scorer),
+    }
+    write_json(art / "confirmation-summary.json", summary)
+    write_json(art / "confirmation-recount-audit.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py

@@ -0,0 +1,119 @@
+"""Registered relation/component and paired-knowledge trajectory descriptions."""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from pathlib import Path
+
+from .realworld_composition_data import write_json
+
+
+def threshold_intervals(history, group, threshold):
+    passed = [r["metrics"][group]["alias_em"] >= threshold for r in history]
+
+    def interval(index):
+        if index is None:
+            return None
+        return [history[index - 1]["step"] if index else None, history[index]["step"]]
+
+    first = next((i for i, value in enumerate(passed) if value), None)
+    sustained = next((i for i, value in enumerate(passed) if value and all(passed[i:])), None)
+    return {
+        "first_observed_interval": interval(first),
+        "sustained_observed_interval": interval(sustained),
+    }
+
+
+def analyze_confirmation(config):
+    root = Path(config["results_root"]) / config["phase"]
+    data = json.loads(Path(config["data_file"]).read_text())
+    held = {r["id"]: r for r in data["evaluation_compositions"]}
+    endpoint_groups, thresholds, nodes = {}, {}, {}
+    for spec in config["runs"]:
+        name = spec["name"]
+        out = root / name
+        raw = json.loads((out / "endpoint-predictions.json").read_text())["test_all"]
+        by_relation, by_component = defaultdict(list), defaultdict(list)
+        for prediction in raw:
+            row = held[prediction["id"]]
+            by_relation[" -> ".join(e[1] for e in row["edges"])].append(prediction["alias_em"])
+            by_component[row["group"]].append(prediction["alias_em"])
+        endpoint_groups[name] = {
+            key: {k: {"n": len(v), "alias_em": sum(v) / len(v)} for k, v in groups.items()}
+            for key, groups in [
+                ("relation_pair", by_relation),
+                ("source_head_bridge_component", by_component),
+            ]
+        }
+        history = json.loads((out / "learning.json").read_text())
+        thresholds[name] = {
+            f"{group}_{value}": threshold_intervals(history, group, value)
+            for group, value in [("train_composition", 0.99), ("test_all", 0.5), ("test_all", 0.9)]
+        }
+        nodes[name] = {}
+        for step in config["evaluation_nodes"]:
+            node = json.loads((out / f"predictions-{step:07d}.json").read_text())
+            nodes[name][step] = {
+                group: {r["id"]: r["alias_em"] for r in node[group]}
+                for group in ("atomic", "test_all")
+            }
+    trajectories = []
+    for seed in sorted({s["initialization"] for s in config["runs"]}):
+        specs = {s["architecture"]: s for s in config["runs"] if s["initialization"] == seed}
+        loop = specs["loop4x2"]["name"]
+        for baseline in ("standard8", "standard4"):
+            base = specs[baseline]["name"]
+            for step in config["evaluation_nodes"]:
+                left, right = nodes[loop][step], nodes[base][step]
+                assert set(left["test_all"]) == set(right["test_all"])
+                for pool in ("all", "OO"):
+                    selected = [
+                        held[i]
+                        for i in left["test_all"]
+                        if pool == "all" or held[i]["role"] == pool
+                    ]
+                    common = [
+                        r
+                        for r in selected
+                        if all(n["atomic"][a] for n in (left, right) for a in r["atom_ids"])
+                    ]
+                    trajectories.append(
+                        {
+                            "initialization": seed,
+                            "baseline": baseline,
+                            "step": step,
+                            "pool": pool,
+                            "panel_n": len(selected),
+                            "both_models_necessary_atoms_correct_n": len(common),
+                            "both_models_necessary_atoms_correct_coverage": len(common)
+                            / len(selected),
+                            "full_panel_paired_difference": sum(
+                                left["test_all"][r["id"]] - right["test_all"][r["id"]]
+                                for r in selected
+                            )
+                            / len(selected),
+                            "conditional_paired_difference": sum(
+                                left["test_all"][r["id"]] - right["test_all"][r["id"]]
+                                for r in common
+                            )
+                            / len(common)
+                            if common
+                            else None,
+                        }
+                    )
+    result = {
+        "endpoint_groups": endpoint_groups,
+        "threshold_intervals": thresholds,
+        "paired_knowledge_trajectories": trajectories,
+        "trajectory_scope": (
+            "Fixed panels at registered nodes; threshold brackets are descriptive and do not "
+            "identify exact crossing times or establish grokking."
+        ),
+        "endpoint_scope": (
+            "Full registered evaluation pool; source components are shared by questions, "
+            "not independent worlds."
+        ),
+    }
+    write_json(Path(config["artifact_root"]) / "confirmation-analysis.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/recurrence_use.py

@@ -0,0 +1,416 @@
+"""Frozen-weight update deletion and semantic first-hop interventions.
+
+Responses are measurements of computational dependence, not learned predictors.
+Truth graphs select donors before inference; query means prevent donor frequency
+from creating additional scientific observations.
+"""
+
+from __future__ import annotations
+
+import time
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from .depth_step import EOS, prompt_rows, truth_path_details
+from .latent_scaling import model_digest
+
+COMPONENTS = ("full", "attention", "mlp")
+TASKS = ("atomic",) + tuple(f"{s}_{h}" for h in (2, 3, 4) for s in ("familiar", "strict"))
+
+
+@torch.no_grad()
+def trace(model, tokens, repeats, *, skip=None, patch=None):
+    """Apply one occurrence deletion or one r1 replacement, with native SDPA."""
+    if model.training or repeats < 1:
+        raise ValueError("Evaluation mode and positive recurrence are required")
+    blocks = list(model.iter_blocks(repeats))
+    if skip is not None:
+        scope, source = skip
+        if scope not in ("all", "r1") or source not in range(len(blocks)):
+            raise ValueError("Unknown skip scope/occurrence")
+    if patch is not None and patch[0] not in ("full", "mlp"):
+        raise ValueError("Unknown patch component")
+    x = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=tokens.device))
+    cache = {name: [] for name in ("input", "full", "attention", "mlp", "output")}
+    for index, block in enumerate(blocks):
+        incoming = x
+        z = block.ln1(x)
+        batch, length, width = z.shape
+        a = block.attention
+        q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2)
+        attention = a.proj(
+            F.scaled_dot_product_attention(
+                q.transpose(1, 2),
+                k.transpose(1, 2),
+                v.transpose(1, 2),
+                is_causal=True,
+                dropout_p=0.0,
+            )
+            .transpose(1, 2)
+            .reshape(batch, length, width)
+        )
+        x = x + attention
+        mlp = block.mlp(block.ln2(x))
+        if index == 0 and patch is not None and patch[0] == "mlp":
+            mlp = mlp.clone()
+            if patch[1].shape != mlp[:, 2].shape:
+                raise ValueError("Replacement shape differs")
+            mlp[:, 2] = patch[1]
+        x = x + mlp
+        if index == 0 and patch is not None and patch[0] == "full":
+            x = x.clone()
+            if patch[1].shape != x[:, 2].shape:
+                raise ValueError("Replacement shape differs")
+            x[:, 2] = patch[1]
+        if skip is not None and index == skip[1]:
+            if skip[0] == "all":
+                x, attention, mlp = incoming, torch.zeros_like(attention), torch.zeros_like(mlp)
+            else:
+                x, attention, mlp = x.clone(), attention.clone(), mlp.clone()
+                x[:, 2], attention[:, 2], mlp[:, 2] = incoming[:, 2], 0, 0
+        for name, value in zip(cache, (incoming, x - incoming, attention, mlp, x), strict=True):
+            cache[name].append(value)
+    logits = F.linear(model.ln_final(x), model.token.weight)
+    return logits, {name: torch.stack(values) for name, values in cache.items()}
+
+
+def interaction(numerator, denominator):
+    """Ratio of query-averaged norms; an absent denominator is not zero influence."""
+    numerator, denominator = np.asarray(numerator), np.asarray(denominator)
+    if numerator.shape != denominator.shape or not len(numerator):
+        raise ValueError("Require nonempty aligned response arrays")
+    n, b = float(numerator.mean()), float(denominator.mean())
+    return {"N": n, "B": b, "C": n / b if b > 1e-8 else None}
+
+
+def prediction_metrics(prediction, targets):
+    generated = prediction["generated"]
+    logits = prediction["logits"].astype(np.float64)
+    targets = np.asarray(targets, dtype=np.int64)
+    maximum = logits.max(1)
+    partition = maximum + np.log(np.exp(logits - maximum[:, None]).sum(1))
+    target_logits = logits[np.arange(len(targets)), targets]
+    competitors = logits.copy()
+    competitors[np.arange(len(targets)), targets] = -np.inf
+    return {
+        "answer": (generated[:, 0] == targets).astype(float),
+        "complete": ((generated[:, 0] == targets) & (generated[:, 1] == EOS)).astype(float),
+        "eos": (generated[:, 1] == EOS).astype(float),
+        "nll": partition - target_logits,
+        "margin": target_logits - competitors.max(1),
+    }
+
+
+def mean_metrics(metrics, mask=None):
+    length = len(next(iter(metrics.values())))
+    mask = np.ones(length, bool) if mask is None else np.asarray(mask, dtype=bool)
+    if mask.shape != (length,):
+        raise ValueError("Mask must align with observations")
+    return {
+        "n": int(mask.sum()),
+        "coverage": float(mask.mean()) if length else 0.0,
+        **{k: float(v[mask].mean()) if mask.any() else None for k, v in metrics.items()},
+    }
+
+
+def query_means(values, indices, n):
+    counts = np.bincount(indices, minlength=n)
+    sums = np.bincount(indices, weights=values, minlength=n)
+    out = np.full(n, np.nan)
+    np.divide(sums, counts, out=out, where=counts > 0)
+    return out
+
+
+def role_counts(world):
+    counts = np.zeros((len(world["atomic"]), 4), dtype=np.int64)
+    for hop in (2, 3, 4):
+        _, edges = truth_path_details(world, world[f"train_{hop}"])
+        for position in range(hop):
+            np.add.at(counts[:, position], edges[:, position], 1)
+    return counts
+
+
+def select_donors(low, high):
+    """Enumerate shared bridge donors and select answer-blind changed paths."""
+    atoms = low["atomic"]
+    for name in TASKS:
+        np.testing.assert_array_equal(low[name], high[name])
+    id_mask = np.asarray(low["metadata"]["id_mask"], bool)
+    np.testing.assert_array_equal(id_mask, high["metadata"]["id_mask"])
+    low_roles, high_roles = role_counts(low), role_counts(high)
+    if low_roles[~id_mask].any() or high_roles[~id_mask].any():
+        raise ValueError("Strict fact has composition training exposure")
+    used_first = (low_roles[:, 0] > 0) & (high_roles[:, 0] > 0)
+    strict = ~id_mask & (low_roles.sum(1) == 0) & (high_roles.sum(1) == 0)
+    result = {"low_roles": low_roles, "high_roles": high_roles}
+    rows = low["strict_2"]
+    nodes, _ = truth_path_details(low, rows)
+    for label, eligible in (("experienced", used_first), ("strict", strict)):
+        recipients, indices = [], []
+        for i, (row, path) in enumerate(zip(rows, nodes, strict=True)):
+            mask = eligible & (atoms[:, 1] == row[1]) & (atoms[:, 2] == path[1])
+            mask &= (atoms[:, 0] != row[0]) & (atoms[:, 0] != row[-1])
+            choices = sorted(np.flatnonzero(mask), key=lambda k: tuple(atoms[k]))
+            recipients.extend([i] * len(choices))
+            indices.extend(choices)
+        result[label + "_recipients"] = np.asarray(recipients, dtype=np.int64)
+        result[label + "_atoms"] = np.asarray(indices, dtype=np.int64)
+    result["common"] = (np.bincount(result["experienced_recipients"], minlength=len(rows)) > 0) & (
+        np.bincount(result["strict_recipients"], minlength=len(rows)) > 0
+    )
+    lookup = {(int(h), int(r)): (i, int(t)) for i, (h, r, t) in enumerate(atoms)}
+    trained = {tuple(row[:-1]) for w in (low, high) for row in w["train_2"]}
+    order = sorted(range(len(atoms)), key=lambda i: tuple(atoms[i]))
+    for label in ("familiar", "strict"):
+        rows = low[label + "_2"]
+        nodes, edges = truth_path_details(low, rows)
+        recipients, donors, targets, successors = [], [], [], []
+        for i, (row, path) in enumerate(zip(rows, nodes, strict=True)):
+            for fact in order:
+                h, r1, bridge = map(int, atoms[fact])
+                successor = lookup.get((bridge, int(row[2])))
+                if successor is None:
+                    continue
+                next_index, target = successor
+                if (
+                    r1 != row[1]
+                    or h in (row[0], row[-1], target)
+                    or bridge == path[1]
+                    or target == row[-1]
+                    or (h, r1, int(row[2])) in trained
+                    or id_mask[fact] != id_mask[edges[i, 0]]
+                    or id_mask[next_index] != id_mask[edges[i, 1]]
+                ):
+                    continue
+                recipients.append(i)
+                donors.append(fact)
+                targets.append(target)
+                successors.append(next_index)
+                break
+        result[label + "_changed_recipients"] = np.asarray(recipients, dtype=np.int64)
+        result[label + "_changed_atoms"] = np.asarray(donors, dtype=np.int64)
+        result[label + "_changed_targets"] = np.asarray(targets, dtype=np.int64)
+        result[label + "_changed_successors"] = np.asarray(successors, dtype=np.int64)
+    return result
+
+
+@torch.no_grad()
+def generate(model, rows, separator, repeats, *, skip=None, donor_atoms=None, component="full"):
+    """Free answer and free EOS; a donor sees only the atomic question prefix."""
+    rows = np.asarray(rows, np.int64)
+    if not len(rows):
+        return {
+            "generated": np.empty((0, 2), np.int64),
+            "logits": np.empty((0, model.config.vocab_size), np.float32),
+        }, None
+    device = next(model.parameters()).device
+    tokens = torch.as_tensor(prompt_rows(rows, separator), device=device)
+
+    def forward(inputs):
+        patch = None
+        if donor_atoms is not None:
+            donor = torch.zeros_like(inputs)
+            donor[:, :3] = torch.as_tensor(
+                prompt_rows(donor_atoms, separator)[:, :3], device=device
+            )
+            _, donor_cache = trace(model, donor, 1)
+            field = "output" if component == "full" else "mlp"
+            patch = (component, donor_cache[field][0, :, 2])
+        return trace(model, inputs, repeats, skip=skip, patch=patch)
+
+    logits, cache = forward(tokens)
+    answer_logits = logits[:, -1]
+    answer = answer_logits.argmax(-1)
+    eos_logits, _ = forward(torch.cat((tokens, answer[:, None]), dim=1))
+    prediction = {
+        "generated": torch.stack((answer, eos_logits[:, -1].argmax(-1)), 1).cpu().numpy(),
+        "logits": answer_logits.cpu().numpy(),
+    }
+    return prediction, cache
+
+
+def response_arrays(baseline, changed, source):
+    arrays, rows = {}, []
+    for component in COMPONENTS:
+        for site, position in (("all", None), ("r1", 2), ("answer", -1)):
+            a, b = baseline[component], changed[component]
+            n, d = (b - a).norm(dim=-1), a.norm(dim=-1)
+            n, d = (
+                (n.mean(-1), d.mean(-1))
+                if position is None
+                else (n[..., position], d[..., position])
+            )
+            for target in range(source + 1, len(a)):
+                numerator, denominator = n[target].cpu().numpy(), d[target].cpu().numpy()
+                key = f"{component}_{site}_i{source}_j{target}"
+                arrays[key + "_N"], arrays[key + "_B"] = numerator, denominator
+                rows.append(
+                    {
+                        "component": component,
+                        "site": site,
+                        "source": source,
+                        "target": target,
+                        **interaction(numerator, denominator),
+                    }
+                )
+    return arrays, rows
+
+
+@torch.no_grad()
+def evaluate(model, world, selection, repeats):
+    started = time.perf_counter()
+    if any(p.requires_grad for p in model.parameters()) or model.training:
+        raise ValueError("All weights must be frozen in evaluation mode")
+    before = model_digest(model)
+    model.repeats = repeats
+    separator = world["metadata"]["separator_token"]
+    arrays, summaries, engineering = {}, {}, {}
+    predictions, caches, metrics = {}, {}, {}
+    conditions = [("baseline", None)] + [
+        (f"skip_{scope}_{i}", (scope, i)) for scope in ("all", "r1") for i in range(repeats)
+    ]
+    for task in TASKS:
+        rows = world[task]
+        arrays[task + "_rows"] = rows
+        predictions[task], metrics[task] = {}, {}
+        for name, skip in conditions:
+            pred, cache = generate(model, rows, separator, repeats, skip=skip)
+            m = prediction_metrics(pred, rows[:, -1])
+            predictions[task][name], metrics[task][name] = pred, m
+            for field, values in {**pred, **m}.items():
+                arrays[f"{task}_{name}_{field}"] = values
+            summaries[f"{task}/{name}"] = {"full_pool": mean_metrics(m)}
+            if name == "baseline":
+                caches[task] = cache
+                inputs = torch.as_tensor(
+                    prompt_rows(rows, separator), device=next(model.parameters()).device
+                )
+                native = model(inputs)[:, -1].cpu().numpy()
+                if not np.array_equal(native, pred["logits"]):
+                    raise AssertionError("Traced logits differ from native forward")
+                engineering[task + "_native_logits_exact"] = True
+            elif task != "atomic":
+                response, cells = response_arrays(caches[task], cache, skip[1])
+                arrays.update({f"{task}_{name}_{k}": v for k, v in response.items()})
+                summaries[f"{task}/{name}"]["responses"] = cells
+            if name == f"skip_r1_{repeats - 1}":
+                for field in ("generated", "logits"):
+                    np.testing.assert_array_equal(pred[field], predictions[task]["baseline"][field])
+                engineering[task + "_last_r1_no_downstream_effect"] = True
+        del cache
+    for task in TASKS[1:]:
+        _, edges = truth_path_details(world, world[task])
+        arrays[task + "_atomic_indices"] = edges
+        common = np.ones(len(world[task]), bool)
+        for name, _ in conditions:
+            common &= metrics["atomic"][name]["complete"][edges].all(1)
+        arrays[task + "_common_atomic_mask"] = common
+        for name, _ in conditions:
+            cell = summaries[f"{task}/{name}"]
+            cell["necessary_atomic_coverage"] = float(
+                metrics["atomic"][name]["complete"][edges].all(1).mean()
+            )
+            cell["common_atomic_pool"] = mean_metrics(metrics[task][name], common)
+    # Self-prefix patches at equal physical length verify absence of later-relation information.
+    for task in ("familiar_2", "strict_2"):
+        rows = world[task]
+        atoms = np.c_[rows[:, :2], np.zeros(len(rows), np.int64)]
+        for component in ("full", "mlp"):
+            pred, _ = generate(
+                model, rows, separator, repeats, donor_atoms=atoms, component=component
+            )
+            for field in ("generated", "logits"):
+                np.testing.assert_array_equal(pred[field], predictions[task]["baseline"][field])
+            engineering[f"{task}_self_prefix_{component}_exact"] = True
+    rows = world["strict_2"]
+    _, edges = truth_path_details(world, rows)
+    common = selection["common"]
+    donor_atom_ok = np.ones(len(world["atomic"]), bool)
+    for label in ("experienced", "strict"):
+        recipients, facts = selection[label + "_recipients"], selection[label + "_atoms"]
+        donor_atom_ok[facts] = metrics["atomic"]["baseline"]["complete"][facts].astype(bool)
+        for component in ("full", "mlp"):
+            if not len(recipients):
+                continue
+            pred, _ = generate(
+                model,
+                rows[recipients],
+                separator,
+                repeats,
+                donor_atoms=world["atomic"][facts],
+                component=component,
+            )
+            m = prediction_metrics(pred, rows[recipients, -1])
+            key = f"same_{label}_{component}"
+            for field, value in {**pred, **m}.items():
+                arrays[key + "_" + field] = value
+            balanced = {k: query_means(v, recipients, len(rows)) for k, v in m.items()}
+            summaries[key] = {
+                "common_graph_pool": mean_metrics(balanced, common),
+                "all_available": mean_metrics(balanced, np.isfinite(balanced["complete"])),
+            }
+    known = metrics["atomic"]["baseline"]["complete"][edges].all(1)
+    for label in ("experienced", "strict"):
+        recipients, facts = selection[label + "_recipients"], selection[label + "_atoms"]
+        for recipient, fact in zip(recipients, facts, strict=True):
+            known[recipient] &= donor_atom_ok[fact]
+    arrays["same_common_known_mask"] = known & common
+    summaries["same_baseline"] = {
+        "common_graph_pool": mean_metrics(metrics["strict_2"]["baseline"], common),
+        "common_known_pool": mean_metrics(metrics["strict_2"]["baseline"], known & common),
+    }
+    for label in ("experienced", "strict"):
+        recipients = selection[label + "_recipients"]
+        for component in ("full", "mlp"):
+            key = f"same_{label}_{component}"
+            if key in summaries:
+                m = {
+                    k: arrays[key + "_" + k] for k in ("answer", "complete", "eos", "nll", "margin")
+                }
+                balanced = {k: query_means(v, recipients, len(rows)) for k, v in m.items()}
+                summaries[key]["common_known_pool"] = mean_metrics(balanced, known & common)
+    for label in ("familiar", "strict"):
+        task = label + "_2"
+        recipients = selection[label + "_changed_recipients"]
+        facts = selection[label + "_changed_atoms"]
+        targets = selection[label + "_changed_targets"]
+        if not len(recipients):
+            continue
+        original = world[task][recipients]
+        counterfactual = original.copy()
+        counterfactual[:, 0] = world["atomic"][facts, 0]
+        counterfactual[:, -1] = targets
+        truth_path_details(world, counterfactual)
+        native_cf, _ = generate(model, counterfactual, separator, repeats)
+        values = {
+            "baseline": {k: v[recipients] for k, v in predictions[task]["baseline"].items()},
+            "counterfactual": native_cf,
+        }
+        for component in ("full", "mlp"):
+            values[component], _ = generate(
+                model,
+                original,
+                separator,
+                repeats,
+                donor_atoms=world["atomic"][facts],
+                component=component,
+            )
+        for name, pred in values.items():
+            key = f"changed_{label}_{name}"
+            m = prediction_metrics(pred, targets)
+            for field, vector in {**pred, **m}.items():
+                arrays[key + "_" + field] = vector
+            summaries[key] = mean_metrics(m)
+    arrays.update({"selection_" + k: v for k, v in selection.items()})
+    if model_digest(model) != before:
+        raise AssertionError("Intervention changed model parameters")
+    return arrays, {
+        "repeats": repeats,
+        "seconds": time.perf_counter() - started,
+        "weights_unchanged": True,
+        "model_sha256": before,
+        "engineering": engineering,
+        "conditions": summaries,
+    }

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/representation_alignment.py

@@ -0,0 +1,269 @@
+"""Intermediate supervision and input-compatible states in complete causal GPTs.
+
+The intervention observes the first executed block at the first relation token.
+Every arm executes the same forward/backward graph. Ordinary full-token CE,
+auxiliary entity CE, and state geometry are recorded separately.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from .grok_depth import EpochStream, GraphStep, make_optimizer, utc, write_json
+from .grok_loop_model import LoopGPT, flops
+from .latent_scaling import build_world, construct, model_digest
+from .storage_composition import data_digest, evaluate, file_hash, pack_sentences
+from .storage_frontier import learning_rate
+
+
+class RepresentationGPT(LoopGPT):
+    """Unchanged GPT/Loop computation, optionally exposing a causal early state."""
+
+    def forward(self, tokens, positions=None, repeats=None, return_bridge=False):
+        p = self.dropout if self.training else 0.0
+        x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device))
+        x = F.dropout(x, p=p, training=self.training)
+        bridge = None
+        for index, block in enumerate(self.iter_blocks(repeats)):
+            z = block.ln1(x)
+            batch, length, width = z.shape
+            a = block.attention
+            q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2)
+            y = F.scaled_dot_product_attention(
+                q.transpose(1, 2),
+                k.transpose(1, 2),
+                v.transpose(1, 2),
+                is_causal=True,
+                dropout_p=p,
+            )
+            y = a.proj(y.transpose(1, 2).reshape(batch, length, width))
+            x = x + F.dropout(y, p=p, training=self.training)
+            x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training)
+            if index == 0 and return_bridge:
+                bridge = x[:, 3]
+        x = self.ln_final(x)
+        if positions is not None:
+            x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions]
+        logits = F.linear(x, self.token.weight)
+        return (logits, bridge) if return_bridge else logits
+
+
+def new_model(spec, device):
+    # Construct through the established initializer, then replace only the type.
+    model = construct(spec, device)
+    model.__class__ = RepresentationGPT
+    return model
+
+
+def pack_training(world):
+    strata = [world[k] for k in ("common_atomic", "train_composite", "anchor_atomic")]
+    tokens, labels = (
+        np.concatenate(parts)
+        for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True)
+    )
+    # Column 2 is the atomic answer or the composition's first-hop answer.
+    # It never enters the composed input; it is an explicit auxiliary target.
+    targets = np.concatenate([rows[:, 2] for rows in strata])
+    return (tokens, labels, targets), [len(rows) for rows in strata]
+
+
+def objective(model, tokens, labels, targets, bridge_weight, alignment_weight):
+    logits, bridge = model(tokens, return_bridge=True)
+    text_ce = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100)
+    bridge_logits = F.linear(model.ln_final(bridge), model.token.weight)
+    bridge_ce = F.cross_entropy(bridge_logits, targets)
+    canonical = model.token(targets).detach()
+    alignment = (
+        (F.normalize(bridge, dim=-1) - F.normalize(canonical, dim=-1)).square().sum(-1).mean()
+    )
+    parts = torch.stack((text_ce, bridge_ce, alignment))
+    return text_ce + bridge_weight * bridge_ce + alignment_weight * alignment, parts
+
+
+class RepresentationStep(GraphStep):
+    def __init__(self, model, optimizer, table, batch_size, spec):
+        self.spec = spec
+        super().__init__(model, optimizer, table, batch_size)
+
+    def eager(self):
+        self.optimizer.zero_grad(set_to_none=False)
+        tokens, labels, targets = (part[self.index] for part in self.table)
+        loss, self.components = objective(
+            self.model,
+            tokens,
+            labels,
+            targets,
+            self.spec["bridge_weight"],
+            self.spec["alignment_weight"],
+        )
+        loss.backward()
+        norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True)
+        self.optimizer.step()
+        return loss, norm
+
+
+def run_name(spec):
+    return f"{spec['phase']}-w{spec['world']}-i{spec['initialization']}-{spec['arm']}"
+
+
+def train(spec, out, source, device):
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "run.json").exists():
+        raise FileExistsError(f"Do not overwrite an attempt: {out}")
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_device(device)
+    started = time.perf_counter()
+    world = build_world(spec)
+    np.savez_compressed(out / "world.npz", **world)
+    arrays, sizes = pack_training(world)
+    model = new_model(spec, device)
+    initial_hash = model_digest(model)
+    write_json(
+        out / "run.json",
+        {
+            "spec": spec,
+            "source": source,
+            "world_sha256": data_digest(world),
+            "initial_model_sha256": initial_hash,
+            "pid": os.getpid(),
+            "gpu": device.index,
+            "gpu_name": torch.cuda.get_device_name(device),
+            "dtype": "float32",
+            "parameters": sum(p.numel() for p in model.parameters()),
+            "atomic_examples": sizes[0] + sizes[2],
+            "composition_examples": sizes[1],
+            "vocab_size": model.config.vocab_size,
+        },
+    )
+    table = tuple(torch.as_tensor(a, device=device) for a in arrays)
+    lr = torch.tensor(spec["lr"], device=device)
+    optimizer = make_optimizer(model, lr, spec["weight_decay"])
+    model.train()
+    graph = RepresentationStep(model, optimizer, table, spec["batch_size"], spec)
+    assert model_digest(model) == initial_hash, "CUDA capture changed initialization"
+    streams = [EpochStream(n, spec["stream_seed"] + j) for j, n in enumerate(sizes)]
+    offsets = np.cumsum([0, *sizes[:-1]])
+    counts = [np.zeros(n, dtype=np.int64) for n in sizes]
+    input_hash = hashlib.sha256()
+    history, step, training_seconds = [], 0, 0.0
+    flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 9, output_positions=9)
+    # All arms also execute the auxiliary readout and normalization.
+    flop_step += 6 * spec["batch_size"] * model.config.width * model.config.vocab_size
+
+    def measure():
+        metrics, predictions = evaluate(model, world, "low", device)
+        parts = graph.components.detach().cpu().tolist() if step else [None] * 3
+        row = {
+            "step": step,
+            "metrics": metrics,
+            "text_ce": parts[0],
+            "bridge_ce": parts[1],
+            "alignment_loss": parts[2],
+            "training_seconds": training_seconds,
+            "wall_seconds": time.perf_counter() - started,
+            "examples": step * spec["batch_size"],
+            "supervised_tokens": step * spec["batch_size"] // 3 * (7 + 9 + 7),
+            "auxiliary_target_presentations": step * spec["batch_size"],
+            "estimated_matmul_training_flops": step * flop_step,
+            "composition_epochs": step * spec["batch_size"] / 3 / sizes[1],
+        }
+        history.append(row)
+        write_json(out / "learning.json", history)
+        np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions)
+        write_json(out / "status.json", {"state": "running", "step": step, "budget": spec["steps"]})
+        print(
+            json.dumps(
+                {
+                    "run": run_name(spec),
+                    "step": step,
+                    "atomic": metrics["common_atomic"]["accuracy"],
+                    "train": metrics["train_composite"]["accuracy"],
+                    "familiar": metrics["familiar_test"]["accuracy"],
+                    "strict": metrics["strict_test"]["accuracy"],
+                }
+            ),
+            flush=True,
+        )
+        model.train()
+
+    measure()
+    for end in spec["nodes"][1:]:
+        torch.cuda.synchronize(device)
+        began = time.perf_counter()
+        while step < end:
+            n = min(128, end - step)
+            indices = []
+            for j, stream in enumerate(streams):
+                drawn = stream.take(n * spec["batch_size"] // 3).reshape(n, -1)
+                counts[j] += np.bincount(drawn.ravel(), minlength=sizes[j])
+                indices.append(drawn + offsets[j])
+            indices = np.concatenate(indices, axis=1)
+            input_hash.update(indices.tobytes())
+            indices = torch.as_tensor(indices, device=device)
+            for j in range(n):
+                lr.fill_(learning_rate(spec, step + j + 1))
+                loss = graph(indices[j])
+            step += n
+        torch.cuda.synchronize(device)
+        training_seconds += time.perf_counter() - began
+        if not np.isfinite(float(loss)):
+            raise FloatingPointError(f"Nonfinite objective at {step}")
+        measure()
+    model.eval()
+    torch.save(
+        {"spec": spec, "model": model.state_dict(), "optimizer": optimizer.state_dict()},
+        out / "model.pt",
+    )
+    np.savez_compressed(out / "exposures.npz", **{f"stratum{j}": c for j, c in enumerate(counts)})
+    write_json(
+        out / "complete.json",
+        {
+            "spec": spec,
+            "source": source,
+            "finished_utc": utc(),
+            "metrics": history[-1]["metrics"],
+            "training_seconds": training_seconds,
+            "world_sha256": data_digest(world),
+            "initial_model_sha256": initial_hash,
+            "sample_stream_sha256": input_hash.hexdigest(),
+            "model_sha256": file_hash(out / "model.pt"),
+        },
+    )
+    write_json(out / "status.json", {"state": "complete", "step": step})
+
+
+def audit(out, device):
+    out = Path(out)
+    # Match trainer arithmetic before comparing generated tokens and NLL.
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    payload = torch.load(out / "model.pt", map_location="cpu", weights_only=False)
+    spec = payload["spec"]
+    model = new_model(spec, device)
+    model.load_state_dict(payload["model"])
+    world = build_world(spec)
+    metrics, predictions = evaluate(model, world, "low", device)
+    saved = np.load(out / f"predictions-{spec['steps']:06d}.npz")
+    max_nll_error = 0.0
+    for key, actual in predictions.items():
+        if key.endswith("nll"):
+            max_nll_error = max(max_nll_error, float(np.max(np.abs(actual - saved[key]))))
+            np.testing.assert_allclose(actual, saved[key], rtol=1e-5, atol=1e-5)
+        else:
+            np.testing.assert_array_equal(actual, saved[key])
+    write_json(
+        out / "audit.json",
+        {"passed": True, "metrics": metrics, "max_nll_error": max_nll_error, "allow_tf32": True},
+    )

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_composition.py

@@ -0,0 +1,543 @@
+"""Development comparison in an unchanged, fully trained pretrained Qwen LM.
+
+Only training document grouping differs. All weights, native embeddings,
+residuals, attention, norms and distinct MLP layers are retained.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+import shutil
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+import torch
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+QUESTIONS = (
+    (
+        "Who is {head}'s mentor?",
+        "Who mentors {head}?",
+        "Name the mentor of {head}.",
+        "Who is the mentor of {head}?",
+    ),
+    (
+        "Which city does {bridge} live in?",
+        "What city is {bridge}'s home?",
+        "Where does {bridge} live?",
+        "Name the city where {bridge} lives.",
+    ),
+    (
+        "Which city does {head}'s mentor live in?",
+        "What city is home to {head}'s mentor?",
+        "Where does the mentor of {head} live?",
+        "Name the city where {head}'s mentor lives.",
+    ),
+)
+CITIES = (
+    "Paris Rome London Berlin Tokyo Oslo Lima Cairo Delhi Seoul Dublin Madrid "
+    "Vienna Boston Sydney Lisbon"
+).split()
+
+
+def read(path):
+    return json.loads(Path(path).read_text())
+
+
+def write(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n")
+
+
+def sha(path):
+    with Path(path).open("rb") as handle:
+        return hashlib.file_digest(handle, "sha256").hexdigest()
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def build_world(config):
+    first = (
+        "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo"
+    ).split()
+    last = "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split()
+    names = [f"{a} {b}" for a in first for b in last]
+    n = config["target_triples"] + config["background_triples"]
+    assert 2 * n <= len(names)
+    rng = np.random.default_rng(config["world_seed"])
+    names = rng.permutation(names).tolist()
+    rows = []
+    for split, count in (
+        ("target", config["target_triples"]),
+        ("background", config["background_triples"]),
+    ):
+        cities = rng.permutation([CITIES[i % len(CITIES)] for i in range(count)])
+        for city in cities:
+            i = len(rows)
+            rows.append(
+                dict(id=i, split=split, head=names[2 * i], bridge=names[2 * i + 1], city=str(city))
+            )
+    return rows
+
+
+def prompt(row, hop, variant=0):
+    return "Fictional registry.\nQuestion: " + QUESTIONS[hop][variant].format(**row) + "\nAnswer:"
+
+
+def answer(row, hop):
+    return row["bridge"] if hop == 0 else row["city"]
+
+
+def encode_document(tokenizer, row, hop, variant):
+    ids = tokenizer.encode(
+        prompt(row, hop, variant) + " " + answer(row, hop) + ".", add_special_tokens=False
+    ) + [tokenizer.eos_token_id]
+    # The initial token of each atomic document has no within-document predecessor.
+    # It remains unscored when documents are joined, preserving every target token.
+    return dict(ids=ids, labels=[-100, *ids[1:]], triple=row["id"], hop=hop, variant=variant)
+
+
+def corpus(tokenizer, world):
+    records = {}
+    for row in world:
+        hops = range(3) if row["split"] == "background" else range(2)
+        for hop in hops:
+            for variant in range(4):
+                records[row["id"], hop, variant] = encode_document(tokenizer, row, hop, variant)
+    return records
+
+
+def stream(config, world):
+    rng = np.random.default_rng(config["training_seed"])
+    background = [r["id"] for r in world if r["split"] == "background"]
+    result = []
+    for _ in range(config["steps"]):
+        pairs = [
+            [int(i), int(v)]
+            for i, v in zip(
+                rng.choice(len(world), config["atomic_pairs_per_step"], replace=False),
+                rng.integers(4, size=config["atomic_pairs_per_step"]),
+                strict=True,
+            )
+        ]
+        compositions = [
+            [int(i), int(v)]
+            for i, v in zip(
+                rng.choice(background, config["background_compositions_per_step"], replace=False),
+                rng.integers(4, size=config["background_compositions_per_step"]),
+                strict=True,
+            )
+        ]
+        result.append(dict(pairs=pairs, compositions=compositions))
+    return result
+
+
+def documents(records, batch, arm):
+    docs = []
+    for i, v in batch["pairs"]:
+        first, second = records[i, 0, v], records[i, 1, v]
+        if arm == "separate":
+            docs.extend([first, second])
+        elif arm == "linked":
+            docs.append(
+                dict(ids=first["ids"] + second["ids"], labels=first["labels"] + second["labels"])
+            )
+        else:
+            raise ValueError(arm)
+    docs.extend(records[i, 2, v] for i, v in batch["compositions"])
+    return docs
+
+
+def batch_tensors(docs, pad_id, device):
+    width = max(len(d["ids"]) for d in docs)
+    ids = torch.full((len(docs), width), pad_id, device=device, dtype=torch.long)
+    labels = torch.full_like(ids, -100)
+    mask = torch.zeros_like(ids)
+    for i, doc in enumerate(docs):
+        n = len(doc["ids"])
+        ids[i, :n] = torch.tensor(doc["ids"], device=device)
+        labels[i, :n] = torch.tensor(doc["labels"], device=device)
+        mask[i, :n] = 1
+    return dict(input_ids=ids, attention_mask=mask, labels=labels)
+
+
+def normalize(text):
+    return re.sub(r"\s+", " ", text.strip().rstrip(".").strip()).casefold()
+
+
+def grade(text, gold):
+    first_line = text.strip().split("\n")[0]
+    return normalize(first_line) == normalize(gold)
+
+
+def evaluation_rows(world):
+    return [
+        dict(**row, hop=hop, prompt=prompt(row, hop), answer=answer(row, hop))
+        for row in world
+        for hop in (range(3) if row["split"] == "target" else [2])
+    ]
+
+
+@torch.inference_mode()
+def evaluate(model, tokenizer, world, config):
+    model.eval()
+    tokenizer.padding_side = "left"
+    rows = evaluation_rows(world)
+    results = []
+    for start in range(0, len(rows), config["eval_batch"]):
+        chunk = rows[start : start + config["eval_batch"]]
+        enc = tokenizer(
+            [r["prompt"] for r in chunk],
+            padding=True,
+            return_tensors="pt",
+            add_special_tokens=False,
+        ).to(config["device"])
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            generated = model.generate(
+                **enc,
+                do_sample=False,
+                max_new_tokens=config["max_new_tokens"],
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                use_cache=True,
+            )[:, enc.input_ids.shape[1] :]
+        for row, tokens in zip(chunk, generated.cpu().tolist(), strict=True):
+            # Drop batching padding after the first EOS; retain the actual generated EOS.
+            if tokenizer.eos_token_id in tokens:
+                tokens = tokens[: tokens.index(tokenizer.eos_token_id) + 1]
+            text = tokenizer.decode(tokens, skip_special_tokens=True)
+            results.append(
+                dict(**row, tokens=tokens, text=text, correct=grade(text, row["answer"]))
+            )
+    return results
+
+
+def score(rows):
+    result = {}
+    for split, hop, key in (
+        ("target", 0, "first_hop"),
+        ("target", 1, "second_hop"),
+        ("target", 2, "two_hop"),
+        ("background", 2, "background_two_hop"),
+    ):
+        selected = [r for r in rows if r["split"] == split and r["hop"] == hop]
+        result[key] = sum(r["correct"] for r in selected) / len(selected)
+    indexed = {(r["id"], r["hop"]): r for r in rows if r["split"] == "target"}
+    mastered = [
+        i for i, h in indexed if h == 0 and indexed[i, 0]["correct"] and indexed[i, 1]["correct"]
+    ]
+    result["both_atomic_coverage"] = len(mastered) / sum(h == 0 for _, h in indexed)
+    result["two_hop_if_both_atomic"] = (
+        sum(indexed[i, 2]["correct"] for i in mastered) / len(mastered) if mastered else None
+    )
+    return result
+
+
+def prepare(config_path):
+    config = read(config_path)
+    art = Path(config["artifact_root"])
+    if (art / "lock.json").exists():
+        raise RuntimeError("Development lock already exists; do not overwrite it.")
+    tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True)
+    world = build_world(config)
+    batches = stream(config, world)
+    records = corpus(tokenizer, world)
+    assert all(h != 2 or world[i]["split"] == "background" for i, h, _ in records)
+    stats = {}
+    for arm in config["arms"]:
+        counts = Counter()
+        token_counts = Counter()
+        input_tokens = supervised_tokens = padded_tokens = attention_cells = 0
+        for batch in batches:
+            docs = documents(records, batch, arm)
+            for d in docs:
+                input_tokens += len(d["ids"])
+                supervised_tokens += sum(t != -100 for t in d["labels"])
+                counts.update(t for t in d["labels"] if t != -100)
+                token_counts.update(d["ids"])
+            width = max(len(d["ids"]) for d in docs)
+            padded_tokens += len(docs) * width
+            attention_cells += len(docs) * width**2
+        stats[arm] = dict(
+            input_tokens=input_tokens,
+            supervised_tokens=supervised_tokens,
+            padded_tokens=padded_tokens,
+            attention_cells=attention_cells,
+            target_token_counts=sorted(counts.items()),
+            input_token_counts=sorted(token_counts.items()),
+        )
+    for key in ("input_tokens", "supervised_tokens", "target_token_counts", "input_token_counts"):
+        assert stats["separate"][key] == stats["linked"][key], key
+    write(art / "world.json", world)
+    write(art / "stream.json", batches)
+    write(art / "data-audit.json", dict(status="passed", stats=stats, target_composition_labels=0))
+    sources = [
+        str(config_path),
+        __file__,
+        "scripts/run_small_lm_composition.py",
+        "tests/test_small_lm_composition.py",
+        str(art / "development-plan.md"),
+    ]
+    frozen = {}
+    for source in sources:
+        path = Path(source).resolve()
+        relative = path.relative_to(Path.cwd())
+        dest = art / "source" / relative
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(path, dest)
+        frozen[str(relative)] = sha(path)
+    model_files = {
+        str(p): sha(p)
+        for p in Path(config["model_path"]).iterdir()
+        if p.suffix in (".safetensors", ".json")
+    }
+    write(
+        art / "lock.json",
+        dict(
+            status="locked_before_training",
+            utc=now(),
+            sources=frozen,
+            model_files=model_files,
+            world_sha256=sha(art / "world.json"),
+            stream_sha256=sha(art / "stream.json"),
+        ),
+    )
+    print(
+        json.dumps(
+            {
+                "status": "prepared",
+                "stats": {
+                    a: {k: v for k, v in s.items() if not k.endswith("counts")}
+                    for a, s in stats.items()
+                },
+            }
+        ),
+        flush=True,
+    )
+
+
+def parameter_samples(model):
+    names = [
+        "model.embed_tokens.weight",
+        "model.layers.0.self_attn.q_proj.weight",
+        "model.layers.0.mlp.down_proj.weight",
+        "model.layers.0.input_layernorm.weight",
+        "model.layers.27.self_attn.o_proj.weight",
+        "model.layers.27.mlp.down_proj.weight",
+    ]
+    params = dict(model.named_parameters())
+    return {n: params[n].detach().flatten()[:4096].clone() for n in names}
+
+
+def train(config_path, arm):
+    config = read(config_path)
+    assert arm in config["arms"]
+    art = Path(config["artifact_root"])
+    lock = read(art / "lock.json")
+    for path, expected in lock["sources"].items():
+        assert sha(path) == expected, path
+    for path, expected in lock["model_files"].items():
+        assert sha(path) == expected, path
+    assert sha(art / "world.json") == lock["world_sha256"]
+    assert sha(art / "stream.json") == lock["stream_sha256"]
+    out = Path(config["output_root"]) / arm
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "status.json").exists():
+        raise RuntimeError("A run record already exists; preserve it and use a new output root.")
+    write(out / "status.json", dict(status="running", arm=arm, utc=now()))
+    begun = time.perf_counter()
+    torch.set_num_threads(config["cpu_threads"])
+    torch.manual_seed(config["training_seed"])
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    torch.cuda.set_device(config["device"])
+    torch.cuda.reset_peak_memory_stats()
+    tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    model = AutoModelForCausalLM.from_pretrained(
+        config["model_path"],
+        torch_dtype=torch.float32,
+        attn_implementation="sdpa",
+        local_files_only=True,
+    ).to(config["device"])
+    model.requires_grad_(True)
+    assert all(p.requires_grad for p in model.parameters())
+    assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024
+    assert len({id(layer.mlp) for layer in model.model.layers}) == 28
+    samples = parameter_samples(model)
+    world, batches = read(art / "world.json"), read(art / "stream.json")
+    records = corpus(tokenizer, world)
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=config["learning_rate"],
+        weight_decay=config["weight_decay"],
+        fused=True,
+    )
+    curve = []
+    token_count = 0
+    train_seconds = 0.0
+    initial_gradients = {}
+    for step in range(config["steps"] + 1):
+        if step in config["nodes"]:
+            rows = evaluate(model, tokenizer, world, config)
+            write(out / f"predictions-{step:05d}.json", rows)
+            record = dict(step=step, **score(rows))
+            curve.append(record)
+            write(out / "curve.json", curve)
+            print(json.dumps(dict(arm=arm, **record)), flush=True)
+        if step == config["steps"]:
+            break
+        rate = config["minimum_learning_rate"] + 0.5 * (
+            config["learning_rate"] - config["minimum_learning_rate"]
+        ) * (
+            1
+            + math.cos(
+                math.pi
+                * max(0, step - config["warmup_steps"])
+                / (config["steps"] - config["warmup_steps"])
+            )
+        )
+        rate *= min(1.0, (step + 1) / config["warmup_steps"])
+        for group in optimizer.param_groups:
+            group["lr"] = rate
+        model.train()
+        docs = documents(records, batches[step], arm)
+        inputs = batch_tensors(docs, tokenizer.pad_token_id, config["device"])
+        token_count += int(inputs["labels"].ne(-100).sum())
+        torch.cuda.synchronize()
+        tick = time.perf_counter()
+        optimizer.zero_grad(set_to_none=True)
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            loss = model(**inputs, use_cache=False).loss
+        assert torch.isfinite(loss), float(loss)
+        loss.backward()
+        if step == 0:
+            for name, p in model.named_parameters():
+                assert p.grad is not None and torch.isfinite(p.grad).all(), name
+                if name in samples:
+                    initial_gradients[name] = float(p.grad.norm())
+        torch.nn.utils.clip_grad_norm_(model.parameters(), config["gradient_clip"])
+        optimizer.step()
+        torch.cuda.synchronize()
+        train_seconds += time.perf_counter() - tick
+        if (step + 1) % 32 == 0:
+            print(
+                json.dumps(
+                    dict(
+                        arm=arm,
+                        step=step + 1,
+                        loss=float(loss),
+                        learning_rate=rate,
+                        train_seconds=train_seconds,
+                    )
+                ),
+                flush=True,
+            )
+    changed = {
+        n: bool(not torch.equal(old, parameter_samples(model)[n])) for n, old in samples.items()
+    }
+    assert all(changed.values()), changed
+    parameter_count = sum(p.numel() for p in model.parameters())
+    model.save_pretrained(out / "model", safe_serialization=True)
+    tokenizer.save_pretrained(out / "model")
+    final_rows = rows
+    del optimizer, model, samples, inputs, loss
+    torch.cuda.empty_cache()
+    reloaded = AutoModelForCausalLM.from_pretrained(
+        out / "model",
+        torch_dtype=torch.float32,
+        attn_implementation="sdpa",
+        local_files_only=True,
+    ).to(config["device"])
+    reloaded_rows = evaluate(reloaded, tokenizer, world, config)
+    assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in reloaded_rows]
+    write(
+        out / "reload-audit.json",
+        dict(status="passed", predictions=len(final_rows), exact_generated_tokens=True),
+    )
+    budget = read(art / "data-audit.json")["stats"][arm]
+    assert token_count == budget["supervised_tokens"]
+    summary = dict(
+        status="complete",
+        phase="development",
+        arm=arm,
+        utc=now(),
+        metrics=score(final_rows),
+        model_repo=config["model_repo"],
+        model_revision=config["model_revision"],
+        lock_sha256=sha(art / "lock.json"),
+        parameter_count=parameter_count,
+        trainable_parameters=parameter_count,
+        sampled_parameters_changed=changed,
+        initial_sampled_gradient_norms=initial_gradients,
+        budget={k: v for k, v in budget.items() if not k.endswith("counts")},
+        updates=config["steps"],
+        train_seconds=train_seconds,
+        process_seconds=time.perf_counter() - begun,
+        peak_gpu_bytes=torch.cuda.max_memory_allocated(),
+        torch_version=torch.__version__,
+        transformers_version=transformers.__version__,
+        gpu=torch.cuda.get_device_name(),
+        train_weight_dtype="float32",
+        forward_dtype="bfloat16 autocast",
+        tf32=False,
+        checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")},
+    )
+    write(out / "summary.json", summary)
+    write(out / "status.json", dict(status="complete", utc=now()))
+    print(json.dumps(summary), flush=True)
+
+
+def report(config_path):
+    config = read(config_path)
+    art = Path(config["artifact_root"])
+    runs, predictions = {}, {}
+    for arm in config["arms"]:
+        out = Path(config["output_root"]) / arm
+        runs[arm] = read(out / "summary.json")
+        assert runs[arm]["status"] == "complete"
+        assert read(out / "reload-audit.json")["status"] == "passed"
+        rows = read(out / f"predictions-{config['steps']:05d}.json")
+        assert score(rows) == runs[arm]["metrics"]
+        predictions[arm] = {(r["id"], r["hop"]): r for r in rows if r["split"] == "target"}
+    common = [
+        i
+        for i, h in predictions["separate"]
+        if h == 0
+        and all(predictions[a][i, hop]["correct"] for a in config["arms"] for hop in (0, 1))
+    ]
+    conditional = {
+        a: sum(predictions[a][i, 2]["correct"] for i in common) / len(common) if common else None
+        for a in config["arms"]
+    }
+    result = dict(
+        status="complete",
+        phase="development_only",
+        utc=now(),
+        runs=runs,
+        common_atomic_n=len(common),
+        common_atomic_coverage=len(common) / config["target_triples"],
+        common_atomic_two_hop=conditional,
+        two_hop_difference=runs["linked"]["metrics"]["two_hop"]
+        - runs["separate"]["metrics"]["two_hop"],
+        notes=[
+            "One synthetic world and one training seed; no independent confirmation.",
+            "Natural-language fictional facts; original pretrained Qwen architecture.",
+            "Exact fact, input-token and supervised-token exposure match.",
+            "Document grouping changes context, positions and attention work.",
+            "Linked training co-presents the head and final city; not zero cooccurrence.",
+            "This behavior comparison does not uniquely identify an MLP mechanism.",
+        ],
+    )
+    write(art / "summary.json", result)
+    print(json.dumps({k: v for k, v in result.items() if k != "runs"}), flush=True)

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_followup.py

@@ -0,0 +1,558 @@
+"""Small full-Qwen development: matched rehearsal, pairing, and factual updates."""
+
+from __future__ import annotations
+
+import copy
+import itertools
+import json
+import math
+import shutil
+import time
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import torch
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from . import small_lm_composition as base
+
+HELDOUT = (
+    "Give the name of the person mentoring {head}.",
+    "In which city is {bridge} living?",
+    "In which city is the person mentoring {head} living?",
+)
+
+
+def pairing_stream(config, world):
+    batches = base.stream(config, world)
+    rng = np.random.default_rng(config["pairing_seed"])
+    for batch in batches:
+        pairs = batch["pairs"]
+
+        def valid(order, pairs=pairs):
+            return all(
+                world[i]["city"] != world[pairs[k][0]]["city"]
+                for (i, _), k in zip(pairs, order, strict=True)
+            )
+
+        candidates = (rng.permutation(len(pairs)).tolist() for _ in range(1000))
+        order = next((p for p in candidates if valid(p)), None)
+        if order is None:
+            order = next(
+                (list(p) for p in itertools.permutations(range(len(pairs))) if valid(p)), None
+            )
+        if order is None:
+            raise ValueError("Batch cannot match distinct cities; revise before training.")
+        batch["second_order"] = order
+    return batches
+
+
+def training_documents(records, batch, arm, copies=1):
+    pairs = batch["pairs"]
+    singles = [records[i, h, v] for i, v in pairs for h in (0, 1)]
+    docs = []
+    if arm == "separate":
+        docs.extend(singles)
+    else:
+        order = range(len(pairs)) if arm == "linked" else batch["second_order"]
+        if arm not in ("linked", "shuffled"):
+            raise ValueError(arm)
+        for (i, v), j in zip(pairs, order, strict=True):
+            k, w = pairs[j]
+            first, second = records[i, 0, v], records[k, 1, w]
+            docs.append(
+                dict(ids=first["ids"] + second["ids"], labels=first["labels"] + second["labels"])
+            )
+    docs.extend(singles * copies)
+    docs.extend(records[i, 2, v] for i, v in batch["compositions"])
+    return docs
+
+
+def edit_design(config, world):
+    rng = np.random.default_rng(config["edit_seed"])
+    ids = []
+    for city in base.CITIES:
+        options = [r["id"] for r in world if r["split"] == "target" and r["city"] == city]
+        ids.extend(int(i) for i in rng.choice(options, len(options) // 2, replace=False))
+    cities = rng.permutation(base.CITIES).tolist()
+    shift = int(rng.integers(1, len(cities)))
+    mapping = dict(zip(cities, cities[shift:] + cities[:shift], strict=True))
+    changed = copy.deepcopy(world)
+    for row in changed:
+        if row["id"] in ids:
+            row["city"] = mapping[row["city"]]
+    rng = np.random.default_rng(config["edit_training_seed"])
+    background = [r["id"] for r in world if r["split"] == "background"]
+    batches = []
+    for _ in range(config["edit_steps"]):
+        specs = []
+        for pool, count, hop in (
+            (ids, config["edited_second_per_step"], 1),
+            (ids, config["replayed_first_per_step"], 0),
+            (background, config["background_atomic_per_step"], None),
+            (background, config["background_compositions_edit_per_step"], 2),
+        ):
+            for i in rng.choice(pool, count, replace=False):
+                h = int(rng.integers(2)) if hop is None else hop
+                specs.append([int(i), h, int(rng.integers(4))])
+        batches.append(specs)
+    return dict(edited_ids=sorted(ids), city_mapping=mapping, world=changed, stream=batches)
+
+
+def view_prompt(row, hop, view):
+    if view == 0:
+        return base.prompt(row, hop)
+    return "Fictional registry.\nQuestion: " + HELDOUT[hop].format(**row) + "\nAnswer:"
+
+
+def evaluation_rows(world, extras=False):
+    return [
+        dict(
+            **row,
+            hop=hop,
+            view=view,
+            mode="direct",
+            prompt=view_prompt(row, hop, view),
+            answer=base.answer(row, hop),
+        )
+        for view in ((0, 1) if extras else (0,))
+        for row in world
+        if view == 0 or row["split"] == "target"
+        for hop in range(3)
+    ]
+
+
+def autonomous_rows(world, direct):
+    lookup = {r["id"]: r for r in world}
+    result = []
+    for first in direct:
+        if first["split"] != "target" or first["hop"] != 0:
+            continue
+        bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip()
+        row = lookup[first["id"]]
+        substituted = dict(row, bridge=bridge)
+        result.append(
+            dict(
+                **row,
+                hop=2,
+                view=first["view"],
+                mode="autonomous",
+                prompt=view_prompt(substituted, 1, first["view"]),
+                answer=row["city"],
+                generated_bridge=bridge,
+                first_tokens=first["tokens"],
+                first_text=first["text"],
+                first_correct=first["correct"],
+            )
+        )
+    return result
+
+
+@torch.inference_mode()
+def generate(model, tokenizer, rows, config):
+    model.eval()
+    tokenizer.padding_side = "left"
+    result = []
+    for start in range(0, len(rows), config["eval_batch"]):
+        chunk = rows[start : start + config["eval_batch"]]
+        x = tokenizer(
+            [r["prompt"] for r in chunk],
+            padding=True,
+            return_tensors="pt",
+            add_special_tokens=False,
+        ).to(config["device"])
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            tokens = model.generate(
+                **x,
+                do_sample=False,
+                max_new_tokens=config["max_new_tokens"],
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                use_cache=True,
+            )[:, x.input_ids.shape[1] :]
+        for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True):
+            if tokenizer.eos_token_id in tok:
+                tok = tok[: tok.index(tokenizer.eos_token_id) + 1]
+            text = tokenizer.decode(tok, skip_special_tokens=True)
+            result.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"])))
+    return result
+
+
+def evaluate(model, tokenizer, world, config, extras=False):
+    direct = generate(model, tokenizer, evaluation_rows(world, extras), config)
+    if not extras:
+        return direct
+    return direct + generate(model, tokenizer, autonomous_rows(world, direct), config)
+
+
+def mean_correct(rows):
+    return sum(r["correct"] for r in rows) / len(rows) if rows else None
+
+
+def metrics(rows, old_world, edit):
+    primary = [r for r in rows if r["view"] == 0 and r["mode"] == "direct"]
+    result = base.score(primary)
+    result["background_atomic"] = mean_correct(
+        [r for r in primary if r["split"] == "background" and r["hop"] < 2]
+    )
+    edited = set(edit["edited_ids"])
+    old = {r["id"]: r for r in old_world}
+    for view in (0, 1):
+        subset = [r for r in rows if r["view"] == view]
+        if not subset:
+            continue
+        for pool, keep in (("E", True), ("U", False)):
+            target = [r for r in subset if r["split"] == "target" and (r["id"] in edited) == keep]
+            for hop, name in ((0, "first"), (1, "second"), (2, "two")):
+                cell = [r for r in target if r["hop"] == hop and r["mode"] == "direct"]
+                result[f"v{view}_{pool}_{name}"] = mean_correct(cell)
+                if hop == 2 and cell:
+                    result[f"v{view}_{pool}_old_two"] = sum(
+                        base.grade(r["text"], old[r["id"]]["city"]) for r in cell
+                    ) / len(cell)
+            result[f"v{view}_{pool}_autonomous"] = mean_correct(
+                [r for r in target if r["mode"] == "autonomous"]
+            )
+        if view == 1:
+            for hop, name in ((0, "first"), (1, "second"), (2, "two")):
+                result[f"heldout_{name}"] = mean_correct(
+                    [r for r in subset if r["mode"] == "direct" and r["hop"] == hop]
+                )
+    return result
+
+
+def document_budget(docs):
+    width = max(len(d["ids"]) for d in docs)
+    return dict(
+        input_tokens=sum(len(d["ids"]) for d in docs),
+        supervised_tokens=sum(sum(t != -100 for t in d["labels"]) for d in docs),
+        padded_tokens=len(docs) * width,
+        attention_cells=len(docs) * width**2,
+    )
+
+
+def prepare(config_path):
+    config = base.read(config_path)
+    art = Path(config["artifact_root"])
+    if (art / "lock.json").exists():
+        raise RuntimeError("Preserve existing lock.")
+    tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True)
+    world = base.build_world(config)
+    batches = pairing_stream(config, world)
+    edit = edit_design(config, world)
+    records = base.corpus(tokenizer, world)
+    stats = {arm: Counter() for arm in config["arms"]}
+    for batch in batches:
+        signatures = []
+        for arm in config["arms"]:
+            docs = training_documents(records, batch, arm, config["standalone_rehearsal_copies"])
+            stats[arm].update(document_budget(docs))
+            signatures.append(
+                (
+                    Counter(t for d in docs for t in d["ids"]),
+                    Counter(t for d in docs for t in d["labels"] if t != -100),
+                )
+            )
+        assert all(s == signatures[0] for s in signatures)
+    changed = base.corpus(tokenizer, edit["world"])
+    edit_stats = {branch: Counter() for branch in ("update", "replay")}
+    for specs in edit["stream"]:
+        for branch, rec in (("update", changed), ("replay", records)):
+            docs = [rec[tuple(s)] for s in specs]
+            edit_stats[branch].update(document_budget(docs))
+        assert [len(changed[tuple(s)]["ids"]) for s in specs] == [
+            len(records[tuple(s)]["ids"]) for s in specs
+        ]
+    assert edit_stats["update"] == edit_stats["replay"]
+    base.write(art / "world.json", world)
+    base.write(art / "stream.json", batches)
+    base.write(art / "edit-design.json", edit)
+    base.write(
+        art / "data-audit.json",
+        dict(
+            status="passed",
+            training=stats,
+            editing=edit_stats,
+            paired_batch_checks=len(batches),
+            equal_edit_length_checks=len(edit["stream"]),
+            target_composition_labels=0,
+            edit_target_composition_labels=0,
+        ),
+    )
+    sources = [
+        str(config_path),
+        str(Path(__file__).relative_to(Path.cwd())) if Path(__file__).is_absolute() else __file__,
+        "src/llm_memory_editability/small_lm_composition.py",
+        "scripts/run_small_lm_followup.py",
+        "tests/test_small_lm_followup.py",
+        str(art / "development-plan.md"),
+    ]
+    hashes = {}
+    for source in sources:
+        relative = Path(source).resolve().relative_to(Path.cwd())
+        dest = art / "source" / relative
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(relative, dest)
+        hashes[str(relative)] = base.sha(relative)
+    model_files = {
+        str(p): base.sha(p)
+        for p in Path(config["model_path"]).iterdir()
+        if p.suffix in (".safetensors", ".json")
+    }
+    base.write(
+        art / "lock.json",
+        dict(
+            status="locked_before_training",
+            utc=base.now(),
+            sources=hashes,
+            model_files=model_files,
+            data_files={
+                str(art / f): base.sha(art / f)
+                for f in ("world.json", "stream.json", "edit-design.json", "data-audit.json")
+            },
+        ),
+    )
+    print(json.dumps(dict(status="prepared", training=stats, editing=edit_stats)), flush=True)
+
+
+def check_lock(config):
+    art = Path(config["artifact_root"])
+    lock = base.read(art / "lock.json")
+    for group in ("sources", "model_files", "data_files"):
+        for path, digest in lock[group].items():
+            assert base.sha(path) == digest, path
+
+
+def learning_rate(step, steps, lr, minimum, warmup):
+    decay = 0.5 * (1 + math.cos(math.pi * max(0, step - warmup) / (steps - warmup)))
+    return (minimum + (lr - minimum) * decay) * min(1.0, (step + 1) / warmup)
+
+
+def run(config_path, arm, branch=None):
+    config = base.read(config_path)
+    check_lock(config)
+    assert arm in config["arms"] and branch in (None, "update", "replay")
+    art = Path(config["artifact_root"])
+    root = Path(config["output_root"])
+    out = root / ("training" if branch is None else "editing") / arm
+    if branch:
+        out = out / branch
+    if (out / "status.json").exists():
+        raise RuntimeError(f"Preserve existing run: {out}")
+    old_world = base.read(art / "world.json")
+    edit = base.read(art / "edit-design.json")
+    # Both update and replay are scored against the SAME edited world.
+    world = edit["world"] if branch else old_world
+    source = Path(config["model_path"]) if branch is None else root / "training" / arm / "model"
+    if branch:
+        parent = base.read(root / "training" / arm / "summary.json")
+        for path, digest in parent["checkpoint_files"].items():
+            assert base.sha(path) == digest
+    steps = config["edit_steps"] if branch else config["steps"]
+    nodes = config["edit_nodes"] if branch else config["nodes"]
+    seed = config["edit_training_seed"] if branch else config["training_seed"]
+    prefix = "edit_" if branch else ""
+    batches = edit["stream"] if branch else base.read(art / "stream.json")
+    base.write(out / "status.json", dict(status="running", utc=base.now(), arm=arm, branch=branch))
+    started = time.perf_counter()
+    torch.set_num_threads(config["cpu_threads"])
+    torch.manual_seed(seed)
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    torch.cuda.set_device(config["device"])
+    torch.cuda.reset_peak_memory_stats()
+    tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    def load_model(path):
+        return AutoModelForCausalLM.from_pretrained(
+            path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True
+        ).to(config["device"])
+
+    model = load_model(source)
+    model.requires_grad_(True)
+    assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024
+    assert len({id(layer.mlp) for layer in model.model.layers}) == 28
+    samples = base.parameter_samples(model)
+    parameter_count = sum(p.numel() for p in model.parameters())
+    records = base.corpus(tokenizer, edit["world"] if branch == "update" else old_world)
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=config[prefix + "learning_rate"],
+        weight_decay=config["weight_decay"],
+        fused=True,
+    )
+    curve, budget = [], Counter()
+    train_seconds = 0.0
+    for step in range(steps + 1):
+        if step in nodes:
+            rows = evaluate(model, tokenizer, world, config, extras=step == steps)
+            base.write(out / f"predictions-{step:05d}.json", rows)
+            record = dict(step=step, **metrics(rows, old_world, edit))
+            curve.append(record)
+            base.write(out / "curve.json", curve)
+            print(json.dumps(dict(arm=arm, branch=branch, **record)), flush=True)
+        if step == steps:
+            break
+        rate = learning_rate(
+            step,
+            steps,
+            config[prefix + "learning_rate"],
+            config[prefix + "minimum_learning_rate"],
+            config[prefix + "warmup_steps"],
+        )
+        for group in optimizer.param_groups:
+            group["lr"] = rate
+        docs = (
+            [records[tuple(s)] for s in batches[step]]
+            if branch
+            else training_documents(
+                records, batches[step], arm, config["standalone_rehearsal_copies"]
+            )
+        )
+        budget.update(document_budget(docs))
+        inputs = base.batch_tensors(docs, tokenizer.pad_token_id, config["device"])
+        model.train()
+        torch.cuda.synchronize()
+        tick = time.perf_counter()
+        optimizer.zero_grad(set_to_none=True)
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            loss = model(**inputs, use_cache=False).loss
+        assert torch.isfinite(loss)
+        loss.backward()
+        if step == 0:
+            assert all(
+                p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all()
+                for p in model.parameters()
+            )
+        torch.nn.utils.clip_grad_norm_(model.parameters(), config["gradient_clip"])
+        optimizer.step()
+        torch.cuda.synchronize()
+        train_seconds += time.perf_counter() - tick
+        if (step + 1) % 64 == 0:
+            print(
+                json.dumps(
+                    dict(
+                        arm=arm,
+                        branch=branch,
+                        step=step + 1,
+                        loss=float(loss.detach()),
+                        train_seconds=train_seconds,
+                    )
+                ),
+                flush=True,
+            )
+    changed = {
+        n: not torch.equal(before, base.parameter_samples(model)[n])
+        for n, before in samples.items()
+    }
+    assert all(changed.values())
+    architecture = model.config.to_dict()
+    model.save_pretrained(out / "model", safe_serialization=True)
+    tokenizer.save_pretrained(out / "model")
+    final_rows = rows
+    del optimizer, model, samples, inputs, loss
+    torch.cuda.empty_cache()
+    reloaded = load_model(out / "model")
+    again = evaluate(reloaded, tokenizer, world, config, extras=True)
+    assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again]
+    assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again]
+    base.write(
+        out / "reload-audit.json",
+        dict(
+            status="passed",
+            predictions=len(again),
+            exact_generated_tokens=True,
+            exact_autonomous_prompts=True,
+        ),
+    )
+    expected = base.read(art / "data-audit.json")
+    assert budget == expected["editing" if branch else "training"][branch or arm]
+    # Dense matrix estimate: 3x forward for training; all vocab logits are evaluated.
+    d, layers, intermediate = 1024, 28, architecture["intermediate_size"]
+    kv = architecture["num_key_value_heads"] * architecture["head_dim"]
+    query_width = architecture["num_attention_heads"] * architecture["head_dim"]
+    attention_projections = 2 * d * query_width + 2 * d * kv
+    per_token = layers * (attention_projections + 3 * d * intermediate)
+    per_token += d * architecture["vocab_size"]
+    flops = (
+        6 * per_token * budget["padded_tokens"]
+        + 12
+        * layers
+        * (architecture["num_attention_heads"] * architecture["head_dim"])
+        * budget["attention_cells"]
+    )
+    summary = dict(
+        status="complete",
+        phase="development_only",
+        arm=arm,
+        branch=branch,
+        utc=base.now(),
+        metrics=metrics(final_rows, old_world, edit),
+        updates=steps,
+        parameter_count=parameter_count,
+        trainable_parameters=parameter_count,
+        initial_all_gradients_finite=True,
+        sampled_parameters_changed=changed,
+        source_checkpoint=str(source),
+        fresh_optimizer=True,
+        budget=dict(budget),
+        estimated_training_matrix_flops=flops,
+        train_seconds=train_seconds,
+        process_seconds=time.perf_counter() - started,
+        peak_gpu_bytes=torch.cuda.max_memory_allocated(),
+        torch_version=torch.__version__,
+        transformers_version=transformers.__version__,
+        gpu=torch.cuda.get_device_name(),
+        tf32=False,
+        lock_sha256=base.sha(art / "lock.json"),
+        checkpoint_files={str(p): base.sha(p) for p in (out / "model").glob("*.safetensors")},
+    )
+    base.write(out / "summary.json", summary)
+    base.write(out / "status.json", dict(status="complete", utc=base.now()))
+    print(json.dumps(summary), flush=True)
+
+
+def report(config_path):
+    config = base.read(config_path)
+    check_lock(config)
+    art, root = Path(config["artifact_root"]), Path(config["output_root"])
+    world, edit = base.read(art / "world.json"), base.read(art / "edit-design.json")
+    runs = {}
+    checks = 0
+    for arm in config["arms"]:
+        for branch in (None, "update", "replay"):
+            out = root / ("editing" if branch else "training") / arm
+            if branch:
+                out /= branch
+            key = f"{arm}/{branch or 'training'}"
+            summary = base.read(out / "summary.json")
+            assert summary["status"] == "complete"
+            assert base.read(out / "reload-audit.json")["status"] == "passed"
+            for node in base.read(out / "curve.json"):
+                rows = base.read(out / f"predictions-{node['step']:05d}.json")
+                assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows)
+                assert dict(step=node["step"], **metrics(rows, world, edit)) == node
+                checks += len(rows)
+            assert metrics(rows, world, edit) == summary["metrics"]
+            runs[key] = summary
+    result = dict(
+        status="complete",
+        phase="single_world_development",
+        utc=base.now(),
+        runs=runs,
+        node_prediction_checks=checks,
+        total_train_seconds=sum(r["train_seconds"] for r in runs.values()),
+        total_process_seconds=sum(r["process_seconds"] for r in runs.values()),
+        total_updates=sum(r["updates"] for r in runs.values()),
+        total_input_tokens=sum(r["budget"]["input_tokens"] for r in runs.values()),
+        total_supervised_tokens=sum(r["budget"]["supervised_tokens"] for r in runs.values()),
+        estimated_training_matrix_flops=sum(
+            r["estimated_training_matrix_flops"] for r in runs.values()
+        ),
+        lock_sha256=base.sha(art / "lock.json"),
+    )
+    base.write(art / "summary.json", result)
+    print(json.dumps({k: v for k, v in result.items() if k != "runs"}), flush=True)

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_composition.py

@@ -0,0 +1,424 @@
+"""Fact-load experiments in unmodified GPT-2 blocks and depth-shared GPT-2 blocks.
+
+Template-language data are controlled; the architecture is an ordinary causal LM.
+No embeddings/projections are frozen, no intermediate answers are supplied, and
+all non-padding next tokens contribute to the training loss.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from .bios_model import ModelConfig
+from .grok_depth import EpochStream, GraphStep, SmallGPT, make_optimizer, utc, write_json
+from .grok_loop_model import LoopGPT, flops
+from .text_pretrain import WORDS, atomic_sentence, composite_sentence
+
+SOURCE_FILES = [
+    "src/llm_memory_editability/storage_composition.py",
+    "src/llm_memory_editability/bios_model.py",
+    "src/llm_memory_editability/grok_depth.py",
+    "src/llm_memory_editability/grok_loop_model.py",
+    "src/llm_memory_editability/text_pretrain.py",
+    "scripts/run_storage_composition.py",
+    "tests/test_storage_composition.py",
+]
+ARCHITECTURES = {
+    "standard1": (1, 1),
+    "standard2": (2, 1),
+    "standard3": (3, 1),
+    "loop1x2": (1, 2),
+    "loop1x3": (1, 3),
+}
+
+
+def file_hash(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def build_world(spec):
+    """Keep the target subgraph, vocabulary and candidates fixed across loads.
+
+    Matched low load repeats anchor atomics outside every evaluated chain.
+    High load teaches distinct distractor atomics. The original development
+    setting repeated familiar atomics; its results are retained separately.
+    """
+    rng = np.random.default_rng(spec["world"])
+    hn, bn, tn = (spec[k] for k in ("heads_n", "bridges_n", "tails_n"))
+    familiar, strict = spec["familiar_n"], spec["strict_n"]
+    core = familiar + strict
+    if not (0 < familiar < core <= min(hn, bn)):
+        raise ValueError("Invalid disjoint familiar/strict subgraph sizes")
+    heads = np.arange(len(WORDS), len(WORDS) + hn)
+    bridges = np.arange(heads[-1] + 1, heads[-1] + 1 + bn)
+    tails = np.arange(bridges[-1] + 1, bridges[-1] + 1 + tn)
+    first = []
+    for index, head in enumerate(heads):
+        candidates = (
+            bridges[:familiar]
+            if index < familiar
+            else bridges[familiar:core]
+            if index < core
+            else bridges
+        )
+        first.extend((head, r, rng.choice(candidates)) for r in range(13, 17))
+    first = np.asarray(first, dtype=np.int64)
+    second = np.asarray(
+        [(b, r, rng.choice(tails)) for b in bridges for r in range(17, 21)], dtype=np.int64
+    )
+    lookup = {(int(h), int(r)): int(t) for h, r, t in second}
+    paths = np.asarray(
+        [
+            (h, r1, b, r2, lookup[int(b), r2])
+            for h, r1, b in first[: core * 4]
+            for r2 in range(17, 21)
+        ],
+        dtype=np.int64,
+    )
+    familiar_paths = paths[paths[:, 0] < heads[familiar]]
+    # Hold out entire (head, terminal) pairs, including alternate relation paths.
+    reserved = rng.random((familiar, tn)) < spec["holdout_fraction"]
+    held = reserved[familiar_paths[:, 0] - heads[0], familiar_paths[:, 4] - tails[0]]
+    world = {
+        "common_atomic": np.concatenate([first[: core * 4], second[: core * 4]]),
+        "background_atomic": np.concatenate([first[: familiar * 4], second[: familiar * 4]]),
+        "extra_atomic": np.concatenate([first[core * 4 :], second[core * 4 :]]),
+        "train_composite": familiar_paths[~held],
+        "familiar_test": familiar_paths[held],
+        "strict_test": paths[paths[:, 0] >= heads[familiar]],
+    }
+    if spec.get("low_extra") == "anchors":
+        anchors = spec["anchor_n"]
+        if not 0 < anchors <= min(hn, bn) - core:
+            raise ValueError("Anchor entities must be outside the common subgraph")
+        world["anchor_atomic"] = np.concatenate(
+            [first[core * 4 : (core + anchors) * 4], second[core * 4 : (core + anchors) * 4]]
+        )
+    if any(not len(rows) for rows in world.values()):
+        raise ValueError("Empty stratum: do not silently reroll a world")
+    atoms = np.concatenate([world["common_atomic"], world["extra_atomic"]])
+    audit_world(world)
+    assert len(atoms) == 4 * (hn + bn)
+    return world
+
+
+def audit_world(world):
+    atoms = np.concatenate([world["common_atomic"], world["extra_atomic"]])
+    lookup = {(int(h), int(r)): int(t) for h, r, t in atoms}
+    assert len(lookup) == len(atoms)
+    for name in ("train_composite", "familiar_test", "strict_test"):
+        for h, r1, b, r2, t in world[name]:
+            assert lookup[int(h), int(r1)] == b
+            assert lookup[int(b), int(r2)] == t
+    train_pairs = {tuple(r[[0, 4]]) for r in world["train_composite"]}
+    assert not train_pairs & {tuple(r[[0, 4]]) for r in world["familiar_test"]}
+    train_facts = {(int(h), int(r1), int(b)) for h, r1, b, _r2, _t in world["train_composite"]} | {
+        (int(b), int(r2), int(t)) for _h, _r1, b, r2, t in world["train_composite"]
+    }
+    strict_facts = {(int(h), int(r1), int(b)) for h, r1, b, _r2, _t in world["strict_test"]} | {
+        (int(b), int(r2), int(t)) for _h, _r1, b, r2, t in world["strict_test"]
+    }
+    assert not strict_facts & train_facts
+    assert not strict_facts & set(map(tuple, world["extra_atomic"]))
+    if "anchor_atomic" in world:
+        assert not set(map(tuple, world["anchor_atomic"])) & set(map(tuple, world["common_atomic"]))
+        assert set(map(tuple, world["anchor_atomic"])) <= set(map(tuple, world["extra_atomic"]))
+
+
+def pack_sentences(rows):
+    render = atomic_sentence if rows.shape[1] == 3 else composite_sentence
+    x = np.zeros((len(rows), 9), dtype=np.int64)
+    labels = np.full_like(x, -100)
+    for index, row in enumerate(rows):
+        sentence = render(row)
+        x[index, : len(sentence) - 1] = sentence[:-1]
+        labels[index, : len(sentence) - 1] = sentence[1:]
+    return x, labels
+
+
+class FullTokenStep(GraphStep):
+    def eager(self):
+        self.optimizer.zero_grad(set_to_none=True)
+        tokens, labels = (part[self.index] for part in self.table)
+        logits = self.model(tokens)
+        loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100)
+        loss.backward()
+        norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True)
+        self.optimizer.step()
+        return loss, norm
+
+
+def construct(spec, device):
+    layers, repeats = ARCHITECTURES[spec["architecture"]]
+    config = ModelConfig(
+        vocab_size=len(WORDS) + spec["heads_n"] + spec["bridges_n"] + spec["tails_n"],
+        width=spec["width"],
+        layers=layers,
+        heads=spec["heads"],
+        context=16,
+    )
+    torch.manual_seed(spec["initialization"])
+    if repeats == 1:
+        model = SmallGPT(config, dropout=spec["dropout"])
+    else:
+        # Same unique-block initialization as standard1, without zeroing residuals.
+        model = LoopGPT(config, repeats, spec["dropout"], initialization="legacy_unique")
+    return model.to(device)
+
+
+@torch.no_grad()
+def generate_rows(model, rows, device, repeats=None, batch_size=512):
+    """Greedy answer, then '.', then EOS; feed back every generated token."""
+    model.eval()
+    if rows.shape[1] == 3:
+        prompts = np.asarray([atomic_sentence(r)[:5] for r in rows])
+    else:
+        prompts = np.asarray([composite_sentence(r)[:7] for r in rows])
+    predictions, nlls = [], []
+    kwargs = {"repeats": repeats} if isinstance(model, LoopGPT) else {}
+    for start in range(0, len(rows), batch_size):
+        tokens = torch.as_tensor(prompts[start : start + batch_size], device=device)
+        target = torch.as_tensor(rows[start : start + batch_size, -1], device=device)
+        generated = []
+        for i in range(3):
+            logits = model(tokens, **kwargs)[:, -1]
+            if i == 0:
+                nlls.append(F.cross_entropy(logits, target, reduction="none").cpu().numpy())
+            next_token = logits.argmax(-1)
+            generated.append(next_token.cpu().numpy())
+            tokens = torch.cat([tokens, next_token[:, None]], dim=1)
+        predictions.append(np.stack(generated, axis=1))
+    pred, nll = np.concatenate(predictions), np.concatenate(nlls)
+    answer_ok = pred[:, 0] == rows[:, -1]
+    full_ok = answer_ok & (pred[:, 1] == 5) & (pred[:, 2] == 1)
+    metrics = {
+        "n": len(rows),
+        "answer_accuracy": float(answer_ok.mean()),
+        "accuracy": float(full_ok.mean()),
+        "answer_nll": float(nll.mean()),
+    }
+    return metrics, {"generated": pred, "correct": full_ok, "answer_nll": nll}
+
+
+def evaluate(model, world, load, device, repeats=None):
+    metrics, predictions = {}, {}
+    names = ["common_atomic", "train_composite", "familiar_test", "strict_test"]
+    if "anchor_atomic" in world:
+        names.append("anchor_atomic")
+    if load == "high":
+        names.append("extra_atomic")
+    for name in names:
+        metrics[name], pred = generate_rows(model, world[name], device, repeats)
+        predictions.update({name + "_" + k: v for k, v in pred.items()})
+    for name in ("familiar_test", "strict_test"):
+        rows = world[name]
+        first = rows[:, [0, 1, 2]]
+        second = rows[:, [2, 3, 4]]
+        _m, p1 = generate_rows(model, first, device, repeats)
+        _m, p2 = generate_rows(model, second, device, repeats)
+        covered = p1["correct"] & p2["correct"]
+        generated_second = second.copy()
+        generated_second[:, 0] = p1["generated"][:, 0]
+        _m, autonomous = generate_rows(model, generated_second, device, repeats)
+        calls_ok = (
+            (p1["generated"][:, 1] == 5) & (p1["generated"][:, 2] == 1) & autonomous["correct"]
+        )
+        direct = predictions[name + "_correct"]
+        metrics[name].update(
+            {
+                "atomic_correct_coverage": float(covered.mean()),
+                "conditional_accuracy": float(direct[covered].mean()) if covered.any() else None,
+                "autonomous_two_calls": float(calls_ok.mean()),
+            }
+        )
+        predictions.update({name + "_coverage": covered, name + "_two_calls": calls_ok})
+    model.train()
+    return metrics, predictions
+
+
+def data_digest(world):
+    digest = hashlib.sha256()
+    for key, value in sorted(world.items()):
+        digest.update(key.encode())
+        digest.update(str(value.shape).encode())
+        digest.update(value.tobytes())
+    return digest.hexdigest()
+
+
+def run(spec, out, device="cuda:2"):
+    out = Path(out)
+    if (out / "complete.json").exists():
+        raise FileExistsError(f"Completed run exists: {out}")
+    out.mkdir(parents=True, exist_ok=True)
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    device = torch.device(device)
+    torch.cuda.set_device(device)
+    world = build_world(spec)
+    np.savez_compressed(out / "world.npz", **world)
+    source = {path: file_hash(path) for path in SOURCE_FILES}
+    write_json(
+        out / "spec.json", {"spec": spec, "source": source, "data_sha256": data_digest(world)}
+    )
+    model = construct(spec, device)
+    lr = torch.tensor(spec["lr"], device=device)
+    opt = make_optimizer(model, lr, spec["weight_decay"])
+    low_extra = world["anchor_atomic"] if "anchor_atomic" in world else world["background_atomic"]
+    extra = world["extra_atomic"] if spec["load"] == "high" else low_extra
+    strata = [world["common_atomic"], world["train_composite"], extra]
+    packed = [pack_sentences(rows) for rows in strata]
+    table = tuple(
+        torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True)
+    )
+    sizes = [len(rows) for rows in strata]
+    offsets = np.cumsum([0, *sizes[:-1]])
+    streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)]
+    counts = [np.zeros(size, dtype=np.int64) for size in sizes]
+    batch = spec["batch_size"]
+    if batch % 3:
+        raise ValueError("Batch must divide into three equal exposure strata")
+    graph = FullTokenStep(model, opt, table, batch)
+    history, training_seconds = [], 0.0
+    layers, repeats = ARCHITECTURES[spec["architecture"]]
+    parameters = sum(p.numel() for p in model.parameters())
+    flop_step = flops(model.config, repeats, batch, 9, output_positions=9)
+    start = 0
+
+    def measure(step, loss=None):
+        metrics, predictions = evaluate(model, world, spec["load"], device)
+        row = {
+            "step": step,
+            "metrics": metrics,
+            "loss": loss,
+            "training_seconds": training_seconds,
+            "estimated_training_flops": step * flop_step,
+        }
+        history.append(row)
+        write_json(out / "learning.json", history)
+        np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions)
+        state = {
+            "spec": spec,
+            "step": step,
+            "model": model.state_dict(),
+            "optimizer": opt.state_dict(),
+            "streams": [s.state_dict() for s in streams],
+            "cpu_rng": torch.get_rng_state(),
+            "cuda_rng": torch.cuda.get_rng_state(device),
+            "counts": counts,
+            "source": source,
+            "data_sha256": data_digest(world),
+        }
+        torch.save(state, out / "latest.tmp.pt")
+        (out / "latest.tmp.pt").replace(out / "latest.pt")
+        write_json(
+            out / "status.json",
+            {
+                "step": step,
+                "budget": spec["steps"],
+                "atomic": metrics["common_atomic"]["accuracy"],
+                "familiar": metrics["familiar_test"]["accuracy"],
+                "strict": metrics["strict_test"]["accuracy"],
+            },
+        )
+        print(json.dumps({"run": str(out), "step": step, "metrics": metrics}), flush=True)
+        return row
+
+    measure(0)
+    for end in spec["nodes"]:
+        if end == 0:
+            continue
+        torch.cuda.synchronize()
+        t0 = time.perf_counter()
+        while start < end:
+            n = min(128, end - start)
+            indices = []
+            for i, stream in enumerate(streams):
+                drawn = stream.take(n * batch // 3).reshape(n, batch // 3)
+                counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i])
+                indices.append(drawn + offsets[i])
+            indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device)
+            for j in range(n):
+                lr.fill_(spec["lr"] * min(1.0, (start + j + 1) / spec["warmup"]))
+                last_loss = graph(indices[j])
+            start += n
+        torch.cuda.synchronize()
+        training_seconds += time.perf_counter() - t0
+        loss = float(last_loss)
+        if not np.isfinite(loss):
+            raise FloatingPointError(f"Nonfinite loss at {end}")
+        endpoint = measure(end, loss)
+    assert start == spec["steps"]
+    # Prespecified test-time repeat sweep; these weights never change.
+    repeat_metrics = {}
+    if isinstance(model, LoopGPT):
+        for count in spec["test_repeats"]:
+            metrics, predictions = evaluate(model, world, spec["load"], device, count)
+            repeat_metrics[str(count)] = metrics
+            np.savez_compressed(out / f"repeat-{count:02d}.npz", **predictions)
+    np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)})
+    write_json(
+        out / "complete.json",
+        {
+            "spec": spec,
+            "finished_utc": utc(),
+            "parameters": parameters,
+            "unique_blocks": layers,
+            "executed_blocks": layers * repeats,
+            "independent_facts": len(world["common_atomic"])
+            + (len(extra) if spec["load"] == "high" or "anchor_atomic" in world else 0),
+            "training_seconds": training_seconds,
+            "endpoint": endpoint,
+            "repeat_metrics": repeat_metrics,
+            "examples": start * batch,
+            "effective_input_tokens": start * batch * 23 // 3,
+            "supervised_tokens": start * batch * 23 // 3,
+            "padded_input_tokens": start * batch * 9,
+            "source": source,
+            "data_sha256": data_digest(world),
+            "environment": {"torch": torch.__version__, "gpu": torch.cuda.get_device_name(device)},
+        },
+    )
+    return endpoint
+
+
+def audit_run(out, device="cuda:2"):
+    """Independently reload the final checkpoint and regenerate all endpoint tokens."""
+    torch.set_num_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    out = Path(out)
+    complete = json.loads((out / "complete.json").read_text())
+    saved = torch.load(out / "latest.pt", map_location=device, weights_only=False)
+    assert saved["step"] == complete["spec"]["steps"]
+    world = build_world(saved["spec"])
+    assert data_digest(world) == saved["data_sha256"] == complete["data_sha256"]
+    model = construct(saved["spec"], device)
+    model.load_state_dict(saved["model"])
+    metrics, predictions = evaluate(model, world, saved["spec"]["load"], device)
+    expected = np.load(out / f"predictions-{saved['step']:06d}.npz")
+    for key, value in predictions.items():
+        # Tiny batching/platform differences can affect NLL, never generated tokens.
+        np.testing.assert_allclose(value, expected[key], rtol=1e-5, atol=1e-5)
+    assert metrics == complete["endpoint"]["metrics"]
+    exposures = np.load(out / "exposures.npz")
+    for i in range(3):
+        np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i])
+        assert exposures[f"stratum{i}"].sum() == saved["step"] * saved["spec"]["batch_size"] // 3
+        assert np.ptp(exposures[f"stratum{i}"]) <= 1
+    result = {
+        "passed": True,
+        "step": saved["step"],
+        "prediction_arrays": len(predictions),
+        "utc": utc(),
+    }
+    write_json(out / "audit.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_frontier.py

@@ -0,0 +1,262 @@
+"""Stable training and nested fact loads in ordinary GPT/Loop architectures.
+
+The historical storage_composition implementation is reused without changing its
+frozen sources, truth, tokenizer, architecture or full-generation score.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from .grok_depth import EpochStream, make_optimizer, utc, write_json
+from .grok_loop_model import LoopGPT, flops
+from .storage_composition import (
+    ARCHITECTURES,
+    FullTokenStep,
+    construct,
+    data_digest,
+    evaluate,
+    file_hash,
+    pack_sentences,
+)
+from .storage_composition import (
+    SOURCE_FILES as HISTORICAL_SOURCE_FILES,
+)
+from .storage_composition import (
+    build_world as historical_world,
+)
+
+SOURCE_FILES = [
+    *HISTORICAL_SOURCE_FILES,
+    "src/llm_memory_editability/storage_frontier.py",
+    "scripts/run_storage_frontier.py",
+    "tests/test_storage_frontier.py",
+]
+
+
+def learning_rate(spec, step):
+    """One-based update; paired schedules share the exact same warmup."""
+    if not 1 <= step <= spec["steps"]:
+        raise ValueError("Step must be within the training budget")
+    warmup = spec["warmup"]
+    if warmup and step <= warmup:
+        return spec["lr"] * step / warmup
+    if spec["schedule"] == "constant":
+        return spec["lr"]
+    if spec["schedule"] != "cosine":
+        raise ValueError("Unknown learning-rate schedule")
+    fraction = (step - warmup) / (spec["steps"] - warmup)
+    floor = spec["min_lr_ratio"]
+    return spec["lr"] * (floor + (1 - floor) * (1 + math.cos(math.pi * fraction)) / 2)
+
+
+def build_world(spec):
+    world = historical_world(spec)
+    if "extra_count" in spec:
+        # A world-specific, fixed permutation defines nested distractor fact sets.
+        # Common facts and every combination example remain bit-identical.
+        count = spec["extra_count"]
+        if not 0 < count <= len(world["extra_atomic"]):
+            raise ValueError("Extra fact count exceeds the fixed master graph")
+        rng = np.random.default_rng(spec["world"] + 900000)
+        order = rng.permutation(len(world["extra_atomic"]))
+        world["extra_atomic"] = world["extra_atomic"][order[:count]]
+    return world
+
+
+def strata_for(spec, world):
+    extra = world["extra_atomic"] if spec["load"] == "high" else world["anchor_atomic"]
+    return [world["common_atomic"], world["train_composite"], extra]
+
+
+def run_name(spec):
+    load = spec["load"]
+    if "extra_count" in spec:
+        load = f"f{spec['extra_count'] + 8 * (spec['familiar_n'] + spec['strict_n'])}"
+    return (
+        f"w{spec['world']}-i{spec['initialization']}-{spec['architecture']}"
+        f"-d{spec['width']}-{load}-{spec['schedule']}-s{spec['steps']}"
+    )
+
+
+def train(spec, out, source, device="cuda:0"):
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    if (out / "latest.pt").exists() or (out / "complete.json").exists():
+        raise FileExistsError(f"Do not overwrite an existing training attempt: {out}")
+    torch.set_num_threads(1)
+    torch.set_num_interop_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    device = torch.device(device)
+    torch.cuda.set_device(device)
+    world = build_world(spec)
+    np.savez_compressed(out / "world.npz", **world)
+    digest = data_digest(world)
+    write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest})
+    model = construct(spec, device)
+    initial_sha = file_hash(out / "spec.json")
+    lr = torch.tensor(spec["lr"], device=device)
+    optimizer = make_optimizer(model, lr, spec["weight_decay"])
+    strata = strata_for(spec, world)
+    table = tuple(
+        torch.as_tensor(np.concatenate(parts), device=device)
+        for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True)
+    )
+    sizes = [len(rows) for rows in strata]
+    offsets = np.cumsum([0, *sizes[:-1]])
+    streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)]
+    counts = [np.zeros(size, dtype=np.int64) for size in sizes]
+    batch = spec["batch_size"]
+    if batch % 3:
+        raise ValueError("Batch must divide into three equal streams")
+    graph = FullTokenStep(model, optimizer, table, batch)
+    layers, repeats = ARCHITECTURES[spec["architecture"]]
+    flop_step = flops(model.config, repeats, batch, 9, output_positions=9)
+    history, training_seconds, start = [], 0.0, 0
+
+    def measure(step, loss=None):
+        metrics, predictions = evaluate(model, world, spec["load"], device)
+        row = {
+            "step": step,
+            "lr": learning_rate(spec, step) if step else 0,
+            "metrics": metrics,
+            "loss": loss,
+            "training_seconds": training_seconds,
+            "estimated_training_flops": step * flop_step,
+        }
+        history.append(row)
+        write_json(out / "learning.json", history)
+        np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions)
+        state = {
+            "spec": spec,
+            "step": step,
+            "model": model.state_dict(),
+            "optimizer": optimizer.state_dict(),
+            "streams": [stream.state_dict() for stream in streams],
+            "counts": counts,
+            "cpu_rng": torch.get_rng_state(),
+            "cuda_rng": torch.cuda.get_rng_state(device),
+            "source": source,
+            "data_sha256": digest,
+        }
+        torch.save(state, out / "latest.tmp.pt")
+        (out / "latest.tmp.pt").replace(out / "latest.pt")
+        write_json(out / "status.json", {"step": step, "budget": spec["steps"]})
+        print(json.dumps({"run": run_name(spec), "step": step, "metrics": metrics}), flush=True)
+        return row
+
+    measure(0)
+    for end in spec["nodes"]:
+        if not end:
+            continue
+        torch.cuda.synchronize()
+        started = time.perf_counter()
+        while start < end:
+            n = min(128, end - start)
+            indices = []
+            for i, stream in enumerate(streams):
+                drawn = stream.take(n * batch // 3).reshape(n, batch // 3)
+                counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i])
+                indices.append(drawn + offsets[i])
+            indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device)
+            for j in range(n):
+                lr.fill_(learning_rate(spec, start + j + 1))
+                last_loss = graph(indices[j])
+            start += n
+        torch.cuda.synchronize()
+        training_seconds += time.perf_counter() - started
+        loss = float(last_loss)
+        if not np.isfinite(loss):
+            raise FloatingPointError(f"Nonfinite training loss at {end}")
+        endpoint = measure(end, loss)
+    assert start == spec["steps"]
+    repeat_metrics = {}
+    if isinstance(model, LoopGPT):
+        for repeat in spec["test_repeats"]:
+            metrics, predictions = evaluate(model, world, spec["load"], device, repeat)
+            repeat_metrics[str(repeat)] = metrics
+            np.savez_compressed(out / f"repeat-{repeat:02d}.npz", **predictions)
+    np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)})
+    result = {
+        "spec": spec,
+        "finished_utc": utc(),
+        "parameters": sum(p.numel() for p in model.parameters()),
+        "unique_blocks": layers,
+        "executed_blocks": layers * repeats,
+        "independent_facts": len(strata[0]) + len(strata[2]),
+        "training_seconds": training_seconds,
+        "endpoint": endpoint,
+        "repeat_metrics": repeat_metrics,
+        "source": source,
+        "data_sha256": digest,
+        "spec_sha256": initial_sha,
+        "checkpoint_sha256": file_hash(out / "latest.pt"),
+        "supervised_tokens": start * batch * 23 // 3,
+        "padded_input_tokens": start * batch * 9,
+        "environment": {
+            "torch": torch.__version__,
+            "numpy": np.__version__,
+            "cuda": torch.version.cuda,
+            "gpu": torch.cuda.get_device_name(device),
+            "tf32": True,
+        },
+    }
+    write_json(out / "complete.json", result)
+    return result
+
+
+def audit(out, device="cuda:0"):
+    """Independent-process reload: tokens exact, floating NLL tolerance recorded."""
+    out = Path(out)
+    torch.set_num_threads(1)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_device(torch.device(device))
+    complete = json.loads((out / "complete.json").read_text())
+    saved = torch.load(out / "latest.pt", map_location=device, weights_only=False)
+    assert saved["step"] == complete["spec"]["steps"]
+    assert file_hash(out / "latest.pt") == complete["checkpoint_sha256"]
+    world = build_world(saved["spec"])
+    assert data_digest(world) == saved["data_sha256"] == complete["data_sha256"]
+    model = construct(saved["spec"], device)
+    model.load_state_dict(saved["model"])
+    metrics, predictions = evaluate(model, world, saved["spec"]["load"], device)
+    expected = np.load(out / f"predictions-{saved['step']:06d}.npz")
+    max_nll_difference = 0.0
+    for key, value in predictions.items():
+        if key.endswith("answer_nll"):
+            max_nll_difference = max(max_nll_difference, float(np.abs(value - expected[key]).max()))
+            np.testing.assert_allclose(value, expected[key], rtol=1e-5, atol=1e-5)
+        else:
+            np.testing.assert_array_equal(value, expected[key])
+    for task, values in metrics.items():
+        for key, value in values.items():
+            reference = complete["endpoint"]["metrics"][task][key]
+            if key == "answer_nll":
+                np.testing.assert_allclose(value, reference, rtol=1e-5, atol=1e-5)
+            else:
+                assert value == reference
+    exposures = np.load(out / "exposures.npz")
+    for i in range(3):
+        np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i])
+        assert exposures[f"stratum{i}"].sum() == saved["step"] * saved["spec"]["batch_size"] // 3
+        assert np.ptp(exposures[f"stratum{i}"]) <= 1
+    result = {
+        "passed": True,
+        "step": saved["step"],
+        "prediction_arrays": len(predictions),
+        "max_nll_difference": max_nll_difference,
+        "nll_rtol": 1e-5,
+        "nll_atol": 1e-5,
+        "tokens_exact": True,
+        "utc": utc(),
+    }
+    write_json(out / "audit.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_loss_source.py

@@ -0,0 +1,256 @@
+"""Factorial loss-source interventions on an unchanged text-pretraining stream."""
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from .grok_depth import EpochStream, GraphStep, make_optimizer, write_json
+from .grok_loop_model import flops
+from .text_pretrain import construct, evaluate, sha
+
+ARMS = {"AB": (1, 1), "A": (1, 0), "B": (0, 1), "N": (0, 0)}
+SPLITS = ("atomic", "background_train", "background_test", "target_train", "target_test")
+
+
+def loss_sources(labels, bounds):
+    """0=atomic text, 1=background composition, 2=neutral text, -1=ignored."""
+    result = np.full(labels.shape, -1, dtype=np.int64)
+    result[: bounds[1]] = 0
+    result[bounds[1] : bounds[2]] = 1
+    result[bounds[2] :, :15] = 0
+    result[bounds[2] :, 16:] = 2
+    result[labels == -100] = -1
+    assert np.array_equal(result >= 0, labels != -100)
+    return result
+
+
+def weights_for(source, arm):
+    a, b = ARMS[arm]
+    return ((source == 0) * a + (source == 1) * b + (source == 2)).astype(np.float32)
+
+
+def weighted_loss(logits, labels, weights):
+    per_token = F.cross_entropy(
+        logits.flatten(0, 1), labels.flatten(), reduction="none", ignore_index=-100
+    ).view_as(labels)
+    # Removing a source does NOT renormalize the remaining losses.
+    return (per_token * weights).sum() / (labels != -100).sum()
+
+
+class SourceGraphStep(GraphStep):
+    def eager(self):
+        self.optimizer.zero_grad(set_to_none=False)
+        x, positions, mask, labels, weights = (t[self.index] for t in self.table)
+        logits = self.model(x, position_ids=positions, attention_mask=mask)
+        loss = weighted_loss(logits, labels, weights)
+        loss.backward()
+        norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True)
+        self.optimizer.step()
+        return loss, norm
+
+
+@torch.inference_mode()
+def measure(model, world, table, source, device):
+    scores, predictions = {}, {}
+    for split in SPLITS:
+        scores[split], pred = evaluate(model, world[split], device, composite=split != "atomic")
+        predictions.update({split + "_" + k: v for k, v in pred.items()})
+    atomic = predictions["atomic_answer"] == world["atomic"][:, -1]
+    known = {(h, r): ok for (h, r, _), ok in zip(world["atomic"], atomic, strict=True)}
+    eligible = np.array([known[h, r1] and known[b, r2] for h, r1, b, r2, t in world["target_test"]])
+    full = (predictions["target_test_answer"] == world["target_test"][:, -1]) & (
+        predictions["target_test_stops"] == [5, 1]
+    ).all(-1)
+    scores["both_atomics"] = dict(
+        n=int(eligible.sum()),
+        coverage=float(eligible.mean()),
+        accuracy=float(full[eligible].mean()) if eligible.any() else None,
+    )
+    sums, counts = np.zeros(3), np.zeros(3, dtype=np.int64)
+    for start in range(0, len(table[0]), 128):
+        x, pos, mask, labels = [
+            torch.as_tensor(t[start : start + 128], device=device) for t in table[:4]
+        ]
+        logits = model(x, position_ids=pos, attention_mask=mask)
+        nll = (
+            F.cross_entropy(
+                logits.flatten(0, 1), labels.flatten(), reduction="none", ignore_index=-100
+            )
+            .view_as(labels)
+            .cpu()
+            .numpy()
+        )
+        for group in range(3):
+            selected = source[start : start + 128] == group
+            sums[group] += nll[selected].sum(dtype=np.float64)
+            counts[group] += selected.sum()
+    scores["training_text_nll"] = {
+        name: float(sums[i] / counts[i])
+        for i, name in enumerate(("atomic", "background", "neutral"))
+    }
+    return scores, predictions
+
+
+def run(cfg, name, device):
+    overrides = cfg["runs"][name]
+    root = Path(cfg["output_root"]) / name
+    if (root / "complete.json").exists():
+        return
+    lock = json.loads(Path(cfg["lock"]).read_text())
+    for p, digest in lock["sources"].items():
+        assert sha(p) == digest, p
+    assert sha(cfg["config_path"]) == lock["config_sha256"]
+    assert sha(cfg["plan"]) == lock["plan_sha256"]
+    for p, expected in lock["inputs"].items():
+        assert sha(p) == expected, p
+    parent = Path(overrides["parent"])
+    assert sha(parent / "latest.pt") == lock["parents"][str(parent / "latest.pt")]
+    root.mkdir(parents=True, exist_ok=True)
+    state = torch.load(parent / "latest.pt", map_location=device, weights_only=False)
+    spec = state["spec"]
+    assert spec["arm"] == "P1" and state["step"] == 32000
+    world = dict(np.load(parent / "world.npz"))
+    stored = np.load(parent / "training-table.npz")
+    table = tuple(stored[k] for k in ("tokens", "positions", "mask", "labels"))
+    bounds = np.cumsum(
+        [0, len(world["atomic"]), len(world["background_train"]), len(world["target_train"])]
+    )
+    source = loss_sources(table[3], bounds)
+    weights = weights_for(source, overrides["arm"])
+    gpu_table = tuple(torch.as_tensor(t, device=device) for t in (*table, weights))
+    model = construct(spec, device)
+    model.load_state_dict(state["model"])
+    opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"])
+    opt.load_state_dict(state["optimizer"])
+    streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(3)]
+    for stream, saved in zip(streams, state["streams"], strict=True):
+        stream.load_state_dict(saved)
+    torch.set_rng_state(state["cpu_rng"].cpu())
+    torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device)
+    settings = dict(
+        parent=str(parent),
+        world=spec["world"],
+        initialization=spec["initialization"],
+        arm=overrides["arm"],
+        steps=cfg["steps"],
+        parent_sha256=sha(parent / "latest.pt"),
+        config=cfg["config_path"],
+    )
+    write_json(root / "settings.json", settings)
+    start, elapsed, histories = 0, 0.0, []
+    digest = hashlib.sha256()
+    # Recovery is deliberately from this branch's saved stream, never its parent's.
+    if (root / "latest.pt").exists():
+        saved = torch.load(root / "latest.pt", map_location=device, weights_only=False)
+        assert saved["settings"] == settings
+        model.load_state_dict(saved["model"])
+        opt.load_state_dict(saved["optimizer"])
+        for stream, value in zip(streams, saved["streams"], strict=True):
+            stream.load_state_dict(value)
+        torch.set_rng_state(saved["cpu_rng"].cpu())
+        torch.cuda.set_rng_state(saved["cuda_rng"].cpu(), device)
+        start, elapsed, histories = saved["step"], saved["seconds"], saved["histories"]
+        # Rebuild the hash of previously consumed paired indices from the parent state.
+        replay = [EpochStream(bounds[i + 1] - bounds[i], 0) for i in range(3)]
+        for stream, value in zip(replay, state["streams"], strict=True):
+            stream.load_state_dict(value)
+        for _ in range(start):
+            idx = np.concatenate(
+                [
+                    stream.take(n) + lo
+                    for stream, n, lo in zip(replay, spec["batch_parts"], bounds[:-1], strict=True)
+                ]
+            )
+            digest.update(idx.tobytes())
+    initial_vector = torch.nn.utils.parameters_to_vector(
+        [v for v in state["model"].values()]
+    ).clone()
+
+    def checkpoint(step):
+        metrics, predictions = measure(model, world, table, source, device)
+        record = dict(
+            step=step,
+            seconds=elapsed,
+            metrics=metrics,
+            parameter_l2_from_source=float(
+                torch.linalg.vector_norm(
+                    torch.nn.utils.parameters_to_vector(model.parameters()).detach()
+                    - initial_vector
+                )
+            ),
+            last_loss=None if step == 0 else float(graph.loss),
+            last_gradient_norm=None if step == 0 else float(graph.grad_norm),
+        )
+        histories.append(record)
+        np.savez_compressed(root / f"predictions-{step:06d}.npz", **predictions)
+        write_json(root / "learning.json", histories)
+        model.train()
+        current = dict(
+            model=model.state_dict(),
+            optimizer=opt.state_dict(),
+            streams=[s.state_dict() for s in streams],
+            cpu_rng=torch.get_rng_state(),
+            cuda_rng=torch.cuda.get_rng_state(device),
+            step=step,
+            seconds=elapsed,
+            histories=histories,
+            settings=settings,
+        )
+        tmp = root / "latest.tmp"
+        torch.save(current, tmp)
+        tmp.replace(root / "latest.pt")
+        if step == 0 or step == cfg["steps"]:
+            torch.save(
+                dict(model=current["model"], step=step, settings=settings),
+                root / f"weights-{step:06d}.pt",
+            )
+        print(
+            json.dumps(
+                dict(
+                    run=name,
+                    step=step,
+                    target=metrics["target_test"]["accuracy"],
+                    atomic=metrics["atomic"]["accuracy"],
+                    background=metrics["background_test"]["accuracy"],
+                )
+            ),
+            flush=True,
+        )
+
+    if start == 0:
+        checkpoint(0)
+    graph = SourceGraphStep(model, opt, gpu_table, sum(spec["batch_parts"]))
+    tick = time.monotonic()
+    for step in range(start + 1, cfg["steps"] + 1):
+        idx = np.concatenate(
+            [
+                stream.take(n) + lo
+                for stream, n, lo in zip(streams, spec["batch_parts"], bounds[:-1], strict=True)
+            ]
+        )
+        digest.update(idx.tobytes())
+        graph(torch.as_tensor(idx, device=device))
+        if step in cfg["nodes"]:
+            torch.cuda.synchronize()
+            elapsed += time.monotonic() - tick
+            checkpoint(step)
+            tick = time.monotonic()
+    a, b = ARMS[overrides["arm"]]
+    write_json(
+        root / "complete.json",
+        dict(
+            settings=settings,
+            final=histories[-1],
+            sample_trace_sha256=digest.hexdigest(),
+            visible_supervised_tokens=cfg["steps"] * 1984,
+            active_supervised_tokens=cfg["steps"] * (1120 * a + 288 * b + 576),
+            estimated_flops=cfg["steps"]
+            * flops(model.config, spec["repeats"], 128, 25, output_positions=25),
+            checkpoint_sha256=sha(root / "latest.pt"),
+        ),
+    )

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_pretrain.py

@@ -0,0 +1,401 @@
+"""Paired full-token text pretraining with controlled cross-document access.
+
+P0/P1 have identical token arrays and labels; only document attention changes.
+P2 replaces an isolated neutral record by a derived fact, an explicit change in
+supervision. This is controlled template-language pretraining, not a pretrained
+natural-language model or a replication of the original bioS scale.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from .bios_model import ModelConfig
+from .grok_depth import EpochStream, GraphStep, make_optimizer, write_json
+from .grok_loop_model import LoopGPT, flops
+
+WORDS = [
+    "<pad>",
+    "<eos>",
+    "<bos>",
+    "'s",
+    "is",
+    ".",
+    "This",
+    "record",
+    "has",
+    "no",
+    "additional",
+    "fact",
+    "here",
+    "mentor",
+    "advisor",
+    "coach",
+    "supervisor",
+    "city",
+    "district",
+    "region",
+    "campus",
+]
+LENGTH = 26
+PAD, EOS, BOS = 0, 1, 2
+
+
+def sha(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def vocabulary(spec):
+    return (
+        WORDS
+        + [f"Person{i:03d}" for i in range(spec["heads_n"])]
+        + [f"Expert{i:03d}" for i in range(spec["bridges_n"])]
+        + [f"Place{i:03d}" for i in range(spec["tails_n"])]
+    )
+
+
+def atomic_sentence(row):
+    h, r, t = map(int, row)
+    return [BOS, h, 3, r, 4, t, 5, EOS]
+
+
+def composite_sentence(row):
+    h, r1, _b, r2, t = map(int, row)
+    return [BOS, h, 3, r1, 3, r2, 4, t, 5, EOS]
+
+
+def pack_documents(documents, groups):
+    """Reset positions per record in every arm; BOS is an exogenous boundary.
+
+    All remaining next-token targets, including names, relations and EOS, are
+    supervised. The next record's BOS and padding are never prediction targets.
+    """
+    seq, positions, segments = [], [], []
+    for doc, group in zip(documents, groups, strict=True):
+        seq.extend(doc)
+        positions.extend(range(len(doc)))
+        segments.extend([group] * len(doc))
+    if len(seq) > LENGTH:
+        raise ValueError("Record exceeds fixed context")
+    n = len(seq)
+    seq += [PAD] * (LENGTH - n)
+    positions += [0] * (LENGTH - n)
+    segments += list(range(100, 100 + LENGTH - n))
+    labels = np.asarray(seq[1:], dtype=np.int64)
+    labels[(labels == BOS) | (labels == PAD)] = -100
+    seg = np.asarray(segments[:-1])
+    mask = (seg[:, None] == seg[None, :]) & np.tri(LENGTH - 1, dtype=bool)
+    return (
+        np.asarray(seq[:-1], dtype=np.int64),
+        np.asarray(positions[:-1], dtype=np.int64),
+        mask[None],
+        labels,
+    )
+
+
+def build_world(spec):
+    """One supplied world; complete head-tail pairs held out before rendering."""
+    rng = np.random.default_rng(spec["world"])
+    hn, bn, tn = spec["heads_n"], spec["bridges_n"], spec["tails_n"]
+    hs = np.arange(len(WORDS), len(WORDS) + hn)
+    bs = np.arange(hs[-1] + 1, hs[-1] + 1 + bn)
+    ts = np.arange(bs[-1] + 1, bs[-1] + 1 + tn)
+    first = np.array([(h, r, rng.choice(bs)) for h in hs for r in range(13, 17)])
+    second = np.array([(b, r, rng.choice(ts)) for b in bs for r in range(17, 21)])
+    lookup = {(int(h), int(r)): int(t) for h, r, t in second}
+    paths = np.array(
+        [(h, r1, b, r2, lookup[int(b), r2]) for h, r1, b in first for r2 in range(17, 21)],
+        dtype=np.int64,
+    )
+    reserved = rng.random((hn, tn)) < spec["holdout_fraction"]
+    held = reserved[paths[:, 0] - hs[0], paths[:, 4] - ts[0]]
+    background = paths[:, 0] < hs[0] + hn // 2
+    groups = {
+        "atomic_first": first,
+        "atomic_second": second,
+        "background_train": paths[background & ~held],
+        "background_test": paths[background & held],
+        "target_train": paths[~background & ~held],
+        "target_test": paths[~background & held],
+    }
+    for key, rows in groups.items():
+        if not len(rows):
+            raise ValueError(f"Empty world stratum {key}; do not silently reroll")
+    train_pairs = {tuple(r[[0, 4]]) for r in paths[~held]}
+    test_pairs = {tuple(r[[0, 4]]) for r in paths[held]}
+    assert not train_pairs & test_pairs
+    # Typed atomics can never expose a head and a tail together.
+    assert not set(first[:, 0]) & set(second[:, 0])
+    assert not set(first[:, 2]) & set(second[:, 2])
+    groups["atomic"] = np.concatenate([first, second])
+    groups["all_paths"] = paths
+    return groups
+
+
+def training_table(world, arm):
+    if arm not in ("P0", "P1", "P2"):
+        raise ValueError(arm)
+    packed = [pack_documents([atomic_sentence(r)], [0]) for r in world["atomic"]]
+    base_end = len(packed)
+    packed.extend(pack_documents([composite_sentence(r)], [0]) for r in world["background_train"])
+    background_end = len(packed)
+    neutral = [BOS, 6, 7, 8, 9, 10, 11, 12, 5, EOS]
+    for row in world["target_train"]:
+        h, r1, b, r2, t = row
+        third = composite_sentence(row) if arm == "P2" else neutral
+        packed.append(
+            pack_documents(
+                [atomic_sentence([h, r1, b]), atomic_sentence([b, r2, t]), third],
+                [0, 1, 2] if arm == "P0" else [0, 0, 2],
+            )
+        )
+    table = tuple(np.stack([row[i] for row in packed]) for i in range(4))
+    return table, [0, base_end, background_end, len(packed)]
+
+
+class TextGPT(LoopGPT):
+    def forward(self, tokens, position_ids=None, attention_mask=None, patch=None, cache=None):
+        if position_ids is None:
+            position_ids = torch.arange(tokens.shape[1], device=tokens.device)[None]
+        p = self.dropout if self.training else 0.0
+        x = F.dropout(self.token(tokens) + self.position(position_ids), p=p, training=self.training)
+        for layer, block in enumerate(self.iter_blocks()):
+            z = block.ln1(x)
+            batch, length, width = z.shape
+            a = block.attention
+            q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2)
+            y = F.scaled_dot_product_attention(
+                q.transpose(1, 2),
+                k.transpose(1, 2),
+                v.transpose(1, 2),
+                attn_mask=attention_mask,
+                is_causal=attention_mask is None,
+                dropout_p=p,
+            )
+            attn = F.dropout(
+                a.proj(y.transpose(1, 2).reshape(batch, length, width)), p=p, training=self.training
+            )
+            mlp = F.dropout(block.mlp(block.ln2(x + attn)), p=p, training=self.training)
+            if cache is not None:
+                cache[layer] = {
+                    "attention": attn.detach(),
+                    "mlp": mlp.detach(),
+                    "full": (x + attn + mlp).detach(),
+                }
+            if patch is not None and layer == patch["layer"]:
+                pos, value, component = patch["position"], patch["value"], patch["component"]
+                if component == "full":
+                    x = x + attn + mlp
+                    x = x.clone()
+                    x[:, pos] = value
+                    continue
+                if component == "attention":
+                    attn = attn.clone()
+                    attn[:, pos] = value
+                elif component == "mlp":
+                    mlp = mlp.clone()
+                    mlp[:, pos] = value
+                else:
+                    raise ValueError(component)
+            x = x + attn + mlp
+        return F.linear(self.ln_final(x), self.token.weight)
+
+
+class TextGraphStep(GraphStep):
+    def eager(self):
+        self.optimizer.zero_grad(set_to_none=False)
+        x, positions, mask, labels = (t[self.index] for t in self.table)
+        logits = self.model(x, position_ids=positions, attention_mask=mask)
+        loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100)
+        loss.backward()
+        norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True)
+        self.optimizer.step()
+        return loss, norm
+
+
+def construct(spec, device):
+    torch.manual_seed(spec["initialization"])
+    cfg = ModelConfig(
+        vocab_size=len(vocabulary(spec)),
+        width=spec["width"],
+        layers=spec["layers"],
+        heads=spec["heads"],
+        context=LENGTH,
+    )
+    return TextGPT(cfg, repeats=spec["repeats"], dropout=spec["dropout"]).to(device)
+
+
+@torch.inference_mode()
+def evaluate(model, rows, device, composite=False, patch=None, batch_size=256):
+    model.eval()
+    encode = composite_sentence if composite else atomic_sentence
+    prompts = np.asarray([encode(r)[:-3] for r in rows], dtype=np.int64)
+    answers, stops, probs = [], [], []
+    for start in range(0, len(rows), batch_size):
+        x = torch.as_tensor(prompts[start : start + batch_size], device=device)
+        intervention = (
+            None if patch is None else dict(patch, value=patch["value"][start : start + batch_size])
+        )
+        logits = model(x, patch=intervention)[:, -1]
+        target = torch.as_tensor(rows[start : start + batch_size, -1], device=device)
+        probs.extend(logits.softmax(-1).gather(1, target[:, None]).squeeze(1).tolist())
+        prediction = logits.argmax(-1)
+        answers.extend(prediction.tolist())
+        x = torch.cat([x, prediction[:, None]], dim=1)
+        period = model(x, patch=intervention)[:, -1].argmax(-1)
+        x = torch.cat([x, period[:, None]], dim=1)
+        eos = model(x, patch=intervention)[:, -1].argmax(-1)
+        stops.extend(torch.stack([period, eos], dim=1).tolist())
+    ans, stop, probability = np.asarray(answers), np.asarray(stops), np.asarray(probs)
+    correct = ans == rows[:, -1]
+    full = correct & (stop[:, 0] == 5) & (stop[:, 1] == EOS)
+    return dict(
+        n=len(rows),
+        answer_accuracy=float(correct.mean()),
+        accuracy=float(full.mean()),
+        answer_probability=float(probability.mean()),
+    ), dict(answer=ans, stops=stop, probability=probability, target=rows[:, -1])
+
+
+def run(spec, output, device):
+    output = Path(output)
+    if (output / "complete.json").exists():
+        return json.loads((output / "complete.json").read_text())
+    output.mkdir(parents=True, exist_ok=True)
+    lock = json.loads(Path(spec["source_lock"]).read_text())
+    for file, expected in lock["sources"].items():
+        assert sha(file) == expected, file
+    assert lock["config_sha256"] == sha(spec["config_path"])
+    torch.set_num_threads(2)
+    torch.cuda.set_device(device)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_per_process_memory_fraction(0.08, device)
+    world = build_world(spec)
+    cpu_table, bounds = training_table(world, spec["arm"])
+    np.savez_compressed(output / "world.npz", **world)
+    np.savez_compressed(
+        output / "training-table.npz",
+        **{k: v for k, v in zip(("tokens", "positions", "mask", "labels"), cpu_table, strict=True)},
+    )
+    write_json(output / "spec.json", spec)
+    write_json(output / "vocabulary.json", vocabulary(spec))
+    model = construct(spec, device)
+    opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"])
+    table = tuple(torch.as_tensor(t, device=device) for t in cpu_table)
+    streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(3)]
+    latest = output / "latest.pt"
+    start, elapsed, histories = 0, 0.0, []
+    if latest.exists():
+        state = torch.load(latest, map_location=device, weights_only=False)
+        model.load_state_dict(state["model"])
+        opt.load_state_dict(state["optimizer"])
+        for stream, saved in zip(streams, state["streams"], strict=True):
+            stream.load_state_dict(saved)
+        start, elapsed, histories = state["step"], state["seconds"], state["histories"]
+        torch.set_rng_state(state["cpu_rng"].cpu())
+        torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device)
+    counts = spec["batch_parts"]
+    supervised_per_step = sum(n * tokens for n, tokens in zip(counts, [7, 9, 23], strict=True))
+    step_flops = flops(
+        model.config, spec["repeats"], sum(counts), LENGTH - 1, output_positions=LENGTH - 1
+    )
+
+    def checkpoint(step, seconds):
+        metrics, predictions = {}, {}
+        for split in (
+            "atomic",
+            "background_train",
+            "background_test",
+            "target_train",
+            "target_test",
+        ):
+            metrics[split], preds = evaluate(
+                model, world[split], device, composite=split != "atomic"
+            )
+            predictions.update({split + "_" + k: v for k, v in preds.items()})
+        atomic_ok = predictions["atomic_answer"] == world["atomic"][:, -1]
+        knowledge = {
+            (int(h), int(r)): bool(ok)
+            for (h, r, _t), ok in zip(world["atomic"], atomic_ok, strict=True)
+        }
+        eligible = np.array(
+            [
+                knowledge[int(h), int(r1)] and knowledge[int(b), int(r2)]
+                for h, r1, b, r2, _t in world["target_test"]
+            ]
+        )
+        target_ok = predictions["target_test_answer"] == world["target_test"][:, -1]
+        metrics["target_atomic_correct"] = dict(
+            n=int(eligible.sum()),
+            coverage=float(eligible.mean()),
+            answer_accuracy=float(target_ok[eligible].mean()) if eligible.any() else None,
+        )
+        record = dict(
+            step=step,
+            seconds=seconds,
+            supervised_tokens=step * supervised_per_step,
+            estimated_flops=step * step_flops,
+            metrics=metrics,
+        )
+        histories.append(record)
+        np.savez_compressed(output / f"predictions-{step:06d}.npz", **predictions)
+        write_json(output / "learning.json", histories)
+        model.train()
+        state = dict(
+            model=model.state_dict(),
+            optimizer=opt.state_dict(),
+            step=step,
+            seconds=seconds,
+            histories=histories,
+            spec=spec,
+            streams=[s.state_dict() for s in streams],
+            cpu_rng=torch.get_rng_state(),
+            cuda_rng=torch.cuda.get_rng_state(device),
+        )
+        tmp = output / "latest.tmp"
+        torch.save(state, tmp)
+        tmp.replace(latest)
+        if step in spec["weight_nodes"]:
+            torch.save(
+                dict(model=state["model"], step=step, spec=spec), output / f"weights-{step:06d}.pt"
+            )
+        print(json.dumps(dict(run=output.name, **record)), flush=True)
+
+    if start == 0:
+        checkpoint(0, elapsed)
+    model.train()
+    graph = TextGraphStep(model, opt, table, sum(counts))
+    tick = time.monotonic()
+    for step in range(start + 1, spec["steps"] + 1):
+        idx = np.concatenate(
+            [
+                stream.take(n) + offset
+                for stream, n, offset in zip(streams, counts, bounds[:-1], strict=True)
+            ]
+        )
+        for group in opt.param_groups:
+            group["lr"].fill_(spec["lr"] * min(1.0, step / spec["warmup"]))
+        graph(torch.as_tensor(idx, device=device))
+        if step in spec["nodes"]:
+            torch.cuda.synchronize()
+            elapsed += time.monotonic() - tick
+            checkpoint(step, elapsed)
+            tick = time.monotonic()
+    result = dict(
+        status="complete",
+        final=histories[-1],
+        parameters=sum(p.numel() for p in model.parameters()),
+        source_lock_sha256=sha(spec["source_lock"]),
+        world_sha256=sha(output / "world.npz"),
+        peak_memory_bytes=torch.cuda.max_memory_allocated(device),
+    )
+    write_json(output / "complete.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_structure.py

@@ -0,0 +1,432 @@
+"""Matched relation-pair support and transfer to atomically trained facts.
+
+Reuse the full-token text model; change composition support, not atomics,
+per-fact role counts, unique chain count, or token marginals. Target heads and
+bridges are disjoint from background; answer values are deliberately shared.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from .grok_depth import EpochStream, make_optimizer, utc, write_json
+from .grok_loop_model import flops
+from .text_pretrain import (
+    LENGTH,
+    WORDS,
+    TextGraphStep,
+    atomic_sentence,
+    composite_sentence,
+    construct,
+    evaluate,
+    pack_documents,
+    sha,
+    vocabulary,
+)
+
+ARMS = ("restricted", "broad", "positive")
+TESTS = ("id_test", "first_only", "second_only", "background_neither", "strict_test")
+SPLITS = ("atomic", "train_composite", "positive_train", *TESTS)
+
+
+def build_world(spec):
+    """Balanced graph; common head-tail holdout defined before any model exists.
+
+    Each background bridge receives four trained heads per first relation.
+    Two of its four second facts have composition experience. Restricted
+    support pairs r1[0:2] only with even r2 and r1[2:4] only with odd r2.
+    Broad support assigns half the incoming facts of EACH r1 to each active r2.
+    Thus the relation-pair support has two components versus one, while all
+    underlying first/second edge counts match exactly.
+    """
+    rng = np.random.default_rng(spec["world"])
+    hn, bn, tn = spec["heads_n"], spec["bridges_n"], spec["tails_n"]
+    if hn != 128 or bn != 32 or tn != 32:
+        raise ValueError("This version fixes 128 heads, 32 bridges, 32 shared answer values")
+    hs = np.arange(len(WORDS), len(WORDS) + hn)
+    bs = np.arange(hs[-1] + 1, hs[-1] + 1 + bn)
+    ts = np.arange(bs[-1] + 1, bs[-1] + 1 + tn)
+    first = []
+    for heads, bridges in ((hs[:64], bs[:16]), (hs[64:96], bs[:16]), (hs[96:], bs[16:])):
+        mappings = [rng.permutation(np.tile(bridges, len(heads) // len(bridges))) for _ in range(4)]
+        first.extend((h, 13 + ri, mappings[ri][i]) for i, h in enumerate(heads) for ri in range(4))
+    first = np.asarray(first, dtype=np.int64)
+    active, inactive = [], []
+    for bi, b in enumerate(bs[:16]):
+        chosen = (17, 18) if bi % 2 == 0 else (19, 20)
+        active.extend((b, r) for r in chosen)
+        inactive.extend((b, r) for r in range(17, 21) if r not in chosen)
+    second = []
+    for edges in (active, inactive, [(b, r) for b in bs[16:] for r in range(17, 21)]):
+        tails = rng.permutation(np.tile(ts, len(edges) // len(ts)))
+        second.extend((*edge, t) for edge, t in zip(edges, tails, strict=True))
+    second = np.asarray(sorted(second), dtype=np.int64)
+    lookup = {(int(h), int(r)): int(t) for h, r, t in second}
+    paths = np.asarray(
+        [(h, r1, b, r2, lookup[int(b), r2]) for h, r1, b in first for r2 in range(17, 21)],
+        dtype=np.int64,
+    )
+    trained_first = first[:256]
+    active_set = set(active)
+    broad_assignment = {}
+    for b in bs[:16]:
+        choices = sorted(r for bb, r in active if bb == b)
+        for r1 in range(13, 17):
+            incoming = rng.permutation(
+                trained_first[(trained_first[:, 2] == b) & (trained_first[:, 1] == r1), 0]
+            )
+            if len(incoming) != 4:
+                raise ValueError("Unbalanced graph")
+            for i, h in enumerate(incoming):
+                broad_assignment[int(h), r1] = choices[i // 2]
+    trains = {}
+    for arm in ARMS[:2]:
+        rows = []
+        for h, r1, b in trained_first:
+            choices = sorted(r for bb, r in active if bb == b)
+            r2 = (
+                choices[int(r1 >= 15)] if arm == "restricted" else broad_assignment[int(h), int(r1)]
+            )
+            rows.append((h, r1, b, r2, lookup[int(b), r2]))
+        trains[arm] = np.asarray(rows, dtype=np.int64)
+    # Two supervised paths per target person; keep the remaining head-tail
+    # pairs for an independent positive-control generalization evaluation.
+    positive = []
+    for h in hs[96:]:
+        candidates = paths[paths[:, 0] == h]
+        positive.extend(candidates[rng.choice(len(candidates), 2, replace=False)])
+    positive = np.asarray(positive, dtype=np.int64)
+    train_union = np.concatenate([trains["restricted"], trains["broad"], positive])
+    pairs = {tuple(row[[0, 4]]) for row in train_union}
+    held = np.asarray([tuple(row[[0, 4]]) not in pairs for row in paths])
+    first_seen = paths[:, 0] < hs[64]
+    second_seen = np.asarray([(int(b), int(r2)) in active_set for b, r2 in paths[:, [2, 3]]])
+    strict = paths[:, 0] >= hs[96]
+    world = dict(
+        atomic=np.concatenate([first, second]),
+        atomic_first=first,
+        atomic_second=second,
+        restricted_train=trains["restricted"],
+        broad_train=trains["broad"],
+        positive_train=positive,
+        id_test=paths[held & first_seen & second_seen],
+        first_only=paths[held & first_seen & ~second_seen],
+        second_only=paths[held & ~first_seen & second_seen],
+        background_neither=paths[held & ~first_seen & ~second_seen & ~strict],
+        strict_test=paths[held & strict],
+        strict_all=paths[strict],
+        all_paths=paths,
+        background_heads=hs[:96],
+        background_bridges=bs[:16],
+        target_heads=hs[96:],
+        target_bridges=bs[16:],
+        active_second=np.asarray(active, dtype=np.int64),
+    )
+    if any(not len(world[key]) for key in TESTS):
+        raise ValueError("Empty evaluation stratum; do not reroll worlds")
+    return world
+
+
+def role_counts(rows):
+    return (
+        Counter(map(tuple, rows[:, :3])),
+        Counter(map(tuple, rows[:, 2:])),
+    )
+
+
+def support_components(rows):
+    adjacency = {}
+    for _h, r1, _b, r2, _t in rows:
+        a, b = (0, int(r1)), (1, int(r2))
+        adjacency.setdefault(a, set()).add(b)
+        adjacency.setdefault(b, set()).add(a)
+    remaining, components = set(adjacency), []
+    while remaining:
+        stack, found = [min(remaining)], set()
+        while stack:
+            node = stack.pop()
+            if node not in found:
+                found.add(node)
+                stack.extend(adjacency[node] - found)
+        remaining -= found
+        components.append(sorted(found))
+    return components
+
+
+def data_audit(world):
+    a, b = world["restricted_train"], world["broad_train"]
+    assert len(a) == len(b) == 256
+    assert len(set(map(tuple, a))) == len(set(map(tuple, b))) == 256
+    assert role_counts(a) == role_counts(b)
+    assert Counter(t for row in a for t in composite_sentence(row)) == Counter(
+        t for row in b for t in composite_sentence(row)
+    )
+    assert len(support_components(a)) == 2 and len(support_components(b)) == 1
+    lookup = {(int(h), int(r)): int(t) for h, r, t in world["atomic"]}
+    for h, r1, bridge, r2, t in world["all_paths"]:
+        assert lookup[int(h), int(r1)] == bridge and lookup[int(bridge), int(r2)] == t
+    train_pairs = {tuple(r[[0, 4]]) for rows in (a, b, world["positive_train"]) for r in rows}
+    assert all(not train_pairs & {tuple(r[[0, 4]]) for r in world[s]} for s in TESTS)
+    assert not set(world["target_heads"]) & set(
+        np.concatenate([a[:, 0], a[:, 2], b[:, 0], b[:, 2]])
+    )
+    assert not set(world["target_bridges"]) & set(world["background_bridges"])
+    assert set(world["strict_all"][:, 2]) <= set(world["target_bridges"])
+    first_counts, second_counts = role_counts(a)
+    return dict(
+        status="passed",
+        sizes={k: len(v) for k, v in world.items()},
+        unique_chains={arm: len(world[arm + "_train"]) for arm in ARMS[:2]},
+        relation_pair_counts={
+            arm: np.bincount(
+                (world[arm + "_train"][:, 1] - 13) * 4 + world[arm + "_train"][:, 3] - 17,
+                minlength=16,
+            )
+            .reshape(4, 4)
+            .tolist()
+            for arm in ARMS[:2]
+        },
+        role_counts_match=True,
+        token_marginals_match=True,
+        first_edge_usage=list(sorted(set(first_counts.values()))),
+        second_edge_usage=list(sorted(set(second_counts.values()))),
+        common_holdout_pairs=True,
+        isolated_target_heads_and_bridges=True,
+        shared_answer_values=True,
+    )
+
+
+def training_table(world, arm):
+    if arm not in ARMS:
+        raise ValueError(arm)
+    rows = world["restricted_train" if arm == "restricted" else "broad_train"]
+    if arm == "positive":
+        rows = np.concatenate([rows, world["positive_train"]])
+    packed = [pack_documents([atomic_sentence(r)], [0]) for r in world["atomic"]]
+    packed.extend(pack_documents([composite_sentence(r)], [0]) for r in rows)
+    return (
+        tuple(np.stack([row[i] for row in packed]) for i in range(4)),
+        [0, len(world["atomic"]), len(packed)],
+        rows,
+    )
+
+
+def score_predictions(predictions):
+    correct = predictions["answer"] == predictions["target"]
+    stops = predictions["stops"]
+    full = correct & (stops[:, 0] == 5) & (stops[:, 1] == 1)
+    return dict(
+        n=len(correct),
+        answer_accuracy=float(correct.mean()),
+        accuracy=float(full.mean()),
+        answer_probability=float(predictions["probability"].mean()),
+    )
+
+
+@torch.inference_mode()
+def two_calls(model, rows, device):
+    first = rows[:, :3]
+    first_scores, first_pred = evaluate(model, first, device)
+    second = np.c_[first_pred["answer"], rows[:, 3:]]
+    _scores, pred = evaluate(model, second, device)
+    first_stops = first_pred["stops"]
+    format_ok = (first_stops[:, 0] == 5) & (first_stops[:, 1] == 1)
+    second_full = (
+        (pred["answer"] == rows[:, -1]) & (pred["stops"][:, 0] == 5) & (pred["stops"][:, 1] == 1)
+    )
+    first_ok = first_pred["answer"] == rows[:, 2]
+    scores = score_predictions(pred)
+    scores.update(
+        accuracy=float((format_ok & second_full).mean()),
+        path_accuracy=float((format_ok & first_ok & second_full).mean()),
+        first_accuracy=first_scores["accuracy"],
+    )
+    pred.update(
+        first_answer=first_pred["answer"],
+        first_stops=first_stops,
+        first_target=rows[:, 2],
+        first_probability=first_pred["probability"],
+    )
+    return scores, pred
+
+
+def evaluate_all(model, world, train_rows, device):
+    metrics, predictions = {}, {}
+    groups = dict(world, train_composite=train_rows)
+    for split in SPLITS:
+        scores, pred = evaluate(model, groups[split], device, composite=split != "atomic")
+        metrics[split] = scores
+        predictions.update({split + "_" + k: v for k, v in pred.items()})
+    atomic_ok = predictions["atomic_answer"] == world["atomic"][:, -1]
+    knowledge = {
+        (int(h), int(r)): bool(ok)
+        for (h, r, _t), ok in zip(world["atomic"], atomic_ok, strict=True)
+    }
+    for split in TESTS:
+        rows = world[split]
+        eligible = np.asarray(
+            [knowledge[int(h), int(r1)] and knowledge[int(b), int(r2)] for h, r1, b, r2, _t in rows]
+        )
+        predictions[split + "_eligible"] = eligible
+        conditional = {
+            k: predictions[split + "_" + k][eligible]
+            for k in ("answer", "target", "stops", "probability")
+        }
+        metrics[split + "_conditional"] = dict(
+            n=int(eligible.sum()), coverage=float(eligible.mean())
+        )
+        if eligible.any():
+            metrics[split + "_conditional"].update(score_predictions(conditional))
+        else:
+            metrics[split + "_conditional"].update(
+                answer_accuracy=None, accuracy=None, answer_probability=None
+            )
+        scores, pred = two_calls(model, rows, device)
+        metrics[split + "_two_calls"] = scores
+        predictions.update({split + "_two_calls_" + k: v for k, v in pred.items()})
+    return metrics, predictions
+
+
+def verify_lock(config, source_lock):
+    lock = json.loads(Path(source_lock).read_text())
+    assert lock["config_sha256"] == sha(config), config
+    for file, expected in lock["sources"].items():
+        assert sha(file) == expected, file
+    return lock
+
+
+def run(spec, output, device):
+    output = Path(output)
+    verify_lock(spec["config_path"], spec["source_lock"])
+    if (output / "complete.json").exists():
+        return json.loads((output / "complete.json").read_text())
+    output.mkdir(parents=True, exist_ok=True)
+    torch.set_num_threads(2)
+    torch.cuda.set_device(device)
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.cuda.set_per_process_memory_fraction(0.06, device)
+    world = build_world(spec)
+    write_json(output / "data-audit.json", data_audit(world))
+    cpu_table, bounds, train_rows = training_table(world, spec["arm"])
+    np.savez_compressed(output / "world.npz", **world, train_composite=train_rows)
+    np.savez_compressed(
+        output / "training-table.npz",
+        **{k: v for k, v in zip(("tokens", "positions", "mask", "labels"), cpu_table, strict=True)},
+    )
+    write_json(output / "spec.json", spec)
+    write_json(output / "vocabulary.json", vocabulary(spec))
+    model = construct(spec, device)
+    initial_hash = {
+        key: hashlib.sha256(value.detach().cpu().numpy().tobytes()).hexdigest()
+        for key, value in model.state_dict().items()
+    }
+    write_json(output / "initialization-hashes.json", initial_hash)
+    opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"])
+    table = tuple(torch.as_tensor(t, device=device) for t in cpu_table)
+    streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(2)]
+    latest = output / "latest.pt"
+    start, elapsed, histories = 0, 0.0, []
+    if latest.exists():
+        state = torch.load(latest, map_location=device, weights_only=False)
+        assert state["spec"] == spec
+        model.load_state_dict(state["model"])
+        opt.load_state_dict(state["optimizer"])
+        for stream, saved in zip(streams, state["streams"], strict=True):
+            stream.load_state_dict(saved)
+        start, elapsed, histories = state["step"], state["seconds"], state["histories"]
+        torch.set_rng_state(state["cpu_rng"].cpu())
+        torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device)
+    counts = spec["batch_parts"]
+    supervised_per_step = sum(n * tokens for n, tokens in zip(counts, [7, 9], strict=True))
+    step_flops = flops(
+        model.config, spec["repeats"], sum(counts), LENGTH - 1, output_positions=LENGTH - 1
+    )
+    started = utc()
+
+    def checkpoint(step, seconds):
+        metrics, predictions = evaluate_all(model, world, train_rows, device)
+        record = dict(
+            step=step,
+            seconds=seconds,
+            supervised_tokens=step * supervised_per_step,
+            estimated_flops=step * step_flops,
+            metrics=metrics,
+        )
+        histories.append(record)
+        np.savez_compressed(output / f"predictions-{step:06d}.npz", **predictions)
+        write_json(output / "learning.json", histories)
+        model.train()
+        state = dict(
+            model=model.state_dict(),
+            optimizer=opt.state_dict(),
+            step=step,
+            seconds=seconds,
+            histories=histories,
+            spec=spec,
+            streams=[s.state_dict() for s in streams],
+            cpu_rng=torch.get_rng_state(),
+            cuda_rng=torch.cuda.get_rng_state(device),
+        )
+        tmp = output / "latest.tmp"
+        torch.save(state, tmp)
+        tmp.replace(latest)
+        if step in spec["weight_nodes"]:
+            torch.save(
+                dict(model=state["model"], step=step, spec=spec), output / f"weights-{step:06d}.pt"
+            )
+        print(
+            json.dumps(
+                dict(
+                    run=output.name,
+                    step=step,
+                    seconds=seconds,
+                    metrics={k: metrics[k] for k in ("atomic", "train_composite", *TESTS)},
+                )
+            ),
+            flush=True,
+        )
+
+    if start == 0:
+        checkpoint(0, elapsed)
+    model.train()
+    before = {k: v.detach().clone() for k, v in model.state_dict().items()}
+    graph = TextGraphStep(model, opt, table, sum(counts))
+    assert all(torch.equal(before[k], v) for k, v in model.state_dict().items())
+    tick = time.monotonic()
+    for step in range(start + 1, spec["steps"] + 1):
+        idx = np.concatenate(
+            [
+                stream.take(n) + offset
+                for stream, n, offset in zip(streams, counts, bounds[:-1], strict=True)
+            ]
+        )
+        for group in opt.param_groups:
+            group["lr"].fill_(spec["lr"] * min(1.0, step / spec["warmup"]))
+        graph(torch.as_tensor(idx, device=device))
+        if step in spec["nodes"]:
+            torch.cuda.synchronize()
+            elapsed += time.monotonic() - tick
+            checkpoint(step, elapsed)
+            tick = time.monotonic()
+    result = dict(
+        status="complete",
+        started_utc=started,
+        finished_utc=utc(),
+        final=histories[-1],
+        parameters=sum(p.numel() for p in model.parameters()),
+        source_lock_sha256=sha(spec["source_lock"]),
+        world_sha256=sha(output / "world.npz"),
+        peak_memory_bytes=torch.cuda.max_memory_allocated(device),
+        gpu=torch.cuda.get_device_name(device),
+        torch_version=torch.__version__,
+    )
+    write_json(output / "complete.json", result)
+    return result

docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/twohop_depth.py

@@ -0,0 +1,362 @@
+"""Depth, held-out composition, and bridge interventions in random fact worlds.
+
+Entity IDs and relation IDs are disjoint. A relation is a random permutation;
+this makes every atom and each split's answer marginal exactly balanced.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+from llm_memory_editability.bios_model import CausalLM, ModelConfig
+
+ROOT = Path(os.environ.get("TWOHOP_PROJECT_ROOT", Path(__file__).resolve().parents[2]))
+CONFIG = ROOT / "configs/twohop-depth-v1.json"
+DATA = ROOT / "data/twohop-depth-v1"
+RESULTS = ROOT / "results/twohop-depth-v1"
+ART = ROOT / "docs/development-artifacts/twohop-depth-v1"
+BOS, EOS, ENTITY = 1, 2, 3
+
+
+def read(path):
+    return json.loads(Path(path).read_text())
+
+
+def write(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix(path.suffix + ".tmp")
+    temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n")
+    temp.replace(path)
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with Path(path).open("rb") as f:
+        for block in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def world_arrays(seed, cfg):
+    n, r = cfg["entities"], cfg["relations"]
+    if r % 2 or r < 2:
+        raise ValueError("An even relation count is required for balanced coverage")
+    rng = np.random.default_rng(seed)
+    maps = np.stack([rng.permutation(n) for _ in range(r)])
+    # For each bridge, a regular bipartite graph over first/second relations.
+    # Each atom occurs in r/2 training compositions in EACH hop role.
+    orders = np.stack([rng.permutation(r) for _ in range(n)])
+    mask = np.zeros((n, r, r), dtype=bool)
+    for a in range(n):
+        for r1 in range(r):
+            b = maps[r1, a]
+            mask[a, r1, orders[b, (r1 + np.arange(r // 2)) % r]] = True
+    atoms = np.array([(a, rel) for a in range(n) for rel in range(r)], dtype=np.int64)
+    comps = np.array(
+        [(a, r1, r2) for a in range(n) for r1 in range(r) for r2 in range(r)],
+        dtype=np.int64,
+    )
+    a, r1, r2 = comps.T
+    bridge = maps[r1, a]
+    answer = maps[r2, bridge]
+    selected = rng.choice(np.flatnonzero(~mask.ravel()), cfg["diagnostic_cases"], replace=False)
+    cases = []
+    inverse = np.argsort(maps, axis=1)
+    for index in selected:
+        a0, r10, r20 = comps[index]
+        b0, c0 = bridge[index], answer[index]
+        # Donor contains only a first-hop prefix; neither its explicit entity nor
+        # its first-hop answer is the counterfactual final answer.
+        candidates = []
+        for b1 in range(n):
+            a1, c1 = inverse[r10, b1], maps[r20, b1]
+            if b1 != b0 and c1 not in {a1, b1, a0, b0, c0}:
+                candidates.append((int(a1), int(b1), int(c1)))
+        if not candidates:
+            raise ValueError("No answer-free bridge donor; increase world size")
+        a1, b1, c1 = candidates[int(rng.integers(len(candidates)))]
+        same_r = (r10 + 1) % r
+        same_a = inverse[same_r, b0]
+        wrong_candidates = [
+            (rr, int(maps[rr, b1])) for rr in range(r) if rr != r20 and maps[rr, b1] not in {c0, c1}
+        ]
+        if not wrong_candidates:
+            raise ValueError("No distinct wrong-relation answer")
+        wrong_r, wrong_y = wrong_candidates[int(rng.integers(len(wrong_candidates)))]
+        cases.append([index, a0, r10, r20, b0, c0, a1, b1, c1, same_a, same_r, wrong_r, wrong_y])
+    ax = np.c_[np.full(len(atoms), BOS), ENTITY + atoms[:, 0], ENTITY + n + atoms[:, 1]]
+    cx = np.c_[np.full(len(comps), BOS), ENTITY + a, ENTITY + n + r1, ENTITY + n + r2]
+    return {
+        "maps": maps,
+        "atoms": atoms,
+        "comps": comps,
+        "train_mask": mask.ravel(),
+        "atomic_x": ax,
+        "atomic_y": ENTITY + maps[atoms[:, 1], atoms[:, 0]],
+        "composite_x": cx,
+        "composite_y": ENTITY + answer,
+        "bridge": ENTITY + bridge,
+        "cases": np.asarray(cases, dtype=np.int64),
+    }
+
+
+def audit_world(w, cfg):
+    n, r = cfg["entities"], cfg["relations"]
+    maps, comps = w["maps"], w["comps"]
+    assert all(np.array_equal(np.sort(row), np.arange(n)) for row in maps)
+    assert len(set(map(tuple, w["atomic_x"]))) == n * r
+    assert len(set(map(tuple, w["composite_x"]))) == n * r * r
+    for mask in (w["train_mask"], ~w["train_mask"]):
+        a, r1, r2 = comps[mask].T
+        b = maps[r1, a]
+        assert np.all(np.bincount(a * r + r1, minlength=n * r) == r // 2)
+        assert np.all(np.bincount(b * r + r2, minlength=n * r) == r // 2)
+        assert np.all(np.bincount(w["composite_y"][mask] - ENTITY, minlength=n) == r * r // 2)
+    assert np.all(~w["train_mask"][w["cases"][:, 0]])
+    for _, a, r1, r2, b, c, da, db, dc, sa, sr, wr, wy in w["cases"]:
+        assert maps[r1, a] == b and maps[r2, b] == c
+        assert maps[r1, da] == db and maps[r2, db] == dc
+        assert maps[sr, sa] == b and sr != r1
+        assert dc not in {da, db, a, b, c}
+        assert maps[wr, db] == wy and wr != r2 and wy not in {c, dc}
+    return {
+        "atoms": n * r,
+        "train_compositions": int(w["train_mask"].sum()),
+        "test_compositions": int((~w["train_mask"]).sum()),
+        "diagnostic_cases": len(w["cases"]),
+        "every_atom_train_composition_occurrences_per_hop": r // 2,
+        "balanced_answers": True,
+        "answer_free_donors": True,
+    }
+
+
+def stream_indices(length, count, rng):
+    return np.concatenate([rng.permutation(length) for _ in range((count + length - 1) // length)])[
+        :count
+    ]
+
+
+def make_stream(w, seed, cfg):
+    rng = np.random.default_rng(seed)
+    count = cfg["steps"] * cfg["batch_per_kind"]
+    return {
+        "atomic": stream_indices(len(w["atomic_x"]), count, rng),
+        "composite": stream_indices(int(w["train_mask"].sum()), count, rng),
+    }
+
+
+def build_model(arch, cfg):
+    return CausalLM(
+        ModelConfig(
+            vocab_size=ENTITY + cfg["entities"] + cfg["relations"],
+            layers=arch["layers"],
+            width=arch["width"],
+            heads=arch["heads"],
+            context=8,
+        )
+    )
+
+
+def amp(device):
+    return (
+        torch.autocast("cuda", dtype=torch.bfloat16)
+        if str(device).startswith("cuda")
+        else contextlib.nullcontext()
+    )
+
+
+def training_tensors(w, device):
+    result = {}
+    for name, mask in (("atomic", slice(None)), ("composite", w["train_mask"])):
+        x, y = w[name + "_x"][mask], w[name + "_y"][mask]
+        full = np.zeros((len(x), 6), dtype=np.int64)
+        full[:, : x.shape[1]] = x
+        full[:, x.shape[1]] = y
+        full[:, x.shape[1] + 1] = EOS
+        pos = np.tile([x.shape[1] - 1, x.shape[1]], (len(x), 1))
+        labels = np.c_[y, np.full(len(x), EOS)]
+        result[name] = tuple(torch.as_tensor(v, device=device) for v in (full, pos, labels))
+    return result
+
+
+def optimizer_for(model, cfg, device):
+    decay, no_decay = [], []
+    for p in model.parameters():
+        (decay if p.ndim >= 2 else no_decay).append(p)
+    return torch.optim.AdamW(
+        [
+            {"params": decay, "weight_decay": cfg["weight_decay"]},
+            {"params": no_decay, "weight_decay": 0},
+        ],
+        lr=cfg["lr"],
+        betas=(0.9, 0.999),
+        eps=1e-8,
+        fused=str(device).startswith("cuda"),
+    )
+
+
+def train_step(model, optimizer, tensors, indices, step, cfg, device):
+    parts = [tuple(v[indices[k]] for v in tensors[k]) for k in ("atomic", "composite")]
+    x, pos, labels = (torch.cat([p[j] for p in parts]) for j in range(3))
+    lr = cfg["lr"] * min(1.0, (step + 1) / cfg["warmup"])
+    for group in optimizer.param_groups:
+        group["lr"] = lr
+    optimizer.zero_grad(set_to_none=True)
+    with amp(device):
+        logits = model(x, positions=pos)
+        losses = F.cross_entropy(logits.float().flatten(0, 1), labels.flatten(), reduction="none")
+        loss = losses.mean()
+    loss.backward()
+    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"])
+    optimizer.step()
+    return loss.detach(), norm.detach()
+
+
+@torch.no_grad()
+def predict(model, x, y, device, batch=512):
+    pred, eos, prob = [], [], []
+    for start in range(0, len(x), batch):
+        q = torch.as_tensor(x[start : start + batch], device=device)
+        target = torch.as_tensor(y[start : start + batch], device=device)
+        with amp(device):
+            logits = model(q)[:, -1].float()
+            answer = logits.argmax(-1)
+            stop = model(torch.cat([q, answer[:, None]], dim=1))[:, -1].argmax(-1)
+        pred.extend(answer.cpu().tolist())
+        eos.extend(stop.cpu().tolist())
+        prob.extend(logits.log_softmax(-1).gather(1, target[:, None]).squeeze(1).cpu().tolist())
+    return np.asarray(pred), np.asarray(eos), np.asarray(prob)
+
+
+@torch.no_grad()
+def evaluate(model, w, cfg, device):
+    arrays, metrics = {}, {}
+    for name, key, mask in (
+        ("atomic", "atomic", slice(None)),
+        ("train", "composite", w["train_mask"]),
+        ("test", "composite", ~w["train_mask"]),
+    ):
+        x, y = w[key + "_x"][mask], w[key + "_y"][mask]
+        pred, eos, logp = predict(model, x, y, device, cfg["eval_batch"])
+        arrays.update({name + "_pred": pred, name + "_eos": eos, name + "_logp": logp})
+        metrics.update(
+            {
+                name + "_answer": float(np.mean(pred == y)),
+                name + "_exact": float(np.mean((pred == y) & (eos == EOS))),
+                name + "_nll": float(-logp.mean()),
+            }
+        )
+    # Autonomous two-call baseline uses its own generated bridge, never the oracle.
+    test_ids = np.flatnonzero(~w["train_mask"])
+    a, r1, r2 = w["comps"][test_ids].T
+    bridge_pred = arrays["atomic_pred"][a * cfg["relations"] + r1]
+    bridge_eos = arrays["atomic_eos"][a * cfg["relations"] + r1]
+    second_x = np.c_[np.full(len(a), BOS), bridge_pred, ENTITY + cfg["entities"] + r2]
+    y = w["composite_y"][test_ids]
+    pred, eos, logp = predict(model, second_x, y, device, cfg["eval_batch"])
+    arrays.update(
+        two_call_pred=pred, two_call_eos=eos, two_call_logp=logp, two_call_bridge=bridge_pred
+    )
+    two_exact = (pred == y) & (eos == EOS) & (bridge_eos == EOS)
+    metrics["two_call_exact"] = float(two_exact.mean())
+    atom_ok = (arrays["atomic_pred"] == w["atomic_y"]) & (arrays["atomic_eos"] == EOS)
+    b = w["maps"][r1, a]
+    both = atom_ok[a * cfg["relations"] + r1] & atom_ok[b * cfg["relations"] + r2]
+    arrays["test_both_atoms_correct"] = both
+    exact = (arrays["test_pred"] == y) & (arrays["test_eos"] == EOS)
+    metrics["test_both_atoms_n"] = int(both.sum())
+    metrics["test_given_both_atoms"] = float(exact[both].mean()) if both.any() else None
+    return metrics, arrays
+
+
+@torch.no_grad()
+def states_and_logits(model, tokens, device):
+    # Mirrors bios_model.CausalLM.forward; contract-tested against ordinary forward.
+    with amp(device):
+        h = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=device))
+        states = [h.clone()]
+        for block in model.blocks:
+            h = block(h)
+            states.append(h.clone())
+        logits = F.linear(model.ln_final(h), model.token.weight)
+    return states, logits.float()
+
+
+@torch.no_grad()
+def patched_logits(model, tokens, layer, positions, replacement, device):
+    with amp(device):
+        h = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=device))
+        if layer == 0:
+            h[:, positions] = replacement.to(h.dtype)
+        for number, block in enumerate(model.blocks, 1):
+            h = block(h)
+            if number == layer:
+                h[:, positions] = replacement.to(h.dtype)
+        return F.linear(model.ln_final(h), model.token.weight)[:, -1].float()
+
+
+@torch.no_grad()
+def diagnostics(model, w, cfg, device):
+    cases = w["cases"]
+    q = torch.as_tensor(w["composite_x"][cases[:, 0]], device=device)
+    dx = np.c_[
+        np.full(len(cases), BOS), ENTITY + cases[:, 6], ENTITY + cfg["entities"] + cases[:, 2]
+    ]
+    sx = np.c_[
+        np.full(len(cases), BOS), ENTITY + cases[:, 9], ENTITY + cfg["entities"] + cases[:, 10]
+    ]
+    clean, logits = states_and_logits(model, q, device)
+    donor, _ = states_and_logits(model, torch.as_tensor(dx, device=device), device)
+    same, _ = states_and_logits(model, torch.as_tensor(sx, device=device), device)
+    old = torch.as_tensor(ENTITY + cases[:, 5], device=device)
+    new = torch.as_tensor(ENTITY + cases[:, 8], device=device)
+    wrong = torch.as_tensor(ENTITY + cases[:, 12], device=device)
+    row = torch.arange(len(q), device=device)
+    baseline = logits[:, -1]
+    out = {
+        "case_ids": cases[:, 0],
+        "clean_pred": baseline.argmax(-1).cpu().numpy(),
+        "clean_margin": (baseline[row, new] - baseline[row, old]).cpu().numpy(),
+        "old_y": old.cpu().numpy(),
+        "new_y": new.cpu().numpy(),
+        "wrong_y": wrong.cpu().numpy(),
+    }
+    # Fixed random orthogonal coordinate permutation preserves perturbation norm.
+    rng = np.random.default_rng(142899)
+    perm = torch.as_tensor(rng.permutation(model.config.width), device=device)
+    signs = torch.as_tensor(rng.choice([-1, 1], model.config.width), device=device)
+    for layer in range(len(clean)):
+        with amp(device):
+            lens = F.linear(model.ln_final(clean[layer]), model.token.weight).float()
+        out[f"lens_bridge_pos2_{layer}"] = lens[:, 2].argmax(-1).cpu().numpy()
+        out[f"lens_query_pos3_{layer}"] = lens[:, 3].argmax(-1).cpu().numpy()
+        delta = donor[layer][:, 2] - clean[layer][:, 2]
+        random_state = clean[layer][:, 2] + delta[:, perm] * signs
+        conditions = {
+            "bridge": ([2], donor[layer][:, [2]]),
+            "same_bridge": ([2], same[layer][:, [2]]),
+            "random": ([2], random_state[:, None]),
+            "source": ([1], donor[layer][:, [1]]),
+            "prefix": ([1, 2], donor[layer][:, [1, 2]]),
+            "identity": ([2], clean[layer][:, [2]]),
+        }
+        for name, (positions, replacement) in conditions.items():
+            z = patched_logits(model, q, layer, positions, replacement, device)
+            prefix = f"{name}_{layer}"
+            out[prefix + "_pred"] = z.argmax(-1).cpu().numpy()
+            out[prefix + "_margin"] = (z[row, new] - z[row, old]).cpu().numpy()
+            out[prefix + "_max_delta"] = (z - baseline).abs().max(-1).values.cpu().numpy()
+    return out
+
+
+def run_name(world, seed, architecture):
+    return f"w{world}-s{seed}-{architecture}"

docs/development-artifacts/composition-data-curves-v1/source/tests/test_composition_curves.py

@@ -0,0 +1,208 @@
+"""Conclusion-changing contracts for the data-size and knowledge-load comparisons."""
+
+import copy
+import importlib.util
+import json
+import math
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from llm_memory_editability.composition_curves import (
+    anchors_pass,
+    budget_nodes,
+    calibrated_choice,
+    confirmation_specs,
+    construct,
+    load_specs,
+    prepare_world,
+)
+from llm_memory_editability.grok_depth import EpochStream
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def spec(phi=1, entities=16):
+    return {
+        "world_seed": 311,
+        "entities": entities,
+        "max_entities": 32,
+        "relations": 8,
+        "degree": 4,
+        "phi": phi,
+        "id_fraction": 0.75,
+        "test_fraction": 0.1,
+        "evaluation_size": 128,
+        "batch_size": 16,
+        "target_exposures": 17,
+        "compute_steps": 64,
+        "width": 16,
+        "layers": 2,
+        "heads": 2,
+        "dropout": 0.1,
+        "initialization": 981,
+    }
+
+
+def test_distinct_supports_are_nested_and_never_change_world_or_test_panels():
+    previous = set()
+    identity = None
+    reference = None
+    for phi in (0, 0.5, 1, 2):
+        arrays, panels, meta = prepare_world(spec(phi))
+        current = {tuple(row[:-1]) for row in arrays["train_composite"]}
+        assert previous <= current
+        assert len(current) == meta["composition_examples"]
+        assert not current & {tuple(row[:-1]) for row in arrays["test_composite"]}
+        if identity is None:
+            identity, reference = meta["world_sha256"], panels
+        assert meta["world_sha256"] == identity
+        for key in ("atomic", "II", "OO"):
+            np.testing.assert_array_equal(panels[key], reference[key])
+        previous = current
+
+
+def test_truth_and_ood_roles_survive_fixed_vocabulary_remapping():
+    arrays, _, meta = prepare_world(spec(2))
+    atomic = {tuple(row[:2]): int(row[2]) for row in arrays["atomic"]}
+    ood = {tuple(row[:2]) for row in arrays["ood_atomic"]}
+    for head, r1, r2, answer in arrays["train_composite"]:
+        bridge = atomic[head, r1]
+        assert atomic[bridge, r2] == answer
+        assert (head, r1) not in ood and (bridge, r2) not in ood
+    for head, r1, r2, answer in arrays["ood_composite"]:
+        bridge = atomic[head, r1]
+        assert atomic[bridge, r2] == answer
+        assert (head, r1) in ood and (bridge, r2) in ood
+    assert meta["role_coverage"]["ood_composite"]["both_facts_seen_in_required_roles"] in (0, None)
+    assert arrays["atomic"][:, 1].min() >= spec()["max_entities"] + 2
+
+
+def test_same_model_parameters_and_initial_weights_at_every_load():
+    import torch
+
+    small, cfg = construct(spec(1, 8), "cpu")
+    large, large_cfg = construct(spec(1, 32), "cpu")
+    assert cfg == large_cfg
+    for key, value in small.state_dict().items():
+        assert torch.equal(value, large.state_dict()[key])
+    for n in (8, 16, 32):
+        arrays, _, meta = prepare_world(spec(1, n))
+        assert meta["knowledge_bits"] == len(arrays["atomic"]) * math.log2(n)
+        assert meta["composition_additional_independent_bits"] == 0
+
+
+def test_requests_never_cap_or_silently_repeat_distinct_compositions():
+    with pytest.raises(ValueError, match="exceeds"):
+        prepare_world(spec(100))
+    with pytest.raises(ValueError, match="vocabulary"):
+        prepare_world(spec(1, 33))
+
+
+def test_world_creation_does_not_touch_global_numpy_rng():
+    np.random.seed(775)
+    expected = np.random.random(8)
+    np.random.seed(775)
+    prepare_world(spec())
+    np.testing.assert_array_equal(np.random.random(8), expected)
+
+
+def test_matched_exposure_budget_gives_every_record_the_declared_exposure():
+    item = spec()
+    total = 39
+    nodes, budgets = budget_nodes(item, total)
+    assert budgets["exposure"] == math.ceil(17 * total / 16)
+    assert budgets["exposure"] in nodes and budgets["compute"] in nodes
+    stream = EpochStream(total, 763)
+    seen = np.bincount(stream.take(budgets["exposure"] * 16), minlength=total)
+    assert seen.min() == 17 and seen.max() == 18
+    resumed = EpochStream(total, 1)
+    resumed.load_state_dict(copy.deepcopy(stream.state_dict()))
+    np.testing.assert_array_equal(stream.take(120), resumed.take(120))
+
+
+def test_fixed_development_budget_does_not_pretend_to_reach_exposure_endpoint():
+    item = {**spec(), "fixed_steps": 64}
+    nodes, budgets = budget_nodes(item, 1000)
+    assert budgets["end"] == 64
+    assert nodes[-1] == 64
+    assert budgets["exposure"] not in nodes
+
+
+def metrics(atomic=1, train=1, test=0.9):
+    return {
+        "atomic": {"accuracy": atomic},
+        "train_composition": {"accuracy": train},
+        "II": {"accuracy": test},
+    }
+
+
+def test_development_gate_does_not_reward_best_training_fit_without_generalization():
+    thresholds = {"atomic": 0.95, "train_composition": 0.95, "II": 0.8}
+    two, four = {"layers": 2}, {"layers": 4}
+    assert calibrated_choice([(two, metrics(test=0.02)), (four, metrics())], thresholds) == four
+    assert calibrated_choice([(four, metrics()), (two, metrics())], thresholds) == two
+    assert calibrated_choice([(two, metrics(atomic=0.94))], thresholds) is None
+
+
+def test_load_gate_requires_all_distinct_registered_worlds():
+    thresholds = {"atomic": 0.95, "train_composition": 0.95, "II": 0.8}
+    rows = [({"world_seed": n}, metrics()) for n in (1, 2, 3)]
+    assert anchors_pass(rows, [1, 2, 3], thresholds)
+    assert not anchors_pass(rows[:2], [1, 2, 3], thresholds)
+    assert not anchors_pass([rows[0], rows[0], rows[2]], [1, 2, 3], thresholds)
+    rows[1] = ({"world_seed": 2}, metrics(test=0.79))
+    assert not anchors_pass(rows, [1, 2, 3], thresholds)
+
+
+def test_complete_registered_matrix_reuses_low_load_without_duplicate_training():
+    config = json.loads((ROOT / "configs/composition-data-curves-v1.json").read_text())
+    selected = {**config["base_spec"], "layers": 2}
+    support = confirmation_specs(config, selected)
+    load = load_specs(config, selected)
+    assert len(support) == 21 and len(load) == 15
+    assert len({row["name"] for row in support + load}) == 36
+    for world in config["confirmation_worlds"]:
+        assert {row["phi"] for row in support if row["world_seed"] == world} == set(
+            config["support_phi"]
+        )
+        anchors = [
+            row
+            for row in support
+            if row["world_seed"] == world and row["phi"] == config["anchor_phi"]
+        ]
+        assert len(anchors) == 1 and anchors[0]["entities"] == 128
+        assert all(row["entities"] != 128 for row in load)
+    assert all(row["phase"] == "confirmation" for row in support + load)
+    assert config["development_world"] not in config["confirmation_worlds"]
+
+
+def load_executor():
+    module_spec = importlib.util.spec_from_file_location(
+        "curve_executor", ROOT / "scripts/execute_composition_curves.py"
+    )
+    module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(module)
+    return module
+
+
+def test_container_isolation_uses_real_repository_and_frozen_source(tmp_path):
+    executor = load_executor()
+    config = {
+        "batch": "example",
+        "repository": "/repo",
+        "source_root": "/repo/frozen/source",
+        "runtime": {"image": "sha256:fixed", "python": "/python", "cpus": 2, "memory": "12g"},
+    }
+    name, command = executor.container_command(
+        config, Path("/repo/frozen/support-config.json"), {"name": "phi1"}, tmp_path, 1, 1
+    )
+    assert command[:4] == ["docker", "--context", "lm-memory", "run"]
+    assert "type=bind,src=/repo,dst=/repo,readonly" in command
+    assert "PYTHONPATH=/repo/frozen/source/src" in command
+    assert "device=1" in command and "--read-only" in command and "--network=none" in command
+    other, _ = executor.container_command(
+        config, Path("/repo/frozen/support-config.json"), {"name": "phi1"}, tmp_path, 1, 2
+    )
+    assert name != other

docs/development-artifacts/composition-data-curves-v1/support-config.json

@@ -0,0 +1,780 @@
+{
+  "batch": "composition-data-curves-v1",
+  "results_root": "/ossfs/workspace/llm-memory-editability/results/composition-data-curves-v1",
+  "gpus": [
+    0,
+    1
+  ],
+  "preflight": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/cuda.json",
+  "runtime": {
+    "docker_context": "lm-memory",
+    "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f",
+    "python": "/opt/conda/bin/python",
+    "cpus": 2,
+    "memory": "12g"
+  },
+  "base_spec": {
+    "entities": 128,
+    "max_entities": 4096,
+    "relations": 32,
+    "degree": 16,
+    "id_fraction": 0.95,
+    "test_fraction": 0.1,
+    "width": 64,
+    "heads": 4,
+    "dropout": 0.1,
+    "lr": 0.0001,
+    "weight_decay": 0.1,
+    "warmup": 2000,
+    "batch_size": 256,
+    "evaluation_size": 2048,
+    "compute_steps": 128000,
+    "target_exposures": 4000,
+    "max_wall_seconds": 43200
+  },
+  "development_world": 961006101,
+  "confirmation_worlds": [
+    961006111,
+    961006112,
+    961006113
+  ],
+  "initialization": 961006121,
+  "stream_seed": 961006131,
+  "calibration_layers": [
+    2,
+    4
+  ],
+  "calibration_steps": [
+    128000,
+    512000
+  ],
+  "calibration_thresholds": {
+    "atomic": 0.95,
+    "train_composition": 0.95,
+    "II": 0.8
+  },
+  "selection_rule": "development world only; prefer 2 layers if its fixed endpoint passes, otherwise 4; one predeclared common budget extension if neither passes",
+  "anchor_phi": 7.2,
+  "support_phi": [
+    0,
+    0.5,
+    1,
+    2,
+    4,
+    7.2,
+    12.6
+  ],
+  "load_entities": [
+    128,
+    256,
+    512,
+    1024,
+    2048,
+    4096
+  ],
+  "load_gate": {
+    "atomic": 0.95,
+    "train_composition": 0.95,
+    "II": 0.8
+  },
+  "tracking": {
+    "enabled": true,
+    "entity": "zhusq20",
+    "project": "llm-memory-editability",
+    "mode": "online"
+  },
+  "budget": {
+    "maximum_training_runs": 40,
+    "maximum_gpu_hours": 64,
+    "per_run_wall_seconds": 43200,
+    "extension_target_exposures": 8000,
+    "automatic_new_learning_rates": false,
+    "automatic_new_architectures": false
+  },
+  "interpretation": {
+    "primary_level": "controlled synthetic behavior; no universal capacity law or internal MLP attribution",
+    "knowledge_entropy": "F log2(N), conditional on relation keys; composition support adds zero independent bits",
+    "load_graphs": "closed random graphs at each N, same registered world-family seeds but different facts; not a nested-fact intervention",
+    "world_weighting": "three independent world families, one initialization each; do not pool queries as independent worlds",
+    "budgets": "128000 updates gives identical executed-shape FLOPs; matched average record exposures is a separate comparison"
+  },
+  "repository": "/ossfs/workspace/llm-memory-editability",
+  "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source",
+  "source_files": {
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/composition_curves.py": "520c4503f3d1525612432dd2c0b9fbf56d2e39ee5d6dff9f1484f19a7bfae8ec",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/curve_tracking.py": "50cc8a1d652c44ef14d42b4a44cc800fb15e2ed72f4b83c4848870d76ab56fec",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/scripts/run_composition_curves.py": "f01b63f3e80427ffe37c730f81e3cc1ca854735807554d5a6cbd812416d00b3b",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/scripts/execute_composition_curves.py": "ba220f8f570c62a9677694de9bdf9b3f4b4dda9be5579242bb093d9d783d939d",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/scripts/report_composition_curves.py": "89320834c058bd57b3307e95d6024a5025cdb45931020cbeac7cf7e9d32cbf05",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/tests/test_composition_curves.py": "3620a14156b8e40682da1309444be1e646ce10639b2691f6c99deb33e74b2674",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/configs/composition-data-curves-v1.json": "ea6b69279d78372490bb25f4bc46fda1325673a500ce070137b055acb7d75722",
+    "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/docs/development-artifacts/composition-data-curves-v1/protocol.md": "22d9eabc0facbcc40cf9fc2dbb4b07bac3d0351caf91e10aa9625bcbe3ef45ee"
+  },
+  "preflight_sha256": "599a85f6e3cd81a6105ae9168d3f4a387093fe68cd53c94697a88477e7d6f28f",
+  "frozen_utc": "2026-10-06T01:03:49.716017+00:00",
+  "git_commit": "b7b1741e5c840b68612c4eeb4fb2248ad5f2be61",
+  "runs": [
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 0,
+      "phase": "confirmation",
+      "name": "support-w1-phi0"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 0.5,
+      "phase": "confirmation",
+      "name": "support-w1-phi0.5"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 1,
+      "phase": "confirmation",
+      "name": "support-w1-phi1"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 2,
+      "phase": "confirmation",
+      "name": "support-w1-phi2"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 4,
+      "phase": "confirmation",
+      "name": "support-w1-phi4"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 7.2,
+      "phase": "confirmation",
+      "name": "support-w1-phi7.2"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006111,
+      "initialization": 961006121,
+      "stream_seed": 961006131,
+      "phi": 12.6,
+      "phase": "confirmation",
+      "name": "support-w1-phi12.6"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 0,
+      "phase": "confirmation",
+      "name": "support-w2-phi0"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 0.5,
+      "phase": "confirmation",
+      "name": "support-w2-phi0.5"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 1,
+      "phase": "confirmation",
+      "name": "support-w2-phi1"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 2,
+      "phase": "confirmation",
+      "name": "support-w2-phi2"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 4,
+      "phase": "confirmation",
+      "name": "support-w2-phi4"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 7.2,
+      "phase": "confirmation",
+      "name": "support-w2-phi7.2"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006112,
+      "initialization": 961006122,
+      "stream_seed": 961006132,
+      "phi": 12.6,
+      "phase": "confirmation",
+      "name": "support-w2-phi12.6"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 0,
+      "phase": "confirmation",
+      "name": "support-w3-phi0"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 0.5,
+      "phase": "confirmation",
+      "name": "support-w3-phi0.5"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 1,
+      "phase": "confirmation",
+      "name": "support-w3-phi1"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 2,
+      "phase": "confirmation",
+      "name": "support-w3-phi2"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 4,
+      "phase": "confirmation",
+      "name": "support-w3-phi4"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 7.2,
+      "phase": "confirmation",
+      "name": "support-w3-phi7.2"
+    },
+    {
+      "entities": 128,
+      "max_entities": 4096,
+      "relations": 32,
+      "degree": 16,
+      "id_fraction": 0.95,
+      "test_fraction": 0.1,
+      "width": 64,
+      "heads": 4,
+      "dropout": 0.1,
+      "lr": 0.0001,
+      "weight_decay": 0.1,
+      "warmup": 2000,
+      "batch_size": 256,
+      "evaluation_size": 2048,
+      "compute_steps": 128000,
+      "target_exposures": 4000,
+      "max_wall_seconds": 43200,
+      "layers": 4,
+      "world_seed": 961006113,
+      "initialization": 961006123,
+      "stream_seed": 961006133,
+      "phi": 12.6,
+      "phase": "confirmation",
+      "name": "support-w3-phi12.6"
+    }
+  ],
+  "phase": "support"
+}

docs/development-artifacts/composition-data-curves-v1/support-execution-lock.json

@@ -0,0 +1,4 @@
+{
+  "config_sha256": "630012f8b6c6d1a1032b3b66fb078777c3b032dd75c9db87eb315a7c9ba484b4",
+  "utc": "2026-10-06T01:07:16.671477+00:00"
+}

docs/development-artifacts/composition-data-curves-v1/verification.json

@@ -0,0 +1,18 @@
+{
+  "passed": true,
+  "utc": "2026-10-06T01:05:47.805911+00:00",
+  "pytest": {
+    "passed": 30,
+    "files": [
+      "tests/test_composition_curves.py",
+      "tests/test_grok_depth_data.py",
+      "tests/test_grok_depth_training.py"
+    ]
+  },
+  "ruff_check": "passed",
+  "ruff_format_check": "passed",
+  "cuda_preflight": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/cuda.json",
+  "gpu_pipeline_reload": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/smoke/audit.json",
+  "wandb_connectivity": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/wandb-connectivity.json",
+  "engineering_preflight_not_scientific_result": true
+}

docs/development-artifacts/compositional-capacity-discussion-20261006/note.md

@@ -0,0 +1,80 @@
+# 存储与组合容量的分离：讨论候选
+
+2026-10-06。原论文标题保持 **Transformers as Associative Memories: Exploring the Scaling of Storage and Compositional Recall**。本文件保留限定模型的代数推导与 CPU 数值核验；结合 Physics of Language Models 的后续思考、实验逻辑与故事线已按用户要求纳入[当前研究计划](../../hebbian-learning-plan-v1.md#capacity-scaling-mainline-20261006)。这不是新的训练执行协议，不修改现有运行。
+
+## 核心问题与证据层级
+
+随着事实负载增加，单跳可提取的知识量与多跳可组合的知识量，是否出现不同的宽度依赖？如果存在差距，中间状态的纠错能否改变它的增长规律？
+
+复合答案由原子事实决定，不自带一份与每条链独立的新知识熵。不能因组合链数量增长，就推出存储参数必须按链数量增长。所需解释是特定表示和计算过程的代价：被压缩存储的关联能否连续使用，以及中间串扰如何随负载传播。
+
+下面的结果仅属于随机编码、外积叠加、直接线性串接这一构造。它不证明所有可学习矩阵、MLP 或 Transformer 都具有相同损失，更不构成任意架构的容量下界。训练可重排表示、改变读写规则或实现内部纠错，这正是后续实验必须检验的部分。
+
+## 一个精确的二阶矩计算
+
+每个阶段有 N 个实体的独立随机单位球编码，写成 E_l ∈ R^{d×N}，不同阶段也独立。阶段间关系取任意固定双射；对编码列重编号后，可无损地写成同索引关联。
+
+记忆矩阵为 W_l = E_l E_{l-1}^T。一次查询从 E_0 e_i 开始，连续应用 h 个记忆矩阵，最后用 E_h 的内积打分。令 G_l = E_l^T E_l，则分数向量为
+
+    s = G_h G_{h-1} ... G_0 e_i.
+
+这里 G_l 独立，E[G_l]=I。对独立于 G_l 的固定向量 v，令 a=1+(N−1)/d、b=1−1/d，有
+
+    E ||G_l v||² = a ||v||²,
+    E [(G_l v)_j²] = b v_j² + ||v||²/d.
+
+第一式由对角元恒为 1、非对角元均值为 0 且二阶矩为 1/d 得到；第二式展开平方后，不同非对角项的交叉期望为零。对先前随机向量条件化后同样成立。
+
+记 t 个 Gram 因子之后的错误坐标二阶矩为 q_t，则 q_0=0，且
+
+    q_{t+1} = b q_t + a^t/d,
+    q_t = (a^t − b^t)/N.
+
+因此 h 次检索后的任一错误候选 j≠i 满足以下精确关系，期望遍历随机编码：
+
+    E[s_j] = 0,
+    Var(s_j) = { [1+(N−1)/d]^(h+1) − [1−1/d]^(h+1) } / N.
+
+正确候选的均值为 1，二阶矩为 a^(h+1)/N + (1−1/N)b^(h+1)；正确分数本身也有随机性，不可把它当成恒定信号。
+
+特别地：
+
+    一跳：Var(s_j) = 2/d + (N−2)/d²,
+    两跳：Var(s_j) = 3/d + 3(N−2)/d² + (N²−3N+3)/d³.
+
+在固定 h、N/d 足够大时，错误分数方差的主项为 N^h/d^(h+1)。这说明该构造中，连续组合的串扰负担增长快于单跳，不能仅按独立单跳错误率相乘解释。
+
+这还不是准确率阈值定理。候选分数有依赖，正确分数也波动；要得到容量尺度，还须控制尾部概率和最大错误分数。把主项直接改写为 N≈d^(1+1/h)，只能得到忽略尾部及对数因子的启发式尺度，不能写成已证明的 Transformer 定律。
+
+## 中间重编码与架构含义
+
+在每一步后使用模型自己的 argmax，将状态替换为预测实体的固定编码，再进入下一步。在必要单跳都正确的查询上，整个链确定正确。这一性质是构造的直接结果，不是新的普遍定理；它需要编码表、额外解码计算，并可能在单跳错误时做出不可逆的错误选择。
+
+有价值的理论目标是比较两类计算在相同随机记忆负载下的准确率尺度，并明确纠错资源。之后再问训练后的非线性网络是否出现同类分离，以及是否已经学会消除它。此推导不适用于同一矩阵重复相乘；Loop 的跨步误差依赖需另行分析。
+
+## CPU 验算与复现
+
+[sanity_check.py](sanity_check.py) 使用 NumPy、16 次独立编码抽样，每次抽取 48 个查询；各条件的随机流固定。结果保存于 [sanity-results.json](sanity-results.json)。未进行参数训练、未使用 GPU。查询在同一编码世界内相关，768 个查询不能当作 768 个独立世界。报告的是抽样原子准确率。
+
+当前主机复现命令：
+
+```bash
+LD_LIBRARY_PATH="/lib64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python docs/development-artifacts/compositional-capacity-discussion-20261006/sanity_check.py
+```
+
+## 小 Transformer 需要区分的解释
+
+- 主轴采用原子世界信息量相对于参数量的负载 B/P，N 作为其中一个控制量；[知识容量对接](physics-of-language-connection.md)区分数据熵和实测掌握量。少量宽度用于验证尺度，先固定两跳，有规律后才延伸三跳。模型从头预训练，原子事实和有限组合示范可见，测试链留出。
+- 固���最大词表、实体编码长度、关系类型、目标查询和目标事实的曝光；避免增加 N 时顺带改变词表参数或链难度。加入无关事实是一个关键比较：目标链保持不变，改变其他关联占用的记忆。
+- 固定每条事实曝光与固定总 FLOPs 不能同时随 N 严格保持。前者用于机制主比较，后者只作资源复核；分别报告曲线，不混成同一容量结论。对临界点检查延长训练是否移动边界，不能把有限预算的优化失败写成结构不可能性。
+- 报告全池多跳、必要单跳正确率及共同正确子集覆盖率。高平均原子准确率不足以排除组成目标链的事实恰好更难。
+- 优先普通 Transformer 与共享块 Transformer，再按观测选一个机制变体。中间纠错若需要首跳监督，两臂给相同监督；若加入计算，补同等计算的对照。仅有外部多次问答成功不证明内部架构改善。
+- 若串扰随负载的效应只存在于预设线性记忆、被正常训练消除，应收窄或放弃其作为普通 Transformer 主机制的解释。现有约 17% OO 平台不能被预先归因于容量。
+
+## 相关文献及当前阅读边界
+
+- [Meta: Scaling Laws for Looped Mixture of Experts](https://arxiv.org/html/2609.40316v1)，2026-09-30 预印本：核对联合 recurrence/sparsity scaling、有效参数映射和下游计算比较。之前的参数/循环计算效率选题与其确有明显重叠。
+- [Understanding Factual Recall in Transformers via Associative Memories](https://arxiv.org/html/2412.06538)：随机编码关联记忆、事实存储与 Transformer 构造的理论基础。其单跳容量不能直接当成连续组合容量。
+- [Sharp Capacity Thresholds in Linear Associative Memory: From Top-1 Retrieval to Tail-Average Learning](https://arxiv.org/html/2605.05189)，所读为 2026-08-19 v2：核对摘要、§1 模型及 top-1 阈值陈述。v1 与 v2 的标题和定理强度不同；本次未独立验证整篇证明。其模型表明检索标准影响容量，不能将“容量取决于读出方式”本身当作我们的新发现。
+- [Holographic Memory for Zero-Shot Compositional Reasoning in Knowledge Graphs](https://arxiv.org/html/2606.24948)，2026-06-23 预印本：核对 HRR/FHRR 记忆构造、hard cleanup 两跳及必要第二跳的原子难度诊断。该模型的结果提醒我们必须核验路径上的必要事实，不能仅比较全局单跳均值。
+- 搜索发现 OpenReview 稿件 *How Many Parameters for Multi-Hop?*，但两个正文入口都被站点验证页阻挡。本次未核对其定理，不据摘要认可其普遍容量结论；选题新颖性审查仍须补读。

docs/development-artifacts/compositional-capacity-discussion-20261006/physics-of-language-connection.md

@@ -0,0 +1,48 @@
+# Physics of Language Models 3.3 对组合容量研究的帮助
+
+2026-10-06，用户提出的文献连接；随后要求将思考和后续实验逻辑落盘。统一的故事线、实验顺序、判断分支和写作范围已纳入[当前研究计划](../../hebbian-learning-plan-v1.md#capacity-scaling-mainline-20261006)及[论文定位](../../paper-framing.md)。本文件保留文献口径与信息量定义，不增加训练预算或修改正在执行的协议。
+
+## 原文口径
+
+[Part 3.3，ICLR 2025 会议版](https://proceedings.iclr.cc/paper_files/paper/2025/file/26d3c9a66836ded8f34a944f2bfe868e-Paper-Conference.pdf)报告的是约 **2 bits of knowledge per parameter**，不是每条事实需要 2 bits。2 是受控实验中充分训练后的经验容量比例，信息论定理提供的是知识比特数的下界，不是任意 Transformer 都不得超过 2 bits/parameter 的普遍定理。
+
+本次也读取了 [2024 arXiv 完整版](https://arxiv.org/html/2404.05405)的 §2–5、训练曝光与架构相关陈述、附录 A 的参数口径和提取验证。原文以随机生成的事实和知识 token 的损失估计信息量；名字集合、属性值、值词典分别计数。1000 次与 100 次事实曝光有不同经验容量。其参数口径排除未使用的词表行；MoE 分母是总存储参数，不是单次激活参数。提取验证借助在部分人物上微调 QA 后测试其余人物，不能自动解释为无监督零样本知识操作。
+
+同系列 [Part 3.2，ICLR 2025 会议版](https://proceedings.iclr.cc/paper_files/paper/2025/file/d5494c8747276d3cdb2598e5617de89d-Paper-Conference.pdf)已研究提取、分类、比较、逆向搜索，并观察到提取成功与知识操作失败可以并存。因此，“记得但不会用”本身不是我们的新增主张。
+
+## 用知识熵取代事实条数作为主负载
+
+在固定地址与值词表、N 个独立且均匀的 M 选一属性值的简化世界中：
+
+    H(Z) = N log₂ M.
+
+如果原子属性值的平均负对数概率为 ℓ₁（nats），则可采用与原文思路一致的经验量：
+
+    B_hat = N (log₂ M − ℓ₁ / ln 2).
+
+跨随机世界取期望时，可由熵与交叉熵关系给出模型保有信息量的下界；单个世界的实测估计不等于已知的真实互信息。该简式只计条件属性信息，不包含随机名字/词典的学习成本，也不能直接用于相关的真实知识图。
+
+区分两个横轴：数据负载 ρ_data=H(Z)/P，与已掌握信息的经验密度 ρ_learned=B_hat/P。提高数据量但没有学会，并不意味着存储密度提高。
+
+多跳答案由原子世界 Z 决定。不能把大量复合查询的 log₂ 候选数相加，当作新存入的知识 bits。组合题之间共享事实，联合熵不能按题数独立计数。
+
+## 候选容量定义与理论目标
+
+固定世界生成器、训练支持、训练流程、知识表示、评价分布及准确率要求，定义：
+
+- C₁(P)：达到指定原子提取准确率时，可承载的最大原子世界信息量。
+- C_h(P)：同时满足同一原子提取要求及指定 h 跳泛化准确率时，可承载的最大原子世界信息量。
+
+组合容量的单位是“满足使用要求的知识库 bits”，不是复合答案新增 bits。由定义的集合包含关系 C_h≤C₁；这个不等式不是论文贡献。真正要研究的是两者的尺度、差距随 h 的变化，以及架构是否改变差距。
+
+尤其不能直接设 C₁(P)=2P：原文约 2 bits/parameter 是基于损失估计的峰值容量比例，与我们指定例如 99% 原子准确率时的容量边界不是同一定义。先复用其测量方法，再独立测定我们的 C₁ 和 C_h。
+
+经典信息论能限制需要存储的世界信息，但不会因复合查询数量大就自动产生新的 h 倍信息下界。若需证明组合额外代价，必须引入明确的计算限制、状态维数、精度或中间纠错条件。前一份随机线性记忆的串扰推导只覆盖其中一个构造，不能推出所有学习到的 Transformer 都有同一尺度。
+
+## 对当前实验的实际影响
+
+当前真实图 65,968 条原子事实，D8 约 96.1M 总参数，二者尚未转换到相容的信息/参数口径。没有证据说明已经接近 3.3 的存储极限。仅作为量纲示例：如果每条独立关联为 20 bits，条件关联信息量约 1.32M bits，用当前总参数分母约为 0.014 bits/parameter；这不是当前真实数据的熵估计，也尚未扣除未使用词表行。
+
+因此，下一步应先校准小模型的单跳容量曲线，适当缩小模型或增加受控事实熵，覆盖欠载至接近饱和的区间，再观察未见组合。保持共同词表，报告全部参数与按原文口径调整的参数；共享循环参数只计一次，MoE 同时报总参数和实际计算。
+
+可检验的中心问题是：**在相同知识 bits/parameter 和必要原子提取水平下，组合能力是否仍受状态宽度、执行结构与中间纠错显著影响？** 若负载归一化能让单跳曲线接近重合、组合曲线却依架构分离，就得到超出架构排名的机制问题。先以两跳为主，负载为主轴；不自动追加架构或跳数全矩阵。

docs/development-artifacts/compositional-capacity-discussion-20261006/sanity-results.json

@@ -0,0 +1,99 @@
+{
+  "kind": "exploratory CPU algebra verification; no training",
+  "seed": 601006,
+  "numpy_version": "1.23.5",
+  "rows": [
+    {
+      "d": 64,
+      "associations_per_stage": 128,
+      "independent_codebook_draws": 16,
+      "queries_per_draw": 48,
+      "atomic1": 0.9817708333333334,
+      "atomic2": 0.9817708333333334,
+      "continuous_twohop": 0.4088541666666667,
+      "both_atomic_correct_coverage": 0.9635416666666666,
+      "continuous_twohop_given_both_correct": 0.4175675675675676,
+      "reset_twohop": 0.9635416666666666,
+      "reset_twohop_given_both_correct": 1.0,
+      "off_score_second_moment_onehop_measured": 0.06191769958576853,
+      "off_score_second_moment_onehop_exact": 0.06201171875,
+      "off_score_second_moment_twohop_measured": 0.19202592507422953,
+      "off_score_second_moment_twohop_exact": 0.20020675659179688
+    },
+    {
+      "d": 64,
+      "associations_per_stage": 256,
+      "independent_codebook_draws": 16,
+      "queries_per_draw": 48,
+      "atomic1": 0.73828125,
+      "atomic2": 0.7760416666666666,
+      "continuous_twohop": 0.078125,
+      "both_atomic_correct_coverage": 0.5572916666666666,
+      "continuous_twohop_given_both_correct": 0.11214953271028037,
+      "reset_twohop": 0.55859375,
+      "reset_twohop_given_both_correct": 1.0,
+      "off_score_second_moment_onehop_measured": 0.09284981942132862,
+      "off_score_second_moment_onehop_exact": 0.09326171875,
+      "off_score_second_moment_twohop_measured": 0.4692728946295357,
+      "off_score_second_moment_twohop_exact": 0.4799919128417969
+    },
+    {
+      "d": 128,
+      "associations_per_stage": 256,
+      "independent_codebook_draws": 16,
+      "queries_per_draw": 48,
+      "atomic1": 1.0,
+      "atomic2": 1.0,
+      "continuous_twohop": 0.64453125,
+      "both_atomic_correct_coverage": 1.0,
+      "continuous_twohop_given_both_correct": 0.64453125,
+      "reset_twohop": 1.0,
+      "reset_twohop_given_both_correct": 1.0,
+      "off_score_second_moment_onehop_measured": 0.03121580010666049,
+      "off_score_second_moment_onehop_exact": 0.0311279296875,
+      "off_score_second_moment_twohop_measured": 0.10011350323057835,
+      "off_score_second_moment_twohop_exact": 0.10083150863647461
+    },
+    {
+      "d": 128,
+      "associations_per_stage": 512,
+      "independent_codebook_draws": 16,
+      "queries_per_draw": 48,
+      "atomic1": 0.9778645833333334,
+      "atomic2": 0.96484375,
+      "continuous_twohop": 0.15494791666666666,
+      "both_atomic_correct_coverage": 0.9466145833333334,
+      "continuous_twohop_given_both_correct": 0.1623108665749656,
+      "reset_twohop": 0.9466145833333334,
+      "reset_twohop_given_both_correct": 1.0,
+      "off_score_second_moment_onehop_measured": 0.04736494144751186,
+      "off_score_second_moment_onehop_exact": 0.0467529296875,
+      "off_score_second_moment_twohop_measured": 0.2419763221214787,
+      "off_score_second_moment_twohop_exact": 0.2410902976989746
+    },
+    {
+      "d": 128,
+      "associations_per_stage": 1024,
+      "independent_codebook_draws": 16,
+      "queries_per_draw": 48,
+      "atomic1": 0.69140625,
+      "atomic2": 0.66015625,
+      "continuous_twohop": 0.013020833333333334,
+      "both_atomic_correct_coverage": 0.4635416666666667,
+      "continuous_twohop_given_both_correct": 0.02247191011235955,
+      "reset_twohop": 0.4635416666666667,
+      "reset_twohop_given_both_correct": 1.0,
+      "off_score_second_moment_onehop_measured": 0.07904413494810934,
+      "off_score_second_moment_onehop_exact": 0.0780029296875,
+      "off_score_second_moment_twohop_measured": 0.7224368904657623,
+      "off_score_second_moment_twohop_exact": 0.7091078758239746
+    }
+  ],
+  "limitations": [
+    "Query samples within a codebook draw are dependent.",
+    "Atomic percentages refer to sampled queries, not all stored facts.",
+    "Reset accesses a fixed codebook and adds decoding work.",
+    "No confidence intervals or capacity exponent fitted.",
+    "Independent codebooks do not establish behavior of tied recurrent weights."
+  ]
+}

docs/development-artifacts/compositional-capacity-discussion-20261006/sanity_check.py

@@ -0,0 +1,81 @@
+"""CPU-only algebra check, not a Transformer training experiment.
+
+Run on the current host with /lib64 first in LD_LIBRARY_PATH and one BLAS thread.
+The random codebooks are independent between stages and have unit-norm columns.
+This does not model a repeatedly applied shared matrix or SGD learning.
+"""
+
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+def main():
+    rng = np.random.default_rng(601006)
+    rows = []
+    for d, n in [(64, 128), (64, 256), (128, 256), (128, 512), (128, 1024)]:
+        totals = np.zeros(9, dtype=float)
+        for _ in range(16):
+            codebooks = [rng.normal(size=(d, n)) for _ in range(3)]
+            codebooks = [e / np.linalg.norm(e, axis=0) for e in codebooks]
+            w1 = codebooks[1] @ codebooks[0].T
+            w2 = codebooks[2] @ codebooks[1].T
+            ids = rng.choice(n, size=48, replace=False)
+            hidden = w1 @ codebooks[0][:, ids]
+            s1 = codebooks[1].T @ hidden
+            s2_atomic = codebooks[2].T @ (w2 @ codebooks[1][:, ids])
+            s2 = codebooks[2].T @ (w2 @ hidden)
+            predicted_bridge = s1.argmax(axis=0)
+            reset_scores = codebooks[2].T @ (w2 @ codebooks[1][:, predicted_bridge])
+            correct1 = predicted_bridge == ids
+            correct2 = s2_atomic.argmax(axis=0) == ids
+            both = correct1 & correct2
+            composed = s2.argmax(axis=0) == ids
+            reset_correct = reset_scores.argmax(axis=0) == ids
+            # Exact consequence of replacing a correct prediction by its codeword.
+            assert np.all(reset_correct[both])
+            wrong = np.ones((n, len(ids)), dtype=bool)
+            wrong[ids, np.arange(len(ids))] = False
+            totals += [
+                correct1.sum(), correct2.sum(), composed.sum(), both.sum(),
+                (composed & both).sum(), (s1[wrong] ** 2).mean(),
+                (s2[wrong] ** 2).mean(), len(ids), reset_correct.sum(),
+            ]
+        a, b = 1 + (n - 1) / d, 1 - 1 / d
+        rows.append(dict(
+            d=d, associations_per_stage=n, independent_codebook_draws=16,
+            queries_per_draw=48, atomic1=totals[0] / totals[7],
+            atomic2=totals[1] / totals[7], continuous_twohop=totals[2] / totals[7],
+            both_atomic_correct_coverage=totals[3] / totals[7],
+            continuous_twohop_given_both_correct=totals[4] / totals[3],
+            reset_twohop=totals[8] / totals[7],
+            reset_twohop_given_both_correct=1.0,
+            off_score_second_moment_onehop_measured=totals[5] / 16,
+            off_score_second_moment_onehop_exact=(a ** 2 - b ** 2) / n,
+            off_score_second_moment_twohop_measured=totals[6] / 16,
+            off_score_second_moment_twohop_exact=(a ** 3 - b ** 3) / n,
+        ))
+    output = dict(
+        kind="exploratory CPU algebra verification; no training",
+        seed=601006, numpy_version=np.__version__, rows=rows,
+        limitations=[
+            "Query samples within a codebook draw are dependent.",
+            "Atomic percentages refer to sampled queries, not all stored facts.",
+            "Reset accesses a fixed codebook and adds decoding work.",
+            "No confidence intervals or capacity exponent fitted.",
+            "Independent codebooks do not establish behavior of tied recurrent weights.",
+        ],
+    )
+    Path(__file__).with_name("sanity-results.json").write_text(
+        json.dumps(output, ensure_ascii=False, indent=2) + "\n"
+    )
+    for row in rows:
+        print(json.dumps({k: row[k] for k in (
+            "d", "associations_per_stage", "atomic1", "atomic2",
+            "continuous_twohop_given_both_correct", "reset_twohop",
+        )}))
+
+
+if __name__ == "__main__":
+    main()

docs/development-artifacts/oo-budget-attribution-20261005/analysis-execution.json

@@ -0,0 +1,41 @@
+{
+  "real_loop": {
+    "oo_percent": 16.73161860223435,
+    "training_hours": 6.638698058694394,
+    "estimated_matmul_training_flops": 2775305955439048704,
+    "executed_input_tokens": 6554798306.666667,
+    "examples": 153249855,
+    "atomic_epochs": 1255.2304046406339,
+    "composition_epochs": 1255.2309414776405,
+    "n_initializations": 3,
+    "oo_n_each": 1283,
+    "oo_sample_sd": 0.6536630618555017
+  },
+  "synthetic_loop_wd03": {
+    "dataset": "synthetic",
+    "run": "loop4x2-phi7.2-wd0.3",
+    "architecture": "loop4x2",
+    "initialization": 791101,
+    "learning_rate": 0.0001,
+    "weight_decay": 0.3,
+    "phi": 7.2,
+    "step": 1500000,
+    "oo_n": 2004,
+    "oo_percent": 81.3373253493014,
+    "evaluation_scope": "fixed_full_OO_pool",
+    "training_hours": 6.5032488311454655,
+    "estimated_matmul_training_flops": 1415910260736000000,
+    "executed_input_tokens": 3072000000,
+    "examples": 767373824,
+    "atomic_epochs": 2446.9826,
+    "composition_epochs": 2446.982894736842
+  },
+  "ratios": {
+    "training_hours": 1.020827932478953,
+    "estimated_matmul_training_flops": 1.9600860537562779,
+    "executed_input_tokens": 2.1337234071180555,
+    "examples": 0.1997069097316512,
+    "atomic_epochs": 0.5129707112100568
+  },
+  "recounted_pools": 81
+}

docs/development-artifacts/oo-budget-attribution-20261005/budget-brackets.json

@@ -0,0 +1,422 @@
+[
+  {
+    "real_run": "confirmation-loop4x2-init1",
+    "budget": "training_hours",
+    "real_value": 6.636754266745928,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 1500000,
+      "oo_n": 2004,
+      "oo_percent": 81.3373253493014,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 6.5032488311454655,
+      "estimated_matmul_training_flops": 1415910260736000000,
+      "executed_input_tokens": 3072000000,
+      "examples": 767373824,
+      "atomic_epochs": 2446.9826,
+      "composition_epochs": 2446.982894736842
+    },
+    "synthetic_above": null,
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init1",
+    "budget": "estimated_matmul_training_flops",
+    "real_value": 2775487015724686848,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 1500000,
+      "oo_n": 2004,
+      "oo_percent": 81.3373253493014,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 6.5032488311454655,
+      "estimated_matmul_training_flops": 1415910260736000000,
+      "executed_input_tokens": 3072000000,
+      "examples": 767373824,
+      "atomic_epochs": 2446.9826,
+      "composition_epochs": 2446.982894736842
+    },
+    "synthetic_above": null,
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init1",
+    "budget": "examples",
+    "real_value": 153249855,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 296000,
+      "oo_n": 2004,
+      "oo_percent": 24.10179640718563,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 1.2962222684443825,
+      "estimated_matmul_training_flops": 279406291451904000,
+      "executed_input_tokens": 606208000,
+      "examples": 151428608,
+      "atomic_epochs": 482.872525,
+      "composition_epochs": 482.8717361111111
+    },
+    "synthetic_above": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 300000,
+      "oo_n": 2004,
+      "oo_percent": 24.451097804391217,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 1.3134469647612423,
+      "estimated_matmul_training_flops": 283182052147200000,
+      "executed_input_tokens": 614400000,
+      "examples": 153474816,
+      "atomic_epochs": 489.39375,
+      "composition_epochs": 489.39717105263156
+    },
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init1",
+    "budget": "atomic_epochs",
+    "real_value": 1255.2305814940578,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 768000,
+      "oo_n": 2004,
+      "oo_percent": 70.60878243512974,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 3.328787970851279,
+      "estimated_matmul_training_flops": 724946053496832000,
+      "executed_input_tokens": 1572864000,
+      "examples": 392895488,
+      "atomic_epochs": 1252.856725,
+      "composition_epochs": 1252.855332602339
+    },
+    "synthetic_above": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 772000,
+      "oo_n": 2004,
+      "oo_percent": 70.50898203592814,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 3.3460153445280674,
+      "estimated_matmul_training_flops": 728721814192128000,
+      "executed_input_tokens": 1581056000,
+      "examples": 394941696,
+      "atomic_epochs": 1259.380075,
+      "composition_epochs": 1259.3804568713451
+    },
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init2",
+    "budget": "training_hours",
+    "real_value": 6.642358209469045,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 1500000,
+      "oo_n": 2004,
+      "oo_percent": 81.3373253493014,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 6.5032488311454655,
+      "estimated_matmul_training_flops": 1415910260736000000,
+      "executed_input_tokens": 3072000000,
+      "examples": 767373824,
+      "atomic_epochs": 2446.9826,
+      "composition_epochs": 2446.982894736842
+    },
+    "synthetic_above": null,
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init2",
+    "budget": "estimated_matmul_training_flops",
+    "real_value": 2775118595566491648,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 1500000,
+      "oo_n": 2004,
+      "oo_percent": 81.3373253493014,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 6.5032488311454655,
+      "estimated_matmul_training_flops": 1415910260736000000,
+      "executed_input_tokens": 3072000000,
+      "examples": 767373824,
+      "atomic_epochs": 2446.9826,
+      "composition_epochs": 2446.982894736842
+    },
+    "synthetic_above": null,
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init2",
+    "budget": "examples",
+    "real_value": 153249855,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 296000,
+      "oo_n": 2004,
+      "oo_percent": 24.10179640718563,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 1.2962222684443825,
+      "estimated_matmul_training_flops": 279406291451904000,
+      "executed_input_tokens": 606208000,
+      "examples": 151428608,
+      "atomic_epochs": 482.872525,
+      "composition_epochs": 482.8717361111111
+    },
+    "synthetic_above": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 300000,
+      "oo_n": 2004,
+      "oo_percent": 24.451097804391217,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 1.3134469647612423,
+      "estimated_matmul_training_flops": 283182052147200000,
+      "executed_input_tokens": 614400000,
+      "examples": 153474816,
+      "atomic_epochs": 489.39375,
+      "composition_epochs": 489.39717105263156
+    },
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init2",
+    "budget": "atomic_epochs",
+    "real_value": 1255.2311120543293,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 768000,
+      "oo_n": 2004,
+      "oo_percent": 70.60878243512974,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 3.328787970851279,
+      "estimated_matmul_training_flops": 724946053496832000,
+      "executed_input_tokens": 1572864000,
+      "examples": 392895488,
+      "atomic_epochs": 1252.856725,
+      "composition_epochs": 1252.855332602339
+    },
+    "synthetic_above": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 772000,
+      "oo_n": 2004,
+      "oo_percent": 70.50898203592814,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 3.3460153445280674,
+      "estimated_matmul_training_flops": 728721814192128000,
+      "executed_input_tokens": 1581056000,
+      "examples": 394941696,
+      "atomic_epochs": 1259.380075,
+      "composition_epochs": 1259.3804568713451
+    },
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init3",
+    "budget": "training_hours",
+    "real_value": 6.636981699868209,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 1500000,
+      "oo_n": 2004,
+      "oo_percent": 81.3373253493014,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 6.5032488311454655,
+      "estimated_matmul_training_flops": 1415910260736000000,
+      "executed_input_tokens": 3072000000,
+      "examples": 767373824,
+      "atomic_epochs": 2446.9826,
+      "composition_epochs": 2446.982894736842
+    },
+    "synthetic_above": null,
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init3",
+    "budget": "estimated_matmul_training_flops",
+    "real_value": 2775312255025967616,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 1500000,
+      "oo_n": 2004,
+      "oo_percent": 81.3373253493014,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 6.5032488311454655,
+      "estimated_matmul_training_flops": 1415910260736000000,
+      "executed_input_tokens": 3072000000,
+      "examples": 767373824,
+      "atomic_epochs": 2446.9826,
+      "composition_epochs": 2446.982894736842
+    },
+    "synthetic_above": null,
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init3",
+    "budget": "examples",
+    "real_value": 153249855,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 296000,
+      "oo_n": 2004,
+      "oo_percent": 24.10179640718563,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 1.2962222684443825,
+      "estimated_matmul_training_flops": 279406291451904000,
+      "executed_input_tokens": 606208000,
+      "examples": 151428608,
+      "atomic_epochs": 482.872525,
+      "composition_epochs": 482.8717361111111
+    },
+    "synthetic_above": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 300000,
+      "oo_n": 2004,
+      "oo_percent": 24.451097804391217,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 1.3134469647612423,
+      "estimated_matmul_training_flops": 283182052147200000,
+      "executed_input_tokens": 614400000,
+      "examples": 153474816,
+      "atomic_epochs": 489.39375,
+      "composition_epochs": 489.39717105263156
+    },
+    "extrapolated": false
+  },
+  {
+    "real_run": "confirmation-loop4x2-init3",
+    "budget": "atomic_epochs",
+    "real_value": 1255.2295203735143,
+    "synthetic_below": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 768000,
+      "oo_n": 2004,
+      "oo_percent": 70.60878243512974,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 3.328787970851279,
+      "estimated_matmul_training_flops": 724946053496832000,
+      "executed_input_tokens": 1572864000,
+      "examples": 392895488,
+      "atomic_epochs": 1252.856725,
+      "composition_epochs": 1252.855332602339
+    },
+    "synthetic_above": {
+      "dataset": "synthetic",
+      "run": "loop4x2-phi7.2-wd0.3",
+      "architecture": "loop4x2",
+      "initialization": 791101,
+      "learning_rate": 0.0001,
+      "weight_decay": 0.3,
+      "phi": 7.2,
+      "step": 772000,
+      "oo_n": 2004,
+      "oo_percent": 70.50898203592814,
+      "evaluation_scope": "fixed_full_OO_pool",
+      "training_hours": 3.3460153445280674,
+      "estimated_matmul_training_flops": 728721814192128000,
+      "executed_input_tokens": 1581056000,
+      "examples": 394941696,
+      "atomic_epochs": 1259.380075,
+      "composition_epochs": 1259.3804568713451
+    },
+    "extrapolated": false
+  }
+]

docs/development-artifacts/oo-budget-attribution-20261005/endpoints.csv

@@ -0,0 +1,18 @@
+dataset,run,architecture,initialization,learning_rate,weight_decay,phi,step,oo_n,oo_percent,evaluation_scope,training_hours,estimated_matmul_training_flops,executed_input_tokens,examples,atomic_epochs,composition_epochs
+synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1500000,2004,66.1676646706587,fixed_full_OO_pool,6.511084337063755,1415910260736000000,3072000000,767455728,1479.289375,1479.2902109440267
+synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1500000,2004,25.64870259481038,fixed_full_OO_pool,6.498463879016539,1415910260736000000,3072000000,766474080,4335.2594,4335.260994152047
+synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1500000,2004,53.293413173652695,fixed_full_OO_pool,6.48271472582904,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842
+synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1500000,2004,81.3373253493014,fixed_full_OO_pool,6.5032488311454655,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842
+synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1500000,2004,0.0,fixed_full_OO_pool,6.750595387809185,1415910260736000000,3072000000,767455728,1479.289375,1479.2902109440267
+synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1500000,2004,0.39920159680638717,fixed_full_OO_pool,6.9142334482353185,1415910260736000000,3072000000,766474080,4335.2594,4335.260994152047
+synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1500000,2004,0.19960079840319359,fixed_full_OO_pool,6.740193886749653,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842
+synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1500000,2004,0.0,fixed_full_OO_pool,6.771571062275519,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842
+real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,300000,1283,17.069368667186282,full_endpoint,6.636754266745928,2775487015724686848,6555176928,153249855,1255.2305814940578,1255.2307335934854
+real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,300000,1283,17.1473109898675,full_endpoint,6.642358209469045,2775118595566491648,6554444824,153249855,1255.2311120543293,1255.2301099410204
+real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,300000,1283,15.97817614964926,full_endpoint,6.636981699868209,2775312255025967616,6554773168,153249855,1255.2295203735143,1255.231980898416
+real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,300000,1283,16.91348402182385,full_endpoint,4.311865449844756,1651459843050610176,6555176928,153249855,1255.2305814940578,1255.2307335934854
+real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,300000,1283,17.614964925954794,full_endpoint,4.306228105037784,1651217730075777024,6554444824,153249855,1255.2311120543293,1255.2301099410204
+real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,300000,1283,16.52377240841777,full_endpoint,4.338233347138804,1651354498478928384,6554773168,153249855,1255.2295203735143,1255.231980898416
+real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,300000,1283,17.692907248636008,full_endpoint,6.723028642990523,2775487015724686848,6555176928,153249855,1255.2305814940578,1255.2307335934854
+real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,300000,1283,19.095869056897897,full_endpoint,6.7091564928398775,2775118595566491648,6554444824,153249855,1255.2311120543293,1255.2301099410204
+real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,300000,1283,16.445830085736556,full_endpoint,6.712122530073135,2775312255025967616,6554773168,153249855,1255.2295203735143,1255.231980898416

docs/development-artifacts/oo-budget-attribution-20261005/recount-audit.json

@@ -0,0 +1,619 @@
+{
+  "passed": true,
+  "raw_pools_recounted": 81,
+  "records": [
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 32000,
+      "n": 2004,
+      "correct": 0
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 64000,
+      "n": 2004,
+      "correct": 9
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 128000,
+      "n": 2004,
+      "correct": 31
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 200000,
+      "n": 2004,
+      "correct": 56
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 300000,
+      "n": 2004,
+      "correct": 84
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 500000,
+      "n": 2004,
+      "correct": 304
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 700000,
+      "n": 2004,
+      "correct": 527
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 857
+    },
+    {
+      "run": "loop4x2-phi12.6-wd0.1",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 1326
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 32000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 64000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 128000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 200000,
+      "n": 2004,
+      "correct": 11
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 300000,
+      "n": 2004,
+      "correct": 12
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 500000,
+      "n": 2004,
+      "correct": 10
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 700000,
+      "n": 2004,
+      "correct": 22
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 72
+    },
+    {
+      "run": "loop4x2-phi3.6-wd0.1",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 514
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 32000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 64000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 128000,
+      "n": 2004,
+      "correct": 14
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 200000,
+      "n": 2004,
+      "correct": 47
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 300000,
+      "n": 2004,
+      "correct": 70
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 500000,
+      "n": 2004,
+      "correct": 231
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 700000,
+      "n": 2004,
+      "correct": 426
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 689
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.1",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 1068
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 32000,
+      "n": 2004,
+      "correct": 6
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 64000,
+      "n": 2004,
+      "correct": 9
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 128000,
+      "n": 2004,
+      "correct": 94
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 200000,
+      "n": 2004,
+      "correct": 216
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 300000,
+      "n": 2004,
+      "correct": 490
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 500000,
+      "n": 2004,
+      "correct": 1028
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 700000,
+      "n": 2004,
+      "correct": 1352
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 1522
+    },
+    {
+      "run": "loop4x2-phi7.2-wd0.3",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 1630
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 32000,
+      "n": 2004,
+      "correct": 0
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 64000,
+      "n": 2004,
+      "correct": 0
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 128000,
+      "n": 2004,
+      "correct": 3
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 200000,
+      "n": 2004,
+      "correct": 3
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 300000,
+      "n": 2004,
+      "correct": 2
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 500000,
+      "n": 2004,
+      "correct": 6
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 700000,
+      "n": 2004,
+      "correct": 3
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 2
+    },
+    {
+      "run": "standard8-phi12.6-wd0.1",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 0
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 32000,
+      "n": 2004,
+      "correct": 2
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 64000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 128000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 200000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 300000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 500000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 700000,
+      "n": 2004,
+      "correct": 7
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 1
+    },
+    {
+      "run": "standard8-phi3.6-wd0.1",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 8
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 32000,
+      "n": 2004,
+      "correct": 7
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 64000,
+      "n": 2004,
+      "correct": 1
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 128000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 200000,
+      "n": 2004,
+      "correct": 2
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 300000,
+      "n": 2004,
+      "correct": 2
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 500000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 700000,
+      "n": 2004,
+      "correct": 6
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 8
+    },
+    {
+      "run": "standard8-phi7.2-wd0.1",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 32000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 64000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 128000,
+      "n": 2004,
+      "correct": 5
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 200000,
+      "n": 2004,
+      "correct": 3
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 300000,
+      "n": 2004,
+      "correct": 4
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 500000,
+      "n": 2004,
+      "correct": 3
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 700000,
+      "n": 2004,
+      "correct": 2
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 1000000,
+      "n": 2004,
+      "correct": 3
+    },
+    {
+      "run": "standard8-phi7.2-wd0.3",
+      "step": 1500000,
+      "n": 2004,
+      "correct": 0
+    },
+    {
+      "run": "confirmation-loop4x2-init1",
+      "step": 300000,
+      "n": 1283,
+      "correct": 219
+    },
+    {
+      "run": "confirmation-loop4x2-init2",
+      "step": 300000,
+      "n": 1283,
+      "correct": 220
+    },
+    {
+      "run": "confirmation-loop4x2-init3",
+      "step": 300000,
+      "n": 1283,
+      "correct": 205
+    },
+    {
+      "run": "confirmation-standard4-init1",
+      "step": 300000,
+      "n": 1283,
+      "correct": 217
+    },
+    {
+      "run": "confirmation-standard4-init2",
+      "step": 300000,
+      "n": 1283,
+      "correct": 226
+    },
+    {
+      "run": "confirmation-standard4-init3",
+      "step": 300000,
+      "n": 1283,
+      "correct": 212
+    },
+    {
+      "run": "confirmation-standard8-init1",
+      "step": 300000,
+      "n": 1283,
+      "correct": 227
+    },
+    {
+      "run": "confirmation-standard8-init2",
+      "step": 300000,
+      "n": 1283,
+      "correct": 245
+    },
+    {
+      "run": "confirmation-standard8-init3",
+      "step": 300000,
+      "n": 1283,
+      "correct": 211
+    }
+  ],
+  "sources_sha256": {
+    "results/grokking-reproduction-v1/data/complete.json": "c60b3c65e6ab889d78b2b0fa6b17cf82ee8739ce14cb2ae18897fe3b10cfda83",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/run.json": "62c593fe5dc85f6a17e5a447e1b25f6c76d0dd6a5cf612283a9185138c884f05",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/learning.json": "5ec2979a7d81bfcf71c8d009b410f06b39b9053fb1282a1a5c65e266290edcfd",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0032000-test_oo.npz": "a272fe5b30e5c251f4a2f5aa6f280fa23ffc6b1e30a38b7644a7054a48b489e2",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0064000-test_oo.npz": "c31fd027ad2284a9dd66fe4f83dd7129820b66dcfc2f3bb7f92e8c26181d7d05",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0128000-test_oo.npz": "586380b3f777488a86708aedbc8ab6922ee1f67ff7dad2f0d4116d1d3062db88",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0200000-test_oo.npz": "df645588cbd33fae6312da6817f4a3872c9085ddf15a03b48e58464d2894dedc",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0300000-test_oo.npz": "b7d6608fc66a83ecf2e86c367b7f73c985ce7c6dac42055d88289acad37340b9",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0500000-test_oo.npz": "9c9362b6e6e41d4df6ed1ca1cb7697284802bc7e06c492e8ebc6d819d2538665",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0700000-test_oo.npz": "77d9e7d41d1bb9ffecc989a2319a0470c504de2c13fbd5808edaf93f46c56977",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-1000000-test_oo.npz": "7b92d86add226d179bd0cea94740728b30d6ce9e91a3acc456de5de2d47d1845",
+    "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-1500000-test_oo.npz": "e89a82f6ff41ebd6166de73e4d90547446ef6e141e06162e47de5ba75b169ea4",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/run.json": "8b0d1ef4aa8a68cc65b3b20ba57147598618beacbc21c30c68f40a4eae4459ba",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/learning.json": "95a44a719606c3d43a8323a5813b8c22f48a0ce88cf57ee2378fef7cdcdabf01",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0032000-test_oo.npz": "e1de7070988bffe16dd420362ae3cfc30ea8858b4a878d4b5432c16cb17d5c7e",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0064000-test_oo.npz": "03a91a328e2a3d5a6d4477c3e396e6c895e0e5d633f3fcaa078f8586db2b7b92",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0128000-test_oo.npz": "b93be84721dde34cc887e68baa2851165fe4640e4ef037b054ec7eb581509419",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0200000-test_oo.npz": "d1ea80aeae192e1628932d805990e416db3f0f15a0fd3f3407398c7f1a6eaba3",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0300000-test_oo.npz": "be1d16c2703bb5790387f289734c2ccc72c9f04105214f372e866a4323783ad4",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0500000-test_oo.npz": "26b9adb9f8e08ae2e7843917622b4ed390181f208279a6dea7a2033495e28b43",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0700000-test_oo.npz": "de2ff55207351f1c0ea8cf8f73969bcf956d0055bef18cc744fcdabb5a2aed1f",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-1000000-test_oo.npz": "f99173107a99738b0a21644679de9ca147892d972b0b86d95c87b1e57f7e8283",
+    "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-1500000-test_oo.npz": "7c2adacf7e90a6e5808825cf6c546d9ad386f17ecd4a20a764403ed0de8eddf9",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/run.json": "46c6a2e5aaa17363b778072faf5f6a220a5928dbd8f2c3c4b425c939247ad369",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/learning.json": "05a659a625d60c606dd15e45c48269ff58d5e000f6c5e30eb15d43a56eb78b35",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0032000-test_oo.npz": "de9d3f81439e6f23b4cc5370b6007b63cb9958d8e67eb7c2b8e8c72d9e824790",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0064000-test_oo.npz": "ea0ce38033b2dfe1c4b92570b2432e02857e066c0936726d668170eb8453eafe",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0128000-test_oo.npz": "18542eeccca5b59390c42b3ba2c20253ce69defd29f766983c0fde8ef150bb01",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0200000-test_oo.npz": "56c805a50d43e28f31b33dfc14ff04c92e5dcbb2d711f9e2101cd88999368271",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0300000-test_oo.npz": "e02bd7345478544fd00715919490c3aad3a55db3651636055069483bd3f36a99",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0500000-test_oo.npz": "62e86937272a395a3898c539e9f9b45859c68d20e36da4e380e97d900b2f056b",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0700000-test_oo.npz": "540118de2d3ca1dffbe0588e1d0748651a8b43bd63dd361cbbb8a89b36b172d4",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-1000000-test_oo.npz": "ed60ef14b9713eeec1ec029be238eafcce14fe43224c9a9ff0cc6e807e909027",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-1500000-test_oo.npz": "7be587982acb77c4056a4192ee9ad365606e5319ec45ead3155297af39ae0db5",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/run.json": "83c0bfa5e5cb042734b29243c10f6d3faff005103a97b8180ae79da462b26504",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/learning.json": "265aa27765acb98a17db0af0e304d23436be75cf88a0cbf7f71d802eebdc431b",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0032000-test_oo.npz": "33ecea27acc46a6d5d04ff0e9ccd358e68d8e8791f0c1c1d6fa7e90a963cbd91",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0064000-test_oo.npz": "7e9d52ab94f47c790c608c07c2be756013636a7c6dab7b5d5e1fea56cdee0409",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0128000-test_oo.npz": "7f3cfae50269936f5624fa9fc61c7f9eaf120a5d4c28724980c5ddcbd9e16975",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0200000-test_oo.npz": "1cd33df3479903b85133bfca39dc5bffa27c4a64ff2130eb18346cacf7cdfb2e",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0300000-test_oo.npz": "1d28d9ad2ff6ce42b1736f1e9a41ead08cd651c06e1a28fe8c0d954a26abb023",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0500000-test_oo.npz": "f82b1dc268b63e636f589126516eb5e82be25e458e9ee360a38d51f5d12a3d30",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0700000-test_oo.npz": "89286f3fdd871f395efc7f2cce4f67b819f7b79c7279676ae3af9354c19332d4",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-1000000-test_oo.npz": "fbd8d490ae2a1c5f06cbb37a61a2f720f0f7f46d4e9c9d465049fd3490cc3099",
+    "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-1500000-test_oo.npz": "15d16f7c1f039530076abed4e86148bcad772f059a716b74d563964a7a5dbf3b",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/run.json": "c68dbd61ea91244860d35f7e852b70dcd7f9168a4fb27516c1b73e00412212b2",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/learning.json": "8e021c7007ecf13ff4ecbfc723ac7d6bc2ab00bfa6b1e75a27fcd80410df64f3",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0032000-test_oo.npz": "40edb2432dc398b082a8e65f88dc10dcc5da7a9e7668bed94eaf9157fe068b5c",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0064000-test_oo.npz": "a323ced50b1a91e4ee02b2d9d7ab7e3ea50c2e65ec615b2b6c573bdb620e21d7",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0128000-test_oo.npz": "b69f4269dd704950750deabc30f874cccf0bd59d24dd9a1a3d5835f18f85fa2a",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0200000-test_oo.npz": "632c7e40da95c37cc5573be5d93f072031ddec4fe7bc575a7e2b7eb38127c90b",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0300000-test_oo.npz": "3a826b97e142699e634a059a61e13492c1687bbd4bfb854ce18ead25a5a65276",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0500000-test_oo.npz": "f695a111d1bb4ac76e2661838e448f8ea17f0cdf9b3995c77354f0baf58206df",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0700000-test_oo.npz": "55b657ae8bbf22a42ed4bb8e18e70508ae50e2b57d647e8046a077b500c48718",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-1000000-test_oo.npz": "59d52aca1af2b394f091d50a5425af407b39aa206ccc38a03ca20dc416e019a4",
+    "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-1500000-test_oo.npz": "634f391c2efb311260dfca1c0d933aad911a7d77ac1984e253932779f4ee7169",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/run.json": "fd03256d8f10c9bbbcf2f9b42f5c0d68743992d7a025eb7b2d159b628193f372",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/learning.json": "d81a7441a5dd2d877216e50e9ea9378f9b270e282caf7b08d54b71fb9f34f8ab",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0032000-test_oo.npz": "fcfd417607ae26f26a7bc01f20090dd527e21693a097f6887bfc7af32c796d6f",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0064000-test_oo.npz": "1bf8a51b2d1cc5e3fc47fbede357bab8e0fa21e576c34b661022861408672c12",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0128000-test_oo.npz": "e0a6146778a34e97bed606a49f3059b2cfcdd5c2a59645847ce523744eb473e0",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0200000-test_oo.npz": "3a16c38a0cf7ba3f8d0a1f2ea49f6f79504d0870f4ce0a61bc21666463d67636",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0300000-test_oo.npz": "54ff1dceec1ab82fdd3d5097354ce193ec8941f66edd499e8761fc7bdbbdc065",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0500000-test_oo.npz": "c7a2404097433f8d93c2ed6c9d7d3503ea76ba447e8090ee820eec7e76846731",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0700000-test_oo.npz": "9b1135b8db8c0fd71bd5d7579a29dc0d8cf5baa77a66171f0b7eb3aeef1a14ff",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-1000000-test_oo.npz": "b9dc9ed7de4eb7a6c9018b92868c04e98a275bebfda4a8008902e94ea5737a8a",
+    "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-1500000-test_oo.npz": "f21a49a8e05bd18cf61a43960a560d73290173d5fc2da95fc5e5a012bd731121",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/run.json": "bd83c908ebd9b52a3988cf1edaa6a43f25684782b5ddeab46883ef7de7b56999",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/learning.json": "5848e79a0890de6ef91960475c86665446ffea3d651eb88c7206af6bf10a27f2",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0032000-test_oo.npz": "12980e13ef40e83a0088285ae55d964ef709979f31e932da3c0f6331940f8660",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0064000-test_oo.npz": "77e1afb758ca100d49e123cfbc4f585283eefedc26159a8d53450ba5b0ffa8ae",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0128000-test_oo.npz": "4953d8a97ecf2cfbd94722f2bd832b356bb5f823c954f41f830baeb9aac089ef",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0200000-test_oo.npz": "7d969674c5f471c58ccc1d90406f6ed05fb1fa81c6e08131d483867873970b64",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0300000-test_oo.npz": "9dd384900c93b6a9c4cb31dba52ebff30455580e156a5f2ece652735af496415",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0500000-test_oo.npz": "6b1382e0db5e70393c9d17d77212bb414cf081a998f0c54c5778c76da041c82b",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0700000-test_oo.npz": "1a11875e664200de8f035da18fc1db4972153b62b1f19a18bb9435035aaa7066",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-1000000-test_oo.npz": "9600c18eeb8c1fb5caacac92fbcfc448e7d6491e41f0a2044da5fcb1139b2e11",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-1500000-test_oo.npz": "6ce4c1071c0576a5060a7c30b4d22263fb102e6df63e3d60fa8885552c224b04",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/run.json": "b5406855d2b5c80c7346f1614b45a2a301ec470b40c0a73e0bcb0aa3ac614411",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/learning.json": "bcc0087f153515d71d6f1ff2ce51b0c14d41d054b320c959d76f27017e9be893",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0032000-test_oo.npz": "3a5eae216f217b5be7d8a91e96cc33951bc626de296b95fe8d25d24b261d9329",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0064000-test_oo.npz": "64cf49e27b8195343bfc8b16fc7629a43e135477475b747b51da2c41c49ca11a",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0128000-test_oo.npz": "f923c264b8f4e74671eeade976e76c09b34ab0a3cbc70c8d4c7758824430362d",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0200000-test_oo.npz": "492fcc96fab6011695534d98da541c9b046d81076882e51060b6e4c934f32330",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0300000-test_oo.npz": "606b09064520dc28ca0f5ad1f5de23ce0b5fd4de69ed7a63fbc4c3ab20e37376",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0500000-test_oo.npz": "7205738fa226f7cd4d4c3805c1f79f49553867c73a176dd5b83e08af39294c70",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0700000-test_oo.npz": "d81f167040fb988813ab68691de03cee5c9dcb26c40c9c070c0f41007bc77cbd",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-1000000-test_oo.npz": "af428d27a5bc0b856f49645e779a40b0636c1d0f014e8dbcba5e778d8c8e870e",
+    "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-1500000-test_oo.npz": "cc9f6258133f83436a639e33d292c0086c091e1673e61bc63f1892d36e831aad",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/run.json": "f8fd280022b2d40edc717a7c908da922c5f4e75b24b24ae87f8bcea4e68ffaca",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/learning.json": "8e045439cc66d0aad1cf20a3fc633117bcb095dacc929b43c514217cb36d1f98",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/endpoint-predictions.json": "b398a209a41b70eca35f49127131ee5e0204f1b06205e9c6cf5e19f9dfc92c26",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/endpoint.json": "96f329a5597797d5f70621138c7b46c0a346e38cdbd63d52875151969bb3a966",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/run.json": "c185f8a370caa84baf8a5ffff8c830d70ed18a8788dbfb0c39b3fccfb5d7a144",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/learning.json": "c07a77df26c6e4e9f8e3a6e229b5d8c8af7ea31e93ed984a9a9c4e521734a48d",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/endpoint-predictions.json": "6f19e925d39316f7cda5ae461047c48a881a57cb25afae2c660d248fb9766a58",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/endpoint.json": "93a5cee6e0f93a88ace0c6520af2e5a5a4a3542e7da91c4cbad1cc67d50b5f4c",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/run.json": "92acf8f03ed1e6bdb5699f248e6aef03c40596f9f817acff255b59fbf789f555",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/learning.json": "10af8613533149838027e0d64bda4d46364b0d0e1f5851fd58857425c7d4db01",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/endpoint-predictions.json": "e37fddfe344ceb3324ce1807b3d459eaee5d089445ab644a0d738ce11bb3cb59",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/endpoint.json": "bba44c72fc8a16ff140c92a70e9c74b599e5e5d941cd346e0979d2e472c0adf7",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/run.json": "e1d0f26e708cdb11884f3a73c9c5770f91dedb0f87590b7957f9d771f37b18f6",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/learning.json": "934bfe84758d069ed9b6140eb6b93767e4eac81e12e88baeb5ed6fa7f5709894",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/endpoint-predictions.json": "cbfabe574fa68fbef5ee1ce8636dda07f2c4dc05601262479d24dec38e868652",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/endpoint.json": "d2a2b1d4dea5f0f44975c60f659c98d120b8e16da8d101f34aab91d4f049ff52",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/run.json": "c14c6ffa44556abc2075d732f67f1a7ff64b41b47da3c794f3122ea277619c66",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/learning.json": "010486fd17963c46ac8493d1ac2a19ae437f33bf56540cadb6e18907996ba540",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/endpoint-predictions.json": "7b5c9bbc21b9c2adc1b9d1d3228354a0333ba9a3918abc9b74e2c17362b59b42",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/endpoint.json": "a439df47ed9a0f515f29795c234402cde7adf4f595e8462a40e8848aa4ae78c0",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/run.json": "d44315713c460614d377c9d66fb964eefc412d59bcfb03bdec9e8cc5fddb664f",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/learning.json": "d8193f28e73a49d319d3539cd6bc89e604c0a48f6ef796dd4a0c49dfd95039bc",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/endpoint-predictions.json": "4c43f61d01bfc684bc3b9af49bb15ec45819a93fd1e13b8f266f0e92826ccf25",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/endpoint.json": "88a07f66aae6e15ba2c30ebe5c9475193189a448b99d00a0ebaf6add09c9f17e",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/run.json": "c20f15d7ea290881e114e8f24f3d53798c79d1ee14a9c1d6fa72062c1bc74c7c",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/learning.json": "b0b2b1c401b896518324fa16227a1cc2072b894ca48b1569f0108b2304baa81a",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/endpoint-predictions.json": "827ae62858fcddf436b24eb331f308304c957b7c04cf4429dd9a30882a96695b",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/endpoint.json": "52b08c70b82458de76fcb3b5c94b3f7b1c1e8e5570d0e253a39a8cc1cd00cb84",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/run.json": "cd4df24357259f187c4212bfd21e55f16336dfc8182c94b21937b6940e6093ea",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/learning.json": "86b41da13c8fe6438b8a12b2645fd5b2f13051a74f5c7caab35ebc61c6a52627",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/endpoint-predictions.json": "dd2a4fca6ddb6f4a2b5763f194b1fbd8e7f40003ec4593e98e23feb2c8c45425",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/endpoint.json": "19ebb12cce35e9ee26ba7069cdd0eb59cbeda72cd94166c4a22f3a1498730642",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/run.json": "bf45cdb24a989a287f48d5d2dd40435f02756187095b6eccfd2a1e0dcbafcc36",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/learning.json": "28d1a7641e0323dbcfeaaa47cb0d78c62b7473d8c576d654b25b4038b7c93baa",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/endpoint-predictions.json": "f8ddfcafc4296554d803f6078de3472e3a4f7c31f702004ba28c15c6aae26493",
+    "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/endpoint.json": "b590152f4206e2c2106c369781907795d1114ef4061526d8a43c0b19c575f4cd"
+  }
+}