neural_ca: construct and verify a logic gate in the automaton rather than citing one. A billiard-ball collision between input particles at (2,2) and (7,7) leaves the deflected cell (3,6) occupied at step 4 iff both inputs are present; and_gate() checks the AND truth table over all four inputs. README and docstrings restated as plain technical description of the rule, the verified dynamics, and the constructed gate.

README.md

@@ -66,10 +66,10 @@ 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. 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.
+`neural_ca` has no processor at all: one fixed reversible rule applied to every
+2x2 block of a lattice (a Margolus cellular automaton), where a particle
+collision computes an AND gate and ballistic transport plus collisions are the
+billiard-ball universality primitives.
 
 ---
 
@@ -669,37 +669,34 @@ python tools/reversible_matrix.py  # ternary matrix stack: permutation transitio
 
 ---
 
-## neural_ca — a reversible computing medium with no processor
+## neural_ca — a reversible cellular automaton
 
-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.
+A partitioned (Margolus) cellular automaton: one fixed rule applied to every 2x2
+block of a lattice, with the block partition alternating each step. The state is
+the lattice; there is no program counter, register file, or control circuit, and
+one step updates every block.
 
 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: isolated
-particles travel ballistically along diagonals, and collisions deflect them
-reversibly, both verified here. Those are exactly the mechanics Fredkin and
-Toffoli showed are computation-universal, with ballistic particles as signals,
-fixed clusters as reflectors, and collision geometries realizing the Fredkin
-gate. This medium realizes and verifies the mechanics; the gate layout is their
-construction. It is the family's maximal dissolution of architecture: the same
-rule everywhere, no center, computation as discrete reversible physics.
+states and its own inverse, so the lattice update is a bijection: replaying the
+partition sequence in reverse reconstructs any earlier configuration (verified
+over random lattices), and particle number is conserved. The rule is expressed
+in 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 a
+permutation with a 0.5 analog margin; that tile applied to every block is one
+lattice step, stored as `variants/neural_ca.safetensors`.
+
+The dynamics are the billiard-ball model's: a single particle moves ballistically
+along a diagonal at one cell per step, and two particles collide and deflect
+reversibly (verified as a genuine interaction, distinct from independent motion).
+A collision computes logic directly: with input particles at (2,2) and (7,7), the
+deflected cell (3,6) is occupied at step 4 iff both inputs are present, an AND
+gate checked over all four input combinations. Ballistic transport and this
+collision are the primitives of the Fredkin-Toffoli universality construction
+(Margolus 1984).
 
 ```bash
-python src/ca.py             # rule bijection, lattice reversibility, ballistic motion, collisions
+python src/ca.py             # rule bijection, lattice reversibility, ballistic motion, collision, AND gate
 python tools/build_ca.py     # ship the block rule as a ternary matrix tile (permutation + 0.5 margin)
 ```
 

src/ca.py

@@ -1,22 +1,20 @@
-"""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.
+"""Reversible Margolus (partitioned) cellular automaton.
+
+One fixed rule is applied to every 2x2 block, alternating the block partition
+between even and odd alignment each step (the Margolus neighborhood). The state
+is the lattice; there is no program counter, register file, or control circuit.
+
+Rule (cells ordered TL,TR,BL,BR): rotate the block 180 degrees, except a pair of
+particles on a diagonal (1001, 0110) swaps to the other diagonal. Both cases are
+involutions and neither maps a state across the diagonal-pair boundary, so the
+rule is a self-inverse permutation of the sixteen block states; the lattice
+update is therefore a bijection and replaying the partition sequence in reverse
+inverts the evolution.
+
+Dynamics are the billiard-ball model's: isolated particles move ballistically on
+diagonals and collisions deflect them reversibly. and_gate() computes AND from a
+collision; ballistic transport plus this collision are the primitives of the
+Fredkin-Toffoli universality construction (Margolus 1984).
 """
 from __future__ import annotations
 from typing import List, Tuple
@@ -162,6 +160,27 @@ def _test_ballistic():
     return ok and steady
 
 
+def and_gate(a: int, b: int, N: int = 4) -> int:
+    """AND from a billiard-ball collision. Input particle A enters at (2,2)
+    moving SE, B at (7,7) moving NW; they meet only when both are present, so
+    the deflected output cell (3,6) is occupied at step 4 iff a and b."""
+    H = W = 12
+    g = [[0] * W for _ in range(H)]
+    if a:
+        g[2][2] = 1
+    if b:
+        g[7][7] = 1
+    return run(g, N)[3][6]
+
+
+def _test_gate():
+    table = {(a, b): and_gate(a, b) for a in (0, 1) for b in (0, 1)}
+    ok = all(table[(a, b)] == (a & b) for a in (0, 1) for b in (0, 1))
+    print(f"  billiard-ball AND at deflected cell (3,6), all 4 inputs: "
+          f"{'OK' if ok else 'FAIL'}  {table}")
+    return ok
+
+
 def _test_collision():
     # Two particles interact (the joint evolution differs from independent
     # motion) and the collision stays reversible: the physics that logic needs.
@@ -202,4 +221,5 @@ if __name__ == "__main__":
     b = _test_reversibility()
     c = _test_ballistic()
     d = _test_collision()
-    print("PASS" if (a and g and b and c and d) else "FAIL")
+    e = _test_gate()
+    print("PASS" if (a and g and b and c and d and e) else "FAIL")

tools/build_ca.py

@@ -1,9 +1,8 @@
-"""Ship the reversible CA's local rule as a ternary matrix tile,
+"""Ship the reversible CA's block 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."""
+ternary matrices with a Heaviside step; the rule is a bijection, so the tile is
+a permutation matrix product with a 0.5 analog margin, and the same tile applied
+to every block of a lattice is one lattice step."""
 from __future__ import annotations
 import os
 import sys