Upload ScooBDoob code without binary caches

.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+.pytest_cache/
+.mplconfig/
+.ruff_cache/
+figures/
+*.pdf
+*.png
+*.svg
+data/mb_reactive/
+data/aib9/
+*.xtc
+*.dcd
+*.trr
+*.npz

INPUTS.tsv

@@ -0,0 +1,11 @@
+analysis	relative_path	purpose
+muller_brown	data/mb_reactive	Saved trajectories for MSM refitting and rollout analyses
+aib9	data/aib9/COLVAR_phi	Continuous OpenMM backbone angles
+aib9	data/aib9/COLVAR_psi	Continuous OpenMM backbone angles
+p53_heldout	data/p53/pocket_sc_feats_s10.pkl	Side-chain feature cache for trajectory-held-out refitting
+p53_heldout	data/p53/frame_drug/frames.json	Per-frame structural observables
+p53_discovery	data/p53/rmsd_matrix.npy	Crystal-to-MD structural comparisons
+p53_discovery	data/p53/pocket_msm_pi.json	Reference Model S populations
+p53_discovery	data/p53/pocket_reps	Representative PDB files and cached Fpocket outputs
+p53_discovery	data/p53/pocket_feats_s10_cb_ALL.pkl	Feature-cache trajectory provenance
+p53_discovery	data/p53/coverage_all_y220c.json	Crystallographic reference metadata

README.md

@@ -1,3 +1,97 @@
----
-license: apache-2.0
----
+# ScooBDoob
+
+## Setup
+
+Use Python 3.10 or newer. Run commands from this directory.
+
+```bash
+python -m pip install -r requirements.txt
+python -m pytest tests -q
+```
+
+## Contents
+
+- `scoobdoob/`: conditioning, MSM construction, and analysis functions.
+- `make_*.py`, `paper_figures/`: paper analyses and plots.
+- `analysis/`, `data/`: sensitivity analyses and saved numerical results.
+- `tests/`: numerical correctness checks.
+
+## Paper analyses
+
+Generate the MB, Aib9 robustness, and p53 plots from the included results:
+
+```bash
+python run_cached_figures.py
+```
+
+Outputs are written to `figures/`. For a subset, use `--only mb`,
+`--only aib9_robustness`, or `--only p53`.
+
+| Analysis | Script |
+| --- | --- |
+| MB sampling comparisons | `make_mb_panels.py`, `make_mb_unconditional.py` |
+| MB replicated statistics and parameter sweeps | `mb_stats.py`, `mb_alpha_seeds.py`, `mb_ticalag_seeds.py` |
+| MB density-floor sensitivity | `analysis/mb_floor_sensitivity/analyze.py` |
+| Aib9 sampling comparison | `make_aib9_method_figure.py` |
+| Aib9 robustness and density sweep | `validate_aib9.py`, `aib9_kappa_sweep.py` |
+| p53 discovery and preference | `paper_figures/data/`, `paper_figures/plot/` |
+| p53 trajectory-held-out analysis | `trajectory_cv_tilt.py`, `summarize_trajectory_cv_tilt.py` |
+
+After preparing the inputs below, rerun the main analyses with:
+
+```bash
+python make_mb_panels.py --cache-only
+python make_mb_unconditional.py --cache-only
+python make_aib9_method_figure.py
+python validate_aib9.py --robustness
+python aib9_kappa_sweep.py
+python paper_figures/data/p53_preference_data.py --splits 400
+```
+
+For the MB floor sweep, run `analyze.py --seed N` for seeds 0–19, then
+`analyze.py --summarize`. Use `--validate` for its exact finite-model check.
+
+## Data
+
+MD trajectories are not distributed with this package. Small numerical results
+and docking scores are included; additional analysis inputs are listed in
+`INPUTS.tsv`.
+
+### Müller–Brown
+
+Generate 12 overdamped Langevin trajectories with the paper settings
+(250,000 steps each, timestep 0.0002, inverse temperature 0.06, saving every
+five steps):
+
+```bash
+python -m scoobdoob.validation.mb_data --out data/mb_reactive
+```
+
+### Aib9
+
+Use the [published Aib9 OpenMM workflow](https://github.com/shams-mehdi/aib9_openmm)
+from [Mehdi et al. (2022)](https://doi.org/10.1021/acs.jctc.2c00058) to prepare
+and simulate the solvated peptide. The paper analyzes a continuous, approximately
+223 ns trajectory at 500 K with a 2 fs timestep. Record the nine backbone
+phi and psi angles in radians every 0.2 ps using PLUMED.
+
+Place `COLVAR_phi` and `COLVAR_psi` in `data/aib9/`, or set
+`SCOOBDOOB_AIB9_DATA` to their directory. Each file should contain time followed
+by nine angles. The loader takes every fifth sample, giving 1 ps spacing.
+
+### p53 Y220C
+
+The supplied numerical results support plotting and docking-preference analysis.
+MSM refits require the feature and pocket-observable files listed in `INPUTS.tsv`.
+Use the simulation and feature definitions in the paper's Methods.
+
+For held-out fits, use `--k` 75, 100, or 150 and `--seed` 0, 1, or 2.
+The observable/threshold pairs are `site_drug`/0.5, `site_volume`/300.865,
+and `site_apolar`/55.551. For example:
+
+```bash
+python trajectory_cv_tilt.py --k 100 --seed 0 --observable site_volume \
+    --drug-thresh 300.865 --out data/p53/trajectory_cv_tilt_vol_k100_seed0.json
+python summarize_trajectory_cv_tilt.py --pattern 'trajectory_cv_tilt_vol_k*_seed*.json' \
+    --out data/p53/trajectory_cv_tilt_vol_robustness.json
+```

aib9_kappa_sweep.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+
+from scoobdoob.validation import aib9, msm_build as mb, tpt
+
+
+ROOT = Path(__file__).resolve().parent
+LAG, K, N_COMP, STRIDE, HORIZON = 5, 100, 4, 5, 320
+N_PATHS = 600
+PATH_SEEDS = (0, 1, 2)
+KAPPAS = (0.0, 0.10, 0.20, 0.36, 0.50, 0.75, 1.00)
+GATE_BETA, TIME_SIGMA, W_FLOOR = 0.5, 0.30, 1e-12
+
+
+def conditioned_kernels(P, target, weights):
+    n_states = P.shape[0]
+    terminal = np.zeros(n_states)
+    terminal[target] = 1.0 / len(target)
+    backward = terminal.copy()
+    messages = [backward.copy()]
+    for t in range(HORIZON - 1, -1, -1):
+        raw = P @ (weights[t] * backward)
+        total = raw.sum()
+        backward = raw / total if total > 0 else np.full(n_states, 1.0 / n_states)
+        messages.append(backward.copy())
+    messages = messages[::-1]
+
+    kernels = []
+    for t in range(HORIZON):
+        numerator = P * (weights[t][None, :] * messages[t + 1][None, :])
+        denominator = (P @ (weights[t] * messages[t + 1]))[:, None]
+        kernel = np.maximum(
+            np.nan_to_num(np.divide(numerator, np.maximum(denominator, 1e-300))),
+            0.0,
+        )
+        row_sum = kernel.sum(axis=1, keepdims=True)
+        bad = (row_sum <= 1e-300).ravel()
+        if bad.any():
+            kernel[bad] = P[bad]
+            row_sum = kernel.sum(axis=1, keepdims=True)
+        kernels.append(kernel / np.maximum(row_sum, 1e-300))
+    return kernels
+
+
+def sample(kernels, starts, seed):
+    rng = np.random.default_rng(seed)
+    paths = []
+    for _ in range(N_PATHS):
+        state = int(rng.choice(starts))
+        path = [state]
+        for kernel in kernels:
+            probabilities = kernel[state]
+            state = int(
+                rng.choice(len(probabilities), p=probabilities / probabilities.sum())
+            )
+            path.append(state)
+        paths.append(np.asarray(path, dtype=int))
+    return paths
+
+
+def main():
+    trajectories, _ = aib9.load_openmm_colvar(stride=STRIDE)
+    features = aib9.featurize_sincos(trajectories)
+    handedness = aib9.handedness_indicator(trajectories)
+    model = mb.build_full_msm(
+        features,
+        handedness,
+        lag=LAG,
+        k=K,
+        n_comp=N_COMP,
+        seed=0,
+        use_tica=True,
+    )
+
+    labels = aib9.classify_microstates(model.active_xy)
+    sets = {
+        name: np.where(labels == name)[0].tolist()
+        for name in ("R", "L", "I_N", "I_C", "other")
+    }
+    P = np.asarray(model.P)
+    pi = np.asarray(model.stationary)
+    projection = model.centers[model.active_symbols][:, :2]
+
+    intermediate = sorted(set(sets["I_N"]) | set(sets["I_C"]))
+    q_intermediate_to_left = tpt.committor_agreement(model, intermediate, sets["L"])[1]
+    net_flux_matrix = np.asarray(
+        tpt.reactive_flux(model, sets["R"], sets["L"]).net_flux
+    )
+    state_flux = (net_flux_matrix.sum(1) + net_flux_matrix.sum(0)) / 2
+
+    n_center = projection[sets["I_N"]].mean(0)
+    c_center = projection[sets["I_C"]].mean(0)
+    gateways = sorted(
+        [
+            i
+            for i in range(model.n_active)
+            if i not in set(intermediate)
+            and i not in set(sets["L"])
+            and abs(q_intermediate_to_left[i] - 0.5) < 0.2
+        ],
+        key=lambda i: -state_flux[i],
+    )[:4]
+    gateway_set = set(gateways)
+
+    state_handedness = model.active_xy
+    n_half = state_handedness[:, 1:4].mean(axis=1)
+    c_half = state_handedness[:, 5:8].mean(axis=1)
+    n_channel = set(sets["I_N"]) | {i for i in sets["other"] if n_half[i] > c_half[i]}
+    c_channel = set(sets["I_C"]) | {i for i in sets["other"] if n_half[i] <= c_half[i]}
+
+    counts = np.asarray(model.model.count_model.count_matrix, dtype=float)
+    rho = np.clip(counts.sum(1), 1.0, None) / counts.sum(1).mean()
+    z = np.log(state_flux / np.maximum(pi, 1e-15) + 1e-9)
+    z = (z - z.mean()) / z.std()
+    time_window = np.exp(
+        -0.5 * ((np.arange(HORIZON) - (HORIZON - 1) / 2) / (TIME_SIGMA * HORIZON)) ** 2
+    )
+
+    results = []
+    for kappa in KAPPAS:
+        density = np.maximum(np.exp(-kappa * rho), W_FLOOR)
+        weights = [
+            np.maximum(
+                density * np.exp(GATE_BETA * z * time_window[t]),
+                W_FLOOR,
+            )
+            for t in range(HORIZON)
+        ]
+        kernels = conditioned_kernels(P, sets["L"], weights)
+
+        seed_metrics = []
+        for seed in PATH_SEEDS:
+            paths = sample(kernels, sets["R"], seed)
+            reaches = []
+            gateway_hits = []
+            channels = []
+            visited = set()
+            for path in paths:
+                visited.update(map(int, path))
+                in_left = np.array([int(x) in set(sets["L"]) for x in path])
+                reaches.append(bool(in_left.any()))
+                if not in_left.any():
+                    continue
+                first_left = int(np.argmax(in_left))
+                before = np.array([int(x) in set(sets["R"]) for x in path[:first_left]])
+                if not before.any():
+                    continue
+                segment = path[int(np.where(before)[0][-1]) : first_left + 1]
+                gateway_hits.append(bool(set(map(int, segment)) & gateway_set))
+                n_count = sum(int(x) in n_channel for x in segment)
+                c_count = sum(int(x) in c_channel for x in segment)
+                channels.append(
+                    "I_N"
+                    if n_count > c_count
+                    else "I_C"
+                    if c_count > n_count
+                    else "other"
+                )
+
+            n_paths = sum(channel == "I_N" for channel in channels)
+            c_paths = sum(channel == "I_C" for channel in channels)
+            seed_metrics.append(
+                {
+                    "reach_pct": 100 * np.mean(reaches),
+                    "gateway_pct": 100 * np.mean(gateway_hits),
+                    "n_channel": n_paths,
+                    "c_channel": c_paths,
+                    "c_share_pct": 100 * c_paths / max(n_paths + c_paths, 1),
+                    "distinct_states": len(visited),
+                }
+            )
+
+        record = {"kappa": kappa, "path_seeds": list(PATH_SEEDS)}
+        for key in seed_metrics[0]:
+            values = np.asarray([metric[key] for metric in seed_metrics], dtype=float)
+            record[key] = {
+                "mean": float(values.mean()),
+                "sd": float(values.std(ddof=1)),
+            }
+        results.append(record)
+        print(
+            f"kappa={kappa:4.2f}  reach={record['reach_pct']['mean']:5.1f}%  "
+            f"gateway={record['gateway_pct']['mean']:5.1f}%  "
+            f"C-share={record['c_share_pct']['mean']:5.1f}%  "
+            f"states={record['distinct_states']['mean']:4.0f}"
+        )
+
+    output = {
+        "model": {
+            "lag_frames": LAG,
+            "frame_interval_ps": 1.0,
+            "horizon": HORIZON,
+            "n_microstates": K,
+            "clustering_seed": 0,
+        },
+        "sampler": {
+            "gate_beta": GATE_BETA,
+            "time_sigma": TIME_SIGMA,
+            "n_paths_per_seed": N_PATHS,
+        },
+        "results": results,
+    }
+    out_path = ROOT / "data" / "aib9_fes" / "aib9_kappa_sweep.json"
+    out_path.write_text(json.dumps(output, indent=2))
+    print(f"wrote {out_path}")
+
+
+if __name__ == "__main__":
+    main()

analysis/mb_floor_sensitivity/all_results.csv

@@ -0,0 +1,121 @@
+s1_probability,expected_distinct_states,expected_self_transitions,self_transition_fraction,expected_s1_state_observations,terminal_probability,max_outside_corridor_probability,max_outside_arrival_mask_probability,condition,floor_percentile,density_floor,fraction_corridor_states_below_floor,independent_recursion_error,cluster_seed
+0.43691794546073415,15.013666141340575,0.6533119085168925,0.04083199428230578,0.5035914002980231,1.0,0.0,0.0,doob,,,,1.1102230246251565e-16,0
+0.9595572296791586,11.733030279406437,1.4831157288792642,0.09269473305495401,2.8990900899171863,0.9999999999999998,0.0,0.0,none,0,0.0,0.0,0.0,0
+0.8902087824180265,11.938725995059936,1.3434524895761015,0.08396578059850635,1.9223774857137172,1.0,0.0,0.0,p10,10,0.22521666666666668,0.05555555555555555,1.1102230246251565e-16,0
+0.7676334652497048,12.162471438442612,1.206251585062303,0.07539072406639394,1.2264193451367236,1.0000000000000002,0.0,0.0,p25,25,0.306125,0.1,1.1102230246251565e-16,0
+0.6878636642681657,12.536110821091299,1.1103615285855495,0.06939759553659684,0.9759709933847585,1.0000000000000002,0.0,0.0,p50,50,0.3833333333333333,0.2,0.0,0
+0.6242797495046818,13.211821050555066,1.019008773393519,0.06368804833709493,0.8256362469038774,0.9999999999999998,0.0,0.0,p75,75,0.5533333333333333,0.3333333333333333,1.1102230246251565e-16,0
+0.47431774413772165,14.962806670822289,0.6646379767601857,0.041539873547511603,0.5656135812877474,1.0000000000000002,0.0,0.0,doob,,,,0.0,1
+0.921186672272567,12.554198995233554,1.2723206679621673,0.07952004174763545,2.491381984616749,1.0,0.0,0.0,none,0,0.0,0.0,1.1102230246251565e-16,1
+0.8740443333450296,12.632418653953259,1.2115611948906388,0.07572257468066493,1.9787923417975324,0.9999999999999997,0.0,0.0,p10,10,0.17853333333333332,0.04395604395604396,1.1102230246251565e-16,1
+0.8045858652078739,12.83339276935726,1.0997845920403504,0.0687365370025219,1.5116968074655235,1.0000000000000002,0.0,0.0,p25,25,0.22158333333333335,0.08791208791208792,1.1102230246251565e-16,1
+0.7171638280522671,13.101709613591051,0.9696859373588358,0.06060537108492724,1.1197796664715896,1.0,0.0,0.0,p50,50,0.31133333333333335,0.17582417582417584,3.3306690738754696e-16,1
+0.6695714939378443,13.124068598363051,0.9589335944737107,0.05993334965460692,0.9806618033719668,0.9999999999999999,0.0,0.0,p75,75,0.3735,0.27472527472527475,3.3306690738754696e-16,1
+0.4770124753307715,15.022239303408549,0.641083807715894,0.040067737982243376,0.5722517563630657,1.0000000000000002,0.0,0.0,doob,,,,0.0,2
+0.9788540758905597,11.552706077458156,1.536411795616068,0.09602573722600426,3.766589674181204,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,1.1102230246251565e-16,2
+0.9567884525122707,11.726665146315467,1.4632838020840366,0.09145523763025229,3.0495216306615904,1.0,0.0,0.0,p10,10,0.16490000000000002,0.05555555555555555,1.1102230246251565e-16,2
+0.7861058920937647,12.46863243700942,1.0849601814080623,0.06781001133800389,1.3789396874220046,0.9999999999999998,0.0,0.0,p25,25,0.30533333333333335,0.08888888888888889,0.0,2
+0.7070082795708856,12.601639392510245,1.0176181458639135,0.0636011341164946,1.0772612246813502,1.0000000000000004,0.0,0.0,p50,50,0.3641666666666667,0.17777777777777778,1.1102230246251565e-16,2
+0.6818964076424328,12.800445043295559,1.0065659793738178,0.06291037371086361,1.0045758468701496,1.0000000000000002,0.0,0.0,p75,75,0.4265,0.2777777777777778,0.0,2
+0.45650454079958447,14.80991960644764,0.7074257266949784,0.04421410791843615,0.5331538613794161,1.0,0.16666666666666666,0.0,doob,,,,1.1102230246251565e-16,3
+0.9580141712857912,11.722590642329202,1.3804948464763818,0.08628092790477386,2.6954344282610743,0.9999999999999998,0.16666666666666666,0.0,none,0,0.0,0.0,1.1102230246251565e-16,3
+0.9274037645156145,11.886116032329102,1.2966589793929524,0.08104118621205952,2.1717549681508266,1.0000000000000002,0.16666666666666666,0.0,p10,10,0.20299999999999999,0.044444444444444446,1.1102230246251565e-16,3
+0.8644404152551027,12.187795360059418,1.1580546182737619,0.07237841364211012,1.6004178669081626,1.0000000000000002,0.16666666666666666,0.0,p25,25,0.2625,0.07777777777777778,0.0,3
+0.7561161682190445,12.54985520188381,1.024436758333206,0.06402729739582537,1.114883703386301,1.0,0.16666666666666666,0.0,p50,50,0.347,0.15555555555555556,0.0,3
+0.7280076348197122,12.662176039866797,1.0083460210337105,0.06302162631460691,1.0420058079762458,1.0,0.16666666666666666,0.0,p75,75,0.3958333333333333,0.24444444444444444,2.220446049250313e-16,3
+0.5529362581820605,15.096978659761653,0.6165138189916382,0.038532113686977384,0.6938552475249293,1.0,0.0,0.0,doob,,,,0.0,4
+0.9962276948671395,11.34002279146719,1.518485787800281,0.09490536173751757,4.920757910254638,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,0.0,4
+0.9921726986874595,11.455959087069008,1.4760596380344395,0.09225372737715247,4.283802798145508,1.0000000000000002,0.0,0.0,p10,10,0.1519,0.043010752688172046,0.0,4
+0.946675144782042,12.218260605057775,1.2002374039935013,0.07501483774959383,2.595595583070055,1.0,0.0,0.0,p25,25,0.254,0.08602150537634409,0.0,4
+0.8183163335930693,12.859082521969363,1.0121470034882263,0.06325918771801414,1.4608022924170065,1.0,0.0,0.0,p50,50,0.3795,0.17204301075268819,1.1102230246251565e-16,4
+0.7688763668259164,13.114078672127016,0.9792047667707706,0.061200297923173164,1.2307998669706566,1.0000000000000002,0.0,0.0,p75,75,0.4625,0.27956989247311825,1.1102230246251565e-16,4
+0.4475602830610881,15.094047987295635,0.6207786082633657,0.03879866301646036,0.5208747341411591,1.0000000000000002,0.0,0.0,doob,,,,1.1102230246251565e-16,5
+0.9530796173580153,11.884313166919643,1.411491487518026,0.08821821796987663,3.014314188472334,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,0.0,5
+0.9127507912936526,12.049203567603252,1.3080615820306891,0.08175384887691807,2.3538333584987883,0.9999999999999999,0.0,0.0,p10,10,0.18513333333333334,0.05555555555555555,0.0,5
+0.7411179555254174,12.60407489377736,1.0541361022213542,0.06588350638883464,1.2146468265537802,0.9999999999999999,0.0,0.0,p25,25,0.30883333333333335,0.1111111111111111,1.1102230246251565e-16,5
+0.6804422405100263,12.681695688214198,1.0189917438498421,0.06368698399061513,1.008741924340221,0.9999999999999999,0.0,0.0,p50,50,0.36233333333333334,0.2111111111111111,0.0,5
+0.5838773589540722,13.628192477580198,0.8897060914934126,0.05560663071833829,0.7727162921515831,0.9999999999999999,0.0,0.0,p75,75,0.5523333333333333,0.3333333333333333,4.440892098500626e-16,5
+0.4330891968703052,14.812621566148653,0.7115744248981953,0.04447340155613721,0.5060695633503917,1.0,0.0,0.0,doob,,,,1.1102230246251565e-16,6
+0.9862046252727615,11.587086114432688,1.4214949908667145,0.08884343692916966,3.9865094885600447,0.9999999999999992,0.0,0.0,none,0,0.0,0.0,0.0,6
+0.9836480121489333,11.602393615840489,1.410855463597818,0.08817846647486363,3.8014144944916866,0.9999999999999999,0.0,0.0,p10,10,0.11635000000000001,0.03409090909090909,0.0,6
+0.9306993298623017,11.921810944168588,1.3139973024524192,0.0821248314032762,2.4684163841751254,1.0,0.0,0.0,p25,25,0.20033333333333334,0.07954545454545454,1.1102230246251565e-16,6
+0.7754659268098913,12.624829062467224,1.0498558002845293,0.06561598751778308,1.362450444544891,1.0,0.0,0.0,p50,50,0.32508333333333334,0.17045454545454544,0.0,6
+0.695208874139938,12.679419500226675,1.0121127701508243,0.06325704813442652,1.0637699981720814,1.0000000000000002,0.0,0.0,p75,75,0.411625,0.2727272727272727,0.0,6
+0.4884589808111566,14.994452299580114,0.6482842306768242,0.04051776441730151,0.5785314679769923,1.0,0.0,0.0,doob,,,,1.1102230246251565e-16,7
+0.9970695060214769,11.119728321434357,1.6311413077969785,0.10194633173731116,5.117273761682558,1.0000000000000007,0.0,0.0,none,0,0.0,0.0,0.0,7
+0.9905373110999428,11.282207434922423,1.546376692189688,0.0966485432618555,4.127171135559552,1.0000000000000004,0.0,0.0,p10,10,0.15273333333333336,0.056818181818181816,0.0,7
+0.9071215542274581,11.996151855457436,1.2650281951517115,0.07906426219698197,2.053269132739316,1.0000000000000002,0.0,0.0,p25,25,0.28370833333333334,0.09090909090909091,0.0,7
+0.78024190725,12.635238791275325,1.0605083364204373,0.06628177102627733,1.2401950270444022,1.0000000000000002,0.0,0.0,p50,50,0.3988333333333334,0.18181818181818182,0.0,7
+0.7291624828547295,13.128647027607355,0.9858064336192434,0.06161290210120271,1.044385291903564,0.9999999999999999,0.0,0.0,p75,75,0.4955,0.2840909090909091,2.220446049250313e-16,7
+0.5054293429258443,14.854209733539234,0.6975411031703469,0.04359631894814668,0.6073257775311078,0.9999999999999999,0.0,0.0,doob,,,,2.220446049250313e-16,8
+0.9940177316962647,11.509475480412506,1.5475124157900457,0.09671952598687786,5.095286662920895,1.0000000000000004,0.0,0.0,none,0,0.0,0.0,0.0,8
+0.9830252052368973,11.721096187851614,1.4345296572099877,0.08965810357562423,4.017327042556997,1.0000000000000004,0.0,0.0,p10,10,0.16044999999999998,0.056818181818181816,0.0,8
+0.8854252755682153,12.099530695987792,1.2263908921328786,0.07664943075830491,2.0259081797573457,0.9999999999999997,0.0,0.0,p25,25,0.26104166666666667,0.06818181818181818,0.0,8
+0.761042673816384,12.270895988869396,1.0851524193189312,0.0678220262074332,1.283189944065588,1.0000000000000004,0.0,0.0,p50,50,0.33991666666666664,0.17045454545454544,2.220446049250313e-16,8
+0.7115873574216767,12.66425418303297,1.0320268561339894,0.06450167850837434,1.1069094672502628,0.9999999999999999,0.0,0.0,p75,75,0.476875,0.2840909090909091,0.0,8
+0.4321947930753325,14.959125837669543,0.6528087882950669,0.040800549268441684,0.5043806778973854,1.0,0.0,0.0,doob,,,,0.0,9
+0.9922548889637395,11.158649449096961,1.7718351738964258,0.11073969836852661,4.681688268883696,0.9999999999999998,0.0,0.0,none,0,0.0,0.0,0.0,9
+0.9862652954199567,11.23542193589623,1.6771373550243227,0.10482108468902017,4.0906750835499555,0.9999999999999998,0.0,0.0,p10,10,0.14635,0.04597701149425287,0.0,9
+0.8542112181689199,11.811094967472858,1.3295836088353485,0.08309897555220928,1.7944217524464068,1.0,0.0,0.0,p25,25,0.2720416666666667,0.06896551724137931,1.1102230246251565e-16,9
+0.7002573561629514,12.247741214714685,1.1058247327645034,0.06911404579778146,1.0830644694916232,1.0000000000000002,0.0,0.0,p50,50,0.36916666666666664,0.16091954022988506,1.1102230246251565e-16,9
+0.6281463071310748,13.061567615927256,1.0008641881095364,0.06255401175684602,0.8914368368993364,1.0,0.0,0.0,p75,75,0.5270416666666667,0.27586206896551724,2.220446049250313e-16,9
+0.6051181115385142,14.898790156219114,0.6895663770362908,0.04309789856476817,0.7978389368820248,1.0,0.0,0.0,doob,,,,0.0,10
+0.9960723731249793,12.108313232484242,1.2484269792291747,0.07802668620182342,4.784325928801066,0.9999999999999999,0.0,0.0,none,0,0.0,0.0,0.0,10
+0.9886936975414197,12.345579862311531,1.2027634815656683,0.07517271759785427,3.8259931725796976,1.0000000000000002,0.0,0.0,p10,10,0.15466666666666667,0.0449438202247191,0.0,10
+0.9441917969436444,12.687284115336098,1.063120271254222,0.06644501695338888,2.2645034779545337,0.9999999999999998,0.0,0.0,p25,25,0.2615,0.0898876404494382,0.0,10
+0.9067334886564498,12.81703412684616,1.0081206556493085,0.06300754097808178,1.8045492433168,0.9999999999999999,0.0,0.0,p50,50,0.31466666666666665,0.16853932584269662,0.0,10
+0.8779686750518605,12.991303042068983,0.9682211305877053,0.06051382066173158,1.5892576833755752,0.9999999999999999,0.0,0.0,p75,75,0.37566666666666665,0.2696629213483146,0.0,10
+0.5227648276466925,14.952478476397784,0.6698842167729214,0.04186776354830759,0.6485438186452674,1.0,0.0,0.0,doob,,,,0.0,11
+0.9764343521424959,11.840554429710174,1.4049643499017979,0.08781027186886237,3.6834512261704884,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,0.0,11
+0.9654393738446215,11.98816705508663,1.340488749764659,0.08378054686029118,3.3155282335956326,1.0000000000000002,0.0,0.0,p10,10,0.13820000000000002,0.05555555555555555,0.0,11
+0.9000840431726618,12.379209353329747,1.1727567904554896,0.0732972994034681,2.1995035743632476,0.9999999999999998,0.0,0.0,p25,25,0.22129166666666666,0.1111111111111111,1.1102230246251565e-16,11
+0.7637631333045501,12.741223593205294,1.0348147023423626,0.06467591889639766,1.3413614896784345,1.0000000000000002,0.0,0.0,p50,50,0.34441666666666665,0.2111111111111111,1.1102230246251565e-16,11
+0.6825699061407696,13.06836698527062,0.9818561100047247,0.061366006875295295,1.0506181378973352,0.9999999999999997,0.0,0.0,p75,75,0.49687499999999996,0.32222222222222224,2.220446049250313e-16,11
+0.43150466464742265,14.958334976066823,0.646413093784507,0.040400818361531685,0.49979048531686193,1.0000000000000002,0.0,0.0,doob,,,,0.0,12
+0.988923030398696,11.688235191755401,1.4661954290112311,0.09163721431320195,4.050480062642302,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,0.0,12
+0.9855422938397457,11.713517855443706,1.4352571804827687,0.08970357378017305,3.79892881277627,1.0000000000000004,0.0,0.0,p10,10,0.12803333333333333,0.034482758620689655,0.0,12
+0.8476239480490195,12.426199837847292,1.0800756165620315,0.06750472603512697,1.6311665058150513,0.9999999999999998,0.0,0.0,p25,25,0.26275,0.09195402298850575,2.220446049250313e-16,12
+0.7544350487486045,12.511998253499439,1.0285811310685948,0.06428632069178718,1.207751153064137,0.9999999999999999,0.0,0.0,p50,50,0.3285,0.1839080459770115,2.220446049250313e-16,12
+0.6601035016617813,13.21859773674616,0.9393830882581088,0.0587114430161318,0.9361200763687552,1.0,0.0,0.0,p75,75,0.5500833333333333,0.3103448275862069,3.3306690738754696e-16,12
+0.5644169520367373,14.907966245921752,0.6821570141263407,0.04263481338289629,0.7030244957756517,0.9999999999999999,0.0,0.0,doob,,,,1.1102230246251565e-16,13
+0.9995822259964128,11.028821590700947,1.620670447864448,0.101291902991528,6.3844195580942165,1.0000000000000004,0.0,0.0,none,0,0.0,0.0,0.0,13
+0.9982600785956507,11.266864578810566,1.5829988979751701,0.09893743112344813,5.277765857814593,0.9999999999999999,0.0,0.0,p10,10,0.1595666666666667,0.05813953488372093,0.0,13
+0.9759464362308001,11.872651211875759,1.4015521068986858,0.08759700668116786,3.089001381621692,1.0,0.0,0.0,p25,25,0.26416666666666666,0.10465116279069768,0.0,13
+0.8314949774975573,12.749958528241645,1.0784138744273526,0.06740086715170954,1.4307226559464783,1.0,0.0,0.0,p50,50,0.41883333333333334,0.19767441860465115,2.220446049250313e-16,13
+0.7880574122487745,13.095931046640345,1.0176976594917684,0.06360610371823552,1.2267282859841262,0.9999999999999997,0.0,0.0,p75,75,0.49483333333333335,0.313953488372093,2.220446049250313e-16,13
+0.45817858397768185,15.013769341014864,0.6450019739490105,0.040312623371813155,0.5366109157711714,1.0,0.0,0.0,doob,,,,2.220446049250313e-16,14
+0.9696157237057008,11.698324699493291,1.4327847953261001,0.08954904970788126,3.2328725221772694,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,0.0,14
+0.9504459941648574,11.730085388967026,1.3837907183634548,0.08648691989771592,2.7702876080665657,1.0,0.0,0.0,p10,10,0.17400000000000002,0.045454545454545456,0.0,14
+0.8550732563525272,11.849763126034592,1.2824634098773733,0.08015396311733583,1.7557732258712033,0.9999999999999997,0.0,0.0,p25,25,0.24566666666666667,0.07954545454545454,0.0,14
+0.6970726461583261,12.781191300620106,1.0273923036735624,0.06421201897959765,1.0613050980570757,1.0000000000000002,0.0,0.0,p50,50,0.38116666666666665,0.19318181818181818,2.220446049250313e-16,14
+0.6279562111989816,13.45153592577016,0.9476847582789945,0.05923029739243715,0.8730248746739183,1.0,0.0,0.0,p75,75,0.49783333333333335,0.32954545454545453,1.1102230246251565e-16,14
+0.5853865507163494,15.035766065692105,0.6366963051976371,0.03979351907485232,0.7644231778054192,1.0000000000000002,0.0,0.0,doob,,,,2.220446049250313e-16,15
+0.989443457761515,12.042604625242614,1.4167824752841478,0.08854890470525924,4.356122662242784,1.0,0.0,0.0,none,0,0.0,0.0,0.0,15
+0.9759379667573901,12.261838416733776,1.3125205161728628,0.08203253226080393,3.541394526083165,1.0000000000000002,0.0,0.0,p10,10,0.16111666666666669,0.05434782608695652,0.0,15
+0.8932853974358681,12.820922793413317,1.0515828741564877,0.06572392963478048,1.969194834993593,0.9999999999999997,0.0,0.0,p25,25,0.26491666666666663,0.10869565217391304,1.1102230246251565e-16,15
+0.832556953327635,12.83180481468052,0.9955184938708881,0.062219905866930506,1.5327626604734748,1.0000000000000002,0.0,0.0,p50,50,0.32399999999999995,0.20652173913043478,2.220446049250313e-16,15
+0.7885261940702322,13.008696207651493,0.965879401768791,0.060367462610549434,1.3145724952877371,0.9999999999999999,0.0,0.0,p75,75,0.43825000000000003,0.29347826086956524,2.220446049250313e-16,15
+0.4837880922813723,15.042876505280352,0.6341114606979306,0.03963196629362066,0.5775827916257097,1.0,0.0,0.0,doob,,,,2.220446049250313e-16,16
+0.9917865141498091,11.845921704214799,1.280111885500374,0.08000699284377337,4.454788340196466,1.0000000000000004,0.0,0.0,none,0,0.0,0.0,0.0,16
+0.9796062551512817,11.972994713920363,1.2552591091124683,0.07845369431952927,3.6295932982820784,0.9999999999999999,0.0,0.0,p10,10,0.14175,0.05555555555555555,0.0,16
+0.9089795841296135,12.338684626584055,1.115876816720724,0.06974230104504525,2.1914936962783855,1.0000000000000002,0.0,0.0,p25,25,0.230125,0.1,0.0,16
+0.750461636250534,12.998491601091787,0.9397360252722106,0.05873350157951316,1.2131966351385546,1.0000000000000002,0.0,0.0,p50,50,0.357,0.18888888888888888,1.1102230246251565e-16,16
+0.7251508494551543,13.036352824416662,0.9406048818053995,0.05878780511283747,1.1197531901503124,1.0,0.0,0.0,p75,75,0.39245833333333335,0.3,0.0,16
+0.506739254130001,14.803467535092778,0.7189674227192553,0.044935463919953456,0.6154647589491531,1.0,0.0,0.0,doob,,,,1.1102230246251565e-16,17
+0.9664202615157165,12.02215316179213,1.339269336429185,0.08370433352682406,3.11550809490882,1.0000000000000002,0.0,0.0,none,0,0.0,0.0,0.0,17
+0.9404164221867446,12.118348013862942,1.2742328206125921,0.07963955128828701,2.5356605932571266,0.9999999999999996,0.0,0.0,p10,10,0.18708333333333332,0.047058823529411764,1.1102230246251565e-16,17
+0.7988441067613953,12.345487304715524,1.0931751257950446,0.06832344536219029,1.380012686167018,1.0000000000000002,0.0,0.0,p25,25,0.29191666666666666,0.10588235294117647,2.220446049250313e-16,17
+0.7727105408685718,12.450340568775854,1.058037068630455,0.06612731678940344,1.2707168266977908,0.9999999999999998,0.0,0.0,p50,50,0.3154166666666667,0.18823529411764706,0.0,17
+0.726303143742091,12.727484622353309,1.0044951140423584,0.0627809446276474,1.1208166008893121,1.0000000000000002,0.0,0.0,p75,75,0.40325,0.2823529411764706,2.220446049250313e-16,17
+0.46599293713852674,14.81881748965592,0.7261562803021575,0.045384767518884844,0.5499415632673067,1.0000000000000002,0.16666666666666666,0.0,doob,,,,1.1102230246251565e-16,18
+0.9716797561020993,11.345619862067814,1.6230656449742473,0.10144160281089046,3.440952451261235,1.0000000000000002,0.16666666666666666,0.0,none,0,0.0,0.0,1.1102230246251565e-16,18
+0.9676600844143882,11.341798298267861,1.6109208351440203,0.10068255219650127,3.2959845573650792,1.0,0.16666666666666666,0.0,p10,10,0.16426666666666667,0.03409090909090909,1.1102230246251565e-16,18
+0.9167709099313877,11.431522120805528,1.5187491425301674,0.09492182140813546,2.3683237529140384,1.0000000000000002,0.16666666666666666,0.0,p25,25,0.21945833333333334,0.06818181818181818,1.1102230246251565e-16,18
+0.7979787092834122,12.0758916497212,1.2619461483905667,0.07887163427441042,1.5012528726304077,1.0,0.16666666666666666,0.0,p50,50,0.32025000000000003,0.13636363636363635,0.0,18
+0.6911013312412888,12.577765689529569,1.1156690158244678,0.06972931348902923,1.0913266157219796,0.9999999999999998,0.16666666666666666,0.0,p75,75,0.4329166666666666,0.2159090909090909,3.3306690738754696e-16,18
+0.5911223376745427,15.037682806054997,0.6173704673959552,0.0385856542122472,0.7563655871719949,1.0,0.0,0.0,doob,,,,0.0,19
+0.9940628269348554,11.92295814454286,1.2530964816499932,0.07831853010312458,4.4945914608736635,0.9999999999999997,0.0,0.0,none,0,0.0,0.0,0.0,19
+0.9851874451785548,12.117485369184298,1.1871902273862402,0.07419938921164002,3.7013947994795875,0.9999999999999999,0.0,0.0,p10,10,0.16283333333333333,0.056179775280898875,0.0,19
+0.924501258010828,12.43542465705962,1.052367675030286,0.06577297968939287,2.1850920352979477,0.9999999999999998,0.0,0.0,p25,25,0.25966666666666666,0.10112359550561797,1.1102230246251565e-16,19
+0.8591177847987432,12.744674789431965,0.955353538458335,0.05970959615364594,1.6170819071311933,0.9999999999999999,0.0,0.0,p50,50,0.33216666666666667,0.19101123595505617,1.1102230246251565e-16,19
+0.8012584473980241,13.374537050824975,0.8727450747307617,0.054546567170672605,1.3430220419973777,1.0,0.0,0.0,p75,75,0.46108333333333335,0.29213483146067415,1.1102230246251565e-16,19

analysis/mb_floor_sensitivity/analyze.py

@@ -0,0 +1,499 @@
+from pathlib import Path
+import argparse
+import csv
+import hashlib
+import importlib.metadata
+import itertools
+import json
+import platform
+import sys
+import time
+
+import numpy as np
+
+OUT = Path(__file__).resolve().parent
+ROOT = OUT.parents[1]
+sys.path.insert(0, str(ROOT))
+from scoobdoob import _conditioning
+
+CONDITIONS = [
+    ("doob", None),
+    ("none", 0),
+    ("p10", 10),
+    ("p25", 25),
+    ("p50", 50),
+    ("p75", 75),
+]
+SETTINGS = dict(
+    cluster_seeds=list(range(20)),
+    k=100,
+    tica_lag=20,
+    msm_lag=5,
+    horizon=16,
+    alpha_per_transition=7.5,
+    floor_percentiles=[10, 25, 50, 75],
+    no_floor_control=True,
+    start_law="uniform on the original source set; fixed-start mixture",
+    s1_radius=0.25,
+)
+
+
+def dump(path, obj):
+    path.write_text(json.dumps(obj, indent=2, allow_nan=False) + "\n")
+
+
+def digest(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def exact_metrics(kernels, mu, region, targets, corridor):
+    """Forward full law and killed laws, including the state at step zero."""
+    m, n = len(mu), len(kernels)
+    mass = mu.copy()
+    survival = mu.copy()
+    survival[region] = 0
+    avoiding = np.broadcast_to(mu, (m, m)).copy()
+    np.fill_diagonal(avoiding, 0)
+    s1_occupancy = float(mass[region].sum())
+    self_steps = 0.0
+    max_outside = float(mass[~corridor].sum())
+    max_outside_arrivals = 0.0
+    for K in kernels:
+        self_steps += float(mass @ np.diag(K))
+        mass = mass @ K
+        np.testing.assert_allclose(mass.sum(), 1, atol=2e-12, rtol=0)
+        max_outside = max(max_outside, float(mass[~corridor].sum()))
+        max_outside_arrivals = max(max_outside_arrivals, float(mass[~corridor].sum()))
+        s1_occupancy += float(mass[region].sum())
+        survival = survival @ K
+        survival[region] = 0
+        avoiding = avoiding @ K
+        np.fill_diagonal(avoiding, 0)
+    hit_each = np.clip(1 - avoiding.sum(axis=1), 0, 1)
+    return dict(
+        s1_probability=float(np.clip(1 - survival.sum(), 0, 1)),
+        expected_distinct_states=float(hit_each.sum()),
+        expected_self_transitions=self_steps,
+        self_transition_fraction=self_steps / n,
+        expected_s1_state_observations=s1_occupancy,
+        terminal_probability=float(mass[targets].sum()),
+        max_outside_corridor_probability=max_outside,
+        max_outside_arrival_mask_probability=max_outside_arrivals,
+    )
+
+
+def reference_hit_probability(P, w, mu, region, targets, horizon):
+    """Independent ratio of weighted path sums, separately for each start."""
+    full = np.zeros(len(P))
+    full[targets] = 1
+    avoided = full.copy()
+    avoided[region] = 0
+    w_avoid = w.copy()
+    w_avoid[region] = 0
+    for _ in range(horizon):
+        full = P @ (w * full)
+        avoided = P @ (w_avoid * avoided)
+        scale = float(full.max())
+        if scale <= 0:
+            raise RuntimeError("No feasible weighted continuation")
+        full /= scale
+        avoided /= scale
+    initial = mu > 0
+    if np.any(full[initial] <= 0):
+        raise RuntimeError("Infeasible prescribed start")
+    avoided[region] = 0
+    return float(1 - mu[initial] @ (avoided[initial] / full[initial]))
+
+
+def validate_toy():
+    """Brute-force the weighted reference law, not a second kernel simulation."""
+    P = np.array([[0.5, 0.4, 0.1], [0.1, 0.6, 0.3], [0.2, 0.3, 0.5]])
+    w = np.array([0.7, 0.3, 1.2])
+    mu = np.array([0.3, 0.7, 0.0])
+    region = np.array([False, True, False])
+    targets = np.array([2])
+    horizon = 4
+    kernels, _ = _conditioning.build(P, w, targets, horizon, starts=[0, 1])
+    got = exact_metrics(kernels, mu, region, targets, np.ones(3, dtype=bool))
+    expected = np.zeros(4)
+    for i in [0, 1]:
+        norm = 0.0
+        moments = np.zeros(4)
+        for rest in itertools.product(range(3), repeat=horizon):
+            if rest[-1] != 2:
+                continue
+            path = (i,) + rest
+            prob = float(np.prod([P[a, b] * w[b] for a, b in zip(path[:-1], path[1:])]))
+            norm += prob
+            moments += prob * np.array(
+                [
+                    any(region[s] for s in path),
+                    len(set(path)),
+                    sum(a == b for a, b in zip(path[:-1], path[1:])),
+                    sum(region[s] for s in path),
+                ],
+                dtype=float,
+            )
+        expected += mu[i] * moments / norm
+    actual = [
+        got[k]
+        for k in [
+            "s1_probability",
+            "expected_distinct_states",
+            "expected_self_transitions",
+            "expected_s1_state_observations",
+        ]
+    ]
+    np.testing.assert_allclose(actual, expected, atol=2e-12, rtol=0)
+    other = reference_hit_probability(P, w, mu, region, targets, horizon)
+    np.testing.assert_allclose(other, expected[0], atol=2e-12, rtol=0)
+
+    masked_w = np.array([0.0, 0.3, 1.2])
+    K, _ = _conditioning.build(P, masked_w, targets, 1, starts=[0])
+    edge = exact_metrics(K, np.array([1.0, 0.0, 0.0]), region, targets, masked_w > 0)
+    np.testing.assert_allclose(
+        [
+            edge["terminal_probability"],
+            edge["expected_distinct_states"],
+            edge["max_outside_corridor_probability"],
+            edge["max_outside_arrival_mask_probability"],
+        ],
+        [1.0, 2.0, 1.0, 0.0],
+        atol=2e-12,
+        rtol=0,
+    )
+    return dict(
+        exhaustive_reference_check=True,
+        outside_mask_start_check=True,
+        max_absolute_error=float(np.max(np.abs(np.array(actual) - expected))),
+    )
+
+
+def run(seed):
+    start_time = time.time()
+    toy = validate_toy()
+    from scoobdoob.validation import msm_build as mb, tpt
+    from scoobdoob.validation import mb_ground_truth as gt
+    from scoobdoob.validation import mb_data as V
+
+    files = sorted((ROOT / "data/mb_reactive").glob("traj_*.npy"))
+    if len(files) != 12:
+        raise RuntimeError(
+            "Expected twelve trajectory files in data/mb_reactive; run python -m scoobdoob.validation.mb_data first"
+        )
+    trajs = [np.load(p).astype(np.float64) for p in files]
+    model = mb.build_full_msm(
+        trajs, trajs, lag=5, tica_lag=20, k=100, n_comp=2, seed=seed, use_tica=True
+    )
+
+    np.testing.assert_array_equal(model.active_symbols, np.arange(100))
+    A, B, _ = mb.q2_sign_endpoints(model)
+    starts, targets = V.orient_endpoints(model, A, B)
+    starts, targets = np.array(starts), np.array(targets)
+    xy = model.active_xy
+    agreement, q, _ = tpt.committor_agreement(model, starts.tolist(), targets.tolist())
+    flux = tpt.reactive_flux(model, starts.tolist(), targets.tolist())
+    through = np.asarray(flux.gross_flux).sum(axis=1)
+    corridor = through / through.sum() > 0.5 / model.n_active
+    corridor[starts] = True
+    corridor[targets] = True
+    saddles = gt.saddle_points()
+    S1 = saddles[np.argmin(saddles[:, 0])]
+    landmarks = np.vstack([xy[starts].mean(0), xy[targets].mean(0), saddles])
+    lo, hi = landmarks.min(0) - 0.35, landmarks.max(0) + 0.35
+    corridor &= np.all((xy >= lo) & (xy <= hi), axis=1)
+
+    counts = model.counts[model.active_symbols].astype(float)
+    rho = np.maximum(counts, 1) / counts.mean()
+    react = (q > 0.05) & (q < 0.95)
+    region = np.linalg.norm(xy - S1, axis=1) < 0.25
+    if not np.any(region) or not np.any(react):
+        raise RuntimeError("Missing S1 or reference committor region")
+    mu = np.zeros(model.n_active)
+    mu[starts] = 1 / len(starts)
+    saved_match = None
+    if seed == 0:
+        with np.load(
+            ROOT / "data/mb_panels_data/panels_cache.npz", allow_pickle=True
+        ) as z:
+            saved_match = dict(
+                max_state_coordinate_difference=float(np.max(np.abs(xy - z["xy"]))),
+                counts_equal=bool(np.array_equal(counts, z["counts"])),
+                corridor_equal=bool(np.array_equal(corridor, z["on"])),
+            )
+    np.savez_compressed(
+        OUT / f"model_{seed:02d}.npz",
+        P=model.P,
+        pi=model.stationary,
+        q=q,
+        xy=xy,
+        counts=counts,
+        rho=rho,
+        corridor=corridor,
+        source=starts,
+        target=targets,
+        S1_region=region,
+        mu=mu,
+    )
+    records = []
+    for name, pct in CONDITIONS:
+        floor = (
+            None
+            if pct is None
+            else (0.0 if pct == 0 else float(np.percentile(rho[react], pct)))
+        )
+        w = (
+            np.ones_like(rho)
+            if name == "doob"
+            else np.exp(-7.5 * np.maximum(rho, floor))
+        )
+        if np.any(w <= 0):
+            raise FloatingPointError("A positive density weight underflowed")
+        w[~corridor] = 0
+        kernels, h = _conditioning.build(model.P, w, targets, 16, starts=starts)
+        for K in kernels:
+            if np.any((K > 0) & (model.P == 0)):
+                raise RuntimeError("New edge introduced")
+        record = exact_metrics(kernels, mu, region, targets, corridor)
+        independent = reference_hit_probability(model.P, w, mu, region, targets, 16)
+        error = abs(independent - record["s1_probability"])
+        if error > 2e-10:
+            raise AssertionError(f"Two path-law calculations disagree by {error}")
+        record.update(
+            condition=name,
+            floor_percentile=pct,
+            density_floor=floor,
+            fraction_corridor_states_below_floor=(
+                None if floor is None else float(np.mean(rho[corridor] < floor))
+            ),
+            independent_recursion_error=error,
+        )
+        records.append(record)
+        print(
+            f"seed={seed} {name} S1={record['s1_probability']:.8f} "
+            f"distinct/path={record['expected_distinct_states']:.6f}",
+            flush=True,
+        )
+    source_names = [
+        "make_mb_panels.py",
+        "mb_stats.py",
+        "scoobdoob/validation/msm_build.py",
+        "scoobdoob/_conditioning.py",
+        "scoobdoob/validation/mb_data.py",
+    ]
+    sources = {str(p.relative_to(ROOT)): digest(p) for p in files}
+    sources.update({p: digest(ROOT / p) for p in source_names})
+    sources[str(Path(__file__).relative_to(ROOT))] = digest(__file__)
+    versions = {
+        p: importlib.metadata.version(p)
+        for p in ["numpy", "scipy", "scikit-learn", "deeptime"]
+    }
+    dump(
+        OUT / f"result_{seed:02d}.json",
+        dict(
+            seed=seed,
+            settings=SETTINGS,
+            records=records,
+            n_frames=sum(len(t) for t in trajs),
+            n_active=model.n_active,
+            corridor_states=int(corridor.sum()),
+            s1_states=int(region.sum()),
+            source_states_outside_arrival_mask=starts[~corridor[starts]].tolist(),
+            target_states_outside_arrival_mask=targets[~corridor[targets]].tolist(),
+            reference_committor_agreement=float(agreement),
+            seed0_saved_figure_check=saved_match,
+            validation=toy,
+            source_sha256=sources,
+            versions=versions,
+            python=platform.python_version(),
+            elapsed_seconds=time.time() - start_time,
+        ),
+    )
+
+
+def summarize():
+    results = [
+        json.loads((OUT / f"result_{s:02d}.json").read_text()) for s in range(20)
+    ]
+    if any(r["settings"] != SETTINGS for r in results):
+        raise RuntimeError("Inconsistent settings")
+    if len({json.dumps(r["source_sha256"], sort_keys=True) for r in results}) != 1:
+        raise RuntimeError("Source/data hashes changed across jobs")
+    records = [
+        {**row, "cluster_seed": r["seed"]} for r in results for row in r["records"]
+    ]
+    with (OUT / "all_results.csv").open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=list(records[0]))
+        writer.writeheader()
+        writer.writerows(records)
+    values = {
+        name: np.array(
+            [
+                next(x for x in r["records"] if x["condition"] == name)[
+                    "s1_probability"
+                ]
+                for r in results
+            ]
+        )
+        * 100
+        for name, _ in CONDITIONS
+    }
+    stats = {}
+    for name, _ in CONDITIONS:
+        y = values[name]
+        delta = y - values["doob"]
+        delta25 = y - values["p25"]
+        by = [next(x for x in r["records"] if x["condition"] == name) for r in results]
+        stats[name] = dict(
+            s1_mean_pct=float(y.mean()),
+            s1_sd_pct=float(y.std(ddof=1)),
+            s1_min_pct=float(y.min()),
+            s1_max_pct=float(y.max()),
+            paired_gain_vs_doob_mean_pp=float(delta.mean()),
+            paired_gain_vs_doob_min_pp=float(delta.min()),
+            paired_gain_vs_doob_max_pp=float(delta.max()),
+            paired_vs_p25_mean_pp=float(delta25.mean()),
+            paired_vs_p25_min_pp=float(delta25.min()),
+            paired_vs_p25_max_pp=float(delta25.max()),
+            n_clusterings_better_than_doob=int(np.sum(delta > 1e-10)),
+            distinct_per_path_mean=float(
+                np.mean([x["expected_distinct_states"] for x in by])
+            ),
+            self_steps_mean=float(
+                np.mean([x["expected_self_transitions"] for x in by])
+            ),
+        )
+    archive = json.loads((ROOT / "data/mb_stats.json").read_text())
+    comparison = {
+        name: dict(
+            archived_mean_pct=float(np.mean(archive[key])),
+            mean_exact_minus_archived_pp=float(np.mean(values[name] - archive[key])),
+            max_absolute_difference_pp=float(
+                np.max(np.abs(values[name] - archive[key]))
+            ),
+        )
+        for name, key in [("doob", "raw"), ("p25", "fk")]
+    }
+    check = dict(
+        toy_exhaustive_passed=all(
+            r["validation"]["exhaustive_reference_check"] for r in results
+        ),
+        max_independent_recursion_error=max(
+            x["independent_recursion_error"] for x in records
+        ),
+        max_terminal_error=max(abs(x["terminal_probability"] - 1) for x in records),
+        max_outside_corridor_probability=max(
+            x["max_outside_corridor_probability"] for x in records
+        ),
+        max_outside_arrival_mask_probability=max(
+            x["max_outside_arrival_mask_probability"] for x in records
+        ),
+        endpoint_mask_exceptions=[
+            dict(
+                seed=r["seed"],
+                source=r["source_states_outside_arrival_mask"],
+                target=r["target_states_outside_arrival_mask"],
+            )
+            for r in results
+            if r["source_states_outside_arrival_mask"]
+            or r["target_states_outside_arrival_mask"]
+        ],
+        seed0_saved_figure_check=results[0]["seed0_saved_figure_check"],
+    )
+    summary = dict(
+        settings=SETTINGS,
+        conditions=stats,
+        checks=check,
+        archive_comparison=comparison,
+        scope="Exact probabilities on refitted MSMs from fixed MD data. SD is clustering sensitivity, not MD uncertainty.",
+        completed_clusterings=len(results),
+    )
+    dump(OUT / "summary.json", summary)
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    labels = ["No floor", "10th", "25th (original)", "50th", "75th"]
+    names = ["none", "p10", "p25", "p50", "p75"]
+    fig, axes = plt.subplots(1, 2, figsize=(10, 4.3))
+    x = np.arange(5)
+    for s in range(20):
+        axes[0].plot(
+            x, [values[n][s] for n in names], color="#93b6cc", alpha=0.42, lw=0.8
+        )
+        axes[1].plot(
+            x,
+            [values[n][s] - values["doob"][s] for n in names],
+            color="#93b6cc",
+            alpha=0.42,
+            lw=0.8,
+        )
+    for ax, metric in zip(axes, ["s1_mean_pct", "paired_gain_vs_doob_mean_pp"]):
+        ax.plot(
+            x,
+            [stats[n][metric] for n in names],
+            "o-",
+            color="#164e70",
+            lw=2,
+            label="Mean of 20 clusterings",
+        )
+        ax.set_xticks(x, labels, rotation=18)
+        ax.set_xlabel("Density-floor percentile")
+        ax.spines[["top", "right"]].set_visible(False)
+        ax.grid(axis="y", alpha=0.2)
+    axes[0].axhline(
+        stats["doob"]["s1_mean_pct"], ls="--", color="#777777", label="Pure-Doob mean"
+    )
+    axes[1].axhline(0, ls="--", color="#777777")
+    axes[0].set_ylabel("Exact probability of S1 visitation (%)")
+    axes[1].set_ylabel("Paired gain over pure Doob (percentage points)")
+    axes[0].legend(frameon=False, fontsize=8)
+    fig.suptitle("MB floor sensitivity at fixed density strength and horizon")
+    fig.tight_layout()
+    (ROOT / "figures").mkdir(parents=True, exist_ok=True)
+    for ext in ["pdf", "png", "svg"]:
+        fig.savefig(
+            ROOT / "figures" / f"floor_sensitivity.{ext}", dpi=180, bbox_inches="tight"
+        )
+    lines = [
+        "MB FLOOR SENSITIVITY — completed",
+        "",
+        summary["scope"],
+        "",
+        "Condition       S1 mean +/- SD (%)      gain vs Doob (pp)   better /20",
+    ]
+    for name, _ in CONDITIONS:
+        z = stats[name]
+        lines.append(
+            f"{name:12s} {z['s1_mean_pct']:7.3f} +/- {z['s1_sd_pct']:6.3f} "
+            f"          {z['paired_gain_vs_doob_mean_pp']:+7.3f}             "
+            f"{z['n_clusterings_better_than_doob']}"
+        )
+    lines += [
+        "",
+        "Checks:",
+        json.dumps(check, indent=2),
+        "",
+        "The original 25th-percentile setting is retained. No optimum was selected.",
+        "Use per-clustering paired differences in all_results.csv; original results were not overwritten.",
+        "Exact evaluation has no rollout Monte Carlo error. Refitting may differ from archived finite samples.",
+        "Aib9 and the p53 held-out density experiment used no density floor; this test concerns MB.",
+    ]
+    (OUT / "RESULTS.txt").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines), flush=True)
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    group = p.add_mutually_exclusive_group(required=True)
+    group.add_argument("--seed", type=int, choices=range(20))
+    group.add_argument("--summarize", action="store_true")
+    group.add_argument("--validate", action="store_true")
+    args = p.parse_args()
+    if args.validate:
+        print(json.dumps(validate_toy(), indent=2))
+    elif args.summarize:
+        summarize()
+    else:
+        run(args.seed)

analysis/mb_floor_sensitivity/result_00.json

@@ -0,0 +1,178 @@
+{
+  "seed": 0,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.43691794546073415,
+      "expected_distinct_states": 15.013666141340575,
+      "expected_self_transitions": 0.6533119085168925,
+      "self_transition_fraction": 0.04083199428230578,
+      "expected_s1_state_observations": 0.5035914002980231,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9595572296791586,
+      "expected_distinct_states": 11.733030279406437,
+      "expected_self_transitions": 1.4831157288792642,
+      "self_transition_fraction": 0.09269473305495401,
+      "expected_s1_state_observations": 2.8990900899171863,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8902087824180265,
+      "expected_distinct_states": 11.938725995059936,
+      "expected_self_transitions": 1.3434524895761015,
+      "self_transition_fraction": 0.08396578059850635,
+      "expected_s1_state_observations": 1.9223774857137172,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.22521666666666668,
+      "fraction_corridor_states_below_floor": 0.05555555555555555,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7676334652497048,
+      "expected_distinct_states": 12.162471438442612,
+      "expected_self_transitions": 1.206251585062303,
+      "self_transition_fraction": 0.07539072406639394,
+      "expected_s1_state_observations": 1.2264193451367236,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.306125,
+      "fraction_corridor_states_below_floor": 0.1,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.6878636642681657,
+      "expected_distinct_states": 12.536110821091299,
+      "expected_self_transitions": 1.1103615285855495,
+      "self_transition_fraction": 0.06939759553659684,
+      "expected_s1_state_observations": 0.9759709933847585,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.3833333333333333,
+      "fraction_corridor_states_below_floor": 0.2,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.6242797495046818,
+      "expected_distinct_states": 13.211821050555066,
+      "expected_self_transitions": 1.019008773393519,
+      "self_transition_fraction": 0.06368804833709493,
+      "expected_s1_state_observations": 0.8256362469038774,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.5533333333333333,
+      "fraction_corridor_states_below_floor": 0.3333333333333333,
+      "independent_recursion_error": 1.1102230246251565e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 90,
+  "s1_states": 4,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": {
+    "max_state_coordinate_difference": 0.0,
+    "counts_equal": true,
+    "corridor_equal": true
+  },
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 13.785944700241089
+}

analysis/mb_floor_sensitivity/result_01.json

@@ -0,0 +1,174 @@
+{
+  "seed": 1,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.47431774413772165,
+      "expected_distinct_states": 14.962806670822289,
+      "expected_self_transitions": 0.6646379767601857,
+      "self_transition_fraction": 0.041539873547511603,
+      "expected_s1_state_observations": 0.5656135812877474,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.921186672272567,
+      "expected_distinct_states": 12.554198995233554,
+      "expected_self_transitions": 1.2723206679621673,
+      "self_transition_fraction": 0.07952004174763545,
+      "expected_s1_state_observations": 2.491381984616749,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.8740443333450296,
+      "expected_distinct_states": 12.632418653953259,
+      "expected_self_transitions": 1.2115611948906388,
+      "self_transition_fraction": 0.07572257468066493,
+      "expected_s1_state_observations": 1.9787923417975324,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.17853333333333332,
+      "fraction_corridor_states_below_floor": 0.04395604395604396,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.8045858652078739,
+      "expected_distinct_states": 12.83339276935726,
+      "expected_self_transitions": 1.0997845920403504,
+      "self_transition_fraction": 0.0687365370025219,
+      "expected_s1_state_observations": 1.5116968074655235,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.22158333333333335,
+      "fraction_corridor_states_below_floor": 0.08791208791208792,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7171638280522671,
+      "expected_distinct_states": 13.101709613591051,
+      "expected_self_transitions": 0.9696859373588358,
+      "self_transition_fraction": 0.06060537108492724,
+      "expected_s1_state_observations": 1.1197796664715896,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.31133333333333335,
+      "fraction_corridor_states_below_floor": 0.17582417582417584,
+      "independent_recursion_error": 3.3306690738754696e-16
+    },
+    {
+      "s1_probability": 0.6695714939378443,
+      "expected_distinct_states": 13.124068598363051,
+      "expected_self_transitions": 0.9589335944737107,
+      "self_transition_fraction": 0.05993334965460692,
+      "expected_s1_state_observations": 0.9806618033719668,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.3735,
+      "fraction_corridor_states_below_floor": 0.27472527472527475,
+      "independent_recursion_error": 3.3306690738754696e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 91,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 13.56903338432312
+}

analysis/mb_floor_sensitivity/result_02.json

@@ -0,0 +1,174 @@
+{
+  "seed": 2,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.4770124753307715,
+      "expected_distinct_states": 15.022239303408549,
+      "expected_self_transitions": 0.641083807715894,
+      "self_transition_fraction": 0.040067737982243376,
+      "expected_s1_state_observations": 0.5722517563630657,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9788540758905597,
+      "expected_distinct_states": 11.552706077458156,
+      "expected_self_transitions": 1.536411795616068,
+      "self_transition_fraction": 0.09602573722600426,
+      "expected_s1_state_observations": 3.766589674181204,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9567884525122707,
+      "expected_distinct_states": 11.726665146315467,
+      "expected_self_transitions": 1.4632838020840366,
+      "self_transition_fraction": 0.09145523763025229,
+      "expected_s1_state_observations": 3.0495216306615904,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.16490000000000002,
+      "fraction_corridor_states_below_floor": 0.05555555555555555,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7861058920937647,
+      "expected_distinct_states": 12.46863243700942,
+      "expected_self_transitions": 1.0849601814080623,
+      "self_transition_fraction": 0.06781001133800389,
+      "expected_s1_state_observations": 1.3789396874220046,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.30533333333333335,
+      "fraction_corridor_states_below_floor": 0.08888888888888889,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.7070082795708856,
+      "expected_distinct_states": 12.601639392510245,
+      "expected_self_transitions": 1.0176181458639135,
+      "self_transition_fraction": 0.0636011341164946,
+      "expected_s1_state_observations": 1.0772612246813502,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.3641666666666667,
+      "fraction_corridor_states_below_floor": 0.17777777777777778,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.6818964076424328,
+      "expected_distinct_states": 12.800445043295559,
+      "expected_self_transitions": 1.0065659793738178,
+      "self_transition_fraction": 0.06291037371086361,
+      "expected_s1_state_observations": 1.0045758468701496,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.4265,
+      "fraction_corridor_states_below_floor": 0.2777777777777778,
+      "independent_recursion_error": 0.0
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 90,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 12.15404987335205
+}

analysis/mb_floor_sensitivity/result_03.json

@@ -0,0 +1,176 @@
+{
+  "seed": 3,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.45650454079958447,
+      "expected_distinct_states": 14.80991960644764,
+      "expected_self_transitions": 0.7074257266949784,
+      "self_transition_fraction": 0.04421410791843615,
+      "expected_s1_state_observations": 0.5331538613794161,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9580141712857912,
+      "expected_distinct_states": 11.722590642329202,
+      "expected_self_transitions": 1.3804948464763818,
+      "self_transition_fraction": 0.08628092790477386,
+      "expected_s1_state_observations": 2.6954344282610743,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9274037645156145,
+      "expected_distinct_states": 11.886116032329102,
+      "expected_self_transitions": 1.2966589793929524,
+      "self_transition_fraction": 0.08104118621205952,
+      "expected_s1_state_observations": 2.1717549681508266,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.20299999999999999,
+      "fraction_corridor_states_below_floor": 0.044444444444444446,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.8644404152551027,
+      "expected_distinct_states": 12.187795360059418,
+      "expected_self_transitions": 1.1580546182737619,
+      "self_transition_fraction": 0.07237841364211012,
+      "expected_s1_state_observations": 1.6004178669081626,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.2625,
+      "fraction_corridor_states_below_floor": 0.07777777777777778,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.7561161682190445,
+      "expected_distinct_states": 12.54985520188381,
+      "expected_self_transitions": 1.024436758333206,
+      "self_transition_fraction": 0.06402729739582537,
+      "expected_s1_state_observations": 1.114883703386301,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.347,
+      "fraction_corridor_states_below_floor": 0.15555555555555556,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.7280076348197122,
+      "expected_distinct_states": 12.662176039866797,
+      "expected_self_transitions": 1.0083460210337105,
+      "self_transition_fraction": 0.06302162631460691,
+      "expected_s1_state_observations": 1.0420058079762458,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.3958333333333333,
+      "fraction_corridor_states_below_floor": 0.24444444444444444,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 90,
+  "s1_states": 4,
+  "source_states_outside_arrival_mask": [
+    70
+  ],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 5.551115123125783e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 13.07038426399231
+}

analysis/mb_floor_sensitivity/result_04.json

@@ -0,0 +1,174 @@
+{
+  "seed": 4,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.5529362581820605,
+      "expected_distinct_states": 15.096978659761653,
+      "expected_self_transitions": 0.6165138189916382,
+      "self_transition_fraction": 0.038532113686977384,
+      "expected_s1_state_observations": 0.6938552475249293,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9962276948671395,
+      "expected_distinct_states": 11.34002279146719,
+      "expected_self_transitions": 1.518485787800281,
+      "self_transition_fraction": 0.09490536173751757,
+      "expected_s1_state_observations": 4.920757910254638,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9921726986874595,
+      "expected_distinct_states": 11.455959087069008,
+      "expected_self_transitions": 1.4760596380344395,
+      "self_transition_fraction": 0.09225372737715247,
+      "expected_s1_state_observations": 4.283802798145508,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.1519,
+      "fraction_corridor_states_below_floor": 0.043010752688172046,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.946675144782042,
+      "expected_distinct_states": 12.218260605057775,
+      "expected_self_transitions": 1.2002374039935013,
+      "self_transition_fraction": 0.07501483774959383,
+      "expected_s1_state_observations": 2.595595583070055,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.254,
+      "fraction_corridor_states_below_floor": 0.08602150537634409,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8183163335930693,
+      "expected_distinct_states": 12.859082521969363,
+      "expected_self_transitions": 1.0121470034882263,
+      "self_transition_fraction": 0.06325918771801414,
+      "expected_s1_state_observations": 1.4608022924170065,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.3795,
+      "fraction_corridor_states_below_floor": 0.17204301075268819,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7688763668259164,
+      "expected_distinct_states": 13.114078672127016,
+      "expected_self_transitions": 0.9792047667707706,
+      "self_transition_fraction": 0.061200297923173164,
+      "expected_s1_state_observations": 1.2307998669706566,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.4625,
+      "fraction_corridor_states_below_floor": 0.27956989247311825,
+      "independent_recursion_error": 1.1102230246251565e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 93,
+  "s1_states": 6,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 5.551115123125783e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 13.0308256149292
+}

analysis/mb_floor_sensitivity/result_05.json

@@ -0,0 +1,174 @@
+{
+  "seed": 5,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.4475602830610881,
+      "expected_distinct_states": 15.094047987295635,
+      "expected_self_transitions": 0.6207786082633657,
+      "self_transition_fraction": 0.03879866301646036,
+      "expected_s1_state_observations": 0.5208747341411591,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9530796173580153,
+      "expected_distinct_states": 11.884313166919643,
+      "expected_self_transitions": 1.411491487518026,
+      "self_transition_fraction": 0.08821821796987663,
+      "expected_s1_state_observations": 3.014314188472334,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9127507912936526,
+      "expected_distinct_states": 12.049203567603252,
+      "expected_self_transitions": 1.3080615820306891,
+      "self_transition_fraction": 0.08175384887691807,
+      "expected_s1_state_observations": 2.3538333584987883,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.18513333333333334,
+      "fraction_corridor_states_below_floor": 0.05555555555555555,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.7411179555254174,
+      "expected_distinct_states": 12.60407489377736,
+      "expected_self_transitions": 1.0541361022213542,
+      "self_transition_fraction": 0.06588350638883464,
+      "expected_s1_state_observations": 1.2146468265537802,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.30883333333333335,
+      "fraction_corridor_states_below_floor": 0.1111111111111111,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.6804422405100263,
+      "expected_distinct_states": 12.681695688214198,
+      "expected_self_transitions": 1.0189917438498421,
+      "self_transition_fraction": 0.06368698399061513,
+      "expected_s1_state_observations": 1.008741924340221,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.36233333333333334,
+      "fraction_corridor_states_below_floor": 0.2111111111111111,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.5838773589540722,
+      "expected_distinct_states": 13.628192477580198,
+      "expected_self_transitions": 0.8897060914934126,
+      "self_transition_fraction": 0.05560663071833829,
+      "expected_s1_state_observations": 0.7727162921515831,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.5523333333333333,
+      "fraction_corridor_states_below_floor": 0.3333333333333333,
+      "independent_recursion_error": 4.440892098500626e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 90,
+  "s1_states": 4,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 13.582573652267456
+}

analysis/mb_floor_sensitivity/result_06.json

@@ -0,0 +1,174 @@
+{
+  "seed": 6,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.4330891968703052,
+      "expected_distinct_states": 14.812621566148653,
+      "expected_self_transitions": 0.7115744248981953,
+      "self_transition_fraction": 0.04447340155613721,
+      "expected_s1_state_observations": 0.5060695633503917,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9862046252727615,
+      "expected_distinct_states": 11.587086114432688,
+      "expected_self_transitions": 1.4214949908667145,
+      "self_transition_fraction": 0.08884343692916966,
+      "expected_s1_state_observations": 3.9865094885600447,
+      "terminal_probability": 0.9999999999999992,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9836480121489333,
+      "expected_distinct_states": 11.602393615840489,
+      "expected_self_transitions": 1.410855463597818,
+      "self_transition_fraction": 0.08817846647486363,
+      "expected_s1_state_observations": 3.8014144944916866,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.11635000000000001,
+      "fraction_corridor_states_below_floor": 0.03409090909090909,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9306993298623017,
+      "expected_distinct_states": 11.921810944168588,
+      "expected_self_transitions": 1.3139973024524192,
+      "self_transition_fraction": 0.0821248314032762,
+      "expected_s1_state_observations": 2.4684163841751254,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.20033333333333334,
+      "fraction_corridor_states_below_floor": 0.07954545454545454,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7754659268098913,
+      "expected_distinct_states": 12.624829062467224,
+      "expected_self_transitions": 1.0498558002845293,
+      "self_transition_fraction": 0.06561598751778308,
+      "expected_s1_state_observations": 1.362450444544891,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.32508333333333334,
+      "fraction_corridor_states_below_floor": 0.17045454545454544,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.695208874139938,
+      "expected_distinct_states": 12.679419500226675,
+      "expected_self_transitions": 1.0121127701508243,
+      "self_transition_fraction": 0.06325704813442652,
+      "expected_s1_state_observations": 1.0637699981720814,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.411625,
+      "fraction_corridor_states_below_floor": 0.2727272727272727,
+      "independent_recursion_error": 0.0
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 88,
+  "s1_states": 6,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 3.3306690738754696e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 10.88566780090332
+}

analysis/mb_floor_sensitivity/result_07.json

@@ -0,0 +1,174 @@
+{
+  "seed": 7,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.4884589808111566,
+      "expected_distinct_states": 14.994452299580114,
+      "expected_self_transitions": 0.6482842306768242,
+      "self_transition_fraction": 0.04051776441730151,
+      "expected_s1_state_observations": 0.5785314679769923,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9970695060214769,
+      "expected_distinct_states": 11.119728321434357,
+      "expected_self_transitions": 1.6311413077969785,
+      "self_transition_fraction": 0.10194633173731116,
+      "expected_s1_state_observations": 5.117273761682558,
+      "terminal_probability": 1.0000000000000007,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9905373110999428,
+      "expected_distinct_states": 11.282207434922423,
+      "expected_self_transitions": 1.546376692189688,
+      "self_transition_fraction": 0.0966485432618555,
+      "expected_s1_state_observations": 4.127171135559552,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.15273333333333336,
+      "fraction_corridor_states_below_floor": 0.056818181818181816,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9071215542274581,
+      "expected_distinct_states": 11.996151855457436,
+      "expected_self_transitions": 1.2650281951517115,
+      "self_transition_fraction": 0.07906426219698197,
+      "expected_s1_state_observations": 2.053269132739316,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.28370833333333334,
+      "fraction_corridor_states_below_floor": 0.09090909090909091,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.78024190725,
+      "expected_distinct_states": 12.635238791275325,
+      "expected_self_transitions": 1.0605083364204373,
+      "self_transition_fraction": 0.06628177102627733,
+      "expected_s1_state_observations": 1.2401950270444022,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.3988333333333334,
+      "fraction_corridor_states_below_floor": 0.18181818181818182,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.7291624828547295,
+      "expected_distinct_states": 13.128647027607355,
+      "expected_self_transitions": 0.9858064336192434,
+      "self_transition_fraction": 0.06161290210120271,
+      "expected_s1_state_observations": 1.044385291903564,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.4955,
+      "fraction_corridor_states_below_floor": 0.2840909090909091,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 88,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 12.590587377548218
+}

analysis/mb_floor_sensitivity/result_08.json

@@ -0,0 +1,174 @@
+{
+  "seed": 8,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.5054293429258443,
+      "expected_distinct_states": 14.854209733539234,
+      "expected_self_transitions": 0.6975411031703469,
+      "self_transition_fraction": 0.04359631894814668,
+      "expected_s1_state_observations": 0.6073257775311078,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.9940177316962647,
+      "expected_distinct_states": 11.509475480412506,
+      "expected_self_transitions": 1.5475124157900457,
+      "self_transition_fraction": 0.09671952598687786,
+      "expected_s1_state_observations": 5.095286662920895,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9830252052368973,
+      "expected_distinct_states": 11.721096187851614,
+      "expected_self_transitions": 1.4345296572099877,
+      "self_transition_fraction": 0.08965810357562423,
+      "expected_s1_state_observations": 4.017327042556997,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.16044999999999998,
+      "fraction_corridor_states_below_floor": 0.056818181818181816,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8854252755682153,
+      "expected_distinct_states": 12.099530695987792,
+      "expected_self_transitions": 1.2263908921328786,
+      "self_transition_fraction": 0.07664943075830491,
+      "expected_s1_state_observations": 2.0259081797573457,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.26104166666666667,
+      "fraction_corridor_states_below_floor": 0.06818181818181818,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.761042673816384,
+      "expected_distinct_states": 12.270895988869396,
+      "expected_self_transitions": 1.0851524193189312,
+      "self_transition_fraction": 0.0678220262074332,
+      "expected_s1_state_observations": 1.283189944065588,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.33991666666666664,
+      "fraction_corridor_states_below_floor": 0.17045454545454544,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.7115873574216767,
+      "expected_distinct_states": 12.66425418303297,
+      "expected_self_transitions": 1.0320268561339894,
+      "self_transition_fraction": 0.06450167850837434,
+      "expected_s1_state_observations": 1.1069094672502628,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.476875,
+      "fraction_corridor_states_below_floor": 0.2840909090909091,
+      "independent_recursion_error": 0.0
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 88,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 3.3306690738754696e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 10.731775283813477
+}

analysis/mb_floor_sensitivity/result_09.json

@@ -0,0 +1,174 @@
+{
+  "seed": 9,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.4321947930753325,
+      "expected_distinct_states": 14.959125837669543,
+      "expected_self_transitions": 0.6528087882950669,
+      "self_transition_fraction": 0.040800549268441684,
+      "expected_s1_state_observations": 0.5043806778973854,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9922548889637395,
+      "expected_distinct_states": 11.158649449096961,
+      "expected_self_transitions": 1.7718351738964258,
+      "self_transition_fraction": 0.11073969836852661,
+      "expected_s1_state_observations": 4.681688268883696,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9862652954199567,
+      "expected_distinct_states": 11.23542193589623,
+      "expected_self_transitions": 1.6771373550243227,
+      "self_transition_fraction": 0.10482108468902017,
+      "expected_s1_state_observations": 4.0906750835499555,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.14635,
+      "fraction_corridor_states_below_floor": 0.04597701149425287,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8542112181689199,
+      "expected_distinct_states": 11.811094967472858,
+      "expected_self_transitions": 1.3295836088353485,
+      "self_transition_fraction": 0.08309897555220928,
+      "expected_s1_state_observations": 1.7944217524464068,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.2720416666666667,
+      "fraction_corridor_states_below_floor": 0.06896551724137931,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7002573561629514,
+      "expected_distinct_states": 12.247741214714685,
+      "expected_self_transitions": 1.1058247327645034,
+      "self_transition_fraction": 0.06911404579778146,
+      "expected_s1_state_observations": 1.0830644694916232,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.36916666666666664,
+      "fraction_corridor_states_below_floor": 0.16091954022988506,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.6281463071310748,
+      "expected_distinct_states": 13.061567615927256,
+      "expected_self_transitions": 1.0008641881095364,
+      "self_transition_fraction": 0.06255401175684602,
+      "expected_s1_state_observations": 0.8914368368993364,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.5270416666666667,
+      "fraction_corridor_states_below_floor": 0.27586206896551724,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 87,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 12.145994663238525
+}

analysis/mb_floor_sensitivity/result_10.json

@@ -0,0 +1,174 @@
+{
+  "seed": 10,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.6051181115385142,
+      "expected_distinct_states": 14.898790156219114,
+      "expected_self_transitions": 0.6895663770362908,
+      "self_transition_fraction": 0.04309789856476817,
+      "expected_s1_state_observations": 0.7978389368820248,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9960723731249793,
+      "expected_distinct_states": 12.108313232484242,
+      "expected_self_transitions": 1.2484269792291747,
+      "self_transition_fraction": 0.07802668620182342,
+      "expected_s1_state_observations": 4.784325928801066,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9886936975414197,
+      "expected_distinct_states": 12.345579862311531,
+      "expected_self_transitions": 1.2027634815656683,
+      "self_transition_fraction": 0.07517271759785427,
+      "expected_s1_state_observations": 3.8259931725796976,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.15466666666666667,
+      "fraction_corridor_states_below_floor": 0.0449438202247191,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9441917969436444,
+      "expected_distinct_states": 12.687284115336098,
+      "expected_self_transitions": 1.063120271254222,
+      "self_transition_fraction": 0.06644501695338888,
+      "expected_s1_state_observations": 2.2645034779545337,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.2615,
+      "fraction_corridor_states_below_floor": 0.0898876404494382,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9067334886564498,
+      "expected_distinct_states": 12.81703412684616,
+      "expected_self_transitions": 1.0081206556493085,
+      "self_transition_fraction": 0.06300754097808178,
+      "expected_s1_state_observations": 1.8045492433168,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.31466666666666665,
+      "fraction_corridor_states_below_floor": 0.16853932584269662,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8779686750518605,
+      "expected_distinct_states": 12.991303042068983,
+      "expected_self_transitions": 0.9682211305877053,
+      "self_transition_fraction": 0.06051382066173158,
+      "expected_s1_state_observations": 1.5892576833755752,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.37566666666666665,
+      "fraction_corridor_states_below_floor": 0.2696629213483146,
+      "independent_recursion_error": 0.0
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 89,
+  "s1_states": 6,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 3.3306690738754696e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 10.604124784469604
+}

analysis/mb_floor_sensitivity/result_11.json

@@ -0,0 +1,174 @@
+{
+  "seed": 11,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.5227648276466925,
+      "expected_distinct_states": 14.952478476397784,
+      "expected_self_transitions": 0.6698842167729214,
+      "self_transition_fraction": 0.04186776354830759,
+      "expected_s1_state_observations": 0.6485438186452674,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9764343521424959,
+      "expected_distinct_states": 11.840554429710174,
+      "expected_self_transitions": 1.4049643499017979,
+      "self_transition_fraction": 0.08781027186886237,
+      "expected_s1_state_observations": 3.6834512261704884,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9654393738446215,
+      "expected_distinct_states": 11.98816705508663,
+      "expected_self_transitions": 1.340488749764659,
+      "self_transition_fraction": 0.08378054686029118,
+      "expected_s1_state_observations": 3.3155282335956326,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.13820000000000002,
+      "fraction_corridor_states_below_floor": 0.05555555555555555,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9000840431726618,
+      "expected_distinct_states": 12.379209353329747,
+      "expected_self_transitions": 1.1727567904554896,
+      "self_transition_fraction": 0.0732972994034681,
+      "expected_s1_state_observations": 2.1995035743632476,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.22129166666666666,
+      "fraction_corridor_states_below_floor": 0.1111111111111111,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7637631333045501,
+      "expected_distinct_states": 12.741223593205294,
+      "expected_self_transitions": 1.0348147023423626,
+      "self_transition_fraction": 0.06467591889639766,
+      "expected_s1_state_observations": 1.3413614896784345,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.34441666666666665,
+      "fraction_corridor_states_below_floor": 0.2111111111111111,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.6825699061407696,
+      "expected_distinct_states": 13.06836698527062,
+      "expected_self_transitions": 0.9818561100047247,
+      "self_transition_fraction": 0.061366006875295295,
+      "expected_s1_state_observations": 1.0506181378973352,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.49687499999999996,
+      "fraction_corridor_states_below_floor": 0.32222222222222224,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 90,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 5.551115123125783e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 12.264551877975464
+}

analysis/mb_floor_sensitivity/result_12.json

@@ -0,0 +1,174 @@
+{
+  "seed": 12,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.43150466464742265,
+      "expected_distinct_states": 14.958334976066823,
+      "expected_self_transitions": 0.646413093784507,
+      "self_transition_fraction": 0.040400818361531685,
+      "expected_s1_state_observations": 0.49979048531686193,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.988923030398696,
+      "expected_distinct_states": 11.688235191755401,
+      "expected_self_transitions": 1.4661954290112311,
+      "self_transition_fraction": 0.09163721431320195,
+      "expected_s1_state_observations": 4.050480062642302,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9855422938397457,
+      "expected_distinct_states": 11.713517855443706,
+      "expected_self_transitions": 1.4352571804827687,
+      "self_transition_fraction": 0.08970357378017305,
+      "expected_s1_state_observations": 3.79892881277627,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.12803333333333333,
+      "fraction_corridor_states_below_floor": 0.034482758620689655,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8476239480490195,
+      "expected_distinct_states": 12.426199837847292,
+      "expected_self_transitions": 1.0800756165620315,
+      "self_transition_fraction": 0.06750472603512697,
+      "expected_s1_state_observations": 1.6311665058150513,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.26275,
+      "fraction_corridor_states_below_floor": 0.09195402298850575,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.7544350487486045,
+      "expected_distinct_states": 12.511998253499439,
+      "expected_self_transitions": 1.0285811310685948,
+      "self_transition_fraction": 0.06428632069178718,
+      "expected_s1_state_observations": 1.207751153064137,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.3285,
+      "fraction_corridor_states_below_floor": 0.1839080459770115,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.6601035016617813,
+      "expected_distinct_states": 13.21859773674616,
+      "expected_self_transitions": 0.9393830882581088,
+      "self_transition_fraction": 0.0587114430161318,
+      "expected_s1_state_observations": 0.9361200763687552,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.5500833333333333,
+      "fraction_corridor_states_below_floor": 0.3103448275862069,
+      "independent_recursion_error": 3.3306690738754696e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 87,
+  "s1_states": 7,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 5.551115123125783e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 12.063010215759277
+}

analysis/mb_floor_sensitivity/result_13.json

@@ -0,0 +1,174 @@
+{
+  "seed": 13,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.5644169520367373,
+      "expected_distinct_states": 14.907966245921752,
+      "expected_self_transitions": 0.6821570141263407,
+      "self_transition_fraction": 0.04263481338289629,
+      "expected_s1_state_observations": 0.7030244957756517,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9995822259964128,
+      "expected_distinct_states": 11.028821590700947,
+      "expected_self_transitions": 1.620670447864448,
+      "self_transition_fraction": 0.101291902991528,
+      "expected_s1_state_observations": 6.3844195580942165,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9982600785956507,
+      "expected_distinct_states": 11.266864578810566,
+      "expected_self_transitions": 1.5829988979751701,
+      "self_transition_fraction": 0.09893743112344813,
+      "expected_s1_state_observations": 5.277765857814593,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.1595666666666667,
+      "fraction_corridor_states_below_floor": 0.05813953488372093,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9759464362308001,
+      "expected_distinct_states": 11.872651211875759,
+      "expected_self_transitions": 1.4015521068986858,
+      "self_transition_fraction": 0.08759700668116786,
+      "expected_s1_state_observations": 3.089001381621692,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.26416666666666666,
+      "fraction_corridor_states_below_floor": 0.10465116279069768,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8314949774975573,
+      "expected_distinct_states": 12.749958528241645,
+      "expected_self_transitions": 1.0784138744273526,
+      "self_transition_fraction": 0.06740086715170954,
+      "expected_s1_state_observations": 1.4307226559464783,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.41883333333333334,
+      "fraction_corridor_states_below_floor": 0.19767441860465115,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.7880574122487745,
+      "expected_distinct_states": 13.095931046640345,
+      "expected_self_transitions": 1.0176976594917684,
+      "self_transition_fraction": 0.06360610371823552,
+      "expected_s1_state_observations": 1.2267282859841262,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.49483333333333335,
+      "fraction_corridor_states_below_floor": 0.313953488372093,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 86,
+  "s1_states": 6,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 7.771561172376096e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 10.978748798370361
+}

analysis/mb_floor_sensitivity/result_14.json

@@ -0,0 +1,174 @@
+{
+  "seed": 14,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.45817858397768185,
+      "expected_distinct_states": 15.013769341014864,
+      "expected_self_transitions": 0.6450019739490105,
+      "self_transition_fraction": 0.040312623371813155,
+      "expected_s1_state_observations": 0.5366109157711714,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.9696157237057008,
+      "expected_distinct_states": 11.698324699493291,
+      "expected_self_transitions": 1.4327847953261001,
+      "self_transition_fraction": 0.08954904970788126,
+      "expected_s1_state_observations": 3.2328725221772694,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9504459941648574,
+      "expected_distinct_states": 11.730085388967026,
+      "expected_self_transitions": 1.3837907183634548,
+      "self_transition_fraction": 0.08648691989771592,
+      "expected_s1_state_observations": 2.7702876080665657,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.17400000000000002,
+      "fraction_corridor_states_below_floor": 0.045454545454545456,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8550732563525272,
+      "expected_distinct_states": 11.849763126034592,
+      "expected_self_transitions": 1.2824634098773733,
+      "self_transition_fraction": 0.08015396311733583,
+      "expected_s1_state_observations": 1.7557732258712033,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.24566666666666667,
+      "fraction_corridor_states_below_floor": 0.07954545454545454,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.6970726461583261,
+      "expected_distinct_states": 12.781191300620106,
+      "expected_self_transitions": 1.0273923036735624,
+      "self_transition_fraction": 0.06421201897959765,
+      "expected_s1_state_observations": 1.0613050980570757,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.38116666666666665,
+      "fraction_corridor_states_below_floor": 0.19318181818181818,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.6279562111989816,
+      "expected_distinct_states": 13.45153592577016,
+      "expected_self_transitions": 0.9476847582789945,
+      "self_transition_fraction": 0.05923029739243715,
+      "expected_s1_state_observations": 0.8730248746739183,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.49783333333333335,
+      "fraction_corridor_states_below_floor": 0.32954545454545453,
+      "independent_recursion_error": 1.1102230246251565e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 88,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 3.3306690738754696e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 11.968786478042603
+}

analysis/mb_floor_sensitivity/result_15.json

@@ -0,0 +1,174 @@
+{
+  "seed": 15,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.5853865507163494,
+      "expected_distinct_states": 15.035766065692105,
+      "expected_self_transitions": 0.6366963051976371,
+      "self_transition_fraction": 0.03979351907485232,
+      "expected_s1_state_observations": 0.7644231778054192,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.989443457761515,
+      "expected_distinct_states": 12.042604625242614,
+      "expected_self_transitions": 1.4167824752841478,
+      "self_transition_fraction": 0.08854890470525924,
+      "expected_s1_state_observations": 4.356122662242784,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9759379667573901,
+      "expected_distinct_states": 12.261838416733776,
+      "expected_self_transitions": 1.3125205161728628,
+      "self_transition_fraction": 0.08203253226080393,
+      "expected_s1_state_observations": 3.541394526083165,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.16111666666666669,
+      "fraction_corridor_states_below_floor": 0.05434782608695652,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.8932853974358681,
+      "expected_distinct_states": 12.820922793413317,
+      "expected_self_transitions": 1.0515828741564877,
+      "self_transition_fraction": 0.06572392963478048,
+      "expected_s1_state_observations": 1.969194834993593,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.26491666666666663,
+      "fraction_corridor_states_below_floor": 0.10869565217391304,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.832556953327635,
+      "expected_distinct_states": 12.83180481468052,
+      "expected_self_transitions": 0.9955184938708881,
+      "self_transition_fraction": 0.062219905866930506,
+      "expected_s1_state_observations": 1.5327626604734748,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.32399999999999995,
+      "fraction_corridor_states_below_floor": 0.20652173913043478,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.7885261940702322,
+      "expected_distinct_states": 13.008696207651493,
+      "expected_self_transitions": 0.965879401768791,
+      "self_transition_fraction": 0.060367462610549434,
+      "expected_s1_state_observations": 1.3145724952877371,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.43825000000000003,
+      "fraction_corridor_states_below_floor": 0.29347826086956524,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 92,
+  "s1_states": 6,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 5.551115123125783e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 11.918363809585571
+}

analysis/mb_floor_sensitivity/result_16.json

@@ -0,0 +1,174 @@
+{
+  "seed": 16,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.4837880922813723,
+      "expected_distinct_states": 15.042876505280352,
+      "expected_self_transitions": 0.6341114606979306,
+      "self_transition_fraction": 0.03963196629362066,
+      "expected_s1_state_observations": 0.5775827916257097,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.9917865141498091,
+      "expected_distinct_states": 11.845921704214799,
+      "expected_self_transitions": 1.280111885500374,
+      "self_transition_fraction": 0.08000699284377337,
+      "expected_s1_state_observations": 4.454788340196466,
+      "terminal_probability": 1.0000000000000004,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9796062551512817,
+      "expected_distinct_states": 11.972994713920363,
+      "expected_self_transitions": 1.2552591091124683,
+      "self_transition_fraction": 0.07845369431952927,
+      "expected_s1_state_observations": 3.6295932982820784,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.14175,
+      "fraction_corridor_states_below_floor": 0.05555555555555555,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9089795841296135,
+      "expected_distinct_states": 12.338684626584055,
+      "expected_self_transitions": 1.115876816720724,
+      "self_transition_fraction": 0.06974230104504525,
+      "expected_s1_state_observations": 2.1914936962783855,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.230125,
+      "fraction_corridor_states_below_floor": 0.1,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.750461636250534,
+      "expected_distinct_states": 12.998491601091787,
+      "expected_self_transitions": 0.9397360252722106,
+      "self_transition_fraction": 0.05873350157951316,
+      "expected_s1_state_observations": 1.2131966351385546,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.357,
+      "fraction_corridor_states_below_floor": 0.18888888888888888,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7251508494551543,
+      "expected_distinct_states": 13.036352824416662,
+      "expected_self_transitions": 0.9406048818053995,
+      "self_transition_fraction": 0.05878780511283747,
+      "expected_s1_state_observations": 1.1197531901503124,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.39245833333333335,
+      "fraction_corridor_states_below_floor": 0.3,
+      "independent_recursion_error": 0.0
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 90,
+  "s1_states": 6,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 10.63613247871399
+}

analysis/mb_floor_sensitivity/result_17.json

@@ -0,0 +1,174 @@
+{
+  "seed": 17,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.506739254130001,
+      "expected_distinct_states": 14.803467535092778,
+      "expected_self_transitions": 0.7189674227192553,
+      "self_transition_fraction": 0.044935463919953456,
+      "expected_s1_state_observations": 0.6154647589491531,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9664202615157165,
+      "expected_distinct_states": 12.02215316179213,
+      "expected_self_transitions": 1.339269336429185,
+      "self_transition_fraction": 0.08370433352682406,
+      "expected_s1_state_observations": 3.11550809490882,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9404164221867446,
+      "expected_distinct_states": 12.118348013862942,
+      "expected_self_transitions": 1.2742328206125921,
+      "self_transition_fraction": 0.07963955128828701,
+      "expected_s1_state_observations": 2.5356605932571266,
+      "terminal_probability": 0.9999999999999996,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.18708333333333332,
+      "fraction_corridor_states_below_floor": 0.047058823529411764,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7988441067613953,
+      "expected_distinct_states": 12.345487304715524,
+      "expected_self_transitions": 1.0931751257950446,
+      "self_transition_fraction": 0.06832344536219029,
+      "expected_s1_state_observations": 1.380012686167018,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.29191666666666666,
+      "fraction_corridor_states_below_floor": 0.10588235294117647,
+      "independent_recursion_error": 2.220446049250313e-16
+    },
+    {
+      "s1_probability": 0.7727105408685718,
+      "expected_distinct_states": 12.450340568775854,
+      "expected_self_transitions": 1.058037068630455,
+      "self_transition_fraction": 0.06612731678940344,
+      "expected_s1_state_observations": 1.2707168266977908,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.3154166666666667,
+      "fraction_corridor_states_below_floor": 0.18823529411764706,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.726303143742091,
+      "expected_distinct_states": 12.727484622353309,
+      "expected_self_transitions": 1.0044951140423584,
+      "self_transition_fraction": 0.0627809446276474,
+      "expected_s1_state_observations": 1.1208166008893121,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.40325,
+      "fraction_corridor_states_below_floor": 0.2823529411764706,
+      "independent_recursion_error": 2.220446049250313e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 85,
+  "s1_states": 4,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 11.92125654220581
+}

analysis/mb_floor_sensitivity/result_18.json

@@ -0,0 +1,176 @@
+{
+  "seed": 18,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.46599293713852674,
+      "expected_distinct_states": 14.81881748965592,
+      "expected_self_transitions": 0.7261562803021575,
+      "self_transition_fraction": 0.045384767518884844,
+      "expected_s1_state_observations": 0.5499415632673067,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9716797561020993,
+      "expected_distinct_states": 11.345619862067814,
+      "expected_self_transitions": 1.6230656449742473,
+      "self_transition_fraction": 0.10144160281089046,
+      "expected_s1_state_observations": 3.440952451261235,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9676600844143882,
+      "expected_distinct_states": 11.341798298267861,
+      "expected_self_transitions": 1.6109208351440203,
+      "self_transition_fraction": 0.10068255219650127,
+      "expected_s1_state_observations": 3.2959845573650792,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.16426666666666667,
+      "fraction_corridor_states_below_floor": 0.03409090909090909,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.9167709099313877,
+      "expected_distinct_states": 11.431522120805528,
+      "expected_self_transitions": 1.5187491425301674,
+      "self_transition_fraction": 0.09492182140813546,
+      "expected_s1_state_observations": 2.3683237529140384,
+      "terminal_probability": 1.0000000000000002,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.21945833333333334,
+      "fraction_corridor_states_below_floor": 0.06818181818181818,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.7979787092834122,
+      "expected_distinct_states": 12.0758916497212,
+      "expected_self_transitions": 1.2619461483905667,
+      "self_transition_fraction": 0.07887163427441042,
+      "expected_s1_state_observations": 1.5012528726304077,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.32025000000000003,
+      "fraction_corridor_states_below_floor": 0.13636363636363635,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.6911013312412888,
+      "expected_distinct_states": 12.577765689529569,
+      "expected_self_transitions": 1.1156690158244678,
+      "self_transition_fraction": 0.06972931348902923,
+      "expected_s1_state_observations": 1.0913266157219796,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.16666666666666666,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.4329166666666666,
+      "fraction_corridor_states_below_floor": 0.2159090909090909,
+      "independent_recursion_error": 3.3306690738754696e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 88,
+  "s1_states": 4,
+  "source_states_outside_arrival_mask": [
+    42
+  ],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 3.3306690738754696e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 11.052842855453491
+}

analysis/mb_floor_sensitivity/result_19.json

@@ -0,0 +1,174 @@
+{
+  "seed": 19,
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "records": [
+    {
+      "s1_probability": 0.5911223376745427,
+      "expected_distinct_states": 15.037682806054997,
+      "expected_self_transitions": 0.6173704673959552,
+      "self_transition_fraction": 0.0385856542122472,
+      "expected_s1_state_observations": 0.7563655871719949,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "doob",
+      "floor_percentile": null,
+      "density_floor": null,
+      "fraction_corridor_states_below_floor": null,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9940628269348554,
+      "expected_distinct_states": 11.92295814454286,
+      "expected_self_transitions": 1.2530964816499932,
+      "self_transition_fraction": 0.07831853010312458,
+      "expected_s1_state_observations": 4.4945914608736635,
+      "terminal_probability": 0.9999999999999997,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "none",
+      "floor_percentile": 0,
+      "density_floor": 0.0,
+      "fraction_corridor_states_below_floor": 0.0,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.9851874451785548,
+      "expected_distinct_states": 12.117485369184298,
+      "expected_self_transitions": 1.1871902273862402,
+      "self_transition_fraction": 0.07419938921164002,
+      "expected_s1_state_observations": 3.7013947994795875,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p10",
+      "floor_percentile": 10,
+      "density_floor": 0.16283333333333333,
+      "fraction_corridor_states_below_floor": 0.056179775280898875,
+      "independent_recursion_error": 0.0
+    },
+    {
+      "s1_probability": 0.924501258010828,
+      "expected_distinct_states": 12.43542465705962,
+      "expected_self_transitions": 1.052367675030286,
+      "self_transition_fraction": 0.06577297968939287,
+      "expected_s1_state_observations": 2.1850920352979477,
+      "terminal_probability": 0.9999999999999998,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p25",
+      "floor_percentile": 25,
+      "density_floor": 0.25966666666666666,
+      "fraction_corridor_states_below_floor": 0.10112359550561797,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.8591177847987432,
+      "expected_distinct_states": 12.744674789431965,
+      "expected_self_transitions": 0.955353538458335,
+      "self_transition_fraction": 0.05970959615364594,
+      "expected_s1_state_observations": 1.6170819071311933,
+      "terminal_probability": 0.9999999999999999,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p50",
+      "floor_percentile": 50,
+      "density_floor": 0.33216666666666667,
+      "fraction_corridor_states_below_floor": 0.19101123595505617,
+      "independent_recursion_error": 1.1102230246251565e-16
+    },
+    {
+      "s1_probability": 0.8012584473980241,
+      "expected_distinct_states": 13.374537050824975,
+      "expected_self_transitions": 0.8727450747307617,
+      "self_transition_fraction": 0.054546567170672605,
+      "expected_s1_state_observations": 1.3430220419973777,
+      "terminal_probability": 1.0,
+      "max_outside_corridor_probability": 0.0,
+      "max_outside_arrival_mask_probability": 0.0,
+      "condition": "p75",
+      "floor_percentile": 75,
+      "density_floor": 0.46108333333333335,
+      "fraction_corridor_states_below_floor": 0.29213483146067415,
+      "independent_recursion_error": 1.1102230246251565e-16
+    }
+  ],
+  "n_frames": 600000,
+  "n_active": 100,
+  "corridor_states": 89,
+  "s1_states": 5,
+  "source_states_outside_arrival_mask": [],
+  "target_states_outside_arrival_mask": [],
+  "reference_committor_agreement": 4.440892098500626e-16,
+  "seed0_saved_figure_check": null,
+  "validation": {
+    "exhaustive_reference_check": true,
+    "outside_mask_start_check": true,
+    "max_absolute_error": 4.440892098500626e-16
+  },
+  "source_sha256": {
+    "scoobdoob/data/mb_reactive/traj_0000.npy": "ee49c4657f8376a0f9e698ccc96b927b9064673b78b0dc5c19da3bda076352ef",
+    "scoobdoob/data/mb_reactive/traj_0001.npy": "8b6a8c0dc7fde5112bac0a1a0c434f5f9a4f76a8c8720479ea7be7ccc32bfa96",
+    "scoobdoob/data/mb_reactive/traj_0002.npy": "d9f3910f90c26aa2f6d270c380fdcc283d40158dc8404790331fe44d4f2c1ecd",
+    "scoobdoob/data/mb_reactive/traj_0003.npy": "cedc2002714c3c1ddf065bf0ffe4656a1c050a782bc15ba947e4f6a26f56db75",
+    "scoobdoob/data/mb_reactive/traj_0004.npy": "65ba296704f373945bc419c2d3ce95301ab80f8ce10557091002d08498427db0",
+    "scoobdoob/data/mb_reactive/traj_0005.npy": "8cc509bf5cc7adc6939944746d348fae33f7e0e9d1b1262ebdfcc9843617dae0",
+    "scoobdoob/data/mb_reactive/traj_0006.npy": "a29b36328cea4d000de430c8850508a39d1173803d6b8675f891a8b836b75f26",
+    "scoobdoob/data/mb_reactive/traj_0007.npy": "e9c622ab1d3a063427b61de9fe1f2fa357b7cd8385c7f5f86a8ba05b0da558e0",
+    "scoobdoob/data/mb_reactive/traj_0008.npy": "b99413fe7e82bd8669157f481581e252e00cf153e413c9b57f01f29407c36f00",
+    "scoobdoob/data/mb_reactive/traj_0009.npy": "16cef629e75952c3373ab36f373b9fb2ca4ea8a4b2f6a9be8ef247fdd5d38ab6",
+    "scoobdoob/data/mb_reactive/traj_0010.npy": "fed8575c02336dd57329c03d4cb0468f0093264bacd02fb0f5d17f469571379e",
+    "scoobdoob/data/mb_reactive/traj_0011.npy": "14f715121e55f495f37737d9ed9fbe5cf50a392d74638fd427620f181eb758aa",
+    "make_mb_panels.py": "0b8783b39d8272e6f119efb6c52efc212c936243bd3289ada6f08038832ed5c5",
+    "mb_stats.py": "80bdb3ce8b9a197c6a7fa1e1339e934fd7e4e98163cf91e5a519099a7ae624cb",
+    "scoobdoob/validation/msm_build.py": "0e1c90780e3e75eabf31b055e3c028e207d71573be9db1bc8f0c6a7f26086a9a",
+    "scoobdoob/_conditioning.py": "e37a49f9c22c83a3addf90bdfd0d21a4c22336fad43abbf33d18e9f5a87c7447",
+    "validate_mb.py": "4d12ae76a860d84ed4897f1fd25441226062deea1756be48065ecfc827735b5d",
+    "analysis/mb_floor_sensitivity_20261012/analyze.py": "85187c709e5d07f0ca3f18c58eac18987b1e3e13955f33e71740427a3ce6757b"
+  },
+  "versions": {
+    "numpy": "2.2.6",
+    "scipy": "1.14.1",
+    "scikit-learn": "1.7.1",
+    "deeptime": "0.4.5"
+  },
+  "python": "3.10.13",
+  "elapsed_seconds": 27.396819591522217
+}

analysis/mb_floor_sensitivity/summary.json

@@ -0,0 +1,174 @@
+{
+  "settings": {
+    "cluster_seeds": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19
+    ],
+    "k": 100,
+    "tica_lag": 20,
+    "msm_lag": 5,
+    "horizon": 16,
+    "alpha_per_transition": 7.5,
+    "floor_percentiles": [
+      10,
+      25,
+      50,
+      75
+    ],
+    "no_floor_control": true,
+    "start_law": "uniform on the original source set; fixed-start mixture",
+    "s1_radius": 0.25
+  },
+  "conditions": {
+    "doob": {
+      "s1_mean_pct": 49.5971693622122,
+      "s1_sd_pct": 5.654118830936145,
+      "s1_min_pct": 43.150466464742266,
+      "s1_max_pct": 60.511811153851426,
+      "paired_gain_vs_doob_mean_pp": 0.0,
+      "paired_gain_vs_doob_min_pp": 0.0,
+      "paired_gain_vs_doob_max_pp": 0.0,
+      "paired_vs_p25_mean_pp": -37.66941490258053,
+      "paired_vs_p25_min_pp": -49.76101329919965,
+      "paired_vs_p25_max_pp": -29.210485263139425,
+      "n_clusterings_better_than_doob": 0,
+      "distinct_per_path_mean": 14.95450087017052,
+      "self_steps_mean": 0.6640142502982698
+    },
+    "none": {
+      "s1_mean_pct": 97.90243367569876,
+      "s1_sd_pct": 1.9905840635575514,
+      "s1_min_pct": 92.11866722725671,
+      "s1_max_pct": 99.95822259964127,
+      "paired_gain_vs_doob_mean_pp": 48.305264313486575,
+      "paired_gain_vs_doob_min_pp": 39.095426158646504,
+      "paired_gain_vs_doob_max_pp": 56.0060095888407,
+      "paired_vs_p25_mean_pp": 10.635849410906038,
+      "paired_vs_p25_min_pp": 2.363578976561257,
+      "paired_vs_p25_max_pp": 21.19616618325979,
+      "n_clusterings_better_than_doob": 20,
+      "distinct_per_path_mean": 11.685265398009747,
+      "self_steps_mean": 1.4529836013886528
+    },
+    "p10": {
+      "s1_mean_pct": 96.1701712917622,
+      "s1_sd_pct": 3.5562336668562864,
+      "s1_min_pct": 87.40443333450297,
+      "s1_max_pct": 99.82600785956507,
+      "paired_gain_vs_doob_mean_pp": 46.573001929549996,
+      "paired_gain_vs_doob_min_pp": 38.357558600290545,
+      "paired_gain_vs_doob_max_pp": 55.40705023446242,
+      "paired_vs_p25_mean_pp": 8.90358702696946,
+      "paired_vs_p25_min_pp": 2.2313642364850494,
+      "paired_vs_p25_max_pp": 17.163283576823517,
+      "n_clusterings_better_than_doob": 20,
+      "distinct_per_path_mean": 11.819344360471474,
+      "self_steps_mean": 1.387669969530529
+    },
+    "p25": {
+      "s1_mean_pct": 87.26658426479273,
+      "s1_sd_pct": 6.5036230375719155,
+      "s1_min_pct": 74.11179555254174,
+      "s1_max_pct": 97.59464362308002,
+      "paired_gain_vs_doob_mean_pp": 37.66941490258053,
+      "paired_gain_vs_doob_min_pp": 29.210485263139425,
+      "paired_gain_vs_doob_max_pp": 49.76101329919965,
+      "paired_vs_p25_mean_pp": 0.0,
+      "paired_vs_p25_min_pp": 0.0,
+      "paired_vs_p25_max_pp": 0.0,
+      "n_clusterings_better_than_doob": 20,
+      "distinct_per_path_mean": 12.244518255689602,
+      "self_steps_mean": 1.1885072155426104
+    },
+    "p50": {
+      "s1_mean_pct": 76.75121648573534,
+      "s1_sd_pct": 6.074691783181966,
+      "s1_min_pct": 68.04422405100263,
+      "s1_max_pct": 90.67334886564498,
+      "paired_gain_vs_doob_mean_pp": 27.154047123523146,
+      "paired_gain_vs_doob_min_pp": 22.999580424011413,
+      "paired_gain_vs_doob_max_pp": 34.23767299395861,
+      "paired_vs_p25_mean_pp": -10.515367779057382,
+      "paired_vs_p25_min_pp": -15.851794787907963,
+      "paired_vs_p25_max_pp": -2.613356589282347,
+      "n_clusterings_better_than_doob": 20,
+      "distinct_per_path_mean": 12.640570376135027,
+      "self_steps_mean": 1.0421248174025806
+    },
+    "p75": {
+      "s1_mean_pct": 70.94804852720517,
+      "s1_sd_pct": 7.122227751513362,
+      "s1_min_pct": 58.387735895407225,
+      "s1_max_pct": 87.79686750518604,
+      "paired_gain_vs_doob_mean_pp": 21.350879164992982,
+      "paired_gain_vs_doob_min_pp": 13.631707589298415,
+      "paired_gain_vs_doob_max_pp": 27.285056351334617,
+      "paired_vs_p25_mean_pp": -16.318535737587553,
+      "paired_vs_p25_min_pp": -23.549045572236366,
+      "paired_vs_p25_max_pp": -6.622312189178402,
+      "n_clusterings_better_than_doob": 20,
+      "distinct_per_path_mean": 13.03126206699271,
+      "self_steps_mean": 0.9823405854672809
+    }
+  },
+  "checks": {
+    "toy_exhaustive_passed": true,
+    "max_independent_recursion_error": 4.440892098500626e-16,
+    "max_terminal_error": 7.771561172376096e-16,
+    "max_outside_corridor_probability": 0.16666666666666666,
+    "max_outside_arrival_mask_probability": 0.0,
+    "endpoint_mask_exceptions": [
+      {
+        "seed": 3,
+        "source": [
+          70
+        ],
+        "target": []
+      },
+      {
+        "seed": 18,
+        "source": [
+          42
+        ],
+        "target": []
+      }
+    ],
+    "seed0_saved_figure_check": {
+      "max_state_coordinate_difference": 0.0,
+      "counts_equal": true,
+      "corridor_equal": true
+    }
+  },
+  "archive_comparison": {
+    "doob": {
+      "archived_mean_pct": 49.652499999999996,
+      "mean_exact_minus_archived_pp": -0.05533063778779912,
+      "max_absolute_difference_pp": 1.4495335352577357
+    },
+    "p25": {
+      "archived_mean_pct": 87.27916666666667,
+      "mean_exact_minus_archived_pp": -0.012582401873935112,
+      "max_absolute_difference_pp": 0.8121554227458176
+    }
+  },
+  "scope": "Exact probabilities on refitted MSMs from fixed MD data. SD is clustering sensitivity, not MD uncertainty.",
+  "completed_clusterings": 20
+}

data/aib9_fes/aib9_kappa_sweep.json

@@ -0,0 +1,240 @@
+{
+  "model": {
+    "lag_frames": 5,
+    "frame_interval_ps": 1.0,
+    "horizon": 320,
+    "n_microstates": 100,
+    "clustering_seed": 0
+  },
+  "sampler": {
+    "gate_beta": 0.5,
+    "time_sigma": 0.3,
+    "n_paths_per_seed": 600
+  },
+  "results": [
+    {
+      "kappa": 0.0,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 62.5,
+        "sd": 2.0480342879074143
+      },
+      "n_channel": {
+        "mean": 555.6666666666666,
+        "sd": 6.027713773341707
+      },
+      "c_channel": {
+        "mean": 44.0,
+        "sd": 6.0
+      },
+      "c_share_pct": {
+        "mean": 7.33741420886663,
+        "sd": 1.0000249800056775
+      },
+      "distinct_states": {
+        "mean": 98.66666666666667,
+        "sd": 0.5773502691896257
+      }
+    },
+    {
+      "kappa": 0.1,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 72.72222222222221,
+        "sd": 1.5122952876462374
+      },
+      "n_channel": {
+        "mean": 561.0,
+        "sd": 2.6457513110645907
+      },
+      "c_channel": {
+        "mean": 38.666666666666664,
+        "sd": 3.2145502536643185
+      },
+      "c_share_pct": {
+        "mean": 6.447690595436839,
+        "sd": 0.5302050289335655
+      },
+      "distinct_states": {
+        "mean": 96.33333333333333,
+        "sd": 1.1547005383792517
+      }
+    },
+    {
+      "kappa": 0.2,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 75.6111111111111,
+        "sd": 2.341256389522826
+      },
+      "n_channel": {
+        "mean": 565.0,
+        "sd": 9.539392014169456
+      },
+      "c_channel": {
+        "mean": 33.333333333333336,
+        "sd": 10.598742063723098
+      },
+      "c_share_pct": {
+        "mean": 5.568931655122206,
+        "sd": 1.7628295898376896
+      },
+      "distinct_states": {
+        "mean": 91.33333333333333,
+        "sd": 2.3094010767585034
+      }
+    },
+    {
+      "kappa": 0.36,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 80.05555555555556,
+        "sd": 1.6777409856157277
+      },
+      "n_channel": {
+        "mean": 581.3333333333334,
+        "sd": 6.110100926607787
+      },
+      "c_channel": {
+        "mean": 18.666666666666668,
+        "sd": 6.110100926607786
+      },
+      "c_share_pct": {
+        "mean": 3.111111111111111,
+        "sd": 1.0183501544346312
+      },
+      "distinct_states": {
+        "mean": 79.66666666666667,
+        "sd": 4.163331998932265
+      }
+    },
+    {
+      "kappa": 0.5,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 81.5,
+        "sd": 0.763762615825981
+      },
+      "n_channel": {
+        "mean": 581.3333333333334,
+        "sd": 4.932882862316247
+      },
+      "c_channel": {
+        "mean": 18.0,
+        "sd": 4.58257569495584
+      },
+      "c_share_pct": {
+        "mean": 3.003530286138982,
+        "sd": 0.764941739718453
+      },
+      "distinct_states": {
+        "mean": 72.66666666666667,
+        "sd": 3.511884584284246
+      }
+    },
+    {
+      "kappa": 0.75,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 80.72222222222223,
+        "sd": 3.0971910810592
+      },
+      "n_channel": {
+        "mean": 581.0,
+        "sd": 6.244997998398398
+      },
+      "c_channel": {
+        "mean": 16.0,
+        "sd": 6.557438524302
+      },
+      "c_share_pct": {
+        "mean": 2.6796054825390296,
+        "sd": 1.0959544374089136
+      },
+      "distinct_states": {
+        "mean": 73.0,
+        "sd": 3.605551275463989
+      }
+    },
+    {
+      "kappa": 1.0,
+      "path_seeds": [
+        0,
+        1,
+        2
+      ],
+      "reach_pct": {
+        "mean": 100.0,
+        "sd": 0.0
+      },
+      "gateway_pct": {
+        "mean": 80.27777777777779,
+        "sd": 2.0161385901804545
+      },
+      "n_channel": {
+        "mean": 582.3333333333334,
+        "sd": 0.5773502691896257
+      },
+      "c_channel": {
+        "mean": 15.0,
+        "sd": 1.0
+      },
+      "c_share_pct": {
+        "mean": 2.5108915445152546,
+        "sd": 0.16106912425173006
+      },
+      "distinct_states": {
+        "mean": 69.66666666666667,
+        "sd": 3.055050463303893
+      }
+    }
+  ]
+}

data/mb_stats.json

@@ -0,0 +1,78 @@
+{
+  "raw": [
+    43.36666666666667,
+    47.03333333333333,
+    48.31666666666666,
+    45.18333333333334,
+    55.199999999999996,
+    45.31666666666667,
+    43.54999999999999,
+    47.81666666666666,
+    50.36666666666667,
+    43.949999999999996,
+    59.650000000000006,
+    53.48333333333333,
+    44.6,
+    55.86666666666665,
+    46.85,
+    58.650000000000006,
+    48.29999999999999,
+    51.06666666666666,
+    45.633333333333326,
+    58.849999999999994
+  ],
+  "fk": [
+    76.85,
+    80.43333333333334,
+    79.26666666666667,
+    85.88333333333334,
+    94.53333333333332,
+    74.76666666666667,
+    93.13333333333334,
+    89.89999999999999,
+    87.98333333333333,
+    85.31666666666666,
+    94.14999999999999,
+    89.89999999999999,
+    84.85000000000001,
+    97.83333333333333,
+    85.48333333333333,
+    89.88333333333333,
+    90.98333333333335,
+    80.43333333333334,
+    91.56666666666666,
+    92.43333333333334
+  ],
+  "clust_seeds": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19
+  ],
+  "path_seeds": [
+    0,
+    1,
+    2
+  ],
+  "n_paths": 2000,
+  "tica_lag": 20,
+  "lag": 5,
+  "N": 16,
+  "alpha": 1.5
+}