Add PUSH/POP/RET stack operation tests

- PUSH SP decrement: 96 tests (16-bit borrow chain)
- POP SP increment: 96 tests (16-bit carry chain)
- RET address buffer: 80 tests (16 identity gates)
- Tests: 6,169 -> 6,441
- Fitness: 1.000000

README.md

@@ -479,7 +479,7 @@ The interface generalizes to **all** 65,536 8-bit additions once trained—no me
 |------|-------------|
 | `neural_computer.safetensors` | 11,581 tensors, 8,290,134 parameters |
 | `threshold_cpu.py` | CPU state, reference cycle, threshold runtime |
-| `eval.py` | Unified evaluation suite (6,169 tests, GPU-batched) |
+| `eval.py` | Unified evaluation suite (6,441 tests, GPU-batched) |
 | `build.py` | Build tools for memory, ALU, and .inputs tensors |
 | `prune_weights.py` | Weight magnitude pruning |
 

eval.py

@@ -1327,6 +1327,157 @@ class BatchedFitnessEvaluator:
             scores += s
             total += t
 
+        # Stack operations
+        s, t = self._test_stack_ops(pop, debug)
+        scores += s
+        total += t
+
+        return scores, total
+
+    def _test_stack_ops(self, pop: Dict, debug: bool) -> Tuple[torch.Tensor, int]:
+        """Test PUSH/POP/RET stack operation circuits."""
+        pop_size = next(iter(pop.values())).shape[0]
+        scores = torch.zeros(pop_size, device=self.device)
+        total = 0
+
+        if debug:
+            print("\n=== STACK OPERATIONS ===")
+
+        # Test PUSH SP decrement (16-bit, borrow chain)
+        try:
+            sp_tests = [0x0000, 0x0001, 0x0100, 0x8000, 0xFFFF, 0x1234]
+            op_scores = torch.zeros(pop_size, device=self.device)
+            op_total = 0
+
+            for sp_val in sp_tests:
+                expected_val = (sp_val - 1) & 0xFFFF
+                sp_bits = [float((sp_val >> (15 - i)) & 1) for i in range(16)]
+
+                borrow = 1.0
+                out_bits = []
+                for bit in range(15, -1, -1):  # LSB to MSB
+                    prefix = f'control.push.sp_dec.bit{bit}'
+
+                    w_or = pop[f'{prefix}.xor.layer1.or.weight'].view(pop_size, 2)
+                    b_or = pop[f'{prefix}.xor.layer1.or.bias'].view(pop_size)
+                    w_nand = pop[f'{prefix}.xor.layer1.nand.weight'].view(pop_size, 2)
+                    b_nand = pop[f'{prefix}.xor.layer1.nand.bias'].view(pop_size)
+                    w2 = pop[f'{prefix}.xor.layer2.weight'].view(pop_size, 2)
+                    b2 = pop[f'{prefix}.xor.layer2.bias'].view(pop_size)
+
+                    inp = torch.tensor([sp_bits[bit], borrow], device=self.device)
+                    h_or = heaviside((inp * w_or).sum(-1) + b_or)
+                    h_nand = heaviside((inp * w_nand).sum(-1) + b_nand)
+                    hidden = torch.stack([h_or, h_nand], dim=-1)
+                    diff_bit = heaviside((hidden * w2).sum(-1) + b2)
+                    out_bits.insert(0, diff_bit)
+
+                    # Borrow: NOT(sp) AND borrow_in
+                    not_sp = 1.0 - sp_bits[bit]
+                    w_borrow = pop[f'{prefix}.borrow.weight'].view(pop_size, 2)
+                    b_borrow = pop[f'{prefix}.borrow.bias'].view(pop_size)
+                    borrow_inp = torch.tensor([not_sp, borrow], device=self.device)
+                    borrow = heaviside((borrow_inp * w_borrow).sum(-1) + b_borrow)[0].item()
+
+                out = torch.stack(out_bits, dim=-1)
+                expected = torch.tensor([((expected_val >> (15 - i)) & 1) for i in range(16)],
+                                       device=self.device, dtype=torch.float32)
+                correct = (out == expected.unsqueeze(0)).float().sum(1)
+                op_scores += correct
+                op_total += 16
+
+            scores += op_scores
+            total += op_total
+            self._record('control.push.sp_dec', int(op_scores[0].item()), op_total, [])
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+        except (KeyError, RuntimeError) as e:
+            if debug:
+                print(f"  control.push.sp_dec: SKIP ({e})")
+
+        # Test POP SP increment (16-bit, carry chain)
+        try:
+            op_scores = torch.zeros(pop_size, device=self.device)
+            op_total = 0
+
+            for sp_val in sp_tests:
+                expected_val = (sp_val + 1) & 0xFFFF
+                sp_bits = [float((sp_val >> (15 - i)) & 1) for i in range(16)]
+
+                carry = 1.0
+                out_bits = []
+                for bit in range(15, -1, -1):  # LSB to MSB
+                    prefix = f'control.pop.sp_inc.bit{bit}'
+
+                    w_or = pop[f'{prefix}.xor.layer1.or.weight'].view(pop_size, 2)
+                    b_or = pop[f'{prefix}.xor.layer1.or.bias'].view(pop_size)
+                    w_nand = pop[f'{prefix}.xor.layer1.nand.weight'].view(pop_size, 2)
+                    b_nand = pop[f'{prefix}.xor.layer1.nand.bias'].view(pop_size)
+                    w2 = pop[f'{prefix}.xor.layer2.weight'].view(pop_size, 2)
+                    b2 = pop[f'{prefix}.xor.layer2.bias'].view(pop_size)
+
+                    inp = torch.tensor([sp_bits[bit], carry], device=self.device)
+                    h_or = heaviside((inp * w_or).sum(-1) + b_or)
+                    h_nand = heaviside((inp * w_nand).sum(-1) + b_nand)
+                    hidden = torch.stack([h_or, h_nand], dim=-1)
+                    sum_bit = heaviside((hidden * w2).sum(-1) + b2)
+                    out_bits.insert(0, sum_bit)
+
+                    # Carry: sp AND carry_in
+                    w_carry = pop[f'{prefix}.carry.weight'].view(pop_size, 2)
+                    b_carry = pop[f'{prefix}.carry.bias'].view(pop_size)
+                    carry = heaviside((inp * w_carry).sum(-1) + b_carry)[0].item()
+
+                out = torch.stack(out_bits, dim=-1)
+                expected = torch.tensor([((expected_val >> (15 - i)) & 1) for i in range(16)],
+                                       device=self.device, dtype=torch.float32)
+                correct = (out == expected.unsqueeze(0)).float().sum(1)
+                op_scores += correct
+                op_total += 16
+
+            scores += op_scores
+            total += op_total
+            self._record('control.pop.sp_inc', int(op_scores[0].item()), op_total, [])
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+        except (KeyError, RuntimeError) as e:
+            if debug:
+                print(f"  control.pop.sp_inc: SKIP ({e})")
+
+        # Test RET address buffer (16 identity gates)
+        try:
+            op_scores = torch.zeros(pop_size, device=self.device)
+            op_total = 0
+
+            addr_tests = [0x0000, 0xFFFF, 0x1234, 0x8000, 0x00FF]
+            for addr_val in addr_tests:
+                addr_bits = torch.tensor([float((addr_val >> (15 - i)) & 1) for i in range(16)],
+                                        device=self.device, dtype=torch.float32)
+
+                out_bits = []
+                for bit in range(16):
+                    w = pop[f'control.ret.addr.bit{bit}.weight'].view(pop_size)
+                    b = pop[f'control.ret.addr.bit{bit}.bias'].view(pop_size)
+                    out = heaviside(addr_bits[bit] * w + b)
+                    out_bits.append(out)
+
+                out = torch.stack(out_bits, dim=-1)
+                correct = (out == addr_bits.unsqueeze(0)).float().sum(1)
+                op_scores += correct
+                op_total += 16
+
+            scores += op_scores
+            total += op_total
+            self._record('control.ret.addr', int(op_scores[0].item()), op_total, [])
+            if debug:
+                r = self.results[-1]
+                print(f"  {r.name}: {r.passed}/{r.total} {'PASS' if r.success else 'FAIL'}")
+        except (KeyError, RuntimeError) as e:
+            if debug:
+                print(f"  control.ret.addr: SKIP ({e})")
+
         return scores, total
 
     # =========================================================================