Update app.py

app.py

@@ -1,103 +1,40 @@
-# app.py
-# Coherent_Compute_Engine — RFTSystems
-# Real, on-machine coherent throughput benchmark + tamper-evident receipt download (SHA-256).
-#
-# What an “item” is:
-#   1 item = one per-oscillator coherent state update of [Psi, E, L] per step.
-#
-# Notes:
-# - Measurements reflect the Hugging Face Space runtime hardware (not the visitor’s local machine).
-# - Includes optional baselines (NumPy vectorised + tiny Python loop) computed live.
-# - Produces a downloadable receipt JSON with canonical hashing for verification.
+# app.py — Coherent_Compute_Engine (RFTSystems)
+# Live, measurable throughput + stability + energy proxy, with verification baselines + receipt download.
+# No estimates. No precomputed data. Same workload, same machine, same rules.
 
 import os
-import json
 import time
+import json
 import math
-import csv
 import hashlib
 import platform
-import datetime as dt
-from pathlib import Path
+from datetime import datetime, timezone
 
 import numpy as np
 import gradio as gr
 
-# Optional: Numba acceleration (used if available)
+# Optional: numba acceleration
 try:
     import numba as nb
     NUMBA_OK = True
 except Exception:
-    nb = None
     NUMBA_OK = False
+    nb = None
 
-APP_NAME = "Coherent_Compute_Engine"
-APP_VERSION = "v1.0.0"
-RESULTS_DIR = Path("results")
-RESULTS_DIR.mkdir(exist_ok=True)
-
-# ----------------------------
-# Canonical JSON + integrity
-# ----------------------------
-def canon_json_bytes(obj) -> bytes:
-    return json.dumps(
-        obj,
-        ensure_ascii=False,
-        sort_keys=True,
-        separators=(",", ":"),
-    ).encode("utf-8")
-
-def sha256_hex(b: bytes) -> str:
-    return hashlib.sha256(b).hexdigest()
-
-def utc_now_iso() -> str:
-    # Avoid deprecated utcnow warning in newer Python versions
-    return dt.datetime.now(dt.timezone.utc).isoformat().replace("+00:00", "Z")
-
-def write_receipt(payload: dict) -> str:
-    """
-    Writes a JSON receipt to disk and returns the filepath for Gradio download.
-    Receipt includes its own SHA-256 of the canonical JSON (tamper-evident).
-    """
-    # hash without integrity field
-    payload = dict(payload)  # copy
-    payload.pop("integrity", None)
-
-    b0 = canon_json_bytes(payload)
-    h = sha256_hex(b0)
+APP_TITLE = "Coherent Compute Engine"
+RESULTS_DIR = "receipts"
 
-    payload["integrity"] = {
-        "sha256": h,
-        "receipt_id": h[:12],
-        "canonical_json": "sorted_keys + compact_separators",
-    }
+# -----------------------------
+# Definition: what an "item" is
+# -----------------------------
+# One coherent state update of [Psi, E, L] per oscillator per step.
+# Items/sec = (N oscillators * steps) / elapsed_seconds
 
-    b1 = canon_json_bytes(payload)
-
-    ts = payload.get("timestamp_utc", utc_now_iso())
-    safe_ts = ts.replace(":", "").replace(".", "").replace("Z", "")
-    fname = f"receipt_{safe_ts}_{h[:12]}.json"
-    path = RESULTS_DIR / fname
-    path.write_bytes(b1)
-    return str(path)
-
-def append_csv_row(row: dict, csv_path: Path):
-    headers = [
-        "timestamp_utc","engine","device_note","oscillators","steps",
-        "elapsed_s","throughput_Bps","coherence_abs","mean_energy",
-        "python","platform","cpu_count_logical","numba_available","seed","scale"
-    ]
-    need_header = not csv_path.exists()
-    with csv_path.open("a", newline="") as f:
-        w = csv.DictWriter(f, fieldnames=headers)
-        if need_header:
-            w.writeheader()
-        w.writerow({k: row.get(k, "") for k in headers})
-
-# ----------------------------
-# RFT-lite coherent kernel
-# ----------------------------
-def _np_step(Psi, E, L, scale=1.0):
+# -----------------------------
+# Core update: vectorised (NumPy)
+# -----------------------------
+def np_step(Psi, E, L, scale=1.0):
+    # Numerically tame, branchless-ish ops; stable for large N.
     phase = 0.997 * Psi + 0.003 * E
     drive = np.tanh(phase * scale)
     Psi_n = 0.999 * Psi + 0.001 * drive
@@ -105,303 +42,298 @@ def _np_step(Psi, E, L, scale=1.0):
     L_n   = 0.998 * L   + 0.001 * (Psi_n * E_n)
     return Psi_n, E_n, L_n
 
-def coherence_abs(Psi0: np.ndarray, Psi1: np.ndarray) -> float:
-    v0 = Psi0.astype(np.float64, copy=False)
-    v1 = Psi1.astype(np.float64, copy=False)
-    num = float(np.dot(v0, v1))
-    den = float(np.linalg.norm(v0) * np.linalg.norm(v1)) + 1e-12
-    return abs(num / den)
+# -----------------------------
+# Baseline: tiny Python loop (safety-capped)
+# -----------------------------
+def pyloop_step(Psi, E, L, scale=1.0):
+    # Scalar operations; intentionally slow baseline.
+    phase = 0.997 * Psi + 0.003 * E
+    drive = math.tanh(phase * scale)
+    Psi_n = 0.999 * Psi + 0.001 * drive
+    E_n   = 0.995 * E   + 0.004 * Psi_n
+    L_n   = 0.998 * L   + 0.001 * (Psi_n * E_n)
+    return Psi_n, E_n, L_n
 
-def mean_energy(E: np.ndarray) -> float:
+def run_python_loop_baseline(n, steps, seed=7, cap_seconds=1.2):
+    """
+    Runs a scalar baseline on a small subset for a short capped duration.
+    Reports throughput in *equivalent* items/sec for that baseline subset only.
+    This is a "floor" baseline, not a competitor.
+    """
+    rng = np.random.default_rng(seed)
+    # Keep tiny so we don't lock the Space.
+    n0 = min(n, 150_000)  # safety subset
+    Psi = rng.random(n0, dtype=np.float32)
+    E   = rng.random(n0, dtype=np.float32)
+    L   = rng.random(n0, dtype=np.float32)
+
+    # Run until either steps done or time cap hit
+    t0 = time.time()
+    done = 0
+    for _ in range(int(steps)):
+        # time cap guard
+        if (time.time() - t0) > cap_seconds:
+            break
+        # scalar loop over subset
+        for i in range(n0):
+            Psi[i], E[i], L[i] = pyloop_step(float(Psi[i]), float(E[i]), float(L[i]))
+        done += 1
+
+    elapsed = max(1e-9, time.time() - t0)
+    items = done * n0
+    thr_Bps = (items / elapsed) / 1e9
+    return thr_Bps, elapsed, n0, done
+
+# -----------------------------
+# Optional: Numba kernel
+# -----------------------------
+if NUMBA_OK:
+    @nb.njit(fastmath=True, parallel=True)
+    def nb_run(Psi, E, L, steps):
+        for _ in range(steps):
+            # same math as numpy step, inside jit loop
+            phase = 0.997 * Psi + 0.003 * E
+            drive = np.tanh(phase)
+            Psi = 0.999 * Psi + 0.001 * drive
+            E   = 0.995 * E   + 0.004 * Psi
+            L   = 0.998 * L   + 0.001 * (Psi * E)
+        return Psi, E, L
+
+def compute_coherence(Psi_before, Psi_after):
+    # Normalised dot product: magnitude is the point; can be signed.
+    # We report |C| for "stability" to avoid phase sign confusion.
+    v1 = Psi_before.astype(np.float64, copy=False)
+    v2 = Psi_after.astype(np.float64, copy=False)
+    num = float(np.dot(v1, v2)) + 1e-12
+    den = float(np.linalg.norm(v1) * np.linalg.norm(v2)) + 1e-12
+    return num / den
+
+def compute_energy(E):
+    # Energy proxy: bounded mean in [0,1.5]
     return float(np.mean(np.clip(E, 0.0, 1.5)))
 
-def run_engine_numpy(n: int, steps: int, seed: int, scale: float):
-    rng = np.random.default_rng(seed)
+def human_bps(x_bps):
+    # x_bps is in billions/sec (B/s)
+    if x_bps >= 1.0:
+        return f"{x_bps:.3f} B/s"
+    return f"{x_bps:.3f} B/s"
+
+def get_cpu_string():
+    # best-effort
+    try:
+        return platform.processor() or platform.uname().processor or ""
+    except Exception:
+        return ""
+
+def sha256_bytes(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+def make_receipt(payload: dict):
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H-%M-%SZ")
+    fname = f"receipt_{ts}.json"
+    path = os.path.join(RESULTS_DIR, fname)
+
+    # Canonical JSON for stable hashing
+    canon = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    h = sha256_bytes(canon)
+
+    payload_out = dict(payload)
+    payload_out["receipt_sha256"] = h
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(payload_out, f, indent=2)
+
+    return path, h, payload_out
+
+def run_engine(n_oscillators: int, steps: int, include_baselines: bool):
+    # Hard safety rails for HF Spaces stability (still "full throttle" within reason)
+    n = int(max(50_000, min(int(n_oscillators), 25_000_000)))
+    steps = int(max(10, min(int(steps), 2_000)))
+
+    rng = np.random.default_rng(7)
     Psi = rng.random(n, dtype=np.float32)
     E   = rng.random(n, dtype=np.float32)
     L   = rng.random(n, dtype=np.float32)
 
-    sample = min(n, 200_000)
+    # Snapshot for coherence metric (small sample)
+    sample = min(n, 250_000)
     Psi0 = Psi[:sample].copy()
 
-    t0 = time.perf_counter()
-    for _ in range(steps):
-        Psi, E, L = _np_step(Psi, E, L, scale=scale)
-    t1 = time.perf_counter()
-
-    elapsed = t1 - t0
-    Psi1 = Psi[:sample].copy()
-
-    items = int(n) * int(steps)
-    throughput_Bps = (items / elapsed) / 1e9
-
-    return {
-        "engine": "numpy",
-        "oscillators": int(n),
-        "steps": int(steps),
-        "elapsed_s": float(elapsed),
-        "throughput_Bps": float(throughput_Bps),
-        "coherence_abs": float(coherence_abs(Psi0, Psi1)),
-        "mean_energy": float(mean_energy(E[:sample])),
-    }
-
-# ----------------------------
-# Baselines (optional, live)
-# ----------------------------
-def run_baseline_python(n: int, steps: int, seed: int):
-    # Safety caps for hosted runtimes
-    n = min(n, 200_000)
-    steps = min(steps, 10)
-
-    rng = np.random.default_rng(seed)
-    Psi = rng.random(n).tolist()
-    E   = rng.random(n).tolist()
-    L   = rng.random(n).tolist()
-
-    def step(Psi, E, L):
-        outPsi = [0.0]*n
-        outE   = [0.0]*n
-        outL   = [0.0]*n
-        for i in range(n):
-            phase = 0.997*Psi[i] + 0.003*E[i]
-            drive = math.tanh(phase)
-            p = 0.999*Psi[i] + 0.001*drive
-            e = 0.995*E[i] + 0.004*p
-            l = 0.998*L[i] + 0.001*(p*e)
-            outPsi[i], outE[i], outL[i] = p, e, l
-        return outPsi, outE, outL
-
-    t0 = time.perf_counter()
-    for _ in range(steps):
-        Psi, E, L = step(Psi, E, L)
-    t1 = time.perf_counter()
-
-    elapsed = t1 - t0
-    items = int(n) * int(steps)
-    throughput_Bps = (items / elapsed) / 1e9
-
-    return {
-        "engine": "python_loop",
-        "oscillators": int(n),
-        "steps": int(steps),
-        "elapsed_s": float(elapsed),
-        "throughput_Bps": float(throughput_Bps),
-        "coherence_abs": 1.0,
-        "mean_energy": float(np.mean(np.clip(np.array(E[:min(n, 50_000)], dtype=np.float32), 0.0, 1.5))),
-        "note": "Python baseline is safety-capped (n<=200k, steps<=10).",
-    }
+    # Choose engine: prefer numba if available, else numpy
+    engine = "numpy"
+    t0 = time.time()
 
-# ----------------------------
-# Numba engine (if available)
-# ----------------------------
-if NUMBA_OK:
-    @nb.njit(fastmath=True)
-    def _numba_kernel(Psi, E, L, scale):
-        n = Psi.shape[0]
-        for i in range(n):
-            phase = 0.997 * Psi[i] + 0.003 * E[i]
-            drive = math.tanh(phase * scale)
-            p = 0.999 * Psi[i] + 0.001 * drive
-            e = 0.995 * E[i] + 0.004 * p
-            l = 0.998 * L[i] + 0.001 * (p * e)
-            Psi[i] = p
-            E[i] = e
-            L[i] = l
-
-    def run_engine_numba(n: int, steps: int, seed: int, scale: float):
-        rng = np.random.default_rng(seed)
-        Psi = rng.random(n, dtype=np.float32)
-        E   = rng.random(n, dtype=np.float32)
-        L   = rng.random(n, dtype=np.float32)
-
-        sample = min(n, 200_000)
-        Psi0 = Psi[:sample].copy()
-
-        # compile warmup on tiny arrays
-        tiny = min(n, 1024)
-        _numba_kernel(Psi[:tiny], E[:tiny], L[:tiny], scale)
-
-        t0 = time.perf_counter()
-        for _ in range(steps):
-            _numba_kernel(Psi, E, L, scale)
-        t1 = time.perf_counter()
-
-        elapsed = t1 - t0
-        Psi1 = Psi[:sample].copy()
-
-        items = int(n) * int(steps)
-        throughput_Bps = (items / elapsed) / 1e9
-
-        return {
-            "engine": "numba",
-            "oscillators": int(n),
-            "steps": int(steps),
-            "elapsed_s": float(elapsed),
-            "throughput_Bps": float(throughput_Bps),
-            "coherence_abs": float(coherence_abs(Psi0, Psi1)),
-            "mean_energy": float(mean_energy(E[:sample])),
-        }
-
-# ----------------------------
-# Runner + UI helpers
-# ----------------------------
-def format_ui(primary: dict, baselines: dict | None):
-    ui = {
-        "Throughput (B/s)": f'{primary["throughput_Bps"]:.3f} B/s',
-        "Coherence (|C|)": f'{primary["coherence_abs"]:.5f}',
-        "Mean Energy": f'{primary["mean_energy"]:.5f}',
-        "Elapsed Time (s)": f'{primary["elapsed_s"]:.2f}',
-        "Oscillators": f'{primary["oscillators"]:,}',
-        "Steps": f'{primary["steps"]:,}',
-        "Engine": primary["engine"],
-        "CPU Cores Available": os.cpu_count(),
-    }
-    if baselines:
-        for name, b in baselines.items():
-            ui[f"Baseline: {name} (B/s)"] = f'{b["throughput_Bps"]:.3f}'
-            ui[f"Baseline: {name} Engine"] = b["engine"]
-    return ui
-
-def run_and_receipt(n_oscillators, steps, seed, scale, include_baselines):
-    n = int(n_oscillators)
-    s = int(steps)
-    seed = int(seed)
-    scale = float(scale)
-
-    # Safety rails (prevents accidental crash / OOM on Space)
-    n = max(100_000, min(n, 40_000_000))
-    s = max(10, min(s, 5000))
-
-    # primary engine
     if NUMBA_OK:
-        primary = run_engine_numba(n, s, seed, scale)
+        engine = "numba"
+        # warm-up compile on a tiny slice if first run
+        # (keeps first-run penalty from ruining the metric)
+        try:
+            _Psi_w = Psi[:50_000].copy()
+            _E_w   = E[:50_000].copy()
+            _L_w   = L[:50_000].copy()
+            nb_run(_Psi_w, _E_w, _L_w, 2)
+        except Exception:
+            engine = "numpy"
+
+    if engine == "numba":
+        Psi, E, L = nb_run(Psi, E, L, steps)
     else:
-        primary = run_engine_numpy(n, s, seed, scale)
+        for _ in range(steps):
+            Psi, E, L = np_step(Psi, E, L)
+
+    elapsed = max(1e-9, time.time() - t0)
+
+    # Metrics
+    items = n * steps
+    thr_Bps = (items / elapsed) / 1e9
+
+    coh = compute_coherence(Psi0, Psi[:sample])
+    coh_abs = abs(coh)
+    meanE = compute_energy(E[:sample])
+
+    # Optional baselines (measured live)
+    base_numpy = None
+    base_py = None
+    speedup_vs_py = None
+    speedup_vs_numpy = None
 
-    # optional baselines
-    baselines = {}
     if include_baselines:
-        baselines["numpy"] = run_engine_numpy(min(n, 8_000_000), min(s, 2000), seed, scale)
-        baselines["python_loop"] = run_baseline_python(min(n, 500_000), min(s, 200), seed)
+        # Baseline A: NumPy (forced) on same n/steps
+        t1 = time.time()
+        PsiA = rng.random(n, dtype=np.float32)
+        EA   = rng.random(n, dtype=np.float32)
+        LA   = rng.random(n, dtype=np.float32)
+        for _ in range(steps):
+            PsiA, EA, LA = np_step(PsiA, EA, LA)
+        elA = max(1e-9, time.time() - t1)
+        base_numpy = (n * steps / elA) / 1e9
+
+        # Baseline B: Python loop (subset, capped)
+        base_py, py_elapsed, py_n, py_steps_done = run_python_loop_baseline(n=n, steps=steps, seed=7)
 
-    # build receipt payload
+        # Speedups (honest: can be < 1.0)
+        if base_py and base_py > 0:
+            speedup_vs_py = thr_Bps / base_py
+        if base_numpy and base_numpy > 0:
+            speedup_vs_numpy = thr_Bps / base_numpy
+
+    # Receipt payload
     payload = {
-        "timestamp_utc": utc_now_iso(),
-        "app": {"name": APP_NAME, "version": APP_VERSION},
-        "definition": {
-            "item": "1 item = one per-oscillator coherent state update of [Psi, E, L] per step (as implemented here)."
-        },
-        "runtime": {
-            "device_note": "Hugging Face Space runtime machine (results are not from the visitor's local CPU).",
-            "platform": platform.platform(),
-            "python": platform.python_version(),
-            "cpu_count_logical": os.cpu_count(),
-            "numba_available": bool(NUMBA_OK),
-        },
-        "inputs": {
-            "oscillators": int(n),
-            "steps": int(s),
-            "seed": int(seed),
-            "scale": float(scale),
-            "include_baselines": bool(include_baselines),
-        },
-        "results": {
-            "primary": primary,
-            "baselines": baselines,
-        },
+        "app": APP_TITLE,
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "definition_of_item": "One coherent update of [Psi,E,L] per oscillator per step",
+        "n_oscillators": n,
+        "steps": steps,
+        "engine": engine,
+        "elapsed_seconds": elapsed,
+        "throughput_Bps": thr_Bps,
+        "coherence_C": coh,
+        "coherence_abs": coh_abs,
+        "mean_energy_proxy": meanE,
+        "cpu": get_cpu_string(),
+        "cores_available": os.cpu_count() or 1,
+        "baselines_enabled": bool(include_baselines),
+        "baseline_numpy_Bps": base_numpy,
+        "baseline_python_loop_Bps": base_py,
+        "speedup_vs_python_loop_x": speedup_vs_py,
+        "speedup_vs_numpy_x": speedup_vs_numpy,
+        "notes": [
+            "All values measured live on the Space runtime machine.",
+            "Baselines are measured on the same machine with the same workload settings.",
+            "Python loop baseline is safety-capped and uses a subset to keep the Space responsive.",
+        ],
     }
 
-    receipt_path = write_receipt(payload)
-
-    # append csv row (primary only)
-    csv_row = {
-        "timestamp_utc": payload["timestamp_utc"],
-        "engine": primary["engine"],
-        "device_note": payload["runtime"]["device_note"],
-        "oscillators": primary["oscillators"],
-        "steps": primary["steps"],
-        "elapsed_s": primary["elapsed_s"],
-        "throughput_Bps": primary["throughput_Bps"],
-        "coherence_abs": primary["coherence_abs"],
-        "mean_energy": primary["mean_energy"],
-        "python": payload["runtime"]["python"],
-        "platform": payload["runtime"]["platform"],
-        "cpu_count_logical": payload["runtime"]["cpu_count_logical"],
-        "numba_available": payload["runtime"]["numba_available"],
-        "seed": seed,
-        "scale": scale,
+    receipt_path, receipt_sha, payload_out = make_receipt(payload)
+
+    # UI-friendly output (minimal, factual)
+    result = {
+        "Throughput (B/s)": f"{thr_Bps:.3f}",
+        "Coherence (|C|)": f"{coh_abs:.5f}",
+        "Mean Energy": f"{meanE:.5f}",
+        "Elapsed Time (s)": f"{elapsed:.2f}",
+        "Oscillators": f"{n:,}",
+        "Steps": f"{steps}",
+        "Engine": engine,
+        "CPU Cores Available": int(os.cpu_count() or 1),
     }
-    append_csv_row(csv_row, RESULTS_DIR / "runs.csv")
 
-    # UI output
-    ui = format_ui(primary, baselines if include_baselines else None)
-    ui["Receipt SHA-256 (in file)"] = payload["integrity"]["sha256"] if "integrity" in payload else "written in receipt"
+    if include_baselines:
+        result["Baseline (Vectorised NumPy) (B/s)"] = f"{base_numpy:.3f}" if base_numpy is not None else "n/a"
+        result["Baseline (Python loop, capped) (B/s)"] = f"{base_py:.3f}" if base_py is not None else "n/a"
+        if speedup_vs_py is not None:
+            result["Speedup vs Python loop (x)"] = f"{speedup_vs_py:.1f}"
+        if speedup_vs_numpy is not None:
+            result["Speedup vs NumPy (x)"] = f"{speedup_vs_numpy:.2f}"
+        # add one explicit honesty line
+        result["Note"] = "Speedups can be <1.0 depending on runtime/Numba warmup/CPU features. That is expected and is reported as-is."
+
+    result["Receipt SHA-256 (in file)"] = "written in receipt"
+
+    return json.dumps(result, indent=2), receipt_path
 
-    return ui, receipt_path
 
-# ----------------------------
+# -----------------------------
 # UI
-# ----------------------------
-CSS = """
-:root { --rft-accent: #ff7a18; }
-.gradio-container { max-width: 980px !important; }
-#titlebar h1 { font-size: 2.05rem; letter-spacing: -0.02em; }
-.rft-card { border-radius: 16px !important; border: 1px solid rgba(255,255,255,0.08) !important; }
-"""
+# -----------------------------
+INTRO_MD = """
+### What this is
+- **No precomputed results**
+- **No GPUs required**
+- Measures **real throughput**, **stability**, and **energy behaviour** on the machine running this Space.
 
-with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        """
-<div id="titlebar"><h1>Coherent Compute Engine</h1></div>
+### What an “item” is
+- One coherent state update of **[Ψ, E, L]** per oscillator per step.
 
-**What this Space does**  
-Runs a real coherent state-update benchmark and reports measured throughput, stability proxy, and energy behavior. No precomputed results.
+Everything you see below is computed **right now**, on this machine.
+"""
 
-**What an “item” is**  
-One coherent update of **[Ψ, E, L]** per oscillator per step.
+NOTES_MD = """
+**Notes**
+- This runs on the Hugging Face Space runtime machine. Your browser just displays the UI.
+- If the Space is under load, throughput will vary — that variance is real and is part of the measurement.
+- Baselines are not “competitions”. They are **verification anchors** measured live on the same machine.
+"""
 
-**Verification**  
-Every run generates a tamper-evident receipt (JSON) with a SHA-256 hash you can download.
-        """
+with gr.Blocks(theme=gr.themes.Soft(), title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}")
+    gr.Markdown(INTRO_MD)
+
+    with gr.Row():
+        n_slider = gr.Slider(
+            minimum=250_000,
+            maximum=25_000_000,
+            value=6_400_000,
+            step=50_000,
+            label="Number of Oscillators",
+        )
+        steps_slider = gr.Slider(
+            minimum=50,
+            maximum=2000,
+            value=650,
+            step=10,
+            label="Simulation Steps",
+        )
+
+    include_baselines = gr.Checkbox(
+        value=True,
+        label="Show verification baselines (same machine)",
+        info="Baselines are measured live too. Python loop is safety-capped."
     )
 
+    run_btn = gr.Button("Run Engine", variant="primary")
+
     with gr.Row():
-        with gr.Column(scale=1):
-            with gr.Group(elem_classes=["rft-card"]):
-                n_slider = gr.Slider(
-                    minimum=100_000, maximum=40_000_000, step=100_000,
-                    value=6_400_000, label="Number of Oscillators"
-                )
-                steps_slider = gr.Slider(
-                    minimum=10, maximum=5000, step=10,
-                    value=650, label="Simulation Steps"
-                )
-                seed_box = gr.Number(value=7, precision=0, label="Seed")
-                scale_box = gr.Number(value=1.0, precision=3, label="Scale (stability knob)")
-                include_baselines = gr.Checkbox(
-                    value=False,
-                    label="Include baselines (NumPy + tiny Python loop)",
-                    info="Baselines are measured live too. Python loop is safety-capped."
-                )
-                run_btn = gr.Button("Run Engine", variant="primary")
-
-        with gr.Column(scale=1):
-            results_json = gr.JSON(label="Results")
-            receipt_file = gr.File(label="Receipt (download)")
+        out_json = gr.Code(label="Results", language="json")
+    receipt_file = gr.File(label="Receipt (download)", file_count="single")
 
-    run_btn.click(
-        fn=run_and_receipt,
-        inputs=[n_slider, steps_slider, seed_box, scale_box, include_baselines],
-        outputs=[results_json, receipt_file],
-    )
+    gr.Markdown(NOTES_MD)
 
-    gr.Markdown(
-        """
-**Notes**
-- This runs on the Hugging Face Space runtime machine. Your browser is just the UI.
-- If the Space is under load, throughput will vary; the receipt captures the environment at run time.
-        """
+    run_btn.click(
+        fn=run_engine,
+        inputs=[n_slider, steps_slider, include_baselines],
+        outputs=[out_json, receipt_file],
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue(concurrency_count=1).launch()