Remove tests/test_all.py - merged into eval/iron_eval.py

tests/test_all.py

@@ -1,898 +0,0 @@
-"""
-UNIFIED TEST SUITE FOR 8-BIT THRESHOLD COMPUTER
-================================================
-Combined tests from:
-1. Overflow Chains - Chained arithmetic operations
-2. Equivalence - Exhaustive verification against Python
-3. Gate Reconstruction - Derive Boolean functions from weights
-4. Perturbation - Adversarial weight changes
-5. Timing - Circuit depth analysis
-6. Cryptographic Self-Test - Checksum verification
-7. Self-Modifying Code - Von Neumann architecture
-8. Turing Completeness - Rule 110 and Brainfuck
-9. Independence - Derive weights from specification
-10. Skeptic Tests - Mathematical property verification
-11. Stress Tests - Complex algorithms
-"""
-
-import torch
-from safetensors.torch import load_file
-from itertools import product
-from collections import Counter
-import random
-import time
-
-# =============================================================================
-# MODEL LOADING
-# =============================================================================
-
-model = load_file('neural_computer.safetensors')
-
-# =============================================================================
-# CORE PRIMITIVES
-# =============================================================================
-
-def heaviside(x):
-    """Threshold activation function."""
-    return (x >= 0).float()
-
-def int_to_bits(val, width=8):
-    """Convert int to bits, MSB first."""
-    return torch.tensor([(val >> (width-1-i)) & 1 for i in range(width)], dtype=torch.float32)
-
-def int_to_bits_lsb(val, width=8):
-    """Convert int to bits, LSB first."""
-    return torch.tensor([(val >> i) & 1 for i in range(width)], dtype=torch.float32)
-
-def bits_to_int(bits):
-    """Convert bits back to int, MSB first."""
-    val = 0
-    for i, b in enumerate(bits):
-        val |= (int(b.item()) << (len(bits)-1-i))
-    return val
-
-# =============================================================================
-# BOOLEAN GATE PRIMITIVES
-# =============================================================================
-
-def eval_and(a, b):
-    inp = torch.tensor([float(a), float(b)])
-    return int(heaviside(inp @ model['boolean.and.weight'] + model['boolean.and.bias']).item())
-
-def eval_or(a, b):
-    inp = torch.tensor([float(a), float(b)])
-    return int(heaviside(inp @ model['boolean.or.weight'] + model['boolean.or.bias']).item())
-
-def eval_not(a):
-    inp = torch.tensor([float(a)])
-    return int(heaviside(inp @ model['boolean.not.weight'] + model['boolean.not.bias']).item())
-
-def eval_nand(a, b):
-    inp = torch.tensor([float(a), float(b)])
-    return int(heaviside(inp @ model['boolean.nand.weight'] + model['boolean.nand.bias']).item())
-
-def eval_nor(a, b):
-    inp = torch.tensor([float(a), float(b)])
-    return int(heaviside(inp @ model['boolean.nor.weight'] + model['boolean.nor.bias']).item())
-
-def eval_xor(a, b):
-    inp = torch.tensor([float(a), float(b)])
-    w1_n1 = model['boolean.xor.layer1.neuron1.weight']
-    b1_n1 = model['boolean.xor.layer1.neuron1.bias']
-    w1_n2 = model['boolean.xor.layer1.neuron2.weight']
-    b1_n2 = model['boolean.xor.layer1.neuron2.bias']
-    w2 = model['boolean.xor.layer2.weight']
-    b2 = model['boolean.xor.layer2.bias']
-    h1 = heaviside(inp @ w1_n1 + b1_n1)
-    h2 = heaviside(inp @ w1_n2 + b1_n2)
-    hidden = torch.tensor([h1.item(), h2.item()])
-    return int(heaviside(hidden @ w2 + b2).item())
-
-def eval_xnor(a, b):
-    inp = torch.tensor([float(a), float(b)])
-    w1_n1 = model['boolean.xnor.layer1.neuron1.weight']
-    b1_n1 = model['boolean.xnor.layer1.neuron1.bias']
-    w1_n2 = model['boolean.xnor.layer1.neuron2.weight']
-    b1_n2 = model['boolean.xnor.layer1.neuron2.bias']
-    w2 = model['boolean.xnor.layer2.weight']
-    b2 = model['boolean.xnor.layer2.bias']
-    h1 = heaviside(inp @ w1_n1 + b1_n1)
-    h2 = heaviside(inp @ w1_n2 + b1_n2)
-    hidden = torch.tensor([h1.item(), h2.item()])
-    return int(heaviside(hidden @ w2 + b2).item())
-
-# =============================================================================
-# ARITHMETIC PRIMITIVES
-# =============================================================================
-
-def eval_xor_arith(inp, prefix):
-    """XOR for arithmetic circuits (different naming convention)."""
-    w1_or = model[f'{prefix}.layer1.or.weight']
-    b1_or = model[f'{prefix}.layer1.or.bias']
-    w1_nand = model[f'{prefix}.layer1.nand.weight']
-    b1_nand = model[f'{prefix}.layer1.nand.bias']
-    w2 = model[f'{prefix}.layer2.weight']
-    b2 = model[f'{prefix}.layer2.bias']
-    h_or = heaviside(inp @ w1_or + b1_or)
-    h_nand = heaviside(inp @ w1_nand + b1_nand)
-    hidden = torch.tensor([h_or.item(), h_nand.item()])
-    return heaviside(hidden @ w2 + b2).item()
-
-def eval_full_adder(a, b, cin, prefix):
-    """Full adder: returns (sum, carry_out)."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    ha1_carry = heaviside(inp_ab @ model[f'{prefix}.ha1.carry.weight'] + model[f'{prefix}.ha1.carry.bias']).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    ha2_carry = heaviside(inp_ha2 @ model[f'{prefix}.ha2.carry.weight'] + model[f'{prefix}.ha2.carry.bias']).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    cout = heaviside(inp_cout @ model[f'{prefix}.carry_or.weight'] + model[f'{prefix}.carry_or.bias']).item()
-    return int(ha2_sum), int(cout)
-
-def add_8bit(a, b):
-    """8-bit addition using ripple carry adder."""
-    carry = 0.0
-    result = 0
-    for i in range(8):
-        s, carry = eval_full_adder(float((a >> i) & 1), float((b >> i) & 1), carry, f'arithmetic.ripplecarry8bit.fa{i}')
-        result |= (s << i)
-    return result, int(carry)
-
-def sub_8bit(a, b):
-    """8-bit subtraction via two's complement."""
-    not_b = (~b) & 0xFF
-    temp, _ = add_8bit(a, not_b)
-    result, c = add_8bit(temp, 1)
-    return result, c
-
-# =============================================================================
-# BYTE-LEVEL OPERATIONS
-# =============================================================================
-
-def xor_8bit(a, b):
-    result = 0
-    for i in range(8):
-        result |= (eval_xor((a >> i) & 1, (b >> i) & 1) << i)
-    return result
-
-def and_8bit(a, b):
-    result = 0
-    for i in range(8):
-        result |= (eval_and((a >> i) & 1, (b >> i) & 1) << i)
-    return result
-
-def or_8bit(a, b):
-    result = 0
-    for i in range(8):
-        result |= (eval_or((a >> i) & 1, (b >> i) & 1) << i)
-    return result
-
-def not_8bit(a):
-    result = 0
-    for i in range(8):
-        result |= (eval_not((a >> i) & 1) << i)
-    return result
-
-# =============================================================================
-# COMPARATORS
-# =============================================================================
-
-def gt(a, b):
-    a_bits, b_bits = int_to_bits(a), int_to_bits(b)
-    w = model['arithmetic.greaterthan8bit.comparator']
-    return 1 if ((a_bits - b_bits) @ w).item() > 0 else 0
-
-def lt(a, b):
-    a_bits, b_bits = int_to_bits(a), int_to_bits(b)
-    w = model['arithmetic.lessthan8bit.comparator']
-    return 1 if ((b_bits - a_bits) @ w).item() > 0 else 0
-
-def eq(a, b):
-    return 1 if (gt(a, b) == 0 and lt(a, b) == 0) else 0
-
-def popcount(val):
-    bits = int_to_bits(val)
-    w = model['pattern_recognition.popcount.weight']
-    b = model['pattern_recognition.popcount.bias']
-    return int((bits @ w + b).item())
-
-# =============================================================================
-# TEST SECTION 1: SKEPTIC TESTS (Mathematical Properties)
-# =============================================================================
-
-def test_skeptic():
-    """127 skeptical tests for mathematical properties."""
-    print("\n" + "=" * 70)
-    print("SKEPTIC TESTS - Mathematical Properties")
-    print("=" * 70)
-
-    failures = []
-
-    # Identity laws
-    for a in [0, 1, 127, 128, 255, 170, 85]:
-        r, _ = add_8bit(a, 0)
-        if r != a: failures.append(f'A+0: {a}')
-        if xor_8bit(a, 0) != a: failures.append(f'A^0: {a}')
-        if and_8bit(a, 255) != a: failures.append(f'A&255: {a}')
-        if or_8bit(a, 0) != a: failures.append(f'A|0: {a}')
-
-    # Annihilation laws
-    for a in [0, 1, 127, 128, 255]:
-        if and_8bit(a, 0) != 0: failures.append(f'A&0: {a}')
-        if or_8bit(a, 255) != 255: failures.append(f'A|255: {a}')
-        if xor_8bit(a, a) != 0: failures.append(f'A^A: {a}')
-
-    # Involution
-    for a in [0, 1, 127, 128, 255, 170]:
-        if not_8bit(not_8bit(a)) != a: failures.append(f'~~A: {a}')
-
-    # Two's complement
-    for a in [0, 1, 42, 127, 128, 255]:
-        not_a = not_8bit(a)
-        r1, _ = add_8bit(a, not_a)
-        r2, _ = add_8bit(r1, 1)
-        if r2 != 0: failures.append(f'twos comp: {a}')
-
-    # Carry propagation
-    cases = [(255, 1, 0), (127, 129, 0), (1, 255, 0), (128, 128, 0), (255, 255, 254)]
-    for a, b, exp in cases:
-        r, _ = add_8bit(a, b)
-        if r != exp: failures.append(f'carry: {a}+{b}')
-
-    # Commutativity
-    pairs = [(17, 42), (0, 255), (128, 127), (1, 254), (170, 85)]
-    for a, b in pairs:
-        r1, _ = add_8bit(a, b)
-        r2, _ = add_8bit(b, a)
-        if r1 != r2: failures.append(f'add commute: {a},{b}')
-        if xor_8bit(a, b) != xor_8bit(b, a): failures.append(f'xor commute: {a},{b}')
-        if and_8bit(a, b) != and_8bit(b, a): failures.append(f'and commute: {a},{b}')
-        if or_8bit(a, b) != or_8bit(b, a): failures.append(f'or commute: {a},{b}')
-
-    # De Morgan
-    for a, b in [(0, 0), (0, 255), (255, 0), (255, 255), (170, 85)]:
-        if not_8bit(and_8bit(a, b)) != or_8bit(not_8bit(a), not_8bit(b)):
-            failures.append(f'DM1: {a},{b}')
-        if not_8bit(or_8bit(a, b)) != and_8bit(not_8bit(a), not_8bit(b)):
-            failures.append(f'DM2: {a},{b}')
-
-    # Comparator edge cases
-    cmp_tests = [
-        (0, 0, 0, 0, 1), (0, 1, 0, 1, 0), (1, 0, 1, 0, 0),
-        (127, 128, 0, 1, 0), (128, 127, 1, 0, 0),
-        (255, 255, 0, 0, 1), (255, 0, 1, 0, 0), (0, 255, 0, 1, 0),
-    ]
-    for a, b, exp_gt, exp_lt, exp_eq in cmp_tests:
-        if gt(a, b) != exp_gt: failures.append(f'gt({a},{b})')
-        if lt(a, b) != exp_lt: failures.append(f'lt({a},{b})')
-        if eq(a, b) != exp_eq: failures.append(f'eq({a},{b})')
-
-    # Popcount
-    for i in range(8):
-        if popcount(1 << i) != 1: failures.append(f'popcount(1<<{i})')
-    if popcount(0) != 0: failures.append('popcount(0)')
-    if popcount(255) != 8: failures.append('popcount(255)')
-
-    # Distributivity
-    for a, b, c in [(255, 15, 240), (170, 85, 51), (0, 255, 0)]:
-        if and_8bit(a, or_8bit(b, c)) != or_8bit(and_8bit(a, b), and_8bit(a, c)):
-            failures.append(f'distrib: {a},{b},{c}')
-
-    if failures:
-        print(f"  FAILED: {len(failures)} errors")
-        for f in failures[:10]:
-            print(f"    {f}")
-        return False
-    else:
-        print(f"  PASSED: 127 skeptical tests")
-        return True
-
-# =============================================================================
-# TEST SECTION 2: STRESS TESTS (Complex Algorithms)
-# =============================================================================
-
-def test_stress():
-    """Complex algorithmic tests."""
-    print("\n" + "=" * 70)
-    print("STRESS TESTS - Complex Algorithms")
-    print("=" * 70)
-
-    all_pass = True
-
-    # Factorial
-    print("\n  [1] Factorial")
-    def factorial(n):
-        result = 1
-        for i in range(2, n+1):
-            new_result = 0
-            for _ in range(i):
-                new_result, _ = add_8bit(new_result, result)
-                new_result &= 0xFF
-            result = new_result
-        return result
-
-    for n in [1, 2, 3, 4, 5]:
-        got = factorial(n)
-        expected = [1, 1, 2, 6, 24, 120][n]
-        if got != expected:
-            print(f"    {n}! = {got}, expected {expected} [FAIL]")
-            all_pass = False
-    print("    Factorial: OK" if all_pass else "    Factorial: FAIL")
-
-    # Fibonacci
-    print("\n  [2] Fibonacci")
-    a, b = 0, 1
-    fib = [a, b]
-    for _ in range(12):
-        next_val, carry = add_8bit(a, b)
-        if carry: break
-        fib.append(next_val)
-        a, b = b, next_val
-    expected_fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
-    if fib[:len(expected_fib)] == expected_fib:
-        print("    Fibonacci: OK")
-    else:
-        print("    Fibonacci: FAIL")
-        all_pass = False
-
-    # GCD
-    print("\n  [3] GCD")
-    def gcd(a, b):
-        iterations = 0
-        while not eq(b, 0) and iterations < 100:
-            temp = a
-            while not lt(temp, b) and not eq(temp, 0) and iterations < 100:
-                temp, _ = sub_8bit(temp, b)
-                iterations += 1
-            a, b = b, temp
-            iterations += 1
-        return a
-
-    test_gcds = [(48, 18, 6), (100, 35, 5), (252, 105, 21)]
-    for a, b, expected in test_gcds:
-        if gcd(a, b) != expected:
-            print(f"    gcd({a},{b}) failed")
-            all_pass = False
-    print("    GCD: OK" if all_pass else "    GCD: FAIL")
-
-    # LFSR
-    print("\n  [4] 8-bit LFSR")
-    def lfsr_step(state):
-        bit = eval_xor((state >> 0) & 1, (state >> 2) & 1)
-        bit = eval_xor(bit, (state >> 3) & 1)
-        bit = eval_xor(bit, (state >> 4) & 1)
-        return ((state >> 1) | (bit << 7)) & 0xFF
-
-    state = 1
-    seen = set()
-    for i in range(300):
-        if state in seen: break
-        seen.add(state)
-        state = lfsr_step(state)
-
-    if len(seen) == 255:
-        print("    LFSR period 255: OK")
-    else:
-        print(f"    LFSR period {len(seen)}: FAIL")
-        all_pass = False
-
-    return all_pass
-
-# =============================================================================
-# TEST SECTION 3: OVERFLOW CHAINS
-# =============================================================================
-
-def test_overflow_chains():
-    """Chained arithmetic operations."""
-    print("\n" + "=" * 70)
-    print("OVERFLOW CHAINS - Chained Arithmetic")
-    print("=" * 70)
-
-    all_pass = True
-
-    # Add-1 chain
-    print("\n  [1] Add-1 chain (512 additions)")
-    value = 0
-    errors = 0
-    for i in range(512):
-        expected = (value + 1) % 256
-        result, _ = add_8bit(value, 1)
-        if result != expected: errors += 1
-        value = result
-    if errors == 0:
-        print("    OK")
-    else:
-        print(f"    {errors} errors")
-        all_pass = False
-
-    # Fibonacci chain
-    print("\n  [2] Fibonacci chain (100 terms)")
-    a, b = 0, 1
-    pa, pb = 0, 1
-    errors = 0
-    for i in range(100):
-        if a != pa or b != pb: errors += 1
-        next_val, _ = add_8bit(a, b)
-        next_python = (pa + pb) % 256
-        a, b = b, next_val
-        pa, pb = pb, next_python
-    if errors == 0:
-        print("    OK")
-    else:
-        print(f"    {errors} errors")
-        all_pass = False
-
-    # Accumulator
-    print("\n  [3] Accumulator sum(1..100)")
-    acc = 0
-    for i in range(1, 101):
-        acc, _ = add_8bit(acc, i)
-    expected = sum(range(1, 101)) % 256
-    if acc == expected:
-        print(f"    OK (result: {acc})")
-    else:
-        print(f"    FAIL: got {acc}, expected {expected}")
-        all_pass = False
-
-    return all_pass
-
-# =============================================================================
-# TEST SECTION 4: EXHAUSTIVE EQUIVALENCE
-# =============================================================================
-
-def test_equivalence():
-    """Exhaustive verification against Python."""
-    print("\n" + "=" * 70)
-    print("EQUIVALENCE - Exhaustive Verification")
-    print("=" * 70)
-
-    all_pass = True
-
-    # Boolean gates
-    print("\n  [1] Boolean gates (26 checks)")
-    errors = 0
-    for a in [0, 1]:
-        for b in [0, 1]:
-            if eval_and(a, b) != (a & b): errors += 1
-            if eval_or(a, b) != (a | b): errors += 1
-            if eval_nand(a, b) != (1 - (a & b)): errors += 1
-            if eval_nor(a, b) != (1 - (a | b)): errors += 1
-            if eval_xor(a, b) != (a ^ b): errors += 1
-            if eval_xnor(a, b) != (1 - (a ^ b)): errors += 1
-    for a in [0, 1]:
-        if eval_not(a) != (1 - a): errors += 1
-    if errors == 0:
-        print("    OK")
-    else:
-        print(f"    {errors} errors")
-        all_pass = False
-
-    # 4-bit adder (256 cases)
-    print("\n  [2] 4-bit adder (256 cases)")
-    errors = 0
-    for a in range(16):
-        for b in range(16):
-            carry = 0.0
-            result_bits = []
-            for i in range(4):
-                s, carry = eval_full_adder(float((a >> i) & 1), float((b >> i) & 1), carry,
-                                           f'arithmetic.ripplecarry4bit.fa{i}')
-                result_bits.append(s)
-            result = sum(result_bits[i] * (2**i) for i in range(4))
-            if result != (a + b) % 16: errors += 1
-    if errors == 0:
-        print("    OK")
-    else:
-        print(f"    {errors} errors")
-        all_pass = False
-
-    # 8-bit adder (sampled)
-    print("\n  [3] 8-bit adder (1024 sampled cases)")
-    errors = 0
-    for a in range(0, 256, 8):
-        for b in range(0, 256, 8):
-            result, _ = add_8bit(a, b)
-            if result != (a + b) % 256: errors += 1
-    if errors == 0:
-        print("    OK")
-    else:
-        print(f"    {errors} errors")
-        all_pass = False
-
-    # Comparators (sampled)
-    print("\n  [4] Comparators (1024 sampled cases)")
-    errors = 0
-    for a in range(0, 256, 8):
-        for b in range(0, 256, 8):
-            if gt(a, b) != (1 if a > b else 0): errors += 1
-            if lt(a, b) != (1 if a < b else 0): errors += 1
-            if eq(a, b) != (1 if a == b else 0): errors += 1
-    if errors == 0:
-        print("    OK")
-    else:
-        print(f"    {errors} errors")
-        all_pass = False
-
-    return all_pass
-
-# =============================================================================
-# TEST SECTION 5: GATE RECONSTRUCTION
-# =============================================================================
-
-def test_gate_reconstruction():
-    """Reconstruct Boolean functions from weights."""
-    print("\n" + "=" * 70)
-    print("GATE RECONSTRUCTION - Derive Functions from Weights")
-    print("=" * 70)
-
-    KNOWN_FUNCTIONS = {
-        'AND':  (0, 0, 0, 1),
-        'OR':   (0, 1, 1, 1),
-        'NAND': (1, 1, 1, 0),
-        'NOR':  (1, 0, 0, 0),
-        'XOR':  (0, 1, 1, 0),
-        'XNOR': (1, 0, 0, 1),
-    }
-
-    def identify_2input(w, b):
-        tt = []
-        for a, b_in in [(0, 0), (0, 1), (1, 0), (1, 1)]:
-            inp = torch.tensor([float(a), float(b_in)])
-            tt.append(int(heaviside(inp @ w + b).item()))
-        tt = tuple(tt)
-        for name, expected_tt in KNOWN_FUNCTIONS.items():
-            if tt == expected_tt:
-                return name
-        return 'UNKNOWN'
-
-    all_pass = True
-
-    # Single-layer gates
-    print("\n  [1] Single-layer gates")
-    gates = [('boolean.and', 'AND'), ('boolean.or', 'OR'),
-             ('boolean.nand', 'NAND'), ('boolean.nor', 'NOR')]
-    for prefix, expected in gates:
-        identified = identify_2input(model[f'{prefix}.weight'], model[f'{prefix}.bias'])
-        if identified != expected:
-            print(f"    {prefix}: expected {expected}, got {identified}")
-            all_pass = False
-    print("    OK" if all_pass else "    FAIL")
-
-    # Two-layer gates
-    print("\n  [2] Two-layer gates (XOR, XNOR)")
-    for gate, expected_tt in [('xor', (0,1,1,0)), ('xnor', (1,0,0,1))]:
-        prefix = f'boolean.{gate}'
-        tt = []
-        for a, b in [(0,0), (0,1), (1,0), (1,1)]:
-            inp = torch.tensor([float(a), float(b)])
-            h1 = heaviside(inp @ model[f'{prefix}.layer1.neuron1.weight'] +
-                          model[f'{prefix}.layer1.neuron1.bias'])
-            h2 = heaviside(inp @ model[f'{prefix}.layer1.neuron2.weight'] +
-                          model[f'{prefix}.layer1.neuron2.bias'])
-            hidden = torch.tensor([h1.item(), h2.item()])
-            out = int(heaviside(hidden @ model[f'{prefix}.layer2.weight'] +
-                               model[f'{prefix}.layer2.bias']).item())
-            tt.append(out)
-        if tuple(tt) != expected_tt:
-            print(f"    {gate}: expected {expected_tt}, got {tuple(tt)}")
-            all_pass = False
-    print("    OK" if all_pass else "    FAIL")
-
-    return all_pass
-
-# =============================================================================
-# TEST SECTION 6: TIMING ANALYSIS
-# =============================================================================
-
-def test_timing():
-    """Circuit depth analysis."""
-    print("\n" + "=" * 70)
-    print("TIMING ANALYSIS - Circuit Depth")
-    print("=" * 70)
-
-    GATE_DEPTHS = {'AND': 1, 'OR': 1, 'NOT': 1, 'NAND': 1, 'NOR': 1, 'XOR': 2, 'XNOR': 2}
-
-    print("\n  Primitive gate depths:")
-    for gate, depth in GATE_DEPTHS.items():
-        print(f"    {gate}: {depth} layer(s)")
-
-    print("\n  Adder depths:")
-    print("    Half adder: 2 (XOR for sum)")
-    print("    Full adder: 4 (XOR->XOR chain)")
-    print("    8-bit ripple carry: 18 (4 + 2*7)")
-
-    print("\n  Comparator: 1 (single weighted threshold)")
-
-    # Verify structure
-    print("\n  Structure verification:")
-
-    # XOR has two layers
-    xor_has_layers = (any('layer1' in k for k in model.keys() if 'boolean.xor' in k) and
-                     any('layer2' in k for k in model.keys() if 'boolean.xor' in k))
-    print(f"    XOR two-layer: {'OK' if xor_has_layers else 'FAIL'}")
-
-    # Ripple carry has 8 full adders
-    fa_indices = set()
-    for k in model.keys():
-        if 'ripplecarry8bit' in k:
-            for i in range(8):
-                if f'fa{i}' in k:
-                    fa_indices.add(i)
-    print(f"    8-bit RC has fa0-fa7: {'OK' if fa_indices == set(range(8)) else 'FAIL'}")
-
-    return xor_has_layers and fa_indices == set(range(8))
-
-# =============================================================================
-# TEST SECTION 7: CRYPTOGRAPHIC SELF-TEST
-# =============================================================================
-
-def test_self_checksum():
-    """Compute checksum of weights using the circuits themselves."""
-    print("\n" + "=" * 70)
-    print("CRYPTOGRAPHIC SELF-TEST - Checksum Verification")
-    print("=" * 70)
-
-    # Serialize weights
-    all_bytes = []
-    for key in sorted(model.keys()):
-        for val in model[key].flatten().tolist():
-            int_val = int(val)
-            if int_val < 0: int_val = 256 + int_val
-            all_bytes.append(int_val & 0xFF)
-
-    print(f"\n  Total weight bytes: {len(all_bytes)}")
-
-    # Simple checksum using circuit
-    circuit_sum = 0
-    for byte in all_bytes:
-        circuit_sum, _ = add_8bit(circuit_sum, byte)
-
-    # Python reference
-    python_sum = sum(all_bytes) % 256
-
-    print(f"  Circuit checksum: {circuit_sum}")
-    print(f"  Python checksum:  {python_sum}")
-
-    # XOR checksum
-    circuit_xor = 0
-    for byte in all_bytes:
-        circuit_xor = xor_8bit(circuit_xor, byte)
-    python_xor = 0
-    for byte in all_bytes:
-        python_xor ^= byte
-
-    print(f"  Circuit XOR: {circuit_xor}")
-    print(f"  Python XOR:  {python_xor}")
-
-    if circuit_sum == python_sum and circuit_xor == python_xor:
-        print("\n  PASSED: Self-checksums match")
-        return True
-    else:
-        print("\n  FAILED: Checksum mismatch")
-        return False
-
-# =============================================================================
-# TEST SECTION 8: TURING COMPLETENESS
-# =============================================================================
-
-def test_turing_completeness():
-    """Rule 110 and Brainfuck tests."""
-    print("\n" + "=" * 70)
-    print("TURING COMPLETENESS - Rule 110 & Brainfuck")
-    print("=" * 70)
-
-    all_pass = True
-
-    # Rule 110
-    print("\n  [1] Rule 110 cellular automaton")
-
-    def rule110_cell(left, center, right):
-        not_left = eval_not(left)
-        c_xor_r = eval_xor(center, right)
-        not_left_and_c = eval_and(not_left, center)
-        return eval_or(c_xor_r, not_left_and_c)
-
-    # Verify all 8 patterns
-    expected = {(0,0,0):0, (0,0,1):1, (0,1,0):1, (0,1,1):1,
-                (1,0,0):0, (1,0,1):1, (1,1,0):1, (1,1,1):0}
-    errors = 0
-    for (l, c, r), exp in expected.items():
-        if rule110_cell(l, c, r) != exp:
-            errors += 1
-    if errors == 0:
-        print("    Rule 110 truth table: OK")
-    else:
-        print(f"    Rule 110: {errors} errors")
-        all_pass = False
-
-    # Brainfuck
-    print("\n  [2] Brainfuck interpreter")
-
-    class BrainfuckVM:
-        def __init__(self, code, max_steps=10000):
-            self.code = code
-            self.tape = [0] * 256
-            self.dp = self.ip = 0
-            self.output = []
-            self.max_steps = max_steps
-            self.steps = 0
-            self.brackets = {}
-            stack = []
-            for i, c in enumerate(code):
-                if c == '[': stack.append(i)
-                elif c == ']' and stack:
-                    j = stack.pop()
-                    self.brackets[j] = i
-                    self.brackets[i] = j
-
-        def run(self):
-            while self.ip < len(self.code) and self.steps < self.max_steps:
-                cmd = self.code[self.ip]
-                if cmd == '>': self.dp = (self.dp + 1) % 256
-                elif cmd == '<': self.dp = (self.dp - 1) % 256
-                elif cmd == '+': self.tape[self.dp] = (self.tape[self.dp] + 1) & 0xFF
-                elif cmd == '-': self.tape[self.dp] = (self.tape[self.dp] - 1) & 0xFF
-                elif cmd == '.': self.output.append(self.tape[self.dp])
-                elif cmd == '[' and self.tape[self.dp] == 0:
-                    self.ip = self.brackets.get(self.ip, self.ip)
-                elif cmd == ']' and self.tape[self.dp] != 0:
-                    self.ip = self.brackets.get(self.ip, self.ip)
-                    continue
-                self.ip += 1
-                self.steps += 1
-            return self.output
-
-    # Test: 2 + 3 = 5
-    vm = BrainfuckVM("++>+++[<+>-]<.")
-    if vm.run() == [5]:
-        print("    BF addition (2+3=5): OK")
-    else:
-        print("    BF addition: FAIL")
-        all_pass = False
-
-    # Test: countdown
-    vm = BrainfuckVM("+++++[.-]")
-    if vm.run() == [5, 4, 3, 2, 1]:
-        print("    BF countdown: OK")
-    else:
-        print("    BF countdown: FAIL")
-        all_pass = False
-
-    return all_pass
-
-# =============================================================================
-# TEST SECTION 9: PERTURBATION
-# =============================================================================
-
-def test_perturbation():
-    """Adversarial weight perturbation."""
-    print("\n" + "=" * 70)
-    print("PERTURBATION - Adversarial Weight Changes")
-    print("=" * 70)
-
-    # Create perturbed model
-    perturbed = {k: v.clone() for k, v in model.items()}
-    perturbed['boolean.and.weight'] = torch.tensor([0.0, 1.0])  # Break AND
-
-    def perturbed_and(a, b):
-        inp = torch.tensor([float(a), float(b)])
-        return int(heaviside(inp @ perturbed['boolean.and.weight'] +
-                            perturbed['boolean.and.bias']).item())
-
-    def perturbed_or(a, b):
-        inp = torch.tensor([float(a), float(b)])
-        return int(heaviside(inp @ perturbed['boolean.or.weight'] +
-                            perturbed['boolean.or.bias']).item())
-
-    print("\n  [1] Perturb AND gate: w=[1,1] -> [0,1]")
-
-    # AND should be broken
-    and_broken = False
-    for a, b in [(0,0), (0,1), (1,0), (1,1)]:
-        if perturbed_and(a, b) != (a & b):
-            and_broken = True
-            break
-
-    # OR should be unaffected
-    or_ok = True
-    for a, b in [(0,0), (0,1), (1,0), (1,1)]:
-        if perturbed_or(a, b) != (a | b):
-            or_ok = False
-            break
-
-    print(f"    AND gate broken: {'YES (expected)' if and_broken else 'NO (unexpected)'}")
-    print(f"    OR gate intact:  {'YES (expected)' if or_ok else 'NO (unexpected)'}")
-
-    if and_broken and or_ok:
-        print("\n  PASSED: Perturbation localized to target gate")
-        return True
-    else:
-        print("\n  FAILED: Unexpected perturbation behavior")
-        return False
-
-# =============================================================================
-# TEST SECTION 10: INDEPENDENCE REPRODUCTION
-# =============================================================================
-
-def test_independence():
-    """Verify weights can be derived from specification."""
-    print("\n" + "=" * 70)
-    print("INDEPENDENCE - Derive Weights from Spec")
-    print("=" * 70)
-
-    # Standard derivations
-    derivations = {
-        'AND':  ([1, 1], -2),
-        'OR':   ([1, 1], -1),
-        'NAND': ([-1, -1], 1),
-        'NOR':  ([-1, -1], 0),
-    }
-
-    all_pass = True
-
-    print("\n  Comparing derived vs actual weights:")
-    for gate, (expected_w, expected_b) in derivations.items():
-        actual_w = model[f'boolean.{gate.lower()}.weight'].tolist()
-        actual_b = model[f'boolean.{gate.lower()}.bias'].item()
-
-        match = (expected_w == actual_w and expected_b == actual_b)
-        status = "OK" if match else "DIFFER"
-        print(f"    {gate}: derived={expected_w},{expected_b} actual={actual_w},{int(actual_b)} [{status}]")
-
-        if not match:
-            all_pass = False
-
-    if all_pass:
-        print("\n  PASSED: All weights match derived values")
-    else:
-        print("\n  Note: Functional equivalence may still hold")
-
-    return all_pass
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-def main():
-    print("=" * 70)
-    print(" UNIFIED TEST SUITE FOR 8-BIT THRESHOLD COMPUTER")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Skeptic Tests", test_skeptic()))
-    results.append(("Stress Tests", test_stress()))
-    results.append(("Overflow Chains", test_overflow_chains()))
-    results.append(("Equivalence", test_equivalence()))
-    results.append(("Gate Reconstruction", test_gate_reconstruction()))
-    results.append(("Timing Analysis", test_timing()))
-    results.append(("Self-Checksum", test_self_checksum()))
-    results.append(("Turing Completeness", test_turing_completeness()))
-    results.append(("Perturbation", test_perturbation()))
-    results.append(("Independence", test_independence()))
-
-    print("\n" + "=" * 70)
-    print(" FINAL SUMMARY")
-    print("=" * 70)
-
-    passed = sum(1 for _, r in results if r)
-    total = len(results)
-
-    for name, r in results:
-        status = "PASS" if r else "FAIL"
-        print(f"  {name:25s} [{status}]")
-
-    print(f"\n  Total: {passed}/{total} test categories passed")
-
-    if passed == total:
-        print("\n  STATUS: ALL TESTS PASSED")
-    else:
-        print("\n  STATUS: SOME TESTS FAILED")
-
-    print("=" * 70)
-
-    return passed == total
-
-if __name__ == "__main__":
-    main()