Create app.py

app.py

@@ -0,0 +1,963 @@
+import os
+import time
+import math
+import json
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# ===============================================================
+# Rendered Frame Theory (RFT) — Agent Console (All-in-One Space)
+# Author: Liam Grinstead
+# Purpose: Transparent, reproducible, benchmarkable agent demos
+# Dependencies: numpy, pandas, matplotlib, gradio (NO scipy)
+# ===============================================================
+
+OUTDIR = "outputs"
+os.makedirs(OUTDIR, exist_ok=True)
+
+# -----------------------------
+# Shared utilities
+# -----------------------------
+def set_seed(seed: int):
+    np.random.seed(int(seed) % (2**32 - 1))
+
+def clamp(x, lo, hi):
+    return max(lo, min(hi, x))
+
+def save_plot(fig, name: str):
+    path = os.path.join(OUTDIR, name)
+    fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    return path
+
+def df_to_csv_file(df: pd.DataFrame, name: str):
+    path = os.path.join(OUTDIR, name)
+    df.to_csv(path, index=False)
+    return path
+
+# -----------------------------
+# RFT Core: τ_eff + gating
+# -----------------------------
+def tau_eff_adaptive(uncertainty: float,
+                     base: float = 1.0,
+                     slow_by: float = 1.0,
+                     gain: float = 1.2,
+                     cap: float = 4.0):
+    """
+    τ_eff here is implemented as a timing/decision delay modifier.
+    - base: baseline τ_eff
+    - slow_by: explicit "slow by 1.0" style term (user requested this behaviour)
+    - gain: how strongly τ_eff reacts to uncertainty
+    - cap: prevents absurd values
+    """
+    u = clamp(float(uncertainty), 0.0, 1.0)
+    tau = base + slow_by + gain * u
+    return clamp(tau, base, cap)
+
+def rft_confidence(uncertainty: float):
+    # Confidence is the complement of uncertainty, clipped.
+    return clamp(1.0 - float(uncertainty), 0.0, 1.0)
+
+def rft_gate(conf: float, tau_eff: float, threshold: float):
+    """
+    Collapse gate:
+    - higher τ_eff makes gate stricter (forces more decisive conditions)
+    - threshold is the minimum confidence needed
+    """
+    conf = float(conf)
+    tau_eff = float(tau_eff)
+    # stricter with larger tau: raise the effective threshold
+    effective = threshold + 0.08 * (tau_eff - 1.0)
+    return conf >= clamp(effective, 0.0, 0.999)
+
+# -----------------------------
+# NEO Simulation
+# -----------------------------
+def simulate_neo(seed: int,
+                 steps: int,
+                 dt: float,
+                 alert_km: float,
+                 noise_km: float,
+                 rft_conf_threshold: float,
+                 tau_gain: float,
+                 show_debug: bool):
+    set_seed(seed)
+
+    # Start far-ish but inside a range that can produce alerts
+    pos = np.array([9000.0, 2500.0, 1000.0], dtype=float)  # km
+    vel = np.array([-55.0, -8.0, -3.0], dtype=float)       # km/step (scaled)
+
+    rows = []
+    alerts_baseline = 0
+    alerts_rft_raw = 0
+    alerts_rft_filtered = 0
+    ops_proxy = 0
+
+    for t in range(int(steps)):
+        # Truth propagation (simple linear + drift)
+        drift = 0.05 * np.array([math.sin(0.03*t), math.cos(0.02*t), math.sin(0.015*t)])
+        pos_true = pos + vel * dt + drift
+
+        # Measurement noise
+        meas = pos_true + np.random.normal(0.0, noise_km, size=3)
+
+        # Distance to origin (proxy for Earth)
+        dist = float(np.linalg.norm(meas))
+
+        # Uncertainty proxy: higher noise and higher speed increase uncertainty
+        speed = float(np.linalg.norm(vel))
+        uncertainty = clamp((noise_km / max(alert_km, 1.0)) * 2.0 + (speed / 200.0) * 0.2, 0.0, 1.0)
+
+        # Baseline alert: if within radius
+        baseline_alert = dist <= alert_km
+        if baseline_alert:
+            alerts_baseline += 1
+
+        # RFT: τ_eff + confidence + gate (collapse earlier / smarter)
+        tau = tau_eff_adaptive(uncertainty=uncertainty, base=1.0, slow_by=1.0, gain=tau_gain, cap=4.0)
+        conf = rft_confidence(uncertainty)
+        # "RFT alert candidate" uses same geometric condition but *requires* collapse gate
+        rft_candidate = dist <= alert_km
+        rft_alert = bool(rft_candidate and rft_gate(conf, tau, rft_conf_threshold))
+
+        if rft_candidate:
+            alerts_rft_raw += 1
+        if rft_alert:
+            alerts_rft_filtered += 1
+
+        ops_proxy += 12  # a stable "compute proxy" per step
+
+        rows.append({
+            "t": t,
+            "dt": dt,
+            "x_km": meas[0],
+            "y_km": meas[1],
+            "z_km": meas[2],
+            "dist_km": dist,
+            "noise_km": noise_km,
+            "uncertainty": uncertainty,
+            "tau_eff": tau,
+            "confidence": conf,
+            "baseline_alert": int(baseline_alert),
+            "rft_candidate": int(rft_candidate),
+            "rft_alert": int(rft_alert),
+        })
+
+        pos = pos_true
+
+    df = pd.DataFrame(rows)
+
+    # Plots
+    fig1 = plt.figure(figsize=(10, 4))
+    ax = fig1.add_subplot(111)
+    ax.plot(df["t"], df["dist_km"])
+    ax.axhline(alert_km, linestyle="--")
+    ax.set_title("NEO: Distance to target vs time")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("distance (km)")
+    p_dist = save_plot(fig1, f"neo_distance_seed{seed}.png")
+
+    fig2 = plt.figure(figsize=(10, 4))
+    ax = fig2.add_subplot(111)
+    ax.plot(df["t"], df["confidence"])
+    ax.plot(df["t"], df["tau_eff"])
+    ax.set_title("NEO: Confidence and τ_eff (Adaptive)")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("value")
+    p_conf = save_plot(fig2, f"neo_conf_tau_seed{seed}.png")
+
+    fig3 = plt.figure(figsize=(10, 3))
+    ax = fig3.add_subplot(111)
+    ax.step(df["t"], df["baseline_alert"], where="post")
+    ax.step(df["t"], df["rft_alert"], where="post")
+    ax.set_title("NEO: Alerts (Baseline vs RFT)")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("alert (0/1)")
+    p_alerts = save_plot(fig3, f"neo_alerts_seed{seed}.png")
+
+    csv_path = df_to_csv_file(df, f"neo_log_seed{seed}.csv")
+
+    summary = {
+        "seed": int(seed),
+        "steps": int(steps),
+        "alert_km": float(alert_km),
+        "baseline_alerts": int(alerts_baseline),
+        "rft_candidates": int(alerts_rft_raw),
+        "rft_alerts_filtered": int(alerts_rft_filtered),
+        "false_positive_proxy_reduction_%": float(
+            100.0 * (1.0 - (alerts_rft_filtered / max(alerts_rft_raw, 1)))
+        ),
+        "ops_proxy": int(ops_proxy),
+    }
+
+    debug_lines = ""
+    if show_debug:
+        debug_lines = (
+            "Debug view (first 12 rows):\n"
+            + df.head(12).to_string(index=False)
+        )
+
+    return summary, debug_lines, [p_dist, p_conf, p_alerts], csv_path
+
+# -----------------------------
+# Satellite Jitter Simulation
+# -----------------------------
+def simulate_jitter(seed: int,
+                    steps: int,
+                    dt: float,
+                    noise: float,
+                    baseline_kp: float,
+                    rft_kp: float,
+                    gate_threshold: float,
+                    tau_gain: float):
+    set_seed(seed)
+
+    jitter = 0.0
+    jitter_rate = 0.0
+    act_baseline = 0.0
+    act_rft = 0.0
+
+    rows = []
+    duty_baseline = 0
+    duty_rft = 0
+    ops_proxy = 0
+
+    for t in range(int(steps)):
+        # Jitter dynamics (random walk + periodic micro-vibe)
+        micro = 0.25 * math.sin(0.05 * t) + 0.12 * math.sin(0.13 * t)
+        jitter_rate += np.random.normal(0.0, noise) * 0.08
+        jitter += jitter_rate * dt + micro + np.random.normal(0.0, noise)
+
+        # Baseline: continuous correction
+        u_base = -baseline_kp * jitter
+        jitter_base_next = jitter + u_base * 0.35
+        duty_baseline += int(abs(u_base) > 0.01)
+
+        # RFT: correct only when it’s worth collapsing an action
+        uncertainty = clamp(noise * 3.0, 0.0, 1.0)
+        tau = tau_eff_adaptive(uncertainty, base=1.0, slow_by=1.0, gain=tau_gain, cap=4.0)
+        conf = rft_confidence(uncertainty)
+
+        should_act = rft_gate(conf, tau, gate_threshold) and (abs(jitter) > 0.35)
+        u_rft = (-rft_kp * jitter) if should_act else 0.0
+        jitter_rft_next = jitter + u_rft * 0.35
+        duty_rft += int(abs(u_rft) > 0.01)
+
+        # Apply combined evolution (keep it fair by updating the same jitter state)
+        # We store both "what baseline would do" and "what RFT would do"
+        act_baseline = u_base
+        act_rft = u_rft
+
+        ops_proxy += 10
+
+        rows.append({
+            "t": t,
+            "jitter": jitter,
+            "u_baseline": act_baseline,
+            "u_rft": act_rft,
+            "baseline_active": int(abs(act_baseline) > 0.01),
+            "rft_active": int(abs(act_rft) > 0.01),
+            "tau_eff": tau,
+            "confidence": conf,
+            "noise": noise,
+            "jitter_baseline_next": jitter_base_next,
+            "jitter_rft_next": jitter_rft_next,
+        })
+
+        # Update jitter state (common plant)
+        jitter = jitter_rft_next  # choose RFT plant evolution to reflect "running RFT"
+        jitter_rate *= 0.92
+
+    df = pd.DataFrame(rows)
+
+    rms = lambda x: float(np.sqrt(np.mean(np.square(x))))
+    jitter_rms = rms(df["jitter"].values)
+    duty_b = duty_baseline / max(steps, 1)
+    duty_r = duty_rft / max(steps, 1)
+
+    fig1 = plt.figure(figsize=(10, 4))
+    ax = fig1.add_subplot(111)
+    ax.plot(df["t"], df["jitter"])
+    ax.set_title("Jitter: residual vs time (running RFT plant)")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("jitter (arb)")
+    p_jit = save_plot(fig1, f"jitter_residual_seed{seed}.png")
+
+    fig2 = plt.figure(figsize=(10, 3))
+    ax = fig2.add_subplot(111)
+    ax.step(df["t"], df["baseline_active"], where="post")
+    ax.step(df["t"], df["rft_active"], where="post")
+    ax.set_title("Jitter: Actuation duty (Baseline vs RFT gating)")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("active (0/1)")
+    p_duty = save_plot(fig2, f"jitter_duty_seed{seed}.png")
+
+    fig3 = plt.figure(figsize=(10, 4))
+    ax = fig3.add_subplot(111)
+    ax.plot(df["t"], df["tau_eff"])
+    ax.plot(df["t"], df["confidence"])
+    ax.set_title("Jitter: τ_eff and confidence")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("value")
+    p_tau = save_plot(fig3, f"jitter_tau_seed{seed}.png")
+
+    csv_path = df_to_csv_file(df, f"jitter_log_seed{seed}.csv")
+
+    summary = {
+        "seed": int(seed),
+        "steps": int(steps),
+        "jitter_rms": jitter_rms,
+        "baseline_duty_ratio": float(duty_b),
+        "rft_duty_ratio": float(duty_r),
+        "duty_reduction_%": float(100.0 * (1.0 - (duty_r / max(duty_b, 1e-9)))),
+        "ops_proxy": int(ops_proxy),
+    }
+
+    return summary, [p_jit, p_duty, p_tau], csv_path
+
+# -----------------------------
+# Starship-style Landing Harness (2D)
+# -----------------------------
+def simulate_landing(seed: int,
+                     steps: int,
+                     dt: float,
+                     wind_max: float,
+                     thrust_noise: float,
+                     kp_baseline: float,
+                     kp_rft: float,
+                     gate_threshold: float,
+                     tau_gain: float,
+                     goal_m: float):
+    set_seed(seed)
+
+    # state: altitude, vertical velocity, lateral x offset, lateral velocity
+    alt = 1000.0
+    vv = -45.0
+    x = 60.0
+    xv = 0.0
+
+    anomalies = 0
+    actions = 0
+    ops_proxy = 0
+
+    rows = []
+
+    for t in range(int(steps)):
+        # wind profile
+        wind = wind_max * (0.55 + 0.45 * math.sin(0.08 * t)) + np.random.normal(0, 0.4)
+        wind = clamp(wind, 0.0, wind_max)
+
+        # thrust disturbance
+        thrust_dev = np.random.normal(0.0, thrust_noise)
+
+        # measurement noise (simple)
+        meas_alt = alt + np.random.normal(0, 0.6)
+        meas_vv = vv + np.random.normal(0, 0.35)
+        meas_x = x + np.random.normal(0, 0.8)
+        meas_xv = xv + np.random.normal(0, 0.25)
+
+        # uncertainty proxy
+        uncertainty = clamp((abs(thrust_dev) / 5.0) * 0.15 + (wind / max(wind_max, 1e-9)) * 0.25, 0.0, 1.0)
+        tau = tau_eff_adaptive(uncertainty, base=1.0, slow_by=1.0, gain=tau_gain, cap=4.0)
+        conf = rft_confidence(uncertainty)
+
+        # anomaly definition (reduced spam): only count if materially bad
+        # pitch/yaw/roll are not modelled here; we count "control-relevant" anomalies:
+        # - high wind
+        # - high lateral error near ground
+        # - high descent rate near ground
+        anomaly_types = []
+        if wind > (0.85 * wind_max):
+            anomaly_types.append("High wind")
+        if meas_alt < 200 and abs(meas_x) > 20:
+            anomaly_types.append("High lateral error near ground")
+        if meas_alt < 150 and abs(meas_vv) > 15:
+            anomaly_types.append("High descent rate near ground")
+
+        is_anomaly = len(anomaly_types) > 0
+        if is_anomaly:
+            anomalies += 1
+
+        # Baseline control: continuous proportional
+        u_base_x = -kp_baseline * meas_x - 0.25 * meas_xv
+        u_base_v = -kp_baseline * (meas_vv + 5.0)  # target ~ -5 m/s
+
+        # RFT control: gated “collapse” actions
+        do_action = rft_gate(conf, tau, gate_threshold)
+
+        # lookahead scaling makes RFT more decisive as altitude drops
+        phase = 1.0 - clamp(meas_alt / 1000.0, 0.0, 1.0)  # 0 high up, 1 near ground
+        lookahead = 1.0 + 1.2 * phase
+
+        u_rft_x = 0.0
+        u_rft_v = 0.0
+        if do_action:
+            u_rft_x = (-kp_rft * lookahead * meas_x) - (0.30 * meas_xv)
+            u_rft_v = (-kp_rft * lookahead * (meas_vv + 5.0))
+            actions += 1
+
+        # apply dynamics
+        # vertical: vv integrates thrust + gravity (simplified)
+        g = -9.81
+        vv = vv + (g + 0.18 * u_rft_v + 0.08 * thrust_dev) * dt
+        alt = max(0.0, alt + vv * dt)
+
+        # lateral: wind pushes, control counters
+        xv = xv + (0.35 * wind - 0.30 * u_rft_x) * dt
+        x = x + xv * dt
+
+        ops_proxy += 16
+
+        rows.append({
+            "t": t,
+            "alt_m": alt,
+            "vv_m_s": vv,
+            "x_m": x,
+            "xv_m_s": xv,
+            "wind_m_s": wind,
+            "thrust_dev": thrust_dev,
+            "uncertainty": uncertainty,
+            "tau_eff": tau,
+            "confidence": conf,
+            "anomaly": int(is_anomaly),
+            "anomaly_types": "|".join(anomaly_types) if anomaly_types else "",
+            "action_taken": int(do_action),
+            "u_baseline_x": u_base_x,
+            "u_baseline_v": u_base_v,
+            "u_rft_x": u_rft_x,
+            "u_rft_v": u_rft_v,
+        })
+
+        if alt <= 0.0:
+            break
+
+    df = pd.DataFrame(rows)
+
+    landing_offset = float(abs(df["x_m"].iloc[-1])) if len(df) else 9999.0
+
+    fig1 = plt.figure(figsize=(10, 4))
+    ax = fig1.add_subplot(111)
+    ax.plot(df["t"], df["alt_m"])
+    ax.set_title("Landing: altitude vs time")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("altitude (m)")
+    p_alt = save_plot(fig1, f"landing_alt_seed{seed}.png")
+
+    fig2 = plt.figure(figsize=(10, 4))
+    ax = fig2.add_subplot(111)
+    ax.plot(df["t"], df["x_m"])
+    ax.axhline(goal_m, linestyle="--")
+    ax.axhline(-goal_m, linestyle="--")
+    ax.set_title("Landing: lateral offset vs time (goal band)")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("offset (m)")
+    p_x = save_plot(fig2, f"landing_offset_seed{seed}.png")
+
+    fig3 = plt.figure(figsize=(10, 4))
+    ax = fig3.add_subplot(111)
+    ax.plot(df["t"], df["wind_m_s"])
+    ax.set_title("Landing: wind profile")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("wind (m/s)")
+    p_w = save_plot(fig3, f"landing_wind_seed{seed}.png")
+
+    fig4 = plt.figure(figsize=(10, 3))
+    ax = fig4.add_subplot(111)
+    ax.step(df["t"], df["anomaly"], where="post")
+    ax.step(df["t"], df["action_taken"], where="post")
+    ax.set_title("Landing: anomaly vs action timeline")
+    ax.set_xlabel("t (step)")
+    ax.set_ylabel("0/1")
+    p_a = save_plot(fig4, f"landing_anomaly_action_seed{seed}.png")
+
+    csv_path = df_to_csv_file(df, f"landing_log_seed{seed}.csv")
+
+    summary = {
+        "seed": int(seed),
+        "steps_ran": int(len(df)),
+        "final_landing_offset_m": float(landing_offset),
+        "goal_m": float(goal_m),
+        "hit_goal": bool(landing_offset <= goal_m),
+        "total_anomalies_detected": int(anomalies),
+        "total_control_actions": int(actions),
+        "ops_proxy": int(ops_proxy),
+    }
+
+    return summary, [p_alt, p_x, p_w, p_a], csv_path
+
+# -----------------------------
+# Benchmarks
+# -----------------------------
+def run_benchmarks(seed: int,
+                   neo_steps: int, neo_dt: float, neo_alert_km: float, neo_noise_km: float,
+                   jit_steps: int, jit_dt: float, jit_noise: float,
+                   land_steps: int, land_dt: float, land_wind: float, land_thrust_noise: float,
+                   tau_gain: float):
+    """
+    Benchmarks are baseline vs RFT under the SAME seed.
+    Baseline here means:
+    - NEO: geometric threshold only
+    - Jitter: continuous correction (no gating)
+    - Landing: continuous proportional (no gating)
+    RFT means τ_eff + confidence + gate.
+    """
+    seed = int(seed)
+
+    # NEO benchmark
+    s_rft, _, neo_imgs, neo_csv = simulate_neo(
+        seed=seed,
+        steps=neo_steps,
+        dt=neo_dt,
+        alert_km=neo_alert_km,
+        noise_km=neo_noise_km,
+        rft_conf_threshold=0.55,
+        tau_gain=tau_gain,
+        show_debug=False
+    )
+    # Baseline alerts equals df baseline count; derive from CSV
+    neo_df = pd.read_csv(neo_csv)
+    neo_base = int(neo_df["baseline_alert"].sum())
+    neo_rft = int(neo_df["rft_alert"].sum())
+    neo_candidates = int(neo_df["rft_candidate"].sum())
+
+    # Jitter benchmark
+    j_sum, jit_imgs, jit_csv = simulate_jitter(
+        seed=seed,
+        steps=jit_steps,
+        dt=jit_dt,
+        noise=jit_noise,
+        baseline_kp=0.35,
+        rft_kp=0.55,
+        gate_threshold=0.55,
+        tau_gain=tau_gain
+    )
+
+    # Landing benchmark
+    l_sum, land_imgs, land_csv = simulate_landing(
+        seed=seed,
+        steps=land_steps,
+        dt=land_dt,
+        wind_max=land_wind,
+        thrust_noise=land_thrust_noise,
+        kp_baseline=0.06,   # baseline weaker to show "continuous but less decisive"
+        kp_rft=0.10,        # RFT stronger but gated and phase-weighted
+        gate_threshold=0.55,
+        tau_gain=tau_gain,
+        goal_m=10.0
+    )
+
+    # Scorecard table
+    score = pd.DataFrame([
+        {
+            "Module": "NEO",
+            "Baseline alerts": neo_base,
+            "RFT candidates": neo_candidates,
+            "RFT filtered alerts": neo_rft,
+            "False-positive proxy reduction %": 100.0 * (1.0 - (neo_rft / max(neo_candidates, 1))),
+            "Energy/compute proxy": int(s_rft["ops_proxy"])
+        },
+        {
+            "Module": "Satellite Jitter",
+            "Baseline alerts": "",
+            "RFT candidates": "",
+            "RFT filtered alerts": "",
+            "False-positive proxy reduction %": "",
+            "Energy/compute proxy": int(j_sum["ops_proxy"])
+        },
+        {
+            "Module": "Landing",
+            "Baseline alerts": "",
+            "RFT candidates": "",
+            "RFT filtered alerts": "",
+            "False-positive proxy reduction %": "",
+            "Energy/compute proxy": int(l_sum["ops_proxy"])
+        },
+    ])
+
+    score_path = df_to_csv_file(score, f"bench_score_seed{seed}.csv")
+
+    # Summary text
+    txt = (
+        f"Benchmarks (seed={seed})\n"
+        f"- NEO: baseline alerts={neo_base}, RFT candidates={neo_candidates}, RFT filtered={neo_rft}\n"
+        f"- Jitter: jitter RMS={j_sum['jitter_rms']:.4f}, duty reduction={j_sum['duty_reduction_%']:.1f}%\n"
+        f"- Landing: final offset={l_sum['final_landing_offset_m']:.2f} m (goal 10 m), anomalies={l_sum['total_anomalies_detected']}, actions={l_sum['total_control_actions']}\n"
+    )
+
+    all_imgs = neo_imgs + jit_imgs + land_imgs
+    return txt, score, score_path, all_imgs, [neo_csv, jit_csv, land_csv]
+
+# -----------------------------
+# UI text blocks (your voice, full openness)
+# -----------------------------
+HOME_MD = """
+# Rendered Frame Theory (RFT) — Agent Console
+
+I built this Space to be transparent, reproducible, and benchmarkable.
+
+I’m not asking anyone to “believe” in anything here.  
+Run it. Change the parameters. Break it. Compare baseline vs RFT.  
+
+What I’m demonstrating is a practical idea:
+
+**Decision timing matters.**  
+RFT treats timing (τ_eff), uncertainty, and action “collapse” as first-class controls.
+
+This Space contains three working agent harnesses:
+- **NEO alerting** (reduce early false positives under noisy tracking)
+- **Satellite jitter reduction** (reduce actuator duty / chatter while keeping residual low)
+- **Starship-style landing harness** (simplified, but structured to test decision timing under wind/thrust disturbances)
+
+Every tab shows what it’s doing, why, and where it wins or loses.
+
+No SciPy. No hidden dependencies. No model weights. No tricks.
+"""
+
+LIVE_MD = """
+# Live Console
+
+This tab is a single place to run everything quickly and export logs.
+
+If someone wants to argue, this is where the argument dies:
+- deterministic runs (seeded)
+- plots saved
+- CSV logs exported
+- baseline vs RFT comparisons available
+"""
+
+THEORY_PRACTICE_MD = """
+# Theory → Practice (how I implement RFT here)
+
+This Space uses RFT in a practical way:
+
+## 1) Uncertainty (explicit)
+I compute an uncertainty proxy from noise + disturbance scale.  
+This is not magic. It’s just honest modelling.
+
+## 2) Confidence
+Confidence is the complement: **confidence = 1 − uncertainty** (clipped 0..1).
+
+## 3) Adaptive τ_eff
+τ_eff is implemented as a timing/decision strictness modifier:
+- higher uncertainty → higher τ_eff
+- **and yes, I explicitly slow τ_eff by 1.0**, because this was the target behaviour I wanted to test.
+
+## 4) Collapse gate
+I only apply “decisive actions” when the gate condition passes:
+- confidence must exceed a threshold
+- τ_eff increases strictness (makes the gate harder under uncertainty)
+
+## 5) Why this matters
+Baseline controllers often act constantly.
+RFT tries to act **less often**, but **more decisively**, so you waste less energy and trigger fewer junk corrections/alerts.
+"""
+
+MATH_MD = r"""
+# Mathematics (minimal and implementation-linked)
+
+I’m keeping this readable and tied to actual behaviour in code.
+
+## Variables (used in this Space)
+- **u ∈ [0,1]** : uncertainty proxy (dimensionless)
+- **C ∈ [0,1]** : confidence proxy (dimensionless)
+- **τ_eff ≥ 1** : effective render/decision timing factor (dimensionless)
+- **Gate(C, τ_eff)** : action/alert collapse condition
+
+## Definitions
+### Confidence
+\[
+C = \text{clip}(1 - u, 0, 1)
+\]
+
+### Adaptive τ_eff (with “slow by 1.0”)
+\[
+\tau_{\text{eff}} = \text{clip}(1 + 1.0 + g\cdot u,\; 1,\; \tau_{\max})
+\]
+where \( g \) is a gain.
+
+### Collapse gate (concept)
+A higher τ_eff makes the decision stricter:
+\[
+\text{Gate} = \left[C \ge \theta + k(\tau_{\text{eff}}-1)\right]
+\]
+where \( \theta \) is the base confidence threshold and \( k \) increases strictness with τ_eff.
+
+That’s exactly what I implement here: more uncertainty → higher τ_eff → harder gate → fewer low-confidence actions.
+"""
+
+INVESTOR_MD = """
+# Investor / Agency Walkthrough (plain language)
+
+## What I’m proving inside this Space
+I’m demonstrating a decision-timing framework that can be applied to:
+- alert filtering (NEO / tracking)
+- stabilisation (jitter reduction)
+- anomaly-aware control loops (landing harness)
+
+This is not a “pitch deck”. It’s a runnable harness:
+- you can reproduce the results with seeds
+- you can export logs
+- you can compare baseline vs RFT
+- you can change thresholds and see behaviour shift
+
+## What I’m NOT claiming
+- I’m not claiming flight certification
+- I’m not claiming SpaceX is using this
+- I’m not claiming this replaces aerospace validation pipelines
+
+## What would make this production-grade
+- real sensor ingestion + timing constraints
+- hardware-in-loop testing
+- systematic dataset validation
+- integration targets (embedded, REST, batch)
+
+If you want the “serious build”, I can package these modules as:
+- Python module
+- REST endpoint
+- edge builds (ARM)
+"""
+
+REPRO_MD = """
+# Reproducibility & Logs
+
+Everything here is reproducible:
+- set the seed
+- run baseline vs RFT with the same seed
+- export the CSV
+- verify plots and metrics
+
+CSV schema is explicit in the exports:
+- time index
+- state values
+- uncertainty, confidence, τ_eff
+- alerts/actions flags
+"""
+
+# -----------------------------
+# Gradio UI
+# -----------------------------
+def ui_run_neo(seed, steps, dt, alert_km, noise_km, rft_conf_th, tau_gain, show_debug):
+    summary, debug_lines, imgs, csv_path = simulate_neo(
+        seed=int(seed),
+        steps=int(steps),
+        dt=float(dt),
+        alert_km=float(alert_km),
+        noise_km=float(noise_km),
+        rft_conf_threshold=float(rft_conf_th),
+        tau_gain=float(tau_gain),
+        show_debug=bool(show_debug),
+    )
+    summary_txt = json.dumps(summary, indent=2)
+    return summary_txt, debug_lines, imgs[0], imgs[1], imgs[2], csv_path
+
+def ui_run_jitter(seed, steps, dt, noise, baseline_kp, rft_kp, gate_th, tau_gain):
+    summary, imgs, csv_path = simulate_jitter(
+        seed=int(seed),
+        steps=int(steps),
+        dt=float(dt),
+        noise=float(noise),
+        baseline_kp=float(baseline_kp),
+        rft_kp=float(rft_kp),
+        gate_threshold=float(gate_th),
+        tau_gain=float(tau_gain),
+    )
+    summary_txt = json.dumps(summary, indent=2)
+    return summary_txt, imgs[0], imgs[1], imgs[2], csv_path
+
+def ui_run_landing(seed, steps, dt, wind_max, thrust_noise, kp_base, kp_rft, gate_th, tau_gain, goal_m):
+    summary, imgs, csv_path = simulate_landing(
+        seed=int(seed),
+        steps=int(steps),
+        dt=float(dt),
+        wind_max=float(wind_max),
+        thrust_noise=float(thrust_noise),
+        kp_baseline=float(kp_base),
+        kp_rft=float(kp_rft),
+        gate_threshold=float(gate_th),
+        tau_gain=float(tau_gain),
+        goal_m=float(goal_m),
+    )
+    summary_txt = json.dumps(summary, indent=2)
+    return summary_txt, imgs[0], imgs[1], imgs[2], imgs[3], csv_path
+
+def ui_run_bench(seed, neo_steps, neo_dt, neo_alert_km, neo_noise_km, jit_steps, jit_dt, jit_noise, land_steps, land_dt, land_wind, land_thrust_noise, tau_gain):
+    txt, score_df, score_csv, imgs, logs = run_benchmarks(
+        seed=int(seed),
+        neo_steps=int(neo_steps), neo_dt=float(neo_dt), neo_alert_km=float(neo_alert_km), neo_noise_km=float(neo_noise_km),
+        jit_steps=int(jit_steps), jit_dt=float(jit_dt), jit_noise=float(jit_noise),
+        land_steps=int(land_steps), land_dt=float(land_dt), land_wind=float(land_wind), land_thrust_noise=float(land_thrust_noise),
+        tau_gain=float(tau_gain)
+    )
+    return txt, score_df, score_csv, imgs[0], imgs[1], imgs[2], imgs[3], imgs[4], imgs[5], imgs[6], imgs[7], imgs[8], logs[0], logs[1], logs[2]
+
+with gr.Blocks(title="RFT — Agent Console (NEO / Jitter / Landing)") as demo:
+    gr.Markdown(HOME_MD)
+
+    with gr.Tabs():
+        # ----------------------------------------------------------
+        with gr.Tab("Live Console"):
+            gr.Markdown(LIVE_MD)
+
+            with gr.Row():
+                seed_live = gr.Number(value=42, precision=0, label="Seed (reproducible)")
+                tau_gain_live = gr.Slider(0.0, 3.0, value=1.2, step=0.05, label="τ_eff gain (global)")
+
+            with gr.Accordion("Benchmark settings", open=True):
+                with gr.Row():
+                    neo_steps = gr.Slider(50, 400, value=120, step=1, label="NEO steps")
+                    neo_dt = gr.Slider(0.5, 3.0, value=1.0, step=0.1, label="NEO dt")
+                    neo_alert = gr.Slider(1000, 20000, value=5000, step=50, label="NEO alert radius (km)")
+                    neo_noise = gr.Slider(0.0, 200.0, value=35.0, step=1.0, label="NEO measurement noise (km)")
+
+                with gr.Row():
+                    jit_steps = gr.Slider(100, 1200, value=500, step=1, label="Jitter steps")
+                    jit_dt = gr.Slider(0.5, 2.0, value=1.0, step=0.1, label="Jitter dt")
+                    jit_noise = gr.Slider(0.0, 0.5, value=0.08, step=0.01, label="Jitter noise")
+
+                with gr.Row():
+                    land_steps = gr.Slider(40, 400, value=120, step=1, label="Landing steps")
+                    land_dt = gr.Slider(0.2, 2.0, value=1.0, step=0.1, label="Landing dt")
+                    land_wind = gr.Slider(0.0, 25.0, value=15.0, step=0.5, label="Landing wind max (m/s)")
+                    land_thrust_noise = gr.Slider(0.0, 10.0, value=3.0, step=0.1, label="Landing thrust noise")
+
+            run_b = gr.Button("Run Full Benchmarks (Baseline vs RFT)")
+
+            bench_txt = gr.Textbox(label="Benchmark summary", lines=6)
+            bench_table = gr.Dataframe(label="Scorecard (CSV also exported)")
+
+            bench_score_csv = gr.File(label="Download: benchmark scorecard CSV")
+            with gr.Row():
+                img1 = gr.Image(label="NEO: Distance")
+                img2 = gr.Image(label="NEO: Confidence & τ_eff")
+                img3 = gr.Image(label="NEO: Alerts")
+            with gr.Row():
+                img4 = gr.Image(label="Jitter: Residual")
+                img5 = gr.Image(label="Jitter: Duty")
+                img6 = gr.Image(label="Jitter: τ_eff & confidence")
+            with gr.Row():
+                img7 = gr.Image(label="Landing: Altitude")
+                img8 = gr.Image(label="Landing: Offset")
+                img9 = gr.Image(label="Landing: Wind")
+            img10 = gr.Image(label="Landing: anomaly vs action timeline")
+
+            neo_log = gr.File(label="Download: NEO log CSV")
+            jit_log = gr.File(label="Download: Jitter log CSV")
+            land_log = gr.File(label="Download: Landing log CSV")
+
+            run_b.click(
+                ui_run_bench,
+                inputs=[seed_live, neo_steps, neo_dt, neo_alert, neo_noise, jit_steps, jit_dt, jit_noise, land_steps, land_dt, land_wind, land_thrust_noise, tau_gain_live],
+                outputs=[bench_txt, bench_table, bench_score_csv,
+                         img1, img2, img3, img4, img5, img6, img7, img8, img9, img10,
+                         neo_log, jit_log, land_log]
+            )
+
+        # ----------------------------------------------------------
+        with gr.Tab("NEO Agent"):
+            gr.Markdown("# Near-Earth Object (NEO) Alerting Agent\nThis is a test harness for filtering close-approach alerts under noise.\nBaseline: distance threshold only.\nRFT: distance threshold + confidence + τ_eff collapse gate.\n")
+            with gr.Row():
+                seed_neo = gr.Number(value=42, precision=0, label="Seed")
+                steps_neo = gr.Slider(50, 400, value=120, step=1, label="Steps")
+                dt_neo = gr.Slider(0.5, 3.0, value=1.0, step=0.1, label="dt")
+            with gr.Row():
+                alert_km = gr.Slider(1000, 20000, value=5000, step=50, label="Alert threshold (km)")
+                noise_km = gr.Slider(0.0, 200.0, value=35.0, step=1.0, label="Measurement noise (km)")
+                rft_conf_th = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="RFT confidence threshold")
+                tau_gain = gr.Slider(0.0, 3.0, value=1.2, step=0.05, label="τ_eff gain")
+            show_debug = gr.Checkbox(value=False, label="Show debug table (first rows)")
+            run_neo = gr.Button("Run NEO Simulation")
+
+            out_neo_summary = gr.Textbox(label="Summary JSON", lines=12)
+            out_neo_debug = gr.Textbox(label="Debug", lines=10)
+            with gr.Row():
+                out_neo_img1 = gr.Image(label="Distance vs time")
+                out_neo_img2 = gr.Image(label="Confidence and τ_eff")
+                out_neo_img3 = gr.Image(label="Alerts timeline")
+            out_neo_csv = gr.File(label="Download NEO CSV log")
+
+            run_neo.click(
+                ui_run_neo,
+                inputs=[seed_neo, steps_neo, dt_neo, alert_km, noise_km, rft_conf_th, tau_gain, show_debug],
+                outputs=[out_neo_summary, out_neo_debug, out_neo_img1, out_neo_img2, out_neo_img3, out_neo_csv]
+            )
+
+        # ----------------------------------------------------------
+        with gr.Tab("Satellite Jitter Agent"):
+            gr.Markdown("# Satellite Jitter Reduction\nBaseline: continuous correction.\nRFT: gated correction using confidence + τ_eff.\nThis is a simple but honest test of duty-cycle reduction.\n")
+            with gr.Row():
+                seed_j = gr.Number(value=42, precision=0, label="Seed")
+                steps_j = gr.Slider(100, 1200, value=500, step=1, label="Steps")
+                dt_j = gr.Slider(0.5, 2.0, value=1.0, step=0.1, label="dt")
+                noise_j = gr.Slider(0.0, 0.5, value=0.08, step=0.01, label="Noise")
+            with gr.Row():
+                base_kp = gr.Slider(0.0, 1.0, value=0.35, step=0.01, label="Baseline kp")
+                rft_kp = gr.Slider(0.0, 1.5, value=0.55, step=0.01, label="RFT kp")
+                gate_th = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="Gate threshold")
+                tau_gain_j = gr.Slider(0.0, 3.0, value=1.2, step=0.05, label="τ_eff gain")
+            run_j = gr.Button("Run Jitter Simulation")
+
+            out_j_summary = gr.Textbox(label="Summary JSON", lines=10)
+            with gr.Row():
+                out_j_img1 = gr.Image(label="Residual jitter")
+                out_j_img2 = gr.Image(label="Duty timeline")
+                out_j_img3 = gr.Image(label="τ_eff & confidence")
+            out_j_csv = gr.File(label="Download Jitter CSV log")
+
+            run_j.click(
+                ui_run_jitter,
+                inputs=[seed_j, steps_j, dt_j, noise_j, base_kp, rft_kp, gate_th, tau_gain_j],
+                outputs=[out_j_summary, out_j_img1, out_j_img2, out_j_img3, out_j_csv]
+            )
+
+        # ----------------------------------------------------------
+        with gr.Tab("Starship Landing Harness"):
+            gr.Markdown("# Starship-style Landing Harness (Simplified)\nThis is not a SpaceX flight model. It’s a timing-control harness.\nBaseline vs RFT shows whether gated decision timing can reduce waste and still hit the landing goal.\n")
+            with gr.Row():
+                seed_l = gr.Number(value=42, precision=0, label="Seed")
+                steps_l = gr.Slider(40, 400, value=120, step=1, label="Steps")
+                dt_l = gr.Slider(0.2, 2.0, value=1.0, step=0.1, label="dt")
+            with gr.Row():
+                wind_max = gr.Slider(0.0, 25.0, value=15.0, step=0.5, label="Wind max (m/s)")
+                thrust_noise = gr.Slider(0.0, 10.0, value=3.0, step=0.1, label="Thrust noise")
+                kp_base_l = gr.Slider(0.0, 0.2, value=0.06, step=0.005, label="Baseline kp")
+                kp_rft_l = gr.Slider(0.0, 0.25, value=0.10, step=0.005, label="RFT kp")
+            with gr.Row():
+                gate_th_l = gr.Slider(0.1, 0.95, value=0.55, step=0.01, label="Gate threshold")
+                tau_gain_l = gr.Slider(0.0, 3.0, value=1.2, step=0.05, label="τ_eff gain")
+                goal_m = gr.Slider(1.0, 50.0, value=10.0, step=0.5, label="Landing goal (m)")
+            run_l = gr.Button("Run Landing Simulation")
+
+            out_l_summary = gr.Textbox(label="Summary JSON", lines=10)
+            with gr.Row():
+                out_l_img1 = gr.Image(label="Altitude")
+                out_l_img2 = gr.Image(label="Offset")
+                out_l_img3 = gr.Image(label="Wind")
+            out_l_img4 = gr.Image(label="Anomaly vs Action timeline")
+            out_l_csv = gr.File(label="Download Landing CSV log")
+
+            run_l.click(
+                ui_run_landing,
+                inputs=[seed_l, steps_l, dt_l, wind_max, thrust_noise, kp_base_l, kp_rft_l, gate_th_l, tau_gain_l, goal_m],
+                outputs=[out_l_summary, out_l_img1, out_l_img2, out_l_img3, out_l_img4, out_l_csv]
+            )
+
+        # ----------------------------------------------------------
+        with gr.Tab("Benchmarks"):
+            gr.Markdown("# Benchmarks\nIf someone wants to argue, this is the tab.\nBaseline vs RFT runs, same seed, exported logs.\nUse Live Console to run full benchmark packs.\n")
+
+        # ----------------------------------------------------------
+        with gr.Tab("Theory → Practice"):
+            gr.Markdown(THEORY_PRACTICE_MD)
+
+        with gr.Tab("Mathematics"):
+            gr.Markdown(MATH_MD)
+
+        with gr.Tab("Investor / Agency Walkthrough"):
+            gr.Markdown(INVESTOR_MD)
+
+        with gr.Tab("Reproducibility & Logs"):
+            gr.Markdown(REPRO_MD)
+
+demo.queue().launch()