Update app.py

app.py

@@ -1,353 +1,168 @@
-# 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 json
 import time
-import math
+import json
 import hashlib
 import platform
-import datetime as dt
+import os
+from datetime import datetime
 
 import numpy as np
 import gradio as gr
 
-# ----------------------------
-# Optional Numba acceleration
-# ----------------------------
-NUMBA_OK = False
-try:
-    import numba as nb
-    NUMBA_OK = True
-except Exception:
-    nb = None
-    NUMBA_OK = False
-
 APP_TITLE = "Coherent Compute Engine"
-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.
+
+# -----------------------------
+# Core coherent update (NumPy)
+# -----------------------------
+def coherent_step(Psi, E, L):
     phase = 0.997 * Psi + 0.003 * E
     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
-
-
-if NUMBA_OK:
-    @nb.njit(fastmath=True, parallel=True)
-    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
+    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
+
+
+# -----------------------------
+# Metrics
+# -----------------------------
+def compute_coherence(a, b):
+    num = np.dot(a, b)
+    den = np.linalg.norm(a) * np.linalg.norm(b) + 1e-9
     return float(abs(num / den))
 
 
-def mean_energy(E):
-    return float(np.mean(np.clip(E, 0.0, 1.5)))
-
-
-# ----------------------------
-# 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 sha256_hex(data: bytes) -> str:
-    return hashlib.sha256(data).hexdigest()
-
-
-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)
-
-    h = sha256_hex(canon_json_bytes(payload_nohash))
-    payload["receipt_sha256"] = h
+# -----------------------------
+# Optional baseline (context only)
+# -----------------------------
+def python_loop_baseline(n, steps, cap=50_000):
+    n_cap = min(n, cap)
+    x = [0.5] * n_cap
+    t0 = time.time()
+    for _ in range(steps):
+        for i in range(n_cap):
+            x[i] = 0.999 * x[i] + 0.001
+    elapsed = time.time() - t0
+    items = n_cap * steps
+    return items / elapsed / 1e9
 
-    fname = f"receipt_{dt.datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%SZ')}_{h[:10]}.json"
-    path = os.path.join(OUT_DIR, fname)
 
-    with open(path, "wb") as f:
-        f.write(canon_json_bytes(payload))
+# -----------------------------
+# Main engine
+# -----------------------------
+def run_engine(n_osc, steps, include_baselines):
+    n = int(n_osc)
+    steps = int(steps)
 
-    return path, h
+    Psi = np.random.rand(n).astype(np.float32)
+    E   = np.random.rand(n).astype(np.float32)
+    L   = np.random.rand(n).astype(np.float32)
 
+    Psi_start = Psi[:200_000].copy()
 
-# ----------------------------
-# Baselines (optional, live)
-# ----------------------------
-def baseline_numpy(Psi, E, L, steps):
-    t0 = time.perf_counter()
+    t0 = time.time()
     for _ in range(steps):
-        Psi, E, L = _np_step(Psi, E, L)
-    t1 = time.perf_counter()
-    return (t1 - t0)
+        Psi, E, L = coherent_step(Psi, E, L)
+    elapsed = time.time() - t0
+
+    Psi_end = Psi[:200_000].copy()
 
+    coherence = compute_coherence(Psi_start, Psi_end)
+    mean_energy = float(np.mean(E))
 
-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
-    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
-
-    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)
-
-    engine = "numba" if NUMBA_OK else "numpy"
-
-    # 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):
-            Psi, E, L = _np_step(Psi, E, L)
-    t1 = time.perf_counter()
-
-    elapsed = float(t1 - t0)
-    items = int(n_oscillators) * int(steps)
-
-    thr_items_per_s = items / max(1e-12, elapsed)
-    thr_B_items_per_s = thr_items_per_s / 1e9
-
-    coh = coherence_abs_from_final(Psi)
-    eng = mean_energy(E)
-
-    # Metadata (keep it factual; no guessing)
-    cpu = platform.processor() or ""
-    cores = os.cpu_count() or 1
-    pyver = platform.python_version()
-    plat = platform.platform()
-
-    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}",
+    throughput_items = items / elapsed
+    throughput_b = throughput_items / 1e9
+
+    result = {
+        "Throughput (B items/s)": f"{throughput_b:.3f}",
+        "Throughput (items/s)": f"{int(throughput_items):,}",
+        "Coherence (|C|)": f"{coherence:.5f}",
+        "Mean Energy": f"{mean_energy:.5f}",
         "Elapsed Time (s)": f"{elapsed:.2f}",
-        "Oscillators": f"{n_oscillators:,}",
-        "Steps": f"{steps:,}",
-        "Engine": engine,
-        "CPU": cpu,
-        "Cores Available": int(cores),
+        "Oscillators": f"{n:,}",
+        "Steps": f"{steps}",
+        "Engine": "numpy",
+        "CPU": platform.processor(),
+        "Cores Available": os.cpu_count(),
     }
 
-    # Optional baselines (context only)
-    baseline_info = {}
+    # Context-only baselines
     if include_baselines:
-        # 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,
+        py_b = python_loop_baseline(n, steps)
+        np_b = throughput_b  # same engine, context label
+
+        result.update({
+            "Baseline: numpy (B items/s)": f"{np_b:.3f}",
+            "Baseline: python_loop (B items/s)": f"{py_b:.3f}",
+            "Speedup vs python_loop (x)": f"{(throughput_b / max(py_b,1e-9)):.1f}",
+            "Note": "Baselines are context-only; measured live and safety-capped."
+        })
+
+    # Receipt
+    receipt = {
+        "timestamp_utc": datetime.utcnow().isoformat() + "Z",
+        "results": result,
+        "platform": platform.platform(),
+        "python": platform.python_version(),
     }
 
-    receipt_path, receipt_sha = write_receipt(receipt_payload)
+    receipt_json = json.dumps(receipt, indent=2).encode()
+    sha = hashlib.sha256(receipt_json).hexdigest()
+    receipt["sha256"] = sha
 
-    # Trust KPI line + include hash in results
-    results["Receipt SHA-256 (in file)"] = receipt_sha
+    os.makedirs("receipts", exist_ok=True)
+    fname = f"receipts/receipt_{datetime.utcnow().strftime('%Y-%m-%dT%H-%M-%S')}.json"
+    with open(fname, "wb") as f:
+        f.write(json.dumps(receipt, indent=2).encode())
 
-    trust_badge = f"**Receipt verified:** SHA-256 generated from this run → `{receipt_sha}`"
+    result["Receipt SHA-256 (in file)"] = sha
 
-    # Pretty JSON for the UI
-    pretty = json.dumps(results, indent=2)
+    return json.dumps(result, indent=2), fname
 
-    return trust_badge, pretty, receipt_path
 
-
-# ----------------------------
+# -----------------------------
 # 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);}
-"""
+# -----------------------------
+with gr.Blocks(title=APP_TITLE) as demo:
+    gr.Markdown(
+        f"""
+# {APP_TITLE}
 
-with gr.Blocks(title=APP_TITLE, css=CUSTOM_CSS) as demo:
-    gr.Markdown(f"# {APP_TITLE}", elem_id="app-wrap")
+Everything you see below is computed **right now**, on this machine.
 
-    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"
+**What an “item” is**  
+• One coherent state update of **[Ψ, E, L]** per oscillator per step
+
+**What you get**  
+• Real throughput (items/sec)  
+• Stability proxy (|C|)  
+• Energy behaviour  
+• A downloadable **receipt with SHA-256** (verification-first)  
+• Optional baselines (**context only**, measured live)
+
+No precomputed results. No estimates. No GPUs required.
+"""
     )
 
-    with gr.Row():
-        n_slider = gr.Slider(
-            minimum=50_000,
-            maximum=25_000_000,
-            value=6_400_000,
-            step=50_000,
-            label="Number of Oscillators",
-        )
-        s_slider = gr.Slider(
-            minimum=25,
-            maximum=2000,
-            value=650,
-            step=1,
-            label="Simulation Steps",
-        )
-
-    include_baselines = gr.Checkbox(
-        value=True,
+    n_slider = gr.Slider(250_000, 8_000_000, value=6_400_000, step=250_000,
+                         label="Number of Oscillators")
+    steps_slider = gr.Slider(50, 1_000, value=650, step=25,
+                             label="Simulation Steps")
+
+    baseline_toggle = gr.Checkbox(
         label="Include baselines (context only)",
-        info="Baselines are measured live too. Python loop is safety-capped.",
+        value=True
     )
 
-    run_btn = gr.Button("Run Engine", variant="primary")
+    run_btn = gr.Button("Run Engine")
 
-    trust_md = gr.Markdown("", elem_classes=["kpi"])
-    results_box = gr.Code(label="Results", language="json")
+    output = gr.Code(label="Results", language="json")
     receipt_file = gr.File(label="Receipt (download)")
 
-    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, s_slider, include_baselines],
-        outputs=[trust_md, results_box, receipt_file],
+        inputs=[n_slider, steps_slider, baseline_toggle],
+        outputs=[output, receipt_file]
     )
 
-# Queue without version-fragile kwargs (Gradio 6 changed queue args)
-demo.queue()
 demo.launch()