Upload tests/test_all.py with huggingface_hub

tests/test_all.py

@@ -0,0 +1,898 @@
+"""
+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()