Add 32-bit arithmetic support with cascaded byte comparison

build.py changes:
- Add 'small' memory profile (1KB, 10-bit addresses) for 32-bit scratch space
- Add --bits flag supporting 8/16/32-bit ALU generation
- Add N-bit circuit generators: ripple carry adder, subtractor, comparators,
multiplier, divider, bitwise ops, shifts, INC/DEC, NEG
- Implement cascaded byte-wise comparison for 32-bit to avoid float32
precision loss (2^31 exceeds 24-bit mantissa). Compares byte-by-byte
from MSB using 8-bit comparators chained with AND/OR logic.

eval.py changes:
- Add 32-bit test data (strategic sampling of edge cases)
- Add _test_comparators_nbits with cascaded evaluation for bits > 16
- Add _test_subtractor_nbits, _test_bitwise_nbits, _test_shifts_nbits
- Add _test_inc_dec_nbits, _test_neg_nbits with correct LSB-first indexing
- Fix bit indexing bug: circuits use bit0=LSB, not MSB
- Make _test_memory dynamic: reads actual memory size from manifest
- Make _test_manifest flexible: only checks fixed values, validates
variable values (memory_bytes, pc_width) as non-negative

neural_alu32.safetensors:
- New 32-bit model with 1KB memory (202K params vs 8.3M for 64KB)
- All 6,973 tests passing at 100%

Verified 32-bit arithmetic:
1000 + 2000 = 3000
1000000 + 2345678 = 3345678
0xDEAD0000 + 0xBEEF = 0xDEADBEEF
4294967295 + 1 = 0 (correct overflow)

build.py

@@ -714,23 +714,70 @@ 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).
 
-    Uses weighted sum comparison extended to N bits.
-    For N=32: weights are 2^31, 2^30, ..., 2^0 for A, negated for B.
+    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 ...
     """
-    pos_weights = [float(1 << (bits - 1 - i)) for i in range(bits)]
-    neg_weights = [-w for w in pos_weights]
+    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
+        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.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])
+        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)])
 
 
 def add_mul_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> None:

eval.py

@@ -1745,88 +1745,551 @@ class BatchedFitnessEvaluator:
             comp_a = self.comp_a
             comp_b = self.comp_b
 
-        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)
-        inputs = torch.cat([a_bits, b_bits], dim=1)
+        num_tests = len(comp_a)
 
-        comparators = [
-            (f'arithmetic.greaterthan{bits}bit', lambda a, b: a > b),
-            (f'arithmetic.greaterorequal{bits}bit', lambda a, b: a >= b),
-            (f'arithmetic.lessthan{bits}bit', lambda a, b: a < b),
-            (f'arithmetic.lessorequal{bits}bit', lambda a, b: a <= b),
-        ]
+        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)
+            inputs = torch.cat([a_bits, b_bits], dim=1)
 
-        for name, op in comparators:
+            comparators = [
+                (f'arithmetic.greaterthan{bits}bit', lambda a, b: a > b),
+                (f'arithmetic.greaterorequal{bits}bit', lambda a, b: a >= b),
+                (f'arithmetic.lessthan{bits}bit', lambda a, b: a < b),
+                (f'arithmetic.lessorequal{bits}bit', lambda a, b: a <= b),
+            ]
+
+            for name, op in comparators:
+                try:
+                    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)
+                    w = pop[f'{name}.weight']
+                    b = pop[f'{name}.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(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, 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'}")
+                    scores += correct
+                    total += num_tests
+                except KeyError:
+                    pass
+
+            prefix = f'arithmetic.equality{bits}bit'
             try:
-                expected = torch.tensor([1.0 if op(a.item(), b.item()) else 0.0
+                expected = torch.tensor([1.0 if a.item() == b.item() else 0.0
                                         for a, b in zip(comp_a, comp_b)], device=self.device)
-
-                w = pop[f'{name}.weight']
-                b = pop[f'{name}.bias']
-                out = heaviside(inputs @ w.view(pop_size, -1).T + b.view(pop_size))
-
+                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)
+                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))
                 correct = (out == expected.unsqueeze(1)).float().sum(0)
-
                 failures = []
                 if pop_size == 1:
-                    for i in range(len(comp_a)):
+                    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, int(correct[0].item()), len(comp_a), failures)
+                            failures.append(([int(comp_a[i].item()), int(comp_b[i].item())],
+                                            expected[i].item(), out[i, 0].item()))
+                self._record(prefix, 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'}")
                 scores += correct
-                total += len(comp_a)
+                total += num_tests
             except KeyError:
                 pass
+        else:
+            num_bytes = bits // 8
+            prefix = f"arithmetic.cmp{bits}bit"
+
+            byte_gt = []
+            byte_lt = []
+            byte_eq = []
+
+            for b in range(num_bytes):
+                start_bit = b * 8
+                a_byte = torch.stack([((comp_a >> (bits - 1 - start_bit - i)) & 1).float() for i in range(8)], dim=1)
+                b_byte = torch.stack([((comp_b >> (bits - 1 - start_bit - i)) & 1).float() for i in range(8)], dim=1)
+                byte_input = torch.cat([a_byte, b_byte], dim=1)
+
+                w_gt = pop[f'{prefix}.byte{b}.gt.weight'].view(pop_size, -1)
+                b_gt = pop[f'{prefix}.byte{b}.gt.bias'].view(pop_size)
+                byte_gt.append(heaviside(byte_input @ w_gt.T + b_gt))
+
+                w_lt = pop[f'{prefix}.byte{b}.lt.weight'].view(pop_size, -1)
+                b_lt = pop[f'{prefix}.byte{b}.lt.bias'].view(pop_size)
+                byte_lt.append(heaviside(byte_input @ w_lt.T + b_lt))
+
+                w_geq = pop[f'{prefix}.byte{b}.eq.geq.weight'].view(pop_size, -1)
+                b_geq = pop[f'{prefix}.byte{b}.eq.geq.bias'].view(pop_size)
+                w_leq = pop[f'{prefix}.byte{b}.eq.leq.weight'].view(pop_size, -1)
+                b_leq = pop[f'{prefix}.byte{b}.eq.leq.bias'].view(pop_size)
+                h_geq = heaviside(byte_input @ w_geq.T + b_geq)
+                h_leq = heaviside(byte_input @ w_leq.T + b_leq)
+                w_and = pop[f'{prefix}.byte{b}.eq.and.weight'].view(pop_size, -1)
+                b_and = pop[f'{prefix}.byte{b}.eq.and.bias'].view(pop_size)
+                eq_inp = torch.stack([h_geq, h_leq], dim=-1)
+                byte_eq.append(heaviside((eq_inp * w_and).sum(-1) + b_and))
+
+            cascade_gt = []
+            cascade_lt = []
+            for b in range(num_bytes):
+                if b == 0:
+                    cascade_gt.append(byte_gt[0])
+                    cascade_lt.append(byte_lt[0])
+                else:
+                    eq_stack = torch.stack(byte_eq[:b], dim=-1)
+                    w_all_eq = pop[f'{prefix}.cascade.gt.stage{b}.all_eq.weight'].view(pop_size, -1)
+                    b_all_eq = pop[f'{prefix}.cascade.gt.stage{b}.all_eq.bias'].view(pop_size)
+                    all_eq_gt = heaviside((eq_stack * w_all_eq).sum(-1) + b_all_eq)
+                    w_and = pop[f'{prefix}.cascade.gt.stage{b}.and.weight'].view(pop_size, -1)
+                    b_and = pop[f'{prefix}.cascade.gt.stage{b}.and.bias'].view(pop_size)
+                    stage_inp = torch.stack([all_eq_gt, byte_gt[b]], dim=-1)
+                    cascade_gt.append(heaviside((stage_inp * w_and).sum(-1) + b_and))
+
+                    w_all_eq_lt = pop[f'{prefix}.cascade.lt.stage{b}.all_eq.weight'].view(pop_size, -1)
+                    b_all_eq_lt = pop[f'{prefix}.cascade.lt.stage{b}.all_eq.bias'].view(pop_size)
+                    all_eq_lt = heaviside((eq_stack * w_all_eq_lt).sum(-1) + b_all_eq_lt)
+                    w_and_lt = pop[f'{prefix}.cascade.lt.stage{b}.and.weight'].view(pop_size, -1)
+                    b_and_lt = pop[f'{prefix}.cascade.lt.stage{b}.and.bias'].view(pop_size)
+                    stage_inp_lt = torch.stack([all_eq_lt, byte_lt[b]], dim=-1)
+                    cascade_lt.append(heaviside((stage_inp_lt * w_and_lt).sum(-1) + b_and_lt))
+
+            gt_stack = torch.stack(cascade_gt, dim=-1)
+            w_gt_or = pop[f'arithmetic.greaterthan{bits}bit.weight'].view(pop_size, -1)
+            b_gt_or = pop[f'arithmetic.greaterthan{bits}bit.bias'].view(pop_size)
+            gt_out = heaviside((gt_stack * w_gt_or).sum(-1) + b_gt_or)
+
+            lt_stack = torch.stack(cascade_lt, dim=-1)
+            w_lt_or = pop[f'arithmetic.lessthan{bits}bit.weight'].view(pop_size, -1)
+            b_lt_or = pop[f'arithmetic.lessthan{bits}bit.bias'].view(pop_size)
+            lt_out = heaviside((lt_stack * w_lt_or).sum(-1) + b_lt_or)
+
+            w_not_lt = pop[f'arithmetic.greaterorequal{bits}bit.not_lt.weight'].view(pop_size, -1)
+            b_not_lt = pop[f'arithmetic.greaterorequal{bits}bit.not_lt.bias'].view(pop_size)
+            not_lt = heaviside(lt_out.unsqueeze(-1) @ w_not_lt.T + b_not_lt).squeeze(-1)
+            w_ge = pop[f'arithmetic.greaterorequal{bits}bit.weight'].view(pop_size, -1)
+            b_ge = pop[f'arithmetic.greaterorequal{bits}bit.bias'].view(pop_size)
+            ge_out = heaviside(not_lt.unsqueeze(-1) @ w_ge.T + b_ge).squeeze(-1)
+
+            w_not_gt = pop[f'arithmetic.lessorequal{bits}bit.not_gt.weight'].view(pop_size, -1)
+            b_not_gt = pop[f'arithmetic.lessorequal{bits}bit.not_gt.bias'].view(pop_size)
+            not_gt = heaviside(gt_out.unsqueeze(-1) @ w_not_gt.T + b_not_gt).squeeze(-1)
+            w_le = pop[f'arithmetic.lessorequal{bits}bit.weight'].view(pop_size, -1)
+            b_le = pop[f'arithmetic.lessorequal{bits}bit.bias'].view(pop_size)
+            le_out = heaviside(not_gt.unsqueeze(-1) @ w_le.T + b_le).squeeze(-1)
+
+            eq_stack = torch.stack(byte_eq, dim=-1)
+            w_eq_all = pop[f'arithmetic.equality{bits}bit.weight'].view(pop_size, -1)
+            b_eq_all = pop[f'arithmetic.equality{bits}bit.bias'].view(pop_size)
+            eq_out = heaviside((eq_stack * w_eq_all).sum(-1) + b_eq_all)
+
+            for name, out, op in [
+                (f'arithmetic.greaterthan{bits}bit', gt_out, lambda a, b: a > b),
+                (f'arithmetic.greaterorequal{bits}bit', ge_out, lambda a, b: a >= b),
+                (f'arithmetic.lessthan{bits}bit', lt_out, lambda a, b: a < b),
+                (f'arithmetic.lessorequal{bits}bit', le_out, lambda a, b: a <= b),
+                (f'arithmetic.equality{bits}bit', eq_out, 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)
+                correct = (out == expected.unsqueeze(1)).float().sum(0)
+                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, 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'}")
+                scores += correct
+                total += num_tests
 
-        prefix = f'arithmetic.equality{bits}bit'
-        try:
-            expected = torch.tensor([1.0 if a.item() == b.item() else 0.0
-                                    for a, b in zip(comp_a, comp_b)], device=self.device)
+        return scores, total
 
-            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']
+    def _test_subtractor_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test N-bit subtractor circuit (A - B)."""
+        pop_size = next(iter(pop.values())).shape[0]
 
-            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)
+        if debug:
+            print(f"\n=== {bits}-BIT SUBTRACTOR ===")
 
-            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))
+        prefix = f'arithmetic.sub{bits}bit'
+        max_val = 1 << bits
 
-            correct = (out == expected.unsqueeze(1)).float().sum(0)
+        if bits == 32:
+            test_pairs = [
+                (1000, 500), (5000, 3000), (1000000, 500000),
+                (0xFFFFFFFF, 1), (0x80000000, 1), (100, 100),
+                (0, 0), (1, 0), (0, 1), (256, 255),
+                (0xDEADBEEF, 0xCAFEBABE), (1000000000, 999999999),
+            ]
+        else:
+            test_pairs = [(a, b) for a in [0, 1, 127, 128, 255] for b in [0, 1, 127, 128, 255]]
 
-            failures = []
-            if pop_size == 1:
-                for i in range(len(comp_a)):
-                    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()
-                        ))
+        a_vals = torch.tensor([p[0] for p in test_pairs], device=self.device, dtype=torch.long)
+        b_vals = torch.tensor([p[1] for p in test_pairs], device=self.device, dtype=torch.long)
+        num_tests = len(test_pairs)
+
+        a_bits = torch.stack([((a_vals >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
+        b_bits = torch.stack([((b_vals >> (bits - 1 - i)) & 1).float() for i in range(bits)], dim=1)
+
+        not_b_bits = torch.zeros_like(b_bits)
+        for bit in range(bits):
+            w = pop[f'{prefix}.not_b.bit{bit}.weight'].view(pop_size, -1)
+            b = pop[f'{prefix}.not_b.bit{bit}.bias'].view(pop_size)
+            not_b_bits[:, bit] = heaviside(b_bits[:, bit:bit+1] @ w.T + b)[:, 0]
+
+        carry = torch.ones(num_tests, pop_size, device=self.device)
+        sum_bits = []
+
+        for bit in range(bits):
+            bit_idx = bits - 1 - bit
+            s, carry = self._eval_single_fa(
+                pop, f'{prefix}.fa{bit}',
+                a_bits[:, bit_idx].unsqueeze(1).expand(-1, pop_size),
+                not_b_bits[:, bit_idx].unsqueeze(1).expand(-1, pop_size),
+                carry
+            )
+            sum_bits.append(s)
+
+        sum_bits = torch.stack(sum_bits[::-1], dim=-1)
+        result = torch.zeros(num_tests, pop_size, device=self.device)
+        for i in range(bits):
+            result += sum_bits[:, :, i] * (1 << (bits - 1 - i))
+
+        expected = ((a_vals - b_vals) & (max_val - 1)).unsqueeze(1).expand(-1, pop_size).float()
+        correct = (result == expected).float().sum(0)
+
+        failures = []
+        if pop_size == 1:
+            for i in range(min(num_tests, 20)):
+                if result[i, 0].item() != expected[i, 0].item():
+                    failures.append((
+                        [int(a_vals[i].item()), int(b_vals[i].item())],
+                        int(expected[i, 0].item()),
+                        int(result[i, 0].item())
+                    ))
+
+        self._record(prefix, 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 correct, num_tests
+
+    def _test_bitwise_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test N-bit bitwise operations (AND, OR, XOR, NOT)."""
+        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 BITWISE OPS ===")
+
+        if bits == 32:
+            test_pairs = [
+                (0xAAAAAAAA, 0x55555555), (0xFFFFFFFF, 0x00000000),
+                (0x12345678, 0x87654321), (0xDEADBEEF, 0xCAFEBABE),
+                (0x0F0F0F0F, 0xF0F0F0F0), (0, 0), (0xFFFFFFFF, 0xFFFFFFFF),
+            ]
+        else:
+            test_pairs = [(0xAA, 0x55), (0xFF, 0x00), (0x0F, 0xF0)]
+
+        a_vals = torch.tensor([p[0] for p in test_pairs], device=self.device, dtype=torch.long)
+        b_vals = torch.tensor([p[1] for p in test_pairs], device=self.device, dtype=torch.long)
+        num_tests = len(test_pairs)
+
+        ops = [
+            ('and', lambda a, b: a & b),
+            ('or', lambda a, b: a | b),
+            ('xor', lambda a, b: a ^ b),
+        ]
+
+        for op_name, op_fn in ops:
+            try:
+                result_bits = []
+                for bit in range(bits):
+                    a_bit = ((a_vals >> (bits - 1 - bit)) & 1).float()
+                    b_bit = ((b_vals >> (bits - 1 - bit)) & 1).float()
+
+                    if op_name == 'xor':
+                        prefix = f'alu.alu{bits}bit.{op_name}.bit{bit}'
+                        w_or = pop[f'{prefix}.layer1.or.weight'].view(pop_size, -1)
+                        b_or = pop[f'{prefix}.layer1.or.bias'].view(pop_size)
+                        w_nand = pop[f'{prefix}.layer1.nand.weight'].view(pop_size, -1)
+                        b_nand = pop[f'{prefix}.layer1.nand.bias'].view(pop_size)
+                        inp = torch.stack([a_bit, b_bit], dim=-1)
+                        h_or = heaviside(inp @ w_or.T + b_or)
+                        h_nand = heaviside(inp @ w_nand.T + b_nand)
+                        hidden = torch.stack([h_or, h_nand], dim=-1)
+                        w2 = pop[f'{prefix}.layer2.weight'].view(pop_size, -1)
+                        b2 = pop[f'{prefix}.layer2.bias'].view(pop_size)
+                        out = heaviside((hidden * w2).sum(-1) + b2)
+                    else:
+                        w = pop[f'alu.alu{bits}bit.{op_name}.bit{bit}.weight'].view(pop_size, -1)
+                        b = pop[f'alu.alu{bits}bit.{op_name}.bit{bit}.bias'].view(pop_size)
+                        inp = torch.stack([a_bit, b_bit], dim=-1)
+                        out = heaviside(inp @ w.T + b)
+
+                    result_bits.append(out[:, 0] if out.dim() > 1 else out)
+
+                result = sum(int(result_bits[i][j].item()) << (bits - 1 - i)
+                           for i in range(bits) for j in range(1))
+                results = torch.tensor([sum(int(result_bits[i][j].item()) << (bits - 1 - i)
+                                           for i in range(bits)) for j in range(num_tests)],
+                                       device=self.device)
+                expected = torch.tensor([op_fn(a.item(), b.item()) for a, b in zip(a_vals, b_vals)],
+                                        device=self.device)
+
+                correct = (results == expected).float().sum()
+                self._record(f'alu.alu{bits}bit.{op_name}', int(correct.item()), num_tests, [])
+                if debug:
+                    r = self.results[-1]
+                    print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+                scores += correct
+                total += num_tests
+            except KeyError as e:
+                if debug:
+                    print(f"  alu.alu{bits}bit.{op_name}: SKIP (missing {e})")
+
+        try:
+            test_vals = a_vals
+            result_bits = []
+            for bit in range(bits):
+                a_bit = ((test_vals >> (bits - 1 - bit)) & 1).float()
+                w = pop[f'alu.alu{bits}bit.not.bit{bit}.weight'].view(pop_size, -1)
+                b = pop[f'alu.alu{bits}bit.not.bit{bit}.bias'].view(pop_size)
+                out = heaviside(a_bit.unsqueeze(-1) @ w.T + b)
+                result_bits.append(out[:, 0])
+
+            results = torch.tensor([sum(int(result_bits[i][j].item()) << (bits - 1 - i)
+                                       for i in range(bits)) for j in range(num_tests)],
+                                   device=self.device)
+            expected = torch.tensor([(~a.item()) & ((1 << bits) - 1) for a in test_vals],
+                                    device=self.device)
 
-            self._record(prefix, int(correct[0].item()), len(comp_a), failures)
+            correct = (results == expected).float().sum()
+            self._record(f'alu.alu{bits}bit.not', int(correct.item()), num_tests, [])
             if debug:
                 r = self.results[-1]
                 print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
             scores += correct
-            total += len(comp_a)
-        except KeyError:
-            pass
+            total += num_tests
+        except KeyError as e:
+            if debug:
+                print(f"  alu.alu{bits}bit.not: SKIP (missing {e})")
+
+        return scores, total
+
+    def _test_shifts_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test N-bit shift operations (SHL, SHR)."""
+        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 SHIFTS ===")
+
+        if bits == 32:
+            test_vals = [0x12345678, 0x80000001, 0x00000001, 0xFFFFFFFF, 0x55555555]
+        else:
+            test_vals = [0x81, 0x55, 0x01, 0xFF, 0xAA]
+
+        a_vals = torch.tensor(test_vals, device=self.device, dtype=torch.long)
+        num_tests = len(test_vals)
+        max_val = (1 << bits) - 1
+
+        for op_name, op_fn in [('shl', lambda x: (x << 1) & max_val), ('shr', lambda x: x >> 1)]:
+            try:
+                result_bits = []
+                for bit in range(bits):
+                    a_bit = ((a_vals >> (bits - 1 - bit)) & 1).float()
+                    w = pop[f'alu.alu{bits}bit.{op_name}.bit{bit}.weight'].view(pop_size)
+                    b = pop[f'alu.alu{bits}bit.{op_name}.bit{bit}.bias'].view(pop_size)
+
+                    if op_name == 'shl':
+                        if bit < bits - 1:
+                            src_bit = ((a_vals >> (bits - 2 - bit)) & 1).float()
+                        else:
+                            src_bit = torch.zeros_like(a_bit)
+                    else:
+                        if bit > 0:
+                            src_bit = ((a_vals >> (bits - bit)) & 1).float()
+                        else:
+                            src_bit = torch.zeros_like(a_bit)
+
+                    out = heaviside(src_bit * w + b)
+                    result_bits.append(out)
+
+                results = torch.tensor([sum(int(result_bits[i][j].item()) << (bits - 1 - i)
+                                           for i in range(bits)) for j in range(num_tests)],
+                                       device=self.device)
+                expected = torch.tensor([op_fn(a.item()) for a in a_vals], device=self.device)
+
+                correct = (results == expected).float().sum()
+                self._record(f'alu.alu{bits}bit.{op_name}', int(correct.item()), num_tests, [])
+                if debug:
+                    r = self.results[-1]
+                    print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+                scores += correct
+                total += num_tests
+            except KeyError as e:
+                if debug:
+                    print(f"  alu.alu{bits}bit.{op_name}: SKIP (missing {e})")
+
+        return scores, total
+
+    def _test_inc_dec_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test N-bit INC and DEC operations."""
+        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 INC/DEC ===")
+
+        if bits == 32:
+            test_vals = [0, 1, 0xFFFFFFFF, 0x7FFFFFFF, 0x80000000, 1000000, 0xFFFFFFFE]
+        else:
+            test_vals = [0, 1, 254, 255, 127, 128]
+
+        a_vals = torch.tensor(test_vals, device=self.device, dtype=torch.long)
+        num_tests = len(test_vals)
+        max_val = (1 << bits) - 1
+
+        for op_name, op_fn in [('inc', lambda x: (x + 1) & max_val), ('dec', lambda x: (x - 1) & max_val)]:
+            try:
+                carry = torch.ones(num_tests, device=self.device)
+                result_bits = []
+
+                for bit in range(bits):
+                    a_bit = ((a_vals >> bit) & 1).float()
+
+                    prefix = f'alu.alu{bits}bit.{op_name}.bit{bit}'
+                    w_or = pop[f'{prefix}.xor.layer1.or.weight'].flatten()
+                    b_or = pop[f'{prefix}.xor.layer1.or.bias'].item()
+                    w_nand = pop[f'{prefix}.xor.layer1.nand.weight'].flatten()
+                    b_nand = pop[f'{prefix}.xor.layer1.nand.bias'].item()
+
+                    h_or = heaviside(a_bit * w_or[0] + carry * w_or[1] + b_or)
+                    h_nand = heaviside(a_bit * w_nand[0] + carry * w_nand[1] + b_nand)
+
+                    w2 = pop[f'{prefix}.xor.layer2.weight'].flatten()
+                    b2 = pop[f'{prefix}.xor.layer2.bias'].item()
+                    xor_out = heaviside(h_or * w2[0] + h_nand * w2[1] + b2)
+                    result_bits.append(xor_out)
+
+                    if op_name == 'inc':
+                        w_carry = pop[f'{prefix}.carry.weight'].flatten()
+                        b_carry = pop[f'{prefix}.carry.bias'].item()
+                        carry = heaviside(a_bit * w_carry[0] + carry * w_carry[1] + b_carry)
+                    else:
+                        w_not = pop[f'{prefix}.not_a.weight'].flatten()
+                        b_not = pop[f'{prefix}.not_a.bias'].item()
+                        not_a = heaviside(a_bit * w_not[0] + b_not)
+                        w_borrow = pop[f'{prefix}.borrow.weight'].flatten()
+                        b_borrow = pop[f'{prefix}.borrow.bias'].item()
+                        carry = heaviside(not_a * w_borrow[0] + carry * w_borrow[1] + b_borrow)
+
+                results = torch.tensor([sum(int(result_bits[bit][j].item()) << bit
+                                           for bit in range(bits)) for j in range(num_tests)],
+                                       device=self.device)
+                expected = torch.tensor([op_fn(a.item()) for a in a_vals], device=self.device)
+
+                correct = (results == expected).float().sum()
+                self._record(f'alu.alu{bits}bit.{op_name}', int(correct.item()), num_tests, [])
+                if debug:
+                    r = self.results[-1]
+                    print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+                scores += correct
+                total += num_tests
+            except KeyError as e:
+                if debug:
+                    print(f"  alu.alu{bits}bit.{op_name}: SKIP (missing {e})")
 
         return scores, total
 
+    def _test_neg_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test N-bit NEG operation (two's complement negation)."""
+        pop_size = next(iter(pop.values())).shape[0]
+
+        if debug:
+            print(f"\n=== {bits}-BIT NEG ===")
+
+        if bits == 32:
+            test_vals = [0, 1, 0xFFFFFFFF, 0x7FFFFFFF, 0x80000000, 1000, 1000000]
+        else:
+            test_vals = [0, 1, 127, 128, 255, 100]
+
+        a_vals = torch.tensor(test_vals, device=self.device, dtype=torch.long)
+        num_tests = len(test_vals)
+        max_val = (1 << bits) - 1
+
+        try:
+            not_bits = []
+            for bit in range(bits):
+                a_bit = ((a_vals >> bit) & 1).float()
+                w = pop[f'alu.alu{bits}bit.neg.not.bit{bit}.weight'].flatten()
+                b = pop[f'alu.alu{bits}bit.neg.not.bit{bit}.bias'].item()
+                not_bits.append(heaviside(a_bit * w[0] + b))
+
+            carry = torch.ones(num_tests, device=self.device)
+            result_bits = []
+
+            for bit in range(bits):
+                prefix = f'alu.alu{bits}bit.neg.inc.bit{bit}'
+                not_bit = not_bits[bit]
+
+                w_or = pop[f'{prefix}.xor.layer1.or.weight'].flatten()
+                b_or = pop[f'{prefix}.xor.layer1.or.bias'].item()
+                w_nand = pop[f'{prefix}.xor.layer1.nand.weight'].flatten()
+                b_nand = pop[f'{prefix}.xor.layer1.nand.bias'].item()
+
+                h_or = heaviside(not_bit * w_or[0] + carry * w_or[1] + b_or)
+                h_nand = heaviside(not_bit * w_nand[0] + carry * w_nand[1] + b_nand)
+
+                w2 = pop[f'{prefix}.xor.layer2.weight'].flatten()
+                b2 = pop[f'{prefix}.xor.layer2.bias'].item()
+                xor_out = heaviside(h_or * w2[0] + h_nand * w2[1] + b2)
+                result_bits.append(xor_out)
+
+                w_carry = pop[f'{prefix}.carry.weight'].flatten()
+                b_carry = pop[f'{prefix}.carry.bias'].item()
+                carry = heaviside(not_bit * w_carry[0] + carry * w_carry[1] + b_carry)
+
+            results = torch.tensor([sum(int(result_bits[bit][j].item()) << bit
+                                       for bit in range(bits)) for j in range(num_tests)],
+                                   device=self.device)
+            expected = torch.tensor([(-a.item()) & max_val for a in a_vals], device=self.device)
+
+            correct = (results == expected).float().sum()
+            self._record(f'alu.alu{bits}bit.neg', int(correct.item()), num_tests, [])
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+
+            return torch.tensor([correct], device=self.device), num_tests
+        except KeyError as e:
+            if debug:
+                print(f"  alu.alu{bits}bit.neg: SKIP (missing {e})")
+            return torch.zeros(pop_size, device=self.device), 0
+
     # =========================================================================
     # THRESHOLD GATES
     # =========================================================================
@@ -3159,34 +3622,47 @@ class BatchedFitnessEvaluator:
         if debug:
             print("\n=== MANIFEST ===")
 
-        expected = {
+        fixed_expected = {
             'manifest.alu_operations': 16.0,
             'manifest.flags': 4.0,
             'manifest.instruction_width': 16.0,
-            'manifest.memory_bytes': 65536.0,
-            'manifest.pc_width': 16.0,
             'manifest.register_width': 8.0,
             'manifest.registers': 4.0,
-            'manifest.turing_complete': 1.0,
             'manifest.version': 3.0,
         }
 
-        for name, exp_val in expected.items():
+        for name, exp_val in fixed_expected.items():
             try:
-                val = pop[name][0, 0].item()  # [pop_size, 1] -> scalar
+                val = pop[name][0, 0].item()
                 if val == exp_val:
                     scores += 1
                     self._record(name, 1, 1, [])
                 else:
                     self._record(name, 0, 1, [(exp_val, val)])
                 total += 1
-
                 if debug:
                     r = self.results[-1]
                     print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
             except KeyError:
                 pass
 
+        variable_checks = ['manifest.memory_bytes', 'manifest.pc_width', 'manifest.turing_complete']
+        for name in variable_checks:
+            try:
+                val = pop[name][0, 0].item()
+                valid = val >= 0
+                if valid:
+                    scores += 1
+                    self._record(name, 1, 1, [])
+                else:
+                    self._record(name, 0, 1, [('>=0', val)])
+                total += 1
+                if debug:
+                    r = self.results[-1]
+                    print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'} (value={val})")
+            except KeyError:
+                pass
+
         return scores, total
 
     # =========================================================================
@@ -3202,23 +3678,35 @@ class BatchedFitnessEvaluator:
         if debug:
             print("\n=== MEMORY ===")
 
+        try:
+            mem_bytes = int(pop['manifest.memory_bytes'][0].item())
+            addr_bits = int(pop['manifest.pc_width'][0].item())
+        except KeyError:
+            mem_bytes = 65536
+            addr_bits = 16
+
+        if mem_bytes == 0:
+            if debug:
+                print("  No memory (pure ALU mode)")
+            return scores, 0
+
         expected_shapes = {
-            'memory.addr_decode.weight': (65536, 16),
-            'memory.addr_decode.bias': (65536,),
-            'memory.read.and.weight': (8, 65536, 2),
-            'memory.read.and.bias': (8, 65536),
-            'memory.read.or.weight': (8, 65536),
+            'memory.addr_decode.weight': (mem_bytes, addr_bits),
+            'memory.addr_decode.bias': (mem_bytes,),
+            'memory.read.and.weight': (8, mem_bytes, 2),
+            'memory.read.and.bias': (8, mem_bytes),
+            'memory.read.or.weight': (8, mem_bytes),
             'memory.read.or.bias': (8,),
-            'memory.write.sel.weight': (65536, 2),
-            'memory.write.sel.bias': (65536,),
-            'memory.write.nsel.weight': (65536, 1),
-            'memory.write.nsel.bias': (65536,),
-            'memory.write.and_old.weight': (65536, 8, 2),
-            'memory.write.and_old.bias': (65536, 8),
-            'memory.write.and_new.weight': (65536, 8, 2),
-            'memory.write.and_new.bias': (65536, 8),
-            'memory.write.or.weight': (65536, 8, 2),
-            'memory.write.or.bias': (65536, 8),
+            'memory.write.sel.weight': (mem_bytes, 2),
+            'memory.write.sel.bias': (mem_bytes,),
+            'memory.write.nsel.weight': (mem_bytes, 1),
+            'memory.write.nsel.bias': (mem_bytes,),
+            'memory.write.and_old.weight': (mem_bytes, 8, 2),
+            'memory.write.and_old.bias': (mem_bytes, 8),
+            'memory.write.and_new.weight': (mem_bytes, 8, 2),
+            'memory.write.and_new.bias': (mem_bytes, 8),
+            'memory.write.or.weight': (mem_bytes, 8, 2),
+            'memory.write.or.bias': (mem_bytes, 8),
         }
 
         for name, expected_shape in expected_shapes.items():
@@ -3539,6 +4027,36 @@ class BatchedFitnessEvaluator:
                 total_tests += t
                 self.category_scores[f'comparators{bits}'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
 
+                if f'arithmetic.sub{bits}bit.not_b.bit0.weight' in population:
+                    s, t = self._test_subtractor_nbits(population, bits, debug)
+                    scores += s
+                    total_tests += t
+                    self.category_scores[f'subtractor{bits}'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
+
+                if f'alu.alu{bits}bit.and.bit0.weight' in population:
+                    s, t = self._test_bitwise_nbits(population, bits, debug)
+                    scores += s
+                    total_tests += t
+                    self.category_scores[f'bitwise{bits}'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
+
+                if f'alu.alu{bits}bit.shl.bit0.weight' in population:
+                    s, t = self._test_shifts_nbits(population, bits, debug)
+                    scores += s
+                    total_tests += t
+                    self.category_scores[f'shifts{bits}'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
+
+                if f'alu.alu{bits}bit.inc.bit0.xor.layer1.or.weight' in population:
+                    s, t = self._test_inc_dec_nbits(population, bits, debug)
+                    scores += s
+                    total_tests += t
+                    self.category_scores[f'incdec{bits}'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
+
+                if f'alu.alu{bits}bit.neg.not.bit0.weight' in population:
+                    s, t = self._test_neg_nbits(population, bits, debug)
+                    scores += s
+                    total_tests += t
+                    self.category_scores[f'neg{bits}'] = (s[0].item() if pop_size == 1 else s.mean().item(), t)
+
         # 3-operand adder
         s, t = self._test_add3(population, debug)
         scores += s

neural_alu32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:788a277fbff9e44eb9006f5f76839ced42d90c1ff31513b36b34c9ee604e3d97
-size 4972488
+oid sha256:8a292e8d1dc5b29fd84d25d0333599a9946849e456aeb30b7519156dc150a623
+size 4985016