From fc42f93cee71210532983a3962f1cd227f96e5f3 Mon Sep 17 00:00:00 2001 From: YurenHao0426 Date: Thu, 6 Aug 2026 15:56:27 -0500 Subject: results: reproduce physical structured-bias scaling --- RESULTS.md | 29 + TWO_STATE_BIAS_PROGRAM.md | 8 +- experiments/analyze_physical_bias_p0.py | 267 ++++++ results/figs/physical_bias_p0.png | Bin 0 -> 264202 bytes results/figs/physical_bias_p0_caption.md | 13 + results/physical_bias/p0_summary.json | 1485 ++++++++++++++++++++++++++++++ 6 files changed, 1800 insertions(+), 2 deletions(-) create mode 100644 experiments/analyze_physical_bias_p0.py create mode 100644 results/figs/physical_bias_p0.png create mode 100644 results/figs/physical_bias_p0_caption.md create mode 100644 results/physical_bias/p0_summary.json diff --git a/RESULTS.md b/RESULTS.md index 6cd5166..250b6e2 100644 --- a/RESULTS.md +++ b/RESULTS.md @@ -1,5 +1,34 @@ # SDIL — results log (audited sections report n; timan107 GTX-1080 / ep_pascal) +## Published physical structured-bias reproduction (P0; descriptive) + +The active two-state-bias program begins with a reanalysis of already +published physical measurements rather than a generated neural-network +corruption. We downloaded Dillavou et al.'s complete public artifact from +Zenodo record `15692914`, release `v1.0.1`, and analyzed the released +small-network tables and two-dimensional gate-voltage trajectories. This is a +post-publication descriptive reproduction, not a preregistered confirmation or +an SDIL learning result. + +For each of the three physical experiments, an ordinary log--log fit uses the +six lowest task-switching periods. Combined-error slopes are `0.061871`, +`0.288254`, and `-0.023506` (mean `0.108873`), reproducing a nonzero error +plateau under rapid switching. Squared-cycle-span slopes are `1.837374`, +`1.735974`, and `1.946804` (mean `1.840051`), corresponding to a mean span +slope of `0.920025`. Thus the distance traversed in a cycle shrinks roughly in +proportion to the period while the inferred distance per unit period remains +finite. Faster task averaging reduces the size of each cycle; it does not make +the deterministic physical drift rate vanish. + +`experiments/analyze_physical_bias_p0.py` records a SHA-256 hash for every +source CSV, audits all ten released bow-tie trajectories, emits +`results/physical_bias/p0_summary.json`, and renders +`results/figs/physical_bias_p0.png`. The result supports the existence and +non-averaging of structured bias in a real coupled-learning system. It does +not establish that SDIL removes this bias, that the effect grows with neural +network depth, or that the original paper's overclamping baseline can be +beaten. Those are separate P1 and cross-backbone gates. + ## 2026-07-21 audit and version boundary Git was initialized after inheriting the project. The original code/results are preserved at diff --git a/TWO_STATE_BIAS_PROGRAM.md b/TWO_STATE_BIAS_PROGRAM.md index 8933e33..bf5bc37 100644 --- a/TWO_STATE_BIAS_PROGRAM.md +++ b/TWO_STATE_BIAS_PROGRAM.md @@ -273,8 +273,12 @@ Stop this paper direction if: - Dillavou artifact: downloaded outside the NFS workspace to `/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1`; raw drift, bow-tie, big-network classification and overclamping data are present. -- Physical P0 reproduction: not yet complete. +- Physical P0 descriptive reproduction: complete. Across the lowest six + published periods, combined-error log slopes are + `0.0619/0.2883/-0.0235` while squared-cycle-span slopes are + `1.8374/1.7360/1.9468`; see `results/physical_bias/p0_summary.json`. This + reproduces a nonzero rapid-switching error floor and an approximately + constant low-period drift speed from real hardware. It is not an SDIL result. - 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/analyze_physical_bias_p0.py b/experiments/analyze_physical_bias_p0.py new file mode 100644 index 0000000..381db13 --- /dev/null +++ b/experiments/analyze_physical_bias_p0.py @@ -0,0 +1,267 @@ +#!/usr/bin/env python3 +"""Reproduce physical-bias scaling diagnostics from Dillavou et al. data. + +This is a descriptive reanalysis of already published data, not a prospective +confirmation. It reads only the small-network CSV files from Zenodo record +15692914 (release v1.0.1), records their hashes, and measures the low-period +power laws reported in the paper: + +* nonzero combined-error plateau as the task-switching period decreases; +* squared cycle span proportional to approximately period squared; +* therefore a nonzero cycle-speed proxy span / period. + +The script also audits the released two-dimensional bow-tie trajectories. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +import re +from typing import Dict, List + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np + + +ZENODO_RECORD = "15692914" +ZENODO_DOI = "10.5281/zenodo.15692914" +RELEASE = "v1.0.1" +SOURCE_TREE = "maguzj-imperfect-learning-physical-systems-71b8d72" + + +def sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def log_slope(values: np.ndarray) -> float: + if values.ndim != 2 or values.shape[1] != 2: + raise ValueError("expected a two-column positive-valued table") + if np.any(values <= 0): + raise ValueError("log slope requires strictly positive values") + return float(np.polyfit(np.log(values[:, 0]), np.log(values[:, 1]), 1)[0]) + + +def load_table(path: Path) -> np.ndarray: + values = np.loadtxt(path, delimiter=",") + if values.ndim != 2 or values.shape[1] != 2: + raise ValueError(f"unexpected table shape in {path}: {values.shape}") + if not np.all(np.isfinite(values)): + raise ValueError(f"nonfinite value in {path}") + if np.any(np.diff(values[:, 0]) <= 0): + raise ValueError(f"periods are not strictly increasing in {path}") + return values + + +def experiment_tables(data_dir: Path, fit_points: int) -> Dict[str, dict]: + records: Dict[str, dict] = {} + for experiment in (1, 2, 3): + mse_path = data_dir / f"measured-MSE-exp{experiment}.csv" + span2_path = data_dir / f"measured-DG2-exp{experiment}.csv" + mse = load_table(mse_path) + span2 = load_table(span2_path) + if not np.array_equal(mse[:, 0], span2[:, 0]): + raise ValueError(f"period grids disagree for experiment {experiment}") + if len(mse) < fit_points: + raise ValueError("fit_points exceeds a source table") + low_mse = mse[:fit_points] + low_span2 = span2[:fit_points] + speed = np.sqrt(low_span2[:, 1]) / low_span2[:, 0] + records[str(experiment)] = { + "period": mse[:, 0].tolist(), + "combined_error": mse[:, 1].tolist(), + "cycle_span_squared": span2[:, 1].tolist(), + "low_period_points": int(fit_points), + "low_period_combined_error_log_slope": log_slope(low_mse), + "low_period_span_squared_log_slope": log_slope(low_span2), + "low_period_span_log_slope": 0.5 * log_slope(low_span2), + "low_period_speed_proxy": speed.tolist(), + "low_period_speed_proxy_mean": float(np.mean(speed)), + "low_period_speed_proxy_cv": float(np.std(speed) / np.mean(speed)), + "source_files": { + "combined_error": { + "path": str(mse_path), + "sha256": sha256(mse_path), + }, + "cycle_span_squared": { + "path": str(span2_path), + "sha256": sha256(span2_path), + }, + }, + } + return records + + +def bowtie_records(bowtie_dir: Path) -> List[dict]: + pattern = re.compile(r"bowtie-exp(?P[123])-(?P[0-9.]+)s\.csv") + records = [] + for path in sorted(bowtie_dir.glob("bowtie-exp*-*s.csv")): + match = pattern.fullmatch(path.name) + if match is None: + raise ValueError(f"unrecognized bow-tie filename: {path.name}") + trajectory = np.loadtxt(path, delimiter=",") + if trajectory.ndim != 2 or trajectory.shape[0] != 2: + raise ValueError(f"unexpected bow-tie shape in {path}: {trajectory.shape}") + pairwise = trajectory[:, :, None] - trajectory[:, None, :] + diameter = float(np.sqrt(np.sum(pairwise * pairwise, axis=0)).max()) + midpoint = trajectory.shape[1] // 2 + half_cycle_span = float(np.linalg.norm( + trajectory[:, 0] - trajectory[:, midpoint])) + path_length = float(np.linalg.norm( + np.diff(trajectory, axis=1), axis=0).sum()) + records.append({ + "experiment": int(match.group("experiment")), + "period_seconds": float(match.group("period")), + "samples": int(trajectory.shape[1]), + "diameter": diameter, + "half_cycle_span": half_cycle_span, + "path_length": path_length, + "trajectory": trajectory.tolist(), + "source_file": {"path": str(path), "sha256": sha256(path)}, + }) + if len(records) != 10: + raise ValueError(f"expected 10 bow-tie trajectories, found {len(records)}") + return records + + +def representative_quadratic(period: np.ndarray, values: np.ndarray) -> np.ndarray: + return values[0] * (period / period[0]) ** 2 + + +def plot_report(report: dict, output: Path) -> None: + colors = ["#4477AA", "#EE6677", "#228833"] + fig, axes = plt.subplots(2, 2, figsize=(9.0, 7.0)) + + for index, (experiment, record) in enumerate(report["experiments"].items()): + period = np.asarray(record["period"]) + error = np.asarray(record["combined_error"]) + span2 = np.asarray(record["cycle_span_squared"]) + label = f"physical experiment {experiment}" + axes[0, 0].loglog(period, error, "o-", color=colors[index], label=label) + axes[0, 1].loglog(period, span2, "o-", color=colors[index], label=label) + low_n = int(record["low_period_points"]) + axes[0, 1].loglog( + period[:low_n], representative_quadratic(period[:low_n], span2[:low_n]), + "--", color=colors[index], alpha=0.55) + speed = np.sqrt(span2) / period + axes[1, 0].semilogx(period, speed, "o-", color=colors[index], label=label) + + axes[0, 0].set_title("A Error remains nonzero under rapid switching") + axes[0, 0].set_xlabel("task-switching period (s)") + axes[0, 0].set_ylabel("combined error") + axes[0, 0].legend(frameon=False, fontsize=8) + + axes[0, 1].set_title("B Cycle span follows the bias-drift prediction") + axes[0, 1].set_xlabel("task-switching period (s)") + axes[0, 1].set_ylabel("cycle span squared") + + axes[1, 0].set_title("C Span per unit period does not vanish") + axes[1, 0].set_xlabel("task-switching period (s)") + axes[1, 0].set_ylabel("sqrt(span squared) / period") + + selected = [ + item for item in report["bowtie_trajectories"] + if item["experiment"] == 1 + ] + selected.sort(key=lambda item: item["period_seconds"]) + for index, item in enumerate(selected): + trajectory = np.asarray(item["trajectory"]) + axes[1, 1].plot( + trajectory[0], trajectory[1], "o-", markersize=2.1, + linewidth=1.0, color=colors[index], + label=f"period={item['period_seconds']:g} s") + axes[1, 1].set_title("D Measured bias-driven parameter cycles") + axes[1, 1].set_xlabel("gate voltage +") + axes[1, 1].set_ylabel("gate voltage -") + axes[1, 1].legend(frameon=False, fontsize=8) + + for axis in axes.flat: + axis.grid(alpha=0.18) + fig.suptitle( + "Published physical coupled-learning data (Dillavou et al.; Zenodo 15692914)", + 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( + "--artifact-root", type=Path, required=True, + help="Root of the extracted Zenodo source tree") + parser.add_argument("--fit-points", type=int, default=6) + parser.add_argument( + "--json", type=Path, + default=Path("results/physical_bias/p0_summary.json")) + parser.add_argument( + "--figure", type=Path, + default=Path("results/figs/physical_bias_p0.png")) + return parser.parse_args() + + +def main() -> None: + args = parse_args() + if args.fit_points < 3: + raise ValueError("fit_points must be at least three") + root = args.artifact_root.resolve() + expected_name = SOURCE_TREE + if root.name != expected_name: + raise ValueError(f"expected source root {expected_name}, received {root.name}") + small = root / "small network" + records = experiment_tables(small / "MSE-DG2-Data", args.fit_points) + bowties = bowtie_records(small / "experimental_bowties") + mse_slopes = np.asarray([ + value["low_period_combined_error_log_slope"] + for value in records.values()]) + span2_slopes = np.asarray([ + value["low_period_span_squared_log_slope"] + for value in records.values()]) + report = { + "analysis": "published_physical_bias_descriptive_reproduction", + "confirmatory": False, + "provenance": { + "zenodo_record": ZENODO_RECORD, + "doi": ZENODO_DOI, + "release": RELEASE, + "source_tree": SOURCE_TREE, + }, + "fit_definition": { + "points": int(args.fit_points), + "selection": "lowest task-switching periods in each published table", + "regression": "ordinary least squares on log(period), log(metric)", + }, + "experiments": records, + "bowtie_trajectories": bowties, + "summary": { + "combined_error_log_slope_mean": float(np.mean(mse_slopes)), + "combined_error_log_slopes": mse_slopes.tolist(), + "span_squared_log_slope_mean": float(np.mean(span2_slopes)), + "span_squared_log_slopes": span2_slopes.tolist(), + "span_log_slope_mean": float(0.5 * np.mean(span2_slopes)), + "descriptive_plateau_check_abs_error_slope_below_0p4": bool( + np.all(np.abs(mse_slopes) < 0.4)), + "descriptive_linear_drift_check_span2_slope_1p5_to_2p3": bool( + np.all((span2_slopes > 1.5) & (span2_slopes < 2.3))), + }, + } + args.json.parent.mkdir(parents=True, exist_ok=True) + args.json.write_text(json.dumps(report, indent=2) + "\n") + plot_report(report, args.figure) + print(json.dumps(report["summary"], indent=2)) + print(f"wrote {args.json}") + print(f"wrote {args.figure}") + + +if __name__ == "__main__": + main() diff --git a/results/figs/physical_bias_p0.png b/results/figs/physical_bias_p0.png new file mode 100644 index 0000000..0d5dbb3 Binary files /dev/null and b/results/figs/physical_bias_p0.png differ diff --git a/results/figs/physical_bias_p0_caption.md b/results/figs/physical_bias_p0_caption.md new file mode 100644 index 0000000..0e8fe9a --- /dev/null +++ b/results/figs/physical_bias_p0_caption.md @@ -0,0 +1,13 @@ +**Published physical structured-bias reproduction.** All panels are regenerated +from the raw small-network files released by Dillavou et al. in Zenodo record +`15692914` (release `v1.0.1`). **A,** Combined learning error approaches a +nonzero low-period plateau in three physical experiments. Fits to the lowest +six periods have log--log slopes `0.062`, `0.288`, and `-0.024`. **B,** Squared +cycle span grows approximately quadratically with switching period over the +same points (slopes `1.837`, `1.736`, and `1.947`; dashed lines show quadratic +references). **C,** The resulting span-per-period proxy remains finite at +short periods, as expected for deterministic drift that is not removed by +faster alternation. **D,** Released gate-voltage trajectories from physical +experiment 1 show the measured bias-driven cycles. This is a descriptive +reanalysis of published hardware data, not evidence that SDIL corrects the +bias. diff --git a/results/physical_bias/p0_summary.json b/results/physical_bias/p0_summary.json new file mode 100644 index 0000000..28dc20c --- /dev/null +++ b/results/physical_bias/p0_summary.json @@ -0,0 +1,1485 @@ +{ + "analysis": "published_physical_bias_descriptive_reproduction", + "confirmatory": false, + "provenance": { + "zenodo_record": "15692914", + "doi": "10.5281/zenodo.15692914", + "release": "v1.0.1", + "source_tree": "maguzj-imperfect-learning-physical-systems-71b8d72" + }, + "fit_definition": { + "points": 6, + "selection": "lowest task-switching periods in each published table", + "regression": "ordinary least squares on log(period), log(metric)" + }, + "experiments": { + "1": { + "period": [ + 0.0006, + 0.0008, + 0.0012, + 0.002, + 0.0032, + 0.005, + 0.008, + 0.0126, + 0.02, + 0.0316, + 0.0502, + 0.0796, + 0.1262, + 0.2, + 0.317, + 0.5024, + 0.7962, + 1.262, + 2.0 + ], + "combined_error": [ + 4.51539052715704e-05, + 4.61588719846355e-05, + 4.47481113096561e-05, + 4.55506188865266e-05, + 4.98588861768166e-05, + 5.16620668568295e-05, + 5.27371372583955e-05, + 5.73028011306567e-05, + 6.74968388125026e-05, + 9.85202409937484e-05, + 0.000165859458671063, + 0.000322053243437773, + 0.000689422902018986, + 0.00159712239092084, + 0.00180493157232454, + 0.00180591693725581, + 0.00180606971769925, + 0.00180661690553345, + 0.00185570706939807 + ], + "cycle_span_squared": [ + 2.35134760260328e-05, + 4.05280533158153e-05, + 8.19177276868164e-05, + 0.000203773704691677, + 0.000495231820479515, + 0.00119176758205252, + 0.0030435629035797, + 0.00736085607911876, + 0.0176759218463399, + 0.04378340722672, + 0.110932133926185, + 0.31742736301127, + 0.980395117721945, + 3.6392520804208, + 4.88356705964276, + 4.96702439198189, + 4.96428099704498, + 4.98633676793855, + 4.97453750973931 + ], + "low_period_points": 6, + "low_period_combined_error_log_slope": 0.061871046531009194, + "low_period_span_squared_log_slope": 1.8373743444902582, + "low_period_span_log_slope": 0.9186871722451291, + "low_period_speed_proxy": [ + 8.081782673607627, + 7.957705907229885, + 7.542367724635449, + 7.137466369302152, + 6.954313946659486, + 6.904397387325036 + ], + "low_period_speed_proxy_mean": 7.429672334793271, + "low_period_speed_proxy_cv": 0.06274783134192093, + "source_files": { + "combined_error": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/MSE-DG2-Data/measured-MSE-exp1.csv", + "sha256": "edaf7aa732824ea799e7d5711ddfa340a19aae6943dc77c4dbcfb74a4d67f7c9" + }, + "cycle_span_squared": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/MSE-DG2-Data/measured-DG2-exp1.csv", + "sha256": "b614627f5a306d6e1b2026fc558115ede225466c9786ee4a4b2bede43be3044e" + } + } + }, + "2": { + "period": [ + 0.0006, + 0.0008, + 0.0012, + 0.002, + 0.0032, + 0.005, + 0.008, + 0.0126, + 0.02, + 0.0316, + 0.0502, + 0.0796, + 0.1262, + 0.2, + 0.317, + 0.5024, + 0.7962, + 1.262, + 2.0 + ], + "combined_error": [ + 5.26175823544804e-06, + 9.04712342457534e-06, + 1.12874800025047e-05, + 1.20095854497768e-05, + 1.21824411319321e-05, + 1.11316161005672e-05, + 1.01378114256191e-05, + 9.63294038082661e-06, + 9.68166589433672e-06, + 1.4986425544513e-05, + 1.72663956974471e-05, + 3.62695105054409e-05, + 8.83699006420721e-05, + 0.000177377007356843, + 0.000217805527627104, + 0.000241059241809202, + 0.000290683984651889, + 0.000376698768150252, + 0.000377831141293383 + ], + "cycle_span_squared": [ + 5.67824532369051e-06, + 4.48303060713692e-06, + 9.94668351708421e-06, + 3.05560088771082e-05, + 7.14787821782058e-05, + 0.000160766133577045, + 0.000377278824284651, + 0.000858886163125791, + 0.00236830690608968, + 0.00559307814663573, + 0.0149754892860777, + 0.0398064180451944, + 0.142431388635007, + 0.366388711231736, + 0.466280946600218, + 0.578282095395273, + 0.900495264278173, + 1.48936660603378, + 1.56634328974603 + ], + "low_period_points": 6, + "low_period_combined_error_log_slope": 0.2882539659321607, + "low_period_span_squared_log_slope": 1.7359736925037077, + "low_period_span_log_slope": 0.8679868462518538, + "low_period_speed_proxy": [ + 3.971511510359511, + 2.646646051826998, + 2.62819693118424, + 2.7638744941254205, + 2.642035166702065, + 2.535871712662492 + ], + "low_period_speed_proxy_mean": 2.8646893111434544, + "low_period_speed_proxy_cv": 0.1743286323810085, + "source_files": { + "combined_error": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/MSE-DG2-Data/measured-MSE-exp2.csv", + "sha256": "33469c652e56ea4a2d62c87996c8229b9ffd8b86dc4eb67b54fe1cdeb5fe4e92" + }, + "cycle_span_squared": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/MSE-DG2-Data/measured-DG2-exp2.csv", + "sha256": "054cad8920323d648879dcc0823067ca12b8cb04f389f33adb8de61515c2db4a" + } + } + }, + "3": { + "period": [ + 0.0004, + 0.0008, + 0.0012, + 0.0016, + 0.0024, + 0.004, + 0.0064, + 0.01, + 0.016, + 0.0252, + 0.04, + 0.0632, + 0.1004, + 0.1592, + 0.2524, + 0.4, + 0.634, + 1.0048, + 1.5924, + 2.524, + 4.0, + 6.3396, + 10.0476, + 15.9244, + 25.2384, + 40.0, + 63.3956 + ], + "combined_error": [ + 7.08477085132878e-05, + 6.92795216098303e-05, + 6.83267856567365e-05, + 6.74164648769547e-05, + 6.78771406253706e-05, + 6.70562938987981e-05, + 6.72207610700686e-05, + 6.80809279240339e-05, + 6.81611466344334e-05, + 7.0603330202846e-05, + 7.7569132710239e-05, + 9.14813474774272e-05, + 0.00010901145727023, + 0.000122838004477679, + 0.000130761932623986, + 0.000136097207646364, + 0.000141576011637553, + 0.000156707768446928, + 0.00021310258565499, + 0.000399193244970051, + 0.000962112160390191, + 0.00111873176844371, + 0.00110553394395131, + 0.0011001173722767, + 0.00109111583401839, + 0.00109311679774915, + 0.00112891389333747 + ], + "cycle_span_squared": [ + 3.74261267890472e-06, + 1.68684138405315e-05, + 3.03577469139011e-05, + 6.07634760416401e-05, + 0.00011764938942797, + 0.00035758402128282, + 0.000875421096702711, + 0.00210542755481049, + 0.00519205139730942, + 0.0125419909032191, + 0.028918150946963, + 0.0586238027811135, + 0.0914549752394059, + 0.112974660934772, + 0.134329710324604, + 0.174142416450411, + 0.263703255146455, + 0.474979261490892, + 1.02584286065101, + 2.19952761756218, + 4.04100259631176, + 4.44527726675857, + 4.43245389482504, + 4.41342438606462, + 4.38825289802854, + 4.32799760427928, + 4.49794408275721 + ], + "low_period_points": 6, + "low_period_combined_error_log_slope": -0.02350626081957371, + "low_period_span_squared_log_slope": 1.9468041519016315, + "low_period_span_log_slope": 0.9734020759508157, + "low_period_speed_proxy": [ + 4.836458336753714, + 5.133896826566587, + 4.591488722648581, + 4.8719331716235255, + 4.519429302482083, + 4.727473038545672 + ], + "low_period_speed_proxy_mean": 4.78011323310336, + "low_period_speed_proxy_cv": 0.04210718111029523, + "source_files": { + "combined_error": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/MSE-DG2-Data/measured-MSE-exp3.csv", + "sha256": "2805cc1b0c823889fb5fa25302f92abf4cb93f392c8776cbf4258715451fd9c8" + }, + "cycle_span_squared": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/MSE-DG2-Data/measured-DG2-exp3.csv", + "sha256": "c9e7dfc3fa94668b7c246a550b2ad9d741fc791cf4ffa8b6bd9ed60201581dc4" + } + } + } + }, + "bowtie_trajectories": [ + { + "experiment": 1, + "period_seconds": 0.02, + "samples": 61, + "diameter": 0.1470897005231843, + "half_cycle_span": 0.13877204329402962, + "path_length": 0.2915892022478569, + "trajectory": [ + [ + 2.498, + 2.4964, + 2.4921, + 2.485, + 2.4806, + 2.4767, + 2.4707, + 2.4672, + 2.4624, + 2.4584, + 2.455, + 2.451, + 2.4479, + 2.4453, + 2.4416, + 2.439, + 2.4357, + 2.4336, + 2.4311, + 2.4272, + 2.4269, + 2.4244, + 2.4219, + 2.4197, + 2.4178, + 2.416, + 2.4144, + 2.4127, + 2.4115, + 2.4109, + 2.4082, + 2.4078, + 2.4108, + 2.4165, + 2.4207, + 2.4252, + 2.4302, + 2.4345, + 2.4385, + 2.4436, + 2.4478, + 2.4527, + 2.4558, + 2.4591, + 2.4637, + 2.4656, + 2.4694, + 2.4731, + 2.4775, + 2.4806, + 2.4833, + 2.4867, + 2.4905, + 2.4925, + 2.496, + 2.498, + 2.5017, + 2.5044, + 2.5079, + 2.5102, + 2.5131 + ], + [ + 2.7664, + 2.7686, + 2.7731, + 2.7787, + 2.783, + 2.7872, + 2.7921, + 2.7955, + 2.802, + 2.8041, + 2.8084, + 2.813, + 2.8164, + 2.8202, + 2.824, + 2.8268, + 2.8313, + 2.8342, + 2.8376, + 2.8412, + 2.8441, + 2.8468, + 2.8503, + 2.8528, + 2.8565, + 2.8586, + 2.8618, + 2.8649, + 2.8673, + 2.8702, + 2.8722, + 2.8741, + 2.8709, + 2.8634, + 2.8582, + 2.8534, + 2.8472, + 2.8427, + 2.8389, + 2.8338, + 2.8291, + 2.824, + 2.8207, + 2.8171, + 2.8123, + 2.8086, + 2.806, + 2.8025, + 2.7998, + 2.7958, + 2.7938, + 2.7912, + 2.7881, + 2.7859, + 2.7835, + 2.781, + 2.7786, + 2.7756, + 2.7747, + 2.7732, + 2.7714 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp1-0.02s.csv", + "sha256": "33f9c0dca64319024d4e25e39189cba62e8af547f7ea2c2abf5ef5c46a599409" + } + }, + { + "experiment": 1, + "period_seconds": 0.08, + "samples": 61, + "diameter": 0.5734492915681384, + "half_cycle_span": 0.5665384717739826, + "path_length": 1.2080171657552776, + "trajectory": [ + [ + 2.5401, + 2.544, + 2.5793, + 2.612, + 2.6382, + 2.6648, + 2.6864, + 2.707, + 2.7251, + 2.7425, + 2.7576, + 2.7728, + 2.7855, + 2.7976, + 2.8093, + 2.8195, + 2.8307, + 2.8392, + 2.8485, + 2.8579, + 2.866, + 2.8736, + 2.8803, + 2.8893, + 2.8961, + 2.9029, + 2.9107, + 2.9174, + 2.9246, + 2.9306, + 2.9391, + 2.9408, + 2.9084, + 2.8532, + 2.8091, + 2.7682, + 2.7339, + 2.7034, + 2.6772, + 2.6528, + 2.6342, + 2.6155, + 2.6005, + 2.5897, + 2.5798, + 2.5705, + 2.5624, + 2.5556, + 2.5514, + 2.547, + 2.5442, + 2.5415, + 2.5402, + 2.5384, + 2.5375, + 2.538, + 2.5381, + 2.54, + 2.5409, + 2.543, + 2.5444 + ], + [ + 3.3124, + 3.3058, + 3.2515, + 3.1995, + 3.1595, + 3.1207, + 3.0883, + 3.059, + 3.0354, + 3.0129, + 2.9948, + 2.9799, + 2.9651, + 2.9532, + 2.9435, + 2.9348, + 2.9286, + 2.9226, + 2.9176, + 2.9128, + 2.9105, + 2.908, + 2.9047, + 2.9044, + 2.9036, + 2.9033, + 2.905, + 2.9063, + 2.9072, + 2.9091, + 2.9102, + 2.912, + 2.933, + 2.9705, + 2.9999, + 3.0288, + 3.0529, + 3.0764, + 3.0965, + 3.1146, + 3.1318, + 3.1478, + 3.1617, + 3.175, + 3.1877, + 3.1986, + 3.2103, + 3.2208, + 3.2307, + 3.2393, + 3.2486, + 3.257, + 3.2645, + 3.274, + 3.2817, + 3.2888, + 3.2967, + 3.3033, + 3.3099, + 3.3198, + 3.3262 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp1-0.08s.csv", + "sha256": "4b16b460076273a7896992453e1082f9b440637738232a183f8b9a841c42baef" + } + }, + { + "experiment": 1, + "period_seconds": 0.2, + "samples": 61, + "diameter": 1.91693964432895, + "half_cycle_span": 1.9135862562215487, + "path_length": 4.253149909722854, + "trajectory": [ + [ + 3.1283, + 3.1368, + 3.3305, + 3.4845, + 3.61, + 3.7122, + 3.791, + 3.8589, + 3.9148, + 3.963, + 4.0022, + 4.0377, + 4.0701, + 4.0977, + 4.1231, + 4.1472, + 4.17, + 4.191, + 4.2117, + 4.2327, + 4.2527, + 4.2729, + 4.292, + 4.3114, + 4.3314, + 4.3505, + 4.3704, + 4.3892, + 4.4088, + 4.4274, + 4.4477, + 4.4559, + 4.2581, + 3.9492, + 3.7193, + 3.545, + 3.4123, + 3.3109, + 3.2321, + 3.174, + 3.1333, + 3.1035, + 3.0813, + 3.0669, + 3.0569, + 3.0517, + 3.0483, + 3.0487, + 3.0513, + 3.0546, + 3.0587, + 3.0646, + 3.0692, + 3.0751, + 3.0824, + 3.0877, + 3.0954, + 3.1018, + 3.1089, + 3.116, + 3.1228 + ], + [ + 4.9461, + 4.9299, + 4.5621, + 4.2894, + 4.0838, + 3.9249, + 3.8061, + 3.7123, + 3.6429, + 3.5914, + 3.5529, + 3.5252, + 3.5048, + 3.4916, + 3.4841, + 3.4779, + 3.4762, + 3.4784, + 3.4806, + 3.4857, + 3.4893, + 3.4957, + 3.5019, + 3.5074, + 3.5144, + 3.5215, + 3.5291, + 3.537, + 3.5443, + 3.5521, + 3.5601, + 3.5633, + 3.6727, + 3.8532, + 3.996, + 4.1136, + 4.2084, + 4.2871, + 4.3512, + 4.405, + 4.4484, + 4.4884, + 4.5228, + 4.5537, + 4.5827, + 4.6086, + 4.6339, + 4.657, + 4.6806, + 4.7027, + 4.7248, + 4.7468, + 4.7684, + 4.7894, + 4.8108, + 4.8321, + 4.853, + 4.8729, + 4.8942, + 4.9141, + 4.9342 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp1-0.2s.csv", + "sha256": "52c8ad1bcd4eec43709c2b10e2290908ba991a915042be6a6a5095502a94a1e5" + } + }, + { + "experiment": 2, + "period_seconds": 0.02, + "samples": 61, + "diameter": 0.06861049482404213, + "half_cycle_span": 0.05593755446924718, + "path_length": 0.13899346386608116, + "trajectory": [ + [ + 2.9135, + 2.9116, + 2.9106, + 2.9087, + 2.9064, + 2.9047, + 2.9022, + 2.9008, + 2.8988, + 2.8974, + 2.8956, + 2.8951, + 2.8928, + 2.8924, + 2.889, + 2.8884, + 2.8862, + 2.8862, + 2.885, + 2.8824, + 2.8816, + 2.8809, + 2.8798, + 2.8789, + 2.8784, + 2.8784, + 2.8769, + 2.8772, + 2.8738, + 2.8758, + 2.8745, + 2.8753, + 2.8777, + 2.8797, + 2.882, + 2.8832, + 2.8852, + 2.8866, + 2.8894, + 2.8911, + 2.8922, + 2.8945, + 2.896, + 2.8974, + 2.8998, + 2.8999, + 2.9017, + 2.9038, + 2.905, + 2.9065, + 2.9077, + 2.9086, + 2.9099, + 2.9108, + 2.9113, + 2.9137, + 2.9143, + 2.9144, + 2.9156, + 2.9162, + 2.9147 + ], + [ + 4.1407, + 4.1422, + 4.1444, + 4.1463, + 4.1472, + 4.1492, + 4.1502, + 4.1537, + 4.1554, + 4.1562, + 4.1584, + 4.1599, + 4.1612, + 4.1623, + 4.1641, + 4.1651, + 4.1676, + 4.168, + 4.1686, + 4.1689, + 4.1698, + 4.1714, + 4.1728, + 4.1736, + 4.1739, + 4.1759, + 4.1764, + 4.1788, + 4.1767, + 4.1806, + 4.1808, + 4.1812, + 4.1788, + 4.1753, + 4.1726, + 4.1701, + 4.1673, + 4.166, + 4.1626, + 4.1605, + 4.1585, + 4.1559, + 4.1538, + 4.152, + 4.1499, + 4.1488, + 4.1476, + 4.1446, + 4.1439, + 4.1409, + 4.1405, + 4.1389, + 4.1375, + 4.1359, + 4.135, + 4.1335, + 4.1322, + 4.1318, + 4.1298, + 4.1288, + 4.1252 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp2-0.02s.csv", + "sha256": "aabf48648824c12eab4e619325731ea0b69d939662120e139c644cf828d5181b" + } + }, + { + "experiment": 2, + "period_seconds": 0.08, + "samples": 61, + "diameter": 0.21533771151379816, + "half_cycle_span": 0.21425249123405768, + "path_length": 0.44566313881965536, + "trajectory": [ + [ + 2.9425, + 2.9445, + 2.9578, + 2.9709, + 2.9816, + 2.9916, + 3.0011, + 3.0092, + 3.0156, + 3.0234, + 3.0291, + 3.0347, + 3.0385, + 3.0441, + 3.0476, + 3.0519, + 3.0546, + 3.0578, + 3.0603, + 3.0634, + 3.0651, + 3.0676, + 3.0689, + 3.0694, + 3.072, + 3.0727, + 3.0752, + 3.0743, + 3.0764, + 3.0768, + 3.0782, + 3.0782, + 3.0661, + 3.0434, + 3.0272, + 3.0129, + 3.0019, + 2.9896, + 2.9813, + 2.9728, + 2.9659, + 2.9588, + 2.9513, + 2.9505, + 2.9463, + 2.9434, + 2.9401, + 2.9381, + 2.9346, + 2.9321, + 2.9334, + 2.9322, + 2.9314, + 2.9311, + 2.9305, + 2.9301, + 2.93, + 2.9287, + 2.9295, + 2.9308, + 2.93 + ], + [ + 4.3946, + 4.3951, + 4.3724, + 4.3528, + 4.3355, + 4.3203, + 4.3081, + 4.2971, + 4.2869, + 4.2785, + 4.2715, + 4.2646, + 4.2585, + 4.2541, + 4.2496, + 4.2455, + 4.2429, + 4.2405, + 4.2377, + 4.2366, + 4.2354, + 4.2333, + 4.232, + 4.2309, + 4.2313, + 4.2295, + 4.2288, + 4.2286, + 4.2284, + 4.2289, + 4.2288, + 4.2274, + 4.2365, + 4.248, + 4.2594, + 4.2709, + 4.2813, + 4.2904, + 4.2981, + 4.3059, + 4.3112, + 4.3164, + 4.319, + 4.3274, + 4.3324, + 4.3362, + 4.34, + 4.3443, + 4.346, + 4.3496, + 4.3546, + 4.3566, + 4.3585, + 4.3615, + 4.3639, + 4.3658, + 4.3679, + 4.3678, + 4.3712, + 4.3723, + 4.3729 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp2-0.08s.csv", + "sha256": "9605256a552e75e45923f5ca766b75b26575e2705a46cef6d5ba42d6894a70cd" + } + }, + { + "experiment": 2, + "period_seconds": 0.2, + "samples": 61, + "diameter": 0.6164742411488096, + "half_cycle_span": 0.6160055275726024, + "path_length": 1.3454503348513838, + "trajectory": [ + [ + 3.1883, + 3.1921, + 3.2706, + 3.3287, + 3.374, + 3.409, + 3.4347, + 3.4565, + 3.4705, + 3.4879, + 3.4992, + 3.5091, + 3.5172, + 3.5245, + 3.5315, + 3.5364, + 3.543, + 3.5465, + 3.5514, + 3.5565, + 3.5602, + 3.5641, + 3.5689, + 3.5716, + 3.5754, + 3.5805, + 3.5844, + 3.5884, + 3.5923, + 3.596, + 3.5998, + 3.6015, + 3.5319, + 3.424, + 3.3452, + 3.2888, + 3.2478, + 3.2187, + 3.1978, + 3.1829, + 3.1725, + 3.1647, + 3.1594, + 3.1562, + 3.1546, + 3.1534, + 3.1533, + 3.1511, + 3.1523, + 3.1575, + 3.1586, + 3.1599, + 3.1612, + 3.1612, + 3.1645, + 3.1646, + 3.1665, + 3.1679, + 3.1703, + 3.1697, + 3.1721 + ], + [ + 5.0787, + 5.0714, + 4.9343, + 4.8353, + 4.7641, + 4.7122, + 4.6744, + 4.6454, + 4.6212, + 4.6096, + 4.5991, + 4.5928, + 4.5881, + 4.5857, + 4.5845, + 4.5836, + 4.5851, + 4.5851, + 4.5876, + 4.5891, + 4.592, + 4.5941, + 4.5961, + 4.5997, + 4.6023, + 4.6052, + 4.6076, + 4.6099, + 4.6138, + 4.617, + 4.6203, + 4.6212, + 4.6651, + 4.736, + 4.7894, + 4.8287, + 4.86, + 4.8844, + 4.9036, + 4.9196, + 4.9323, + 4.9435, + 4.9523, + 4.9601, + 4.9668, + 4.9736, + 4.9798, + 4.982, + 4.9873, + 4.9959, + 5.0007, + 5.006, + 5.0108, + 5.0142, + 5.0199, + 5.0237, + 5.0287, + 5.0315, + 5.0357, + 5.0386, + 5.0435 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp2-0.2s.csv", + "sha256": "1bf204eedaaf9287560dc1f0e05efdfb0f96cc946d4062bac8508f6f14101687" + } + }, + { + "experiment": 3, + "period_seconds": 0.025, + "samples": 31, + "diameter": 0.11111458050139052, + "half_cycle_span": 0.10966868285887267, + "path_length": 0.21991622002275915, + "trajectory": [ + [ + 3.1955, + 3.1952, + 3.1889, + 3.1832, + 3.179, + 3.1729, + 3.1681, + 3.1635, + 3.1584, + 3.154, + 3.1489, + 3.1446, + 3.1399, + 3.1359, + 3.1325, + 3.1286, + 3.1274, + 3.1302, + 3.1361, + 3.143, + 3.1502, + 3.154, + 3.1593, + 3.1626, + 3.1688, + 3.1739, + 3.1777, + 3.1813, + 3.1861, + 3.1884, + 3.1929 + ], + [ + 2.8274, + 2.8274, + 2.837, + 2.8429, + 2.8514, + 2.8585, + 2.8655, + 2.8726, + 2.8791, + 2.8833, + 2.8901, + 2.8955, + 2.9, + 2.9053, + 2.9085, + 2.9143, + 2.9152, + 2.9104, + 2.9044, + 2.8965, + 2.8899, + 2.883, + 2.8762, + 2.869, + 2.8641, + 2.8573, + 2.8518, + 2.846, + 2.8407, + 2.8353, + 2.8306 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp3-0.025s.csv", + "sha256": "19e6cb4b1462604aa5fc336b4e8289896573031ce17aa98cacb0059cf9a386d0" + } + }, + { + "experiment": 3, + "period_seconds": 0.1, + "samples": 30, + "diameter": 0.30129457346590227, + "half_cycle_span": 0.30129457346590227, + "path_length": 0.6180397497884059, + "trajectory": [ + [ + 2.8639, + 2.8664, + 2.9051, + 2.9339, + 2.9631, + 2.986, + 3.0057, + 3.0232, + 3.0365, + 3.0453, + 3.0527, + 3.0558, + 3.0572, + 3.0586, + 3.0563, + 3.0548, + 3.0393, + 3.014, + 2.99, + 2.97, + 2.9507, + 2.935, + 2.9211, + 2.9085, + 2.8991, + 2.8903, + 2.8834, + 2.8772, + 2.8721, + 2.8666 + ], + [ + 2.8512, + 2.8498, + 2.8122, + 2.7814, + 2.7518, + 2.7293, + 2.7098, + 2.6911, + 2.6762, + 2.6633, + 2.6506, + 2.6413, + 2.6335, + 2.6268, + 2.6226, + 2.6181, + 2.6424, + 2.6835, + 2.721, + 2.7524, + 2.7772, + 2.7993, + 2.817, + 2.8309, + 2.8412, + 2.8461, + 2.8498, + 2.8512, + 2.8522, + 2.8511 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp3-0.1s.csv", + "sha256": "06e8f6b6ce56d88ce79ebc8ecad6988996b925be49e27e565abdbac93c4b0db5" + } + }, + { + "experiment": 3, + "period_seconds": 0.4, + "samples": 31, + "diameter": 0.4223168123577366, + "half_cycle_span": 0.4155559649433514, + "path_length": 1.0027263857716855, + "trajectory": [ + [ + 2.9545, + 2.9544, + 2.8551, + 2.7953, + 2.765, + 2.7447, + 2.7284, + 2.7121, + 2.6949, + 2.6785, + 2.6616, + 2.6468, + 2.6305, + 2.6139, + 2.5983, + 2.5819, + 2.5727, + 2.6609, + 2.7756, + 2.8385, + 2.8676, + 2.8817, + 2.8943, + 2.9044, + 2.9141, + 2.92, + 2.9282, + 2.935, + 2.939, + 2.9457, + 2.9497 + ], + [ + 2.5301, + 2.5315, + 2.694, + 2.7736, + 2.7936, + 2.793, + 2.7865, + 2.7792, + 2.7715, + 2.7626, + 2.7546, + 2.747, + 2.7389, + 2.7307, + 2.7233, + 2.7141, + 2.7106, + 2.635, + 2.5424, + 2.4979, + 2.4883, + 2.4888, + 2.4947, + 2.4982, + 2.5033, + 2.508, + 2.512, + 2.5162, + 2.5188, + 2.5222, + 2.5266 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp3-0.4s.csv", + "sha256": "fc7462ffc538a4dbf11bffebd05461decc9ac91ca8a1fce8f6b41a75d26bbb3c" + } + }, + { + "experiment": 3, + "period_seconds": 1.592, + "samples": 31, + "diameter": 1.012848917657515, + "half_cycle_span": 0.9840851233506173, + "path_length": 2.3590400915697805, + "trajectory": [ + [ + 2.9816, + 2.9812, + 2.7752, + 2.7114, + 2.6496, + 2.5896, + 2.5298, + 2.47, + 2.4104, + 2.3514, + 2.2932, + 2.2345, + 2.1771, + 2.1198, + 2.0617, + 2.0063, + 1.9793, + 2.3303, + 2.5771, + 2.7141, + 2.8043, + 2.8653, + 2.9075, + 2.9356, + 2.9528, + 2.9638, + 2.9705, + 2.9745, + 2.9767, + 2.9792, + 2.9798 + ], + [ + 2.5509, + 2.5523, + 2.8096, + 2.7806, + 2.7487, + 2.7199, + 2.69, + 2.6602, + 2.6296, + 2.6001, + 2.5686, + 2.5393, + 2.5097, + 2.4793, + 2.4496, + 2.4197, + 2.4051, + 2.2165, + 2.295, + 2.3856, + 2.4392, + 2.475, + 2.4989, + 2.5182, + 2.5308, + 2.5385, + 2.5428, + 2.5447, + 2.5467, + 2.55, + 2.5506 + ] + ], + "source_file": { + "path": "/scratch/yurenh2/imperfect-learning-physical-systems-v1.0.1/maguzj-imperfect-learning-physical-systems-71b8d72/small network/experimental_bowties/bowtie-exp3-1.592s.csv", + "sha256": "84d1aa7e17a7ce66d3d81c1ec49e04f9930a12bbfb9eae7bcac4ef877319d725" + } + } + ], + "summary": { + "combined_error_log_slope_mean": 0.10887291721453206, + "combined_error_log_slopes": [ + 0.061871046531009194, + 0.2882539659321607, + -0.02350626081957371 + ], + "span_squared_log_slope_mean": 1.8400507296318658, + "span_squared_log_slopes": [ + 1.8373743444902582, + 1.7359736925037077, + 1.9468041519016315 + ], + "span_log_slope_mean": 0.9200253648159329, + "descriptive_plateau_check_abs_error_slope_below_0p4": true, + "descriptive_linear_drift_check_span2_slope_1p5_to_2p3": true + } +} -- cgit v1.2.3