Datasets:

PureOne
/

Echo-Mirror-RSI

#!/usr/bin/env python3
"""Echo-Mirror: finite-dimensional recursive response-preservation experiments.
This program tests exact simulation of linear edit maps and adaptive selection
from their linear span. It does not demonstrate autonomous recursive
self-improvement, LLM improvement, or a computational advantage over classical
observability reduction. The classical baseline is intentionally equivalent.
Reproduce:
    OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python run_experiments.py \
        --output ../results --seeds 32
Requires Python 3.10+ and NumPy. Every seed and test protocol is fixed by Config.
"""
from __future__ import annotations

import argparse
import csv
import hashlib
import json
import math
import os
import platform
import sys
import time
from dataclasses import asdict, dataclass
from pathlib import Path

import numpy as np


@dataclass(frozen=True)
class Config:
    ambient_dimension: int = 64
    coarse_rank: int = 4
    response_rank: int = 4
    invariant_rank: int = 16
    library_size: int = 3
    sequences_per_seed: int = 16
    horizon: int = 24
    adaptive_candidates: int = 9
    seeds: int = 32
    seed_offset: int = 20261108
    rank_tolerance: float = 1e-11
    diagnostic_tolerance: float = 1e-10


METHODS = (
    "full_state",
    "wave_only",
    "immediate_echo",
    "random_echo_matched_rank",
    "recursive_echo",
    "classical_observable_quotient",
)


def haar_matrix(n: int) -> np.ndarray:
    """Orthonormal Haar analysis matrix; rows ordered coarse to fine."""
    if n < 1 or n & (n - 1):
        raise ValueError("Haar dimension must be a positive power of two")
    h = np.array([[1.0]])
    size = 1
    while size < n:
        h = np.vstack((np.kron(h, [1.0, 1.0]),
                       np.kron(np.eye(size), [1.0, -1.0]))) / math.sqrt(2.0)
        size *= 2
    return h


def row_basis(matrix: np.ndarray, tol: float = 1e-11) -> np.ndarray:
    """Orthonormal row basis, with a recorded relative numerical rank rule."""
    if matrix.shape[0] == 0:
        return np.empty((0, matrix.shape[1]))
    _, s, vh = np.linalg.svd(matrix, full_matrices=False)
    rank = int(np.count_nonzero(s > tol * max(float(s[0]), 1.0)))
    return vh[:rank]


def invariant_row_closure(initial: np.ndarray, maps: np.ndarray,
                          tol: float = 1e-11) -> tuple[np.ndarray, list[int]]:
    """Smallest row space W containing initial with W T_i subset W.
    Stabilization of dimension is sufficient because every step is an
    inclusion. This is the usual finite observability/Krylov closure.
    """
    q = row_basis(initial, tol)
    trace = [int(q.shape[0])]
    for _ in range(maps.shape[-1] + 1):
        new = row_basis(np.vstack([q, *(q @ t for t in maps)]), tol)
        trace.append(int(new.shape[0]))
        if new.shape[0] == q.shape[0]:
            return new, trace
        q = new
    raise RuntimeError("Closure did not stabilize in the finite-dimensional bound")


def rotation(theta: float) -> np.ndarray:
    return np.array([[math.cos(theta), -math.sin(theta)],
                     [math.sin(theta), math.cos(theta)]])


def make_system(seed: int, cfg: Config) -> dict[str, np.ndarray]:
    """Structured stress test, constructed independently of evaluation seeds.
    In latent wave coordinates the first 16 coordinates form an observable
    upper-triangular chain; the remaining 48 coordinates cannot affect it.
    A seed-specific rotation mixes detail coefficients but leaves the first
    four coarse Haar coordinates fixed. The low observability rank is imposed
    by construction, not an empirical discovery about natural tasks.
    """
    rng = np.random.default_rng(cfg.seed_offset + 1000 * seed)
    d, m, r = cfg.ambient_dimension, cfg.coarse_rank, cfg.invariant_rank
    h = haar_matrix(d)
    detail, _ = np.linalg.qr(rng.normal(size=(d - m, d - m)))
    u = np.eye(d)
    u[m:, m:] = detail
    transform = u @ h

    params = ((0.68, 0.26, 0.30), (0.70, 0.24, -0.50),
              (0.72, 0.22, 0.90))
    latent_maps = []
    for index, (diagonal, coupling, angle) in enumerate(params):
        a = np.zeros((d, d))
        a[:r, :r] = diagonal * np.eye(r)
        for block in range(r // 2 - 1):
            a[2 * block:2 * block + 2,
              2 * block + 2:2 * block + 4] = coupling * rotation(angle)
        nuisance, _ = np.linalg.qr(rng.normal(size=(d - r, d - r)))
        a[r:, r:] = (0.80 + 0.02 * index) * nuisance
        # Top-right block is zero. Bottom-left need not be zero for the
        # quotient theorem, but is zero here to keep the stress test simple.
        latent_maps.append(a)
    latent_maps = np.asarray(latent_maps)
    maps = np.asarray([transform.T @ a @ transform for a in latent_maps])
    p = h[:m]
    output_selector = np.eye(d)[[0, 1, 4, 5]]
    j = output_selector @ transform
    return {"maps": maps, "P": p, "J": j,
            "transform": transform, "latent_maps": latent_maps}


def make_views(system: dict[str, np.ndarray], seed: int, cfg: Config):
    p, j, maps = system["P"], system["J"], system["maps"]
    timings = {}
    start = time.perf_counter()
    immediate = row_basis(np.vstack((p, j)), cfg.rank_tolerance)
    timings["immediate_echo"] = time.perf_counter() - start
    start = time.perf_counter()
    recursive, trace = invariant_row_closure(np.vstack((p, j)), maps,
                                              cfg.rank_tolerance)
    timings["recursive_echo"] = time.perf_counter() - start
    start = time.perf_counter()
    classical, classical_trace = invariant_row_closure(j, maps,
                                                       cfg.rank_tolerance)
    timings["classical_observable_quotient"] = time.perf_counter() - start
    rng = np.random.default_rng(cfg.seed_offset + 1000 * seed + 17)
    start = time.perf_counter()
    extra = rng.normal(size=(recursive.shape[0] - immediate.shape[0],
                             cfg.ambient_dimension))
    extra -= (extra @ immediate.T) @ immediate
    random_echo = row_basis(np.vstack((immediate, extra)), cfg.rank_tolerance)
    timings["random_echo_matched_rank"] = time.perf_counter() - start
    views = {
        "full_state": np.eye(cfg.ambient_dimension),
        "wave_only": p,
        "immediate_echo": immediate,
        "random_echo_matched_rank": random_echo,
        "recursive_echo": recursive,
        "classical_observable_quotient": classical,
    }
    traces = {"recursive_echo": trace,
              "classical_observable_quotient": classical_trace}
    return views, timings, traces


def residuals(q: np.ndarray, j: np.ndarray, maps: np.ndarray) -> dict[str, float]:
    projection = q.T @ q
    complement = np.eye(q.shape[1]) - projection
    return {
        "response_factorization_frobenius": float(np.linalg.norm(j @ complement)),
        "invariance_frobenius_max": float(max(
            np.linalg.norm(q @ t @ complement) for t in maps)),
        "orthonormality_frobenius": float(np.linalg.norm(q @ q.T - np.eye(len(q)))),
    }


def summarize_errors(predicted: np.ndarray, truth: np.ndarray) -> dict[str, float]:
    difference = predicted - truth
    sum_error = float(np.sum(difference ** 2))
    sum_truth = float(np.sum(truth ** 2))
    final_error = float(np.sum(difference[-1] ** 2))
    final_truth = float(np.sum(truth[-1] ** 2))
    return {
        "rms_absolute_error": float(np.sqrt(np.mean(difference ** 2))),
        "max_absolute_error": float(np.max(np.abs(difference))),
        "relative_trajectory_error": math.sqrt(sum_error / max(sum_truth, 1e-300)),
        "relative_final_error": math.sqrt(final_error / max(final_truth, 1e-300)),
        "initial_max_absolute_error": float(np.max(np.abs(difference[0]))),
        "squared_error": sum_error,
        "squared_reference": sum_truth,
    }


def run_open_loop(system, views, seed, cfg):
    rng = np.random.default_rng(cfg.seed_offset + 1000 * seed + 101)
    d, n = cfg.ambient_dimension, cfg.sequences_per_seed
    # Evaluation states and edit mixtures are never used to construct bases.
    initial = rng.normal(size=(n, d)) / math.sqrt(d)
    weights = rng.dirichlet(np.ones(cfg.library_size), size=(cfg.horizon, n))
    trajectories = {}
    for name, q in views.items():
        state = initial @ q.T
        output = system["J"] @ q.T
        reduced_maps = np.asarray([q @ t @ q.T for t in system["maps"]])
        recorded = [state @ output.T]
        for step in range(cfg.horizon):
            next_state = np.zeros_like(state)
            for k, t in enumerate(reduced_maps):
                next_state += weights[step, :, k, None] * (state @ t.T)
            state = next_state
            recorded.append(state @ output.T)
        trajectories[name] = np.asarray(recorded)
    truth = trajectories["full_state"]
    records = []
    for name in METHODS:
        row = {"seed": seed, "mode": "held_out_open_loop", "method": name,
               "retained_coordinates": views[name].shape[0]}
        row.update(summarize_errors(trajectories[name], truth))
        row.update({"action_disagreement_fraction": 0.0,
                    "shadow_relative_trajectory_error": row["relative_trajectory_error"],
                    "shadow_final_response_energy_ratio": 1.0})
        records.append(row)
    return records, trajectories


def run_adaptive(system, views, seed, cfg):
    rng = np.random.default_rng(cfg.seed_offset + 1000 * seed + 211)
    initial = rng.normal(size=(cfg.sequences_per_seed, cfg.ambient_dimension))
    initial /= math.sqrt(cfg.ambient_dimension)
    # Held-out candidate operators are positive mixtures of the training
    # library, hence inside the certified span. They are not used for closure.
    weights = rng.dirichlet(np.ones(cfg.library_size),
                            size=cfg.adaptive_candidates)
    candidates = np.einsum("ci,ijk->cjk", weights, system["maps"])
    trajectories, shadows, actions = {}, {}, {}
    for name, q in views.items():
        state = initial @ q.T
        shadow = initial.copy()
        output = system["J"] @ q.T
        reduced_maps = np.asarray([q @ t @ q.T for t in candidates])
        recorded = [state @ output.T]
        shadow_recorded = [shadow @ system["J"].T]
        selected = []
        for _ in range(cfg.horizon):
            next_candidates = np.asarray([state @ t.T for t in reduced_maps])
            next_outputs = np.einsum("cnr,pr->cnp", next_candidates, output)
            costs = np.sum(next_outputs ** 2, axis=2)
            chosen = np.argmin(costs, axis=0)
            state = next_candidates[chosen, np.arange(len(state))]
            # Every selected policy is also executed on uncompressed full
            # state. Inaccurate predicted improvements are therefore exposed.
            shadow = np.einsum("nij,nj->ni", candidates[chosen], shadow)
            recorded.append(state @ output.T)
            shadow_recorded.append(shadow @ system["J"].T)
            selected.append(chosen)
        trajectories[name] = np.asarray(recorded)
        shadows[name] = np.asarray(shadow_recorded)
        actions[name] = np.asarray(selected)
    truth = trajectories["full_state"]
    records = []
    for name in METHODS:
        row = {"seed": seed, "mode": "adaptive_closed_loop", "method": name,
               "retained_coordinates": views[name].shape[0]}
        row.update(summarize_errors(trajectories[name], truth))
        shadow_error = summarize_errors(trajectories[name], shadows[name])
        row.update({
            "action_disagreement_fraction": float(np.mean(
                actions[name] != actions["full_state"])),
            "shadow_relative_trajectory_error": shadow_error["relative_trajectory_error"],
            "shadow_final_response_energy_ratio": float(
                np.sum(shadows[name][-1] ** 2) /
                max(float(np.sum(truth[-1] ** 2)), 1e-300)),
        })
        records.append(row)
    return records, trajectories, shadows, actions


def counterexamples(cfg: Config) -> dict:
    """Exact rational constructions, plus a numerical mirror of the examples."""
    # Three-dimensional shift example needs no random matrices or tolerances.
    p = np.array([[1.0, 0.0, 0.0]])
    j = p.copy()
    t = np.array([[1.0, 1.0, 0.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]])
    x, y = np.zeros(3), np.array([0.0, 0.0, 1.0])
    output_pairs = []
    for step in range(4):
        output_pairs.append({"step": step, "first_output": float((j @ x)[0]),
                             "second_output": float((j @ y)[0])})
        x, y = t @ x, t @ y
    q, trace = invariant_row_closure(np.vstack((p, j)), np.asarray([t]))

    system = make_system(0, cfg)
    views, _, _ = make_views(system, 0, cfg)
    q16 = views["recursive_echo"]
    # A new map outside the certified library span reads discarded coordinate
    # 16 directly into response 0. No all-words certificate covers this map.
    bad_latent = system["latent_maps"][0].copy()
    bad_latent[0, cfg.invariant_rank] = 0.25
    transform = system["transform"]
    bad_map = transform.T @ bad_latent @ transform
    discarded = transform.T @ np.eye(cfg.ambient_dimension)[cfg.invariant_rank]
    full = system["J"] @ bad_map @ discarded
    reduced = system["J"] @ q16.T @ (q16 @ bad_map @ q16.T) @ q16 @ discarded
    enlarged_maps = np.concatenate((system["maps"], bad_map[None]), axis=0)
    renewed, renewed_trace = invariant_row_closure(q16, enlarged_maps,
                                                  cfg.rank_tolerance)
    renewed_response = (system["J"] @ renewed.T @
                        (renewed @ bad_map @ renewed.T) @ renewed @ discarded)
    return {
        "current_equal_future_different": {
            "P": p.tolist(), "J": j.tolist(), "T": t.tolist(),
            "x": [0.0, 0.0, 0.0], "y": [0.0, 0.0, 1.0],
            "outputs": output_pairs, "closure_rank_trace": trace,
            "minimal_recursive_coordinates": int(q.shape[0]),
            "interpretation": "Same current response and same one-step response, different two-step response.",
        },
        "outside_certified_span": {
            "new_map_added_entry": [0, cfg.invariant_rank, 0.25],
            "full_next_response": full.tolist(),
            "compressed_next_response": reduced.tolist(),
            "absolute_response_error": float(np.linalg.norm(full - reduced)),
            "renewed_closure_rank_trace": renewed_trace,
            "renewed_retained_coordinates": int(renewed.shape[0]),
            "renewed_absolute_response_error": float(np.linalg.norm(full - renewed_response)),
            "interpretation": "Expected failure after a previously unmodelled edit reads a discarded direction.",
        },
    }


def structural_checks(cfg: Config) -> list[dict]:
    checks = []
    h = haar_matrix(cfg.ambient_dimension)
    err = float(np.linalg.norm(h @ h.T - np.eye(len(h))))
    assert err < cfg.diagnostic_tolerance
    checks.append({"name": "Haar orthonormality", "passed": True, "error": err})
    system = make_system(0, cfg)
    views, _, traces = make_views(system, 0, cfg)
    assert views["wave_only"].shape[0] == 4
    assert views["immediate_echo"].shape[0] == 6
    assert views["recursive_echo"].shape[0] == cfg.invariant_rank
    assert views["random_echo_matched_rank"].shape[0] == cfg.invariant_rank
    checks.append({"name": "Designed coarse, immediate, recursive ranks",
                   "passed": True, "ranks": [4, 6, cfg.invariant_rank],
                   "trace": traces["recursive_echo"]})
    for name in ("recursive_echo", "classical_observable_quotient"):
        res = residuals(views[name], system["J"], system["maps"])
        assert max(res.values()) < cfg.diagnostic_tolerance
        checks.append({"name": name + " factorization and invariance",
                       "passed": True, **res})
    qa, qb = views["recursive_echo"], views["classical_observable_quotient"]
    projector_error = float(np.linalg.norm(qa.T @ qa - qb.T @ qb))
    assert projector_error < cfg.diagnostic_tolerance
    checks.append({"name": "Classical quotient equivalence", "passed": True,
                   "projector_error": projector_error})
    examples = counterexamples(cfg)
    equal = examples["current_equal_future_different"]
    assert equal["outputs"][0]["second_output"] == 0
    assert equal["outputs"][1]["second_output"] == 0
    assert equal["outputs"][2]["second_output"] == 1
    assert abs(examples["outside_certified_span"]["absolute_response_error"] - 0.25) < 1e-12
    assert examples["outside_certified_span"]["renewed_retained_coordinates"] == cfg.ambient_dimension
    assert examples["outside_certified_span"]["renewed_absolute_response_error"] < cfg.diagnostic_tolerance
    checks.append({"name": "Analytic blind-pair and new-map failures", "passed": True})
    return checks


def grouped_summary(rows: list[dict]) -> list[dict]:
    result = []
    metrics = ("relative_trajectory_error", "rms_absolute_error",
               "max_absolute_error", "relative_final_error",
               "action_disagreement_fraction", "shadow_relative_trajectory_error",
               "shadow_final_response_energy_ratio")
    for mode in ("held_out_open_loop", "adaptive_closed_loop"):
        for method in METHODS:
            selected = [r for r in rows if r["mode"] == mode and r["method"] == method]
            stats = {"mode": mode, "method": method, "number_of_seeds": len(selected),
                     "retained_coordinates": selected[0]["retained_coordinates"]}
            for metric in metrics:
                values = np.asarray([r[metric] for r in selected])
                stats[metric + "_mean"] = float(values.mean())
                stats[metric + "_min"] = float(values.min())
                stats[metric + "_max"] = float(values.max())
                stats[metric + "_standard_deviation"] = float(values.std(ddof=1)) if len(values) > 1 else 0.0
            stats["pooled_relative_trajectory_error"] = math.sqrt(
                sum(r["squared_error"] for r in selected) /
                max(sum(r["squared_reference"] for r in selected), 1e-300))
            result.append(stats)
    return result


def storage_counts(cfg: Config) -> list[dict]:
    ranks = dict(zip(METHODS, (64, 4, 6, 16, 16, 16)))
    rows = []
    for name, r in ranks.items():
        basis = 0 if name == "full_state" else cfg.ambient_dimension * r
        operators = cfg.library_size * r * r
        readout = cfg.response_rank * r
        rows.append({
            "method": name, "state_scalars": r,
            "basis_scalars": basis, "library_operator_scalars": operators,
            "readout_scalars": readout,
            "total_persistent_dense_scalars_one_state": basis + operators + readout + r,
            "state_bytes_float64": 8 * r,
            "note": "Dense executable representation; construction/evaluation workspace excluded. Full identity basis stored implicitly in this count.",
        })
    return rows


def microbenchmark(cfg: Config) -> dict:
    """Small-array throughput only; explicitly excludes basis construction.
    Fixed linear updates on a batch test quotient arithmetic, not training or
    LLM execution speed. Timings are hardware-dependent descriptive values.
    """
    system = make_system(0, cfg)
    views, _, _ = make_views(system, 0, cfg)
    rng = np.random.default_rng(cfg.seed_offset + 991)
    initial = rng.normal(size=(128, cfg.ambient_dimension))
    results = {}
    steps, repeats = 160, 5
    for name in ("full_state", "recursive_echo"):
        q = views[name]
        t = q @ system["maps"][0] @ q.T
        start_state = initial @ q.T
        durations = []
        checksum = 0.0
        for _ in range(repeats):
            state = start_state.copy()
            start = time.perf_counter()
            for _ in range(steps):
                state = state @ t.T
            durations.append(time.perf_counter() - start)
            checksum = float(np.sum(state))
        results[name] = {"seconds_median": float(np.median(durations)),
                         "seconds_all": durations, "checksum": checksum}
    return {"batch_states": 128, "steps": steps, "repeats": repeats,
            "results": results,
            "caveat": "Arithmetic microbenchmark only. Excludes closure and Jacobian/operator construction, transfer, evaluation, basis storage, and model training. No end-to-end speed claim."}


def write_csv(path: Path, records: list[dict]):
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(records[0]))
        writer.writeheader()
        writer.writerows(records)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output", type=Path, default=Path(__file__).resolve().parent.parent / "results")
    parser.add_argument("--seeds", type=int, default=32)
    parser.add_argument("--self-test", action="store_true", help="Run structural checks only")
    args = parser.parse_args()
    if args.seeds < 1:
        parser.error("--seeds must be positive")
    cfg = Config(seeds=args.seeds)
    checks = structural_checks(cfg)
    if args.self_test:
        print(json.dumps({"checks": checks}, indent=2))
        return
    args.output.mkdir(parents=True, exist_ok=True)
    start_all = time.perf_counter()
    records, diagnostics, closure_records, timings = [], [], [], []
    example_trajectories = {}
    for seed in range(cfg.seeds):
        system = make_system(seed, cfg)
        views, elapsed, traces = make_views(system, seed, cfg)
        for name, q in views.items():
            diagnostics.append({"seed": seed, "method": name,
                                "retained_coordinates": int(q.shape[0]),
                                **residuals(q, system["J"], system["maps"])})
        for name, trace in traces.items():
            closure_records.append({"seed": seed, "method": name, "rank_trace": trace})
        for name, duration in elapsed.items():
            timings.append({"seed": seed, "method": name, "seconds": duration})
        open_records, open_trajectories = run_open_loop(system, views, seed, cfg)
        adaptive_records, adaptive_trajectories, shadows, actions = run_adaptive(system, views, seed, cfg)
        records.extend(open_records + adaptive_records)
        for row in open_records + adaptive_records:
            if row["method"] in ("recursive_echo", "classical_observable_quotient"):
                assert row["max_absolute_error"] < cfg.diagnostic_tolerance, row
                assert row["action_disagreement_fraction"] == 0.0, row
        if seed == 0:
            for name in METHODS:
                example_trajectories["open_" + name] = open_trajectories[name]
                example_trajectories["adaptive_" + name] = adaptive_trajectories[name]
                example_trajectories["shadow_" + name] = shadows[name]
                example_trajectories["actions_" + name] = actions[name]
    elapsed_all = time.perf_counter() - start_all
    summary_rows = grouped_summary(records)
    summary = {
        "experiment": "Finite-dimensional recursive response preservation",
        "status": "Executed synthetic mechanism test; not an autonomous RSI or LLM benchmark",
        "config": asdict(cfg),
        "protocol": {
            "construction_seeds": "seed_offset + 1000 * seed; seed=0,...,seeds-1",
            "random_echo_seeds": "construction seed + 17",
            "open_loop_evaluation_seeds": "construction seed + 101",
            "adaptive_evaluation_seeds": "construction seed + 211",
            "basis_access": "Full P, J, and the three edit matrices; never evaluation states, mixtures, or paths.",
            "scope_of_held_out": "New states, continuous mixtures, and composition sequences within the certified edit span; not new natural task families.",
            "designed_structure": "Observable invariant rank 16 in ambient dimension 64 is imposed by construction.",
            "adaptive_policy": "Greedy argmin of squared predicted next response among 9 held-out convex mixtures. Every compressed policy also executes on a full-state shadow.",
            "no_post_test_tuning": "Configuration fixed in this script. No method selection or parameter fitting uses evaluation outcomes.",
        },
        "environment": {"python": sys.version, "numpy": np.__version__,
                        "platform": platform.platform(),
                        "OPENBLAS_NUM_THREADS": os.environ.get("OPENBLAS_NUM_THREADS"),
                        "OMP_NUM_THREADS": os.environ.get("OMP_NUM_THREADS")},
        "source_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
        "structural_checks": checks,
        "execution_seconds_excluding_microbenchmark": elapsed_all,
        "results": summary_rows,
        "storage": storage_counts(cfg),
        "closure_traces": closure_records,
        "closure_timings": timings,
        "counterexamples": counterexamples(cfg),
        "microbenchmark": microbenchmark(cfg),
        "interpretation_limits": [
            "The row-space closure is classical observability/finite realization algebra, not a new linear algebra theorem.",
            "The recursive_echo and classical_observable_quotient baselines recover the same subspace and are expected to agree.",
            "Preserving a recursive computation is distinct from proving that computation improves its own learning algorithm.",
            "The prototype does not implement a Waldhausen S-construction or claim that a categorical label causes computational gains.",
            "No LLM training, natural task transfer, general RSI, unbounded compounding, or independent replication was performed.",
            "Dense operators, readouts, and bases are supplied; no cost-free access to real-model Jacobians is assumed.",
            "Response-invisible coordinates may become relevant after an edit outside the certified operator span; the explicit counterexample tests this failure.",
        ],
    }
    write_csv(args.output / "per_seed_metrics.csv", records)
    write_csv(args.output / "aggregate_metrics.csv", summary_rows)
    write_csv(args.output / "algebraic_diagnostics.csv", diagnostics)
    write_csv(args.output / "closure_timings.csv", timings)
    (args.output / "summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    np.savez_compressed(args.output / "seed0_trajectories.npz", **example_trajectories)
    print(json.dumps({"output": str(args.output.resolve()), "seeds": cfg.seeds,
                      "seconds": elapsed_all,
                      "summary": [{"mode": r["mode"], "method": r["method"],
                                   "rank": r["retained_coordinates"],
                                   "pooled_relative_error": r["pooled_relative_trajectory_error"],
                                   "action_disagreement_mean": r["action_disagreement_fraction_mean"]}
                                  for r in summary_rows]}, indent=2))


if __name__ == "__main__":
    main()