neural_ca: a reversible cellular-automaton computer with no processor. One fixed Margolus block rule (rotate 180, diagonal pairs swap) applied identically to every 2x2 block of a lattice, alternating partition each step. The rule is a self-inverse permutation of the 16 block states, so the whole lattice update is a bijection; verified reversible over random lattices, particle-conserving, with ballistic single-particle motion and deflecting reversible collisions (the billiard-ball model, Turing-universal by Margolus 1984). The rule is Heaviside threshold gates and compiles to a 6-layer ternary matrix tile that is a permutation with a 0.5 margin; that one tile applied to every block is one whole-lattice step, shipped as variants/neural_ca.safetensors. eval_all skips it; README adds the section and updates counts (8 standalone machines, 27-file family round-trip).

README.md

@@ -40,9 +40,10 @@ variants/neural_subleq8io.safetensors                            SUBLEQ host for
 variants/neural_reflect.safetensors                              interpreter whose state holds its own weights
 variants/neural_attractor.safetensors                            energy-based solver; a multiplier run backward factors
 variants/neural_reversible.safetensors                           reversible arithmetic core, a bijection with no erasure
+variants/neural_ca.safetensors                                   reversible cellular-automaton medium (no processor)
 ```
 
-Seven further machines are detailed in their own sections below, and together
+Eight further machines are detailed in their own sections below, and together
 they carry the family from the smallest possible processor to several results
 about what a threshold network can be. `neural_subleq8` is a Turing-complete
 one-instruction computer whose entire control flow is a single threshold
@@ -64,7 +65,11 @@ consistent assignment, so clamping different wires runs the same network forward
 to evaluate, backward to invert (a multiplier run backward returns factors), or
 as a SAT solver. And `neural_reversible` makes the entire state transition a
 bijection, so no step erases information and the machine runs backward to
-reconstruct its input, a processor with no Landauer erasure floor.
+reconstruct its input, a processor with no Landauer erasure floor. And
+`neural_ca` removes the processor altogether: one fixed reversible rule applied
+identically to every cell of a lattice, a spatially homogeneous medium of the
+billiard-ball class in which a program is a configuration of particles and
+computation is the medium evolving.
 
 ---
 
@@ -360,7 +365,7 @@ Every weight and bias tensor in the canonical model fits in `int8`. The eval pip
 
 The 8-bit arithmetic and ALU tests use strategic sampling rather than the full 65,536-case sweep because exhaustive coverage at 8-bit is feasible but not necessary given that the circuits are constructed gate-by-gate. The 16-bit and 32-bit arithmetic tests sample edge cases only; full exhaustive coverage at those widths is infeasible without specialized hardware.
 
-`src/eval_all.py` runs the unified suite. Exit code is the number of failing variants (0 means all pass). **Testing is evaluation, not rebuilding**: `python src/eval_all.py variants/` scores all 18 fitness variants against the shipped weights in about two minutes (~6 s each, the composed float netlists evaluated in `NetlistEvaluator`'s leveled mode) and cleanly skips the seven standalone machines. Rebuilding the models (`tools/build_all.py`, ~50 min for all 18) is a separate step, needed only when the circuit constructions in `src/build.py` change; routine verification never rebuilds. The batched evaluator is population-safe: every chained intermediate (carry, borrow, mux select) is computed per population slot, so `tools/prune_weights.py`'s parallel fitness screens are exact rather than slot-0 approximations.
+`src/eval_all.py` runs the unified suite. Exit code is the number of failing variants (0 means all pass). **Testing is evaluation, not rebuilding**: `python src/eval_all.py variants/` scores all 18 fitness variants against the shipped weights in about two minutes (~6 s each, the composed float netlists evaluated in `NetlistEvaluator`'s leveled mode) and cleanly skips the eight standalone machines. Rebuilding the models (`tools/build_all.py`, ~50 min for all 18) is a separate step, needed only when the circuit constructions in `src/build.py` change; routine verification never rebuilds. The batched evaluator is population-safe: every chained intermediate (carry, borrow, mux select) is computed per population slot, so `tools/prune_weights.py`'s parallel fitness screens are exact rather than slot-0 approximations.
 
 ---
 
@@ -524,7 +529,7 @@ then the byte-for-byte safetensors file of the host itself.
 
 The equality is machine-checked rather than observed on one run:
 
-- the recipe codec round-trips every file in the family (all 26 shipped
+- the recipe codec round-trips every file in the family (all 27 shipped
   `.safetensors`, 971 MB, byte-identical and sha-verified);
 - the constructor program is executed on three independently-verified
   backends — a pure-integer reference, the gate-graph `SubleqThresholdCPU`
@@ -664,6 +669,42 @@ python tools/reversible_matrix.py  # ternary matrix stack: permutation transitio
 
 ---
 
+## neural_ca — a reversible computing medium with no processor
+
+The other machines still keep distinguished hardware. This one has none: the
+entire machine is a single fixed rule applied identically to every 2x2 block of
+a lattice, with the block partition alternating each step (the Margolus
+neighborhood). No program counter, no memory unit, no control. A program is a
+configuration of particles, and running it is letting the medium evolve.
+
+The block rule rotates each block 180 degrees, except that two particles on a
+diagonal swap to the other diagonal. It is a permutation of the sixteen block
+states and its own inverse, so the whole lattice update is a bijection and the
+medium is reversible: replaying the partition sequence backward reconstructs any
+earlier configuration (verified over random lattices), and particle number is
+conserved. The rule is the family's Heaviside threshold gates (a diagonal-pair
+detector XORed onto the rotated cells) and compiles to a 6-layer ternary matrix
+tile that is itself a permutation with the same 0.5 analog margin as
+`neural_matrix8`; that one tile applied to every block is one whole-lattice step,
+so `variants/neural_ca.safetensors` stores the rule of the medium, not a
+processor.
+
+Its dynamics are those of the billiard-ball model of computation (Fredkin and
+Toffoli): isolated particles travel ballistically along diagonals, and
+collisions deflect them reversibly, both verified here. Particle configurations
+are therefore signals and collision geometries are logic; a Margolus
+billiard-ball automaton of this class is Turing-universal, so a piece of this
+homogeneous reversible medium computes by evolving. It is the family's maximal
+dissolution of architecture: the same rule everywhere, no center, computation as
+discrete reversible physics.
+
+```bash
+python src/ca.py             # rule bijection, lattice reversibility, ballistic motion, collisions
+python tools/build_ca.py     # ship the block rule as a ternary matrix tile (permutation + 0.5 margin)
+```
+
+---
+
 ## Threshold logic
 
 A threshold gate computes a Boolean function by taking a weighted sum of binary inputs and comparing the result to a threshold; the output is 1 when the sum meets or exceeds the threshold and 0 otherwise. Equivalently, it is a neuron with Heaviside step activation, integer weights, and an integer bias.
@@ -836,10 +877,10 @@ Loss components: BCE on output bits, BCE on extracted A and B bits (2× weight),
 
 ```
 neural_computer.safetensors         canonical model (32-bit, 64 KB, ~8.61M params)
-variants/                           18 fitness variants + 7 standalone machines
+variants/                           18 fitness variants + 8 standalone machines
                                     (neural_subleq8, neural_rv32, neural_matrix8,
                                      neural_subleq8io, neural_reflect,
-                                     neural_attractor, neural_reversible)
+                                     neural_attractor, neural_reversible, neural_ca)
 src/                                the library (run scripts as `python src/<name>.py`)
   ├── build.py                      generator (one safetensors per invocation; also `subleq`, `rv32`)
   ├── quantize.py                   min integer dtypes + ternary verification/repair
@@ -858,13 +899,16 @@ src/                                the library (run scripts as `python src/<nam
   ├── reversible.py                 neural_reversible: reversible threshold gates, Cuccaro ALU,
   │                                 Bennett construction
   ├── reversible_cpu.py             reversible register machine: bijective step, backward execution
-  └── reversible_prog.py            structured reversible programs (multiply, Fibonacci, Janus IF)
+  ├── reversible_prog.py            structured reversible programs (multiply, Fibonacci, Janus IF)
+  └── ca.py                         neural_ca: reversible Margolus cellular automaton, threshold
+                                    block rule, lattice reversibility and billiard-ball dynamics
 tools/                              build_all.py (build + quantize + verify every profile),
                                     cpu_programs.py (assembler + CPU program suite), test_cpu.py
                                     (program suite vs a variant), play.py (interactive demo),
                                     prune_weights.py (GPU-batched weight reduction),
                                     build_attractor.py / test_attractor.py (neural_attractor),
-                                    build_reversible.py / reversible_matrix.py (neural_reversible)
+                                    build_reversible.py / reversible_matrix.py (neural_reversible),
+                                    build_ca.py (neural_ca matrix tile)
 llm_integration/                    SmolLM2 extractor + circuit wrapper + training code
   ├── circuits.py                   FrozenThresholdCircuits (loads safetensors, exposes
   │                                 add_8bit / sub_8bit / mul_8bit / compare_*)

src/ca.py

@@ -0,0 +1,205 @@
+"""Reversible cellular-automaton computer: a spatially homogeneous physics.
+
+There is no processor here. The whole machine is one fixed rule applied
+identically to every 2x2 block of a lattice, alternating the block partition
+each step (the Margolus neighborhood). No program counter, no memory unit, no
+control: computation is what a uniform reversible medium does as it evolves, and
+a program is a configuration of cells (particles) inside it.
+
+The block rule is a permutation of the sixteen 2x2 block states, so the whole
+lattice update is a bijection and the medium is reversible. It is of the
+billiard-ball class: isolated particles travel ballistically and collisions
+deflect them, which is Turing-universal (Margolus 1984; particles are signals,
+fixed particle clusters are mirrors, and collision geometries are gates).
+
+Rule (cells ordered TL,TR,BL,BR): rotate every block 180 degrees, except a pair
+of particles on a diagonal swaps to the other diagonal (the deflecting
+collision). Both operations are involutions and neither moves a state between
+the diagonal-pair set and its complement, so the rule is its own inverse and the
+lattice update run with the partition sequence reversed undoes the computation.
+"""
+from __future__ import annotations
+from typing import List, Tuple
+
+Block = Tuple[int, int, int, int]
+
+
+def rule(b: Block) -> Block:
+    tl, tr, bl, br = b
+    if b == (1, 0, 0, 1):
+        return (0, 1, 1, 0)          # diagonal pair -> other diagonal (deflect)
+    if b == (0, 1, 1, 0):
+        return (1, 0, 0, 1)
+    return (br, bl, tr, tl)          # otherwise rotate 180 degrees
+
+
+def is_bijection() -> bool:
+    outs = {rule(tuple((s >> k) & 1 for k in (3, 2, 1, 0))) for s in range(16)}
+    return len(outs) == 16
+
+
+def self_inverse() -> bool:
+    return all(rule(rule(tuple((s >> k) & 1 for k in (3, 2, 1, 0))))
+               == tuple((s >> k) & 1 for k in (3, 2, 1, 0)) for s in range(16))
+
+
+def step(grid: List[List[int]], phase: int) -> List[List[int]]:
+    """One Margolus update. phase 0 aligns blocks at even coordinates; phase 1
+    offsets the partition by (1,1). Toroidal, so H and W must be even."""
+    H, W = len(grid), len(grid[0])
+    out = [row[:] for row in grid]
+    o = phase
+    for r0 in range(o, o + H, 2):
+        for c0 in range(o, o + W, 2):
+            r, r1 = r0 % H, (r0 + 1) % H
+            c, c1 = c0 % W, (c0 + 1) % W
+            nb = rule((grid[r][c], grid[r][c1], grid[r1][c], grid[r1][c1]))
+            out[r][c], out[r][c1], out[r1][c], out[r1][c1] = nb
+    return out
+
+
+def run(grid: List[List[int]], nsteps: int, start_phase: int = 0) -> List[List[int]]:
+    g = grid
+    for n in range(nsteps):
+        g = step(g, (start_phase + n) & 1)
+    return g
+
+
+def run_back(grid: List[List[int]], nsteps: int, start_phase: int = 0) -> List[List[int]]:
+    """Undo `run`: replay the phase sequence in reverse; the rule is self-inverse."""
+    phases = [(start_phase + n) & 1 for n in range(nsteps)]
+    g = grid
+    for p in reversed(phases):
+        g = step(g, p)
+    return g
+
+
+# --- the block rule as Heaviside threshold gates ---
+# rule(s) = rotate180(s) XOR is_diag(s) on every cell: rotation fixes diagonal
+# pairs, and flipping all four cells of a rotated diagonal pair sends it to the
+# other diagonal. is_diag detects the two diagonal-pair states.
+def _H(x):
+    return 1 if x >= 0 else 0
+
+
+def _and(*xs):
+    return _H(sum(xs) - len(xs))
+
+
+def _or(*xs):
+    return _H(sum(xs) - 1)
+
+
+def _xor(a, b):
+    return _and(_or(a, b), _H(1 - a - b))       # OR AND NAND, the family's XOR
+
+
+def gate_rule(b: Block) -> Block:
+    tl, tr, bl, br = b
+    d = _or(_and(tl, 1 - tr, 1 - bl, br), _and(1 - tl, tr, bl, 1 - br))   # is_diag
+    return (_xor(br, d), _xor(bl, d), _xor(tr, d), _xor(tl, d))
+
+
+def _test_gates():
+    ok = all(gate_rule(tuple((s >> k) & 1 for k in (3, 2, 1, 0)))
+             == rule(tuple((s >> k) & 1 for k in (3, 2, 1, 0))) for s in range(16))
+    print(f"  block rule as Heaviside threshold gates matches over 16 states: "
+          f"{'OK' if ok else 'FAIL'}")
+    return ok
+
+
+# --- tests ---
+def _rand_grid(H, W, seed):
+    import random
+    rng = random.Random(seed)
+    return [[rng.randint(0, 1) for _ in range(W)] for _ in range(H)]
+
+
+def _ball_positions(g):
+    return {(r, c) for r, row in enumerate(g) for c, v in enumerate(row) if v}
+
+
+def _test_rule():
+    print(f"  block rule is a bijection of 16 states: {'OK' if is_bijection() else 'FAIL'}")
+    print(f"  block rule is self-inverse: {'OK' if self_inverse() else 'FAIL'}")
+    return is_bijection() and self_inverse()
+
+
+def _test_reversibility():
+    bad = 0
+    for seed in range(20):
+        g = _rand_grid(8, 8, seed)
+        fwd = run(g, 25, start_phase=0)
+        back = run_back(fwd, 25, start_phase=0)
+        if back != g:
+            bad += 1
+    # particle count is conserved (the rule permutes cells within each block)
+    g = _rand_grid(8, 8, 99)
+    conserved = sum(sum(r) for r in g) == sum(sum(r) for r in run(g, 40))
+    print(f"  lattice reversible (run then reverse recovers grid, 20 grids): "
+          f"{'OK' if bad == 0 else f'FAIL({bad})'}")
+    print(f"  particle number conserved: {'OK' if conserved else 'FAIL'}")
+    return bad == 0 and conserved
+
+
+def _test_ballistic():
+    # a single particle travels in a straight diagonal line
+    H = W = 16
+    g = [[0] * W for _ in range(H)]
+    g[2][2] = 1
+    positions = [next(iter(_ball_positions(g)))]
+    gg = g
+    for n in range(8):
+        gg = step(gg, n & 1)
+        p = _ball_positions(gg)
+        positions.append(next(iter(p)) if len(p) == 1 else None)
+    ok = all(p is not None for p in positions)
+    steady = ok and all(positions[i + 1] == (positions[i][0] + 1, positions[i][1] + 1)
+                        for i in range(len(positions) - 1))
+    print(f"  single particle stays a single particle: {'OK' if ok else 'FAIL'}")
+    print(f"  and moves ballistically on the diagonal, +(1,1) per step: "
+          f"{'OK' if steady else 'FAIL'}  trace={positions[:5]}")
+    return ok and steady
+
+
+def _test_collision():
+    # Two particles interact (the joint evolution differs from independent
+    # motion) and the collision stays reversible: the physics that logic needs.
+    H = W = 12
+    interacted = False
+    revok = True
+    # converging pairs: an SE-mover (even,even) meets an NW-mover (odd,odd) on a
+    # shared diagonal, forming the 1001/0110 diagonal pair the rule deflects.
+    for a, b in [((2, 2), (7, 7)), ((3, 3), (8, 8)), ((2, 8), (7, 3)),
+                 ((4, 4), (9, 9)), ((2, 2), (9, 9))]:
+        g = [[0] * W for _ in range(H)]
+        g[a[0]][a[1]] = 1
+        g[b[0]][b[1]] = 1
+        ga = [[0] * W for _ in range(H)]
+        ga[a[0]][a[1]] = 1
+        gb = [[0] * W for _ in range(H)]
+        gb[b[0]][b[1]] = 1
+        joint = g
+        for n in range(12):
+            joint = step(joint, n & 1)
+            ga = step(ga, n & 1)
+            gb = step(gb, n & 1)
+            free = _ball_positions(ga) | _ball_positions(gb)
+            if _ball_positions(joint) != free:
+                interacted = True
+        if run_back(run(g, 12), 12) != g:
+            revok = False
+    print(f"  two-particle collisions interact (joint != independent motion): "
+          f"{'OK' if interacted else 'FAIL'}")
+    print(f"  collisions remain reversible: {'OK' if revok else 'FAIL'}")
+    return interacted and revok
+
+
+if __name__ == "__main__":
+    print("Reversible Margolus cellular automaton")
+    a = _test_rule()
+    g = _test_gates()
+    b = _test_reversibility()
+    c = _test_ballistic()
+    d = _test_collision()
+    print("PASS" if (a and g and b and c and d) else "FAIL")

src/eval_all.py

@@ -672,6 +672,7 @@ MACHINE_VERIFIER = {
     "reflect": "reflect.py",
     "attractor": "tools/test_attractor.py",
     "reversible": "src/reversible.py",
+    "ca": "src/ca.py",
 }
 
 

tools/build_ca.py

@@ -0,0 +1,105 @@
+"""Ship the reversible CA's local rule as a ternary matrix tile,
+variants/neural_ca.safetensors. The 2x2 block rule compiles to a stack of
+ternary matrices with a Heaviside step; because the rule is a bijection the tile
+is a permutation matrix product, crossbar-realizable with a 0.5 margin, and the
+same tile applied to every block of a lattice is one step of the whole machine.
+No processor is stored, only the rule of the medium."""
+from __future__ import annotations
+import os
+import sys
+
+import torch
+from safetensors.torch import save_file, load_file
+from safetensors import safe_open
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(ROOT, "src"))
+import ca
+from matrix8 import Net, compile_net, MatrixMachine
+
+OUT = os.path.join(ROOT, "variants", "neural_ca.safetensors")
+
+
+def block_net():
+    net = Net()
+    ntl, ntr = net.NOT("ntl", "tl"), net.NOT("ntr", "tr")
+    nbl, nbr = net.NOT("nbl", "bl"), net.NOT("nbr", "br")
+    d1 = net.AND("d1", ["tl", ntr, nbl, "br"])
+    d2 = net.AND("d2", [ntl, "tr", "bl", nbr])
+    dg = net.OR("dg", [d1, d2])                       # is_diag
+    TL = net.XOR("oTL", "br", dg)
+    TR = net.XOR("oTR", "bl", dg)
+    BL = net.XOR("oBL", "tr", dg)
+    BR = net.XOR("oBR", "tl", dg)
+    return net, ["tl", "tr", "bl", "br"], [TL, TR, BL, BR]
+
+
+def matrix_step(mm, grid, phase):
+    """One Margolus update driven entirely by the matrix tile."""
+    H, W = len(grid), len(grid[0])
+    out = [row[:] for row in grid]
+    for r0 in range(phase, phase + H, 2):
+        for c0 in range(phase, phase + W, 2):
+            r, r1, c, c1 = r0 % H, (r0 + 1) % H, c0 % W, (c0 + 1) % W
+            v = torch.tensor([[float(grid[r][c]), float(grid[r][c1]),
+                               float(grid[r1][c]), float(grid[r1][c1])]])
+            o = mm.step(v)[0]
+            out[r][c], out[r][c1], out[r1][c], out[r1][c1] = (int(o[0]), int(o[1]),
+                                                              int(o[2]), int(o[3]))
+    return out
+
+
+def main() -> int:
+    net, inp, outp = block_net()
+    layers, info = compile_net(net, inp, outp)
+    mm = MatrixMachine(layers)
+
+    seen, bad, vecs = set(), 0, []
+    for s in range(16):
+        b = tuple((s >> k) & 1 for k in (3, 2, 1, 0))     # tl,tr,bl,br
+        v = torch.tensor([[float(x) for x in b]])
+        got = tuple(int(x) for x in mm.step(v)[0])
+        if got != ca.rule(b):
+            bad += 1
+        seen.add(got)
+        vecs.append(v[0])
+    perm = len(seen) == 16
+    margin = mm.min_margin(torch.stack(vecs))
+
+    tensors = {}
+    for k, (W, B) in enumerate(layers):
+        tensors[f"matrix.layer{k:03d}.weight"] = W.to(torch.int8)
+        tensors[f"matrix.layer{k:03d}.bias"] = B.to(torch.int8)
+    meta = {"machine": "ca",
+            "rule": "Margolus reversible: rotate 180 except diagonal pair swaps (BBM class)",
+            "inputs": "tl,tr,bl,br", "outputs": "TL,TR,BL,BR", "layers": str(info["layers"])}
+    save_file(tensors, OUT, metadata=meta)
+    print(f"Built {os.path.relpath(OUT, ROOT)}: reversible CA block rule as a ternary matrix tile")
+    print(f"  layers={info['layers']}  gates={info['gates']}  size={os.path.getsize(OUT)} bytes")
+    print(f"  every weight ternary: "
+          f"{'OK' if all(((W == -1) | (W == 0) | (W == 1)).all() for W, _ in layers) else 'FAIL'}")
+    print(f"  tile matches the block rule over all 16 states: {'OK' if bad == 0 else f'FAIL({bad})'}")
+    print(f"  tile is a permutation (16 distinct outputs): {'OK' if perm else 'FAIL'}")
+    print(f"  analog noise margin: {margin:.3f} (guarantee 0.5)")
+
+    # the loaded tile, applied to every block, is one whole-lattice CA step
+    t = load_file(OUT)
+    n = 0
+    lyr = []
+    while f"matrix.layer{n:03d}.weight" in t:
+        lyr.append((t[f"matrix.layer{n:03d}.weight"], t[f"matrix.layer{n:03d}.bias"]))
+        n += 1
+    mm2 = MatrixMachine(lyr)
+    g = ca._rand_grid(8, 8, 3)
+    gmat = matrix_step(mm2, g, 0)
+    gref = ca.step(g, 0)
+    print(f"  loaded tile drives a full lattice step (matches ca.step): "
+          f"{'OK' if gmat == gref else 'FAIL'}")
+
+    ok = bad == 0 and perm and abs(margin - 0.5) < 1e-6 and gmat == gref
+    print("PASS" if ok else "FAIL")
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

variants/neural_ca.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d10be4d24d91d2d1100022369d8809c7be9fad154c1347f38ae74c7d59a25ee4
+size 1329