fix: audioop compat for Python 3.13, plain-language UI

app.py

@@ -1,14 +1,14 @@
 import gradio as gr
 import torch
-import sys, os, json, time, hashlib
+import sys, os, time, hashlib
 
 sys.path.insert(0, "src")
 
 from mulattice.protocol import (
-    SynthCfg, build_model, force_fast_scan, logits_at, synth_batch, key_addresses
+    SynthCfg, build_model, force_fast_scan, logits_at, synth_batch
 )
 
-DEVICE = "cpu"  # HF free tier
+DEVICE = "cpu"
 CFG = SynthCfg()
 
 print("Loading model...", flush=True)
@@ -21,9 +21,7 @@ force_fast_scan(MODEL)
 print("Model loaded.", flush=True)
 
 
-# --- Section 1: Your own stream ---
 def run_custom(text, *pair_inputs):
-    """Store user's facts in user's text, overwrite some, query all."""
     seed = int(time.time()) % 100000
     pairs = []
     for i in range(0, len(pair_inputs), 3):
@@ -32,7 +30,7 @@ def run_custom(text, *pair_inputs):
             pairs.append({"name": name.strip(), "value": val.strip(),
                           "new_value": new_val.strip() if new_val.strip() else None})
     if not pairs:
-        return "Enter at least one fact (name and value).", ""
+        return "Enter at least one fact (a name and a value).", ""
 
     used = set()
     def h(s, span, off):
@@ -104,111 +102,116 @@ def run_custom(text, *pair_inputs):
 
     inv = {v: k for k, v in vmap.items()}
     correct = 0
-    lines = ["| Asked | Answered | Expected | Result |", "|---|---|---|---|"]
+    lines = ["| Asked | Answered | Expected | |", "|---|---|---|---|"]
     for q, r in enumerate(store_rows):
-        got = inv.get(int(pred[0, q]), f"?{int(pred[0,q])}")
+        got = inv.get(int(pred[0, q]), "?")
         exp = r["new_value"] if r["new_value"] else r["value"]
         ok = got == exp
         correct += ok
-        old = f" (was: {r['value']})" if r["new_value"] else ""
-        lines.append(f"| {r['name']} | **{got}** | {exp}{old} | {'✅' if ok else '❌'} |")
+        old = f" *(changed from: {r['value']})*" if r["new_value"] else ""
+        lines.append(f"| **{r['name']}** | **{got}** | {exp}{old} | {'✅' if ok else '❌'} |")
 
-    stats = f"\n\n**{correct}/{len(store_rows)} correct** · {L:,} tokens · {dt:.2f}s · {dt/L*1e6:.0f}μs/token"
+    stats = f"\n**{correct} out of {len(store_rows)} correct** — the model read {L:,} tokens in {dt:.2f} seconds ({dt/L*1e6:.0f} millionths of a second per token)"
     return "\n".join(lines), stats
 
 
-# --- Section 2: Scale test ---
-def run_scale(n_pairs, filler, overwrite):
+def run_scale(n_pairs, gap_words, pct_changed):
     g = torch.Generator().manual_seed(42)
     b = synth_batch(1, int(n_pairs), min(32, int(n_pairs)), CFG,
-                    filler=int(filler), overwrite_frac=float(overwrite)/100, generator=g)
+                    filler=int(gap_words), overwrite_frac=float(pct_changed)/100, generator=g)
     t0 = time.time()
     with torch.no_grad():
         pred = logits_at(MODEL, b["tokens"], b["ans_pos"]).argmax(-1).cpu()
     dt = time.time() - t0
     ok = (pred == b["gold"]).squeeze(0)
     n_cells = MODEL.blocks[0].mixer.scan.last_n_cells
-    return (f"Recall: **{ok.float().mean():.4f}** ({int(ok.sum())}/{ok.numel()})\n\n"
-            f"Tokens: {b['L']:,} · Cells: {n_cells:,} · Time: {dt:.2f}s · "
-            f"{dt/b['L']*1e6:.0f}μs/token")
-
-
-# --- Build UI ---
-with gr.Blocks(title="μLattice — Breaking the Quadratic Memory Barrier in AI",
-               theme=gr.themes.Default(font=["Inter", "sans-serif"])) as demo:
+    return (f"### **{ok.float().mean():.1%} correct** ({int(ok.sum())} out of {ok.numel()})\n\n"
+            f"The model read **{b['L']:,} words** in one pass and stored **{n_cells:,} memory slots**.\n\n"
+            f"Time: {dt:.2f} seconds — that's **{dt/b['L']*1e6:.0f}μs per word**, "
+            f"whether it stored {int(n_pairs)} facts or 8,000.")
+
+
+with gr.Blocks(
+    title="μLattice — AI Memory That Grows Without the Cost Growing",
+    theme=gr.themes.Soft(font=["Inter", "sans-serif"]),
+    css="""
+        .gradio-container {max-width: 900px !important; margin: auto !important;}
+        h1 {font-size: 2.2em !important; font-weight: 300 !important;}
+        h2 {color: #2547d0 !important; font-weight: 400 !important;}
+    """
+) as demo:
     gr.Markdown("""
     # μLattice
-    ## Breaking the quadratic memory barrier in AI
-    
+    ## AI memory that grows without the cost growing
+
     **Tensorbend Research · Eric E. · October 2026**
-    
-    A memory system for AI models that grows as it reads while the cost per token stays flat.
-    Store thousands of associations, overwrite any of them, and recall them all —
-    whether the memory holds ten facts or eight thousand.
-    
-    Each token reads and writes exactly **9 cells** on a 2D lattice. Memory grows with content.
-    Access cost doesn't.
+
+    Today's AI models pay more and more to remember more. μLattice fixes this:
+    memory grows as the model reads, but the cost of processing each word stays the same.
+
+    Every word the model reads touches exactly **9 memory slots** — whether the model
+    is storing 10 facts or 8,000. Try it below with your own facts.
     """)
 
-    with gr.Tab("📖 Your Own Facts"):
+    with gr.Tab("✏️ Try It With Your Own Facts"):
         gr.Markdown("""
-        **Paste any text below** (it becomes the stream the model reads).
-        **Define facts** as name → value pairs. Mark which get **overwritten** mid-stream.
-        The model stores, overwrites, and answers — in one pass through your text.
+        Type any text below — it becomes the words the model reads.
+        Then define facts as **name → value** pairs. If you fill in the
+        **"changed to"** field, the fact gets replaced mid-stream and the model
+        must remember the **new** value.
         """)
         with gr.Row():
-            with gr.Column():
-                doc = gr.Textbox(label="Your text (becomes the stream)", lines=5,
-                    value="The harbour was quiet that morning. Gulls circled the masts while the tide went out. A clerk stamped papers without looking up. Somewhere a bell rang twice, then stopped. The road east had been washed out again. Dust settled over the market stalls.")
+            with gr.Column(scale=1):
+                doc = gr.Textbox(
+                    label="Any text (the model reads this)",
+                    lines=5,
+                    value="The harbour was quiet that morning. Gulls circled the masts while the tide went out. A clerk stamped papers without looking up. Somewhere a bell rang twice, then stopped. The road east had been washed out again.")
+                gr.Markdown("**Your facts**")
                 with gr.Row():
-                    n1 = gr.Textbox(label="Fact name", value="the vault password")
-                    v1 = gr.Textbox(label="Value", value="swordfish")
-                    nv1 = gr.Textbox(label="New value (overwrite to)", value="bluedragon")
+                    n1 = gr.Textbox(label="Name", value="the vault password", scale=1)
+                    v1 = gr.Textbox(label="Value", value="swordfish", scale=1)
+                    nv1 = gr.Textbox(label="Changed to (optional)", value="bluedragon", scale=1)
                 with gr.Row():
-                    n2 = gr.Textbox(label="Fact name", value="the meeting time")
-                    v2 = gr.Textbox(label="Value", value="3pm")
-                    nv2 = gr.Textbox(label="New value", value="")
+                    n2 = gr.Textbox(label="Name", value="the meeting time", scale=1)
+                    v2 = gr.Textbox(label="Value", value="3pm", scale=1)
+                    nv2 = gr.Textbox(label="Changed to (optional)", value="", scale=1)
                 with gr.Row():
-                    n3 = gr.Textbox(label="Fact name", value="")
-                    v3 = gr.Textbox(label="Value", value="")
-                    nv3 = gr.Textbox(label="New value", value="")
-                btn1 = gr.Button("Read, store, overwrite — and answer", variant="primary")
-            with gr.Column():
+                    n3 = gr.Textbox(label="Name", value="", scale=1)
+                    v3 = gr.Textbox(label="Value", value="", scale=1)
+                    nv3 = gr.Textbox(label="Changed to (optional)", value="", scale=1)
+                btn1 = gr.Button("Store, overwrite, and recall", variant="primary", size="lg")
+            with gr.Column(scale=1):
                 out1 = gr.Markdown()
                 stats1 = gr.Markdown()
         btn1.click(run_custom, inputs=[doc, n1,v1,nv1, n2,v2,nv2, n3,v3,nv3], outputs=[out1, stats1])
 
-    with gr.Tab("📊 Store at Scale"):
+    with gr.Tab("🔬 Stress Test"):
         gr.Markdown("""
-        Test the model at scale: up to **8,192 stored pairs**, **50% overwritten**,
-        answered after a single causal pass.
+        Test the model at scale. Store hundreds or thousands of facts in one pass,
+        change some of them mid-stream, then ask for them all back.
         """)
         with gr.Row():
-            np_slider = gr.Slider(64, 8192, value=256, step=64, label="Pairs to store")
-            fl_slider = gr.Slider(0, 14, value=14, step=1, label="Filler tokens per pair")
-            ow_slider = gr.Slider(0, 100, value=50, step=10, label="% overwritten")
-        btn2 = gr.Button("Stream & query", variant="primary")
+            np_slider = gr.Slider(64, 2048, value=256, step=64,
+                label="How many facts to store")
+            gap_slider = gr.Slider(0, 14, value=8, step=1,
+                label="Words between each fact")
+            ow_slider = gr.Slider(0, 100, value=50, step=10,
+                label="% of facts changed mid-stream")
+        btn2 = gr.Button("Run the stress test", variant="primary", size="lg")
         out2 = gr.Markdown()
-        btn2.click(run_scale, inputs=[np_slider, fl_slider, ow_slider], outputs=[out2])
+        btn2.click(run_scale, inputs=[np_slider, gap_slider, ow_slider], outputs=[out2])
 
     gr.Markdown("""
     ---
-    
-    **Every number on this page is produced by a live forward pass** of the trained model
-    on the released checkpoint. Nothing is precomputed.
-    
-    [Paper](https://github.com/eelbaz/mLattice/blob/main/PAPER.md) ·
-    [Code](https://github.com/eelbaz/mLattice) ·
-    [Tests](https://github.com/eelbaz/mLattice/tree/main/tests)
-    
-    ```bibtex
-    @misc{mulattice2026,
-      title  = {μLattice: Breaking the Quadratic Memory Barrier in AI},
-      author = {Eric E. and Tensorbend Research},
-      year   = {2026},
-      url    = {github.com/eelbaz/mLattice}
-    }
-    ```
+
+    Every answer above is produced by a **live forward pass** of the trained model.
+    Nothing is precomputed or cached.
+
+    [📄 Full paper](https://github.com/eelbaz/mLattice/blob/main/PAPER.md) ·
+    [💻 Code & tests](https://github.com/eelbaz/mLattice) ·
+    [📊 All results](https://github.com/eelbaz/mLattice/tree/main/results)
+
+    *Tensorbend Research · Eric E. · October 2026*
     """)
 
 demo.launch()

requirements.txt

@@ -1,2 +1,4 @@
+audioop-lts
+pydub
 torch>=2.4
 numpy