neural_reversible: analog read-noise and conductance-mismatch sweeps on the reversible matrix stack. The permutation stays bit-exact through read noise sigma ~ 0.10 (errors at 0.15, where the 0.5-margin error model predicts) and conductance mismatch sigma_G ~ 0.10, the same tolerances neural_matrix8 measures; README states the confirmed tolerance rather than implying it.

README.md

@@ -643,7 +643,9 @@ matrix stack `neural_matrix8` uses: the 4-bit adder becomes 39 ternary matrices
 with a Heaviside step, its composed transition is a verified permutation of the
 state space, and every pre-activation clears the analog threshold by the same
 0.5 margin, so the crossbar realization is bit-exact and information-theoretically
-lossless. Turning that into measured energy below the Landauer bound requires
+lossless, holding under injected read noise through sigma ~ 0.10 and static
+conductance mismatch through sigma_G ~ 0.10, the same tolerances `neural_matrix8`
+measures. Turning that into measured energy below the Landauer bound requires
 adiabatic drive of the crossbar, which is the physical frontier; the logical
 reversibility and its lossless matrix realization are proven here.
 

tools/reversible_matrix.py

@@ -40,29 +40,52 @@ def adder_net(width: int):
     return net, inputs, list(cur), n, a_bits, b_bits, carry
 
 
+def _refs(n, a_bits, b_bits, carry):
+    out = []
+    for x in range(1 << n):
+        reg = [(x >> i) & 1 for i in range(n)]
+        rv._apply(reg, rv._adder_ops(a_bits, b_bits, carry))
+        out.append(sum(reg[i] << i for i in range(n)))
+    return torch.tensor(out)
+
+
+def _outputs(mm, states, n, **step_kw):
+    v = mm.step(states.clone(), **step_kw)
+    bits = (v >= 0.5).to(torch.int64)
+    weights = torch.tensor([1 << i for i in range(n)])
+    return (bits * weights).sum(dim=1)
+
+
+def analog_sweep(mm, states, refs, n):
+    """The permutation must survive analog imperfection. Read noise is injected
+    per matrix-vector product; conductance mismatch is a fixed per-device
+    perturbation of the ternary weights."""
+    print("  read-noise sweep (bit-exact = all 512 outputs still match, 4 trials):")
+    for sigma in (0.05, 0.10, 0.15, 0.20):
+        ok = all((_outputs(mm, states, n, analog=True, noise_sigma=sigma,
+                           gen=torch.Generator().manual_seed(s)) == refs).all()
+                 for s in range(4))
+        print(f"    sigma={sigma:.2f}: {'bit-exact' if ok else 'errors appear'}")
+    print("  conductance-mismatch sweep (fixed per-device weight perturbation):")
+    for sg in (0.05, 0.10, 0.15):
+        ok = (_outputs(mm.perturbed(sg, seed=0), states, n, analog=True) == refs).all()
+        print(f"    sigma_G={sg:.2f}: {'bit-exact' if ok else 'errors appear'}")
+
+
 def main() -> int:
     width = 4
     net, inputs, outputs, n, a_bits, b_bits, carry = adder_net(width)
     layers, info = compile_net(net, inputs, outputs)
     mm = MatrixMachine(layers)
 
-    seen = set()
-    bad = 0
-    vecs = []
-    for x in range(1 << n):
-        reg = [(x >> i) & 1 for i in range(n)]
-        v = torch.tensor([[float(b) for b in reg]])
-        out = mm.step(v)[0]
-        y = sum(int(out[i].item()) << i for i in range(n))
-        seen.add(y)
-        ref = list(reg)
-        rv._apply(ref, rv._adder_ops(a_bits, b_bits, carry))
-        if y != sum(ref[i] << i for i in range(n)):
-            bad += 1
-        vecs.append(v[0])
-
-    perm = len(seen) == (1 << n)
-    margin = mm.min_margin(torch.stack(vecs[:256]))
+    states = torch.stack([torch.tensor([float((x >> i) & 1) for i in range(n)])
+                          for x in range(1 << n)])
+    refs = _refs(n, a_bits, b_bits, carry)
+    got = _outputs(mm, states, n)
+    bad = int((got != refs).sum())
+    perm = len(set(got.tolist())) == (1 << n)
+    margin = mm.min_margin(states[:256])
+
     print(f"reversible {width}-bit adder as a ternary matrix stack")
     print(f"  layers={info['layers']}  gates={info['gates']}  "
           f"max_width={info['max_width']}  total_weights={info['total_weights']}")
@@ -70,6 +93,7 @@ def main() -> int:
     print(f"  matches the gate circuit over all {1 << n} inputs: {'OK' if bad == 0 else f'FAIL({bad})'}")
     print(f"  composed transition is a permutation of the state space: {'OK' if perm else 'FAIL'}")
     print(f"  analog noise margin, all layers: {margin:.3f} (guarantee 0.5)")
+    analog_sweep(mm, states, refs, n)
     ok = bad == 0 and perm and abs(margin - 0.5) < 1e-6
     print("PASS" if ok else "FAIL")
     return 0 if ok else 1