neural_ca: the collision is verified as a reversible interaction gate, not just AND. At step 4 three output cells carry A&B (deflected, (3,6)/(6,3)), A&~B ((6,6)), and ~A&B ((3,3)), checked over all four inputs. Analog robustness sweep on the matrix tile: exact under read noise through sigma 0.10 and conductance mismatch through sigma_G 0.10, matching neural_matrix8. README updated.

README.md

@@ -683,20 +683,21 @@ 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`.
+permutation with a 0.5 analog margin, bit-exact under read noise through
+sigma ~ 0.10 and conductance mismatch through sigma_G ~ 0.10; 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).
+A collision computes logic directly: with input particles at (2,2) and (7,7),
+three output cells at step 4 carry A AND B (the deflected paths (3,6) and (6,3)),
+A AND NOT B ((6,6)), and NOT A AND B ((3,3)), the billiard-ball interaction
+gate, verified over all four inputs. That gate with mirror routing is
+functionally complete (Margolus 1984).
 
 ```bash
-python src/ca.py             # rule bijection, lattice reversibility, ballistic motion, collision, AND gate
+python src/ca.py             # rule bijection, lattice reversibility, ballistic motion, interaction gate
 python tools/build_ca.py     # ship the block rule as a ternary matrix tile (permutation + 0.5 margin)
 ```
 

src/ca.py

@@ -160,24 +160,35 @@ 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."""
+def interaction_gate(a: int, b: int) -> dict:
+    """One billiard-ball collision as a reversible interaction gate. Input
+    particle A enters at (2,2) moving SE and B at (7,7) moving NW; at step 4
+    three output cells carry A&B (the deflected paths), A&~B and ~A&B (the
+    straight-through paths). AND plus routing by mirrors is functionally
+    complete for the billiard-ball construction (Margolus 1984)."""
     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]
+    g = run(g, 4)
+    return {"A_and_B": g[3][6], "A_and_notB": g[6][6], "notA_and_B": g[3][3]}
+
+
+def and_gate(a: int, b: int) -> int:
+    return interaction_gate(a, b)["A_and_B"]
 
 
 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}")
+    ok = True
+    for a in (0, 1):
+        for b in (0, 1):
+            o = interaction_gate(a, b)
+            ok &= (o["A_and_B"] == (a & b) and o["A_and_notB"] == (a & (1 - b))
+                   and o["notA_and_B"] == ((1 - a) & b))
+    print(f"  billiard-ball interaction gate (A&B, A&~B, ~A&B) over all 4 inputs: "
+          f"{'OK' if ok else 'FAIL'}")
     return ok
 
 

tools/build_ca.py

@@ -81,6 +81,25 @@ def main() -> int:
     print(f"  tile is a permutation (16 distinct outputs): {'OK' if perm else 'FAIL'}")
     print(f"  analog noise margin: {margin:.3f} (guarantee 0.5)")
 
+    # analog robustness: the tile must reproduce the rule under read noise and
+    # static conductance mismatch, as neural_matrix8 measures
+    states = torch.stack(vecs)
+    ref = [ca.rule(tuple((s >> k) & 1 for k in (3, 2, 1, 0))) for s in range(16)]
+
+    def outs(machine, **kw):
+        v = machine.step(states, **kw)
+        return [tuple(int(v[i][j]) for j in range(4)) for i in range(v.shape[0])]
+
+    print("  read-noise sweep (exact = tile matches the rule on all 16 states):")
+    for sigma in (0.05, 0.10, 0.15, 0.20):
+        okn = all(outs(mm, analog=True, noise_sigma=sigma,
+                       gen=torch.Generator().manual_seed(s)) == ref for s in range(4))
+        print(f"    sigma={sigma:.2f}: {'exact' if okn else 'errors appear'}")
+    print("  conductance-mismatch sweep:")
+    for sg in (0.05, 0.10, 0.15):
+        okg = outs(mm.perturbed(sg, seed=0), analog=True) == ref
+        print(f"    sigma_G={sg:.2f}: {'exact' if okg else 'errors appear'}")
+
     # the loaded tile, applied to every block, is one whole-lattice CA step
     t = load_file(OUT)
     n = 0