results: test SDIL on measured physical surrogate

6 files changed, 3218 insertions, 0 deletions

diff --git a/TWO_STATE_BIAS_PROGRAM.md b/TWO_STATE_BIAS_PROGRAM.md
index 1020b11..c7a238f 100644
--- a/TWO_STATE_BIAS_PROGRAM.md
+++ b/TWO_STATE_BIAS_PROGRAM.md
@@ -297,6 +297,14 @@ Stop this paper direction if:
   `30/50/80/100 mV` before the observed gate plateaus; see
   `results/physical_bias/p0_state_dependence.json`. This establishes a measured
   locally predictable component suitable for P1, not an SDIL learning result.
+- Physical P1 measured-surrogate development: mixed. With the same upfront
+  neutral observations, frozen affine SDIL beats frozen constant calibration
+  at all seven switching periods and removes essentially the complete modeled
+  raw-to-oracle gap. Online constant recalibration also reaches the oracle but
+  uses `240--6000` further neutral observations. The ideal leading-order
+  overclamping analogue reaches zero error without neutral observations and
+  beats SDIL everywhere. Therefore the mechanism test passes, but the physical
+  strong-baseline gate does not; see `results/physical_bias/p1_surrogate.json`.
 - Dual Prop same-path confirmation: active/supporting, not a passed result.
 - EP/CpL adapters: not implemented under this bias model.
 - Current score for this new paper framing: 5/10 until P1 passes.
diff --git a/experiments/physical_bias_p1.py b/experiments/physical_bias_p1.py
new file mode 100644
index 0000000..9f605c2
--- /dev/null
+++ b/experiments/physical_bias_p1.py
@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""P1: test SDIL on the measured-state-dependent two-edge surrogate."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from sdil.physical_coupled import (  # noqa: E402
+    Circuit,
+    LocalAffineBias,
+    LocalPredictor,
+    Task,
+    calibrate_predictor,
+    simulate_alternating_tasks,
+)
+
+
+METHODS = (
+    "raw",
+    "same_rms_noise",
+    "frozen_constant",
+    "frozen_sdil",
+    "online_constant",
+    "overclamp",
+    "oracle",
+)
+
+LABELS = {
+    "raw": "structured bias",
+    "same_rms_noise": "same-RMS noise",
+    "frozen_constant": "constant calibration",
+    "frozen_sdil": "SDIL",
+    "online_constant": "online recalibration",
+    "overclamp": "overclamp analogue",
+    "oracle": "oracle subtraction",
+}
+
+COLORS = {
+    "raw": "#CC3311",
+    "same_rms_noise": "#BBBBBB",
+    "frozen_constant": "#EE7733",
+    "frozen_sdil": "#0077BB",
+    "online_constant": "#AA4499",
+    "overclamp": "#228833",
+    "oracle": "#000000",
+}
+
+
+def load_pair(source: dict, name: str, strength: float) -> dict:
+    record = source["pairs"][name]
+    reference = np.asarray(record["reference_gate"], dtype=float)
+    affine = record["local_affine_model"]
+    field = LocalAffineBias(
+        reference_gate=reference,
+        bias_at_reference=np.asarray(
+            affine["bias_at_reference_v_per_s"], dtype=float),
+        local_slopes=np.asarray(affine["local_slopes_per_s"], dtype=float),
+    )
+    states = []
+    for trace in record["traces"]:
+        states.append(np.column_stack((
+            trace["retained_gate_minus"], trace["retained_gate_plus"])))
+    states = np.vstack(states)
+    feature_scale = np.maximum(np.ptp(states, axis=0), 0.25)
+    circuit = Circuit()
+    beta_label = 0.14 if name == "experiment_1" else 0.18
+    tasks = (
+        Task("alpha", circuit.high, 0.31),
+        Task("beta", circuit.low, beta_label),
+    )
+    measurement = lambda gates: field(gates, strength)  # noqa: E731
+    constant = LocalPredictor.zeros(reference, feature_scale, affine=False)
+    sdil = LocalPredictor.zeros(reference, feature_scale, affine=True)
+    calibration = {
+        "epochs": 30,
+        "learning_rate": 0.2,
+        "states": int(len(states)),
+    }
+    calibration["neutral_observations_each"] = calibrate_predictor(
+        constant, states, measurement,
+        epochs=calibration["epochs"],
+        learning_rate=calibration["learning_rate"],
+    )
+    sdil_count = calibrate_predictor(
+        sdil, states, measurement,
+        epochs=calibration["epochs"],
+        learning_rate=calibration["learning_rate"],
+    )
+    if sdil_count != calibration["neutral_observations_each"]:
+        raise AssertionError("calibration observation budgets disagree")
+    bias_samples = np.asarray([measurement(state) for state in states])
+    calibration["constant_rmse"] = float(np.sqrt(np.mean([
+        np.mean((measurement(state) - constant.predict(state)) ** 2)
+        for state in states
+    ])))
+    calibration["sdil_rmse"] = float(np.sqrt(np.mean([
+        np.mean((measurement(state) - sdil.predict(state)) ** 2)
+        for state in states
+    ])))
+    calibration["constant_coefficients"] = constant.coefficients.tolist()
+    calibration["sdil_coefficients"] = sdil.coefficients.tolist()
+    return {
+        "field": field,
+        "states": states,
+        "circuit": circuit,
+        "tasks": tasks,
+        "constant": constant,
+        "sdil": sdil,
+        "noise_std": np.sqrt(np.mean(bias_samples * bias_samples, axis=0)),
+        "calibration": calibration,
+    }
+
+
+def run_method(
+    pair: dict,
+    method: str,
+    period: float,
+    cycles: int,
+    initial_gates: np.ndarray,
+    strength: float,
+    seed: int,
+) -> dict:
+    predictor = None
+    if method in {"frozen_constant", "online_constant"}:
+        predictor = pair["constant"]
+    elif method == "frozen_sdil":
+        predictor = pair["sdil"]
+    return simulate_alternating_tasks(
+        pair["circuit"],
+        pair["tasks"],
+        pair["field"],
+        method=method,
+        period_seconds=period,
+        cycles=cycles,
+        initial_gates=initial_gates,
+        bias_strength=strength,
+        predictor=predictor,
+        online_predictor_rate=0.05,
+        noise_standard_deviation=pair["noise_std"],
+        seed=seed,
+    )
+
+
+def plot_report(report: dict, output: Path) -> None:
+    fig, axes = plt.subplots(2, 2, figsize=(9.2, 7.0), sharex="col")
+    for column, name in enumerate(("experiment_1", "experiment_2")):
+        records = report["pairs"][name]["period_sweep"]
+        for method in METHODS:
+            selected = [record for record in records if record["method"] == method]
+            period = np.asarray([record["period_seconds"] for record in selected])
+            error = np.asarray([record["mean_combined_error"] for record in selected])
+            span = np.asarray([record["mean_cycle_span"] for record in selected])
+            axes[0, column].loglog(
+                period, error, "o-", color=COLORS[method],
+                linewidth=1.3, markersize=3.5, label=LABELS[method])
+            axes[1, column].loglog(
+                period, np.maximum(span, 1e-12), "o-", color=COLORS[method],
+                linewidth=1.3, markersize=3.5, label=LABELS[method])
+        axes[0, column].set_title(
+            f"{chr(ord('A') + column)}  {name.replace('_', ' ')}: error floor")
+        axes[0, column].set_ylabel("combined task error")
+        axes[1, column].set_title(
+            f"{chr(ord('C') + column)}  {name.replace('_', ' ')}: cycle span")
+        axes[1, column].set_xlabel("task-switching period (s)")
+        axes[1, column].set_ylabel("gate-space cycle span (V)")
+        for row in range(2):
+            axes[row, column].grid(alpha=0.18)
+    axes[0, 0].legend(frameon=False, fontsize=7, ncol=2)
+    fig.suptitle(
+        "Measured-state-dependent two-edge surrogate: frozen local SDIL",
+        fontsize=11)
+    fig.tight_layout()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(output, dpi=180)
+    plt.close(fig)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--state-dependence-json", type=Path,
+        default=Path("results/physical_bias/p0_state_dependence.json"))
+    parser.add_argument(
+        "--output", type=Path,
+        default=Path("results/physical_bias/p1_surrogate.json"))
+    parser.add_argument(
+        "--figure", type=Path,
+        default=Path("results/figs/physical_bias_p1_surrogate.png"))
+    parser.add_argument("--minimum-cycles", type=int, default=120)
+    parser.add_argument("--total-nominal-time", type=float, default=6.0)
+    parser.add_argument(
+        "--periods", type=float, nargs="+",
+        default=(0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2))
+    parser.add_argument("--bias-strength", type=float, default=1.0)
+    parser.add_argument("--seed", type=int, default=20260806)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    source = json.loads(args.state_dependence_json.read_text())
+    report = {
+        "analysis": "physical_measured_state_dependent_surrogate_p1",
+        "confirmatory": False,
+        "physical_hardware_demonstration": False,
+        "autodiff_used": False,
+        "source_analysis": str(args.state_dependence_json),
+        "protocol": {
+            "minimum_cycles": args.minimum_cycles,
+            "total_nominal_time_seconds": args.total_nominal_time,
+            "periods_seconds": args.periods,
+            "bias_strength": args.bias_strength,
+            "initial_gates": [4.0, 4.0],
+            "methods": METHODS,
+            "overclamp_scope": (
+                "leading-order Appendix-F analogue; not the published classification endpoint"
+            ),
+        },
+        "pairs": {},
+    }
+    initial_gates = np.asarray(report["protocol"]["initial_gates"], dtype=float)
+    for pair_index, name in enumerate(("experiment_1", "experiment_2")):
+        pair = load_pair(source, name, args.bias_strength)
+        period_records = []
+        for period in args.periods:
+            cycles = max(
+                args.minimum_cycles,
+                int(np.ceil(args.total_nominal_time / period)),
+            )
+            for method_index, method in enumerate(METHODS):
+                period_records.append(run_method(
+                    pair, method, period, cycles, initial_gates,
+                    args.bias_strength,
+                    args.seed + 1000 * pair_index + 10 * method_index,
+                ))
+        by_method = {
+            method: [record for record in period_records if record["method"] == method]
+            for method in METHODS
+        }
+        sdil_error = np.asarray([
+            record["mean_combined_error"] for record in by_method["frozen_sdil"]])
+        constant_error = np.asarray([
+            record["mean_combined_error"] for record in by_method["frozen_constant"]])
+        raw_error = np.asarray([
+            record["mean_combined_error"] for record in by_method["raw"]])
+        oracle_error = np.asarray([
+            record["mean_combined_error"] for record in by_method["oracle"]])
+        valid_gap = raw_error > oracle_error + 1e-16
+        gap_closed = (
+            (raw_error[valid_gap] - sdil_error[valid_gap])
+            / (raw_error[valid_gap] - oracle_error[valid_gap])
+        )
+        overclamp_error = np.asarray([
+            record["mean_combined_error"] for record in by_method["overclamp"]])
+        report["pairs"][name] = {
+            "calibration": pair["calibration"],
+            "noise_standard_deviation_v_per_s": pair["noise_std"].tolist(),
+            "period_sweep": period_records,
+            "summary": {
+                "sdil_beats_frozen_constant_all_periods": bool(np.all(
+                    sdil_error < constant_error)),
+                "median_raw_to_oracle_gap_closed_by_sdil": (
+                    None if len(gap_closed) == 0 else float(np.median(gap_closed))),
+                "overclamp_beats_sdil_all_periods": bool(np.all(
+                    overclamp_error < sdil_error)),
+                "online_constant_neutral_observations_by_period": [
+                    int(record["neutral_observations_during_learning"])
+                    for record in by_method["online_constant"]
+                ],
+                "frozen_sdil_neutral_observations_by_period": [
+                    int(record["neutral_observations_during_learning"])
+                    for record in by_method["frozen_sdil"]
+                ],
+            },
+        }
+    report["summary"] = {
+        "sdil_beats_frozen_constant_both_pairs": bool(all(
+            record["summary"]["sdil_beats_frozen_constant_all_periods"]
+            for record in report["pairs"].values()
+        )),
+        "median_gap_closed_by_pair": {
+            name: record["summary"]["median_raw_to_oracle_gap_closed_by_sdil"]
+            for name, record in report["pairs"].items()
+        },
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2) + "\n")
+    plot_report(report, args.figure)
+    print(json.dumps(report["summary"], indent=2))
+    print(f"wrote {args.output}")
+    print(f"wrote {args.figure}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/results/figs/physical_bias_p1_surrogate.png b/results/figs/physical_bias_p1_surrogate.png
new file mode 100644
index 0000000..6888aa9
--- /dev/null
+++ b/results/figs/physical_bias_p1_surrogate.png
diff --git a/results/figs/physical_bias_p1_surrogate_caption.md b/results/figs/physical_bias_p1_surrogate_caption.md
new file mode 100644
index 0000000..7174c0b
--- /dev/null
+++ b/results/figs/physical_bias_p1_surrogate_caption.md
@@ -0,0 +1,14 @@
+**Development result on a measured-state-dependent two-edge surrogate.** A--B,
+combined task error after matching at least 6 s of nominal training time across
+switching periods. C--D, corresponding gate-space cycle span. The local affine
+bias fields are inferred from the released Dillavou et al. drift traces; they
+are not independent hardware measurements. Frozen constant calibration and
+SDIL receive the same 660/2040 neutral observations in the two task pairs,
+respectively, before learning. SDIL removes essentially the entire modeled
+raw-to-oracle gap and beats frozen constant calibration at every period. A
+constant estimator can also reach oracle performance when allowed another
+240--6000 online neutral observations per run. Most importantly, the ideal
+leading-order overclamping analogue reaches zero error without neutral
+observations and beats SDIL throughout. Thus this result verifies the local
+mechanism and observation tradeoff but does not pass the physical strong-
+baseline gate or demonstrate correction on hardware.
diff --git a/results/physical_bias/p1_surrogate.json b/results/physical_bias/p1_surrogate.json
new file mode 100644
index 0000000..538aca1
--- /dev/null
+++ b/results/physical_bias/p1_surrogate.json
@@ -0,0 +1,2734 @@
+{
+  "analysis": "physical_measured_state_dependent_surrogate_p1",
+  "confirmatory": false,
+  "physical_hardware_demonstration": false,
+  "autodiff_used": false,
+  "source_analysis": "results/physical_bias/p0_state_dependence.json",
+  "protocol": {
+    "minimum_cycles": 120,
+    "total_nominal_time_seconds": 6.0,
+    "periods_seconds": [
+      0.002,
+      0.005,
+      0.01,
+      0.02,
+      0.05,
+      0.1,
+      0.2
+    ],
+    "bias_strength": 1.0,
+    "initial_gates": [
+      4.0,
+      4.0
+    ],
+    "methods": [
+      "raw",
+      "same_rms_noise",
+      "frozen_constant",
+      "frozen_sdil",
+      "online_constant",
+      "overclamp",
+      "oracle"
+    ],
+    "overclamp_scope": "leading-order Appendix-F analogue; not the published classification endpoint"
+  },
+  "pairs": {
+    "experiment_1": {
+      "calibration": {
+        "epochs": 30,
+        "learning_rate": 0.2,
+        "states": 22,
+        "neutral_observations_each": 660,
+        "constant_rmse": 0.6092862026373747,
+        "sdil_rmse": 0.00022387993784781475,
+        "constant_coefficients": [
+          [
+            2.680657432007967
+          ],
+          [
+            5.076732410928136
+          ]
+        ],
+        "sdil_coefficients": [
+          [
+            2.6533297670019302,
+            1.8846356629906003
+          ],
+          [
+            4.543569954617925,
+            1.2256020448180966
+          ]
+        ]
+      },
+      "noise_standard_deviation_v_per_s": [
+        3.069815200619905,
+        4.678340465344394
+      ],
+      "period_sweep": [
+        {
+          "method": "raw",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.8092950610197422,
+            2.7801625927089715
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00010132868475959094,
+          "std_combined_error": 1.3552527156068805e-20,
+          "mean_cycle_span": 0.012124201610815623,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4348008741467715,
+            2.3914423248582395
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.8492752386031335e-08,
+          "std_combined_error": 2.8226404709445005e-08,
+          "mean_cycle_span": 0.001980552372751122,
+          "std_cycle_span": 0.0010148528512669655,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.3483393122116025,
+            2.296572194967358
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.153264153456787e-06,
+          "std_combined_error": 8.470329472543003e-22,
+          "mean_cycle_span": 0.0032048623473235746,
+          "std_cycle_span": 4.336808689942018e-19,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314547564137823,
+            2.387155458484078
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.357314677519754e-12,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 1.3508054197714377e-06,
+          "std_cycle_span": 2.117582368135751e-22,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892734493,
+            2.387197231833999
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.140770454804554e-30,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 3.1401849173675502e-15,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 6000,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.1636571024018956
+            ],
+            [
+              3.844278964067793
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733636,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.031753401590313146,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892734493,
+            2.387197231833999
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.140770454804554e-30,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 3.1401849173675502e-15,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.8157189778542713,
+            2.7745905776153856
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00010199355355150576,
+          "std_combined_error": 1.3552527156068805e-20,
+          "mean_cycle_span": 0.029105116820791088,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.443926854020796,
+            2.4076596115844797
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.4181655343656334e-07,
+          "std_combined_error": 7.224475537035746e-08,
+          "mean_cycle_span": 0.0027930688106144923,
+          "std_cycle_span": 0.0012869103694595587,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.346707000455192,
+            2.2981034295135827
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.214734003252294e-06,
+          "std_combined_error": 8.470329472543003e-22,
+          "mean_cycle_span": 0.007692475077109321,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431454123493791,
+            2.387156147013957
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.3673238256676707e-12,
+          "std_combined_error": 2.0194839173657902e-28,
+          "mean_cycle_span": 3.2419331160020885e-06,
+          "std_cycle_span": 4.235164736271502e-22,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487889273448,
+            2.3871972318339947
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.61942121885893e-30,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 7.536443801682121e-15,
+          "std_cycle_span": 1.5777218104420236e-30,
+          "neutral_observations_during_learning": 2400,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.163657102401891
+            ],
+            [
+              3.8442789640677892
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487889273364,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.03175469628805606,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487889273448,
+            2.3871972318339947
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.61942121885893e-30,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 7.536443801682121e-15,
+          "std_cycle_span": 1.5777218104420236e-30,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.829137596724204,
+            2.765695325601806
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00010468365735072873,
+          "std_combined_error": 1.3552527156068805e-20,
+          "mean_cycle_span": 0.06069482777522618,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4348145889966357,
+            2.3907868242683947
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 8.028745097576818e-08,
+          "std_combined_error": 6.12766613433568e-08,
+          "mean_cycle_span": 0.004359354310386148,
+          "std_cycle_span": 0.002949089530150418,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.3433128217321104,
+            2.3005860749982743
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.463848041630655e-06,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.016032761228693466,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.43145280599553,
+            2.3871572783847346
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.4078218456206076e-12,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 6.754028213225775e-06,
+          "std_cycle_span": 8.470329472543003e-22,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733254,
+            2.387197231833879
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 8.397054557528348e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 1200,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.1636571024017908
+            ],
+            [
+              3.8442789640677173
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733636,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.03175859291984668,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733875,
+            2.3871972318339405
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.888609052210118e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.86041773979248,
+            2.7537847011829983
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00011521059490045322,
+          "std_combined_error": 1.3552527156068805e-20,
+          "mean_cycle_span": 0.12184926735735116,
+          "std_cycle_span": 1.3877787807814457e-17,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.43486212016216,
+            2.390381459087656
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.7506885005100094e-07,
+          "std_combined_error": 1.3600797927093883e-07,
+          "mean_cycle_span": 0.006769875807616741,
+          "std_cycle_span": 0.0034511326501450923,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.335463918674156,
+            2.3040622548784158
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 8.444831514408495e-06,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.03211797946499549,
+          "std_cycle_span": 6.938893903907228e-18,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431449760564751,
+            2.387158923466784
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5663008198711989e-12,
+          "std_combined_error": 2.0194839173657902e-28,
+          "mean_cycle_span": 1.3508063288864665e-05,
+          "std_cycle_span": 3.3881317890172014e-21,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487889273368,
+            2.3871972318338974
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 8.829618423037722e-31,
+          "std_combined_error": 6.368804265876902e-32,
+          "mean_cycle_span": 8.881784197001253e-17,
+          "std_cycle_span": 3.8714799753065e-16,
+          "neutral_observations_during_learning": 600,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.163657102401808
+            ],
+            [
+              3.844278964067742
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487889273363,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.03176676920855227,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733875,
+            2.3871972318339405
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.888609052210118e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.997349031378711,
+            2.7560615550386856
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00019054762008641855,
+          "std_combined_error": 9.244675222610997e-16,
+          "mean_cycle_span": 0.3125016255415446,
+          "std_cycle_span": 8.400902749285477e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.437208185576708,
+            2.39142169352168
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.9515584814923498e-07,
+          "std_combined_error": 1.7634282210639652e-07,
+          "mean_cycle_span": 0.010388750288987723,
+          "std_cycle_span": 0.005462496446466231,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.3018625017984506,
+            2.3049553752688
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.573409373032438e-05,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.08117759729854893,
+          "std_cycle_span": 1.3877787807814457e-17,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431436893766853,
+            2.3871599934589325
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.69962879231075e-12,
+          "std_combined_error": 4.0389678347315804e-28,
+          "mean_cycle_span": 3.377027255632158e-05,
+          "std_cycle_span": 6.776263578034403e-21,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487614311821,
+            2.3871970285098962
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.69473107681078e-15,
+          "std_combined_error": 1.9675422661411047e-15,
+          "mean_cycle_span": 7.375974614382561e-07,
+          "std_cycle_span": 4.723544418725612e-07,
+          "neutral_observations_during_learning": 240,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.163656688805505
+            ],
+            [
+              3.8442822176345444
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487889273363,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.03177473827091023,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733875,
+            2.3871972318339405
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.888609052210118e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.364095082798542,
+            2.863858140999168
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00047738371762902387,
+          "std_combined_error": 5.421010862427522e-20,
+          "mean_cycle_span": 0.678341055788438,
+          "std_cycle_span": 1.1102230246251565e-16,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.415853646830911,
+            2.383944446107968
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.284170183249626e-07,
+          "std_combined_error": 3.663912605977088e-07,
+          "mean_cycle_span": 0.01645254240734324,
+          "std_cycle_span": 0.006714250532846139,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.217657716584461,
+            2.2817475250102337
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 4.6960587863687746e-05,
+          "std_combined_error": 6.776263578034403e-21,
+          "mean_cycle_span": 0.16783822717153069,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314062868891466,
+            2.387152306257588
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.962180538140995e-12,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 6.754123450716741e-05,
+          "std_cycle_span": 1.3552527156068805e-20,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431487732570713,
+            2.387197118645531
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.0402571186271138e-15,
+          "std_combined_error": 1.2382518634320076e-15,
+          "mean_cycle_span": 7.024009057970519e-07,
+          "std_cycle_span": 4.631954102213817e-07,
+          "neutral_observations_during_learning": 240,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.1636558358249895
+            ],
+            [
+              3.844281524644432
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733636,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.03177520231889655,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733875,
+            2.3871972318339405
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.888609052210118e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            4.690236335935761,
+            3.3986961942246574
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.0018000468460461258,
+          "std_combined_error": 6.268050226983288e-17,
+          "mean_cycle_span": 1.78741571052108,
+          "std_cycle_span": 4.8714886040487515e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.452310046781332,
+            2.3945189106070064
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.453687156062093e-07,
+          "std_combined_error": 6.680922284342304e-07,
+          "mean_cycle_span": 0.0249177070035543,
+          "std_cycle_span": 0.011391443518562177,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            1.9862402321993025,
+            2.190959339656071
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.0002306141403267977,
+          "std_combined_error": 2.710505431213761e-20,
+          "mean_cycle_span": 0.36609667263607126,
+          "std_cycle_span": 5.551115123125783e-17,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.680657432007967
+            ],
+            [
+              5.076732410928136
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.431331914351697,
+            2.3871234133188963
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.483834916974681e-11,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0001350861087249672,
+          "std_cycle_span": 2.710505431213761e-20,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.6533297670019302,
+              1.8846356629906003
+            ],
+            [
+              4.543569954617925,
+              1.2256020448180966
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314879320244738,
+            2.387197210808737
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.255565466427137e-16,
+          "std_combined_error": 2.5702906872208766e-16,
+          "mean_cycle_span": 4.1624257419200855e-07,
+          "std_cycle_span": 2.5507665702156565e-07,
+          "neutral_observations_during_learning": 240,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              2.1636552501266073
+            ],
+            [
+              3.8442809550164565
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733636,
+            2.3871972318339174
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.274080905458301e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.03177520526850427,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.4314878892733875,
+            2.3871972318339405
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.888609052210118e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        }
+      ],
+      "summary": {
+        "sdil_beats_frozen_constant_all_periods": true,
+        "median_raw_to_oracle_gap_closed_by_sdil": 0.9999999864048891,
+        "overclamp_beats_sdil_all_periods": true,
+        "online_constant_neutral_observations_by_period": [
+          6000,
+          2400,
+          1200,
+          600,
+          240,
+          240,
+          240
+        ],
+        "frozen_sdil_neutral_observations_by_period": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      }
+    },
+    "experiment_2": {
+      "calibration": {
+        "epochs": 30,
+        "learning_rate": 0.2,
+        "states": 68,
+        "neutral_observations_each": 2040,
+        "constant_rmse": 0.3335551554014055,
+        "sdil_rmse": 2.192388102797653e-06,
+        "constant_coefficients": [
+          [
+            -0.33502087152139154
+          ],
+          [
+            1.996528756755168
+          ]
+        ],
+        "sdil_coefficients": [
+          [
+            -0.2839866529869272,
+            1.4140559020638932
+          ],
+          [
+            2.0992982944920144,
+            -0.1862355096516429
+          ]
+        ]
+      },
+      "noise_standard_deviation_v_per_s": [
+        0.4218300293576763,
+        2.0616027304234703
+      ],
+      "period_sweep": [
+        {
+          "method": "raw",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.176531959717122,
+            3.9390092336660687
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.957371367511765e-05,
+          "std_combined_error": 2.767656425223995e-15,
+          "mean_cycle_span": 0.005070816704448247,
+          "std_cycle_span": 4.1053612840121085e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.966230900449063,
+            3.6329395631130024
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.309315045502897e-09,
+          "std_combined_error": 1.6826583274247304e-09,
+          "mean_cycle_span": 0.0006750258186158052,
+          "std_cycle_span": 0.0006049739423524212,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.979065145785647,
+            3.654103430880535
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.3538567866487397e-07,
+          "std_combined_error": 5.762675161018651e-18,
+          "mean_cycle_span": 0.0004005873201374974,
+          "std_cycle_span": 1.0896774870155784e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533383368455,
+            3.6303166883990974
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 9.628573830176422e-19,
+          "std_combined_error": 2.2483300014744642e-24,
+          "mean_cycle_span": 1.1520884141532123e-09,
+          "std_cycle_span": 1.486414608333225e-15,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936661133,
+            3.630316742082591
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.931269832241446e-28,
+          "std_combined_error": 4.197039051139412e-29,
+          "mean_cycle_span": 2.52478247881128e-14,
+          "std_cycle_span": 1.1733564156075178e-15,
+          "neutral_observations_during_learning": 6000,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.4096138759565473
+            ],
+            [
+              2.213187313789102
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.01413443259744131,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.002,
+          "cycles": 3000,
+          "half_steps": 5,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964253393666265,
+            3.630316742082775
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 5.262216557415797e-28,
+          "std_combined_error": 5.594464262246296e-29,
+          "mean_cycle_span": 2.922397051978476e-14,
+          "std_cycle_span": 1.610423795018914e-15,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.1792619353532885,
+            3.936756053914711
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.9646470671690832e-05,
+          "std_combined_error": 1.6888927163362493e-14,
+          "mean_cycle_span": 0.012171175618583796,
+          "std_cycle_span": 5.989147116649013e-12,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9700354721887097,
+            3.6370679415086054
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.4462136678271593e-08,
+          "std_combined_error": 8.309248298984371e-09,
+          "mean_cycle_span": 0.001582775700256443,
+          "std_cycle_span": 0.0008049379867913901,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9792691518821868,
+            3.6539143712803246
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.3588613108188043e-07,
+          "std_combined_error": 4.350849321850363e-17,
+          "mean_cycle_span": 0.0009614752233830148,
+          "std_cycle_span": 1.972728586978365e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533376238918,
+            3.630316688802258
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 9.669779508030872e-19,
+          "std_combined_error": 1.856395820837115e-23,
+          "mean_cycle_span": 2.7648542667100643e-09,
+          "std_cycle_span": 2.7958509530774352e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964253393667424,
+            3.630316742084126
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.89364054277892e-27,
+          "std_combined_error": 7.369116159769359e-28,
+          "mean_cycle_span": 1.6343894148704521e-13,
+          "std_cycle_span": 2.094557663874815e-14,
+          "neutral_observations_during_learning": 2400,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.40961387595487614
+            ],
+            [
+              2.2131873137887244
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.01398740069769411,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.005,
+          "cycles": 1200,
+          "half_steps": 12,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936685473,
+            3.6303167420854257
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.367176174770757e-27,
+          "std_combined_error": 1.5925201331071837e-27,
+          "mean_cycle_span": 2.416855484135761e-13,
+          "std_cycle_span": 3.0289709200763395e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 5.7600000000033065,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.1848610835073123,
+            3.933175774521425
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.9940803657707882e-05,
+          "std_combined_error": 1.969022990071133e-14,
+          "mean_cycle_span": 0.025366845329081584,
+          "std_cycle_span": 1.432983327119186e-11,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9662902295955997,
+            3.6327888368612915
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 5.422781795471078e-09,
+          "std_combined_error": 4.521418008163007e-09,
+          "mean_cycle_span": 0.0017510872536162798,
+          "std_cycle_span": 0.000908326551390631,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9796882348645752,
+            3.6536091927695766
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.3791142522237858e-07,
+          "std_combined_error": 4.5378679236239257e-17,
+          "mean_cycle_span": 0.002003625870996928,
+          "std_cycle_span": 4.2131266342481465e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533361817702,
+            3.6303166894187515
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 9.841438267223092e-19,
+          "std_combined_error": 1.820369867746918e-23,
+          "mean_cycle_span": 5.76035992722468e-09,
+          "std_cycle_span": 5.644789281414016e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936655098,
+            3.6303167420818547
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.2621972854320462e-28,
+          "std_combined_error": 6.715716366905685e-29,
+          "mean_cycle_span": 6.882162419836761e-14,
+          "std_cycle_span": 1.8664261041976768e-14,
+          "neutral_observations_during_learning": 1200,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.40961387595692217
+            ],
+            [
+              2.2131873137891827
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.013987476025233779,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.01,
+          "cycles": 600,
+          "half_steps": 25,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964253393666416,
+            3.6303167420828686
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.4843898779267577e-27,
+          "std_combined_error": 7.561051799375225e-28,
+          "mean_cycle_span": 2.352362569495467e-13,
+          "std_cycle_span": 6.119277922394014e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.1975697969457184,
+            3.928478949922958
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.1091928677703137e-05,
+          "std_combined_error": 7.408420918385458e-14,
+          "mean_cycle_span": 0.05081326173431949,
+          "std_cycle_span": 1.0189414300386609e-10,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.966382328890066,
+            3.6327744115680476
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.620024496179272e-08,
+          "std_combined_error": 1.546368000002186e-08,
+          "mean_cycle_span": 0.0024337779581857124,
+          "std_cycle_span": 0.0012269652618947826,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9806413447254876,
+            3.6531888857104304
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.458437241513648e-07,
+          "std_combined_error": 2.054432720285989e-16,
+          "mean_cycle_span": 0.004011547784602845,
+          "std_cycle_span": 3.565009874503914e-12,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533330081595,
+            3.6303166901572124
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.0508008569722728e-18,
+          "std_combined_error": 8.687113950617191e-23,
+          "mean_cycle_span": 1.1520155201956403e-08,
+          "std_cycle_span": 5.016834562953646e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936655973,
+            3.630316742081905
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 4.922919219840778e-28,
+          "std_combined_error": 4.272260719650653e-28,
+          "mean_cycle_span": 2.4006870467148263e-13,
+          "std_cycle_span": 1.0959565513441156e-13,
+          "neutral_observations_during_learning": 600,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.4096138759572491
+            ],
+            [
+              2.2131873137892812
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.01398797679940297,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.02,
+          "cycles": 300,
+          "half_steps": 50,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936669624,
+            3.6303167420833438
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 9.871444814590853e-27,
+          "std_combined_error": 9.299414080521215e-27,
+          "mean_cycle_span": 1.0836956880419996e-12,
+          "std_cycle_span": 5.450016010478752e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.250950849312841,
+            3.9310464437485537
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.93110837511962e-05,
+          "std_combined_error": 3.0687604349048204e-12,
+          "mean_cycle_span": 0.12840654696041115,
+          "std_cycle_span": 7.615564138367519e-09,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.966860681643815,
+            3.632687706921391
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5137351959154617e-08,
+          "std_combined_error": 1.3223270145000082e-08,
+          "mean_cycle_span": 0.003492894585600989,
+          "std_cycle_span": 0.0017844315068364142,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9846492965900473,
+            3.6531987886779493
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.029886103778275e-07,
+          "std_combined_error": 1.970328054838896e-14,
+          "mean_cycle_span": 0.010102835203733236,
+          "std_cycle_span": 5.825192133491712e-10,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533204425123,
+            3.630316688957864
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5147217416747773e-18,
+          "std_combined_error": 1.0173963506700801e-20,
+          "mean_cycle_span": 2.8707525774118444e-08,
+          "std_cycle_span": 1.008211211346341e-10,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533232749066,
+            3.630316745461578
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 7.627832375710677e-17,
+          "std_combined_error": 8.907999183187963e-17,
+          "mean_cycle_span": 9.340505301936189e-08,
+          "std_cycle_span": 7.0279956013451e-08,
+          "neutral_observations_during_learning": 240,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.40961218298891705
+            ],
+            [
+              2.213185887579869
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.01398819495276491,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.05,
+          "cycles": 120,
+          "half_steps": 125,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964253393681474,
+            3.630316742095593
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.549258815097925e-23,
+          "std_combined_error": 6.209461805765814e-23,
+          "mean_cycle_span": 1.0367440195878089e-10,
+          "std_cycle_span": 1.0965298829349936e-10,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 6.000000000003813,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.3882768221995287,
+            3.9847125473836953
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.065163347074931e-05,
+          "std_combined_error": 7.11544194994956e-16,
+          "mean_cycle_span": 0.2661768713085517,
+          "std_cycle_span": 1.7761504262354212e-12,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964751067934781,
+            3.621874878697866
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.84718500823959e-08,
+          "std_combined_error": 1.4277851709520875e-08,
+          "mean_cycle_span": 0.006844039282168616,
+          "std_cycle_span": 0.003189052088983512,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9948827337270805,
+            3.656967588425128
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 4.2783429730822625e-07,
+          "std_combined_error": 1.249236399827717e-18,
+          "mean_cycle_span": 0.020703809998703283,
+          "std_cycle_span": 3.397826570547046e-14,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964253290923972,
+            3.630316677267772
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 3.2820004315345595e-18,
+          "std_combined_error": 1.4267738435327517e-25,
+          "mean_cycle_span": 5.760577929980747e-08,
+          "std_cycle_span": 1.2105734719707505e-15,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.96425338685285,
+            3.630316785982766
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 4.2695914896844e-17,
+          "std_combined_error": 4.438713773983293e-17,
+          "mean_cycle_span": 1.1348019564361219e-07,
+          "std_cycle_span": 6.109442246241253e-08,
+          "neutral_observations_during_learning": 240,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.4096124585637328
+            ],
+            [
+              2.213185988465957
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.01398819591109883,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.1,
+          "cycles": 120,
+          "half_steps": 250,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936652082,
+            3.6303167420815114
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 9.506390205495396e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 11.99999999999871,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "raw",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.8237890439877713,
+            4.2322590657718075
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 0.00020745009918461807,
+          "std_combined_error": 1.3414351419184588e-16,
+          "mean_cycle_span": 0.6003387233585882,
+          "std_cycle_span": 2.345558964216802e-13,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "same_rms_noise",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964099481543456,
+            3.6319122591676485
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 2.206579663654022e-08,
+          "std_combined_error": 2.2474838335593827e-08,
+          "mean_cycle_span": 0.007024101768689795,
+          "std_cycle_span": 0.00310757766930167,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "frozen_constant",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            3.025804072284264,
+            3.6743278033788007
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5706092974008448e-06,
+          "std_combined_error": 9.215762501224779e-20,
+          "mean_cycle_span": 0.04480377417319827,
+          "std_cycle_span": 1.1877108307227618e-15,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.33502087152139154
+            ],
+            [
+              1.996528756755168
+            ]
+          ]
+        },
+        {
+          "method": "frozen_sdil",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642532144996294,
+            3.630316633618741
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.076305364663816e-17,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 1.1521161904577788e-07,
+          "std_cycle_span": 2.6469779601696886e-23,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.2839866529869272,
+              1.4140559020638932
+            ],
+            [
+              2.0992982944920144,
+              -0.1862355096516429
+            ]
+          ]
+        },
+        {
+          "method": "online_constant",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.964253404793115,
+            3.6303167944322667
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 6.331430267398849e-17,
+          "std_combined_error": 6.545416707926297e-17,
+          "mean_cycle_span": 2.3644399541514118e-07,
+          "std_cycle_span": 1.3174095406631684e-07,
+          "neutral_observations_during_learning": 240,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": [
+            [
+              -0.4096124578308895
+            ],
+            [
+              2.2131859838848285
+            ]
+          ]
+        },
+        {
+          "method": "overclamp",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936651647,
+            3.630316742081457
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 1.5792625543975334e-32,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 0.013988195910677756,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        },
+        {
+          "method": "oracle",
+          "period_seconds": 0.2,
+          "cycles": 120,
+          "half_steps": 500,
+          "initial_gates": [
+            4.0,
+            4.0
+          ],
+          "final_gates": [
+            2.9642533936652082,
+            3.6303167420815114
+          ],
+          "bias_strength": 1.0,
+          "mean_combined_error": 9.506390205495396e-31,
+          "std_combined_error": 0.0,
+          "mean_cycle_span": 0.0,
+          "std_cycle_span": 0.0,
+          "neutral_observations_during_learning": 0,
+          "learning_on_time_seconds": 23.999999999970743,
+          "clipped_updates": 0,
+          "final_predictor_coefficients": null
+        }
+      ],
+      "summary": {
+        "sdil_beats_frozen_constant_all_periods": true,
+        "median_raw_to_oracle_gap_closed_by_sdil": 0.9999999999999502,
+        "overclamp_beats_sdil_all_periods": true,
+        "online_constant_neutral_observations_by_period": [
+          6000,
+          2400,
+          1200,
+          600,
+          240,
+          240,
+          240
+        ],
+        "frozen_sdil_neutral_observations_by_period": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      }
+    }
+  },
+  "summary": {
+    "sdil_beats_frozen_constant_both_pairs": true,
+    "median_gap_closed_by_pair": {
+      "experiment_1": 0.9999999864048891,
+      "experiment_2": 0.9999999999999502
+    }
+  }
+}
diff --git a/sdil/physical_coupled.py b/sdil/physical_coupled.py
index 0216048..f451947 100644
--- a/sdil/physical_coupled.py
+++ b/sdil/physical_coupled.py
@@ -244,3 +244,158 @@ def local_replay_update(
     residual = np.asarray(teaching_measurement) - predictor.predict(gates)
     return learning_rate * residual * np.asarray(eligibility)
 
+
+def task_errors(circuit: Circuit, gates: Array, tasks: Iterable[Task]) -> Array:
+    return np.asarray([
+        (task.label_voltage - free_output(
+            circuit, gates, task.input_voltage)) ** 2
+        for task in tasks
+    ], dtype=float)
+
+
+def simulate_alternating_tasks(
+    circuit: Circuit,
+    tasks: Iterable[Task],
+    bias_field: LocalAffineBias,
+    *,
+    method: str,
+    period_seconds: float,
+    cycles: int,
+    initial_gates: Array,
+    bias_strength: float = 1.0,
+    predictor: Optional[LocalPredictor] = None,
+    online_predictor_rate: float = 0.05,
+    noise_standard_deviation: Optional[Array] = None,
+    seed: int = 0,
+    summary_cycles: int = 20,
+    record_history: bool = False,
+) -> dict:
+    """Alternate two tasks using explicit local circuit updates.
+
+    `online_constant` and `online_sdil` take one neutral observation at the
+    beginning of each half-cycle.  Frozen predictors take none during task
+    learning.  The overclamping implementation uses the leading-order
+    constant-displacement signal of Eq. F6 and the error-proportional update
+    duration of Eq. F8; it is an analogue for these regression tasks, not a
+    reproduction of the paper's classification experiment.
+    """
+    allowed = {
+        "raw", "frozen_constant", "frozen_sdil", "online_constant",
+        "online_sdil", "oracle", "same_rms_noise", "overclamp",
+    }
+    if method not in allowed:
+        raise ValueError(f"unrecognized method {method}")
+    tasks = tuple(tasks)
+    if len(tasks) != 2:
+        raise ValueError("exactly two alternating tasks are required")
+    if period_seconds <= 0.0 or cycles < 1:
+        raise ValueError("period and cycles must be positive")
+    if method in {
+        "frozen_constant", "frozen_sdil", "online_constant", "online_sdil"
+    } and predictor is None:
+        raise ValueError(f"{method} requires a predictor")
+    if method == "same_rms_noise" and noise_standard_deviation is None:
+        raise ValueError("same_rms_noise requires a standard deviation")
+
+    active_predictor = predictor.copy() if predictor is not None else None
+    gates = np.asarray(initial_gates, dtype=float).copy()
+    if gates.shape != (2,):
+        raise ValueError("initial gates must have shape (2,)")
+    nominal_step = circuit.integration_step_seconds
+    half_steps = max(1, int(round(period_seconds / (2.0 * nominal_step))))
+    rng = np.random.default_rng(seed)
+    initial_error_scale = float(np.mean([
+        abs(task.label_voltage - free_output(
+            circuit, gates, task.input_voltage))
+        for task in tasks
+    ]))
+    initial_error_scale = max(initial_error_scale, 1e-6)
+
+    combined_error_history = []
+    cycle_span_history = []
+    gate_history = []
+    task_error_history = []
+    learning_on_time = 0.0
+    neutral_observations = 0
+    clipped_updates = 0
+
+    for _ in range(cycles):
+        half_endpoints = []
+        half_task_errors = []
+        for task in tasks:
+            if method in {"online_constant", "online_sdil"}:
+                neutral = bias_field(gates, bias_strength)
+                active_predictor.update(
+                    gates, neutral, online_predictor_rate)
+                neutral_observations += 1
+            for _ in range(half_steps):
+                physical_bias = bias_field(gates, bias_strength)
+                if method == "overclamp":
+                    clean_rate, output_free, _ = overclamped_clean_rate(
+                        circuit, gates, task)
+                    duration = nominal_step * abs(
+                        task.label_voltage - output_free) / initial_error_scale
+                    residual_bias = physical_bias
+                else:
+                    clean_rate, _, _ = standard_clean_rate(circuit, gates, task)
+                    duration = nominal_step
+                    if method == "raw":
+                        residual_bias = physical_bias
+                    elif method == "oracle":
+                        residual_bias = np.zeros(2, dtype=float)
+                    elif method == "same_rms_noise":
+                        residual_bias = rng.normal(
+                            loc=0.0,
+                            scale=np.asarray(noise_standard_deviation, dtype=float),
+                            size=2,
+                        )
+                    else:
+                        residual_bias = (
+                            physical_bias - active_predictor.predict(gates)
+                        )
+                proposed = gates + duration * (clean_rate + residual_bias)
+                clipped = np.clip(
+                    proposed, circuit.gate_minimum, circuit.gate_maximum)
+                clipped_updates += int(np.any(clipped != proposed))
+                gates = clipped
+                learning_on_time += duration
+            half_endpoints.append(gates.copy())
+            half_task_errors.append(task_errors(circuit, gates, tasks))
+        half_task_errors_array = np.asarray(half_task_errors)
+        combined_error_history.append(float(np.mean(half_task_errors_array)))
+        cycle_span_history.append(float(np.linalg.norm(
+            half_endpoints[1] - half_endpoints[0])))
+        gate_history.append(np.asarray(half_endpoints).tolist())
+        task_error_history.append(half_task_errors_array.tolist())
+
+    summary_count = min(summary_cycles, cycles)
+    combined = np.asarray(combined_error_history[-summary_count:])
+    spans = np.asarray(cycle_span_history[-summary_count:])
+    result = {
+        "method": method,
+        "period_seconds": period_seconds,
+        "cycles": cycles,
+        "half_steps": half_steps,
+        "initial_gates": np.asarray(initial_gates, dtype=float).tolist(),
+        "final_gates": gates.tolist(),
+        "bias_strength": bias_strength,
+        "mean_combined_error": float(np.mean(combined)),
+        "std_combined_error": float(np.std(combined)),
+        "mean_cycle_span": float(np.mean(spans)),
+        "std_cycle_span": float(np.std(spans)),
+        "neutral_observations_during_learning": neutral_observations,
+        "learning_on_time_seconds": float(learning_on_time),
+        "clipped_updates": clipped_updates,
+        "final_predictor_coefficients": (
+            None if active_predictor is None
+            else active_predictor.coefficients.tolist()
+        ),
+    }
+    if record_history:
+        result.update({
+            "combined_error_history": combined_error_history,
+            "cycle_span_history": cycle_span_history,
+            "half_cycle_gate_history": gate_history,
+            "half_cycle_task_error_history": task_error_history,
+        })
+    return result