Bit-cascade integer comparators (8/16/32-bit) with ternary weights

build.add_bit_cascade_compare emits an N-bit comparator family using
only weights in {-1, 0, 1}:

per-bit: gt = A AND NOT B, lt = NOT A AND B, eq = XNOR (2 layers)
cascade prefix: eq_prefix[i] = AND of eq[0..i-1]
cascade per-bit: cascade.gt[i] = eq_prefix[i] AND gt[i] (LT analogous)
final OR for GT and LT, AND of all eq for EQ
GE = NOT(LT), LE = NOT(GT) via NOT + identity buffer

add_comparators (8-bit) and add_comparators_nbits (16/32-bit) now both
delegate to this builder. The single-layer 8-bit case (16 weights at
+/-128, +1 bias) and the 32-bit byte-cascade structure (byte-level
+/-128 weights) are removed; all comparator weights across the library
are now ternary by construction.

eval._eval_bit_cascade_compare walks the new structure. _test_comparators
and _test_comparators_nbits were rewritten to use it; legacy paths kept
under _test_comparators_nbits_legacy for old files.

cmd_alu now also drops arithmetic.cmp{N}bit. on rebuild so stale
byte-cascade gates from old seed files don't leak through.

22 of 183 non-ternary weight tensors eliminated by this change. The
remaining 161 are positional comparators inside division stages
(integer 8/16/32-bit and float16/32 mantissa div), float magnitude
comparators, modular arithmetic detection gates, and pattern_recognition
priority encoders -- subsequent passes will bit-cascade those too.

All 18 variants rebuilt; eval_all.py reports 100% fitness on every one.
Test counts increased across the board (e.g. 8-bit small: 6772 -> 7171)
because the bit-cascade exposes more sub-gates for individual checking.

build.py

@@ -769,41 +769,95 @@ def add_priority_encoder_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> N
     add_gate(tensors, f"{prefix}.valid", [1.0] * bits, [-1.0])
 
 
-def add_comparators(tensors: Dict[str, torch.Tensor]) -> None:
-    """Add 8-bit comparator circuits (GT, LT, GE, LE, EQ).
+def add_bit_cascade_compare(
+    tensors: Dict[str, torch.Tensor],
+    cmp_prefix: str,
+    bits: int,
+    out_gt: str,
+    out_lt: str,
+    out_ge: str,
+    out_le: str,
+    out_eq: str,
+) -> None:
+    """Generic ternary-only N-bit comparator.
+
+    Inputs are two N-bit values A and B in MSB-first order. The structure
+    produces unsigned-magnitude GT, LT, GE, LE, EQ outputs using only
+    weights in {-1, 0, 1} and integer biases.
+
+    Per-bit primitives (i = 0 is the MSB):
+      {cmp_prefix}.bit{i}.gt              A[i] AND NOT B[i]   weights [1, -1], bias -1
+      {cmp_prefix}.bit{i}.lt              NOT A[i] AND B[i]   weights [-1, 1], bias -1
+      {cmp_prefix}.bit{i}.eq.layer1.and   A[i] AND B[i]
+      {cmp_prefix}.bit{i}.eq.layer1.nor   NOR(A[i], B[i])
+      {cmp_prefix}.bit{i}.eq              XNOR via OR of layer1 outputs
+
+    Cascade (linear chain from MSB to LSB):
+      {cmp_prefix}.cascade.eq_prefix.bit{i}   AND of eq[0..i-1] (i in 1..N-1)
+      {cmp_prefix}.cascade.gt.bit{i}          eq_prefix[i] AND gt[i]
+      {cmp_prefix}.cascade.lt.bit{i}          eq_prefix[i] AND lt[i]
+
+    Final outputs:
+      out_gt = OR of (gt[0], cascade.gt.bit{1..N-1})
+      out_lt = OR of (lt[0], cascade.lt.bit{1..N-1})
+      out_eq = AND of all eq[i]
+      out_ge = NOT(out_lt)
+      out_le = NOT(out_gt)
+    """
+    for i in range(bits):
+        # per-bit GT: A[i] AND NOT B[i]   ->  H(A - B - 1)
+        add_gate(tensors, f"{cmp_prefix}.bit{i}.gt", [1.0, -1.0], [-1.0])
+        # per-bit LT: NOT A[i] AND B[i]   ->  H(-A + B - 1)
+        add_gate(tensors, f"{cmp_prefix}.bit{i}.lt", [-1.0, 1.0], [-1.0])
+        # per-bit EQ via XNOR = (A AND B) OR (NOR A B)
+        add_gate(tensors, f"{cmp_prefix}.bit{i}.eq.layer1.and", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{cmp_prefix}.bit{i}.eq.layer1.nor", [-1.0, -1.0], [0.0])
+        add_gate(tensors, f"{cmp_prefix}.bit{i}.eq", [1.0, 1.0], [-1.0])
+
+    # eq_prefix[i] = AND of eq[0..i-1], i in 1..N-1
+    for i in range(1, bits):
+        add_gate(
+            tensors,
+            f"{cmp_prefix}.cascade.eq_prefix.bit{i}",
+            [1.0] * i,
+            [-float(i)],
+        )
 
-    Each comparator takes 16 inputs (8 bits from A, 8 bits from B) in MSB-first order.
-    Uses weighted sum comparison on the binary representation.
+    # cascade.gt[i], cascade.lt[i] for i in 1..N-1
+    for i in range(1, bits):
+        add_gate(tensors, f"{cmp_prefix}.cascade.gt.bit{i}", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{cmp_prefix}.cascade.lt.bit{i}", [1.0, 1.0], [-2.0])
 
-    For unsigned comparison of A vs B:
-    - Assign positional weights: bit i has weight 2^(7-i)
-    - A > B: sum(a_i * w_i) > sum(b_i * w_i)
-    - This becomes: sum(a_i * w_i - b_i * w_i) > 0
-    - Or: sum((a_i - b_i) * w_i) > 0
+    # Final OR for GT and LT (N inputs each)
+    add_gate(tensors, out_gt, [1.0] * bits, [-1.0])
+    add_gate(tensors, out_lt, [1.0] * bits, [-1.0])
 
-    Threshold gate: H(sum(x_i * w_i) + b) = 1 if sum >= -b
+    # AND of all eq's for EQ
+    add_gate(tensors, out_eq, [1.0] * bits, [-float(bits)])
 
-    For A > B: weights = [128, 64, 32, 16, 8, 4, 2, 1, -128, -64, -32, -16, -8, -4, -2, -1]
-               bias = -1 (strictly greater, so need sum >= 1)
-    For A >= B: bias = 0 (sum >= 0)
-    For A < B: flip weights, bias = -1
-    For A <= B: flip weights, bias = 0
-    For A == B: need A >= B AND A <= B (two-layer)
-    """
-    pos_weights = [128.0, 64.0, 32.0, 16.0, 8.0, 4.0, 2.0, 1.0]
-    neg_weights = [-128.0, -64.0, -32.0, -16.0, -8.0, -4.0, -2.0, -1.0]
+    # GE = NOT(LT), LE = NOT(GT) -- single-input NOT then identity buffer
+    add_gate(tensors, f"{out_ge}.not_lt", [-1.0], [0.0])
+    add_gate(tensors, out_ge, [1.0], [-1.0])
+    add_gate(tensors, f"{out_le}.not_gt", [-1.0], [0.0])
+    add_gate(tensors, out_le, [1.0], [-1.0])
 
-    gt_weights = pos_weights + neg_weights
-    lt_weights = neg_weights + pos_weights
 
-    add_gate(tensors, "arithmetic.greaterthan8bit", gt_weights, [-1.0])
-    add_gate(tensors, "arithmetic.greaterorequal8bit", gt_weights, [0.0])
-    add_gate(tensors, "arithmetic.lessthan8bit", lt_weights, [-1.0])
-    add_gate(tensors, "arithmetic.lessorequal8bit", lt_weights, [0.0])
+def add_comparators(tensors: Dict[str, torch.Tensor]) -> None:
+    """Add 8-bit comparator circuits (GT, LT, GE, LE, EQ) using bit-cascade.
 
-    add_gate(tensors, "arithmetic.equality8bit.layer1.geq", gt_weights, [0.0])
-    add_gate(tensors, "arithmetic.equality8bit.layer1.leq", lt_weights, [0.0])
-    add_gate(tensors, "arithmetic.equality8bit.layer2", [1.0, 1.0], [-2.0])
+    Inputs are 8 bits of A then 8 bits of B in MSB-first order. The
+    underlying bit-cascade produces only ternary {-1, 0, 1} weights.
+    """
+    add_bit_cascade_compare(
+        tensors,
+        cmp_prefix="arithmetic.cmp8bit",
+        bits=8,
+        out_gt="arithmetic.greaterthan8bit",
+        out_lt="arithmetic.lessthan8bit",
+        out_ge="arithmetic.greaterorequal8bit",
+        out_le="arithmetic.lessorequal8bit",
+        out_eq="arithmetic.equality8bit",
+    )
 
 
 def add_ripple_carry_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> None:
@@ -841,72 +895,20 @@ def add_sub_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> None:
 
 
 def add_comparators_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> None:
-    """Add N-bit comparator circuits (GT, LT, GE, LE, EQ).
+    """Add N-bit comparator circuits (GT, LT, GE, LE, EQ) via bit-cascade.
 
-    For bits <= 16: Use single-layer weighted comparison (float32 safe).
-    For bits > 16: Use cascaded byte-wise comparison to avoid float32 precision loss.
-
-    Cascaded approach compares byte-by-byte from MSB:
-      A > B iff: (A[31:24] > B[31:24]) OR
-                 (A[31:24] == B[31:24] AND A[23:16] > B[23:16]) OR ...
+    All weights are in {-1, 0, 1}. Inputs are A bits then B bits, MSB-first.
     """
-    if bits <= 16:
-        pos_weights = [float(1 << (bits - 1 - i)) for i in range(bits)]
-        neg_weights = [-w for w in pos_weights]
-
-        gt_weights = pos_weights + neg_weights
-        lt_weights = neg_weights + pos_weights
-
-        add_gate(tensors, f"arithmetic.greaterthan{bits}bit", gt_weights, [-1.0])
-        add_gate(tensors, f"arithmetic.greaterorequal{bits}bit", gt_weights, [0.0])
-        add_gate(tensors, f"arithmetic.lessthan{bits}bit", lt_weights, [-1.0])
-        add_gate(tensors, f"arithmetic.lessorequal{bits}bit", lt_weights, [0.0])
-
-        add_gate(tensors, f"arithmetic.equality{bits}bit.layer1.geq", gt_weights, [0.0])
-        add_gate(tensors, f"arithmetic.equality{bits}bit.layer1.leq", lt_weights, [0.0])
-        add_gate(tensors, f"arithmetic.equality{bits}bit.layer2", [1.0, 1.0], [-2.0])
-    else:
-        num_bytes = bits // 8
-        prefix = f"arithmetic.cmp{bits}bit"
-
-        byte_pos_weights = [128.0, 64.0, 32.0, 16.0, 8.0, 4.0, 2.0, 1.0]
-        byte_neg_weights = [-128.0, -64.0, -32.0, -16.0, -8.0, -4.0, -2.0, -1.0]
-        byte_gt_weights = byte_pos_weights + byte_neg_weights
-        byte_lt_weights = byte_neg_weights + byte_pos_weights
-
-        for b in range(num_bytes):
-            add_gate(tensors, f"{prefix}.byte{b}.gt", byte_gt_weights, [-1.0])
-            add_gate(tensors, f"{prefix}.byte{b}.lt", byte_lt_weights, [-1.0])
-            add_gate(tensors, f"{prefix}.byte{b}.eq.geq", byte_gt_weights, [0.0])
-            add_gate(tensors, f"{prefix}.byte{b}.eq.leq", byte_lt_weights, [0.0])
-            add_gate(tensors, f"{prefix}.byte{b}.eq.and", [1.0, 1.0], [-2.0])
-
-        for b in range(num_bytes):
-            if b == 0:
-                add_gate(tensors, f"{prefix}.cascade.gt.stage{b}", [1.0], [-1.0])
-                add_gate(tensors, f"{prefix}.cascade.lt.stage{b}", [1.0], [-1.0])
-            else:
-                eq_weights = [1.0] * b
-                add_gate(tensors, f"{prefix}.cascade.gt.stage{b}.all_eq", eq_weights, [-float(b)])
-                add_gate(tensors, f"{prefix}.cascade.gt.stage{b}.and", [1.0, 1.0], [-2.0])
-                add_gate(tensors, f"{prefix}.cascade.lt.stage{b}.all_eq", eq_weights, [-float(b)])
-                add_gate(tensors, f"{prefix}.cascade.lt.stage{b}.and", [1.0, 1.0], [-2.0])
-
-        or_weights_gt = [1.0] * num_bytes
-        or_weights_lt = [1.0] * num_bytes
-        add_gate(tensors, f"arithmetic.greaterthan{bits}bit", or_weights_gt, [-1.0])
-        add_gate(tensors, f"arithmetic.lessthan{bits}bit", or_weights_lt, [-1.0])
-
-        not_lt_weights = [-1.0]
-        add_gate(tensors, f"arithmetic.greaterorequal{bits}bit.not_lt", not_lt_weights, [0.0])
-        add_gate(tensors, f"arithmetic.greaterorequal{bits}bit", [1.0], [-1.0])
-
-        not_gt_weights = [-1.0]
-        add_gate(tensors, f"arithmetic.lessorequal{bits}bit.not_gt", not_gt_weights, [0.0])
-        add_gate(tensors, f"arithmetic.lessorequal{bits}bit", [1.0], [-1.0])
-
-        eq_all_weights = [1.0] * num_bytes
-        add_gate(tensors, f"arithmetic.equality{bits}bit", eq_all_weights, [-float(num_bytes)])
+    add_bit_cascade_compare(
+        tensors,
+        cmp_prefix=f"arithmetic.cmp{bits}bit",
+        bits=bits,
+        out_gt=f"arithmetic.greaterthan{bits}bit",
+        out_lt=f"arithmetic.lessthan{bits}bit",
+        out_ge=f"arithmetic.greaterorequal{bits}bit",
+        out_le=f"arithmetic.lessorequal{bits}bit",
+        out_eq=f"arithmetic.equality{bits}bit",
+    )
 
 
 def add_mul_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> None:
@@ -2910,6 +2912,7 @@ def cmd_alu(args) -> None:
         "arithmetic.greaterthan8bit.", "arithmetic.lessthan8bit.",
         "arithmetic.greaterorequal8bit.", "arithmetic.lessorequal8bit.",
         "arithmetic.equality8bit.", "arithmetic.add3_8bit.", "arithmetic.expr_add_mul.", "arithmetic.expr_paren.",
+        "arithmetic.cmp8bit.",  # bit-cascade internals (replaces single-layer)
         "combinational.barrelshifter.", "combinational.priorityencoder.",
         "float16.", "float32.",
     ]
@@ -2920,6 +2923,7 @@ def cmd_alu(args) -> None:
             f"arithmetic.sub{bits}bit.", f"arithmetic.greaterthan{bits}bit.",
             f"arithmetic.lessthan{bits}bit.", f"arithmetic.greaterorequal{bits}bit.",
             f"arithmetic.lessorequal{bits}bit.", f"arithmetic.equality{bits}bit.",
+            f"arithmetic.cmp{bits}bit.",  # legacy byte-cascade (32-bit) and new bit-cascade
         ])
 
     print("\nDropping existing ALU extension tensors...")

eval.py

@@ -1636,100 +1636,162 @@ class BatchedFitnessEvaluator:
     # COMPARATORS
     # =========================================================================
 
-    def _test_comparator(self, pop: Dict, name: str, op: Callable[[int, int], bool],
-                         debug: bool) -> Tuple[torch.Tensor, int]:
-        """Test 8-bit comparator."""
+    def _eval_bit_cascade_compare(
+        self,
+        pop: Dict,
+        cmp_prefix: str,
+        out_gt: str,
+        out_lt: str,
+        out_ge: str,
+        out_le: str,
+        out_eq: str,
+        bits: int,
+        a_bits_2d: torch.Tensor,
+        b_bits_2d: torch.Tensor,
+    ) -> Dict[str, torch.Tensor]:
+        """Walk the ternary bit-cascade comparator generated by
+        build.add_bit_cascade_compare. Returns a dict with gt/lt/ge/le/eq each of
+        shape [num_tests, pop_size]. a_bits_2d, b_bits_2d are [num_tests, bits]
+        MSB-first.
+        """
         pop_size = next(iter(pop.values())).shape[0]
-        prefix = f'arithmetic.{name}'
-
-        # Use pre-computed test pairs
-        expected = torch.tensor([1.0 if op(a.item(), b.item()) else 0.0
-                                for a, b in zip(self.comp_a, self.comp_b)],
-                               device=self.device)
-
-        # Convert to bits
-        a_bits = torch.stack([((self.comp_a >> (7 - i)) & 1).float() for i in range(8)], dim=1)
-        b_bits = torch.stack([((self.comp_b >> (7 - i)) & 1).float() for i in range(8)], dim=1)
-        inputs = torch.cat([a_bits, b_bits], dim=1)
-
-        w = pop[f'{prefix}.weight']
-        b = pop[f'{prefix}.bias']
-        out = heaviside(inputs @ w.view(pop_size, -1).T + b.view(pop_size))
-
-        correct = (out == expected.unsqueeze(1)).float().sum(0)
-
-        failures = []
-        if pop_size == 1:
-            for i in range(len(self.comp_a)):
-                if out[i, 0].item() != expected[i].item():
-                    failures.append((
-                        [int(self.comp_a[i].item()), int(self.comp_b[i].item())],
-                        expected[i].item(),
-                        out[i, 0].item()
-                    ))
 
-        self._record(prefix, int(correct[0].item()), len(self.comp_a), failures)
-        if debug:
-            r = self.results[-1]
-            print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
-
-        return correct, len(self.comp_a)
+        # Per-bit gt, lt, eq
+        gt_b: List[torch.Tensor] = []
+        lt_b: List[torch.Tensor] = []
+        eq_b: List[torch.Tensor] = []
+        for i in range(bits):
+            a_i = a_bits_2d[:, i].unsqueeze(1).expand(-1, pop_size)
+            b_i = b_bits_2d[:, i].unsqueeze(1).expand(-1, pop_size)
+            ab = torch.stack([a_i, b_i], dim=-1)
+
+            w = pop[f'{cmp_prefix}.bit{i}.gt.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.bit{i}.gt.bias'].view(pop_size)
+            gt_b.append(heaviside((ab * w).sum(-1) + bb))
+
+            w = pop[f'{cmp_prefix}.bit{i}.lt.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.bit{i}.lt.bias'].view(pop_size)
+            lt_b.append(heaviside((ab * w).sum(-1) + bb))
+
+            w = pop[f'{cmp_prefix}.bit{i}.eq.layer1.and.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.bit{i}.eq.layer1.and.bias'].view(pop_size)
+            h_and = heaviside((ab * w).sum(-1) + bb)
+            w = pop[f'{cmp_prefix}.bit{i}.eq.layer1.nor.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.bit{i}.eq.layer1.nor.bias'].view(pop_size)
+            h_nor = heaviside((ab * w).sum(-1) + bb)
+            hidden = torch.stack([h_and, h_nor], dim=-1)
+            w = pop[f'{cmp_prefix}.bit{i}.eq.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.bit{i}.eq.bias'].view(pop_size)
+            eq_b.append(heaviside((hidden * w).sum(-1) + bb))
+
+        # eq_prefix[i] = AND of eq[0..i-1]
+        eq_pref: List[Optional[torch.Tensor]] = [None]
+        for i in range(1, bits):
+            eq_stack = torch.stack(eq_b[:i], dim=-1)
+            w = pop[f'{cmp_prefix}.cascade.eq_prefix.bit{i}.weight'].view(pop_size, i)
+            bb = pop[f'{cmp_prefix}.cascade.eq_prefix.bit{i}.bias'].view(pop_size)
+            eq_pref.append(heaviside((eq_stack * w).sum(-1) + bb))
+
+        # cascade gt[i], lt[i] = eq_prefix[i] AND gt_b[i] / lt_b[i]
+        casc_gt = [gt_b[0]]
+        casc_lt = [lt_b[0]]
+        for i in range(1, bits):
+            inp = torch.stack([eq_pref[i], gt_b[i]], dim=-1)
+            w = pop[f'{cmp_prefix}.cascade.gt.bit{i}.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.cascade.gt.bit{i}.bias'].view(pop_size)
+            casc_gt.append(heaviside((inp * w).sum(-1) + bb))
+            inp = torch.stack([eq_pref[i], lt_b[i]], dim=-1)
+            w = pop[f'{cmp_prefix}.cascade.lt.bit{i}.weight'].view(pop_size, 2)
+            bb = pop[f'{cmp_prefix}.cascade.lt.bit{i}.bias'].view(pop_size)
+            casc_lt.append(heaviside((inp * w).sum(-1) + bb))
+
+        # Final OR for GT / LT
+        gt_stack = torch.stack(casc_gt, dim=-1)
+        w = pop[f'{out_gt}.weight'].view(pop_size, bits)
+        bb = pop[f'{out_gt}.bias'].view(pop_size)
+        final_gt = heaviside((gt_stack * w).sum(-1) + bb)
+
+        lt_stack = torch.stack(casc_lt, dim=-1)
+        w = pop[f'{out_lt}.weight'].view(pop_size, bits)
+        bb = pop[f'{out_lt}.bias'].view(pop_size)
+        final_lt = heaviside((lt_stack * w).sum(-1) + bb)
+
+        # Final AND for EQ
+        eq_stack = torch.stack(eq_b, dim=-1)
+        w = pop[f'{out_eq}.weight'].view(pop_size, bits)
+        bb = pop[f'{out_eq}.bias'].view(pop_size)
+        final_eq = heaviside((eq_stack * w).sum(-1) + bb)
+
+        # GE = NOT(LT) buffer pair, LE = NOT(GT) buffer pair
+        w = pop[f'{out_ge}.not_lt.weight'].view(pop_size)
+        bb = pop[f'{out_ge}.not_lt.bias'].view(pop_size)
+        not_lt = heaviside(final_lt * w + bb)
+        w = pop[f'{out_ge}.weight'].view(pop_size)
+        bb = pop[f'{out_ge}.bias'].view(pop_size)
+        final_ge = heaviside(not_lt * w + bb)
+
+        w = pop[f'{out_le}.not_gt.weight'].view(pop_size)
+        bb = pop[f'{out_le}.not_gt.bias'].view(pop_size)
+        not_gt = heaviside(final_gt * w + bb)
+        w = pop[f'{out_le}.weight'].view(pop_size)
+        bb = pop[f'{out_le}.bias'].view(pop_size)
+        final_le = heaviside(not_gt * w + bb)
+
+        return {
+            "gt": final_gt, "lt": final_lt, "eq": final_eq,
+            "ge": final_ge, "le": final_le,
+        }
 
     def _test_comparators(self, pop: Dict, debug: bool) -> Tuple[torch.Tensor, int]:
-        """Test all comparators."""
+        """Test 8-bit comparators (bit-cascade)."""
         pop_size = next(iter(pop.values())).shape[0]
         scores = torch.zeros(pop_size, device=self.device)
         total = 0
 
         if debug:
-            print("\n=== COMPARATORS ===")
-
-        comparators = [
-            ('greaterthan8bit', lambda a, b: a > b),
-            ('lessthan8bit', lambda a, b: a < b),
-            ('greaterorequal8bit', lambda a, b: a >= b),
-            ('lessorequal8bit', lambda a, b: a <= b),
-            ('equality8bit', lambda a, b: a == b),
-        ]
-
-        for name, op in comparators:
-            if name == 'equality8bit':
-                continue  # Handle separately as two-layer
-            try:
-                s, t = self._test_comparator(pop, name, op, debug)
-                scores += s
-                total += t
-            except KeyError:
-                pass  # Circuit not present
+            print("\n=== COMPARATORS (8-bit bit-cascade) ===")
 
-        # Two-layer equality circuit
+        bits = 8
+        a_bits = torch.stack([((self.comp_a >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
+        b_bits = torch.stack([((self.comp_b >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
         try:
-            prefix = 'arithmetic.equality8bit'
-            expected = torch.tensor([1.0 if a.item() == b.item() else 0.0
-                                    for a, b in zip(self.comp_a, self.comp_b)],
-                                   device=self.device)
-
-            a_bits = torch.stack([((self.comp_a >> (7 - i)) & 1).float() for i in range(8)], dim=1)
-            b_bits = torch.stack([((self.comp_b >> (7 - i)) & 1).float() for i in range(8)], dim=1)
-            inputs = torch.cat([a_bits, b_bits], dim=1)
-
-            # Layer 1: geq and leq
-            w_geq = pop[f'{prefix}.layer1.geq.weight']
-            b_geq = pop[f'{prefix}.layer1.geq.bias']
-            w_leq = pop[f'{prefix}.layer1.leq.weight']
-            b_leq = pop[f'{prefix}.layer1.leq.bias']
-
-            h_geq = heaviside(inputs @ w_geq.view(pop_size, -1).T + b_geq.view(pop_size))
-            h_leq = heaviside(inputs @ w_leq.view(pop_size, -1).T + b_leq.view(pop_size))
-            hidden = torch.stack([h_geq, h_leq], dim=-1)  # [num_tests, pop_size, 2]
-
-            # Layer 2: AND
-            w2 = pop[f'{prefix}.layer2.weight']
-            b2 = pop[f'{prefix}.layer2.bias']
-            out = heaviside((hidden * w2.view(pop_size, 1, 2)).sum(-1) + b2.view(pop_size))
-
+            outs = self._eval_bit_cascade_compare(
+                pop,
+                f"arithmetic.cmp{bits}bit",
+                f"arithmetic.greaterthan{bits}bit",
+                f"arithmetic.lessthan{bits}bit",
+                f"arithmetic.greaterorequal{bits}bit",
+                f"arithmetic.lessorequal{bits}bit",
+                f"arithmetic.equality{bits}bit",
+                bits,
+                a_bits,
+                b_bits,
+            )
+        except KeyError:
+            return scores, total
+
+        for kind, op in [
+            ("gt", lambda a, b: a > b),
+            ("lt", lambda a, b: a < b),
+            ("ge", lambda a, b: a >= b),
+            ("le", lambda a, b: a <= b),
+            ("eq", lambda a, b: a == b),
+        ]:
+            expected = torch.tensor(
+                [1.0 if op(a.item(), b.item()) else 0.0 for a, b in zip(self.comp_a, self.comp_b)],
+                device=self.device,
+            )
+            out = outs[kind]
             correct = (out == expected.unsqueeze(1)).float().sum(0)
-
+            scores += correct
+            total += len(self.comp_a)
+            name_map = {
+                "gt": f"arithmetic.greaterthan{bits}bit",
+                "lt": f"arithmetic.lessthan{bits}bit",
+                "ge": f"arithmetic.greaterorequal{bits}bit",
+                "le": f"arithmetic.lessorequal{bits}bit",
+                "eq": f"arithmetic.equality{bits}bit",
+            }
             failures = []
             if pop_size == 1:
                 for i in range(len(self.comp_a)):
@@ -1737,28 +1799,22 @@ class BatchedFitnessEvaluator:
                         failures.append((
                             [int(self.comp_a[i].item()), int(self.comp_b[i].item())],
                             expected[i].item(),
-                            out[i, 0].item()
+                            out[i, 0].item(),
                         ))
-
-            self._record(prefix, int(correct[0].item()), len(self.comp_a), failures)
+            self._record(name_map[kind], int(correct[0].item()), len(self.comp_a), failures)
             if debug:
                 r = self.results[-1]
                 print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
-            scores += correct
-            total += len(self.comp_a)
-        except KeyError:
-            pass
-
         return scores, total
 
     def _test_comparators_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
-        """Test N-bit comparator circuits (GT, LT, GE, LE, EQ)."""
+        """Test N-bit comparator circuits (GT, LT, GE, LE, EQ) via bit-cascade."""
         pop_size = next(iter(pop.values())).shape[0]
         scores = torch.zeros(pop_size, device=self.device)
         total = 0
 
         if debug:
-            print(f"\n=== {bits}-BIT COMPARATORS ===")
+            print(f"\n=== {bits}-BIT COMPARATORS (bit-cascade) ===")
 
         if bits == 32:
             comp_a = self.comp32_a
@@ -1771,7 +1827,80 @@ class BatchedFitnessEvaluator:
             comp_b = self.comp_b
 
         num_tests = len(comp_a)
+        a_bits = torch.stack([((comp_a >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
+        b_bits = torch.stack([((comp_b >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
 
+        try:
+            outs = self._eval_bit_cascade_compare(
+                pop,
+                f"arithmetic.cmp{bits}bit",
+                f"arithmetic.greaterthan{bits}bit",
+                f"arithmetic.lessthan{bits}bit",
+                f"arithmetic.greaterorequal{bits}bit",
+                f"arithmetic.lessorequal{bits}bit",
+                f"arithmetic.equality{bits}bit",
+                bits,
+                a_bits,
+                b_bits,
+            )
+        except KeyError:
+            return scores, total
+
+        for kind, op in [
+            ("gt", lambda a, b: a > b),
+            ("lt", lambda a, b: a < b),
+            ("ge", lambda a, b: a >= b),
+            ("le", lambda a, b: a <= b),
+            ("eq", lambda a, b: a == b),
+        ]:
+            expected = torch.tensor(
+                [1.0 if op(a.item(), b.item()) else 0.0 for a, b in zip(comp_a, comp_b)],
+                device=self.device,
+            )
+            out = outs[kind]
+            correct = (out == expected.unsqueeze(1)).float().sum(0)
+            scores += correct
+            total += num_tests
+            name_map = {
+                "gt": f"arithmetic.greaterthan{bits}bit",
+                "lt": f"arithmetic.lessthan{bits}bit",
+                "ge": f"arithmetic.greaterorequal{bits}bit",
+                "le": f"arithmetic.lessorequal{bits}bit",
+                "eq": f"arithmetic.equality{bits}bit",
+            }
+            failures = []
+            if pop_size == 1:
+                for i in range(num_tests):
+                    if out[i, 0].item() != expected[i].item():
+                        failures.append((
+                            [int(comp_a[i].item()), int(comp_b[i].item())],
+                            expected[i].item(),
+                            out[i, 0].item(),
+                        ))
+            self._record(name_map[kind], int(correct[0].item()), num_tests, failures)
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+
+        return scores, total
+
+    # Legacy single-layer/byte-cascade path retained for backwards-compat with
+    # variants built before the bit-cascade migration. Unused on freshly-built
+    # variants but kept to avoid surprises if someone loads an older file.
+    def _test_comparators_nbits_legacy(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
+        pop_size = next(iter(pop.values())).shape[0]
+        scores = torch.zeros(pop_size, device=self.device)
+        total = 0
+        if bits == 32:
+            comp_a = self.comp32_a
+            comp_b = self.comp32_b
+        elif bits == 16:
+            comp_a = self.comp_a.clamp(0, 65535)
+            comp_b = self.comp_b.clamp(0, 65535)
+        else:
+            comp_a = self.comp_a
+            comp_b = self.comp_b
+        num_tests = len(comp_a)
         if bits <= 16:
             a_bits = torch.stack([((comp_a >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
             b_bits = torch.stack([((comp_b >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)

neural_computer.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e9c7424d5643c17ac22bee3930d85976e68b395ae45b146f2bb61318aff38c9f
-size 21777962
+oid sha256:67c1d45eebfde84f4a82fc272ca94b80f23007a69f6d26c120fce62b86eb8b3c
+size 21787023

variants/neural_alu16.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:493f6f679b78e0d3d15a187dcd9a733b9bd8f51b8c5f4065ff68d3ea2aa351f6
-size 11474021
+oid sha256:c2456dd03f42ff0f8a268ad865e326ee5ea0506987a21e08b77d2bc3fafde970
+size 13852411

variants/neural_alu32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a5907e430443b0deb48aa666b15da6ac6e57006367868282aac6dcbe19d28bde
-size 13258660
+oid sha256:5470a8ea7b8d0fe2cfb416f8f12b357b59d4cc6f439219080089db14b18d8ea0
+size 13267721

variants/neural_alu8.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:136684d2ebdd3f54c73dccc2794e7e09bc265c670a0660ba03093a1386478582
-size 10688501
+oid sha256:634a5e8bcb0d4daef76bafc7337187ec7de0e4fd75095020d06fcd6381d78180
+size 13029504

variants/neural_computer16.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9d9ccd2154b44ece7b39ed37c03149ab38f7d840c24d3296c8b427e1217ae2f3
-size 19974899
+oid sha256:c33ef0e17aee7ceb7f19e5675a4f3f873e48e94a67b35fcb549ddcec60f04bdf
+size 22353297

variants/neural_computer16_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5dc5fcb06f90d70173d26556f7ab8105f55c0f8be479f742a1c4d12668cc8116
-size 12163635
+oid sha256:34127e23065b24b0c27b0ae485531f4c174dedebfe7cf399dc9fd2ef765b03a1
+size 14542033

variants/neural_computer16_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:254c05ec2b2e9aac83eb1944d711db20202f26baa5291a5e9bd020e1ed3c713c
-size 11560795
+oid sha256:58058a73c9b0082e8bfbbeef816f971181936e7992ec2213d4657e54e863f967
+size 13939193

variants/neural_computer16_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:370b35f3b1c4a290bfbb64fdfce824259348def722decfaf7f22816f0d3fcc68
-size 11641499
+oid sha256:cb1a44b57d7b78f5df0f12d48343514eb480f625bcad90bb73b757df62157c72
+size 14019889

variants/neural_computer16_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bc54a3aa13383f738e6f2109b96df9cfa7e6bd6869d5c5aa08422c3af523e383
-size 11760339
+oid sha256:de94a6123e7c785adf69054da8d3d54e90cd9c76034a7439244b868c72485c61
+size 14138753

variants/neural_computer32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:313594c493c124733f70b81a73813eb7e242143df2dc3c9b800fa7f1de57dc3b
-size 21777962
+oid sha256:67c1d45eebfde84f4a82fc272ca94b80f23007a69f6d26c120fce62b86eb8b3c
+size 21787023

variants/neural_computer32_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:836ea61f879ead37a5274edb0346ad50af92b99451555a4cc94c11bf65c237bf
-size 13966690
+oid sha256:cd1294e256be584333fb1969b8130e7a0613b15352ef082be9fa318048548b09
+size 13975735

variants/neural_computer32_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e6443f13914c22775003fda952bad6bec7638efadde620e4e094c66d2268e72f
-size 13363858
+oid sha256:e6d3191aee7c7420989701f80d3a4ab675655790e8ce05229d1a6526a09887e7
+size 13372895

variants/neural_computer32_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f24b2425ee50bf65746714ece769b0ddca32f13c29641a2350c9686a4c187289
-size 13444554
+oid sha256:d6d56828f2884b6fe510c4a53030c934e0d1097fa8092c7e15a775b0676c5d55
+size 13453599

variants/neural_computer32_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6d037affb4b59c0c2f0c8814fe2fc75b78e2508068b520c01714e0e4f82447ca
-size 13563410
+oid sha256:729c94a95ead7b34529281072f290bbd289d2b4cdae4e48bbe694f881729dbed
+size 13572439

variants/neural_computer8.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4c25ab253d41866fd627a63bb1d6350c5869f4f6f86dd04e3773fab63595d277
-size 19180203
+oid sha256:cfb9886cf5aa965c83c694cd6f9190ccbd33556a31e67af2ddff6adee39330ab
+size 21521230

variants/neural_computer8_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ea0532e900fad00d62c3c01f9ee8a820f0504e71857c18c4b743499f02b3b1b3
-size 11368939
+oid sha256:b64964bb91266f3a3bb5b8033e69d2a9fabc97b7800865143432fa473f89d3f7
+size 13709942

variants/neural_computer8_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e0f47640d477e167094e90647fdbcb2b9d5b63337f3394b3b5cd0e94229496c9
-size 10766099
+oid sha256:50c7526bf822e84c6a4bd1bd46ea221bb7fc91c027f109d8cd53ebad2a1c9385
+size 13107102

variants/neural_computer8_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fd4d75e83a351b2609c3bc65cd90668228f490ea83c9fb93d86c9b6fbde5ab72
-size 10846803
+oid sha256:0d8dedea26432f64b614854b7b8df3da01b756936dde10cff7eaca25b589e9a5
+size 13187790

variants/neural_computer8_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:eaba41825a68678021fafeced6c21b49b602117ae091ea91744190c2301e8088
-size 10965643
+oid sha256:3911afed70ae0f6d1c47c9ccd0aaf9e5a70dc79031157aba0469e4c4481af9f8
+size 13306646