Update play.py and eval.py to current bit-cascade comparator/mod-5 layout

play.py: alu_compare and mod5 still called legacy gate names from before
the comparators and modular detectors were bit-cascaded. CMP demo crashed
on a 16-vs-8 input shape mismatch; mod-5 demo crashed on a missing
modular.mod5.layer3.or.weight key. Both now walk the current gate family
(arithmetic.cmp8bit.* per-bit gt/lt/eq + cascade.eq_prefix + cascade.gt/lt
+ final OR/AND; modular.mod5.eq.k{val}.bit{i}.match + .all + top OR).

eval.py: _test_integration's add+compare and sub+conditional sub-tests
called pop['arithmetic.{greater,less}than8bit.weight'].view(pop_size, 16)
against the current 8-element OR-tree weight tensor, raising RuntimeError
that was caught and silently SKIPped. Added _pop_cmp8bit helper that
drives the bit-cascade comparator across the population and rewrote both
sub-tests to use it. Wired _test_integration into evaluate(); previously
defined but never called. Test count: 6,364 -> 6,379 on the ALU variants
(+15 integration cases), all passing at fit=1.0000.

eval.py

@@ -4253,6 +4253,60 @@ class BatchedFitnessEvaluator:
     # INTEGRATION TESTS (Multi-circuit chains)
     # =========================================================================
 
+    def _pop_cmp8bit(self, pop: Dict, pop_size: int,
+                     a_bits: torch.Tensor, b_bits: torch.Tensor,
+                     kind: str) -> torch.Tensor:
+        """Drive the bit-cascade comparator (cmp8bit) over a population.
+
+        Returns a (pop_size,) tensor of heaviside outputs for the requested
+        comparison kind ('gt' | 'lt' | 'eq'). Bit 0 is MSB.
+        """
+        def apply(name: str, inp: torch.Tensor, fan_in: int) -> torch.Tensor:
+            w = pop[f'{name}.weight'].view(pop_size, fan_in)
+            b = pop[f'{name}.bias'].view(pop_size)
+            return heaviside((inp * w).sum(-1) + b)
+
+        # Per-bit primitives.
+        bit_gt, bit_lt, bit_eq = [], [], []
+        for i in range(8):
+            ab = torch.stack([a_bits[i], b_bits[i]])
+            bit_gt.append(apply(f'arithmetic.cmp8bit.bit{i}.gt', ab, 2))
+            bit_lt.append(apply(f'arithmetic.cmp8bit.bit{i}.lt', ab, 2))
+            eq_and = apply(f'arithmetic.cmp8bit.bit{i}.eq.layer1.and', ab, 2)
+            eq_nor = apply(f'arithmetic.cmp8bit.bit{i}.eq.layer1.nor', ab, 2)
+            eq_in = torch.stack([eq_and, eq_nor], dim=-1)
+            w = pop[f'arithmetic.cmp8bit.bit{i}.eq.weight'].view(pop_size, 2)
+            b = pop[f'arithmetic.cmp8bit.bit{i}.eq.bias'].view(pop_size)
+            bit_eq.append(heaviside((eq_in * w).sum(-1) + b))
+
+        # Cascade.
+        cas_gt = [bit_gt[0]]
+        cas_lt = [bit_lt[0]]
+        for i in range(1, 8):
+            eq_pref_in = torch.stack(bit_eq[:i], dim=-1)
+            w_pref = pop[f'arithmetic.cmp8bit.cascade.eq_prefix.bit{i}.weight'].view(pop_size, i)
+            b_pref = pop[f'arithmetic.cmp8bit.cascade.eq_prefix.bit{i}.bias'].view(pop_size)
+            eq_pref = heaviside((eq_pref_in * w_pref).sum(-1) + b_pref)
+            cas_in = torch.stack([eq_pref, bit_gt[i]], dim=-1)
+            w_g = pop[f'arithmetic.cmp8bit.cascade.gt.bit{i}.weight'].view(pop_size, 2)
+            b_g = pop[f'arithmetic.cmp8bit.cascade.gt.bit{i}.bias'].view(pop_size)
+            cas_gt.append(heaviside((cas_in * w_g).sum(-1) + b_g))
+            cas_in_lt = torch.stack([eq_pref, bit_lt[i]], dim=-1)
+            w_l = pop[f'arithmetic.cmp8bit.cascade.lt.bit{i}.weight'].view(pop_size, 2)
+            b_l = pop[f'arithmetic.cmp8bit.cascade.lt.bit{i}.bias'].view(pop_size)
+            cas_lt.append(heaviside((cas_in_lt * w_l).sum(-1) + b_l))
+
+        if kind == 'gt':
+            inp = torch.stack(cas_gt, dim=-1)
+            return apply('arithmetic.greaterthan8bit', inp, 8)
+        if kind == 'lt':
+            inp = torch.stack(cas_lt, dim=-1)
+            return apply('arithmetic.lessthan8bit', inp, 8)
+        if kind == 'eq':
+            inp = torch.stack(bit_eq, dim=-1)
+            return apply('arithmetic.equality8bit', inp, 8)
+        raise ValueError(kind)
+
     def _test_integration(self, pop: Dict, debug: bool) -> Tuple[torch.Tensor, int]:
         """Test complex operations that chain multiple circuit families."""
         pop_size = next(iter(pop.values())).shape[0]
@@ -4279,11 +4333,8 @@ class BatchedFitnessEvaluator:
                 c_bits = torch.tensor([((c >> (7 - i)) & 1) for i in range(8)],
                                      device=self.device, dtype=torch.float32)
 
-                # Use comparator
-                w = pop['arithmetic.greaterthan8bit.weight'].view(pop_size, 16)
-                bias = pop['arithmetic.greaterthan8bit.bias'].view(pop_size)
-                inp = torch.cat([sum_bits, c_bits])
-                out = heaviside((inp * w).sum(-1) + bias)
+                # Drive sum_bits vs c_bits through the bit-cascade comparator.
+                out = self._pop_cmp8bit(pop, pop_size, sum_bits, c_bits, 'gt')
                 correct = (out == expected).float()
                 op_scores += correct
                 op_total += 1
@@ -4407,11 +4458,8 @@ class BatchedFitnessEvaluator:
                 b_bits = torch.tensor([((b >> (7 - i)) & 1) for i in range(8)],
                                      device=self.device, dtype=torch.float32)
 
-                # Check LT comparator
-                w = pop['arithmetic.lessthan8bit.weight'].view(pop_size, 16)
-                bias = pop['arithmetic.lessthan8bit.bias'].view(pop_size)
-                inp = torch.cat([a_bits, b_bits])
-                lt_out = heaviside((inp * w).sum(-1) + bias)
+                # Drive a_bits vs b_bits through the bit-cascade LT comparator.
+                lt_out = self._pop_cmp8bit(pop, pop_size, a_bits, b_bits, 'lt')
 
                 correct = (lt_out[0].item() == float(is_negative))
                 op_scores += float(correct)
@@ -4734,6 +4782,15 @@ class BatchedFitnessEvaluator:
                 total_tests += t
                 self.category_scores['float32_cmp'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
 
+        # Cross-family integration tests (chain ripple-carry, comparator,
+        # modular, shifts, subtractor). Each test is internally guarded with
+        # try/except, so unsupported variants silently skip individual tests.
+        if 'arithmetic.cmp8bit.bit0.gt.weight' in population:
+            s, t = self._test_integration(population, debug)
+            scores += s
+            total_tests += t
+            self.category_scores['integration'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
+
         self.total_tests = total_tests
 
         if debug:

play.py

@@ -145,12 +145,30 @@ def main() -> int:
         return bits_msb_to_int(list(reversed(diff_lsb))), carry
 
     def alu_compare(a, b, kind):
-        inp = int_to_bits_msb(a, 8) + int_to_bits_msb(b, 8)
+        # Walks the bit-cascade comparator family: per-bit gt/lt/eq, cascaded
+        # eq_prefix, cascade.gt/lt, and the final OR/AND gates. Bit 0 is MSB.
+        a_msb = int_to_bits_msb(a, 8)
+        b_msb = int_to_bits_msb(b, 8)
+        bit_gt = [gate(f"arithmetic.cmp8bit.bit{i}.gt", [a_msb[i], b_msb[i]]) for i in range(8)]
+        bit_lt = [gate(f"arithmetic.cmp8bit.bit{i}.lt", [a_msb[i], b_msb[i]]) for i in range(8)]
+        bit_eq = []
+        for i in range(8):
+            eq_and = gate(f"arithmetic.cmp8bit.bit{i}.eq.layer1.and", [a_msb[i], b_msb[i]])
+            eq_nor = gate(f"arithmetic.cmp8bit.bit{i}.eq.layer1.nor", [a_msb[i], b_msb[i]])
+            bit_eq.append(gate(f"arithmetic.cmp8bit.bit{i}.eq", [eq_and, eq_nor]))
+        cas_gt = [bit_gt[0]]
+        cas_lt = [bit_lt[0]]
+        for i in range(1, 8):
+            eq_pref = gate(f"arithmetic.cmp8bit.cascade.eq_prefix.bit{i}", bit_eq[:i])
+            cas_gt.append(gate(f"arithmetic.cmp8bit.cascade.gt.bit{i}", [eq_pref, bit_gt[i]]))
+            cas_lt.append(gate(f"arithmetic.cmp8bit.cascade.lt.bit{i}", [eq_pref, bit_lt[i]]))
+        if kind == "greaterthan":
+            return gate("arithmetic.greaterthan8bit", cas_gt)
+        if kind == "lessthan":
+            return gate("arithmetic.lessthan8bit", cas_lt)
         if kind == "eq":
-            h_geq = gate("arithmetic.equality8bit.layer1.geq", inp)
-            h_leq = gate("arithmetic.equality8bit.layer1.leq", inp)
-            return gate("arithmetic.equality8bit.layer2", [h_geq, h_leq])
-        return gate(f"arithmetic.{kind}8bit", inp)
+            return gate("arithmetic.equality8bit", bit_eq)
+        raise ValueError(kind)
 
     def alu_mul(a, b):
         a_bits = int_to_bits_msb(a, 8)
@@ -197,16 +215,16 @@ def main() -> int:
     print("=" * 64)
 
     def mod5(v):
+        # Per-multiple-of-5 match (k0, k5, ..., k255): each k has 8 single-input
+        # "bit{i}.match" gates that fire when bit i of v matches bit i of k,
+        # ANDed by ".all". Final ".weight" ORs all 52 "all" outputs.
         bits = int_to_bits_msb(v, 8)
-        n = 0
-        while f"modular.mod5.layer1.geq{n}.weight" in T:
-            n += 1
-        eqs = []
-        for i in range(n):
-            h_geq = gate(f"modular.mod5.layer1.geq{i}", bits)
-            h_leq = gate(f"modular.mod5.layer1.leq{i}", bits)
-            eqs.append(gate(f"modular.mod5.layer2.eq{i}", [h_geq, h_leq]))
-        return gate("modular.mod5.layer3.or", eqs)
+        ks = [k for k in range(256) if k % 5 == 0]
+        alls = []
+        for k in ks:
+            matches = [gate(f"modular.mod5.eq.k{k}.bit{i}.match", [bits[i]]) for i in range(8)]
+            alls.append(gate(f"modular.mod5.eq.k{k}.all", matches))
+        return gate("modular.mod5", alls)
 
     hits = [v for v in range(256) if mod5(v)]
     print(f"  v in [0,255] with mod5(v)==1: {len(hits)} hits, first 12: {hits[:12]}")