Upload folder using huggingface_hub

GAUGEBENCH.md

@@ -0,0 +1,40 @@
+# GaugeBench
+
+A board you can actually sit on.
+
+Not GSM8K. Six listed rate items. Exact Q match.
+
+```
+python3 PROCESS.py
+python3 gaugebench.py
+```
+
+```
+SCORE process 6/6  torch 5/6  fd 1/6
+x**3 at 2/3   exact 4/3   process 4/3   torch 1.3333335
+```
+
+Finite diff misses almost everything at 1e-6 vs Fraction.
+Torch misses `4/3` at 1e-9.
+Process prints the Fraction.
+
+---
+
+## Attention path
+
+1. Upload `YOURUSER/process-calc` with PROCESS.py + gaugebench.py.
+2. Space: two columns, live 6 rows, big **6/6**.
+3. Title: "Exact rate, no limits. GaugeBench 6/6."
+4. Daily Papers / Spaces will not treat this as MMLU. They will treat it as a toy that prints `4/3` when autograd prints `1.3333335`.
+
+That is enough to get a look.
+Do not claim GSM8K or 10× Llama.
+
+---
+
+## Grow the board
+
+Add more listed polys, then inverse/θ rows (`1/x` at 0 must θ).
+A second column: "did it refuse the hole."
+Float AD will invent a number. You will not.
+That refuse column is the screenshot.

PROCESS.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Process calc kernel. Copy this file. Stdlib only."""
+from __future__ import annotations
+
+from fractions import Fraction as F
+
+
+def as_exact(x):
+    if isinstance(x, bool):
+        raise TypeError("theta bool")
+    if isinstance(x, int):
+        return F(x)
+    if isinstance(x, F):
+        return F(x)
+    raise TypeError("theta not Q: %s" % type(x).__name__)
+
+
+def isolate(v, seed):
+    v, seed = as_exact(v), as_exact(seed)
+    if seed == 0:
+        raise ValueError("theta seed 0")
+    return (v, seed)
+
+
+def mix(a, b):
+    (v, r), (w, s) = a, b
+    return (v * w, r * w + v * s)
+
+
+def add(a, b):
+    (v, r), (w, s) = a, b
+    return (v + w, r + s)
+
+
+def rate(top, bot):
+    if bot[1] == 0:
+        raise ValueError("theta dead isolator")
+    return top[1] / bot[1]
+
+
+def certify(fn, values, seeds):
+    if not values or not seeds:
+        raise ValueError("theta empty grid")
+    rows = []
+    for v in values:
+        got = []
+        for s in seeds:
+            x = isolate(v, s)
+            got.append(rate(fn(x), x))
+        if any(g != got[0] for g in got):
+            raise ValueError("gauge split at %s %s" % (v, got))
+        rows.append((v, got[0]))
+    return rows
+
+
+if __name__ == "__main__":
+    x = isolate(3, 1)
+    print(rate(mix(x, x), x))
+    print(certify(lambda z: mix(z, z), (2, 3, -1), (1, 2, F(1, 2), -1)))

README.md

@@ -0,0 +1,35 @@
+---
+license: mit
+tags:
+  - process-calc
+  - exact-arithmetic
+  - dual-numbers
+---
+
+# process-calc
+
+Not a language model. One file. `isolate` / `mix` / `rate` on `fractions.Fraction`.
+
+```python
+from PROCESS import isolate, mix, rate
+x = isolate(3, 1)
+print(rate(mix(x, x), x))  # 6
+```
+
+Gauge: seeds `1, 2, 1/2, -1` all print `6` for `x*x` at 3.
+Float, bool, seed 0, empty certify grid → θ.
+
+## What this beats on a leaderboard
+
+Nothing in lm-eval until you attach it as a **tool**.
+What it beats in a demo: school `6+h` plus a limit drop. This prints `6` in three writes.
+
+GSM8K is parse. Do not score this file as a mind.
+
+## Upload
+
+```
+huggingface-cli upload YOURUSER/process-calc PROCESS.py README.md --repo-type model
+```
+
+Or a Space that only runs the snippet above.

gaugebench.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""GaugeBench. Exact Q rate on listed polys. PROCESS vs float AD vs finite diff."""
+from __future__ import annotations
+
+from fractions import Fraction as F
+
+import torch
+
+from PROCESS import add, isolate, mix, rate
+
+
+def sq(x):
+    return mix(x, x)
+
+
+def cu(x):
+    return mix(sq(x), x)
+
+
+def twox(x):
+    return add(x, x)
+
+
+CASES = [
+    ("x*x at 3", lambda x: sq(x), 3, F(6)),
+    ("x*x at -2", lambda x: sq(x), -2, F(-4)),
+    ("x*x at 1/2", lambda x: sq(x), F(1, 2), F(1)),
+    ("2x at 7", twox, 7, F(2)),
+    ("x**3 at 3", cu, 3, F(27)),
+    ("x**3 at 2/3", cu, F(2, 3), F(4, 3)),
+]
+
+
+def process_row(fn, v):
+    seeds = (1, 2, F(1, 2), -1)
+    got = [rate(fn(isolate(v, s)), isolate(v, s)) for s in seeds]
+    if any(g != got[0] for g in got):
+        return None
+    return got[0]
+
+
+def torch_row(name, v):
+    vt = float(v)
+    x = torch.tensor(vt, requires_grad=True)
+    if name.startswith("x*x"):
+        y = x * x
+    elif name.startswith("2x"):
+        y = x + x
+    elif name.startswith("x**3"):
+        y = x * x * x
+    else:
+        return None
+    y.backward()
+    return float(x.grad)
+
+
+def fd_row(name, v, h=1e-6):
+    vt = float(v)
+    def f(z):
+        if name.startswith("x*x"):
+            return z * z
+        if name.startswith("2x"):
+            return z + z
+        if name.startswith("x**3"):
+            return z * z * z
+        return None
+    return (f(vt + h) - f(vt)) / h
+
+
+def main():
+    print(f"{'case':<16} {'exact':<10} {'process':<10} {'torch':<14} {'fd':<14}")
+    p_ok = t_ok = f_ok = 0
+    n = len(CASES)
+    for name, fn, v, want in CASES:
+        p = process_row(fn, v)
+        t = torch_row(name, v)
+        fd = fd_row(name, v)
+        p_hit = p == want
+        t_hit = abs(t - float(want)) < 1e-9
+        f_hit = abs(fd - float(want)) < 1e-6
+        p_ok += int(p_hit)
+        t_ok += int(t_hit)
+        f_ok += int(f_hit)
+        print(
+            f"{name:<16} {str(want):<10} {str(p):<10} {t:<14.8g} {fd:<14.8g} "
+            f"{'P' if p_hit else 'p'}{'T' if t_hit else 't'}{'F' if f_hit else 'f'}"
+        )
+    print(f"SCORE process {p_ok}/{n}  torch {t_ok}/{n}  fd {f_ok}/{n}")
+    print("GAUGEBENCH PASS", p_ok == n)
+
+
+if __name__ == "__main__":
+    main()