Blame for src/experiment.py

"""Reproducible, fully metered tests of reciprocal operator repair.

Run: python3 src/experiment.py --seeds 24 --budget 1500000 --rank 4
No third-party dependencies. Development seeds are disjoint from report seeds.
"""
from __future__ import annotations

import argparse
from collections import Counter
import csv
from dataclasses import asdict
import hashlib
import json
import math
from pathlib import Path
import platform
import random
import resource
import statistics
import sys
import time

from core import (BudgetExhausted, K, Mat, Meter, Problem, add,
                  boundary_candidate, differential, equal, kernel_work, mul,
                  nnz, normalize, positions, proposal, repaired_candidate,
                  semantic_certificate, valid, zero)
from domains import CoordinateMoves, from_scratch_contraction, generate


ARMS = ("recursive", "frozen", "boundary", "coordinate", "rebuild_coordinate",
        "uncoupled", "no_normalization", "no_update")


def digest(h: Mat) -> str:
    return hashlib.sha256(json.dumps(h).encode()).hexdigest()[:16]


def search(p: Problem, mode: str, budget: int, seed: int,
           external_generator: Mat | None = None, forbidden: Mat | None = None,
           initial: Mat | None = None,
           cpu_budget: float | None = None) -> tuple[Mat, dict]:
    """All arms optimize the same exact future K-work objective, nnz(h).

    Equality accepted only when it changes h: neutral moves allow drift.
    Strict improvements alone are counted as improvements. For transplant,
    a parent cannot be installed verbatim (forbidden matrix).
    A budget exception discards the incomplete proposal; the last validated
    checkpoint survives. No partial computation is installed.
    """
    rng = random.Random(seed)
    m = Meter(budget)
    h = p.h0 if initial is None else initial
    frozen = p.h0 if external_generator is None else external_generator
    stats = Counter()
    events = []
    start = time.perf_counter()
    cpu_start = time.process_time()
    best_score = sum(row.bit_count() for row in h)
    best = h
    current_score = best_score
    initial_score = best_score
    chart = None
    try:
        m.use(p.n, "setup")
        current_score = best_score = nnz(h, m)
        if not valid(p, h, m):
            raise AssertionError("Invalid supplied initial contraction")
        pos_a = positions(p, -1, m)
        pos_b = positions(p, -2, m)
        if mode in ("coordinate", "rebuild_coordinate"):
            if mode == "rebuild_coordinate":
                candidate = from_scratch_contraction(p, m)
                ok = valid(p, candidate, m)
                score = nnz(candidate, m)
                if ok and score <= best_score:
                    h = best = candidate
                    current_score = best_score = score
                    stats["rebuild_accepted"] += 1
                    events.append((m.used, score))
            chart = CoordinateMoves.build(p, h, m)
        if mode != "no_update":
            while True:
                if cpu_budget is not None and time.process_time() - cpu_start >= cpu_budget:
                    stats["cpu_interrupts"] += 1
                    break
                stats["attempts"] += 1
                m.use(12, "bookkeeping")
                if mode in ("coordinate", "rebuild_coordinate"):
                    candidate = chart.propose(h, rng, m)
                elif mode == "boundary":
                    B = proposal(p, pos_b, rng, m)
                    candidate = boundary_candidate(p, h, B, m)
                else:
                    a = proposal(p, pos_a, rng, m)
                    if mode == "uncoupled":
                        candidate = add(h, a, m)
                    elif mode == "no_normalization":
                        z = add(a, K(p, h, differential(p, a, m), m), m)
                        candidate = add(h, z, m)
                    else:
                        generator = h if mode == "recursive" else frozen
                        candidate = repaired_candidate(p, h, generator, a, m)
                ok = valid(p, candidate, m)
                stats["completed"] += 1
                if cpu_budget is not None and time.process_time() - cpu_start >= cpu_budget:
                    # Never install a candidate whose validation crosses the cap.
                    stats["cpu_interrupts"] += 1
                    break
                if not ok:
                    stats["invalid"] += 1
                    continue
                score = nnz(candidate, m)
                if forbidden is not None and equal(candidate, forbidden, m):
                    stats["parent_copy_rejected"] += 1
                    continue
                same = equal(candidate, h, m)
                if same:
                    stats["unchanged"] += 1
                    continue
                if score <= current_score:
                    h = candidate
                    if score < current_score:
                        stats["strict_accepts"] += 1
                    else:
                        stats["neutral_accepts"] += 1
                    current_score = score
                    if score < best_score:
                        best = h
                        best_score = score
                        events.append((m.used, score))
                else:
                    stats["worse_rejected"] += 1
    except BudgetExhausted:
        stats["budget_interrupts"] += 1
    result = dict(stats)
    result.update({"mode": mode, "budget": budget, "work": m.used,
                   "cpu_budget_s": cpu_budget,
                   "initial_nnz": initial_score, "final_nnz": best_score,
                   "nnz_gain": initial_score - best_score,
                   "wall_s": time.perf_counter() - start,
                   "cpu_s": time.process_time() - cpu_start,
                   "work_categories": dict(m.counts), "events": events,
                   "operator_digest": digest(best),
                   "operator_bytes": sys.getsizeof(best) +
                       sum(sys.getsizeof(row) for row in best),
                   "zero_progress": initial_score == best_score})
    return best, result


def fresh_tasks(p: Problem, seed: int, count: int = 32) -> list[Mat]:
    """Fresh exact End-repair tasks F=partial T; private T is never exposed.

    Random sparse degree-zero T; F has degree one, partial F=0, QFQ=0.
    This is a future-work/validity test, not a task-generalization benchmark:
    the chosen word-RAM cost has a known linear dependence on nnz(h).
    """
    rng = random.Random(seed)
    m = Meter()
    pos = positions(p, 0, m)
    return [differential(p, proposal(p, pos, rng, m, width=5), m)
            for _ in range(count)]


def audit(p: Problem, h: Mat, tasks: list[Mat]) -> dict:
    km = Meter()
    vm = Meter()
    failures = 0
    cross_failures = 0
    start = time.perf_counter()
    for f in tasks:
        repair = K(p, h, f, km)
        if not equal(differential(p, repair, vm), f, vm):
            failures += 1
        no_cross = K(p, h, f, vm, cross=False)
        if not equal(differential(p, no_cross, vm), f, vm):
            cross_failures += 1
    return {"tasks": len(tasks), "task_failures": failures,
            "cross_ablation_failures": cross_failures,
            "kernel_work": km.used,
            "audit_work": vm.used,
            "audit_wall_s": time.perf_counter() - start}


def interval(values: list[float]) -> dict:
    mean = statistics.mean(values)
    sd = statistics.stdev(values) if len(values) > 1 else 0.0
    # Descriptive normal interval; no claim that small-sample tails are Gaussian.
    return {"mean": mean, "sd": sd,
            "mean_ci95_normal": [mean - 1.96 * sd / math.sqrt(len(values)),
                                 mean + 1.96 * sd / math.sqrt(len(values))],
            "min": min(values), "max": max(values)}


def summarize(records: list[dict]) -> dict:
    out = {}
    for arm in sorted({r["arm"] for r in records}):
        rows = [r for r in records if r["arm"] == arm]
        out[arm] = {key: interval([float(r.get(key, 0)) for r in rows])
                    for key in ("nnz_gain", "final_nnz", "kernel_work", "work",
                                "cpu_s", "wall_s", "completed", "invalid",
                                "strict_accepts", "operator_bytes",
                                "task_failures", "cross_ablation_failures")}
        out[arm]["zero_progress_count"] = sum(r["zero_progress"] for r in rows)
        out[arm]["n"] = len(rows)
    return out


def run(args) -> dict:
    records = []
    descendants = []
    outdir = Path(args.output)
    outdir.mkdir(parents=True, exist_ok=True)
    run_start = time.perf_counter()
    for offset in range(args.seeds):
        seed = args.seed_start + offset
        p = generate(seed, rank=args.rank, homology=1,
                     grades_count=4, scramble=args.scramble)
        tasks = fresh_tasks(p, seed * 100000 + 31001)
        outputs = {}
        parent_record = None
        for arm in ARMS:
            h, row = search(p, arm, args.budget, seed * 100000 + 10001,
                            cpu_budget=args.cpu_budget)
            outputs[arm] = h
            row.update({"seed": seed, "arm": arm, "n": p.n})
            row.update(audit(p, h, tasks))
            records.append(row)
            if arm == "recursive":
                parent_record = row
        # Parent -> fresh discovery -> descendant-only fresh repair audit.
        # Every child starts at h0. The parent is available ONLY to the proposal
        # generator; its exact matrix cannot be installed as the child.
        parent = outputs["recursive"]
        child_tasks = fresh_tasks(p, seed * 100000 + 61001)
        for label, generator in (("learned_parent", parent),
                                 ("initial_parent", p.h0)):
            h, row = search(p, "frozen", args.child_budget,
                            seed * 100000 + 41001,
                            external_generator=generator, forbidden=parent,
                            cpu_budget=None if args.cpu_budget is None else args.cpu_budget / 2)
            row.update({"seed": seed, "arm": label, "n": p.n,
                        "parent_digest": digest(parent),
                        "parent_training_work": parent_record["work"] if label == "learned_parent" else 0,
                        "parent_training_cpu_s": parent_record["cpu_s"] if label == "learned_parent" else 0,
                        "total_work_including_parent": row["work"] +
                            (parent_record["work"] if label == "learned_parent" else 0),
                        "total_cpu_including_parent_s": row["cpu_s"] +
                            (parent_record["cpu_s"] if label == "learned_parent" else 0)})
            row.update(audit(p, h, child_tasks))
            descendants.append(row)
        # Resource-inclusive controls can spend the parent's cost on discovery.
        for label, mode in (("initial_parent_full_budget", "frozen"),
                            ("coordinate_full_budget", "coordinate"),
                            ("rebuild_full_budget", "rebuild_coordinate")):
            h, row = search(p, mode, args.budget + args.child_budget,
                            seed * 100000 + 41001, forbidden=parent,
                            cpu_budget=None if args.cpu_budget is None else 1.5 * args.cpu_budget)
            row.update({"seed": seed, "arm": label, "n": p.n,
                        "parent_training_work": 0,
                        "total_work_including_parent": row["work"]})
            row.update(audit(p, h, child_tasks))
            descendants.append(row)
        print(json.dumps({"seed": seed, "progress": offset + 1,
                          "initial_nnz": sum(x.bit_count() for x in p.h0),
                          "final_nnz": {a: sum(x.bit_count() for x in h)
                                        for a, h in outputs.items()}}), flush=True)
        # Checkpoint the reproducible observations; never use them to tune.
        (outdir / "raw_checkpoint.json").write_text(json.dumps(
            {"records": records, "descendants": descendants}, indent=2))

    paired = {}
    by_seed = {(r["seed"], r["arm"]): r for r in records}
    for other in ("frozen", "boundary", "coordinate", "rebuild_coordinate"):
        # Positive means recursive has lower held-out kernel cost.
        vals = [by_seed[(s, other)]["kernel_work"] -
                by_seed[(s, "recursive")]["kernel_work"]
                for s in range(args.seed_start, args.seed_start + args.seeds)]
        paired["recursive_vs_" + other] = interval(vals)
    child_by = {(r["seed"], r["arm"]): r for r in descendants}
    vals = [child_by[(s, "initial_parent")]["kernel_work"] -
            child_by[(s, "learned_parent")]["kernel_work"]
            for s in range(args.seed_start, args.seed_start + args.seeds)]
    paired["descendant_transplant"] = interval(vals)
    results = {"config": vars(args), "platform": platform.platform(),
               "python": sys.version, "total_wall_s": time.perf_counter() - run_start,
               "process_peak_rss_kib": resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,
               "meter_model": "n<=64 word RAM; matrix mul=2n+6*nnz(left); xor=2n; "
                              "fixed scan, RNG and control charges; see source",
               "summary": summarize(records), "descendant_summary": summarize(descendants),
               "paired_differences": paired,
               "records": records, "descendants": descendants}
    (outdir / "results.json").write_text(json.dumps(results, indent=2))
    for filename, rows in (("runs.csv", records), ("descendants.csv", descendants)):
        simple = [{k: v for k, v in row.items() if not isinstance(v, (dict, list))}
                  for row in rows]
        keys = sorted(set().union(*(set(row) for row in simple)))
        with (outdir / filename).open("w", newline="") as f:
            writer = csv.DictWriter(f, fieldnames=keys)
            writer.writeheader()
            writer.writerows(simple)
    print(json.dumps({"finished": True, "total_wall_s": results["total_wall_s"],
                      "results": str(outdir / 'results.json')}), flush=True)
    return results


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--seeds", type=int, default=24)
    parser.add_argument("--seed-start", type=int, default=1000)
    parser.add_argument("--budget", type=int, default=1500000)
    parser.add_argument("--child-budget", type=int, default=750000)
    parser.add_argument("--rank", type=int, default=4)
    parser.add_argument("--scramble", type=int, default=16)
    parser.add_argument("--output", default="results/main")
    parser.add_argument("--cpu-budget", type=float, default=None)
    run(parser.parse_args())