demos: standalone per-machine programs that put each machine to work

A new demos/ folder, one script per machine class, each self-contained and
cross-checked against an independent reference:

- neural_computer8: self-modifying Sieve of Eratosthenes (all 54 primes < 256),
Euclid's GCD via DIV/MUL/SUB, Collatz step counts.
- neural_rv32: pi by Machin's formula to nine digits; ternary neural nets run as
NEUR software (one learned by gradient descent, one XOR compiled by hand).
- neural_matrix8: 65,536 CPUs stepped in lockstep as one batched matrix product.
- neural_attractor: factoring semiprimes by running a multiplier backward, and
6-/8-queens by relaxing toward zero unsatisfied clauses.
- neural_subleq8io: the universal constructor fabricates a sibling byte-for-byte
and boots it.
- neural_reflect: self-modifying SUBLEQ on a stored machine on the interpreter.
- neural_reversible: bijective mixing, exact reversal, and the counterfactual.
- neural_ca: a Loschmidt echo and a reversible-automaton block cipher.
- neural_tile: self-assembly grows Pascal mod 2, verified against Lucas' theorem.

demos/README.md

@@ -0,0 +1,22 @@
+# demos
+
+Standalone programs that put each machine in the family to work on a named
+task. Every script is self-contained (`python demos/<name>.py`), loads the
+shipped weights, and cross-checks its result against an independent reference.
+
+| Demo | Machine | What it does |
+|------|---------|--------------|
+| `neural_computer8_self_modifying_sieve.py` | `neural_computer8` | Sieve of Eratosthenes; with no indexed addressing, the program rewrites the address bytes of its own LOAD/STORE. Finds all 54 primes < 256. |
+| `neural_computer8_euclid_gcd.py` | `neural_computer8` | Euclid's GCD, with `a mod b` built from the DIV/MUL/SUB opcodes and an XOR register swap. |
+| `neural_computer8_collatz.py` | `neural_computer8` | Collatz step counts; exact for every seed whose trajectory stays inside the 8-bit range. |
+| `neural_rv32_machin_pi.py` | `neural_rv32` | pi to nine digits by Machin's 1706 arctangent formula, printed to the console. |
+| `neural_rv32_neural_nets_via_neur.py` | `neural_rv32` | Ternary neural nets run as NEUR software: one learned by gradient descent, one (XOR) compiled by construction. |
+| `neural_matrix8_gpu_cpu_fleet.py` | `neural_matrix8` | 65,536 CPUs stepped in lockstep on the GPU as one batched matrix product. |
+| `neural_attractor_factoring.py` | `neural_attractor` | Factors semiprimes by relaxing an 8x8 multiplier's energy backward; also divides. |
+| `neural_attractor_nqueens.py` | `neural_attractor` | Solves 6- and 8-queens by relaxing toward zero unsatisfied clauses. |
+| `neural_subleq8io_universal_constructor.py` | `neural_subleq8io` | The universal constructor fabricates a sibling machine byte-for-byte, which then boots. |
+| `neural_reflect_self_modifying_stack.py` | `neural_reflect` | Self-modifying SUBLEQ code, on a stored machine, on the fixed interpreter: three levels in one tensor. |
+| `neural_reversible_counterfactual.py` | `neural_reversible` | Bijective mixing, exact reverse recovery, and the counterfactual when a digest bit is flipped. |
+| `neural_ca_loschmidt_echo.py` | `neural_ca` | A ~2,000-particle gas mixed 500 steps and un-mixed exactly; one flipped cell corrupts half the past. |
+| `neural_ca_reversible_cipher.py` | `neural_ca` | The reversible automaton as a block cipher: exact decryption with the right key, noise with a wrong one. |
+| `neural_tile_pascal_lucas.py` | `neural_tile` | Self-assembly grows Pascal's triangle mod 2; every cell verified against Lucas' theorem. |

demos/neural_attractor_factoring.py

@@ -0,0 +1,55 @@
+"""neural_attractor  --  factoring semiprimes by running a multiplier backward.
+
+An 8x8 array multiplier compiles to a quadratic energy that is 0 exactly on its
+truth table. Clamp the 16 product bits and relax the 16 input bits and the
+network settles into a factorization: multiplication run in reverse. Clamp one
+input as well and the same circuit performs division.
+
+    python demos/neural_attractor_factoring.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+from attractor import multiplier
+
+
+if __name__ == "__main__":
+    c, io = multiplier(8)
+    print("neural_attractor: factoring by energy relaxation")
+    print("=" * 56)
+    print(f"8x8 array multiplier as an energy landscape: {len(c.gates)} gate "
+          f"gadgets, {c.n} wires, 16 free input bits\n")
+
+    ladder = [(3599, 59, 61), (9797, 97, 101), (32399, 179, 181), (57599, 239, 241)]
+    for N, pa, pb in ladder:
+        target = {io["prod"][k]: (N >> k) & 1 for k in range(16)}
+        t0, got = time.perf_counter(), None
+        for attempt in range(1, 8):
+            s = c.solve(io["xs"] + io["ys"], {io["zero"]: 0}, target,
+                        sweeps=2500, restarts=12, seed=N * 7 + attempt)
+            if s is not None:
+                x = sum(s[io["xs"][k]] << k for k in range(8))
+                y = sum(s[io["ys"][k]] << k for k in range(8))
+                if x * y == N and x > 1 and y > 1:
+                    got = (x, y, attempt); break
+        dt = time.perf_counter() - t0
+        if got:
+            x, y, att = got
+            tag = "the prime pair" if {x, y} == {pa, pb} else "valid factorization"
+            print(f"  {N:5d} = {x:3d} x {y:3d}   ({dt:4.1f}s, attempt {att})  [{tag}]")
+        else:
+            print(f"  {N:5d}: ground state not reached in budget ({dt:.1f}s)")
+
+    # division: clamp one input and the product, relax the other input
+    N, xa = 57599, 241
+    fixed = {io["zero"]: 0}
+    for k in range(8):
+        fixed[io["xs"][k]] = (xa >> k) & 1
+    target = {io["prod"][k]: (N >> k) & 1 for k in range(16)}
+    t0 = time.perf_counter()
+    s = c.solve(io["ys"], fixed, target, sweeps=800, restarts=10, seed=7)
+    if s is not None:
+        y = sum(s[io["ys"][k]] << k for k in range(8))
+        print(f"\n  division mode: clamp x=241 and the product -> y = {y} "
+              f"({time.perf_counter()-t0:.1f}s; {xa} x {y} = {xa * y})")

demos/neural_attractor_nqueens.py

@@ -0,0 +1,90 @@
+"""neural_attractor  --  the N-queens problem solved by energy relaxation.
+
+The attractor computer has no clock and no program counter: a circuit compiles
+to a quadratic energy whose global minimum is its consistent assignment, and
+"running" it is rolling downhill. Here every N-queens constraint (one queen per
+row, no two sharing a column or diagonal) becomes a clause wire that must be 1;
+the annealer relaxes the board variables toward zero unsatisfied clauses. This
+is the min-conflicts / MAX-SAT objective, expressed entirely in the family's
+Heaviside threshold gadgets.
+
+    python demos/neural_attractor_nqueens.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+from attractor import Circuit
+
+
+def queens_circuit(N):
+    """Build the N-queens CNF as a threshold circuit; return every clause wire
+    so the solver can drive them all to 1 (a graded, per-clause objective)."""
+    c = Circuit()
+    v = {(r, col): c.wire() for r in range(N) for col in range(N)}
+    clauses = []
+
+    def OR_lits(lits):
+        acc = lits[0]
+        for w in lits[1:]:
+            acc = c.OR(acc, w)
+        return acc
+
+    for r in range(N):                                   # each row: >= 1 queen
+        clauses.append(OR_lits([v[(r, col)] for col in range(N)]))
+        for c1 in range(N):                              # each row: <= 1 queen
+            for c2 in range(c1 + 1, N):
+                clauses.append(OR_lits([c.NOT(v[(r, c1)]), c.NOT(v[(r, c2)])]))
+    for col in range(N):                                 # each column: <= 1
+        for r1 in range(N):
+            for r2 in range(r1 + 1, N):
+                clauses.append(OR_lits([c.NOT(v[(r1, col)]), c.NOT(v[(r2, col)])]))
+    cells = [(r, col) for r in range(N) for col in range(N)]
+    for i in range(len(cells)):                          # each diagonal: <= 1
+        for j in range(i + 1, len(cells)):
+            (r1, c1), (r2, c2) = cells[i], cells[j]
+            if r1 - c1 == r2 - c2 or r1 + c1 == r2 + c2:
+                clauses.append(OR_lits([c.NOT(v[(r1, c1)]), c.NOT(v[(r2, c2)])]))
+    return c, v, clauses
+
+
+def valid(board, N):
+    qs = [rc for rc, b in board.items() if b]
+    if len(qs) != N:
+        return False
+    for i in range(len(qs)):
+        for j in range(i + 1, len(qs)):
+            (r1, c1), (r2, c2) = qs[i], qs[j]
+            if r1 == r2 or c1 == c2 or abs(r1 - r2) == abs(c1 - c2):
+                return False
+    return True
+
+
+def solve_board(N, seeds=8):
+    c, v, clauses = queens_circuit(N)
+    free = list(v.values())
+    target = {w: 1 for w in clauses}
+    t0 = time.perf_counter()
+    for seed in range(seeds):
+        s = c.solve(free, {}, target, sweeps=6000, restarts=6, seed=seed)
+        if s is not None:
+            board = {rc: s[w] for rc, w in v.items()}
+            if valid(board, N):
+                return board, len(clauses), c.n, time.perf_counter() - t0
+    return None, len(clauses), c.n, time.perf_counter() - t0
+
+
+if __name__ == "__main__":
+    print("neural_attractor: N-queens as energy relaxation")
+    print("=" * 56)
+    for N in (6, 8):
+        board, nclauses, nwires, dt = solve_board(N)
+        status = "SOLVED" if board else "no solution reached in budget"
+        print(f"\n{N}-queens: {nclauses} clause gadgets over {nwires} wires -> "
+              f"{status} ({dt:.1f}s)")
+        if board:
+            for r in range(N):
+                print("   " + " ".join("Q" if board[(r, col)] else "." for col in range(N)))
+            print(f"   verified: {N} queens, no shared row/column/diagonal")
+    print("\nNo search loop was written: the constraints are an energy surface and")
+    print("the solution is its floor. The queens fall into place.")

demos/neural_ca_loschmidt_echo.py

@@ -0,0 +1,55 @@
+"""neural_ca  --  a Loschmidt echo in a reversible cellular automaton.
+
+The Margolus block rule is a bijection, so a gas of ~2,000 particles mixed for
+500 steps can be un-mixed by iterating the same rule backward: the initial
+configuration returns cell-for-cell (particle number conserved throughout). Yet
+flipping a single cell of the mixed state before reversing corrupts roughly half
+the reconstructed past -- exact reversibility and sensitive dependence in the
+same automaton.
+
+    python demos/neural_ca_loschmidt_echo.py
+"""
+import os, sys, time, random, statistics
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+import ca
+
+
+def coarse(g, H, W, k=8):
+    out = []
+    for by in range(0, H, k):
+        for bx in range(0, W, k):
+            out.append(sum(g[y][x] for y in range(by, by + k) for x in range(bx, bx + k)))
+    return out
+
+
+if __name__ == "__main__":
+    H = W = 64
+    rng = random.Random(2026)
+    grid = [[1 if rng.random() < 0.5 else 0 for _ in range(W)] for _ in range(H)]
+    n0 = sum(map(sum, grid))
+    STEPS = 500
+
+    print("neural_ca: Loschmidt echo (mix, then run time backward)")
+    print("=" * 56)
+    t0 = time.perf_counter()
+    fwd = ca.run(grid, STEPS, 0)
+    n1 = sum(map(sum, fwd))
+    back = ca.run_back(fwd, STEPS, 0)
+    echo = back == grid
+    dt = time.perf_counter() - t0
+
+    print(f"particles: {n0} at t=0, {n1} at t={STEPS} "
+          f"({'conserved' if n0 == n1 else 'NOT CONSERVED'})")
+    print(f"coarse 8x8 occupancy stdev: t=0 {statistics.pstdev(coarse(grid, H, W)):.2f} "
+          f"-> t={STEPS} {statistics.pstdev(coarse(fwd, H, W)):.2f} (mixed)")
+    print(f"{STEPS} steps forward + {STEPS} reversed in {dt:.1f}s: "
+          f"t=0 recovered {'EXACTLY' if echo else 'FAILED'}")
+
+    flip = [row[:] for row in fwd]
+    flip[0][0] ^= 1
+    back2 = ca.run_back(flip, STEPS, 0)
+    ham = sum(back2[y][x] != grid[y][x] for y in range(H) for x in range(W))
+    print(f"butterfly: flip ONE cell at t={STEPS}, reverse again -> reconstructed "
+          f"past wrong in {ham}/{H * W} cells")

demos/neural_ca_reversible_cipher.py

@@ -0,0 +1,84 @@
+"""neural_ca  --  a reversible cellular automaton as a perfect cipher.
+
+The Margolus block rule is a bijection of the lattice, so iterating it forward
+diffuses a bitmap into noise and iterating the exact same rule backward restores
+it bit-for-bit. That makes the automaton a block cipher whose key is the pair
+(number of steps, starting partition phase): the right key inverts the diffusion
+perfectly, and a key off by a single step returns noise. No information is ever
+destroyed, so decryption is exact rather than approximate.
+
+    python demos/neural_ca_reversible_cipher.py
+"""
+import os, sys
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+import ca
+
+# a recognizable plaintext bitmap (a heart), padded into a larger lattice
+ART = [
+    "  ###   ###  ",
+    " ##### ##### ",
+    "#############",
+    "#############",
+    "#############",
+    " ########### ",
+    "  #########  ",
+    "   #######   ",
+    "    #####    ",
+    "     ###     ",
+    "      #      ",
+]
+PAD_X, PAD_Y = 6, 4
+
+
+def make_grid():
+    # the Margolus partition tiles 2x2 blocks toroidally, so H and W must be even
+    h = len(ART) + 2 * PAD_Y
+    w = len(ART[0]) + 2 * PAD_X
+    h += h & 1
+    w += w & 1
+    g = [[0] * w for _ in range(h)]
+    for y, row in enumerate(ART):
+        for x, ch in enumerate(row):
+            if ch == "#":
+                g[y + PAD_Y][x + PAD_X] = 1
+    return g
+
+
+def render(g):
+    return "\n".join("".join("#" if c else "." for c in row) for row in g)
+
+
+def hamming(a, b):
+    return sum(a[y][x] != b[y][x] for y in range(len(a)) for x in range(len(a[0])))
+
+
+if __name__ == "__main__":
+    plain = make_grid()
+    KEY_STEPS, KEY_PHASE = 200, 0
+
+    cipher = ca.run(plain, KEY_STEPS, KEY_PHASE)
+    recovered = ca.run_back(cipher, KEY_STEPS, KEY_PHASE)
+    wrong = ca.run_back(cipher, KEY_STEPS - 1, KEY_PHASE)   # key off by one step
+
+    n = sum(map(sum, plain))
+    print("neural_ca: reversible-automaton cipher")
+    print("=" * 46)
+    print(f"key = ({KEY_STEPS} steps, phase {KEY_PHASE}); {n} set bits (conserved "
+          f"throughout: {sum(map(sum, cipher)) == n})\n")
+
+    print("PLAINTEXT:")
+    print(render(plain))
+    print(f"\nCIPHERTEXT after {KEY_STEPS} forward steps (diffused to noise):")
+    print(render(cipher))
+    print(f"\nDECRYPTED with the correct key:")
+    print(render(recovered))
+    print(f"  exact recovery: {recovered == plain}  (Hamming distance 0)")
+    print(f"\nDECRYPTED with a wrong key (off by one step):")
+    print(render(wrong))
+    print(f"  still scrambled: {hamming(wrong, plain)} of {len(plain)*len(plain[0])} "
+          f"cells differ from the plaintext")
+    print("\nEvery step is a bijection, so the ciphertext holds exactly the")
+    print("information of the plaintext -- no more, no less. Only the exact")
+    print("reverse trajectory recovers it.")

demos/neural_computer8_collatz.py

@@ -0,0 +1,76 @@
+"""neural_computer8  --  the Collatz map iterated on the threshold CPU.
+
+n -> n/2 if even, 3n+1 if odd, counting steps to 1. The parity test is a
+bitwise AND with 1 that leaves the flags untouched, so the loop branches on the
+comparison that precedes it. The register file is architecturally 8-bit, so the
+machine computes the Collatz trajectory modulo 256; for seeds whose true
+trajectory never exceeds 255, that is the exact Collatz step count, checked here
+against a native reference.
+
+    python demos/neural_computer8_collatz.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+sys.path.insert(0, os.path.join(REPO, "tools"))
+from safetensors import safe_open
+from cpu_programs import Asm
+from eval_all import GenericThresholdCPU, get_manifest
+
+
+def build(n0):
+    a = Asm(1024)
+    a.load(0, "N"); a.load(1, "ONE"); a.xor(2, 2)   # R0=n, R1=1, R2=steps
+    a.label("loop")
+    a.cmp(0, 1); a.jz("done")            # n == 1 ?
+    a.xor(3, 3); a.add(3, 0); a.and_(3, 1)   # R3 = n & 1  (flags preserved)
+    a.cmp(3, 1); a.jz("odd")
+    a.shr(0); a.jmp("step")              # even: n >>= 1
+    a.label("odd")
+    a.xor(3, 3); a.add(3, 0); a.shl(3)   # R3 = 2n
+    a.add(0, 3); a.add(0, 1)             # n = 3n + 1
+    a.label("step")
+    a.add(2, 1); a.jmp("loop")           # steps++
+    a.label("done")
+    a.store(2, "RES"); a.halt()
+    a.org(0x300); a.label("N"); a.db(n0)
+    a.label("ONE"); a.db(1); a.label("RES"); a.db(0)
+    return a, a.assemble()
+
+
+def true_collatz(n):
+    peak, steps = n, 0
+    while n != 1:
+        n = n // 2 if n % 2 == 0 else 3 * n + 1
+        peak = max(peak, n); steps += 1
+    return steps, peak
+
+
+if __name__ == "__main__":
+    tens = {}
+    with safe_open(os.path.join(REPO, "variants", "neural_computer8_small.safetensors"),
+                   framework="pt") as f:
+        for name in f.keys():
+            tens[name] = f.get_tensor(name).float()
+    cpu = GenericThresholdCPU(tens)
+    addr = get_manifest(tens)["addr_bits"]
+
+    print("neural_computer8: Collatz step counts through the gates")
+    print("=" * 56)
+    print("  seed   CPU steps   true steps   peak   in 8-bit range?")
+    for n0 in (6, 7, 9, 18, 25, 45):
+        a, mem = build(n0)
+        state = {"pc": 0, "regs": [0] * 4, "flags": [0] * 4, "mem": list(mem),
+                 "halted": False, "sp": (1 << addr) - 1}
+        t0 = time.perf_counter()
+        final, cycles = cpu.run(state, max_cycles=3000)
+        steps = final["mem"][a.labels["RES"]]
+        tsteps, peak = true_collatz(n0)
+        inrange = peak <= 255
+        match = "MATCH" if (inrange and steps == tsteps) else \
+                ("mod-256" if not inrange else "MISMATCH")
+        print(f"  {n0:4d}   {steps:9d}   {tsteps:10d}   {peak:4d}   "
+              f"{'yes' if inrange else 'no (wraps)':10s} [{match}]")
+    print("\n  For every seed whose trajectory stays under 256 the threshold CPU")
+    print("  reproduces the exact Collatz step count.")

demos/neural_computer8_euclid_gcd.py

@@ -0,0 +1,63 @@
+"""neural_computer8  --  Euclid's algorithm on the threshold CPU.
+
+The greatest common divisor by repeated remainder, where the remainder itself
+is synthesized from the machine's own opcodes: a mod b = a - (a / b) * b, using
+the DIV, MUL and SUB gates, and the register swap is three XORs (no temporary).
+Every step runs through threshold neurons.
+
+    python demos/neural_computer8_euclid_gcd.py
+"""
+import os, sys, time, math
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+sys.path.insert(0, os.path.join(REPO, "tools"))
+from safetensors import safe_open
+from cpu_programs import Asm
+from eval_all import GenericThresholdCPU, get_manifest
+
+
+def build(a0, b0):
+    g = Asm(1024)
+    g.load(0, "A")            # R0 = a
+    g.load(1, "B")            # R1 = b
+    g.xor(3, 3)               # R3 = 0
+    g.label("loop")
+    g.cmp(1, 3); g.jz("done")  # while b != 0
+    g.xor(2, 2); g.add(2, 0)   # R2 = a
+    g._alu(0x8, 2, 1)          # R2 = a / b     (DIV opcode)
+    g.mul(2, 1)                # R2 = (a/b)*b
+    g.sub(0, 2)                # R0 = a mod b
+    g.xor(0, 1); g.xor(1, 0); g.xor(0, 1)   # swap -> (b, a mod b)
+    g.jmp("loop")
+    g.label("done")
+    g.store(0, "RES"); g.halt()
+    g.org(0x300)
+    g.label("A"); g.db(a0)
+    g.label("B"); g.db(b0)
+    g.label("RES"); g.db(0)
+    return g, g.assemble()
+
+
+if __name__ == "__main__":
+    tens = {}
+    with safe_open(os.path.join(REPO, "variants", "neural_computer8_small.safetensors"),
+                   framework="pt") as f:
+        for name in f.keys():
+            tens[name] = f.get_tensor(name).float()
+    cpu = GenericThresholdCPU(tens)
+    addr = get_manifest(tens)["addr_bits"]
+
+    print("neural_computer8: Euclid's GCD through the gates")
+    print("=" * 56)
+    for a0, b0 in [(84, 36), (120, 90), (221, 34), (255, 128)]:
+        g, mem = build(a0, b0)
+        state = {"pc": 0, "regs": [0] * 4, "flags": [0] * 4, "mem": list(mem),
+                 "halted": False, "sp": (1 << addr) - 1}
+        t0 = time.perf_counter()
+        final, cycles = cpu.run(state, max_cycles=400)
+        res = final["mem"][g.labels["RES"]]
+        ok = res == math.gcd(a0, b0)
+        print(f"  gcd({a0:3d}, {b0:3d}) = {res:3d}   ({cycles:3d} cycles, "
+              f"{time.perf_counter()-t0:.1f}s)   "
+              f"[{'MATCH' if ok else 'MISMATCH vs ' + str(math.gcd(a0, b0))}]")

demos/neural_computer8_self_modifying_sieve.py

@@ -0,0 +1,76 @@
+"""neural_computer8  --  the Sieve of Eratosthenes with self-modifying code.
+
+The threshold CPU's ISA has no indexed addressing, so the program does exactly
+what memory-constrained 1970s code did: it rewrites the address bytes of its own
+LOAD and STORE instructions before each access, walking a pointer across the
+flags array. Every gate that fetches, decodes, marks, and patches is a threshold
+neuron. It halts with all 54 primes below 256 marked.
+
+    python demos/neural_computer8_self_modifying_sieve.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+sys.path.insert(0, os.path.join(REPO, "tools"))
+from safetensors import safe_open
+from cpu_programs import Asm, _enc
+from eval_all import GenericThresholdCPU, get_manifest
+
+FLAGS = 0x300                       # flags[0..255] at 0x300..0x3FF
+
+
+def build():
+    g = Asm(1024)
+    g.load(3, "ONE")                    # R3 = 1 (mark value / increment)
+    g.load(0, "TWO")                    # R0 = p = 2
+    g.label("outer")
+    g.store(0, "Rlo")                   # patch probe address low byte <- p
+    g.dw(_enc(0xA, 2, 0))               # probe: R2 = flags[p]  (self-modified)
+    g.db(FLAGS >> 8); g.label("Rlo"); g.db(0x00)
+    g.cmp(2, 3); g.jz("next_p")         # flags[p] == 1 -> composite, skip
+    g.xor(1, 1); g.add(1, 0); g.add(1, 0)   # m = 2p
+    g.label("inner")
+    g.store(1, "Wlo")                   # patch mark address low byte <- m
+    g.dw(_enc(0xB, 0, 3))               # mark: flags[m] = R3 = 1  (self-modified)
+    g.db(FLAGS >> 8); g.label("Wlo"); g.db(0x00)
+    g.add(1, 0)                         # m += p  (carry iff we passed 255)
+    g.jnc("inner")
+    g.label("next_p")
+    g.add(0, 3)                         # p += 1
+    g.load(2, "SIXTEEN")
+    g.cmp(0, 2)
+    g.jnz("outer")                      # loop until p == 16 (16^2 > 255)
+    g.halt()
+    g.org(0x200)
+    g.label("ONE"); g.db(1)
+    g.label("TWO"); g.db(2)
+    g.label("SIXTEEN"); g.db(16)
+    return g, g.assemble()
+
+
+if __name__ == "__main__":
+    g, mem = build()
+    tens = {}
+    with safe_open(os.path.join(REPO, "variants", "neural_computer8_small.safetensors"),
+                   framework="pt") as f:
+        for name in f.keys():
+            tens[name] = f.get_tensor(name).float()
+    cpu = GenericThresholdCPU(tens)
+    state = {"pc": 0, "regs": [0] * 4, "flags": [0] * 4, "mem": list(mem),
+             "halted": False, "sp": (1 << get_manifest(tens)["addr_bits"]) - 1}
+    t0 = time.perf_counter()
+    final, cycles = cpu.run(state, max_cycles=4000)
+    dt = time.perf_counter() - t0
+
+    got = [n for n in range(2, 256) if final["mem"][FLAGS + n] == 0]
+    ref = [n for n in range(2, 256) if all(n % d for d in range(2, int(n**0.5) + 1))]
+    print("neural_computer8: self-modifying Sieve of Eratosthenes")
+    print("=" * 56)
+    print(f"halted={final['halted']}  {cycles} cycles through the gates ({dt:.0f}s)")
+    print(f"primes < 256 found: {len(got)}   native sieve: {len(ref)}   "
+          f"{'EXACT MATCH' if got == ref else 'MISMATCH'}")
+    print("  " + " ".join(map(str, got)))
+    print(f"self-modified operand bytes at halt: probe={final['mem'][g.labels['Rlo']]}, "
+          f"mark={final['mem'][g.labels['Wlo']]} (the program rewrote its own "
+          f"instruction stream as it ran)")

demos/neural_matrix8_gpu_cpu_fleet.py

@@ -0,0 +1,73 @@
+"""neural_matrix8  --  a fleet of processors as one batched matrix product.
+
+The whole CPU is compiled to 108 ternary weight matrices with a Heaviside step
+between them, so one clock cycle is one matrix-vector product plus a threshold.
+Add a batch dimension and N processors are the same 108 matmuls: here 65,536
+independent CPUs step in lockstep on the GPU. A 256-wide correctness fleet
+confirms every CPU halts exactly at cycle 2n+1 for its own countdown input.
+
+    python demos/neural_matrix8_gpu_cpu_fleet.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+import torch
+from matrix8 import MatrixMachine, state_to_vec, _mk_state, _instr
+
+
+def prog_bytes():
+    return (_instr(0x1, 0, 1)        # SUB R0, R1
+            + _instr(0xD, 0, 0, 1) + [0, 0]   # JNZ 0x0000 (address word)
+            + _instr(0xF)            # HALT
+            + [0] * 8)
+
+
+if __name__ == "__main__":
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    mm = MatrixMachine.from_file(device=dev)
+    n_neurons = sum(int(b.numel()) for b in mm.B)
+    name = torch.cuda.get_device_name(0) if dev == "cuda" else "cpu"
+    print("neural_matrix8: 65,536 CPUs as one batched matrix product")
+    print("=" * 56)
+    print(f"loaded {len(mm.W)} ternary matrices, {n_neurons:,} threshold neurons "
+          f"per transition, device={dev} ({name})")
+    mem = prog_bytes()
+
+    # correctness fleet: one CPU per 8-bit input, all 256 at once
+    V = torch.stack([state_to_vec(_mk_state(mem=mem, regs=(x, 1, 0, 0)))
+                     for x in range(256)]).to(dev)
+    first_halt = torch.full((256,), -1, dtype=torch.long)
+    step = 0
+    while step < 600:
+        halted = V[:, MatrixMachine.HALT_IDX] > 0.5
+        first_halt[(first_halt < 0) & halted.cpu()] = step
+        if bool(halted.all()):
+            break
+        V = mm.step(V); step += 1
+    expect = torch.tensor([2 * (x if x else 256) + 1 for x in range(256)])
+    ok_halt = bool((first_halt == expect).all())
+    ok_r0 = bool((V[:, 4:12].cpu().long().sum(1) == 0).all())
+    print(f"\ncorrectness fleet of 256: every CPU halts at cycle 2n+1 for its own "
+          f"input: {'EXACT' if ok_halt else 'MISMATCH'}; all results R0==0: {ok_r0}")
+
+    # throughput fleet: 65,536 CPUs
+    B = 65536
+    V = torch.stack([state_to_vec(_mk_state(mem=mem, regs=(x & 0xFF, 1, 0, 0)))
+                     for x in range(256)]).repeat(256, 1).to(dev)
+    if dev == "cuda":
+        torch.cuda.synchronize()
+    t0, steps = time.perf_counter(), 0
+    while steps < 520:
+        V = mm.step(V); steps += 1
+        if steps % 64 == 0 and bool((V[:, MatrixMachine.HALT_IDX] > 0.5).all()):
+            break
+    if dev == "cuda":
+        torch.cuda.synchronize()
+    dt = time.perf_counter() - t0
+    instr = B * steps
+    print(f"\nthroughput fleet of {B:,}: {steps} transitions in {dt:.1f}s")
+    print(f"  {instr / dt / 1e6:,.1f} million instructions/s aggregate "
+          f"({instr:,} instructions retired)")
+    print(f"  {instr * n_neurons / dt / 1e9:,.1f} billion threshold-neuron "
+          f"evaluations/s")

demos/neural_reflect_self_modifying_stack.py

@@ -0,0 +1,87 @@
+"""neural_reflect  --  three levels of machine in one tensor.
+
+Level 0 is U, a fixed ternary threshold interpreter (~24k gates). Level 1 is a
+complete SUBLEQ computer stored as data inside U's writable state. Level 2 is a
+SUBLEQ program that rewrites its own operand bytes as it runs: a zeroing
+instruction that walks itself across memory, erasing a block. The interpreter,
+the machine it runs, and the program that machine executes are all the same
+tensor; the final memory is checked bit-for-bit against a native SUBLEQ emulator.
+
+    python demos/neural_reflect_self_modifying_stack.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+import torch
+from reflect import (Cfg, build_subleq_machine, build_net, Leveled,
+                     encode_netlist, state_to_vec, subleq32_step, MEM, MEMB)
+
+
+if __name__ == "__main__":
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    cfg = Cfg(A=14, G=296, banks=1, self_mod=False)
+    prog, lay = build_subleq_machine(cfg)
+    inet, ii, io = build_net(cfg)
+    print("neural_reflect: self-modifying code on a stored machine on U")
+    print("=" * 60)
+    print(f"level 0: interpreter U = {len(inet.gates):,} threshold gates (fixed)")
+    print(f"level 1: a SUBLEQ machine = {len(prog)} gates, stored as writable data")
+    lev = Leveled(inet, ii, io, device=dev)
+    nl = encode_netlist(cfg, prog)
+    sig0 = [0] * cfg.S
+    sig0[cfg.NET0:cfg.NET0 + len(nl)] = nl
+    base = state_to_vec(cfg, {"sig": sig0, "gp": 0, "halt": 0}).to(dev)
+    PC = lay["PC"]
+
+    # level 2: SUBLEQ (A B C: M[B]-=M[A]; if <=0 goto C). The first instruction
+    # zeroes a target cell, then two instructions increment its own A and B
+    # operand bytes, so the zeroing walks across a data block.
+    pm = [0] * 32
+    pm[0:3]   = [24, 24, 3]      # zero M[<target>]; these operands get rewritten
+    pm[3:6]   = [19, 0, 6]       # M[0] += 1  (patch own A-field: cell 0)
+    pm[6:9]   = [19, 1, 9]       # M[1] += 1  (patch own B-field: cell 1)
+    pm[9:12]  = [20, 21, 15]     # count -= 1; if <= 0 branch to epilogue
+    pm[12:15] = [18, 18, 0]      # 0 -> unconditional jump to loop head
+    pm[15:18] = [18, 18, 31]     # epilogue: branch to 31 = HALT
+    pm[18], pm[19], pm[20], pm[21] = 0, 255, 1, 4
+    pm[24:28] = [7, 99, 123, 200]          # the block the program will erase
+    print(f"level 2: a program whose instruction 0 starts as [24,24,3] and "
+          f"rewrites its own operands")
+
+    ref_mem, ref_pc = list(pm), 0
+    while ref_pc != 31:
+        ref_mem, ref_pc = subleq32_step(ref_mem, ref_pc)
+
+    V = base.unsqueeze(0).clone()
+    for i in range(32):
+        for b in range(8):
+            V[:, MEM + b * MEMB + i] = float((pm[i] >> b) & 1)
+
+    def get_mem(Vc):
+        return sum(Vc[:, MEM + b * MEMB: MEM + b * MEMB + 32].long() << b
+                   for b in range(8))[0].tolist()
+
+    t0, walk, steps, halted = time.perf_counter(), [], 0, False
+    for _ in range(26):
+        m_now = get_mem(V.cpu())
+        walk.append((m_now[0], m_now[1]))
+        for _ in range(cfg.G):
+            V = lev.step(V)
+        steps += 1
+        if int(V[0, cfg.S + cfg.GPW]) == 1:
+            halted = True
+            break
+    dt = time.perf_counter() - t0
+    got = get_mem(V.cpu())
+
+    mut = " -> ".join(f"[{a},{b}]" for a, b in
+                      [walk[0]] + [w for i, w in enumerate(walk[1:], 1) if w != walk[i - 1]])
+    print(f"\nran {steps} hosted instructions in {dt:.0f}s "
+          f"({steps * cfg.G} interpreter recurrences); halted={halted}")
+    print(f"  instruction 0's operand cells as it ran: {mut}")
+    print(f"  target block M[24..27]: {pm[24:28]} -> {got[24:28]}")
+    print(f"  final memory == native SUBLEQ reference: "
+          f"{'EXACT' if got == ref_mem else 'MISMATCH'}")
+    print("\n  The program, the machine it runs on, and the machine that runs")
+    print("  that machine are all the same tensor.")

demos/neural_reversible_counterfactual.py

@@ -0,0 +1,49 @@
+"""neural_reversible  --  computation with no erasure, and the counterfactual.
+
+Every instruction of this register machine is a bijection, so the same weights
+run backward invert the forward computation: a mixing program hashes a seed into
+a digest, and stepping in reverse reconstructs the seed exactly, with no bit ever
+erased (Landauer floor: zero). Because history is only consistent with the truth,
+flipping a single bit of the digest and running backward yields a "past" that is
+wrong in many bits: information is conserved, so a corrupted future refuses to
+invert to the real input.
+
+    python demos/neural_reversible_counterfactual.py
+"""
+import os, sys
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+from reversible_cpu import RCPU, _clone
+
+
+if __name__ == "__main__":
+    # cross-coupled mixing: R0 feeds R3 and R3 feeds R0, so the avalanche spreads
+    prog = []
+    for _ in range(8):
+        prog += [("ADD", 0, 3), ("TOFF", 3, 0, 2), ("ROL", 0, 1), ("XOR", 2, 3)]
+    cpu = RCPU(prog)
+    seed = cpu.new_state(regs=[7, 13, 201, 0])
+
+    print("neural_reversible: no-erasure computing and the counterfactual")
+    print("=" * 60)
+    s = _clone(seed)
+    cpu.run(s, len(prog))
+    print(f"seed registers {seed['R']}  --{len(prog)} bijective steps-->  "
+          f"digest {s['R']}")
+
+    b = _clone(s)
+    cpu.run_back(b, len(prog))
+    print(f"run backward: seed recovered "
+          f"{'EXACTLY' if b['R'] == seed['R'] and b['PC'] == seed['PC'] else 'FAILED'} "
+          f"(no bit was ever erased; Landauer floor 0)")
+
+    c = _clone(s)
+    c["R"][3] ^= 4                                  # corrupt one bit of the digest
+    cpu.run_back(c, len(prog))
+    diff = sum(bin(x ^ y).count("1") for x, y in zip(c["R"], seed["R"]))
+    print(f"counterfactual: flip ONE digest bit, run history backward -> the "
+          f"reconstructed 'seed' is wrong in {diff}/32 register bits")
+    print(f"  corrupted 'seed' = {c['R']}   true seed = {seed['R']}")
+    print("\n  History inverts only when it is the true history. A tampered")
+    print("  future does not lead back to the real past.")

demos/neural_rv32_machin_pi.py

@@ -0,0 +1,85 @@
+"""neural_rv32  --  pi by Machin's formula, computed on the RISC-V threshold CPU.
+
+pi = 16*arctan(1/5) - 4*arctan(1/239)  (John Machin, 1706), evaluated as an
+integer arctangent series at scale 1e8 with rounded divisions. Every add,
+multiply and divide runs through the ternary threshold datapath; 239^2 is
+computed on-machine, and the result is formatted to the memory-mapped console.
+
+    python demos/neural_rv32_machin_pi.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+import torch
+from machines import Asm, Rv32ThresholdCPU, rv_state
+from eval_all import int_to_bits
+
+
+def native():
+    """Integer mirror of the exact recurrence the machine will run."""
+    accA, t, sign, d, dsA = 0, 1600000000 // 5, 1, 1, []
+    while t > 0:
+        accA += sign * ((t + d // 2) // d); dsA.append(d)
+        sign, d, t = -sign, d + 2, (t + 12) // 25
+    accB, t, q, dsB, sign, d = 0, (400000000 + 119) // 239, 239 * 239, [], 1, 1
+    while t > 0:
+        accB += sign * ((t + d // 2) // d); dsB.append(d)
+        sign, d, t = -sign, d + 2, (t + q // 2) // q
+    return accA - accB, dsA, dsB
+
+
+def build(dsA, dsB):
+    a = Asm()
+    a.lui(4, 0x5F5E1)                    # x4 = 1,600,000,000
+    a.addi(5, 0, 25); a.addi(6, 0, 10); a.addi(8, 0, 239); a.addi(14, 0, 5)
+    a.div(11, 4, 14)                     # t = 16e8/5
+    a.addi(10, 0, 0)                     # accA
+    for k, d in enumerate(dsA):
+        a.addi(12, 0, d); a.addi(13, 11, d // 2); a.div(13, 13, 12)
+        (a.add if k % 2 == 0 else a.sub)(10, 10, 13)
+        if k + 1 < len(dsA):
+            a.addi(13, 11, 12); a.div(11, 13, 5)
+    a.lui(7, 0x17D78); a.ori(7, 7, 0x400)    # x7 = 400,000,000
+    a.addi(13, 7, 119); a.div(11, 13, 8)
+    a.mul(9, 8, 8)                       # 239^2 computed on-machine
+    a.srli(14, 9, 1)
+    a.addi(15, 0, 0)                     # accB
+    for k, d in enumerate(dsB):
+        a.addi(12, 0, d); a.addi(13, 11, d // 2); a.div(13, 13, 12)
+        (a.add if k % 2 == 0 else a.sub)(15, 15, 13)
+        if k + 1 < len(dsB):
+            a.add(13, 11, 14); a.div(11, 13, 9)
+    a.sub(10, 10, 15)                    # x10 = pi * 1e8
+    a.addi(20, 0, 0x7F8); a.slli(20, 20, 5)      # console 0xFF00
+    a.lui(21, 0x5F5E); a.ori(21, 21, 0x100)      # P = 1e8
+    a.div(22, 10, 21); a.rem(10, 10, 21)
+    a.addi(22, 22, 48); a.sb(22, 20, 0)          # integer digit
+    a.addi(22, 0, 46); a.sb(22, 20, 0)           # '.'
+    a.div(21, 21, 6); a.addi(23, 0, 8)
+    a.label("digits")
+    a.div(22, 10, 21); a.rem(10, 10, 21)
+    a.addi(22, 22, 48); a.sb(22, 20, 0)
+    a.div(21, 21, 6); a.addi(23, 23, -1); a.bne(23, 0, "digits")
+    a.ecall()
+    return a.assemble()
+
+
+if __name__ == "__main__":
+    pi9, dsA, dsB = native()
+    mem = build(dsA, dsB)
+    print("neural_rv32: Machin's pi on the threshold datapath")
+    print("=" * 56)
+    print("loading neural_rv32 (8.77M ternary parameters)...")
+    cpu = Rv32ThresholdCPU()
+    ts = rv_state(mem)
+    ts["_mem_bits"] = torch.tensor([int_to_bits(b, 8) for b in ts["mem"]], dtype=torch.float32)
+    t0, cyc = time.perf_counter(), 0
+    while not ts["halted"] and cyc < 400:
+        ts = cpu.step(ts); cyc += 1
+    want = f"{pi9 // 10**8}.{pi9 % 10**8:08d}"
+    print(f"console output : {ts['console']!r}   ({cyc} cycles, "
+          f"{time.perf_counter()-t0:.0f}s, dual-issue pairs {cpu.pairs_issued})")
+    print(f"integer mirror : {want!r}   (machine {'EXACT' if ts['console']==want else 'MISMATCH'})")
+    print(f"true pi        : 3.14159265(35...)  -> all printed digits "
+          f"{'correct' if ts['console']=='3.14159265' else 'NOT all correct'}")

demos/neural_rv32_neural_nets_via_neur.py

@@ -0,0 +1,184 @@
+"""neural_rv32  --  neural networks running as software on the neural-net CPU.
+
+neural_rv32's NEUR opcode computes exactly one ternary threshold neuron:
+    rd = H( popcount(rs1 & pos) - popcount(rs1 & neg) + sext5(bias) )
+with weights in {-1,0,+1} and an integer bias. So a program of NEUR
+instructions IS a ternary neural network -- and the CPU executing it is itself
+a threshold network. One net here is LEARNED by gradient descent (a nonlinear
+popcount band) and one is COMPILED by construction (8-bit parity, the function
+that ended the single perceptron); both are then deployed as NEUR code and run
+on the threshold datapath, with the CPU output checked against the reference net.
+
+    python demos/neural_rv32_neural_nets_via_neur.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+os.chdir(REPO)
+import torch
+from machines import Asm, Rv32ThresholdCPU, rv_state
+from eval_all import int_to_bits
+
+torch.manual_seed(0)
+
+
+def ternary(w):                      # {-1,0,+1} forward, identity backward (STE)
+    wq = torch.where(w > 0.5, 1.0, torch.where(w < -0.5, -1.0, 0.0))
+    return w + (wq - w).detach()
+
+def ibias(b, lo=-16, hi=15):
+    bq = b.round().clamp(lo, hi)
+    return b + (bq - b).detach()
+
+# ---- discrete NEUR reference (exactly what the hardware computes) ----------
+def neuron(x, pos, neg, bias):
+    return 1 if (bin(x & pos).count("1") - bin(x & neg).count("1") + bias) >= 0 else 0
+
+def discrete_net(x, hidden, out):
+    h = 0
+    for j, (p, n, b) in enumerate(hidden):
+        h |= neuron(x, p, n, b) << j
+    p, n, b = out
+    return neuron(h, p, n, b)
+
+# ---- train a 2-layer ternary MLP; hidden step trained with an annealed -----
+#      sigmoid so real gradients flow, then hardened to Heaviside at extraction
+def train(target_fn, H, epochs=5000, seed=0, nbits=8):
+    torch.manual_seed(seed)
+    N = 1 << nbits
+    xs = torch.arange(N)
+    X = torch.stack([((xs >> i) & 1).float() for i in range(nbits)], 1)
+    Y = torch.tensor([float(target_fn(int(x))) for x in xs])
+    Wh = torch.nn.Parameter(torch.randn(H, nbits) * 1.5)
+    bh = torch.nn.Parameter(torch.randn(H) * 1.5)
+    Wo = torch.nn.Parameter(torch.randn(H) * 1.5)
+    bo = torch.nn.Parameter(torch.zeros(1))
+    opt = torch.optim.Adam([Wh, bh, Wo, bo], lr=0.03)
+    npos = float(Y.sum())
+    bce = torch.nn.BCEWithLogitsLoss(pos_weight=torch.tensor((N - npos) / max(npos, 1.0)))
+    for ep in range(epochs):
+        opt.zero_grad()
+        Tt = 1.0 + 11.0 * ep / epochs
+        preh = X @ ternary(Wh).T + ibias(bh)
+        h = torch.sigmoid(Tt * preh)
+        preo = h @ ternary(Wo) + ibias(bo)
+        loss = bce(4.0 * preo, Y)
+        loss.backward(); opt.step()
+    Whq = torch.where(Wh > 0.5, 1, torch.where(Wh < -0.5, -1, 0)).tolist()
+    Woq = torch.where(Wo > 0.5, 1, torch.where(Wo < -0.5, -1, 0)).tolist()
+    bhq = bh.round().clamp(-16, 15).long().tolist()
+    boq = int(bo.round().clamp(-16, 15).item())
+    def pack(wrow):
+        return (sum(1 << i for i, w in enumerate(wrow) if w > 0),
+                sum(1 << i for i, w in enumerate(wrow) if w < 0))
+    hidden = [(*pack(Whq[j]), bhq[j]) for j in range(H)]
+    out = (*pack(Woq), boq)
+    acc = sum(discrete_net(int(x), hidden, out) == int(Y[i]) for i, x in enumerate(xs)) / N
+    return hidden, out, acc
+
+# ---- emit the network as NEUR code and run it on neural_rv32 ---------------
+def li(a, reg, v):
+    v &= 0xFFFFFFFF
+    hi = (v + 0x800) >> 12
+    lo = v - (hi << 12)
+    a.lui(reg, hi & 0xFFFFF)
+    if lo: a.addi(reg, reg, lo)
+
+def build_program(xval, hidden, out):
+    a = Asm()
+    li(a, 1, xval)                 # x1 = input byte
+    li(a, 2, 0)                    # x2 = packed hidden
+    for j, (p, n, b) in enumerate(hidden):
+        li(a, 4, p | (n << 8) | ((b & 0x1F) << 16))   # weight word
+        a.neur(3, 1, 4)            # x3 = hidden neuron j
+        if j: a.slli(2, 2, 1)
+        a.or_(2, 2, 3)             # pack MSB-first (neuron 0 -> bit H-1)
+    p, n, b = out
+    H = len(hidden)
+    def remap(mask):               # match the MSB-first hidden packing
+        r = 0
+        for j in range(H):
+            if (mask >> j) & 1: r |= 1 << (H - 1 - j)
+        return r
+    li(a, 4, remap(p) | (remap(n) << 8) | ((b & 0x1F) << 16))
+    a.neur(5, 2, 4)                # x5 = output
+    a.ecall()
+    return a.assemble()
+
+def run_cpu(cpu, xval, hidden, out):
+    mem = build_program(xval, hidden, out)
+    ts = rv_state(mem)
+    ts["_mem_bits"] = torch.tensor([int_to_bits(b, 8) for b in ts["mem"]], dtype=torch.float32)
+    cyc = 0
+    while not ts["halted"] and cyc < 200:
+        ts = cpu.step(ts); cyc += 1
+    return ts["regs"][5], cyc
+
+
+def parity(x, nbits=8): return bin(x & ((1 << nbits) - 1)).count("1") & 1
+def band(x): return int(3 <= bin(x).count("1") <= 5)      # non-monotone in popcount
+
+def learn(fn, H, seeds, epochs):
+    best, t0, used = None, time.perf_counter(), 0
+    for seed in range(seeds):
+        used = seed
+        hidden, out, acc = train(fn, H=H, seed=seed, epochs=epochs)
+        if best is None or acc > best[2]:
+            best = (hidden, out, acc)
+        if acc == 1.0:
+            break
+    hidden, out, acc = best
+    print(f"  trained 8->{H}->1 ternary MLP by annealed-sigmoid SGD: {acc*100:.1f}% "
+          f"exact over all 256 inputs  ({time.perf_counter()-t0:.0f}s, seed {used}); "
+          f"weights all in {{-1,0,+1}}")
+    return hidden, out, acc
+
+def deploy_check(cpu, fn, hidden, out, sample):
+    t0, cpu_vs_net, cpu_vs_true, rows = time.perf_counter(), 0, 0, []
+    for x in sample:
+        y_cpu, _ = run_cpu(cpu, x, hidden, out)
+        cpu_vs_net += (y_cpu == discrete_net(x, hidden, out))
+        cpu_vs_true += (y_cpu == fn(x))
+        rows.append((x, y_cpu, fn(x)))
+    print(f"    NEUR execution on neural_rv32: CPU == reference net on "
+          f"{cpu_vs_net}/{len(sample)} (deployment exact); CPU == truth on "
+          f"{cpu_vs_true}/{len(sample)}  ({time.perf_counter()-t0:.0f}s)")
+    return rows
+
+def compile_parity(nbits=8):        # exact thermometer construction
+    mask = (1 << nbits) - 1
+    hidden = [(mask, 0, -(k + 1)) for k in range(nbits)]     # h_k = [popcount>=k+1]
+    pos = sum(1 << j for j in range(nbits) if j % 2 == 0)    # odd thresholds
+    neg = sum(1 << j for j in range(nbits) if j % 2 == 1)    # even thresholds
+    return hidden, (pos, neg, -1)
+
+
+if __name__ == "__main__":
+    print("=" * 72)
+    print(" Neural networks running as software on the CPU that IS a neural net")
+    print("=" * 72)
+    cpu = Rv32ThresholdCPU()
+
+    print("\n[1] LEARNED by gradient descent -- popcount BAND: fire iff 3<=popcount<=5")
+    print("    (non-monotone, so no single threshold can do it; genuinely nonlinear)")
+    hidden, out, acc = learn(band, H=8, seeds=12, epochs=5000)
+    deploy_check(cpu, band, hidden, out,
+                 [0, 1, 3, 7, 15, 31, 63, 127, 255, 0b10110, 0b1111000, 0b11011011])
+    line = "".join(f"{k}:{discrete_net((1 << k) - 1, hidden, out)} " for k in range(9))
+    print(f"    net output vs popcount k:  {line.strip()}   (true band: k in 3,4,5)")
+
+    print("\n[2] COMPILED by construction -- 8-bit PARITY (XOR), the non-separable")
+    print("    function Minsky & Papert used to end the single perceptron")
+    hidden, out = compile_parity(8)
+    acc = sum(discrete_net(x, hidden, out) == parity(x) for x in range(256)) / 256
+    print(f"    thermometer net (8 hidden 'popcount>=k' + alternating output), all "
+          f"weights in {{-1,0,+1}}: {acc*100:.0f}% exact over all 256 bytes")
+    rows = deploy_check(cpu, parity, hidden, out,
+                        [0, 1, 3, 7, 15, 31, 85, 127, 128, 170, 200, 254, 255])
+    for x, yc, yt in rows:
+        print(f"      parity({x:3d}) = {yc}  (true {yt})  [{'ok' if yc==yt else 'x'}]")
+
+    print("\n  One network learned by SGD, one compiled by hand, both executed")
+    print("  instruction by instruction on a CPU whose every gate is a threshold")
+    print("  neuron. The machine running the models belongs to the models' own class.")

demos/neural_subleq8io_universal_constructor.py

@@ -0,0 +1,73 @@
+"""neural_subleq8io  --  von Neumann's universal constructor, to the byte.
+
+The one-instruction machine (194 gates) runs a 21-instruction SUBLEQ program
+that reads a description of any machine in the family off its tape and emits
+that machine's safetensors file one byte at a time. Here it fabricates
+neural_tile.safetensors on the shipped gate netlist, byte-for-byte sha-identical
+to the target, and the fabricated file is then booted: tiles reconstructed from
+its own bytes regrow the binary counter. A computer made of threshold gates
+prints a working computer, and the product runs.
+
+    python demos/neural_subleq8io_universal_constructor.py
+"""
+import os, sys, time, json, hashlib
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+os.chdir(REPO)
+from constructor8 import describe, ref_construct, GateHost
+
+
+if __name__ == "__main__":
+    target_path = os.path.join(REPO, "variants", "neural_tile.safetensors")
+    data = open(target_path, "rb").read()
+    tape = describe(data)
+    print("neural_subleq8io: the universal constructor fabricates a sibling")
+    print("=" * 60)
+    print(f"recipe compiled: {len(data)} B machine -> {len(tape)} B tape")
+
+    out_ref, n_ref = ref_construct(tape)
+    assert out_ref == data
+    print(f"reference: constructor needs {n_ref:,} instructions")
+
+    host = GateHost()
+    t0 = time.perf_counter()
+    out, n, _ = host.run(tape, max_steps=n_ref + 100)
+    dt = time.perf_counter() - t0
+    sha_out = hashlib.sha256(out).hexdigest()[:16]
+    sha_tgt = hashlib.sha256(data).hexdigest()[:16]
+    print(f"gate netlist: {n:,} instructions in {dt:.0f}s ({n / dt:.0f} instr/s), "
+          f"{len(out)} bytes emitted")
+    print(f"  sha256 fabricated={sha_out}  shipped={sha_tgt}  "
+          f"{'BYTE-IDENTICAL' if out == data else 'MISMATCH'}; "
+          f"instruction count == reference: {n == n_ref}")
+
+    # boot the fabricated machine: regrow its counter from its own bytes
+    fab = os.path.join(os.environ.get("TEMP", "."), "fabricated_neural_tile.safetensors")
+    open(fab, "wb").write(out)
+    from safetensors.torch import load_file
+    from safetensors import safe_open
+    import tile as T
+
+    t = load_file(fab)
+    with safe_open(fab, framework="pt") as f:
+        m = f.metadata()
+    gl = json.loads(m["glues"])
+    strg = {gl[i]: int(v) for i, v in enumerate(t["glue_strength"].tolist())}
+    tiles = []
+    for row, name in zip(t["tile_glues"].tolist(), json.loads(m["tile_names"])):
+        sides = [gl[i] if i >= 0 else "" for i in row]
+        tiles.append(T.Tile(N=sides[0], E=sides[1], S=sides[2], W=sides[3], name=name))
+    NB = 8
+    rows = (1 << NB) - 1
+    A, det = T.grow(tiles, T.counter_seed(NB), int(m["tau"]), strg, (0, 0, NB, rows))
+    bad = filled = 0
+    for y in range(1, rows + 1):
+        cells = [A.get((x, y)) for x in range(NB)]
+        if any(cc is None for cc in cells):
+            continue
+        filled += 1
+        v = sum((1 if cc.N == "b1" else 0) << (NB - 1 - x) for x, cc in enumerate(cells))
+        bad += (v != y)
+    print(f"boot: the fabricated file grew its counter, {filled} rows, "
+          f"row y encodes y: {'EXACT' if bad == 0 and filled == rows else f'{bad} bad'}")

demos/neural_tile_pascal_lucas.py

@@ -0,0 +1,42 @@
+"""neural_tile  --  self-assembly grows Pascal's triangle mod 2 (Lucas' theorem).
+
+The program is a set of square tiles whose binding rule is a threshold gate: a
+tile attaches at a site when the summed strength of its matching glues meets the
+temperature. With the XOR rule tile set, the crystal that grows is exactly the
+Sierpinski triangle -- cell (x,y) is filled iff the binomial C(x+y, x) is odd,
+which by Lucas' theorem is iff x AND y == 0. Every filled cell is verified
+against that arithmetic. Computation as crystal growth.
+
+    python demos/neural_tile_pascal_lucas.py
+"""
+import os, sys, time
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(REPO, "src"))
+import tile as T
+
+
+if __name__ == "__main__":
+    N = 100
+    print("neural_tile: Pascal mod 2 by threshold-gated self-assembly")
+    print("=" * 60)
+    t0 = time.perf_counter()
+    ts = T.rule2_tileset(lambda w, s: w ^ s)
+    seed = T._row_col_seed([1] * (N + 1), [1] * (N + 1))
+    A, det = T.grow(ts, seed, tau=2, strength={}, bounds=(0, 0, N, N), max_tiles=200000)
+    dt = time.perf_counter() - t0
+
+    interior = [(x, y) for x in range(1, N + 1) for y in range(1, N + 1)]
+    grown = sum(1 for p in interior if p in A)
+    bad = 0
+    for (x, y) in interior:
+        v = 1 if A[(x, y)].N == "v1" else 0
+        lucas = 1 if (x & y) == 0 else 0        # C(x+y,x) odd  <=>  no carry in x+y
+        bad += (v != lucas)
+    print(f"grew {grown} rule tiles in {dt:.1f}s (directed={det}, "
+          f"{2 * N} anti-diagonals deep)")
+    print(f"tile(x,y) == [C(x+y,x) is odd] for all {len(interior)} cells: "
+          f"{'EXACT' if bad == 0 else f'{bad} MISMATCHES'}")
+    print("\ncorner of the assembly (30x30, '#' = odd binomial):")
+    for y in range(30, 0, -1):
+        print("  " + "".join("#" if A[(x, y)].N == "v1" else "." for x in range(1, 31)))