Unify eval.py and arithmetic_eval.py into single evaluator

Merge both evaluation scripts into a unified eval.py with CLI args:
- --category/-c: run specific test categories
- --circuit: filter by circuit name
- --quick/-q: fast smoke test mode
- --verbose/-v: detailed output
- --json/-j: CI-friendly JSON output
- --coverage: tensor coverage report
- --list/-l: list available categories

Categories: boolean, threshold, clz, adders, comparators,
multiplier, divider, modular, combinational, pattern,
float16_basic, float16_arith, float16_conv

Remove redundant arithmetic_eval.py.

arithmetic_eval.py

@@ -1,1664 +0,0 @@
-"""
-ARITHMETIC EVALUATOR
-=====================
-Introspection-based exhaustive testing for arithmetic circuits in threshold-calculus.
-
-Stripped-down version of comprehensive_eval.py for arithmetic-only weights.
-Removes: ALU, Control, Manifest, Error Detection
-Keeps: Boolean, Arithmetic, Threshold, Modular, Combinational, Pattern Recognition
-"""
-
-import torch
-from safetensors import safe_open
-from typing import Dict, List, Tuple, Optional, Callable
-from dataclasses import dataclass
-from collections import defaultdict
-import json
-import os
-import re
-import time
-
-
-@dataclass
-class TestResult:
-    """Result of testing a single circuit."""
-    circuit_name: str
-    passed: int
-    total: int
-    failures: List[Tuple]
-
-    @property
-    def success(self) -> bool:
-        return self.passed == self.total
-
-    @property
-    def rate(self) -> float:
-        return self.passed / self.total if self.total > 0 else 0.0
-
-
-def heaviside(x: torch.Tensor) -> torch.Tensor:
-    """Threshold activation: 1 if x >= 0, else 0."""
-    return (x >= 0).float()
-
-
-class TensorRegistry:
-    """Discovers and organizes tensors from a safetensors file."""
-
-    def __init__(self, path: str):
-        self.path = path
-        self.tensors: Dict[str, torch.Tensor] = {}
-        self.circuits: Dict[str, List[str]] = defaultdict(list)
-        self.accessed: set = set()
-        self._load()
-        self._organize()
-
-    def _load(self):
-        with safe_open(self.path, framework='pt') as f:
-            for name in f.keys():
-                self.tensors[name] = f.get_tensor(name).float()
-
-    def _organize(self):
-        for name in self.tensors:
-            circuit = self._extract_circuit(name)
-            self.circuits[circuit].append(name)
-
-    def _extract_circuit(self, tensor_name: str) -> str:
-        if tensor_name.endswith('.weight'):
-            return tensor_name[:-7]
-        elif tensor_name.endswith('.bias'):
-            return tensor_name[:-5]
-        return tensor_name
-
-    def get(self, name: str) -> torch.Tensor:
-        self.accessed.add(name)
-        return self.tensors[name]
-
-    def has(self, name: str) -> bool:
-        return name in self.tensors
-
-    def get_category(self, prefix: str) -> Dict[str, List[str]]:
-        return {k: v for k, v in self.circuits.items() if k.startswith(prefix)}
-
-    @property
-    def categories(self) -> List[str]:
-        cats = set()
-        for name in self.tensors:
-            cats.add(name.split('.')[0])
-        return sorted(cats)
-
-    @property
-    def untested(self) -> List[str]:
-        return sorted(set(self.tensors.keys()) - self.accessed)
-
-    @property
-    def coverage(self) -> float:
-        if not self.tensors:
-            return 0.0
-        return len(self.accessed) / len(self.tensors)
-
-    def coverage_report(self) -> str:
-        lines = []
-        lines.append(f"TENSOR COVERAGE: {len(self.accessed)}/{len(self.tensors)} ({100*self.coverage:.2f}%)")
-
-        untested = self.untested
-        if untested:
-            by_category: Dict[str, List[str]] = defaultdict(list)
-            for name in untested:
-                cat = name.split('.')[0]
-                by_category[cat].append(name)
-
-            lines.append(f"\nUNTESTED TENSORS ({len(untested)}):")
-            for cat in sorted(by_category.keys()):
-                tensors = by_category[cat]
-                lines.append(f"\n  {cat}/ ({len(tensors)} tensors):")
-                for t in tensors[:10]:
-                    lines.append(f"    - {t}")
-                if len(tensors) > 10:
-                    lines.append(f"    ... and {len(tensors) - 10} more")
-        else:
-            lines.append("\nAll tensors tested!")
-
-        return '\n'.join(lines)
-
-
-class RoutingEvaluator:
-    """Evaluates circuits using routing information."""
-
-    def __init__(self, registry: TensorRegistry, routing_path: str, device: str = 'cpu'):
-        self.reg = registry
-        self.device = device
-        self.routing = self._load_routing(routing_path)
-
-    def _load_routing(self, path: str) -> dict:
-        if os.path.exists(path):
-            with open(path, 'r') as f:
-                return json.load(f)
-        return {'circuits': {}}
-
-    def has_routing(self, circuit: str) -> bool:
-        return circuit in self.routing.get('circuits', {})
-
-    def eval_gate(self, gate_path: str, inputs: torch.Tensor) -> torch.Tensor:
-        w = self.reg.get(f'{gate_path}.weight')
-        b = self.reg.get(f'{gate_path}.bias')
-        return heaviside((inputs * w).sum(-1) + b)
-
-    def eval_division(self, dividend: int, divisor: int) -> Tuple[int, int]:
-        if not self.has_routing('arithmetic.div8bit'):
-            return dividend // divisor, dividend % divisor
-
-        routing = self.routing['circuits']['arithmetic.div8bit']
-        internal = routing['internal']
-
-        dividend_bits = [(dividend >> i) & 1 for i in range(8)]
-        divisor_bits = [(divisor >> i) & 1 for i in range(8)]
-
-        values = {}
-        values['#0'] = 0.0
-        values['#1'] = 1.0
-        for i in range(8):
-            values[f'$dividend[{i}]'] = float(dividend_bits[i])
-            values[f'$divisor[{i}]'] = float(divisor_bits[i])
-
-        def resolve(src: str) -> float:
-            if src in values:
-                return values[src]
-            if src.startswith('#'):
-                return float(src[1:])
-            full_path = f'arithmetic.div8bit.{src}'
-            if full_path in values:
-                return values[full_path]
-            raise KeyError(f"Cannot resolve: {src}")
-
-        def eval_gate_from_routing(gate_name: str, sources: list) -> float:
-            gate_path = f'arithmetic.div8bit.{gate_name}'
-            if not self.reg.has(f'{gate_path}.weight'):
-                inp_vals = [resolve(s) for s in sources]
-                return float(sum(inp_vals) >= len(inp_vals))
-
-            w = self.reg.get(f'{gate_path}.weight')
-            b = self.reg.get(f'{gate_path}.bias')
-            inp_vals = torch.tensor([resolve(s) for s in sources], device=self.device, dtype=torch.float32)
-            return heaviside((inp_vals * w).sum() + b).item()
-
-        for stage in range(8):
-            stage_gates = [g for g in internal.keys() if g.startswith(f'stage{stage}.')]
-            sorted_stage_gates = self._topological_sort_subset(internal, stage_gates)
-            for gate_name in sorted_stage_gates:
-                sources = internal[gate_name]
-                values[f'arithmetic.div8bit.{gate_name}'] = eval_gate_from_routing(gate_name, sources)
-
-        for gate_name in ['quotient0', 'quotient1', 'quotient2', 'quotient3',
-                          'quotient4', 'quotient5', 'quotient6', 'quotient7',
-                          'remainder0', 'remainder1', 'remainder2', 'remainder3',
-                          'remainder4', 'remainder5', 'remainder6', 'remainder7']:
-            if gate_name in internal:
-                sources = internal[gate_name]
-                values[f'arithmetic.div8bit.{gate_name}'] = eval_gate_from_routing(gate_name, sources)
-
-        quotient_bits = [int(values.get(f'arithmetic.div8bit.stage{i}.cmp', 0)) for i in range(8)]
-        remainder_bits = [int(values.get(f'arithmetic.div8bit.stage7.mux{i}.or', 0)) for i in range(8)]
-
-        quotient = sum(quotient_bits[i] << (7 - i) for i in range(8))
-        remainder = sum(remainder_bits[i] << i for i in range(8))
-
-        return quotient, remainder
-
-    def _topological_sort_subset(self, internal: dict, subset: list) -> list:
-        subset_set = set(subset)
-        deps = {}
-        for gate in subset:
-            deps[gate] = set()
-            for src in internal.get(gate, []):
-                if src.startswith('$') or src.startswith('#'):
-                    continue
-                if src in subset_set:
-                    deps[gate].add(src)
-
-        result = []
-        visited = set()
-        temp = set()
-
-        def visit(node):
-            if node in temp:
-                return
-            if node in visited:
-                return
-            temp.add(node)
-            for dep in deps.get(node, []):
-                visit(dep)
-            temp.remove(node)
-            visited.add(node)
-            result.append(node)
-
-        for node in subset:
-            visit(node)
-
-        return result
-
-
-class CircuitEvaluator:
-    """Evaluates individual circuit types."""
-
-    def __init__(self, registry: TensorRegistry, device: str = 'cuda', routing_path: str = None):
-        self.reg = registry
-        self.device = device
-        if routing_path is None:
-            routing_path = os.path.join(os.path.dirname(__file__), 'routing.json')
-        self.routing_eval = RoutingEvaluator(registry, routing_path, device)
-        self._move_to_device()
-
-    def _move_to_device(self):
-        for name in self.reg.tensors:
-            self.reg.tensors[name] = self.reg.tensors[name].to(self.device)
-
-    # =========================================================================
-    # PRIMITIVE EVALUATORS
-    # =========================================================================
-
-    def eval_single_layer(self, prefix: str, inputs: torch.Tensor) -> torch.Tensor:
-        w = self.reg.get(f'{prefix}.weight')
-        b = self.reg.get(f'{prefix}.bias')
-        return heaviside(inputs @ w + b)
-
-    def eval_two_layer_xor(self, prefix: str, inputs: torch.Tensor) -> torch.Tensor:
-        w_or = self.reg.get(f'{prefix}.layer1.or.weight')
-        b_or = self.reg.get(f'{prefix}.layer1.or.bias')
-        w_nand = self.reg.get(f'{prefix}.layer1.nand.weight')
-        b_nand = self.reg.get(f'{prefix}.layer1.nand.bias')
-
-        h_or = heaviside(inputs @ w_or + b_or)
-        h_nand = heaviside(inputs @ w_nand + b_nand)
-        hidden = torch.stack([h_or, h_nand], dim=-1)
-
-        w2 = self.reg.get(f'{prefix}.layer2.weight')
-        b2 = self.reg.get(f'{prefix}.layer2.bias')
-        return heaviside((hidden * w2).sum(-1) + b2)
-
-    def eval_two_layer_neuron(self, prefix: str, inputs: torch.Tensor) -> torch.Tensor:
-        w1_n1 = self.reg.get(f'{prefix}.layer1.neuron1.weight')
-        b1_n1 = self.reg.get(f'{prefix}.layer1.neuron1.bias')
-        w1_n2 = self.reg.get(f'{prefix}.layer1.neuron2.weight')
-        b1_n2 = self.reg.get(f'{prefix}.layer1.neuron2.bias')
-
-        h1 = heaviside(inputs @ w1_n1 + b1_n1)
-        h2 = heaviside(inputs @ w1_n2 + b1_n2)
-        hidden = torch.stack([h1, h2], dim=-1)
-
-        w2 = self.reg.get(f'{prefix}.layer2.weight')
-        b2 = self.reg.get(f'{prefix}.layer2.bias')
-        return heaviside((hidden * w2).sum(-1) + b2)
-
-    def eval_two_layer_xnor(self, prefix: str, inputs: torch.Tensor) -> torch.Tensor:
-        w_and = self.reg.get(f'{prefix}.layer1.and.weight')
-        b_and = self.reg.get(f'{prefix}.layer1.and.bias')
-        w_nor = self.reg.get(f'{prefix}.layer1.nor.weight')
-        b_nor = self.reg.get(f'{prefix}.layer1.nor.bias')
-
-        h_and = heaviside(inputs @ w_and + b_and)
-        h_nor = heaviside(inputs @ w_nor + b_nor)
-        hidden = torch.stack([h_and, h_nor], dim=-1)
-
-        w2 = self.reg.get(f'{prefix}.layer2.weight')
-        b2 = self.reg.get(f'{prefix}.layer2.bias')
-        return heaviside((hidden * w2).sum(-1) + b2)
-
-    # =========================================================================
-    # BOOLEAN GATES
-    # =========================================================================
-
-    def test_boolean_and(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([0,0,0,1], device=self.device, dtype=torch.float32)
-        output = self.eval_single_layer('boolean.and', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.and', passed, 4, failures)
-
-    def test_boolean_or(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([0,1,1,1], device=self.device, dtype=torch.float32)
-        output = self.eval_single_layer('boolean.or', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.or', passed, 4, failures)
-
-    def test_boolean_nand(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([1,1,1,0], device=self.device, dtype=torch.float32)
-        output = self.eval_single_layer('boolean.nand', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.nand', passed, 4, failures)
-
-    def test_boolean_nor(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([1,0,0,0], device=self.device, dtype=torch.float32)
-        output = self.eval_single_layer('boolean.nor', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.nor', passed, 4, failures)
-
-    def test_boolean_not(self) -> TestResult:
-        inputs = torch.tensor([[0],[1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([1,0], device=self.device, dtype=torch.float32)
-        output = self.eval_single_layer('boolean.not', inputs)
-        failures = []
-        passed = 0
-        for i in range(2):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.not', passed, 2, failures)
-
-    def test_boolean_xor(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([0,1,1,0], device=self.device, dtype=torch.float32)
-        output = self.eval_two_layer_neuron('boolean.xor', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.xor', passed, 4, failures)
-
-    def test_boolean_xnor(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([1,0,0,1], device=self.device, dtype=torch.float32)
-        output = self.eval_two_layer_neuron('boolean.xnor', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.xnor', passed, 4, failures)
-
-    def test_boolean_implies(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([1,1,0,1], device=self.device, dtype=torch.float32)
-        output = self.eval_single_layer('boolean.implies', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.implies', passed, 4, failures)
-
-    def test_boolean_biimplies(self) -> TestResult:
-        inputs = torch.tensor([[0,0],[0,1],[1,0],[1,1]], device=self.device, dtype=torch.float32)
-        expected = torch.tensor([1,0,0,1], device=self.device, dtype=torch.float32)
-        output = self.eval_two_layer_neuron('boolean.biimplies', inputs)
-        failures = []
-        passed = 0
-        for i in range(4):
-            if output[i] == expected[i]:
-                passed += 1
-            else:
-                failures.append((inputs[i].tolist(), expected[i].item(), output[i].item()))
-        return TestResult('boolean.biimplies', passed, 4, failures)
-
-    # =========================================================================
-    # ARITHMETIC - HALF ADDER
-    # =========================================================================
-
-    def eval_half_adder(self, prefix: str, a: torch.Tensor, b: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        inputs = torch.stack([a, b], dim=-1)
-        sum_out = self.eval_two_layer_xor(f'{prefix}.sum', inputs)
-        carry_out = self.eval_single_layer(f'{prefix}.carry', inputs)
-        return sum_out, carry_out
-
-    def test_half_adder(self) -> TestResult:
-        failures = []
-        passed = 0
-        for a in [0, 1]:
-            for b in [0, 1]:
-                a_t = torch.tensor([float(a)], device=self.device)
-                b_t = torch.tensor([float(b)], device=self.device)
-                sum_out, carry_out = self.eval_half_adder('arithmetic.halfadder', a_t, b_t)
-                expected_sum = a ^ b
-                expected_carry = a & b
-                if sum_out.item() == expected_sum and carry_out.item() == expected_carry:
-                    passed += 1
-                else:
-                    failures.append(((a, b), (expected_sum, expected_carry),
-                                    (sum_out.item(), carry_out.item())))
-        return TestResult('arithmetic.halfadder', passed, 4, failures)
-
-    # =========================================================================
-    # ARITHMETIC - FULL ADDER
-    # =========================================================================
-
-    def eval_full_adder(self, prefix: str, a: torch.Tensor, b: torch.Tensor,
-                        cin: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        ha1_sum, ha1_carry = self.eval_half_adder(f'{prefix}.ha1', a, b)
-        ha2_sum, ha2_carry = self.eval_half_adder(f'{prefix}.ha2', ha1_sum, cin)
-        carry_inputs = torch.stack([ha1_carry, ha2_carry], dim=-1)
-        carry_out = self.eval_single_layer(f'{prefix}.carry_or', carry_inputs)
-        return ha2_sum, carry_out
-
-    def test_full_adder(self) -> TestResult:
-        failures = []
-        passed = 0
-        for a in [0, 1]:
-            for b in [0, 1]:
-                for cin in [0, 1]:
-                    a_t = torch.tensor([float(a)], device=self.device)
-                    b_t = torch.tensor([float(b)], device=self.device)
-                    cin_t = torch.tensor([float(cin)], device=self.device)
-                    sum_out, cout = self.eval_full_adder('arithmetic.fulladder', a_t, b_t, cin_t)
-                    expected_sum = (a + b + cin) & 1
-                    expected_cout = (a + b + cin) >> 1
-                    if sum_out.item() == expected_sum and cout.item() == expected_cout:
-                        passed += 1
-                    else:
-                        failures.append(((a, b, cin), (expected_sum, expected_cout),
-                                        (sum_out.item(), cout.item())))
-        return TestResult('arithmetic.fulladder', passed, 8, failures)
-
-    # =========================================================================
-    # ARITHMETIC - RIPPLE CARRY ADDERS
-    # =========================================================================
-
-    def eval_ripple_carry(self, prefix: str, a: int, b: int, bits: int) -> Tuple[int, int]:
-        carry = torch.tensor([0.0], device=self.device)
-        result_bits = []
-        for i in range(bits):
-            a_bit = torch.tensor([float((a >> i) & 1)], device=self.device)
-            b_bit = torch.tensor([float((b >> i) & 1)], device=self.device)
-            sum_bit, carry = self.eval_full_adder(f'{prefix}.fa{i}', a_bit, b_bit, carry)
-            result_bits.append(int(sum_bit.item()))
-        result = sum(bit << i for i, bit in enumerate(result_bits))
-        return result, int(carry.item())
-
-    def test_ripple_carry_8bit(self) -> TestResult:
-        failures = []
-        passed = 0
-        total = 256 * 256
-        for a in range(256):
-            for b in range(256):
-                result, cout = self.eval_ripple_carry('arithmetic.ripplecarry8bit', a, b, 8)
-                expected = (a + b) & 0xFF
-                expected_cout = 1 if (a + b) > 255 else 0
-                if result == expected and cout == expected_cout:
-                    passed += 1
-                else:
-                    if len(failures) < 100:
-                        failures.append(((a, b), (expected, expected_cout), (result, cout)))
-        return TestResult('arithmetic.ripplecarry8bit', passed, total, failures)
-
-    def test_ripple_carry_4bit(self) -> TestResult:
-        failures = []
-        passed = 0
-        total = 16 * 16
-        for a in range(16):
-            for b in range(16):
-                result, cout = self.eval_ripple_carry('arithmetic.ripplecarry4bit', a, b, 4)
-                expected = (a + b) & 0xF
-                expected_cout = 1 if (a + b) > 15 else 0
-                if result == expected and cout == expected_cout:
-                    passed += 1
-                else:
-                    failures.append(((a, b), (expected, expected_cout), (result, cout)))
-        return TestResult('arithmetic.ripplecarry4bit', passed, total, failures)
-
-    def test_ripple_carry_2bit(self) -> TestResult:
-        failures = []
-        passed = 0
-        total = 4 * 4
-        for a in range(4):
-            for b in range(4):
-                result, cout = self.eval_ripple_carry('arithmetic.ripplecarry2bit', a, b, 2)
-                expected = (a + b) & 0x3
-                expected_cout = 1 if (a + b) > 3 else 0
-                if result == expected and cout == expected_cout:
-                    passed += 1
-                else:
-                    failures.append(((a, b), (expected, expected_cout), (result, cout)))
-        return TestResult('arithmetic.ripplecarry2bit', passed, total, failures)
-
-    # =========================================================================
-    # ARITHMETIC - COMPARATORS
-    # =========================================================================
-
-    def test_comparator_8bit(self, name: str, op: Callable[[int, int], bool]) -> TestResult:
-        failures = []
-        passed = 0
-        total = 256 * 256
-        w = self.reg.get(f'arithmetic.{name}.comparator')
-        for a in range(256):
-            for b in range(256):
-                a_bits = torch.tensor([(a >> (7-i)) & 1 for i in range(8)],
-                                     device=self.device, dtype=torch.float32)
-                b_bits = torch.tensor([(b >> (7-i)) & 1 for i in range(8)],
-                                     device=self.device, dtype=torch.float32)
-                if 'less' in name:
-                    diff = b_bits - a_bits
-                else:
-                    diff = a_bits - b_bits
-                score = (diff * w).sum()
-                if 'equal' in name:
-                    result = int(score >= 0)
-                else:
-                    result = int(score > 0)
-                expected = int(op(a, b))
-                if result == expected:
-                    passed += 1
-                else:
-                    if len(failures) < 100:
-                        failures.append(((a, b), expected, result))
-        return TestResult(f'arithmetic.{name}', passed, total, failures)
-
-    def test_greaterthan8bit(self) -> TestResult:
-        return self.test_comparator_8bit('greaterthan8bit', lambda a, b: a > b)
-
-    def test_lessthan8bit(self) -> TestResult:
-        return self.test_comparator_8bit('lessthan8bit', lambda a, b: a < b)
-
-    def test_greaterorequal8bit(self) -> TestResult:
-        return self.test_comparator_8bit('greaterorequal8bit', lambda a, b: a >= b)
-
-    def test_lessorequal8bit(self) -> TestResult:
-        return self.test_comparator_8bit('lessorequal8bit', lambda a, b: a <= b)
-
-    # =========================================================================
-    # ARITHMETIC - 8x8 MULTIPLIER
-    # =========================================================================
-
-    def test_multiplier_8x8(self) -> TestResult:
-        test_cases = []
-        for a in [0, 1, 127, 128, 255]:
-            for b in [0, 1, 127, 128, 255]:
-                test_cases.append((a, b))
-        for a in [1, 2, 4, 8, 16, 32, 64, 128]:
-            for b in [1, 2, 4, 8, 16, 32, 64, 128]:
-                test_cases.append((a, b))
-        patterns = [0xAA, 0x55, 0x0F, 0xF0, 0x33, 0xCC]
-        for a in patterns:
-            for b in patterns:
-                test_cases.append((a, b))
-        for a in range(16):
-            for b in range(16):
-                test_cases.append((a, b))
-        test_cases = list(set(test_cases))
-        failures = []
-        passed = 0
-        for a, b in test_cases:
-            result = self._eval_multiplier_8x8(a, b)
-            expected = (a * b) & 0xFFFF
-            if result == expected:
-                passed += 1
-            else:
-                if len(failures) < 100:
-                    failures.append(((a, b), expected, result))
-        return TestResult('arithmetic.multiplier8x8', passed, len(test_cases), failures)
-
-    def _eval_multiplier_8x8(self, a: int, b: int) -> int:
-        pp = [[0] * 8 for _ in range(8)]
-        for row in range(8):
-            for col in range(8):
-                a_bit = (a >> col) & 1
-                b_bit = (b >> row) & 1
-                inputs = torch.tensor([[float(a_bit), float(b_bit)]], device=self.device)
-                w = self.reg.get(f'arithmetic.multiplier8x8.pp.r{row}.c{col}.weight')
-                b_tensor = self.reg.get(f'arithmetic.multiplier8x8.pp.r{row}.c{col}.bias')
-                pp[row][col] = int(heaviside((inputs * w).sum() + b_tensor).item())
-        result_bits = [0] * 16
-        for col in range(8):
-            result_bits[col] = pp[0][col]
-        for stage in range(7):
-            row_idx = stage + 1
-            shift = row_idx
-            sum_width = 8 + stage + 1
-            carry = 0
-            for bit in range(sum_width):
-                if bit < shift:
-                    pp_bit = 0
-                elif bit <= shift + 7:
-                    pp_bit = pp[row_idx][bit - shift]
-                else:
-                    pp_bit = 0
-                prev_bit = result_bits[bit] if bit < 16 else 0
-                prefix = f'arithmetic.multiplier8x8.stage{stage}.bit{bit}'
-                total = prev_bit + pp_bit + carry
-                sum_bit, new_carry = self._eval_multiplier_fa(prefix, prev_bit, pp_bit, carry)
-                if bit < 16:
-                    result_bits[bit] = sum_bit
-                carry = new_carry
-            if sum_width < 16:
-                result_bits[sum_width] = carry
-        return sum(result_bits[i] << i for i in range(16))
-
-    def _eval_multiplier_fa(self, prefix: str, a: int, b: int, cin: int) -> Tuple[int, int]:
-        a_t = torch.tensor([float(a)], device=self.device)
-        b_t = torch.tensor([float(b)], device=self.device)
-        cin_t = torch.tensor([float(cin)], device=self.device)
-        inp_ab = torch.stack([a_t, b_t], dim=-1)
-        ha1_sum = self.eval_two_layer_xor(f'{prefix}.ha1.sum', inp_ab)
-        ha1_carry = self.eval_single_layer(f'{prefix}.ha1.carry', inp_ab)
-        inp_ha2 = torch.stack([ha1_sum, cin_t], dim=-1)
-        ha2_sum = self.eval_two_layer_xor(f'{prefix}.ha2.sum', inp_ha2)
-        ha2_carry = self.eval_single_layer(f'{prefix}.ha2.carry', inp_ha2)
-        carry_inp = torch.stack([ha1_carry, ha2_carry], dim=-1)
-        cout = self.eval_single_layer(f'{prefix}.carry_or', carry_inp)
-        return int(ha2_sum.item()), int(cout.item())
-
-    # =========================================================================
-    # THRESHOLD GATES
-    # =========================================================================
-
-    def test_threshold_kofn(self, k: int, name: str) -> TestResult:
-        failures = []
-        passed = 0
-        w = self.reg.get(f'threshold.{name}.weight')
-        b = self.reg.get(f'threshold.{name}.bias')
-        for val in range(256):
-            bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                               device=self.device, dtype=torch.float32)
-            output = heaviside((bits * w).sum() + b)
-            popcount = bin(val).count('1')
-            expected = float(popcount >= k)
-            if output.item() == expected:
-                passed += 1
-            else:
-                failures.append((val, expected, output.item()))
-        return TestResult(f'threshold.{name}', passed, 256, failures)
-
-    def test_threshold_gates(self) -> List[TestResult]:
-        results = []
-        threshold_gates = [
-            (1, 'oneoutof8'),
-            (2, 'twooutof8'),
-            (3, 'threeoutof8'),
-            (4, 'fouroutof8'),
-            (5, 'fiveoutof8'),
-            (6, 'sixoutof8'),
-            (7, 'sevenoutof8'),
-            (8, 'alloutof8'),
-        ]
-        for k, name in threshold_gates:
-            if self.reg.has(f'threshold.{name}.weight'):
-                results.append(self.test_threshold_kofn(k, name))
-        return results
-
-    def test_threshold_atleastk_4(self) -> TestResult:
-        passed = 0
-        if self.reg.has('threshold.atleastk_4.weight'):
-            self.reg.get('threshold.atleastk_4.weight')
-            self.reg.get('threshold.atleastk_4.bias')
-            passed += 2
-        return TestResult('threshold.atleastk_4', passed, 2, [])
-
-    def test_threshold_atmostk_4(self) -> TestResult:
-        passed = 0
-        if self.reg.has('threshold.atmostk_4.weight'):
-            self.reg.get('threshold.atmostk_4.weight')
-            self.reg.get('threshold.atmostk_4.bias')
-            passed += 2
-        return TestResult('threshold.atmostk_4', passed, 2, [])
-
-    def test_threshold_exactlyk_4(self) -> TestResult:
-        passed = 0
-        for comp in ['atleast', 'atmost', 'and']:
-            if self.reg.has(f'threshold.exactlyk_4.{comp}.weight'):
-                self.reg.get(f'threshold.exactlyk_4.{comp}.weight')
-                self.reg.get(f'threshold.exactlyk_4.{comp}.bias')
-                passed += 2
-        return TestResult('threshold.exactlyk_4', passed, 6, [])
-
-    def test_threshold_majority(self) -> TestResult:
-        passed = 0
-        if self.reg.has('threshold.majority.weight'):
-            self.reg.get('threshold.majority.weight')
-            self.reg.get('threshold.majority.bias')
-            passed += 2
-        return TestResult('threshold.majority', passed, 2, [])
-
-    def test_threshold_minority(self) -> TestResult:
-        passed = 0
-        if self.reg.has('threshold.minority.weight'):
-            self.reg.get('threshold.minority.weight')
-            self.reg.get('threshold.minority.bias')
-            passed += 2
-        return TestResult('threshold.minority', passed, 2, [])
-
-    # =========================================================================
-    # MODULAR ARITHMETIC
-    # =========================================================================
-
-    def test_modular(self, mod: int) -> TestResult:
-        failures = []
-        passed = 0
-        if mod in [2, 4, 8]:
-            w = self.reg.get(f'modular.mod{mod}.weight')
-            b = self.reg.get(f'modular.mod{mod}.bias')
-            for val in range(256):
-                bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                                   device=self.device, dtype=torch.float32)
-                output = heaviside((bits * w).sum() + b.item())
-                expected = float(val % mod == 0)
-                if output.item() == expected:
-                    passed += 1
-                else:
-                    failures.append((val, expected, output.item()))
-        else:
-            num_detectors = 0
-            while self.reg.has(f'modular.mod{mod}.layer1.geq{num_detectors}.weight'):
-                num_detectors += 1
-            for val in range(256):
-                bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                                   device=self.device, dtype=torch.float32)
-                layer1_outputs = []
-                for idx in range(num_detectors):
-                    w_geq = self.reg.get(f'modular.mod{mod}.layer1.geq{idx}.weight')
-                    b_geq = self.reg.get(f'modular.mod{mod}.layer1.geq{idx}.bias').item()
-                    w_leq = self.reg.get(f'modular.mod{mod}.layer1.leq{idx}.weight')
-                    b_leq = self.reg.get(f'modular.mod{mod}.layer1.leq{idx}.bias').item()
-                    geq = heaviside((bits * w_geq).sum() + b_geq).item()
-                    leq = heaviside((bits * w_leq).sum() + b_leq).item()
-                    layer1_outputs.append((geq, leq))
-                layer2_outputs = []
-                for idx in range(num_detectors):
-                    w_eq = self.reg.get(f'modular.mod{mod}.layer2.eq{idx}.weight')
-                    b_eq = self.reg.get(f'modular.mod{mod}.layer2.eq{idx}.bias').item()
-                    geq, leq = layer1_outputs[idx]
-                    combined = torch.tensor([geq, leq], device=self.device, dtype=torch.float32)
-                    eq = heaviside((combined * w_eq).sum() + b_eq).item()
-                    layer2_outputs.append(eq)
-                layer2_stack = torch.tensor(layer2_outputs, device=self.device, dtype=torch.float32)
-                w_or = self.reg.get(f'modular.mod{mod}.layer3.or.weight')
-                b_or = self.reg.get(f'modular.mod{mod}.layer3.or.bias').item()
-                output = heaviside((layer2_stack * w_or).sum() + b_or).item()
-                expected = float(val % mod == 0)
-                if output == expected:
-                    passed += 1
-                else:
-                    failures.append((val, expected, output))
-        return TestResult(f'modular.mod{mod}', passed, 256, failures)
-
-    # =========================================================================
-    # COMBINATIONAL CIRCUITS
-    # =========================================================================
-
-    def test_decoder_3to8(self) -> TestResult:
-        failures = []
-        passed = 0
-        for sel in range(8):
-            sel_bits = torch.tensor([(sel >> (2-i)) & 1 for i in range(3)],
-                                   device=self.device, dtype=torch.float32)
-            for out_idx in range(8):
-                w = self.reg.get(f'combinational.decoder3to8.out{out_idx}.weight')
-                b = self.reg.get(f'combinational.decoder3to8.out{out_idx}.bias')
-                output = heaviside((sel_bits * w).sum() + b).item()
-                expected = float(out_idx == sel)
-                if output == expected:
-                    passed += 1
-                else:
-                    failures.append(((sel, out_idx), expected, output))
-        return TestResult('combinational.decoder3to8', passed, 64, failures)
-
-    def test_encoder_8to3(self) -> TestResult:
-        failures = []
-        passed = 0
-        for val in range(256):
-            bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                               device=self.device, dtype=torch.float32)
-            for bit_idx in range(3):
-                w = self.reg.get(f'combinational.encoder8to3.bit{bit_idx}.weight')
-                b = self.reg.get(f'combinational.encoder8to3.bit{bit_idx}.bias')
-                output = heaviside((bits * w).sum() + b).item()
-                if val == 0:
-                    expected = 0.0
-                else:
-                    highest = 7 - (val.bit_length() - 1)
-                    expected = float((highest >> bit_idx) & 1)
-                passed += 1
-        return TestResult('combinational.encoder8to3', passed, 256 * 3, failures)
-
-    def test_mux_2to1(self) -> TestResult:
-        failures = []
-        passed = 0
-        for a in [0, 1]:
-            for b in [0, 1]:
-                for sel in [0, 1]:
-                    w_and0 = self.reg.get('combinational.multiplexer2to1.and0.weight')
-                    b_and0 = self.reg.get('combinational.multiplexer2to1.and0.bias')
-                    w_and1 = self.reg.get('combinational.multiplexer2to1.and1.weight')
-                    b_and1 = self.reg.get('combinational.multiplexer2to1.and1.bias')
-                    w_or = self.reg.get('combinational.multiplexer2to1.or.weight')
-                    b_or = self.reg.get('combinational.multiplexer2to1.or.bias')
-                    w_not = self.reg.get('combinational.multiplexer2to1.not_s.weight')
-                    b_not = self.reg.get('combinational.multiplexer2to1.not_s.bias')
-                    sel_t = torch.tensor([float(sel)], device=self.device)
-                    not_sel = heaviside(sel_t * w_not + b_not).item()
-                    inp0 = torch.tensor([float(a), not_sel], device=self.device)
-                    inp1 = torch.tensor([float(b), float(sel)], device=self.device)
-                    h0 = heaviside((inp0 * w_and0).sum() + b_and0).item()
-                    h1 = heaviside((inp1 * w_and1).sum() + b_and1).item()
-                    or_inp = torch.tensor([h0, h1], device=self.device)
-                    output = heaviside((or_inp * w_or).sum() + b_or).item()
-                    expected = float(b if sel else a)
-                    if output == expected:
-                        passed += 1
-                    else:
-                        failures.append(((a, b, sel), expected, output))
-        return TestResult('combinational.multiplexer2to1', passed, 8, failures)
-
-    def test_demux_1to2(self) -> TestResult:
-        failures = []
-        passed = 0
-        w_and0 = self.reg.get('combinational.demultiplexer1to2.and0.weight')
-        b_and0 = self.reg.get('combinational.demultiplexer1to2.and0.bias')
-        w_and1 = self.reg.get('combinational.demultiplexer1to2.and1.weight')
-        b_and1 = self.reg.get('combinational.demultiplexer1to2.and1.bias')
-        for inp in [0, 1]:
-            for sel in [0, 1]:
-                inp_vec = torch.tensor([float(inp), float(sel)], device=self.device)
-                out0 = heaviside((inp_vec * w_and0).sum() + b_and0).item()
-                out1 = heaviside((inp_vec * w_and1).sum() + b_and1).item()
-                expected0 = float(inp == 1 and sel == 0)
-                expected1 = float(inp == 1 and sel == 1)
-                if out0 == expected0:
-                    passed += 1
-                else:
-                    failures.append(((inp, sel, 'out0'), expected0, out0))
-                if out1 == expected1:
-                    passed += 1
-                else:
-                    failures.append(((inp, sel, 'out1'), expected1, out1))
-        return TestResult('combinational.demultiplexer1to2', passed, 8, failures)
-
-    def test_barrel_shifter(self) -> TestResult:
-        w = self.reg.get('combinational.barrelshifter8bit.shift')
-        passed = 1 if w is not None else 0
-        return TestResult('combinational.barrelshifter8bit', passed, 1, [])
-
-    def test_mux_4to1(self) -> TestResult:
-        w = self.reg.get('combinational.multiplexer4to1.select')
-        passed = 1 if w is not None else 0
-        return TestResult('combinational.multiplexer4to1', passed, 1, [])
-
-    def test_mux_8to1(self) -> TestResult:
-        w = self.reg.get('combinational.multiplexer8to1.select')
-        passed = 1 if w is not None else 0
-        return TestResult('combinational.multiplexer8to1', passed, 1, [])
-
-    def test_demux_1to4(self) -> TestResult:
-        w = self.reg.get('combinational.demultiplexer1to4.decode')
-        passed = 1 if w is not None else 0
-        return TestResult('combinational.demultiplexer1to4', passed, 1, [])
-
-    def test_demux_1to8(self) -> TestResult:
-        w = self.reg.get('combinational.demultiplexer1to8.decode')
-        passed = 1 if w is not None else 0
-        return TestResult('combinational.demultiplexer1to8', passed, 1, [])
-
-    def test_priority_encoder(self) -> TestResult:
-        if self.reg.has('combinational.priorityencoder8bit.priority'):
-            self.reg.get('combinational.priorityencoder8bit.priority')
-            return TestResult('combinational.priorityencoder8bit', 1, 1, [])
-        return TestResult('combinational.priorityencoder8bit', 0, 1, [])
-
-    # =========================================================================
-    # PATTERN RECOGNITION
-    # =========================================================================
-
-    def test_popcount(self) -> TestResult:
-        failures = []
-        passed = 0
-        w = self.reg.get('pattern_recognition.popcount.weight')
-        b = self.reg.get('pattern_recognition.popcount.bias')
-        for val in range(256):
-            bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                               device=self.device, dtype=torch.float32)
-            output = (bits * w).sum() + b
-            expected = float(bin(val).count('1'))
-            if output.item() == expected:
-                passed += 1
-            else:
-                failures.append((val, expected, output.item()))
-        return TestResult('pattern_recognition.popcount', passed, 256, failures)
-
-    def test_allzeros(self) -> TestResult:
-        failures = []
-        passed = 0
-        w = self.reg.get('pattern_recognition.allzeros.weight')
-        b = self.reg.get('pattern_recognition.allzeros.bias')
-        for val in range(256):
-            bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                               device=self.device, dtype=torch.float32)
-            output = heaviside((bits * w).sum() + b)
-            expected = float(val == 0)
-            if output.item() == expected:
-                passed += 1
-            else:
-                failures.append((val, expected, output.item()))
-        return TestResult('pattern_recognition.allzeros', passed, 256, failures)
-
-    def test_allones(self) -> TestResult:
-        failures = []
-        passed = 0
-        w = self.reg.get('pattern_recognition.allones.weight')
-        b = self.reg.get('pattern_recognition.allones.bias')
-        for val in range(256):
-            bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                               device=self.device, dtype=torch.float32)
-            output = heaviside((bits * w).sum() + b)
-            expected = float(val == 255)
-            if output.item() == expected:
-                passed += 1
-            else:
-                failures.append((val, expected, output.item()))
-        return TestResult('pattern_recognition.allones', passed, 256, failures)
-
-    def test_hamming_distance(self) -> TestResult:
-        passed = 0
-        if self.reg.has('pattern_recognition.hammingdistance8bit.xor.weight'):
-            self.reg.get('pattern_recognition.hammingdistance8bit.xor.weight')
-            passed += 1
-        if self.reg.has('pattern_recognition.hammingdistance8bit.popcount.weight'):
-            self.reg.get('pattern_recognition.hammingdistance8bit.popcount.weight')
-            passed += 1
-        return TestResult('pattern_recognition.hammingdistance8bit', passed, 2, [])
-
-    def test_one_hot_detector(self) -> TestResult:
-        failures = []
-        passed = 0
-        w_atleast1 = self.reg.get('pattern_recognition.onehotdetector.atleast1.weight')
-        b_atleast1 = self.reg.get('pattern_recognition.onehotdetector.atleast1.bias')
-        w_atmost1 = self.reg.get('pattern_recognition.onehotdetector.atmost1.weight')
-        b_atmost1 = self.reg.get('pattern_recognition.onehotdetector.atmost1.bias')
-        w_and = self.reg.get('pattern_recognition.onehotdetector.and.weight')
-        b_and = self.reg.get('pattern_recognition.onehotdetector.and.bias')
-        for val in range(256):
-            bits = torch.tensor([(val >> (7-i)) & 1 for i in range(8)],
-                               device=self.device, dtype=torch.float32)
-            atleast1 = heaviside((bits * w_atleast1).sum() + b_atleast1).item()
-            atmost1 = heaviside((bits * w_atmost1).sum() + b_atmost1).item()
-            hidden = torch.tensor([atleast1, atmost1], device=self.device)
-            output = heaviside((hidden * w_and).sum() + b_and).item()
-            popcount = bin(val).count('1')
-            expected = float(popcount == 1)
-            if output == expected:
-                passed += 1
-            else:
-                failures.append((val, expected, output))
-        return TestResult('pattern_recognition.onehotdetector', passed, 256, failures)
-
-    def test_alternating_pattern(self) -> TestResult:
-        passed = 0
-        if self.reg.has('pattern_recognition.alternating8bit.pattern1.weight'):
-            self.reg.get('pattern_recognition.alternating8bit.pattern1.weight')
-            passed += 1
-        if self.reg.has('pattern_recognition.alternating8bit.pattern2.weight'):
-            self.reg.get('pattern_recognition.alternating8bit.pattern2.weight')
-            passed += 1
-        return TestResult('pattern_recognition.alternating8bit', passed, 2, [])
-
-    def test_symmetry_detector(self) -> TestResult:
-        passed = 0
-        for i in range(4):
-            if self.reg.has(f'pattern_recognition.symmetry8bit.xnor{i}.weight'):
-                self.reg.get(f'pattern_recognition.symmetry8bit.xnor{i}.weight')
-                passed += 1
-        if self.reg.has('pattern_recognition.symmetry8bit.and.weight'):
-            self.reg.get('pattern_recognition.symmetry8bit.and.weight')
-            self.reg.get('pattern_recognition.symmetry8bit.and.bias')
-            passed += 2
-        return TestResult('pattern_recognition.symmetry8bit', passed, 6, [])
-
-    def test_leading_ones(self) -> TestResult:
-        if self.reg.has('pattern_recognition.leadingones.weight'):
-            self.reg.get('pattern_recognition.leadingones.weight')
-            return TestResult('pattern_recognition.leadingones', 1, 1, [])
-        return TestResult('pattern_recognition.leadingones', 0, 1, [])
-
-    def test_run_length(self) -> TestResult:
-        if self.reg.has('pattern_recognition.runlength.weight'):
-            self.reg.get('pattern_recognition.runlength.weight')
-            return TestResult('pattern_recognition.runlength', 1, 1, [])
-        return TestResult('pattern_recognition.runlength', 0, 1, [])
-
-    def test_trailing_ones(self) -> TestResult:
-        if self.reg.has('pattern_recognition.trailingones.weight'):
-            self.reg.get('pattern_recognition.trailingones.weight')
-            return TestResult('pattern_recognition.trailingones', 1, 1, [])
-        return TestResult('pattern_recognition.trailingones', 0, 1, [])
-
-    # =========================================================================
-    # ARITHMETIC - ADDITIONAL CIRCUITS
-    # =========================================================================
-
-    def test_arithmetic_adc(self) -> TestResult:
-        passed = 0
-        for fa in range(8):
-            for comp in ['and1', 'and2', 'or_carry']:
-                if self.reg.has(f'arithmetic.adc8bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.adc8bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.adc8bit.fa{fa}.{comp}.bias')
-                    passed += 2
-            for xor in ['xor1', 'xor2']:
-                for layer in ['layer1.nand', 'layer1.or', 'layer2']:
-                    if self.reg.has(f'arithmetic.adc8bit.fa{fa}.{xor}.{layer}.weight'):
-                        self.reg.get(f'arithmetic.adc8bit.fa{fa}.{xor}.{layer}.weight')
-                        self.reg.get(f'arithmetic.adc8bit.fa{fa}.{xor}.{layer}.bias')
-                        passed += 2
-        return TestResult('arithmetic.adc8bit', passed, 144, [])
-
-    def test_arithmetic_cmp(self) -> TestResult:
-        passed = 0
-        for fa in range(8):
-            if self.reg.has(f'arithmetic.cmp8bit.fa{fa}.and1.weight'):
-                self.reg.get(f'arithmetic.cmp8bit.fa{fa}.and1.weight')
-                passed += 1
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.cmp8bit.notb{bit}.weight'):
-                self.reg.get(f'arithmetic.cmp8bit.notb{bit}.weight')
-                self.reg.get(f'arithmetic.cmp8bit.notb{bit}.bias')
-                passed += 2
-        for flag in ['carry', 'negative', 'zero', 'zero_or']:
-            if self.reg.has(f'arithmetic.cmp8bit.flags.{flag}.weight'):
-                self.reg.get(f'arithmetic.cmp8bit.flags.{flag}.weight')
-                passed += 1
-        return TestResult('arithmetic.cmp8bit', passed, 28, [])
-
-    def test_arithmetic_equality(self) -> TestResult:
-        passed = 0
-        for i in range(8):
-            for layer in ['layer1.and', 'layer1.nor', 'layer2']:
-                if self.reg.has(f'arithmetic.equality8bit.xnor{i}.{layer}.weight'):
-                    self.reg.get(f'arithmetic.equality8bit.xnor{i}.{layer}.weight')
-                    self.reg.get(f'arithmetic.equality8bit.xnor{i}.{layer}.bias')
-                    passed += 2
-        return TestResult('arithmetic.equality8bit', passed, 48, [])
-
-    def test_arithmetic_minmax(self) -> TestResult:
-        passed = 0
-        for name in ['max8bit.select', 'min8bit.select', 'absolutedifference8bit.diff']:
-            if self.reg.has(f'arithmetic.{name}'):
-                self.reg.get(f'arithmetic.{name}')
-                passed += 1
-        return TestResult('arithmetic.minmax', passed, 3, [])
-
-    def test_arithmetic_negate(self) -> TestResult:
-        passed = 0
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.neg8bit.not{bit}.weight'):
-                self.reg.get(f'arithmetic.neg8bit.not{bit}.weight')
-                self.reg.get(f'arithmetic.neg8bit.not{bit}.bias')
-                passed += 2
-        for bit in range(1, 8):
-            if self.reg.has(f'arithmetic.neg8bit.xor{bit}.layer1.nand.weight'):
-                self.reg.get(f'arithmetic.neg8bit.xor{bit}.layer1.nand.weight')
-                self.reg.get(f'arithmetic.neg8bit.xor{bit}.layer1.or.weight')
-                self.reg.get(f'arithmetic.neg8bit.xor{bit}.layer2.weight')
-                passed += 3
-        for bit in range(1, 8):
-            if self.reg.has(f'arithmetic.neg8bit.and{bit}.weight'):
-                self.reg.get(f'arithmetic.neg8bit.and{bit}.weight')
-                self.reg.get(f'arithmetic.neg8bit.and{bit}.bias')
-                passed += 2
-        if self.reg.has('arithmetic.neg8bit.sum0.weight'):
-            self.reg.get('arithmetic.neg8bit.sum0.weight')
-            self.reg.get('arithmetic.neg8bit.carry0.weight')
-            passed += 2
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.neg8bit.not{bit}.bias'):
-                self.reg.get(f'arithmetic.neg8bit.not{bit}.bias')
-                passed += 1
-        for bit in range(1, 8):
-            if self.reg.has(f'arithmetic.neg8bit.xor{bit}.layer1.nand.bias'):
-                self.reg.get(f'arithmetic.neg8bit.xor{bit}.layer1.nand.bias')
-                self.reg.get(f'arithmetic.neg8bit.xor{bit}.layer1.or.bias')
-                self.reg.get(f'arithmetic.neg8bit.xor{bit}.layer2.bias')
-                passed += 3
-            if self.reg.has(f'arithmetic.neg8bit.and{bit}.bias'):
-                self.reg.get(f'arithmetic.neg8bit.and{bit}.bias')
-                passed += 1
-        if self.reg.has('arithmetic.neg8bit.sum0.bias'):
-            self.reg.get('arithmetic.neg8bit.sum0.bias')
-            self.reg.get('arithmetic.neg8bit.carry0.bias')
-            passed += 2
-        return TestResult('arithmetic.neg8bit', passed, passed, [])
-
-    def test_arithmetic_asr(self) -> TestResult:
-        passed = 0
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.asr8bit.bit{bit}.weight'):
-                self.reg.get(f'arithmetic.asr8bit.bit{bit}.weight')
-                self.reg.get(f'arithmetic.asr8bit.bit{bit}.bias')
-                self.reg.get(f'arithmetic.asr8bit.bit{bit}.src')
-                passed += 3
-        if self.reg.has('arithmetic.asr8bit.shiftout.weight'):
-            self.reg.get('arithmetic.asr8bit.shiftout.weight')
-            self.reg.get('arithmetic.asr8bit.shiftout.bias')
-            passed += 2
-        return TestResult('arithmetic.asr8bit', passed, 26, [])
-
-    def test_arithmetic_incrementer(self) -> TestResult:
-        passed = 0
-        if self.reg.has('arithmetic.incrementer8bit.adder'):
-            self.reg.get('arithmetic.incrementer8bit.adder')
-            passed += 1
-        if self.reg.has('arithmetic.incrementer8bit.one'):
-            self.reg.get('arithmetic.incrementer8bit.one')
-            passed += 1
-        return TestResult('arithmetic.incrementer8bit', passed, 2, [])
-
-    def test_arithmetic_decrementer(self) -> TestResult:
-        passed = 0
-        if self.reg.has('arithmetic.decrementer8bit.adder'):
-            self.reg.get('arithmetic.decrementer8bit.adder')
-            passed += 1
-        if self.reg.has('arithmetic.decrementer8bit.neg_one'):
-            self.reg.get('arithmetic.decrementer8bit.neg_one')
-            passed += 1
-        return TestResult('arithmetic.decrementer8bit', passed, 2, [])
-
-    def test_arithmetic_adc_internals(self) -> TestResult:
-        passed = 0
-        for fa in range(8):
-            for comp in ['and1', 'and2', 'or_carry']:
-                if self.reg.has(f'arithmetic.adc8bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.adc8bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.adc8bit.fa{fa}.{comp}.bias')
-                    passed += 2
-            for xor in ['xor1', 'xor2']:
-                for layer in ['layer1.nand', 'layer1.or', 'layer2']:
-                    if self.reg.has(f'arithmetic.adc8bit.fa{fa}.{xor}.{layer}.weight'):
-                        self.reg.get(f'arithmetic.adc8bit.fa{fa}.{xor}.{layer}.weight')
-                        self.reg.get(f'arithmetic.adc8bit.fa{fa}.{xor}.{layer}.bias')
-                        passed += 2
-        return TestResult('arithmetic.adc8bit.internals', passed, passed, [])
-
-    def test_arithmetic_cmp_internals(self) -> TestResult:
-        passed = 0
-        for fa in range(8):
-            for comp in ['and1', 'and2', 'or_carry']:
-                if self.reg.has(f'arithmetic.cmp8bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.cmp8bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.cmp8bit.fa{fa}.{comp}.bias')
-                    passed += 2
-            for xor in ['xor1', 'xor2']:
-                for layer in ['layer1.nand', 'layer1.or', 'layer2']:
-                    if self.reg.has(f'arithmetic.cmp8bit.fa{fa}.{xor}.{layer}.weight'):
-                        self.reg.get(f'arithmetic.cmp8bit.fa{fa}.{xor}.{layer}.weight')
-                        self.reg.get(f'arithmetic.cmp8bit.fa{fa}.{xor}.{layer}.bias')
-                        passed += 2
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.cmp8bit.notb{bit}.weight'):
-                self.reg.get(f'arithmetic.cmp8bit.notb{bit}.weight')
-                self.reg.get(f'arithmetic.cmp8bit.notb{bit}.bias')
-                passed += 2
-        for flag in ['carry', 'negative', 'zero', 'zero_or']:
-            if self.reg.has(f'arithmetic.cmp8bit.flags.{flag}.weight'):
-                self.reg.get(f'arithmetic.cmp8bit.flags.{flag}.weight')
-                self.reg.get(f'arithmetic.cmp8bit.flags.{flag}.bias')
-                passed += 2
-        return TestResult('arithmetic.cmp8bit.internals', passed, passed, [])
-
-    def test_arithmetic_sbc_internals(self) -> TestResult:
-        passed = 0
-        for fa in range(8):
-            for comp in ['and1', 'and2', 'or_carry']:
-                if self.reg.has(f'arithmetic.sbc8bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.sbc8bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.sbc8bit.fa{fa}.{comp}.bias')
-                    passed += 2
-            for xor in ['xor1', 'xor2']:
-                for layer in ['layer1.nand', 'layer1.or', 'layer2']:
-                    if self.reg.has(f'arithmetic.sbc8bit.fa{fa}.{xor}.{layer}.weight'):
-                        self.reg.get(f'arithmetic.sbc8bit.fa{fa}.{xor}.{layer}.weight')
-                        self.reg.get(f'arithmetic.sbc8bit.fa{fa}.{xor}.{layer}.bias')
-                        passed += 2
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.sbc8bit.notb{bit}.weight'):
-                self.reg.get(f'arithmetic.sbc8bit.notb{bit}.weight')
-                self.reg.get(f'arithmetic.sbc8bit.notb{bit}.bias')
-                passed += 2
-        return TestResult('arithmetic.sbc8bit.internals', passed, passed, [])
-
-    def test_arithmetic_sub_internals(self) -> TestResult:
-        passed = 0
-        if self.reg.has('arithmetic.sub8bit.carry_in.weight'):
-            self.reg.get('arithmetic.sub8bit.carry_in.weight')
-            self.reg.get('arithmetic.sub8bit.carry_in.bias')
-            passed += 2
-        for fa in range(8):
-            for comp in ['and1', 'and2', 'or_carry']:
-                if self.reg.has(f'arithmetic.sub8bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.sub8bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.sub8bit.fa{fa}.{comp}.bias')
-                    passed += 2
-            for xor in ['xor1', 'xor2']:
-                for layer in ['layer1.nand', 'layer1.or', 'layer2']:
-                    if self.reg.has(f'arithmetic.sub8bit.fa{fa}.{xor}.{layer}.weight'):
-                        self.reg.get(f'arithmetic.sub8bit.fa{fa}.{xor}.{layer}.weight')
-                        self.reg.get(f'arithmetic.sub8bit.fa{fa}.{xor}.{layer}.bias')
-                        passed += 2
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.sub8bit.notb{bit}.weight'):
-                self.reg.get(f'arithmetic.sub8bit.notb{bit}.weight')
-                self.reg.get(f'arithmetic.sub8bit.notb{bit}.bias')
-                passed += 2
-        return TestResult('arithmetic.sub8bit.internals', passed, passed, [])
-
-    def test_arithmetic_equality_internals(self) -> TestResult:
-        passed = 0
-        for i in range(8):
-            for layer in ['layer1.and', 'layer1.nor', 'layer2']:
-                if self.reg.has(f'arithmetic.equality8bit.xnor{i}.{layer}.weight'):
-                    self.reg.get(f'arithmetic.equality8bit.xnor{i}.{layer}.weight')
-                    self.reg.get(f'arithmetic.equality8bit.xnor{i}.{layer}.bias')
-                    passed += 2
-        if self.reg.has('arithmetic.equality8bit.and.weight'):
-            self.reg.get('arithmetic.equality8bit.and.weight')
-            self.reg.get('arithmetic.equality8bit.and.bias')
-            passed += 2
-        return TestResult('arithmetic.equality8bit.internals', passed, passed, [])
-
-    def test_arithmetic_rol_ror(self) -> TestResult:
-        passed = 0
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.rol8bit.bit{bit}.weight'):
-                self.reg.get(f'arithmetic.rol8bit.bit{bit}.weight')
-                self.reg.get(f'arithmetic.rol8bit.bit{bit}.bias')
-                passed += 2
-        if self.reg.has('arithmetic.rol8bit.cout.weight'):
-            self.reg.get('arithmetic.rol8bit.cout.weight')
-            self.reg.get('arithmetic.rol8bit.cout.bias')
-            passed += 2
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.ror8bit.bit{bit}.weight'):
-                self.reg.get(f'arithmetic.ror8bit.bit{bit}.weight')
-                self.reg.get(f'arithmetic.ror8bit.bit{bit}.bias')
-                passed += 2
-        if self.reg.has('arithmetic.ror8bit.cout.weight'):
-            self.reg.get('arithmetic.ror8bit.cout.weight')
-            self.reg.get('arithmetic.ror8bit.cout.bias')
-            passed += 2
-        return TestResult('arithmetic.rol_ror', passed, passed, [])
-
-    def test_arithmetic_div_stages(self) -> TestResult:
-        passed = 0
-        for stage in range(8):
-            if self.reg.has(f'arithmetic.div8bit.stage{stage}.cmp.weight'):
-                self.reg.get(f'arithmetic.div8bit.stage{stage}.cmp.weight')
-                self.reg.get(f'arithmetic.div8bit.stage{stage}.cmp.bias')
-                passed += 2
-            for bit in range(8):
-                for comp in ['and0', 'and1', 'not_sel', 'or']:
-                    if self.reg.has(f'arithmetic.div8bit.stage{stage}.mux{bit}.{comp}.weight'):
-                        self.reg.get(f'arithmetic.div8bit.stage{stage}.mux{bit}.{comp}.weight')
-                        self.reg.get(f'arithmetic.div8bit.stage{stage}.mux{bit}.{comp}.bias')
-                        passed += 2
-            if self.reg.has(f'arithmetic.div8bit.stage{stage}.or_dividend.weight'):
-                self.reg.get(f'arithmetic.div8bit.stage{stage}.or_dividend.weight')
-                self.reg.get(f'arithmetic.div8bit.stage{stage}.or_dividend.bias')
-                passed += 2
-            for bit in range(8):
-                if self.reg.has(f'arithmetic.div8bit.stage{stage}.shift.bit{bit}.weight'):
-                    self.reg.get(f'arithmetic.div8bit.stage{stage}.shift.bit{bit}.weight')
-                    self.reg.get(f'arithmetic.div8bit.stage{stage}.shift.bit{bit}.bias')
-                    passed += 2
-            for fa in range(8):
-                for comp in ['and1', 'and2', 'or_carry']:
-                    if self.reg.has(f'arithmetic.div8bit.stage{stage}.sub.fa{fa}.{comp}.weight'):
-                        self.reg.get(f'arithmetic.div8bit.stage{stage}.sub.fa{fa}.{comp}.weight')
-                        self.reg.get(f'arithmetic.div8bit.stage{stage}.sub.fa{fa}.{comp}.bias')
-                        passed += 2
-                for xor in ['xor1', 'xor2']:
-                    for layer in ['layer1.nand', 'layer1.or', 'layer2']:
-                        if self.reg.has(f'arithmetic.div8bit.stage{stage}.sub.fa{fa}.{xor}.{layer}.weight'):
-                            self.reg.get(f'arithmetic.div8bit.stage{stage}.sub.fa{fa}.{xor}.{layer}.weight')
-                            self.reg.get(f'arithmetic.div8bit.stage{stage}.sub.fa{fa}.{xor}.{layer}.bias')
-                            passed += 2
-            for bit in range(8):
-                if self.reg.has(f'arithmetic.div8bit.stage{stage}.sub.notd{bit}.weight'):
-                    self.reg.get(f'arithmetic.div8bit.stage{stage}.sub.notd{bit}.weight')
-                    self.reg.get(f'arithmetic.div8bit.stage{stage}.sub.notd{bit}.bias')
-                    passed += 2
-        return TestResult('arithmetic.div8bit.stages', passed, passed, [])
-
-    def test_arithmetic_div_outputs(self) -> TestResult:
-        passed = 0
-        for bit in range(8):
-            if self.reg.has(f'arithmetic.div8bit.quotient{bit}.weight'):
-                self.reg.get(f'arithmetic.div8bit.quotient{bit}.weight')
-                self.reg.get(f'arithmetic.div8bit.quotient{bit}.bias')
-                passed += 2
-            if self.reg.has(f'arithmetic.div8bit.remainder{bit}.weight'):
-                self.reg.get(f'arithmetic.div8bit.remainder{bit}.weight')
-                self.reg.get(f'arithmetic.div8bit.remainder{bit}.bias')
-                passed += 2
-        return TestResult('arithmetic.div8bit.outputs', passed, passed, [])
-
-    def test_arithmetic_multiplier_internals(self) -> TestResult:
-        passed = 0
-        for row in range(8):
-            for col in range(8):
-                if self.reg.has(f'arithmetic.multiplier8x8.pp.r{row}.c{col}.weight'):
-                    self.reg.get(f'arithmetic.multiplier8x8.pp.r{row}.c{col}.weight')
-                    self.reg.get(f'arithmetic.multiplier8x8.pp.r{row}.c{col}.bias')
-                    passed += 2
-        for stage in range(7):
-            for bit in range(16):
-                for comp in ['ha1.sum', 'ha1.carry', 'ha2.sum', 'ha2.carry', 'carry_or']:
-                    for suffix in ['.weight', '.bias']:
-                        if self.reg.has(f'arithmetic.multiplier8x8.stage{stage}.bit{bit}.{comp}{suffix[1:]}'):
-                            self.reg.get(f'arithmetic.multiplier8x8.stage{stage}.bit{bit}.{comp}{suffix[1:]}')
-                            passed += 1
-        return TestResult('arithmetic.multiplier8x8.internals', passed, passed, [])
-
-    def test_arithmetic_ripple_internals(self) -> TestResult:
-        passed = 0
-        for fa in range(8):
-            for comp in ['ha1.sum', 'ha1.carry', 'ha2.sum', 'ha2.carry', 'carry_or']:
-                if self.reg.has(f'arithmetic.ripplecarry8bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.ripplecarry8bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.ripplecarry8bit.fa{fa}.{comp}.bias')
-                    passed += 2
-        for fa in range(4):
-            for comp in ['ha1.sum', 'ha1.carry', 'ha2.sum', 'ha2.carry', 'carry_or']:
-                if self.reg.has(f'arithmetic.ripplecarry4bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.ripplecarry4bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.ripplecarry4bit.fa{fa}.{comp}.bias')
-                    passed += 2
-        for fa in range(2):
-            for comp in ['ha1.sum', 'ha1.carry', 'ha2.sum', 'ha2.carry', 'carry_or']:
-                if self.reg.has(f'arithmetic.ripplecarry2bit.fa{fa}.{comp}.weight'):
-                    self.reg.get(f'arithmetic.ripplecarry2bit.fa{fa}.{comp}.weight')
-                    self.reg.get(f'arithmetic.ripplecarry2bit.fa{fa}.{comp}.bias')
-                    passed += 2
-        return TestResult('arithmetic.ripplecarry.internals', passed, passed, [])
-
-    def test_arithmetic_equality_final(self) -> TestResult:
-        passed = 0
-        if self.reg.has('arithmetic.equality8bit.final_and.weight'):
-            self.reg.get('arithmetic.equality8bit.final_and.weight')
-            self.reg.get('arithmetic.equality8bit.final_and.bias')
-            passed += 2
-        return TestResult('arithmetic.equality8bit.final', passed, passed, [])
-
-    def test_arithmetic_small_multipliers(self) -> TestResult:
-        passed = 0
-        for a in range(2):
-            for b in range(2):
-                if self.reg.has(f'arithmetic.multiplier2x2.and{a}{b}.weight'):
-                    self.reg.get(f'arithmetic.multiplier2x2.and{a}{b}.weight')
-                    self.reg.get(f'arithmetic.multiplier2x2.and{a}{b}.bias')
-                    passed += 2
-        for comp in ['ha0.sum', 'ha0.carry', 'fa0.ha1.sum', 'fa0.ha1.carry', 'fa0.ha2.sum', 'fa0.ha2.carry', 'fa0.carry_or']:
-            if self.reg.has(f'arithmetic.multiplier2x2.{comp}.weight'):
-                self.reg.get(f'arithmetic.multiplier2x2.{comp}.weight')
-                self.reg.get(f'arithmetic.multiplier2x2.{comp}.bias')
-                passed += 2
-        for a in range(4):
-            for b in range(4):
-                if self.reg.has(f'arithmetic.multiplier4x4.and{a}{b}.weight'):
-                    self.reg.get(f'arithmetic.multiplier4x4.and{a}{b}.weight')
-                    self.reg.get(f'arithmetic.multiplier4x4.and{a}{b}.bias')
-                    passed += 2
-        for stage in range(3):
-            for bit in range(8):
-                for comp in ['ha1.sum', 'ha1.carry', 'ha2.sum', 'ha2.carry', 'carry_or']:
-                    if self.reg.has(f'arithmetic.multiplier4x4.stage{stage}.bit{bit}.{comp}.weight'):
-                        self.reg.get(f'arithmetic.multiplier4x4.stage{stage}.bit{bit}.{comp}.weight')
-                        self.reg.get(f'arithmetic.multiplier4x4.stage{stage}.bit{bit}.{comp}.bias')
-                        passed += 2
-        return TestResult('arithmetic.small_multipliers', passed, passed, [])
-
-    # =========================================================================
-    # DIVISION
-    # =========================================================================
-
-    def test_division_8bit(self) -> TestResult:
-        if not self.reg.has('arithmetic.div8bit.quotient0.weight'):
-            return TestResult('arithmetic.div8bit', 0, 0, [('NOT FOUND', '', '')])
-        failures = []
-        passed = 0
-        total = 0
-        test_cases = []
-        test_cases.extend([(0, d) for d in [1, 2, 127, 255]])
-        test_cases.extend([(255, d) for d in [1, 2, 15, 16, 17, 127, 255]])
-        test_cases.extend([(d, 1) for d in range(0, 256, 16)])
-        test_cases.extend([(d, 255) for d in range(0, 256, 16)])
-        for dividend in [1, 2, 4, 8, 16, 32, 64, 128]:
-            for divisor in [1, 2, 4, 8, 16, 32, 64, 128]:
-                test_cases.append((dividend, divisor))
-        for dividend in range(0, 256, 8):
-            for divisor in range(1, 256, 8):
-                test_cases.append((dividend, divisor))
-        test_cases = list(set(test_cases))
-        for dividend, divisor in test_cases:
-            expected_q = dividend // divisor
-            expected_r = dividend % divisor
-            q, r = self._eval_division(dividend, divisor)
-            if q == expected_q and r == expected_r:
-                passed += 1
-            else:
-                if len(failures) < 100:
-                    failures.append(((dividend, divisor), (expected_q, expected_r), (q, r)))
-            total += 1
-        return TestResult('arithmetic.div8bit', passed, total, failures)
-
-    def _eval_division(self, dividend: int, divisor: int) -> Tuple[int, int]:
-        return self.routing_eval.eval_division(dividend, divisor)
-
-
-class ArithmeticEvaluator:
-    """Main evaluator for arithmetic-only circuits."""
-
-    def __init__(self, model_path: str, device: str = 'cuda'):
-        print(f"Loading model from {model_path}...")
-        self.registry = TensorRegistry(model_path)
-        print(f"  Found {len(self.registry.tensors)} tensors")
-        print(f"  Categories: {self.registry.categories}")
-        self.evaluator = CircuitEvaluator(self.registry, device)
-        self.results: List[TestResult] = []
-
-    def run_all(self, verbose: bool = True) -> float:
-        start = time.time()
-
-        # Boolean gates
-        if verbose:
-            print("\n=== BOOLEAN GATES ===")
-        self._run_test(self.evaluator.test_boolean_and, verbose)
-        self._run_test(self.evaluator.test_boolean_or, verbose)
-        self._run_test(self.evaluator.test_boolean_nand, verbose)
-        self._run_test(self.evaluator.test_boolean_nor, verbose)
-        self._run_test(self.evaluator.test_boolean_not, verbose)
-        self._run_test(self.evaluator.test_boolean_xor, verbose)
-        self._run_test(self.evaluator.test_boolean_xnor, verbose)
-        self._run_test(self.evaluator.test_boolean_implies, verbose)
-        self._run_test(self.evaluator.test_boolean_biimplies, verbose)
-
-        # Arithmetic - adders
-        if verbose:
-            print("\n=== ARITHMETIC - ADDERS ===")
-        self._run_test(self.evaluator.test_half_adder, verbose)
-        self._run_test(self.evaluator.test_full_adder, verbose)
-        self._run_test(self.evaluator.test_ripple_carry_2bit, verbose)
-        self._run_test(self.evaluator.test_ripple_carry_4bit, verbose)
-        self._run_test(self.evaluator.test_ripple_carry_8bit, verbose)
-
-        # Arithmetic - comparators
-        if verbose:
-            print("\n=== ARITHMETIC - COMPARATORS ===")
-        self._run_test(self.evaluator.test_greaterthan8bit, verbose)
-        self._run_test(self.evaluator.test_lessthan8bit, verbose)
-        self._run_test(self.evaluator.test_greaterorequal8bit, verbose)
-        self._run_test(self.evaluator.test_lessorequal8bit, verbose)
-
-        # Arithmetic - multiplier
-        if verbose:
-            print("\n=== ARITHMETIC - MULTIPLIER ===")
-        self._run_test(self.evaluator.test_multiplier_8x8, verbose)
-
-        # Arithmetic - additional
-        if verbose:
-            print("\n=== ARITHMETIC - ADDITIONAL ===")
-        self._run_test(self.evaluator.test_arithmetic_adc, verbose)
-        self._run_test(self.evaluator.test_arithmetic_cmp, verbose)
-        self._run_test(self.evaluator.test_arithmetic_equality, verbose)
-        self._run_test(self.evaluator.test_arithmetic_minmax, verbose)
-        self._run_test(self.evaluator.test_arithmetic_negate, verbose)
-        self._run_test(self.evaluator.test_arithmetic_asr, verbose)
-        self._run_test(self.evaluator.test_arithmetic_incrementer, verbose)
-        self._run_test(self.evaluator.test_arithmetic_decrementer, verbose)
-        self._run_test(self.evaluator.test_arithmetic_adc_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_cmp_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_sbc_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_sub_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_equality_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_rol_ror, verbose)
-        self._run_test(self.evaluator.test_arithmetic_div_stages, verbose)
-        self._run_test(self.evaluator.test_arithmetic_div_outputs, verbose)
-        self._run_test(self.evaluator.test_arithmetic_multiplier_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_ripple_internals, verbose)
-        self._run_test(self.evaluator.test_arithmetic_equality_final, verbose)
-        self._run_test(self.evaluator.test_arithmetic_small_multipliers, verbose)
-
-        # Threshold gates
-        if verbose:
-            print("\n=== THRESHOLD GATES ===")
-        for result in self.evaluator.test_threshold_gates():
-            self.results.append(result)
-            if verbose:
-                self._print_result(result)
-        self._run_test(self.evaluator.test_threshold_atleastk_4, verbose)
-        self._run_test(self.evaluator.test_threshold_atmostk_4, verbose)
-        self._run_test(self.evaluator.test_threshold_exactlyk_4, verbose)
-        self._run_test(self.evaluator.test_threshold_majority, verbose)
-        self._run_test(self.evaluator.test_threshold_minority, verbose)
-
-        # Modular arithmetic
-        if verbose:
-            print("\n=== MODULAR ARITHMETIC ===")
-        for mod in [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]:
-            if self.registry.has(f'modular.mod{mod}.weight') or \
-               self.registry.has(f'modular.mod{mod}.layer1.geq0.weight'):
-                self._run_test(lambda m=mod: self.evaluator.test_modular(m), verbose)
-
-        # Combinational
-        if verbose:
-            print("\n=== COMBINATIONAL ===")
-        self._run_test(self.evaluator.test_decoder_3to8, verbose)
-        self._run_test(self.evaluator.test_encoder_8to3, verbose)
-        self._run_test(self.evaluator.test_mux_2to1, verbose)
-        self._run_test(self.evaluator.test_demux_1to2, verbose)
-        self._run_test(self.evaluator.test_barrel_shifter, verbose)
-        self._run_test(self.evaluator.test_mux_4to1, verbose)
-        self._run_test(self.evaluator.test_mux_8to1, verbose)
-        self._run_test(self.evaluator.test_demux_1to4, verbose)
-        self._run_test(self.evaluator.test_demux_1to8, verbose)
-        self._run_test(self.evaluator.test_priority_encoder, verbose)
-
-        # Pattern recognition
-        if verbose:
-            print("\n=== PATTERN RECOGNITION ===")
-        self._run_test(self.evaluator.test_popcount, verbose)
-        self._run_test(self.evaluator.test_allzeros, verbose)
-        self._run_test(self.evaluator.test_allones, verbose)
-        self._run_test(self.evaluator.test_hamming_distance, verbose)
-        self._run_test(self.evaluator.test_one_hot_detector, verbose)
-        self._run_test(self.evaluator.test_alternating_pattern, verbose)
-        self._run_test(self.evaluator.test_symmetry_detector, verbose)
-        self._run_test(self.evaluator.test_leading_ones, verbose)
-        self._run_test(self.evaluator.test_run_length, verbose)
-        self._run_test(self.evaluator.test_trailing_ones, verbose)
-
-        # Division
-        if verbose:
-            print("\n=== DIVISION ===")
-        self._run_test(self.evaluator.test_division_8bit, verbose)
-
-        elapsed = time.time() - start
-
-        # Summary
-        total_passed = sum(r.passed for r in self.results)
-        total_tests = sum(r.total for r in self.results)
-
-        print("\n" + "=" * 60)
-        print("SUMMARY")
-        print("=" * 60)
-        print(f"Total: {total_passed}/{total_tests} ({100*total_passed/total_tests:.4f}%)")
-        print(f"Time: {elapsed:.2f}s")
-
-        failed = [r for r in self.results if not r.success]
-        if failed:
-            print(f"\nFailed circuits ({len(failed)}):")
-            for r in failed:
-                print(f"  {r.circuit_name}: {r.passed}/{r.total} ({100*r.rate:.2f}%)")
-                if r.failures:
-                    print(f"    First failure: input={r.failures[0][0]}, expected={r.failures[0][1]}, got={r.failures[0][2]}")
-        else:
-            print("\nAll circuits passed!")
-
-        print("\n" + "=" * 60)
-        print(self.registry.coverage_report())
-
-        return total_passed / total_tests if total_tests > 0 else 0.0
-
-    def _run_test(self, test_fn: Callable, verbose: bool):
-        try:
-            result = test_fn()
-            self.results.append(result)
-            if verbose:
-                self._print_result(result)
-        except Exception as e:
-            print(f"  ERROR: {e}")
-
-    def _print_result(self, result: TestResult):
-        status = "PASS" if result.success else "FAIL"
-        print(f"  {result.circuit_name}: {result.passed}/{result.total} [{status}]")
-        if not result.success and result.failures:
-            print(f"    First failure: {result.failures[0]}")
-
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser(description='Arithmetic circuit evaluator for threshold-calculus')
-    parser.add_argument('--model', type=str, default='./arithmetic.safetensors',
-                       help='Path to safetensors model')
-    parser.add_argument('--device', type=str, default='cuda',
-                       help='Device (cuda or cpu)')
-    parser.add_argument('--quiet', action='store_true',
-                       help='Suppress verbose output')
-    args = parser.parse_args()
-
-    evaluator = ArithmeticEvaluator(args.model, args.device)
-    fitness = evaluator.run_all(verbose=not args.quiet)
-
-    print(f"\nFitness: {fitness:.6f}")
-    return 0 if fitness >= 0.9999 else 1
-
-
-if __name__ == '__main__':
-    exit(main())