Datasets:

PureOne
/

Nemoriu-Research

"""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())

	"""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())