Update app.py

app.py

@@ -1,309 +1,353 @@
-# app.py — Coherent_Compute_Engine (RFTSystems) — Gradio 6.x compatible
-# Live measured throughput + stability + energy proxy, with verification baselines + receipt download.
-# No estimates. No precomputed data.
+# app.py — Coherent_Compute_Engine (RFTSystems)
+# Live, on-machine benchmarking + receipt download (SHA-256)
+# - Clarifies units: "B items/s" (billions of items per second) + raw items/s
+# - Baselines are optional + clearly "context only"
+# - Adds a Trust KPI badge: receipt SHA-256 generated from THIS run
 
 import os
-import time
 import json
+import time
 import math
 import hashlib
 import platform
-from datetime import datetime, timezone
+import datetime as dt
 
 import numpy as np
 import gradio as gr
 
-# Optional: numba acceleration
+# ----------------------------
+# Optional Numba acceleration
+# ----------------------------
+NUMBA_OK = False
 try:
     import numba as nb
     NUMBA_OK = True
 except Exception:
-    NUMBA_OK = False
     nb = None
+    NUMBA_OK = False
 
 APP_TITLE = "Coherent Compute Engine"
-RESULTS_DIR = "receipts"
-
-# -----------------------------
-# Definition: what an "item" is
-# -----------------------------
-# One coherent state update of [Psi, E, L] per oscillator per step.
-# Items/sec = (N oscillators * steps) / elapsed_seconds
-
-# -----------------------------
-# Core update: vectorised (NumPy)
-# -----------------------------
-def np_step(Psi, E, L, scale=1.0):
+OUT_DIR = "/tmp/receipts"
+os.makedirs(OUT_DIR, exist_ok=True)
+
+# ----------------------------
+# "Item" definition
+# ----------------------------
+# One coherent state update of [Ψ, E, L] per oscillator per step.
+# items = n_oscillators * steps
+
+# ----------------------------
+# Core update rules (safe + stable)
+# ----------------------------
+def _np_step(Psi, E, L):
+    # Branchless, numerically tame, vectorised.
     phase = 0.997 * Psi + 0.003 * E
-    drive = np.tanh(phase * scale)
+    drive = np.tanh(phase)
     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
 
-# -----------------------------
-# Baseline: tiny Python loop (safety-capped)
-# -----------------------------
-def pyloop_step(Psi, E, L, scale=1.0):
-    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 run_python_loop_baseline(n, steps, seed=7, cap_seconds=1.2):
-    """
-    Scalar baseline on a small subset for a short capped duration.
-    Reports throughput in items/sec for that subset.
-    """
-    rng = np.random.default_rng(seed)
-    n0 = min(int(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)
-
-    t0 = time.time()
-    done = 0
-    for _ in range(int(steps)):
-        if (time.time() - t0) > cap_seconds:
-            break
-        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):
-            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):
-    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):
+    def _nb_step(Psi, E, L):
+        # same math as numpy path, but parallel
+        n = Psi.shape[0]
+        for i in nb.prange(n):
+            phase = 0.997 * Psi[i] + 0.003 * E[i]
+            drive = math.tanh(phase)
+            Psi_n = 0.999 * Psi[i] + 0.001 * drive
+            E_n   = 0.995 * E[i]   + 0.004 * Psi_n
+            L_n   = 0.998 * L[i]   + 0.001 * (Psi_n * E_n)
+            Psi[i] = Psi_n
+            E[i]   = E_n
+            L[i]   = L_n
+
+
+# ----------------------------
+# Metrics (simple + honest)
+# ----------------------------
+def coherence_abs_from_final(Psi):
+    # Coherence proxy: |corr(Psi[i], Psi[i+1])|
+    # (stable, cheap, avoids extra state storage)
+    if Psi.shape[0] < 3:
+        return 0.0
+    a = Psi[:-1]
+    b = Psi[1:]
+    num = float(np.dot(a, b)) + 1e-12
+    den = float(np.linalg.norm(a) * np.linalg.norm(b)) + 1e-12
+    return float(abs(num / den))
+
+
+def mean_energy(E):
     return float(np.mean(np.clip(E, 0.0, 1.5)))
 
-def get_cpu_string():
-    try:
-        return platform.processor() or platform.uname().processor or ""
-    except Exception:
-        return ""
 
-def sha256_bytes(b: bytes) -> str:
-    return hashlib.sha256(b).hexdigest()
+# ----------------------------
+# Canonical JSON + receipt hashing
+# ----------------------------
+def canon_json_bytes(obj) -> bytes:
+    return json.dumps(obj, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
 
-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)
 
-    canon = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
-    h = sha256_bytes(canon)
+def sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
 
-    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)
+def write_receipt(payload: dict) -> str:
+    # Hash the receipt WITHOUT the hash field, then embed it.
+    payload_nohash = dict(payload)
+    payload_nohash.pop("receipt_sha256", None)
 
-    return path, h, payload_out
+    h = sha256_hex(canon_json_bytes(payload_nohash))
+    payload["receipt_sha256"] = h
 
-def run_engine(n_oscillators: int, steps: int, include_baselines: bool):
-    # Safety rails for HF Spaces stability
-    n = int(max(50_000, min(int(n_oscillators), 25_000_000)))
-    steps = int(max(10, min(int(steps), 2_000)))
+    fname = f"receipt_{dt.datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%SZ')}_{h[:10]}.json"
+    path = os.path.join(OUT_DIR, fname)
 
-    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)
+    with open(path, "wb") as f:
+        f.write(canon_json_bytes(payload))
 
-    sample = min(n, 250_000)
-    Psi0 = Psi[:sample].copy()
+    return path, h
 
-    engine = "numpy"
-    t0 = time.time()
 
-    if NUMBA_OK:
-        engine = "numba"
-        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:
-        for _ in range(steps):
-            Psi, E, L = np_step(Psi, E, L)
+# ----------------------------
+# Baselines (optional, live)
+# ----------------------------
+def baseline_numpy(Psi, E, L, steps):
+    t0 = time.perf_counter()
+    for _ in range(steps):
+        Psi, E, L = _np_step(Psi, E, L)
+    t1 = time.perf_counter()
+    return (t1 - t0)
 
-    elapsed = max(1e-9, time.time() - t0)
 
+def baseline_python_loop(n, steps, seed=7, cap_items=200_000):
+    # Safety-capped pure-Python loop so it doesn't stall the Space.
+    # It measures real work, but only for a small capped subset.
     items = n * steps
-    thr_Bps = (items / elapsed) / 1e9
+    if items > cap_items:
+        # reduce n first, then steps, to keep a meaningful kernel shape
+        scale = cap_items / max(1, items)
+        n2 = max(256, int(n * scale))
+        steps2 = max(5, int(steps * 0.25))
+    else:
+        n2, steps2 = n, steps
 
-    coh = compute_coherence(Psi0, Psi[:sample])
-    coh_abs = abs(coh)
-    meanE = compute_energy(E[:sample])
+    rng = np.random.default_rng(seed)
+    Psi = rng.random(n2).astype(np.float32)
+    E   = rng.random(n2).astype(np.float32)
+    L   = rng.random(n2).astype(np.float32)
+
+    t0 = time.perf_counter()
+    for _ in range(steps2):
+        for i in range(n2):
+            phase = 0.997 * float(Psi[i]) + 0.003 * float(E[i])
+            drive = math.tanh(phase)
+            Psi_n = 0.999 * float(Psi[i]) + 0.001 * drive
+            E_n   = 0.995 * float(E[i])   + 0.004 * Psi_n
+            L_n   = 0.998 * float(L[i])   + 0.001 * (Psi_n * E_n)
+            Psi[i] = Psi_n
+            E[i]   = E_n
+            L[i]   = L_n
+    t1 = time.perf_counter()
+
+    # Compute throughput for the *capped* run
+    elapsed = (t1 - t0)
+    items_done = int(n2) * int(steps2)
+    thr = (items_done / max(1e-9, elapsed))  # items/sec (raw)
+    return elapsed, items_done, thr, (n2, steps2)
+
+
+# ----------------------------
+# Main benchmark
+# ----------------------------
+def run_engine(n_oscillators: int, steps: int, include_baselines: bool):
+    # Hard safety guards (Spaces can be shared + unpredictable)
+    n_oscillators = int(max(50_000, min(int(n_oscillators), 25_000_000)))
+    steps = int(max(25, min(int(steps), 2_000)))
+
+    seed = 7
+    rng = np.random.default_rng(seed)
+    Psi = rng.random(n_oscillators, dtype=np.float32)
+    E   = rng.random(n_oscillators, dtype=np.float32)
+    L   = rng.random(n_oscillators, dtype=np.float32)
 
-    base_numpy = None
-    base_py = None
-    speedup_vs_py = None
-    speedup_vs_numpy = None
+    engine = "numba" if NUMBA_OK else "numpy"
 
-    if include_baselines:
-        # Baseline A: forced NumPy
-        t1 = time.time()
-        PsiA = rng.random(n, dtype=np.float32)
-        EA   = rng.random(n, dtype=np.float32)
-        LA   = rng.random(n, dtype=np.float32)
+    # Warmup (Numba compiles on first call; keep it honest but amortise compile)
+    if NUMBA_OK:
+        _nb_step(Psi[:10_000].copy(), E[:10_000].copy(), L[:10_000].copy())
+
+    t0 = time.perf_counter()
+    if NUMBA_OK:
+        for _ in range(steps):
+            _nb_step(Psi, E, L)
+    else:
         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
+            Psi, E, L = _np_step(Psi, E, L)
+    t1 = time.perf_counter()
 
-        # Baseline B: Python loop (subset + cap)
-        base_py, py_elapsed, py_n, py_steps_done = run_python_loop_baseline(n=n, steps=steps, seed=7)
+    elapsed = float(t1 - t0)
+    items = int(n_oscillators) * int(steps)
 
-        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
+    thr_items_per_s = items / max(1e-12, elapsed)
+    thr_B_items_per_s = thr_items_per_s / 1e9
 
-    payload = {
-        "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.",
-        ],
-    }
+    coh = coherence_abs_from_final(Psi)
+    eng = mean_energy(E)
 
-    receipt_path, receipt_sha, payload_out = make_receipt(payload)
+    # Metadata (keep it factual; no guessing)
+    cpu = platform.processor() or ""
+    cores = os.cpu_count() or 1
+    pyver = platform.python_version()
+    plat = platform.platform()
 
-    result = {
-        "Throughput (B/s)": f"{thr_Bps:.3f}",
-        "Coherence (|C|)": f"{coh_abs:.5f}",
-        "Mean Energy": f"{meanE:.5f}",
+    results = {
+        "Throughput (B items/s)": f"{thr_B_items_per_s:.3f}",
+        "Throughput (items/s)": f"{thr_items_per_s:,.0f}",
+        "Coherence (|C|)": f"{coh:.5f}",
+        "Mean Energy": f"{eng:.5f}",
         "Elapsed Time (s)": f"{elapsed:.2f}",
-        "Oscillators": f"{n:,}",
-        "Steps": f"{steps}",
+        "Oscillators": f"{n_oscillators:,}",
+        "Steps": f"{steps:,}",
         "Engine": engine,
-        "CPU Cores Available": int(os.cpu_count() or 1),
+        "CPU": cpu,
+        "Cores Available": int(cores),
     }
 
+    # Optional baselines (context only)
+    baseline_info = {}
     if include_baselines:
-        result["Baseline: numpy (B/s)"] = f"{base_numpy:.3f}" if base_numpy is not None else "n/a"
-        result["Baseline: python_loop (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}"
-        result["Note"] = "Speedups can be <1.0 depending on runtime/Numba warmup/CPU features. Reported as-is."
+        # NumPy baseline measured live (same maths), but smaller copy for fairness on memory
+        Psi_b = rng.random(n_oscillators, dtype=np.float32)
+        E_b   = rng.random(n_oscillators, dtype=np.float32)
+        L_b   = rng.random(n_oscillators, dtype=np.float32)
+
+        np_elapsed = baseline_numpy(Psi_b, E_b, L_b, steps)
+        np_thr = items / max(1e-12, np_elapsed)
+        np_thr_B = np_thr / 1e9
+
+        py_elapsed, py_items, py_thr, (n2, s2) = baseline_python_loop(n_oscillators, steps)
+
+        baseline_info = {
+            "Baseline: numpy (B items/s)": f"{np_thr_B:.3f}",
+            "Baseline: numpy Engine": "numpy",
+            "Baseline: python_loop (B items/s)": f"{(py_thr/1e9):.3f}",
+            "Baseline: python_loop Engine": "python_loop (safety-capped)",
+            "Baseline: python_loop items measured": f"{py_items:,} (cap run n={n2:,}, steps={s2:,})",
+            "Speedup vs python_loop (x)": f"{(thr_items_per_s / max(1e-9, py_thr)):.1f}",
+            "Speedup vs numpy (x)": f"{(thr_items_per_s / max(1e-9, np_thr)):.2f}",
+            "Note": "Baselines are for context only; all are measured live on this machine.",
+        }
+
+        results.update(baseline_info)
+
+    # Receipt payload (full fidelity + reproducible hash)
+    receipt_payload = {
+        "app": APP_TITLE,
+        "timestamp_utc": dt.datetime.utcnow().isoformat() + "Z",
+        "definition_of_item": "One coherent state update of [Psi, E, L] per oscillator per step",
+        "inputs": {
+            "oscillators": n_oscillators,
+            "steps": steps,
+            "include_baselines": bool(include_baselines),
+            "seed": seed,
+        },
+        "runtime": {
+            "engine": engine,
+            "python": pyver,
+            "platform": plat,
+            "cpu": cpu,
+            "cores_available": int(cores),
+            "numba_available": bool(NUMBA_OK),
+        },
+        "outputs": {
+            "throughput_items_per_s": float(thr_items_per_s),
+            "throughput_B_items_per_s": float(thr_B_items_per_s),
+            "coherence_abs": float(coh),
+            "mean_energy": float(eng),
+            "elapsed_s": float(elapsed),
+        },
+        "baselines": baseline_info if include_baselines else None,
+    }
 
-    result["Receipt SHA-256 (in file)"] = "written in receipt"
+    receipt_path, receipt_sha = write_receipt(receipt_payload)
 
-    return json.dumps(result, indent=2), receipt_path
+    # Trust KPI line + include hash in results
+    results["Receipt SHA-256 (in file)"] = receipt_sha
 
+    trust_badge = f"**Receipt verified:** SHA-256 generated from this run → `{receipt_sha}`"
 
-INTRO_MD = """
-### What this is
-- **No precomputed results**
-- **No GPUs required**
-- Measures **real throughput**, **stability**, and **energy behaviour** on the machine running this Space.
+    # Pretty JSON for the UI
+    pretty = json.dumps(results, indent=2)
 
-### What an “item” is
-- One coherent state update of **[Ψ, E, L]** per oscillator per step.
+    return trust_badge, pretty, receipt_path
 
-Everything you see below is computed **right now**, on this machine.
-"""
 
-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 verification anchors measured live on the same machine.
+# ----------------------------
+# UI
+# ----------------------------
+CUSTOM_CSS = """
+#app-wrap {max-width: 980px; margin: 0 auto;}
+.kpi {padding: 10px 12px; border-radius: 12px; background: rgba(120,120,255,0.08); border: 1px solid rgba(120,120,255,0.18);}
 """
 
-# Gradio 6.x: do NOT pass theme into Blocks(); pass theme into launch()
-with gr.Blocks(title=APP_TITLE) as demo:
-    gr.Markdown(f"# {APP_TITLE}")
-    gr.Markdown(INTRO_MD)
+with gr.Blocks(title=APP_TITLE, css=CUSTOM_CSS) as demo:
+    gr.Markdown(f"# {APP_TITLE}", elem_id="app-wrap")
+
+    gr.Markdown(
+        "Everything you see below is computed **right now, on this machine**.\n\n"
+        "**What an “item” is**\n"
+        "• One coherent state update of `[Ψ, E, L]` per oscillator per step\n\n"
+        "**What you get**\n"
+        "• Real throughput (items/sec), stability proxy (|C|), energy behaviour\n"
+        "• A downloadable receipt with a SHA-256 hash (verification-first)\n"
+        "• Optional baselines (context only), measured live too\n"
+    )
 
     with gr.Row():
         n_slider = gr.Slider(
-            minimum=250_000,
+            minimum=50_000,
             maximum=25_000_000,
             value=6_400_000,
             step=50_000,
             label="Number of Oscillators",
         )
-        steps_slider = gr.Slider(
-            minimum=50,
+        s_slider = gr.Slider(
+            minimum=25,
             maximum=2000,
             value=650,
-            step=10,
+            step=1,
             label="Simulation Steps",
         )
 
     include_baselines = gr.Checkbox(
         value=True,
-        label="Include baselines (NumPy + tiny Python loop)",
-        info="Baselines are measured live too. Python loop is safety-capped."
+        label="Include baselines (context only)",
+        info="Baselines are measured live too. Python loop is safety-capped.",
     )
 
     run_btn = gr.Button("Run Engine", variant="primary")
 
-    out_json = gr.Code(label="Results", language="json")
-    receipt_file = gr.File(label="Receipt (download)", file_count="single")
+    trust_md = gr.Markdown("", elem_classes=["kpi"])
+    results_box = gr.Code(label="Results", language="json")
+    receipt_file = gr.File(label="Receipt (download)")
 
-    gr.Markdown(NOTES_MD)
+    gr.Markdown(
+        "### Notes\n"
+        "• This runs on the Hugging Face Space runtime machine (not your phone UI).\n"
+        "• If the Space is under load, throughput will move — that’s real behaviour.\n"
+        "• **B items/s** means “billions of items per second”, not bytes.\n"
+    )
 
     run_btn.click(
         fn=run_engine,
-        inputs=[n_slider, steps_slider, include_baselines],
-        outputs=[out_json, receipt_file],
+        inputs=[n_slider, s_slider, include_baselines],
+        outputs=[trust_md, results_box, receipt_file],
     )
 
-if __name__ == "__main__":
-    # Gradio 6.x: queue() signature changed; keep it simple and stable.
-    demo.queue().launch(theme=gr.themes.Soft())
+# Queue without version-fragile kwargs (Gradio 6 changed queue args)
+demo.queue()
+demo.launch()