Update app.py

app.py

@@ -1,14 +1,20 @@
 # app.py
 # Coherent_Compute_Engine — RFTSystems
-# Real, on-machine benchmark + tamper-evident receipt download (SHA-256).
+# 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:
-# - Runs on the Space runtime hardware (not the visitor's local machine).
-# - “Item” = one per-oscillator state update of [Psi, E, L] per step.
+# - 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.
 
 import os
 import json
 import time
 import math
+import csv
 import hashlib
 import platform
 import datetime as dt
@@ -17,7 +23,7 @@ from pathlib import Path
 import numpy as np
 import gradio as gr
 
-# Optional: Numba baseline (will be used if available)
+# Optional: Numba acceleration (used if available)
 try:
     import numba as nb
     NUMBA_OK = True
@@ -25,7 +31,8 @@ except Exception:
     nb = None
     NUMBA_OK = False
 
-APP_VERSION = "Coherent_Compute_Engine_v1.0.0"
+APP_NAME = "Coherent_Compute_Engine"
+APP_VERSION = "v1.0.0"
 RESULTS_DIR = Path("results")
 RESULTS_DIR.mkdir(exist_ok=True)
 
@@ -43,12 +50,19 @@ def canon_json_bytes(obj) -> bytes:
 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 contains its own SHA-256 hash (tamper-evident).
+    Receipt includes its own SHA-256 of the canonical JSON (tamper-evident).
     """
-    # hash without integrity first
+    # hash without integrity field
+    payload = dict(payload)  # copy
+    payload.pop("integrity", None)
+
     b0 = canon_json_bytes(payload)
     h = sha256_hex(b0)
 
@@ -59,18 +73,31 @@ def write_receipt(payload: dict) -> str:
     }
 
     b1 = canon_json_bytes(payload)
-    ts = payload.get("timestamp_utc", dt.datetime.utcnow().isoformat() + "Z")
+
+    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})
+
 # ----------------------------
-# Core RFT-lite engine
+# RFT-lite coherent kernel
 # ----------------------------
 def _np_step(Psi, E, L, scale=1.0):
-    # numerically tame, branchless-ish
     phase = 0.997 * Psi + 0.003 * E
     drive = np.tanh(phase * scale)
     Psi_n = 0.999 * Psi + 0.001 * drive
@@ -79,8 +106,6 @@ def _np_step(Psi, E, L, scale=1.0):
     return Psi_n, E_n, L_n
 
 def coherence_abs(Psi0: np.ndarray, Psi1: np.ndarray) -> float:
-    # Normalized dot product (magnitude used)
-    # (If values are constant, den can go tiny — guard it.)
     v0 = Psi0.astype(np.float64, copy=False)
     v1 = Psi1.astype(np.float64, copy=False)
     num = float(np.dot(v0, v1))
@@ -88,7 +113,6 @@ def coherence_abs(Psi0: np.ndarray, Psi1: np.ndarray) -> float:
     return abs(num / den)
 
 def mean_energy(E: np.ndarray) -> float:
-    # bounded to keep metric stable across runs
     return float(np.mean(np.clip(E, 0.0, 1.5)))
 
 def run_engine_numpy(n: int, steps: int, seed: int, scale: float):
@@ -97,7 +121,6 @@ def run_engine_numpy(n: int, steps: int, seed: int, scale: float):
     E   = rng.random(n, dtype=np.float32)
     L   = rng.random(n, dtype=np.float32)
 
-    # capture Psi for coherence (small sample for speed)
     sample = min(n, 200_000)
     Psi0 = Psi[:sample].copy()
 
@@ -106,32 +129,30 @@ def run_engine_numpy(n: int, steps: int, seed: int, scale: float):
         Psi, E, L = _np_step(Psi, E, L, scale=scale)
     t1 = time.perf_counter()
 
-    Psi1 = Psi[:sample].copy()
     elapsed = t1 - t0
+    Psi1 = Psi[:sample].copy()
 
-    # “items” = per-oscillator update of [Psi,E,L] per step
     items = int(n) * int(steps)
     throughput_Bps = (items / elapsed) / 1e9
 
-    coh = coherence_abs(Psi0, Psi1)
-    eng = mean_energy(E[:sample])
-
     return {
         "engine": "numpy",
         "oscillators": int(n),
         "steps": int(steps),
         "elapsed_s": float(elapsed),
         "throughput_Bps": float(throughput_Bps),
-        "coherence_abs": float(coh),
-        "mean_energy": float(eng),
+        "coherence_abs": float(coherence_abs(Psi0, Psi1)),
+        "mean_energy": float(mean_energy(E[:sample])),
     }
 
 # ----------------------------
-# Baselines (optional)
+# Baselines (optional, live)
 # ----------------------------
 def run_baseline_python(n: int, steps: int, seed: int):
-    # Deliberately small n to avoid melting the Space.
+    # 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()
@@ -151,31 +172,28 @@ def run_baseline_python(n: int, steps: int, seed: int):
         return outPsi, outE, outL
 
     t0 = time.perf_counter()
-    for _ in range(min(steps, 10)):  # hard cap for safety
+    for _ in range(steps):
         Psi, E, L = step(Psi, E, L)
     t1 = time.perf_counter()
-    elapsed = t1 - t0
 
-    items = int(n) * int(min(steps, 10))
+    elapsed = t1 - t0
+    items = int(n) * int(steps)
     throughput_Bps = (items / elapsed) / 1e9
 
-    # Coherence proxy (cheap)
-    Psi0 = np.array(Psi[:min(n, 50_000)], dtype=np.float32)
-    Psi1 = Psi0  # can't compare pre/post cheaply here without extra memory
-    coh = 1.0
-    eng = float(np.mean(np.clip(np.array(E[:min(n, 50_000)], dtype=np.float32), 0.0, 1.5)))
-
     return {
         "engine": "python_loop",
         "oscillators": int(n),
-        "steps": int(min(steps, 10)),
+        "steps": int(steps),
         "elapsed_s": float(elapsed),
         "throughput_Bps": float(throughput_Bps),
-        "coherence_abs": float(coh),
-        "mean_energy": float(eng),
-        "note": "Python loop is capped (n<=200k, steps<=10) to keep the Space stable.",
+        "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).",
     }
 
+# ----------------------------
+# Numba engine (if available)
+# ----------------------------
 if NUMBA_OK:
     @nb.njit(fastmath=True)
     def _numba_kernel(Psi, E, L, scale):
@@ -199,76 +217,93 @@ if NUMBA_OK:
         sample = min(n, 200_000)
         Psi0 = Psi[:sample].copy()
 
-        # warmup compile
-        _numba_kernel(Psi[:min(n, 1024)], E[:min(n, 1024)], L[:min(n, 1024)], scale)
+        # 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()
 
-        Psi1 = Psi[:sample].copy()
         elapsed = t1 - t0
+        Psi1 = Psi[:sample].copy()
 
         items = int(n) * int(steps)
         throughput_Bps = (items / elapsed) / 1e9
 
-        coh = coherence_abs(Psi0, Psi1)
-        eng = mean_energy(E[:sample])
-
         return {
             "engine": "numba",
             "oscillators": int(n),
             "steps": int(steps),
             "elapsed_s": float(elapsed),
             "throughput_Bps": float(throughput_Bps),
-            "coherence_abs": float(coh),
-            "mean_energy": float(eng),
+            "coherence_abs": float(coherence_abs(Psi0, Psi1)),
+            "mean_energy": float(mean_energy(E[:sample])),
         }
 
 # ----------------------------
-# Run + Receipt wrapper
+# Runner + UI helpers
 # ----------------------------
-def run_and_receipt(n_oscillators, steps, seed, scale, include_baseline):
+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 for a public Space
-    # (Users can still push, but this avoids accidental hard-crashes.)
+    # Safety rails (prevents accidental crash / OOM on Space)
     n = max(100_000, min(n, 40_000_000))
     s = max(10, min(s, 5000))
 
-    # Decide engine: if numba is available, prefer it; else numpy
+    # primary engine
     if NUMBA_OK:
         primary = run_engine_numba(n, s, seed, scale)
     else:
         primary = run_engine_numpy(n, s, seed, scale)
 
+    # optional baselines
     baselines = {}
-    if include_baseline:
+    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)
 
-    # System metadata (honest)
-    meta = {
-        "timestamp_utc": dt.datetime.utcnow().isoformat() + "Z",
-        "app_version": APP_VERSION,
-        "space_runtime_note": "All measurements are performed on the Hugging Face Space runtime machine.",
-        "platform": platform.platform(),
-        "python": platform.python_version(),
-        "cpu_count_logical": os.cpu_count(),
-        "numba_available": bool(NUMBA_OK),
+    # build 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": seed,
-            "scale": scale,
-            "include_baselines": bool(include_baseline),
-        },
-        "definition": {
-            "item": "1 item = one per-oscillator coherent state update of [Psi, E, L] per step (as implemented in this Space)."
+            "seed": int(seed),
+            "scale": float(scale),
+            "include_baselines": bool(include_baselines),
         },
         "results": {
             "primary": primary,
@@ -276,64 +311,57 @@ def run_and_receipt(n_oscillators, steps, seed, scale, include_baseline):
         },
     }
 
-    receipt_path = write_receipt(meta)
-
-    # UI results (clean, human readable)
-    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(),
-        "Baselines Included": bool(include_baseline),
+    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,
     }
+    append_csv_row(csv_row, RESULTS_DIR / "runs.csv")
 
-    if include_baseline:
-        # add short baseline summary (no hype; facts only)
-        for k, v in baselines.items():
-            ui[f"Baseline: {k} (B/s)"] = f'{v["throughput_Bps"]:.3f}'
-            ui[f"Baseline: {k} Engine"] = v["engine"]
+    # 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"
 
     return ui, receipt_path
 
 # ----------------------------
-# UI (clean, simple, visual)
+# 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;
-}
+: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; }
 """
 
 with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
-<div id="titlebar">
-  <h1>Coherent Compute Engine</h1>
-</div>
+<div id="titlebar"><h1>Coherent Compute Engine</h1></div>
 
 **What this Space does**  
-It runs a real, on-machine benchmark of a coherent state-update engine and reports **measured throughput**, **stability**, and **energy behavior**. No precomputed results.
+Runs a real coherent state-update benchmark and reports measured throughput, stability proxy, and energy behavior. No precomputed results.
 
 **What an “item” is**  
 One coherent update of **[Ψ, E, L]** per oscillator per step.
 
 **Verification**  
-Every run generates a tamper-evident **receipt (JSON)** with a SHA-256 hash you can download.
+Every run generates a tamper-evident receipt (JSON) with a SHA-256 hash you can download.
         """
     )
 
@@ -350,28 +378,28 @@ Every run generates a tamper-evident **receipt (JSON)** with a SHA-256 hash you
                 )
                 seed_box = gr.Number(value=7, precision=0, label="Seed")
                 scale_box = gr.Number(value=1.0, precision=3, label="Scale (stability knob)")
-                include_baseline = gr.Checkbox(
+                include_baselines = gr.Checkbox(
                     value=False,
-                    label="Include baselines (numpy + tiny python loop)",
+                    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 (JSON download)")
+            receipt_file = gr.File(label="Receipt (download)")
 
     run_btn.click(
         fn=run_and_receipt,
-        inputs=[n_slider, steps_slider, seed_box, scale_box, include_baseline],
+        inputs=[n_slider, steps_slider, seed_box, scale_box, include_baselines],
         outputs=[results_json, receipt_file],
     )
 
     gr.Markdown(
         """
 **Notes**
-- This runs on the Hugging Face Space runtime machine. If you want numbers from your own hardware, run the same code locally.
-- If the Space is under load, throughput will vary. That’s normal; the receipt captures the environment at run time.
+- 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.
         """
     )