Remove old individual test files

tests/skeptic_test.py

@@ -1,215 +0,0 @@
-import warnings
-warnings.filterwarnings('ignore')
-from safetensors.torch import load_file
-import torch
-
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-def int_to_bits(val):
-    return torch.tensor([(val >> (7-i)) & 1 for i in range(8)], dtype=torch.float32)
-
-def eval_xor_bool(a, b):
-    inp = torch.tensor([float(a), float(b)], dtype=torch.float32)
-    w1_or = model['boolean.xor.layer1.neuron1.weight']
-    b1_or = model['boolean.xor.layer1.neuron1.bias']
-    w1_nand = model['boolean.xor.layer1.neuron2.weight']
-    b1_nand = model['boolean.xor.layer1.neuron2.bias']
-    w2 = model['boolean.xor.layer2.weight']
-    b2 = model['boolean.xor.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 int(heaviside(hidden @ w2 + b2).item())
-
-def eval_xor_arith(inp, prefix):
-    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):
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def add_8bit(a, b):
-    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 xor_8bit(a, b):
-    result = 0
-    for i in range(8):
-        bit = eval_xor_bool((a >> i) & 1, (b >> i) & 1)
-        result |= (bit << i)
-    return result
-
-def and_8bit(a, b):
-    result = 0
-    w = model['boolean.and.weight']
-    bias = model['boolean.and.bias']
-    for i in range(8):
-        inp = torch.tensor([float((a >> i) & 1), float((b >> i) & 1)], dtype=torch.float32)
-        out = int(heaviside(inp @ w + bias).item())
-        result |= (out << i)
-    return result
-
-def or_8bit(a, b):
-    result = 0
-    w = model['boolean.or.weight']
-    bias = model['boolean.or.bias']
-    for i in range(8):
-        inp = torch.tensor([float((a >> i) & 1), float((b >> i) & 1)], dtype=torch.float32)
-        out = int(heaviside(inp @ w + bias).item())
-        result |= (out << i)
-    return result
-
-def not_8bit(a):
-    result = 0
-    w = model['boolean.not.weight']
-    bias = model['boolean.not.bias']
-    for i in range(8):
-        inp = torch.tensor([float((a >> i) & 1)], dtype=torch.float32)
-        out = int(heaviside(inp @ w + bias).item())
-        result |= (out << i)
-    return result
-
-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
-
-print('=' * 70)
-print('SKEPTICAL NERD TESTS')
-print('=' * 70)
-
-failures = []
-
-print('\n[1] 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}')
-print('  28 tests')
-
-print('\n[2] 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}')
-print('  15 tests')
-
-print('\n[3] INVOLUTION (~~A = A)')
-for a in [0, 1, 127, 128, 255, 170]:
-    if not_8bit(not_8bit(a)) != a: failures.append(f'~~A: {a}')
-print('  6 tests')
-
-print('\n[4] TWOS COMPLEMENT: A + ~A + 1 = 0')
-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}')
-print('  6 tests')
-
-print('\n[5] CARRY PROPAGATION (worst case)')
-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}={r}, expected {exp}')
-print('  5 tests')
-
-print('\n[6] 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}')
-print('  20 tests')
-
-print('\n[7] DE MORGAN')
-for a, b in [(0, 0), (0, 255), (255, 0), (255, 255), (170, 85)]:
-    lhs = not_8bit(and_8bit(a, b))
-    rhs = or_8bit(not_8bit(a), not_8bit(b))
-    if lhs != rhs: failures.append(f'DM1: {a},{b}')
-    lhs = not_8bit(or_8bit(a, b))
-    rhs = and_8bit(not_8bit(a), not_8bit(b))
-    if lhs != rhs: failures.append(f'DM2: {a},{b}')
-print('  10 tests')
-
-print('\n[8] 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})')
-print('  24 tests')
-
-print('\n[9] POPCOUNT SINGLE BITS + EXTREMES')
-w_pop = model['pattern_recognition.popcount.weight']
-b_pop = model['pattern_recognition.popcount.bias']
-for i in range(8):
-    val = 1 << i
-    bits = int_to_bits(val)
-    pc = int((bits @ w_pop + b_pop).item())
-    if pc != 1: failures.append(f'popcount(1<<{i})')
-if int((int_to_bits(0) @ w_pop + b_pop).item()) != 0: failures.append('popcount(0)')
-if int((int_to_bits(255) @ w_pop + b_pop).item()) != 8: failures.append('popcount(255)')
-print('  10 tests')
-
-print('\n[10] DISTRIBUTIVITY: A & (B | C) = (A & B) | (A & C)')
-for a, b, c in [(255, 15, 240), (170, 85, 51), (0, 255, 0)]:
-    lhs = and_8bit(a, or_8bit(b, c))
-    rhs = or_8bit(and_8bit(a, b), and_8bit(a, c))
-    if lhs != rhs: failures.append(f'distrib: {a},{b},{c}')
-print('  3 tests')
-
-print('\n' + '=' * 70)
-if failures:
-    print(f'FAILURES: {len(failures)}')
-    for f in failures[:20]:
-        print(f'  {f}')
-else:
-    print('ALL 127 SKEPTICAL TESTS PASSED')
-print('=' * 70)

tests/stress_test.py

@@ -1,367 +0,0 @@
-"""
-WILD STRESS TESTS - Push the threshold CPU to its limits
-"""
-import torch
-from safetensors.torch import load_file
-
-model = load_file('./neural_computer.safetensors')
-model = {k: v.float() for k, v in model.items()}
-
-def heaviside(x):
-    return (x >= 0).float()
-
-def int_to_bits(val, width=8):
-    return torch.tensor([(val >> (width-1-i)) & 1 for i in range(width)], dtype=torch.float32)
-
-def bits_to_int(bits):
-    val = 0
-    for i, b in enumerate(bits):
-        val |= (int(b.item()) << (len(bits)-1-i))
-    return val
-
-# === BASIC PRIMITIVES ===
-
-def eval_xor(a, b):
-    inp = torch.tensor([float(a), float(b)], dtype=torch.float32)
-    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_and(a, b):
-    inp = torch.tensor([float(a), float(b)], dtype=torch.float32)
-    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)], dtype=torch.float32)
-    return int(heaviside(inp @ model['boolean.or.weight'] + model['boolean.or.bias']).item())
-
-def eval_not(a):
-    inp = torch.tensor([float(a)], dtype=torch.float32)
-    return int(heaviside(inp @ model['boolean.not.weight'] + model['boolean.not.bias']).item())
-
-def eval_xor_arith(inp, prefix):
-    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):
-    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):
-    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):
-    # a - b = a + (~b + 1)
-    not_b = 0
-    for i in range(8):
-        not_b |= (eval_not((b >> i) & 1) << i)
-    temp, _ = add_8bit(a, not_b)
-    result, _ = add_8bit(temp, 1)
-    return result
-
-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())
-
-print('='*70)
-print('WILD STRESS TESTS')
-print('='*70)
-
-# === TEST 1: FACTORIAL ===
-print('\n[1] FACTORIAL via chained multiply-add')
-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]
-    status = 'OK' if got == expected else 'FAIL'
-    print(f'  {n}! = {got} (expected {expected}) [{status}]')
-
-# === TEST 2: GCD ===
-print('\n[2] GCD via Euclidean algorithm')
-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), (17, 13, 1), (128, 64, 64)]
-for a, b, expected in test_gcds:
-    got = gcd(a, b)
-    status = 'OK' if got == expected else 'FAIL'
-    print(f'  gcd({a}, {b}) = {got} (expected {expected}) [{status}]')
-
-# === TEST 3: FIBONACCI ===
-print('\n[3] FIBONACCI until overflow')
-def fib_sequence():
-    a, b = 0, 1
-    seq = [a, b]
-    for _ in range(20):
-        next_val, carry = add_8bit(a, b)
-        if carry:
-            break
-        seq.append(next_val)
-        a, b = b, next_val
-    return seq
-
-fib = fib_sequence()
-expected_fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
-print(f'  Computed: {fib[:len(expected_fib)]}')
-print(f'  Expected: {expected_fib}')
-print(f'  Match: {fib[:len(expected_fib)] == expected_fib}')
-
-# === TEST 4: PRIME CHECK ===
-print('\n[4] PRIME CHECK via trial division')
-def is_prime(n):
-    if n < 2: return False
-    if n == 2: return True
-    if (n & 1) == 0: return False
-
-    i = 3
-    while i * i <= n and i < n:
-        temp = n
-        while temp >= i:
-            temp = sub_8bit(temp, i)
-        if eq(temp, 0):
-            return False
-        i += 2
-    return True
-
-primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
-non_primes = [4, 6, 8, 9, 10, 12, 14, 15, 16, 18]
-
-prime_pass = sum(1 for p in primes if is_prime(p))
-non_prime_pass = sum(1 for n in non_primes if not is_prime(n))
-print(f'  Primes correctly identified: {prime_pass}/10')
-print(f'  Non-primes correctly rejected: {non_prime_pass}/10')
-
-# === TEST 5: INTEGER SQRT ===
-print('\n[5] INTEGER SQUARE ROOT via binary search')
-def isqrt(n):
-    if n == 0: return 0
-    lo, hi = 1, min(n, 15)  # limit for 8-bit
-    result = 0
-    iterations = 0
-    while lo <= hi and iterations < 50:
-        mid = (lo + hi) >> 1
-        sq = 0
-        for _ in range(mid):
-            sq, _ = add_8bit(sq, mid)
-            sq &= 0xFF
-
-        if sq <= n:
-            result = mid
-            lo = mid + 1
-        else:
-            hi = mid - 1
-        iterations += 1
-    return result
-
-sqrt_tests = [(0, 0), (1, 1), (4, 2), (9, 3), (16, 4), (25, 5), (36, 6), (49, 7), (64, 8), (81, 9), (100, 10), (144, 12)]
-sqrt_pass = 0
-for n, expected in sqrt_tests:
-    got = isqrt(n)
-    if got == expected:
-        sqrt_pass += 1
-print(f'  Passed: {sqrt_pass}/{len(sqrt_tests)}')
-
-# === TEST 6: COLLATZ ===
-print('\n[6] COLLATZ CONJECTURE iterations')
-def collatz_steps(n):
-    steps = 0
-    while n != 1 and steps < 200:
-        if (n & 1) == 0:
-            n = n >> 1
-        else:
-            temp, _ = add_8bit(n, n)
-            temp, _ = add_8bit(temp, n)
-            n, _ = add_8bit(temp, 1)
-            n &= 0xFF
-        steps += 1
-        if n == 0: break
-    return steps
-
-collatz_tests = [(1, 0), (2, 1), (3, 7), (6, 8)]
-for start, expected in collatz_tests:
-    got = collatz_steps(start)
-    status = 'OK' if got == expected else f'got {got}'
-    print(f'  collatz({start}) = {got} steps [{status}]')
-
-# === TEST 7: SORT BY POPCOUNT ===
-print('\n[7] SORT BY HAMMING WEIGHT (popcount)')
-values = [0b11111111, 0b00000001, 0b10101010, 0b00001111, 0b11110000, 0b00000000]
-weighted = [(v, popcount(v)) for v in values]
-for i in range(len(weighted)):
-    for j in range(len(weighted) - 1):
-        if gt(weighted[j][1], weighted[j+1][1]):
-            weighted[j], weighted[j+1] = weighted[j+1], weighted[j]
-
-print(f'  Sorted by popcount:')
-for v, p in weighted:
-    print(f'    {bin(v):>12} -> popcount = {p}')
-
-# === TEST 8: XOR CHECKSUM ===
-print('\n[8] XOR CHECKSUM of message')
-message = [0x48, 0x65, 0x6C, 0x6C, 0x6F]  # "Hello"
-checksum = 0
-for byte in message:
-    for i in range(8):
-        bit_a = (checksum >> i) & 1
-        bit_b = (byte >> i) & 1
-        xor_bit = eval_xor(bit_a, bit_b)
-        checksum = (checksum & ~(1 << i)) | (xor_bit << i)
-
-expected_checksum = 0x48 ^ 0x65 ^ 0x6C ^ 0x6C ^ 0x6F
-status = 'OK' if checksum == expected_checksum else 'FAIL'
-print(f'  Message: {[hex(b) for b in message]}')
-print(f'  XOR checksum: {hex(checksum)} (expected {hex(expected_checksum)}) [{status}]')
-
-# === TEST 9: PARITY TREE ===
-print('\n[9] 8-BIT PARITY (full XOR tree)')
-def parity_8bit(val):
-    bits = [(val >> i) & 1 for i in range(8)]
-    s1 = [eval_xor(bits[0], bits[1]), eval_xor(bits[2], bits[3]),
-          eval_xor(bits[4], bits[5]), eval_xor(bits[6], bits[7])]
-    s2 = [eval_xor(s1[0], s1[1]), eval_xor(s1[2], s1[3])]
-    return eval_xor(s2[0], s2[1])
-
-parity_tests = [(0x00, 0), (0xFF, 0), (0x01, 1), (0x03, 0), (0x07, 1), (0xAA, 0), (0x55, 0), (0x81, 0), (0x80, 1)]
-parity_pass = sum(1 for v, exp in parity_tests if parity_8bit(v) == exp)
-print(f'  Passed: {parity_pass}/{len(parity_tests)}')
-
-# === TEST 10: OVERFLOW CASCADE ===
-print('\n[10] OVERFLOW CASCADE (255 + 1 chain)')
-val = 255
-carries = []
-for i in range(5):
-    val, carry = add_8bit(val, 1)
-    carries.append(carry)
-print(f'  255 -> +1 -> +1 -> +1 -> +1 -> +1')
-print(f'  Carries: {carries}')
-print(f'  Final value: {val} (expected 4) [{"OK" if val == 4 else "FAIL"}]')
-
-# === TEST 11: POWER OF 2 CHECK ===
-print('\n[11] POWER OF 2 detection (popcount == 1)')
-def is_power_of_2(n):
-    if n == 0: return False
-    return popcount(n) == 1
-
-pow2_tests = [(1, True), (2, True), (4, True), (8, True), (16, True), (32, True), (64, True), (128, True),
-              (3, False), (5, False), (6, False), (7, False), (9, False), (15, False), (255, False)]
-pow2_pass = sum(1 for n, exp in pow2_tests if is_power_of_2(n) == exp)
-print(f'  Passed: {pow2_pass}/{len(pow2_tests)}')
-
-# === TEST 12: BYTE REVERSE ===
-print('\n[12] BYTE REVERSE via bit manipulation')
-def reverse_bits(val):
-    result = 0
-    for i in range(8):
-        bit = (val >> i) & 1
-        result |= (bit << (7 - i))
-    return result
-
-reverse_tests = [(0b10000000, 0b00000001), (0b11110000, 0b00001111), (0b10101010, 0b01010101), (0b00000000, 0b00000000), (0b11111111, 0b11111111)]
-reverse_pass = sum(1 for inp, exp in reverse_tests if reverse_bits(inp) == exp)
-print(f'  Passed: {reverse_pass}/{len(reverse_tests)}')
-
-# === TEST 13: MAX/MIN via comparator ===
-print('\n[13] MAX and MIN of array')
-def find_max(arr):
-    m = arr[0]
-    for x in arr[1:]:
-        if gt(x, m):
-            m = x
-    return m
-
-def find_min(arr):
-    m = arr[0]
-    for x in arr[1:]:
-        if lt(x, m):
-            m = x
-    return m
-
-test_arr = [42, 17, 255, 0, 128, 64, 33]
-got_max = find_max(test_arr)
-got_min = find_min(test_arr)
-print(f'  Array: {test_arr}')
-print(f'  Max: {got_max} (expected 255) [{"OK" if got_max == 255 else "FAIL"}]')
-print(f'  Min: {got_min} (expected 0) [{"OK" if got_min == 0 else "FAIL"}]')
-
-# === TEST 14: LFSR (pseudo-random) ===
-print('\n[14] 8-BIT LFSR (taps at 8,6,5,4)')
-def lfsr_step(state):
-    # Taps: 8, 6, 5, 4 (for maximal length)
-    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)
-
-print(f'  Period: {len(seen)} (max possible: 255)')
-print(f'  Full period: {"OK" if len(seen) == 255 else "FAIL"}')
-
-print('\n' + '='*70)
-print('STRESS TESTS COMPLETE')
-print('='*70)

tests/test_cryptographic_selftest.py

@@ -1,516 +0,0 @@
-"""
-TEST #6: Cryptographic Self-Test
-=================================
-Have the threshold computer compute a checksum over its own weights.
-Verify the result matches external (Python) computation.
-
-A skeptic would demand: "Prove the computer can verify its own integrity.
-Bootstrap trust by having it compute over its own weights."
-"""
-
-import torch
-from safetensors.torch import load_file
-import struct
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-# =============================================================================
-# CIRCUIT PRIMITIVES
-# =============================================================================
-
-def eval_xor_arith(inp, prefix):
-    """Evaluate XOR for arithmetic circuits."""
-    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):
-    """Evaluate full adder, return (sum, carry_out)."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def add_8bit(a, b):
-    """8-bit addition using ripple carry adder."""
-    carry = 0.0
-    result_bits = []
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-    result = sum(result_bits[i] * (2**i) for i in range(8))
-    return result, int(carry)
-
-def eval_xor_byte(a, b):
-    """XOR two bytes using the XOR circuit, bit by bit."""
-    result = 0
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        inp = torch.tensor([float(a_bit), float(b_bit)])
-
-        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()])
-        out = int(heaviside(hidden @ w2 + b2).item())
-
-        result |= (out << i)
-
-    return result
-
-def eval_and_byte(a, b):
-    """AND two bytes using the AND circuit, bit by bit."""
-    result = 0
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        inp = torch.tensor([float(a_bit), float(b_bit)])
-        w = model['boolean.and.weight']
-        bias = model['boolean.and.bias']
-        out = int(heaviside(inp @ w + bias).item())
-        result |= (out << i)
-    return result
-
-def shift_left_1(val):
-    """Shift byte left by 1, return (result, bit_shifted_out)."""
-    bit_out = (val >> 7) & 1
-    result = (val << 1) & 0xFF
-    return result, bit_out
-
-def shift_right_1(val):
-    """Shift byte right by 1, return (result, bit_shifted_out)."""
-    bit_out = val & 1
-    result = (val >> 1) & 0xFF
-    return result, bit_out
-
-# =============================================================================
-# CHECKSUM ALGORITHMS IMPLEMENTED ON THRESHOLD CIRCUITS
-# =============================================================================
-
-def circuit_checksum_simple(data_bytes):
-    """
-    Simple additive checksum computed using threshold circuits.
-    Sum all bytes mod 256.
-    """
-    acc = 0
-    for byte in data_bytes:
-        acc, _ = add_8bit(acc, byte)
-    return acc
-
-def circuit_checksum_xor(data_bytes):
-    """
-    XOR checksum computed using threshold circuits.
-    XOR all bytes together.
-    """
-    acc = 0
-    for byte in data_bytes:
-        acc = eval_xor_byte(acc, byte)
-    return acc
-
-def circuit_fletcher8(data_bytes):
-    """
-    Fletcher-8 checksum using threshold circuits.
-    Two running sums: sum1 = sum of bytes, sum2 = sum of sum1s
-    """
-    sum1 = 0
-    sum2 = 0
-    for byte in data_bytes:
-        sum1, _ = add_8bit(sum1, byte)
-        sum2, _ = add_8bit(sum2, sum1)
-    return (sum2 << 8) | sum1  # Return as 16-bit value
-
-def circuit_crc8_simple(data_bytes, poly=0x07):
-    """
-    Simple CRC-8 using threshold circuits.
-    Polynomial: x^8 + x^2 + x + 1 (0x07)
-    """
-    crc = 0
-    for byte in data_bytes:
-        crc = eval_xor_byte(crc, byte)
-        for _ in range(8):
-            crc_shifted, high_bit = shift_left_1(crc)
-            if high_bit:
-                crc = eval_xor_byte(crc_shifted, poly)
-            else:
-                crc = crc_shifted
-    return crc
-
-# =============================================================================
-# PYTHON REFERENCE IMPLEMENTATIONS
-# =============================================================================
-
-def python_checksum_simple(data_bytes):
-    """Python reference: additive checksum."""
-    return sum(data_bytes) % 256
-
-def python_checksum_xor(data_bytes):
-    """Python reference: XOR checksum."""
-    result = 0
-    for b in data_bytes:
-        result ^= b
-    return result
-
-def python_fletcher8(data_bytes):
-    """Python reference: Fletcher-8."""
-    sum1 = 0
-    sum2 = 0
-    for byte in data_bytes:
-        sum1 = (sum1 + byte) % 256
-        sum2 = (sum2 + sum1) % 256
-    return (sum2 << 8) | sum1
-
-def python_crc8(data_bytes, poly=0x07):
-    """Python reference: CRC-8."""
-    crc = 0
-    for byte in data_bytes:
-        crc ^= byte
-        for _ in range(8):
-            if crc & 0x80:
-                crc = ((crc << 1) ^ poly) & 0xFF
-            else:
-                crc = (crc << 1) & 0xFF
-    return crc
-
-# =============================================================================
-# WEIGHT SERIALIZATION
-# =============================================================================
-
-def serialize_weights():
-    """
-    Serialize all model weights to a byte sequence.
-    This is the data the computer will checksum.
-    """
-    all_bytes = []
-
-    # Sort keys for deterministic ordering
-    for key in sorted(model.keys()):
-        tensor = model[key]
-        # Convert to bytes (as int8 since weights are small integers)
-        for val in tensor.flatten().tolist():
-            # Clamp to int8 range and convert
-            int_val = int(val)
-            # Handle signed values
-            if int_val < 0:
-                int_val = 256 + int_val  # Two's complement
-            all_bytes.append(int_val & 0xFF)
-
-    return all_bytes
-
-# =============================================================================
-# TESTS
-# =============================================================================
-
-def test_checksum_primitives():
-    """Test that checksum primitives work on known data."""
-    print("\n[TEST 1] Checksum Primitive Verification")
-    print("-" * 60)
-
-    # Test data
-    test_cases = [
-        [0, 0, 0, 0],
-        [1, 2, 3, 4],
-        [255, 255, 255, 255],
-        [0x12, 0x34, 0x56, 0x78],
-        list(range(10)),
-        [0xAA, 0x55, 0xAA, 0x55],
-    ]
-
-    errors = []
-
-    for data in test_cases:
-        # Simple checksum
-        circuit_sum = circuit_checksum_simple(data)
-        python_sum = python_checksum_simple(data)
-        if circuit_sum != python_sum:
-            errors.append(('SUM', data, python_sum, circuit_sum))
-
-        # XOR checksum
-        circuit_xor = circuit_checksum_xor(data)
-        python_xor = python_checksum_xor(data)
-        if circuit_xor != python_xor:
-            errors.append(('XOR', data, python_xor, circuit_xor))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors[:5]:
-            print(f"    {e[0]} on {e[1]}: expected {e[2]}, got {e[3]}")
-        return False
-    else:
-        print(f"  PASSED: {len(test_cases)} test vectors verified")
-        print(f"    - Simple additive checksum: OK")
-        print(f"    - XOR checksum: OK")
-        return True
-
-def test_fletcher8():
-    """Test Fletcher-8 implementation."""
-    print("\n[TEST 2] Fletcher-8 Checksum")
-    print("-" * 60)
-
-    test_cases = [
-        [0x01, 0x02],
-        [0x00, 0x00, 0x00, 0x00],
-        [0xFF, 0xFF],
-        list(range(16)),
-    ]
-
-    errors = []
-
-    for data in test_cases:
-        circuit_f8 = circuit_fletcher8(data)
-        python_f8 = python_fletcher8(data)
-
-        if circuit_f8 != python_f8:
-            errors.append((data, python_f8, circuit_f8))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    Data {e[0][:4]}...: expected {e[1]:04x}, got {e[2]:04x}")
-        return False
-    else:
-        print(f"  PASSED: {len(test_cases)} Fletcher-8 tests")
-        return True
-
-def test_crc8():
-    """Test CRC-8 implementation."""
-    print("\n[TEST 3] CRC-8 Checksum")
-    print("-" * 60)
-
-    test_cases = [
-        [0x00],
-        [0x01],
-        [0x01, 0x02, 0x03],
-        [0xFF],
-        [0xAA, 0x55],
-    ]
-
-    errors = []
-
-    for data in test_cases:
-        circuit_crc = circuit_crc8_simple(data)
-        python_crc = python_crc8(data)
-
-        if circuit_crc != python_crc:
-            errors.append((data, python_crc, circuit_crc))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    Data {e[0]}: expected {e[1]:02x}, got {e[2]:02x}")
-        return False
-    else:
-        print(f"  PASSED: {len(test_cases)} CRC-8 tests")
-        return True
-
-def test_self_checksum():
-    """
-    The main event: compute checksum of the model's own weights
-    using the threshold circuits, compare to Python.
-    """
-    print("\n[TEST 4] Self-Checksum: Computing checksum of own weights")
-    print("-" * 60)
-
-    # Serialize weights
-    print("  Serializing weights...")
-    weight_bytes = serialize_weights()
-    print(f"    Total bytes: {len(weight_bytes)}")
-    print(f"    First 16 bytes: {weight_bytes[:16]}")
-
-    # For performance, use a subset for the intensive checksums
-    subset = weight_bytes[:256]  # First 256 bytes
-
-    results = {}
-    errors = []
-
-    # Simple checksum (full weights)
-    print("\n  Computing simple additive checksum (full weights)...")
-    circuit_sum = circuit_checksum_simple(weight_bytes)
-    python_sum = python_checksum_simple(weight_bytes)
-    results['simple'] = (circuit_sum, python_sum, circuit_sum == python_sum)
-    print(f"    Circuit: {circuit_sum:3d} (0x{circuit_sum:02x})")
-    print(f"    Python:  {python_sum:3d} (0x{python_sum:02x})")
-    print(f"    Match: {'YES' if circuit_sum == python_sum else 'NO'}")
-    if circuit_sum != python_sum:
-        errors.append('simple')
-
-    # XOR checksum (full weights)
-    print("\n  Computing XOR checksum (full weights)...")
-    circuit_xor = circuit_checksum_xor(weight_bytes)
-    python_xor = python_checksum_xor(weight_bytes)
-    results['xor'] = (circuit_xor, python_xor, circuit_xor == python_xor)
-    print(f"    Circuit: {circuit_xor:3d} (0x{circuit_xor:02x})")
-    print(f"    Python:  {python_xor:3d} (0x{python_xor:02x})")
-    print(f"    Match: {'YES' if circuit_xor == python_xor else 'NO'}")
-    if circuit_xor != python_xor:
-        errors.append('xor')
-
-    # Fletcher-8 (subset for performance)
-    print(f"\n  Computing Fletcher-8 (first {len(subset)} bytes)...")
-    circuit_f8 = circuit_fletcher8(subset)
-    python_f8 = python_fletcher8(subset)
-    results['fletcher8'] = (circuit_f8, python_f8, circuit_f8 == python_f8)
-    print(f"    Circuit: {circuit_f8:5d} (0x{circuit_f8:04x})")
-    print(f"    Python:  {python_f8:5d} (0x{python_f8:04x})")
-    print(f"    Match: {'YES' if circuit_f8 == python_f8 else 'NO'}")
-    if circuit_f8 != python_f8:
-        errors.append('fletcher8')
-
-    # CRC-8 (smaller subset - it's slow)
-    crc_subset = weight_bytes[:64]
-    print(f"\n  Computing CRC-8 (first {len(crc_subset)} bytes)...")
-    circuit_crc = circuit_crc8_simple(crc_subset)
-    python_crc = python_crc8(crc_subset)
-    results['crc8'] = (circuit_crc, python_crc, circuit_crc == python_crc)
-    print(f"    Circuit: {circuit_crc:3d} (0x{circuit_crc:02x})")
-    print(f"    Python:  {python_crc:3d} (0x{python_crc:02x})")
-    print(f"    Match: {'YES' if circuit_crc == python_crc else 'NO'}")
-    if circuit_crc != python_crc:
-        errors.append('crc8')
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} checksums did not match")
-        return False
-    else:
-        print(f"  PASSED: All 4 self-checksums match Python reference")
-        return True
-
-def test_tamper_detection():
-    """
-    Verify that tampering with weights changes the checksum.
-    """
-    print("\n[TEST 5] Tamper Detection")
-    print("-" * 60)
-
-    weight_bytes = serialize_weights()
-    original_checksum = python_checksum_simple(weight_bytes)
-
-    print(f"  Original checksum: {original_checksum} (0x{original_checksum:02x})")
-
-    # Tamper with one byte
-    tampered = weight_bytes.copy()
-    tampered[100] = (tampered[100] + 1) % 256
-    tampered_checksum = python_checksum_simple(tampered)
-
-    print(f"  Tampered checksum: {tampered_checksum} (0x{tampered_checksum:02x})")
-    print(f"  Checksums differ: {'YES' if original_checksum != tampered_checksum else 'NO'}")
-
-    # Verify circuit detects the same difference
-    circuit_original = circuit_checksum_simple(weight_bytes[:128])
-    circuit_tampered = circuit_checksum_simple(tampered[:128])
-
-    print(f"\n  Circuit verification (first 128 bytes):")
-    print(f"    Original: {circuit_original}")
-    print(f"    Tampered: {circuit_tampered}")
-    print(f"    Detects tampering: {'YES' if circuit_original != circuit_tampered else 'NO'}")
-
-    if original_checksum != tampered_checksum and circuit_original != circuit_tampered:
-        print("\n  PASSED: Tampering detected by both Python and circuit")
-        return True
-    else:
-        print("\n  FAILED: Tampering not properly detected")
-        return False
-
-def test_weight_statistics():
-    """
-    Compute and display statistics about the weights.
-    """
-    print("\n[TEST 6] Weight Statistics")
-    print("-" * 60)
-
-    weight_bytes = serialize_weights()
-
-    print(f"  Total weight bytes: {len(weight_bytes)}")
-    print(f"  Unique values: {len(set(weight_bytes))}")
-    print(f"  Min value: {min(weight_bytes)}")
-    print(f"  Max value: {max(weight_bytes)}")
-
-    # Value distribution
-    from collections import Counter
-    counts = Counter(weight_bytes)
-    most_common = counts.most_common(5)
-    print(f"  Most common values:")
-    for val, count in most_common:
-        pct = 100 * count / len(weight_bytes)
-        print(f"    {val:3d} (0x{val:02x}): {count:4d} occurrences ({pct:.1f}%)")
-
-    # Checksums for reference
-    print(f"\n  Reference checksums:")
-    print(f"    Simple sum: {python_checksum_simple(weight_bytes)}")
-    print(f"    XOR:        {python_checksum_xor(weight_bytes)}")
-    print(f"    Fletcher-8: 0x{python_fletcher8(weight_bytes):04x}")
-    print(f"    CRC-8:      0x{python_crc8(weight_bytes[:256]):02x} (first 256 bytes)")
-
-    return True
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #6: CRYPTOGRAPHIC SELF-TEST")
-    print(" Computing checksums of weights using the weights themselves")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Checksum primitives", test_checksum_primitives()))
-    results.append(("Fletcher-8", test_fletcher8()))
-    results.append(("CRC-8", test_crc8()))
-    results.append(("Self-checksum", test_self_checksum()))
-    results.append(("Tamper detection", test_tamper_detection()))
-    results.append(("Weight statistics", test_weight_statistics()))
-
-    print("\n" + "=" * 70)
-    print(" 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} tests passed")
-
-    if passed == total:
-        print("\n  STATUS: CRYPTOGRAPHIC SELF-TEST COMPLETE")
-        print("          The computer verified its own integrity.")
-    else:
-        print("\n  STATUS: SOME SELF-TESTS FAILED")
-
-    print("=" * 70)

tests/test_equivalence.py

@@ -1,477 +0,0 @@
-"""
-TEST #2: Formal Equivalence Checking
-=====================================
-Run 8-bit adder against Python's arithmetic for ALL 2^16 input pairs.
-Bit-for-bit comparison of every result and carry flag.
-
-A skeptic would demand: "Prove exhaustive correctness, not just sampling."
-"""
-
-import torch
-from safetensors.torch import load_file
-import time
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-def eval_xor_arith(inp, prefix):
-    """Evaluate XOR for arithmetic circuits."""
-    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):
-    """Evaluate full adder, return (sum, carry_out)."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def add_8bit(a, b):
-    """8-bit addition using ripple carry adder."""
-    carry = 0.0
-    result_bits = []
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-    result = sum(result_bits[i] * (2**i) for i in range(8))
-    return result, int(carry)
-
-def compare_8bit(a, b):
-    """8-bit comparators."""
-    a_bits = torch.tensor([(a >> (7-i)) & 1 for i in range(8)], dtype=torch.float32)
-    b_bits = torch.tensor([(b >> (7-i)) & 1 for i in range(8)], dtype=torch.float32)
-
-    # Greater than
-    w_gt = model['arithmetic.greaterthan8bit.comparator']
-    gt = 1 if ((a_bits - b_bits) @ w_gt).item() > 0 else 0
-
-    # Less than
-    w_lt = model['arithmetic.lessthan8bit.comparator']
-    lt = 1 if ((b_bits - a_bits) @ w_lt).item() > 0 else 0
-
-    # Equal (neither gt nor lt)
-    eq = 1 if (gt == 0 and lt == 0) else 0
-
-    return gt, lt, eq
-
-# =============================================================================
-# EXHAUSTIVE TESTS
-# =============================================================================
-
-def test_addition_exhaustive():
-    """
-    Test ALL 65,536 addition combinations.
-    """
-    print("\n[TEST 1] Exhaustive 8-bit Addition: 256 x 256 = 65,536 cases")
-    print("-" * 60)
-
-    errors = []
-    start = time.perf_counter()
-
-    for a in range(256):
-        for b in range(256):
-            # Circuit result
-            result, carry = add_8bit(a, b)
-
-            # Python reference
-            full_sum = a + b
-            expected_result = full_sum % 256
-            expected_carry = 1 if full_sum > 255 else 0
-
-            # Compare
-            if result != expected_result:
-                errors.append(('result', a, b, expected_result, result))
-            if carry != expected_carry:
-                errors.append(('carry', a, b, expected_carry, carry))
-
-        # Progress every 32 rows
-        if (a + 1) % 32 == 0:
-            elapsed = time.perf_counter() - start
-            rate = ((a + 1) * 256) / elapsed
-            eta = (256 - a - 1) * 256 / rate
-            print(f"    Progress: {a+1}/256 rows ({(a+1)*256:,} tests) "
-                  f"| {rate:.0f} tests/sec | ETA: {eta:.1f}s")
-
-    elapsed = time.perf_counter() - start
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors[:10]:
-            print(f"    {e[0]}: {e[1]} + {e[2]} = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 65,536 additions verified")
-        print(f"  Time: {elapsed:.2f}s ({65536/elapsed:.0f} tests/sec)")
-
-    return len(errors) == 0
-
-def test_comparators_exhaustive():
-    """
-    Test ALL 65,536 comparator combinations for GT, LT, EQ.
-    """
-    print("\n[TEST 2] Exhaustive 8-bit Comparators: 256 x 256 x 3 = 196,608 checks")
-    print("-" * 60)
-
-    errors = []
-    start = time.perf_counter()
-
-    for a in range(256):
-        for b in range(256):
-            gt, lt, eq = compare_8bit(a, b)
-
-            # Python reference
-            exp_gt = 1 if a > b else 0
-            exp_lt = 1 if a < b else 0
-            exp_eq = 1 if a == b else 0
-
-            if gt != exp_gt:
-                errors.append(('GT', a, b, exp_gt, gt))
-            if lt != exp_lt:
-                errors.append(('LT', a, b, exp_lt, lt))
-            if eq != exp_eq:
-                errors.append(('EQ', a, b, exp_eq, eq))
-
-        if (a + 1) % 32 == 0:
-            elapsed = time.perf_counter() - start
-            rate = ((a + 1) * 256) / elapsed
-            eta = (256 - a - 1) * 256 / rate
-            print(f"    Progress: {a+1}/256 rows | {rate:.0f} pairs/sec | ETA: {eta:.1f}s")
-
-    elapsed = time.perf_counter() - start
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors[:10]:
-            print(f"    {e[0]}({e[1]}, {e[2]}) = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 196,608 comparisons verified (GT, LT, EQ for each pair)")
-        print(f"  Time: {elapsed:.2f}s")
-
-    return len(errors) == 0
-
-def test_boolean_exhaustive():
-    """
-    Exhaustive test of all 2-input Boolean gates (4 cases each).
-    """
-    print("\n[TEST 3] Exhaustive Boolean Gates: AND, OR, NAND, NOR, XOR, XNOR")
-    print("-" * 60)
-
-    gates = {
-        'and':  lambda a, b: a & b,
-        'or':   lambda a, b: a | b,
-        'nand': lambda a, b: 1 - (a & b),
-        'nor':  lambda a, b: 1 - (a | b),
-    }
-
-    errors = []
-
-    # Simple gates (single layer)
-    for gate_name, expected_fn in gates.items():
-        w = model[f'boolean.{gate_name}.weight']
-        bias = model[f'boolean.{gate_name}.bias']
-
-        for a in [0, 1]:
-            for b in [0, 1]:
-                inp = torch.tensor([float(a), float(b)])
-                result = int(heaviside(inp @ w + bias).item())
-                expected = expected_fn(a, b)
-
-                if result != expected:
-                    errors.append((gate_name.upper(), a, b, expected, result))
-
-    # XOR (two-layer)
-    for a in [0, 1]:
-        for b in [0, 1]:
-            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()])
-            result = int(heaviside(hidden @ w2 + b2).item())
-            expected = a ^ b
-
-            if result != expected:
-                errors.append(('XOR', a, b, expected, result))
-
-    # XNOR (two-layer)
-    for a in [0, 1]:
-        for b in [0, 1]:
-            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()])
-            result = int(heaviside(hidden @ w2 + b2).item())
-            expected = 1 - (a ^ b)  # XNOR = NOT XOR
-
-            if result != expected:
-                errors.append(('XNOR', a, b, expected, result))
-
-    # NOT (single input)
-    w = model['boolean.not.weight']
-    bias = model['boolean.not.bias']
-    for a in [0, 1]:
-        inp = torch.tensor([float(a)])
-        result = int(heaviside(inp @ w + bias).item())
-        expected = 1 - a
-        if result != expected:
-            errors.append(('NOT', a, '-', expected, result))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    {e[0]}({e[1]}, {e[2]}) = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: All Boolean gates verified (AND, OR, NAND, NOR, XOR, XNOR, NOT)")
-        print(f"  Total: 26 truth table entries")
-
-    return len(errors) == 0
-
-def test_half_adder_exhaustive():
-    """
-    Exhaustive test of half adder (4 cases).
-    """
-    print("\n[TEST 4] Exhaustive Half Adder: 4 cases")
-    print("-" * 60)
-
-    errors = []
-
-    for a in [0, 1]:
-        for b in [0, 1]:
-            inp = torch.tensor([float(a), float(b)])
-
-            # Sum (XOR)
-            w1_or = model['arithmetic.halfadder.sum.layer1.or.weight']
-            b1_or = model['arithmetic.halfadder.sum.layer1.or.bias']
-            w1_nand = model['arithmetic.halfadder.sum.layer1.nand.weight']
-            b1_nand = model['arithmetic.halfadder.sum.layer1.nand.bias']
-            w2 = model['arithmetic.halfadder.sum.layer2.weight']
-            b2_sum = model['arithmetic.halfadder.sum.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()])
-            sum_bit = int(heaviside(hidden @ w2 + b2_sum).item())
-
-            # Carry (AND)
-            w_c = model['arithmetic.halfadder.carry.weight']
-            b_c = model['arithmetic.halfadder.carry.bias']
-            carry = int(heaviside(inp @ w_c + b_c).item())
-
-            # Expected
-            exp_sum = a ^ b
-            exp_carry = a & b
-
-            if sum_bit != exp_sum:
-                errors.append(('SUM', a, b, exp_sum, sum_bit))
-            if carry != exp_carry:
-                errors.append(('CARRY', a, b, exp_carry, carry))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    HA.{e[0]}({e[1]}, {e[2]}) = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: Half adder verified (4 sum + 4 carry = 8 checks)")
-
-    return len(errors) == 0
-
-def test_full_adder_exhaustive():
-    """
-    Exhaustive test of full adder (8 cases).
-    """
-    print("\n[TEST 5] Exhaustive Full Adder: 8 cases")
-    print("-" * 60)
-
-    errors = []
-
-    for a in [0, 1]:
-        for b in [0, 1]:
-            for cin in [0, 1]:
-                sum_bit, cout = eval_full_adder(float(a), float(b), float(cin),
-                                                 'arithmetic.fulladder')
-
-                # Expected
-                total = a + b + cin
-                exp_sum = total % 2
-                exp_cout = total // 2
-
-                if sum_bit != exp_sum:
-                    errors.append(('SUM', a, b, cin, exp_sum, sum_bit))
-                if cout != exp_cout:
-                    errors.append(('COUT', a, b, cin, exp_cout, cout))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    FA.{e[0]}({e[1]}, {e[2]}, {e[3]}) = {e[5]}, expected {e[4]}")
-    else:
-        print(f"  PASSED: Full adder verified (8 sum + 8 carry = 16 checks)")
-
-    return len(errors) == 0
-
-def test_2bit_adder_exhaustive():
-    """
-    Exhaustive test of 2-bit ripple carry adder (16 cases).
-    """
-    print("\n[TEST 6] Exhaustive 2-bit Adder: 4 x 4 = 16 cases")
-    print("-" * 60)
-
-    errors = []
-
-    for a in range(4):
-        for b in range(4):
-            # Use 2-bit ripple carry
-            carry = 0.0
-            result_bits = []
-
-            for i in range(2):
-                a_bit = (a >> i) & 1
-                b_bit = (b >> i) & 1
-                s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                            f'arithmetic.ripplecarry2bit.fa{i}')
-                result_bits.append(s)
-
-            result = result_bits[0] + 2 * result_bits[1]
-            cout = int(carry)
-
-            exp_result = (a + b) % 4
-            exp_carry = 1 if (a + b) >= 4 else 0
-
-            if result != exp_result:
-                errors.append(('result', a, b, exp_result, result))
-            if cout != exp_carry:
-                errors.append(('carry', a, b, exp_carry, cout))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    {e[0]}: {e[1]} + {e[2]} = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 2-bit adder verified (16 results + 16 carries)")
-
-    return len(errors) == 0
-
-def test_4bit_adder_exhaustive():
-    """
-    Exhaustive test of 4-bit ripple carry adder (256 cases).
-    """
-    print("\n[TEST 7] Exhaustive 4-bit Adder: 16 x 16 = 256 cases")
-    print("-" * 60)
-
-    errors = []
-
-    for a in range(16):
-        for b in range(16):
-            carry = 0.0
-            result_bits = []
-
-            for i in range(4):
-                a_bit = (a >> i) & 1
-                b_bit = (b >> i) & 1
-                s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                            f'arithmetic.ripplecarry4bit.fa{i}')
-                result_bits.append(s)
-
-            result = sum(result_bits[i] * (2**i) for i in range(4))
-            cout = int(carry)
-
-            exp_result = (a + b) % 16
-            exp_carry = 1 if (a + b) >= 16 else 0
-
-            if result != exp_result:
-                errors.append(('result', a, b, exp_result, result))
-            if cout != exp_carry:
-                errors.append(('carry', a, b, exp_carry, cout))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors[:10]:
-            print(f"    {e[0]}: {e[1]} + {e[2]} = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 4-bit adder verified (256 results + 256 carries)")
-
-    return len(errors) == 0
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #2: FORMAL EQUIVALENCE CHECKING")
-    print(" Exhaustive verification against Python's arithmetic")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Boolean gates", test_boolean_exhaustive()))
-    results.append(("Half adder", test_half_adder_exhaustive()))
-    results.append(("Full adder", test_full_adder_exhaustive()))
-    results.append(("2-bit adder", test_2bit_adder_exhaustive()))
-    results.append(("4-bit adder", test_4bit_adder_exhaustive()))
-    results.append(("8-bit adder", test_addition_exhaustive()))
-    results.append(("Comparators", test_comparators_exhaustive()))
-
-    print("\n" + "=" * 70)
-    print(" 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:20s} [{status}]")
-
-    print(f"\n  Total: {passed}/{total} test categories passed")
-
-    total_checks = 26 + 8 + 16 + 32 + 512 + 65536*2 + 65536*3
-    print(f"  Individual checks: ~{total_checks:,}")
-
-    if passed == total:
-        print("\n  STATUS: EXHAUSTIVE EQUIVALENCE VERIFIED")
-    else:
-        print("\n  STATUS: EQUIVALENCE FAILURES DETECTED")
-
-    print("=" * 70)

tests/test_gate_reconstruction.py

@@ -1,469 +0,0 @@
-"""
-TEST #3: Gate-Level Reconstruction
-===================================
-Given ONLY the weights, reconstruct the Boolean function each neuron computes.
-Verify it matches the claimed gate type via truth table exhaustion.
-
-A skeptic would demand: "Prove your weights actually implement the gates you
-claim. Derive the function from weights alone, then verify."
-"""
-
-import torch
-from safetensors.torch import load_file
-from itertools import product
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-# Known Boolean functions (truth tables as tuples)
-KNOWN_FUNCTIONS = {
-    # 1-input functions
-    'IDENTITY':   ((0,), (1,)),           # f(0)=0, f(1)=1
-    'NOT':        ((1,), (0,)),           # f(0)=1, f(1)=0
-    'CONST_0':    ((0,), (0,)),
-    'CONST_1':    ((1,), (1,)),
-
-    # 2-input functions (indexed by (0,0), (0,1), (1,0), (1,1))
-    '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),
-    'IMPLIES':    (1, 1, 0, 1),           # a -> b = ~a | b
-    'NIMPLIES':   (0, 0, 1, 0),           # a & ~b
-    'PROJ_A':     (0, 0, 1, 1),           # output = a
-    'PROJ_B':     (0, 1, 0, 1),           # output = b
-    'NOT_A':      (1, 1, 0, 0),
-    'NOT_B':      (1, 0, 1, 0),
-}
-
-def identify_1input_function(w, b):
-    """
-    Given weights w and bias b for a 1-input gate,
-    reconstruct and identify the Boolean function.
-    """
-    truth_table = []
-    for x in [0, 1]:
-        inp = torch.tensor([float(x)])
-        out = int(heaviside(inp @ w + b).item())
-        truth_table.append(out)
-
-    truth_table = tuple(truth_table)
-
-    # Match against known functions
-    for name, tt in KNOWN_FUNCTIONS.items():
-        if len(tt) == 2 and isinstance(tt[0], tuple):
-            # 1-input format
-            if (tt[0][0], tt[1][0]) == truth_table:
-                return name, truth_table
-
-    return 'UNKNOWN', truth_table
-
-def identify_2input_function(w, b):
-    """
-    Given weights w and bias b for a 2-input gate,
-    reconstruct and identify the Boolean function.
-    """
-    truth_table = []
-    for a, b_in in [(0, 0), (0, 1), (1, 0), (1, 1)]:
-        inp = torch.tensor([float(a), float(b_in)])
-        out = int(heaviside(inp @ w + b).item())
-        truth_table.append(out)
-
-    truth_table = tuple(truth_table)
-
-    # Match against known functions
-    for name, tt in KNOWN_FUNCTIONS.items():
-        if isinstance(tt, tuple) and len(tt) == 4 and isinstance(tt[0], int):
-            if tt == truth_table:
-                return name, truth_table
-
-    return 'UNKNOWN', truth_table
-
-def identify_2layer_function(w1_n1, b1_n1, w1_n2, b1_n2, w2, b2):
-    """
-    Given weights for a 2-layer network (2 hidden neurons),
-    reconstruct and identify the Boolean function.
-    """
-    truth_table = []
-    for a, b_in in [(0, 0), (0, 1), (1, 0), (1, 1)]:
-        inp = torch.tensor([float(a), float(b_in)])
-
-        # Layer 1
-        h1 = heaviside(inp @ w1_n1 + b1_n1).item()
-        h2 = heaviside(inp @ w1_n2 + b1_n2).item()
-        hidden = torch.tensor([h1, h2])
-
-        # Layer 2
-        out = int(heaviside(hidden @ w2 + b2).item())
-        truth_table.append(out)
-
-    truth_table = tuple(truth_table)
-
-    for name, tt in KNOWN_FUNCTIONS.items():
-        if isinstance(tt, tuple) and len(tt) == 4 and isinstance(tt[0], int):
-            if tt == truth_table:
-                return name, truth_table
-
-    return 'UNKNOWN', truth_table
-
-def analyze_threshold_gate(w, b, n_inputs):
-    """
-    Analyze a threshold gate: compute threshold and effective function.
-    For a gate with weights w and bias b:
-    - Fires when sum(w_i * x_i) + b >= 0
-    - Threshold = -b (fires when weighted sum >= -b)
-    """
-    w_list = w.tolist() if hasattr(w, 'tolist') else [w]
-    b_val = b.item() if hasattr(b, 'item') else b
-
-    threshold = -b_val
-
-    # Compute min and max weighted sums
-    min_sum = sum(min(0, wi) for wi in w_list)
-    max_sum = sum(max(0, wi) for wi in w_list)
-
-    return {
-        'weights': w_list,
-        'bias': b_val,
-        'threshold': threshold,
-        'min_sum': min_sum,
-        'max_sum': max_sum,
-    }
-
-# =============================================================================
-# RECONSTRUCTION TESTS
-# =============================================================================
-
-def test_single_layer_gates():
-    """
-    Reconstruct all single-layer Boolean gates from weights.
-    """
-    print("\n[TEST 1] Single-Layer Gate Reconstruction")
-    print("-" * 60)
-
-    gates_to_test = [
-        ('boolean.and', 'AND', 2),
-        ('boolean.or', 'OR', 2),
-        ('boolean.nand', 'NAND', 2),
-        ('boolean.nor', 'NOR', 2),
-        ('boolean.not', 'NOT', 1),
-        ('boolean.implies', 'IMPLIES', 2),
-    ]
-
-    errors = []
-    results = []
-
-    for prefix, expected_name, n_inputs in gates_to_test:
-        w = model[f'{prefix}.weight']
-        b = model[f'{prefix}.bias']
-
-        if n_inputs == 1:
-            identified, tt = identify_1input_function(w, b)
-        else:
-            identified, tt = identify_2input_function(w, b)
-
-        analysis = analyze_threshold_gate(w, b, n_inputs)
-
-        match = identified == expected_name
-        status = "OK" if match else "MISMATCH"
-
-        results.append({
-            'gate': prefix,
-            'expected': expected_name,
-            'identified': identified,
-            'truth_table': tt,
-            'weights': analysis['weights'],
-            'bias': analysis['bias'],
-            'threshold': analysis['threshold'],
-            'match': match
-        })
-
-        if not match:
-            errors.append((prefix, expected_name, identified))
-
-        print(f"  {prefix:25s} -> {identified:10s} [w={analysis['weights']}, b={analysis['bias']:.0f}] [{status}]")
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-        for e in errors:
-            print(f"    {e[0]}: expected {e[1]}, got {e[2]}")
-    else:
-        print(f"  PASSED: {len(gates_to_test)} single-layer gates reconstructed correctly")
-
-    return len(errors) == 0, results
-
-def test_two_layer_gates():
-    """
-    Reconstruct all two-layer Boolean gates from weights.
-    """
-    print("\n[TEST 2] Two-Layer Gate Reconstruction")
-    print("-" * 60)
-
-    gates_to_test = [
-        ('boolean.xor', 'XOR'),
-        ('boolean.xnor', 'XNOR'),
-        ('boolean.biimplies', 'XNOR'),  # biimplies = XNOR
-    ]
-
-    errors = []
-    results = []
-
-    for prefix, expected_name in gates_to_test:
-        w1_n1 = model[f'{prefix}.layer1.neuron1.weight']
-        b1_n1 = model[f'{prefix}.layer1.neuron1.bias']
-        w1_n2 = model[f'{prefix}.layer1.neuron2.weight']
-        b1_n2 = model[f'{prefix}.layer1.neuron2.bias']
-        w2 = model[f'{prefix}.layer2.weight']
-        b2 = model[f'{prefix}.layer2.bias']
-
-        identified, tt = identify_2layer_function(w1_n1, b1_n1, w1_n2, b1_n2, w2, b2)
-
-        # Also identify the hidden neurons
-        hidden1_id, _ = identify_2input_function(w1_n1, b1_n1)
-        hidden2_id, _ = identify_2input_function(w1_n2, b1_n2)
-
-        match = identified == expected_name
-        status = "OK" if match else "MISMATCH"
-
-        results.append({
-            'gate': prefix,
-            'expected': expected_name,
-            'identified': identified,
-            'truth_table': tt,
-            'hidden1': hidden1_id,
-            'hidden2': hidden2_id,
-            'match': match
-        })
-
-        if not match:
-            errors.append((prefix, expected_name, identified))
-
-        print(f"  {prefix:25s} -> {identified:10s} [hidden: {hidden1_id} + {hidden2_id}] [{status}]")
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-    else:
-        print(f"  PASSED: {len(gates_to_test)} two-layer gates reconstructed correctly")
-
-    return len(errors) == 0, results
-
-def test_adder_components():
-    """
-    Reconstruct and verify adder component gates.
-    """
-    print("\n[TEST 3] Adder Component Reconstruction")
-    print("-" * 60)
-
-    errors = []
-
-    # Half adder carry = AND
-    w = model['arithmetic.halfadder.carry.weight']
-    b = model['arithmetic.halfadder.carry.bias']
-    identified, tt = identify_2input_function(w, b)
-    status = "OK" if identified == 'AND' else "MISMATCH"
-    print(f"  halfadder.carry          -> {identified:10s} [{status}]")
-    if identified != 'AND':
-        errors.append(('halfadder.carry', 'AND', identified))
-
-    # Full adder carry_or = OR
-    w = model['arithmetic.fulladder.carry_or.weight']
-    b = model['arithmetic.fulladder.carry_or.bias']
-    identified, tt = identify_2input_function(w, b)
-    status = "OK" if identified == 'OR' else "MISMATCH"
-    print(f"  fulladder.carry_or       -> {identified:10s} [{status}]")
-    if identified != 'OR':
-        errors.append(('fulladder.carry_or', 'OR', identified))
-
-    # Ripple carry FA0 carry_or = OR
-    w = model['arithmetic.ripplecarry8bit.fa0.carry_or.weight']
-    b = model['arithmetic.ripplecarry8bit.fa0.carry_or.bias']
-    identified, tt = identify_2input_function(w, b)
-    status = "OK" if identified == 'OR' else "MISMATCH"
-    print(f"  rc8.fa0.carry_or         -> {identified:10s} [{status}]")
-    if identified != 'OR':
-        errors.append(('rc8.fa0.carry_or', 'OR', identified))
-
-    # Verify all 8 FA carry gates in ripple carry
-    print("\n  Verifying all 8 FA carry_or gates in 8-bit ripple carry...")
-    for i in range(8):
-        w = model[f'arithmetic.ripplecarry8bit.fa{i}.carry_or.weight']
-        b = model[f'arithmetic.ripplecarry8bit.fa{i}.carry_or.bias']
-        identified, _ = identify_2input_function(w, b)
-        if identified != 'OR':
-            errors.append((f'rc8.fa{i}.carry_or', 'OR', identified))
-            print(f"    fa{i}.carry_or: MISMATCH (got {identified})")
-
-    if not any('rc8.fa' in e[0] and 'carry_or' in e[0] for e in errors):
-        print(f"    All 8 carry_or gates verified as OR")
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} mismatches")
-    else:
-        print(f"  PASSED: All adder components match expected gate types")
-
-    return len(errors) == 0
-
-def test_threshold_analysis():
-    """
-    Analyze threshold characteristics of various gates.
-    """
-    print("\n[TEST 4] Threshold Analysis")
-    print("-" * 60)
-
-    print("  Gate              Weights         Bias    Threshold   Function")
-    print("  " + "-" * 56)
-
-    gates = [
-        ('boolean.and', 'AND'),
-        ('boolean.or', 'OR'),
-        ('boolean.nand', 'NAND'),
-        ('boolean.nor', 'NOR'),
-    ]
-
-    for prefix, name in gates:
-        w = model[f'{prefix}.weight']
-        b = model[f'{prefix}.bias']
-        analysis = analyze_threshold_gate(w, b, 2)
-
-        # Verify the threshold makes sense
-        # AND: w=[1,1], b=-2, threshold=2 (both inputs needed)
-        # OR:  w=[1,1], b=-1, threshold=1 (one input needed)
-        # NAND: w=[-1,-1], b=1, threshold=-1 (inverted AND)
-        # NOR:  w=[-1,-1], b=0, threshold=0 (inverted OR)
-
-        w_str = str(analysis['weights'])
-        print(f"  {prefix:18s} {w_str:15s} {analysis['bias']:6.0f} {analysis['threshold']:10.0f}   {name}")
-
-    print()
-    print("  Interpretation:")
-    print("    AND:  fires when sum >= 2 (both inputs must be 1)")
-    print("    OR:   fires when sum >= 1 (at least one input is 1)")
-    print("    NAND: fires when sum >= -1 (always, unless both inputs are 1)")
-    print("    NOR:  fires when sum >= 0 (only when both inputs are 0)")
-
-    return True
-
-def test_weight_uniqueness():
-    """
-    Verify that different gate types have different weight configurations.
-    """
-    print("\n[TEST 5] Weight Configuration Uniqueness")
-    print("-" * 60)
-
-    configs = {}
-
-    gates = ['and', 'or', 'nand', 'nor']
-    for gate in gates:
-        w = model[f'boolean.{gate}.weight']
-        b = model[f'boolean.{gate}.bias']
-        config = (tuple(w.tolist()), b.item())
-        configs[gate] = config
-
-    # Check all configs are unique
-    unique_configs = set(configs.values())
-
-    print(f"  Configurations found:")
-    for gate, config in configs.items():
-        print(f"    {gate:6s}: w={config[0]}, b={config[1]}")
-
-    print()
-    if len(unique_configs) == len(configs):
-        print(f"  PASSED: All {len(gates)} gate types have unique weight configurations")
-        return True
-    else:
-        print(f"  FAILED: Some gates share weight configurations")
-        return False
-
-def test_reconstruction_from_scratch():
-    """
-    Ultimate test: Given arbitrary weights, derive the Boolean function
-    without knowing what gate it's supposed to be.
-    """
-    print("\n[TEST 6] Blind Reconstruction (No Prior Knowledge)")
-    print("-" * 60)
-
-    # Pick some gates without looking at names
-    test_tensors = [
-        'boolean.and.weight',
-        'boolean.or.weight',
-        'boolean.nand.weight',
-        'boolean.xor.layer1.neuron1.weight',
-        'arithmetic.halfadder.carry.weight',
-    ]
-
-    print("  Given only weights and bias, reconstructing functions...\n")
-
-    for w_name in test_tensors:
-        b_name = w_name.replace('.weight', '.bias')
-        w = model[w_name]
-        b = model[b_name]
-
-        identified, tt = identify_2input_function(w, b)
-
-        print(f"  {w_name}")
-        print(f"    Weights: {w.tolist()}")
-        print(f"    Bias:    {b.item()}")
-        print(f"    Truth table: {tt}")
-        print(f"    Identified: {identified}")
-        print()
-
-    print("  (All identifications derived purely from weight enumeration)")
-    return True
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #3: GATE-LEVEL RECONSTRUCTION")
-    print(" Deriving Boolean functions from weights alone")
-    print("=" * 70)
-
-    results = []
-
-    r1, _ = test_single_layer_gates()
-    results.append(("Single-layer gates", r1))
-
-    r2, _ = test_two_layer_gates()
-    results.append(("Two-layer gates", r2))
-
-    r3 = test_adder_components()
-    results.append(("Adder components", r3))
-
-    r4 = test_threshold_analysis()
-    results.append(("Threshold analysis", r4))
-
-    r5 = test_weight_uniqueness()
-    results.append(("Weight uniqueness", r5))
-
-    r6 = test_reconstruction_from_scratch()
-    results.append(("Blind reconstruction", r6))
-
-    print("\n" + "=" * 70)
-    print(" 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 GATES RECONSTRUCTED AND VERIFIED")
-    else:
-        print("\n  STATUS: RECONSTRUCTION FAILURES DETECTED")
-
-    print("=" * 70)

tests/test_independence.py

@@ -1,791 +0,0 @@
-"""
-TEST #9: Independence Reproduction
-===================================
-Derive weights from first principles using only the specification.
-Compare derived weights to original weights.
-Prove they are functionally equivalent.
-
-A skeptic would demand: "Prove your weights aren't arbitrary. Show me that
-someone with only the spec could derive equivalent weights independently."
-
-This test:
-1. Defines formal specs for each gate (truth tables, functional requirements)
-2. Derives weights algorithmically from specs alone
-3. Compares derived vs original weights
-4. Verifies functional equivalence
-"""
-
-import torch
-from safetensors.torch import load_file
-from itertools import product
-
-# Load original circuits
-original_model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-# =============================================================================
-# FORMAL SPECIFICATIONS (what a reproducer would receive)
-# =============================================================================
-
-GATE_SPECS = {
-    'AND': {
-        'inputs': 2,
-        'truth_table': {(0,0): 0, (0,1): 0, (1,0): 0, (1,1): 1},
-        'description': 'Output 1 iff both inputs are 1',
-    },
-    'OR': {
-        'inputs': 2,
-        'truth_table': {(0,0): 0, (0,1): 1, (1,0): 1, (1,1): 1},
-        'description': 'Output 1 iff at least one input is 1',
-    },
-    'NOT': {
-        'inputs': 1,
-        'truth_table': {(0,): 1, (1,): 0},
-        'description': 'Output the complement of input',
-    },
-    'NAND': {
-        'inputs': 2,
-        'truth_table': {(0,0): 1, (0,1): 1, (1,0): 1, (1,1): 0},
-        'description': 'Output 0 iff both inputs are 1',
-    },
-    'NOR': {
-        'inputs': 2,
-        'truth_table': {(0,0): 1, (0,1): 0, (1,0): 0, (1,1): 0},
-        'description': 'Output 1 iff both inputs are 0',
-    },
-    'XOR': {
-        'inputs': 2,
-        'truth_table': {(0,0): 0, (0,1): 1, (1,0): 1, (1,1): 0},
-        'description': 'Output 1 iff inputs differ',
-        'layers': 2,  # Not linearly separable
-    },
-    'XNOR': {
-        'inputs': 2,
-        'truth_table': {(0,0): 1, (0,1): 0, (1,0): 0, (1,1): 1},
-        'description': 'Output 1 iff inputs are equal',
-        'layers': 2,
-    },
-    'IMPLIES': {
-        'inputs': 2,
-        'truth_table': {(0,0): 1, (0,1): 1, (1,0): 0, (1,1): 1},
-        'description': 'a -> b = NOT(a) OR b',
-    },
-}
-
-ADDER_SPECS = {
-    'half_adder': {
-        'inputs': ['a', 'b'],
-        'outputs': ['sum', 'carry'],
-        'truth_table': {
-            (0,0): (0, 0),
-            (0,1): (1, 0),
-            (1,0): (1, 0),
-            (1,1): (0, 1),
-        },
-        'sum_formula': 'a XOR b',
-        'carry_formula': 'a AND b',
-    },
-    'full_adder': {
-        'inputs': ['a', 'b', 'cin'],
-        'outputs': ['sum', 'cout'],
-        'truth_table': {
-            (0,0,0): (0, 0),
-            (0,0,1): (1, 0),
-            (0,1,0): (1, 0),
-            (0,1,1): (0, 1),
-            (1,0,0): (1, 0),
-            (1,0,1): (0, 1),
-            (1,1,0): (0, 1),
-            (1,1,1): (1, 1),
-        },
-        'structure': 'Two half-adders: HA1(a,b) -> (s1,c1), HA2(s1,cin) -> (sum,c2), cout = c1 OR c2',
-    },
-}
-
-# =============================================================================
-# INDEPENDENT WEIGHT DERIVATION
-# =============================================================================
-
-def derive_single_layer_weights(truth_table, n_inputs):
-    """
-    Derive weights and bias for a single-layer threshold gate.
-
-    For a threshold gate: output = 1 if (sum(w_i * x_i) + b) >= 0
-
-    Approach:
-    - For inputs that should output 1, we want sum >= -b (i.e., sum + b >= 0)
-    - For inputs that should output 0, we want sum < -b
-
-    Standard solutions for common gates:
-    - AND(a,b): w=[1,1], b=-2 (fires when sum >= 2, i.e., both inputs = 1)
-    - OR(a,b):  w=[1,1], b=-1 (fires when sum >= 1, i.e., at least one = 1)
-    - NOT(a):   w=[-1], b=0 (fires when -a >= 0, i.e., a = 0)
-    """
-
-    # Separate inputs by output class
-    class_0 = [inp for inp, out in truth_table.items() if out == 0]
-    class_1 = [inp for inp, out in truth_table.items() if out == 1]
-
-    if not class_1:
-        # Constant 0
-        return [0] * n_inputs, -1
-    if not class_0:
-        # Constant 1
-        return [0] * n_inputs, 0
-
-    # Try standard weight patterns
-    if n_inputs == 1:
-        # NOT gate: w=[-1], b=0
-        w, b = [-1], 0
-        if verify_weights(w, b, truth_table):
-            return w, b
-        # IDENTITY: w=[1], b=0
-        w, b = [1], 0
-        if verify_weights(w, b, truth_table):
-            return w, b
-
-    elif n_inputs == 2:
-        # Try common patterns
-        patterns = [
-            ([1, 1], -2),    # AND
-            ([1, 1], -1),    # OR
-            ([-1, -1], 1),   # NAND
-            ([-1, -1], 0),   # NOR
-            ([-1, 1], 0),    # IMPLIES (a -> b)
-            ([1, -1], 0),    # NOT IMPLIES (b -> a)
-        ]
-
-        for w, b in patterns:
-            if verify_weights(w, b, truth_table):
-                return w, b
-
-    # Fallback: Linear programming approach (simplified)
-    # Find weights that separate the two classes
-    # For small cases, we can brute force
-
-    for w1 in range(-3, 4):
-        for w2 in range(-3, 4) if n_inputs > 1 else [0]:
-            for bias in range(-4, 4):
-                w = [w1] if n_inputs == 1 else [w1, w2]
-                if verify_weights(w, bias, truth_table):
-                    return w, bias
-
-    return None, None  # Not linearly separable
-
-def verify_weights(w, b, truth_table):
-    """Verify that weights correctly implement the truth table."""
-    for inputs, expected in truth_table.items():
-        weighted_sum = sum(wi * xi for wi, xi in zip(w, inputs)) + b
-        output = 1 if weighted_sum >= 0 else 0
-        if output != expected:
-            return False
-    return True
-
-def derive_xor_weights():
-    """
-    Derive weights for XOR (2-layer network).
-    XOR = AND(OR(a,b), NAND(a,b))
-
-    Layer 1:
-      - Neuron 1: OR(a,b) -> w=[1,1], b=-1
-      - Neuron 2: NAND(a,b) -> w=[-1,-1], b=1
-
-    Layer 2:
-      - AND(h1, h2) -> w=[1,1], b=-2
-    """
-    layer1_n1 = ([1, 1], -1)    # OR
-    layer1_n2 = ([-1, -1], 1)   # NAND
-    layer2 = ([1, 1], -2)       # AND
-
-    return {
-        'layer1.neuron1': layer1_n1,
-        'layer1.neuron2': layer1_n2,
-        'layer2': layer2,
-    }
-
-def derive_xnor_weights():
-    """
-    Derive weights for XNOR (2-layer network).
-    XNOR = OR(NOR(a,b), AND(a,b)) = OR(both_0, both_1)
-
-    Layer 1:
-      - Neuron 1: NOR(a,b) -> w=[-1,-1], b=0
-      - Neuron 2: AND(a,b) -> w=[1,1], b=-2
-
-    Layer 2:
-      - OR(h1, h2) -> w=[1,1], b=-1
-    """
-    layer1_n1 = ([-1, -1], 0)   # NOR
-    layer1_n2 = ([1, 1], -2)    # AND
-    layer2 = ([1, 1], -1)       # OR
-
-    return {
-        'layer1.neuron1': layer1_n1,
-        'layer1.neuron2': layer1_n2,
-        'layer2': layer2,
-    }
-
-def derive_half_adder_weights():
-    """
-    Derive weights for half adder.
-    sum = XOR(a,b) -> 2-layer
-    carry = AND(a,b) -> 1-layer
-    """
-    xor = derive_xor_weights()
-
-    return {
-        'sum': xor,  # XOR structure
-        'carry': ([1, 1], -2),  # AND
-    }
-
-def derive_full_adder_weights():
-    """
-    Derive weights for full adder.
-    Structure: HA1(a,b), HA2(s1,cin), cout = OR(c1,c2)
-    """
-    ha = derive_half_adder_weights()
-
-    return {
-        'ha1': ha,  # First half adder
-        'ha2': ha,  # Second half adder (same structure)
-        'carry_or': ([1, 1], -1),  # OR for carry out
-    }
-
-# =============================================================================
-# COMPARISON FUNCTIONS
-# =============================================================================
-
-def compare_single_layer(derived_w, derived_b, original_prefix):
-    """Compare derived weights to original for single-layer gate."""
-    orig_w = original_model[f'{original_prefix}.weight'].tolist()
-    orig_b = original_model[f'{original_prefix}.bias'].item()
-
-    weights_match = derived_w == orig_w
-    bias_match = derived_b == orig_b
-
-    return {
-        'weights_match': weights_match,
-        'bias_match': bias_match,
-        'derived': (derived_w, derived_b),
-        'original': (orig_w, orig_b),
-        'exact_match': weights_match and bias_match,
-    }
-
-def test_functional_equivalence(derived_w, derived_b, original_prefix, n_inputs):
-    """Test that derived and original weights produce same outputs."""
-    orig_w = torch.tensor(original_model[f'{original_prefix}.weight'].tolist())
-    orig_b = original_model[f'{original_prefix}.bias'].item()
-
-    derived_w_t = torch.tensor(derived_w, dtype=torch.float32)
-
-    all_match = True
-    mismatches = []
-
-    for inputs in product([0, 1], repeat=n_inputs):
-        inp = torch.tensor([float(x) for x in inputs])
-
-        orig_out = int(heaviside(inp @ orig_w + orig_b).item())
-        derived_out = int(1 if (sum(w*x for w,x in zip(derived_w, inputs)) + derived_b) >= 0 else 0)
-
-        if orig_out != derived_out:
-            all_match = False
-            mismatches.append((inputs, orig_out, derived_out))
-
-    return all_match, mismatches
-
-# =============================================================================
-# TESTS
-# =============================================================================
-
-def test_single_layer_gates():
-    """Derive and compare single-layer gates."""
-    print("\n[TEST 1] Single-Layer Gate Derivation")
-    print("-" * 60)
-
-    gates = [
-        ('AND', 'boolean.and', 2),
-        ('OR', 'boolean.or', 2),
-        ('NOT', 'boolean.not', 1),
-        ('NAND', 'boolean.nand', 2),
-        ('NOR', 'boolean.nor', 2),
-        ('IMPLIES', 'boolean.implies', 2),
-    ]
-
-    results = []
-
-    print(f"  {'Gate':<10} {'Derived':<20} {'Original':<20} {'Match'}")
-    print("  " + "-" * 60)
-
-    for gate_name, prefix, n_inputs in gates:
-        spec = GATE_SPECS[gate_name]
-        derived_w, derived_b = derive_single_layer_weights(spec['truth_table'], n_inputs)
-
-        comparison = compare_single_layer(derived_w, derived_b, prefix)
-        func_equiv, _ = test_functional_equivalence(derived_w, derived_b, prefix, n_inputs)
-
-        derived_str = f"w={derived_w}, b={derived_b}"
-        orig_str = f"w={comparison['original'][0]}, b={int(comparison['original'][1])}"
-
-        # Exact match or functional equivalence?
-        if comparison['exact_match']:
-            status = "EXACT"
-        elif func_equiv:
-            status = "EQUIV"
-        else:
-            status = "FAIL"
-
-        print(f"  {gate_name:<10} {derived_str:<20} {orig_str:<20} [{status}]")
-
-        results.append((gate_name, comparison['exact_match'] or func_equiv))
-
-    all_pass = all(r for _, r in results)
-    print()
-    if all_pass:
-        print("  PASSED: All single-layer gates independently derived")
-    else:
-        print("  FAILED: Some gates could not be derived")
-
-    return all_pass
-
-def test_xor_derivation():
-    """Derive and compare XOR gate."""
-    print("\n[TEST 2] XOR Gate Derivation (2-layer)")
-    print("-" * 60)
-
-    derived = derive_xor_weights()
-
-    print("  Derived structure:")
-    print(f"    Layer 1 Neuron 1 (OR):   w={derived['layer1.neuron1'][0]}, b={derived['layer1.neuron1'][1]}")
-    print(f"    Layer 1 Neuron 2 (NAND): w={derived['layer1.neuron2'][0]}, b={derived['layer1.neuron2'][1]}")
-    print(f"    Layer 2 (AND):           w={derived['layer2'][0]}, b={derived['layer2'][1]}")
-    print()
-
-    # Get original
-    orig_l1_n1_w = original_model['boolean.xor.layer1.neuron1.weight'].tolist()
-    orig_l1_n1_b = original_model['boolean.xor.layer1.neuron1.bias'].item()
-    orig_l1_n2_w = original_model['boolean.xor.layer1.neuron2.weight'].tolist()
-    orig_l1_n2_b = original_model['boolean.xor.layer1.neuron2.bias'].item()
-    orig_l2_w = original_model['boolean.xor.layer2.weight'].tolist()
-    orig_l2_b = original_model['boolean.xor.layer2.bias'].item()
-
-    print("  Original structure:")
-    print(f"    Layer 1 Neuron 1: w={orig_l1_n1_w}, b={int(orig_l1_n1_b)}")
-    print(f"    Layer 1 Neuron 2: w={orig_l1_n2_w}, b={int(orig_l1_n2_b)}")
-    print(f"    Layer 2:          w={orig_l2_w}, b={int(orig_l2_b)}")
-    print()
-
-    # Test functional equivalence
-    def eval_derived_xor(a, b):
-        h1 = 1 if (a + b - 1) >= 0 else 0  # OR
-        h2 = 1 if (-a - b + 1) >= 0 else 0  # NAND
-        return 1 if (h1 + h2 - 2) >= 0 else 0  # AND
-
-    def eval_original_xor(a, b):
-        inp = torch.tensor([float(a), float(b)])
-        h1 = heaviside(inp @ torch.tensor(orig_l1_n1_w) + orig_l1_n1_b).item()
-        h2 = heaviside(inp @ torch.tensor(orig_l1_n2_w) + orig_l1_n2_b).item()
-        hidden = torch.tensor([h1, h2])
-        return int(heaviside(hidden @ torch.tensor(orig_l2_w) + orig_l2_b).item())
-
-    all_match = True
-    print("  Functional comparison:")
-    print("    a b | Derived | Original")
-    print("    " + "-" * 25)
-    for a, b in product([0, 1], repeat=2):
-        d = eval_derived_xor(a, b)
-        o = eval_original_xor(a, b)
-        match = d == o
-        if not match:
-            all_match = False
-        print(f"    {a} {b} |    {d}    |    {o}     {'OK' if match else 'FAIL'}")
-
-    print()
-    if all_match:
-        print("  PASSED: XOR independently derived and functionally equivalent")
-    else:
-        print("  FAILED: XOR derivation mismatch")
-
-    return all_match
-
-def test_half_adder_derivation():
-    """Derive and verify half adder."""
-    print("\n[TEST 3] Half Adder Derivation")
-    print("-" * 60)
-
-    spec = ADDER_SPECS['half_adder']
-
-    print("  Specification:")
-    print("    sum = a XOR b")
-    print("    carry = a AND b")
-    print()
-
-    # Derive
-    derived = derive_half_adder_weights()
-
-    # The carry is simple
-    carry_w, carry_b = derived['carry']
-    orig_carry_w = original_model['arithmetic.halfadder.carry.weight'].tolist()
-    orig_carry_b = original_model['arithmetic.halfadder.carry.bias'].item()
-
-    carry_match = (carry_w == orig_carry_w and carry_b == orig_carry_b)
-
-    print(f"  Carry (AND): derived w={carry_w}, b={carry_b}")
-    print(f"              original w={orig_carry_w}, b={int(orig_carry_b)}")
-    print(f"              Match: {'YES' if carry_match else 'NO'}")
-    print()
-
-    # Functional test
-    all_correct = True
-    print("  Functional verification:")
-    print("    a b | sum carry | Expected")
-    print("    " + "-" * 30)
-
-    for (a, b), (exp_sum, exp_carry) in spec['truth_table'].items():
-        # We know sum = XOR, carry = AND
-        got_carry = 1 if (a + b - 2) >= 0 else 0  # AND
-        got_sum = 1 if ((a ^ b) == 1) else 0  # XOR (using Python for now)
-
-        match = (got_sum == exp_sum and got_carry == exp_carry)
-        if not match:
-            all_correct = False
-
-        print(f"    {a} {b} |  {got_sum}    {got_carry}    |  {exp_sum}    {exp_carry}     {'OK' if match else 'FAIL'}")
-
-    print()
-    if all_correct:
-        print("  PASSED: Half adder independently derived")
-    else:
-        print("  FAILED: Half adder derivation incorrect")
-
-    return all_correct
-
-def test_full_adder_derivation():
-    """Derive and verify full adder."""
-    print("\n[TEST 4] Full Adder Derivation")
-    print("-" * 60)
-
-    spec = ADDER_SPECS['full_adder']
-
-    print("  Specification:")
-    print("    Structure: HA1(a,b) -> (s1,c1), HA2(s1,cin) -> (sum,c2)")
-    print("    cout = c1 OR c2")
-    print()
-
-    # Verify carry_or is OR
-    orig_carry_or_w = original_model['arithmetic.fulladder.carry_or.weight'].tolist()
-    orig_carry_or_b = original_model['arithmetic.fulladder.carry_or.bias'].item()
-
-    derived_or_w, derived_or_b = [1, 1], -1  # OR
-
-    or_match = (derived_or_w == orig_carry_or_w and derived_or_b == orig_carry_or_b)
-
-    print(f"  carry_or (OR): derived w={derived_or_w}, b={derived_or_b}")
-    print(f"                original w={orig_carry_or_w}, b={int(orig_carry_or_b)}")
-    print(f"                Match: {'YES' if or_match else 'NO'}")
-    print()
-
-    # Functional test
-    all_correct = True
-    print("  Functional verification:")
-    print("    a b cin | sum cout | Expected")
-    print("    " + "-" * 35)
-
-    for (a, b, cin), (exp_sum, exp_cout) in spec['truth_table'].items():
-        # Compute using derived formula
-        total = a + b + cin
-        got_sum = total % 2
-        got_cout = total // 2
-
-        match = (got_sum == exp_sum and got_cout == exp_cout)
-        if not match:
-            all_correct = False
-
-        print(f"    {a} {b}  {cin}  |  {got_sum}    {got_cout}    |  {exp_sum}    {exp_cout}      {'OK' if match else 'FAIL'}")
-
-    print()
-    if all_correct:
-        print("  PASSED: Full adder independently derived")
-    else:
-        print("  FAILED: Full adder derivation incorrect")
-
-    return all_correct
-
-def test_ripple_carry_derivation():
-    """Verify ripple carry structure is derivable."""
-    print("\n[TEST 5] Ripple Carry Adder Derivation")
-    print("-" * 60)
-
-    print("  Specification: Chain of 8 full adders")
-    print("    FA_i inputs: a[i], b[i], carry_in from FA_{i-1}")
-    print("    FA_i outputs: sum[i], carry_out to FA_{i+1}")
-    print()
-
-    # Verify each FA in the ripple carry has the same structure
-    all_match = True
-
-    for i in range(8):
-        prefix = f'arithmetic.ripplecarry8bit.fa{i}'
-
-        # Check carry_or is OR
-        carry_or_w = original_model[f'{prefix}.carry_or.weight'].tolist()
-        carry_or_b = original_model[f'{prefix}.carry_or.bias'].item()
-
-        is_or = (carry_or_w == [1.0, 1.0] and carry_or_b == -1.0)
-
-        if not is_or:
-            all_match = False
-            print(f"    FA{i} carry_or: NOT OR! w={carry_or_w}, b={carry_or_b}")
-
-    if all_match:
-        print("  All 8 full adders have correct OR gates for carry")
-
-    # Verify functional correctness
-    print()
-    print("  Functional verification (exhaustive would be 65536 cases):")
-    print("  Testing critical cases:")
-
-    test_cases = [
-        (0, 0, 0),
-        (1, 1, 2),
-        (127, 1, 128),
-        (255, 1, 0),
-        (127, 128, 255),
-        (255, 255, 254),
-    ]
-
-    for a, b, expected in test_cases:
-        # We already verified the adder works in other tests
-        result = (a + b) % 256
-        match = result == expected
-        print(f"    {a:3d} + {b:3d} = {result:3d} (expected {expected:3d}) {'OK' if match else 'FAIL'}")
-        if not match:
-            all_match = False
-
-    print()
-    if all_match:
-        print("  PASSED: Ripple carry adder structure independently derivable")
-    else:
-        print("  FAILED: Ripple carry derivation issues")
-
-    return all_match
-
-def test_comparator_derivation():
-    """Derive comparator weights from first principles."""
-    print("\n[TEST 6] Comparator Derivation")
-    print("-" * 60)
-
-    print("  Specification:")
-    print("    GT(a,b) = 1 if a > b (unsigned 8-bit)")
-    print("    Approach: Weighted positional comparison")
-    print("    Weight bit i by 2^(7-i) so MSB dominates")
-    print()
-
-    # Derive: for GT, we want sum((a_i - b_i) * 2^(7-i)) > 0
-    # This is a single threshold neuron!
-    derived_weights = [2**(7-i) for i in range(8)]  # [128, 64, 32, 16, 8, 4, 2, 1]
-
-    print(f"  Derived weights: {derived_weights}")
-    print("  (These are applied to a - b for each bit position)")
-    print()
-
-    # Check original
-    orig_gt_w = original_model['arithmetic.greaterthan8bit.comparator'].tolist()
-    print(f"  Original weights: {[int(w) for w in orig_gt_w]}")
-
-    weights_match = (derived_weights == [int(w) for w in orig_gt_w])
-    print(f"  Exact match: {'YES' if weights_match else 'NO'}")
-
-    # Functional test
-    print()
-    print("  Functional verification:")
-    test_pairs = [
-        (0, 0, False),
-        (1, 0, True),
-        (0, 1, False),
-        (255, 0, True),
-        (0, 255, False),
-        (128, 127, True),
-        (127, 128, False),
-        (100, 100, False),
-    ]
-
-    all_correct = True
-    for a, b, expected_gt in test_pairs:
-        # Using derived approach
-        diff = a - b
-        result_gt = diff > 0
-
-        match = result_gt == expected_gt
-        if not match:
-            all_correct = False
-
-        print(f"    {a:3d} > {b:3d} : {result_gt} (expected {expected_gt}) {'OK' if match else 'FAIL'}")
-
-    print()
-    if weights_match and all_correct:
-        print("  PASSED: Comparator independently derived with exact weight match")
-        return True
-    elif all_correct:
-        print("  PASSED: Comparator functionally equivalent (weights may differ in representation)")
-        return True
-    else:
-        print("  FAILED: Comparator derivation issues")
-        return False
-
-def test_derivation_determinism():
-    """Verify that weight derivation is deterministic."""
-    print("\n[TEST 7] Derivation Determinism")
-    print("-" * 60)
-
-    print("  Deriving AND gate 10 times...")
-
-    and_spec = GATE_SPECS['AND']
-    derivations = []
-
-    for i in range(10):
-        w, b = derive_single_layer_weights(and_spec['truth_table'], 2)
-        derivations.append((tuple(w), b))
-
-    unique = set(derivations)
-
-    print(f"  Derivations: {derivations[0]}")
-    print(f"  Unique results: {len(unique)}")
-
-    if len(unique) == 1:
-        print("  PASSED: Derivation is deterministic")
-        return True
-    else:
-        print("  FAILED: Non-deterministic derivation")
-        return False
-
-def test_documentation_sufficiency():
-    """Verify the specification is sufficient for reproduction."""
-    print("\n[TEST 8] Specification Sufficiency")
-    print("-" * 60)
-
-    print("  A specification is sufficient if:")
-    print("    1. All truth tables are complete")
-    print("    2. All structural requirements are explicit")
-    print("    3. Weight derivation is mechanical/algorithmic")
-    print()
-
-    # Check all gates have complete truth tables
-    all_complete = True
-
-    for gate_name, spec in GATE_SPECS.items():
-        n_inputs = spec['inputs']
-        expected_entries = 2 ** n_inputs
-        actual_entries = len(spec['truth_table'])
-
-        complete = actual_entries == expected_entries
-        if not complete:
-            all_complete = False
-
-        status = "complete" if complete else f"INCOMPLETE ({actual_entries}/{expected_entries})"
-        print(f"    {gate_name}: {status}")
-
-    print()
-
-    # Check adders
-    for adder_name, spec in ADDER_SPECS.items():
-        n_inputs = len(spec['inputs'])
-        expected_entries = 2 ** n_inputs
-        actual_entries = len(spec['truth_table'])
-
-        complete = actual_entries == expected_entries
-        if not complete:
-            all_complete = False
-
-        status = "complete" if complete else f"INCOMPLETE ({actual_entries}/{expected_entries})"
-        print(f"    {adder_name}: {status}")
-
-    print()
-    if all_complete:
-        print("  PASSED: All specifications are complete and sufficient")
-    else:
-        print("  FAILED: Some specifications incomplete")
-
-    return all_complete
-
-def test_independence_summary():
-    """Summarize the independence reproduction argument."""
-    print("\n[TEST 9] Independence Reproduction Summary")
-    print("-" * 60)
-
-    print("""
-  INDEPENDENCE REPRODUCTION ARGUMENT:
-
-  Given only:
-    1. Boolean function specifications (truth tables)
-    2. Arithmetic specifications (half adder, full adder structure)
-    3. The threshold gate formalism (output = H(w·x + b))
-
-  An independent implementer can derive:
-    - Exact weights for single-layer gates (AND, OR, NOT, NAND, NOR)
-    - Structurally equivalent 2-layer networks (XOR, XNOR)
-    - Complete adder hierarchies (half adder -> full adder -> ripple carry)
-    - Comparators using positional weighting
-
-  The derivation is:
-    - Deterministic (same inputs -> same outputs)
-    - Mechanical (no creativity required, just following the algorithm)
-    - Verifiable (truth tables can be checked exhaustively)
-
-  This proves the weights are NOT:
-    - Arbitrary
-    - Learned through opaque optimization
-    - Dependent on specific training data
-    - Unique to one implementation
-
-  Instead, they are:
-    - Mathematically necessary consequences of the specifications
-    - Independently reproducible by anyone with the spec
-    - Canonical representations of Boolean functions as threshold gates
-""")
-
-    return True
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #9: INDEPENDENCE REPRODUCTION")
-    print(" Deriving weights from specification alone")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Single-layer gates", test_single_layer_gates()))
-    results.append(("XOR derivation", test_xor_derivation()))
-    results.append(("Half adder", test_half_adder_derivation()))
-    results.append(("Full adder", test_full_adder_derivation()))
-    results.append(("Ripple carry", test_ripple_carry_derivation()))
-    results.append(("Comparator", test_comparator_derivation()))
-    results.append(("Determinism", test_derivation_determinism()))
-    results.append(("Spec sufficiency", test_documentation_sufficiency()))
-    results.append(("Summary", test_independence_summary()))
-
-    print("\n" + "=" * 70)
-    print(" 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} tests passed")
-
-    if passed == total:
-        print("\n  STATUS: INDEPENDENCE REPRODUCTION VERIFIED")
-        print("          Weights are derivable from specification alone.")
-    else:
-        print("\n  STATUS: SOME REPRODUCTION TESTS FAILED")
-
-    print("=" * 70)

tests/test_overflow_chains.py

@@ -1,423 +0,0 @@
-"""
-TEST #1: Arithmetic Overflow Chains
-====================================
-Chains 1000+ arithmetic operations, verifying every intermediate state.
-Tests carry/borrow propagation across long sequences, not just single ops.
-
-A skeptic would demand: "Prove your adder doesn't accumulate errors over
-repeated use. Show me every intermediate value matches Python's arithmetic."
-"""
-
-import torch
-from safetensors.torch import load_file
-import random
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-def int_to_bits_lsb(val, width=8):
-    """Convert int to bits, LSB first (for arithmetic)."""
-    return torch.tensor([(val >> i) & 1 for i in range(width)], dtype=torch.float32)
-
-def bits_to_int_lsb(bits):
-    """Convert bits back to int, LSB first."""
-    return sum(int(bits[i].item()) * (2**i) for i in range(len(bits)))
-
-def eval_xor(a, b, prefix='boolean.xor'):
-    """Evaluate XOR gate."""
-    inp = torch.tensor([a, b], dtype=torch.float32)
-    w1_n1 = model[f'{prefix}.layer1.neuron1.weight']
-    b1_n1 = model[f'{prefix}.layer1.neuron1.bias']
-    w1_n2 = model[f'{prefix}.layer1.neuron2.weight']
-    b1_n2 = model[f'{prefix}.layer1.neuron2.bias']
-    w2 = model[f'{prefix}.layer2.weight']
-    b2 = model[f'{prefix}.layer2.bias']
-    h1 = heaviside(inp @ w1_n1 + b1_n1)
-    h2 = heaviside(inp @ w1_n2 + b1_n2)
-    hidden = torch.tensor([h1.item(), h2.item()])
-    return heaviside(hidden @ w2 + b2).item()
-
-def eval_xor_arith(inp, prefix):
-    """Evaluate XOR for arithmetic circuits (different naming)."""
-    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):
-    """Evaluate full adder, return (sum, carry_out)."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-
-    # HA1: a XOR b
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-
-    # HA1 carry: a AND b
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-
-    # HA2: ha1_sum XOR cin
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-
-    # HA2 carry
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-
-    # Carry out = ha1_carry OR ha2_carry
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-
-    return int(ha2_sum), int(cout)
-
-def add_8bit(a, b):
-    """8-bit addition using ripple carry adder. Returns (result, carry)."""
-    carry = 0.0
-    result_bits = []
-
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-
-    result = sum(result_bits[i] * (2**i) for i in range(8))
-    return result, int(carry)
-
-def sub_8bit(a, b):
-    """8-bit subtraction via two's complement: a - b = a + (~b) + 1."""
-    not_b = (~b) & 0xFF
-    temp, c1 = add_8bit(a, not_b)
-    result, c2 = add_8bit(temp, 1)
-    return result, c1 | c2
-
-# =============================================================================
-# TEST CHAINS
-# =============================================================================
-
-def test_chain_add_overflow():
-    """
-    Start at 0, add 1 repeatedly until we wrap around multiple times.
-    Verify every single intermediate value.
-    """
-    print("\n[TEST 1] Add-1 chain: 0 -> 255 -> 0 -> 255 (512 additions)")
-    print("-" * 60)
-
-    value = 0
-    errors = []
-
-    for i in range(512):
-        expected = (value + 1) % 256
-        result, carry = add_8bit(value, 1)
-
-        if result != expected:
-            errors.append((i, value, 1, expected, result))
-
-        # Check carry on overflow
-        if value == 255 and carry != 1:
-            errors.append((i, value, 1, "carry=1", f"carry={carry}"))
-
-        value = result
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    Step {e[0]}: {e[1]} + {e[2]} = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 512 additions, 2 full wraparounds verified")
-
-    return len(errors) == 0
-
-def test_chain_sub_overflow():
-    """
-    Start at 255, subtract 1 repeatedly until we wrap around.
-    """
-    print("\n[TEST 2] Sub-1 chain: 255 -> 0 -> 255 (512 subtractions)")
-    print("-" * 60)
-
-    value = 255
-    errors = []
-
-    for i in range(512):
-        expected = (value - 1) % 256
-        result, _ = sub_8bit(value, 1)
-
-        if result != expected:
-            errors.append((i, value, 1, expected, result))
-
-        value = result
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    Step {e[0]}: {e[1]} - {e[2]} = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 512 subtractions verified")
-
-    return len(errors) == 0
-
-def test_chain_mixed():
-    """
-    Random mix of +1, -1, +k, -k operations. Verify all intermediates.
-    """
-    print("\n[TEST 3] Mixed chain: 1000 random +/- operations")
-    print("-" * 60)
-
-    random.seed(42)  # Reproducible
-
-    value = 128  # Start in middle
-    python_value = 128
-    errors = []
-
-    for i in range(1000):
-        op = random.choice(['+1', '-1', '+k', '-k'])
-
-        if op == '+1':
-            result, _ = add_8bit(value, 1)
-            python_value = (python_value + 1) % 256
-        elif op == '-1':
-            result, _ = sub_8bit(value, 1)
-            python_value = (python_value - 1) % 256
-        elif op == '+k':
-            k = random.randint(1, 50)
-            result, _ = add_8bit(value, k)
-            python_value = (python_value + k) % 256
-        else:  # '-k'
-            k = random.randint(1, 50)
-            result, _ = sub_8bit(value, k)
-            python_value = (python_value - k) % 256
-
-        if result != python_value:
-            errors.append((i, op, value, python_value, result))
-
-        value = result
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    Step {e[0]}: {e[1]} on {e[2]} = {e[4]}, expected {e[3]}")
-    else:
-        print(f"  PASSED: 1000 random ops verified")
-
-    return len(errors) == 0
-
-def test_chain_carry_stress():
-    """
-    Worst-case carry propagation: repeatedly compute 127+128=255, 255+1=0.
-    """
-    print("\n[TEST 4] Carry stress: 127+128 and 255+1 chains (500 each)")
-    print("-" * 60)
-
-    errors = []
-
-    # 127 + 128 = 255 (all bits flip via carry)
-    for i in range(500):
-        result, carry = add_8bit(127, 128)
-        if result != 255:
-            errors.append((i, '127+128', 255, result))
-
-    # 255 + 1 = 0 with carry out (8-bit carry chain)
-    for i in range(500):
-        result, carry = add_8bit(255, 1)
-        if result != 0 or carry != 1:
-            errors.append((i, '255+1', '0,c=1', f'{result},c={carry}'))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    Iteration {e[0]}: {e[1]} = {e[3]}, expected {e[2]}")
-    else:
-        print(f"  PASSED: 1000 worst-case carry operations")
-
-    return len(errors) == 0
-
-def test_chain_accumulator():
-    """
-    Accumulate: start at 0, add 1,2,3,...,100. Verify running sum at each step.
-    """
-    print("\n[TEST 5] Accumulator: sum(1..100) with intermediate verification")
-    print("-" * 60)
-
-    acc = 0
-    errors = []
-
-    for i in range(1, 101):
-        result, _ = add_8bit(acc, i)
-        expected = (acc + i) % 256
-
-        if result != expected:
-            errors.append((i, acc, i, expected, result))
-
-        acc = result
-
-    # Final value: sum(1..100) = 5050, mod 256 = 5050 % 256 = 186
-    final_expected = sum(range(1, 101)) % 256
-
-    if acc != final_expected:
-        errors.append(('final', acc, final_expected))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    {e}")
-    else:
-        print(f"  PASSED: sum(1..100) mod 256 = {acc} verified at every step")
-
-    return len(errors) == 0
-
-def test_chain_fibonacci():
-    """
-    Compute Fibonacci sequence mod 256. Verify against Python.
-    """
-    print("\n[TEST 6] Fibonacci chain: F(0)..F(100) mod 256")
-    print("-" * 60)
-
-    a, b = 0, 1  # Circuit values
-    pa, pb = 0, 1  # Python values
-    errors = []
-
-    for i in range(100):
-        # Verify current values
-        if a != pa:
-            errors.append((i, 'a', pa, a))
-        if b != pb:
-            errors.append((i, 'b', pb, b))
-
-        # Compute next
-        next_val, _ = add_8bit(a, b)
-        next_python = (pa + pb) % 256
-
-        a, b = b, next_val
-        pa, pb = pb, next_python
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    F({e[0]}) {e[1]}: expected {e[2]}, got {e[3]}")
-    else:
-        print(f"  PASSED: 100 Fibonacci terms verified")
-
-    return len(errors) == 0
-
-def test_chain_alternating():
-    """
-    Alternating +127/-127 to stress positive/negative boundaries.
-    """
-    print("\n[TEST 7] Alternating +127/-127 (200 operations)")
-    print("-" * 60)
-
-    value = 0
-    python_value = 0
-    errors = []
-
-    for i in range(200):
-        if i % 2 == 0:
-            result, _ = add_8bit(value, 127)
-            python_value = (python_value + 127) % 256
-        else:
-            result, _ = sub_8bit(value, 127)
-            python_value = (python_value - 127) % 256
-
-        if result != python_value:
-            errors.append((i, value, python_value, result))
-
-        value = result
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    Step {e[0]}: from {e[1]}, expected {e[2]}, got {e[3]}")
-    else:
-        print(f"  PASSED: 200 alternating ops verified")
-
-    return len(errors) == 0
-
-def test_chain_powers_of_two():
-    """
-    Add powers of 2: 1+2+4+8+...+128. Verify intermediate sums.
-    """
-    print("\n[TEST 8] Powers of 2: 1+2+4+8+16+32+64+128")
-    print("-" * 60)
-
-    acc = 0
-    errors = []
-
-    for i in range(8):
-        power = 2 ** i
-        result, _ = add_8bit(acc, power)
-        expected = (acc + power) % 256
-
-        if result != expected:
-            errors.append((i, acc, power, expected, result))
-
-        acc = result
-
-    # Final: 1+2+4+8+16+32+64+128 = 255
-    if acc != 255:
-        errors.append(('final', 255, acc))
-
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        for e in errors[:5]:
-            print(f"    {e}")
-    else:
-        print(f"  PASSED: 2^0 + 2^1 + ... + 2^7 = {acc}")
-
-    return len(errors) == 0
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #1: ARITHMETIC OVERFLOW CHAINS")
-    print(" Verifying every intermediate state across 3000+ chained operations")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Add-1 chain", test_chain_add_overflow()))
-    results.append(("Sub-1 chain", test_chain_sub_overflow()))
-    results.append(("Mixed random", test_chain_mixed()))
-    results.append(("Carry stress", test_chain_carry_stress()))
-    results.append(("Accumulator", test_chain_accumulator()))
-    results.append(("Fibonacci", test_chain_fibonacci()))
-    results.append(("Alternating", test_chain_alternating()))
-    results.append(("Powers of 2", test_chain_powers_of_two()))
-
-    print("\n" + "=" * 70)
-    print(" 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:20s} [{status}]")
-
-    print(f"\n  Total: {passed}/{total} tests passed")
-
-    total_ops = 512 + 512 + 1000 + 1000 + 100 + 100 + 200 + 8  # ~3400
-    print(f"  Operations verified: ~{total_ops}")
-
-    if passed == total:
-        print("\n  STATUS: ALL CHAINS VERIFIED - NO ACCUMULATED ERRORS")
-    else:
-        print("\n  STATUS: FAILURES DETECTED")
-
-    print("=" * 70)

tests/test_perturbation.py

@@ -1,480 +0,0 @@
-"""
-TEST #4: Adversarial Weight Perturbation
-=========================================
-Flip one weight in one gate. Prove exactly which tests fail and why.
-Show failure is localized and predictable, not catastrophic.
-
-A skeptic would demand: "Prove your system fails gracefully. Show me that
-perturbing one weight breaks only what it should break."
-"""
-
-import torch
-from safetensors.torch import load_file
-import copy
-
-# Load circuits
-original_model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-def eval_gate(model, prefix, a, b):
-    """Evaluate a 2-input single-layer gate."""
-    inp = torch.tensor([float(a), float(b)])
-    w = model[f'{prefix}.weight']
-    bias = model[f'{prefix}.bias']
-    return int(heaviside(inp @ w + bias).item())
-
-def eval_xor(model, a, b):
-    """Evaluate XOR gate (2-layer)."""
-    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_full_adder(model, a, b, cin, prefix):
-    """Evaluate full adder."""
-    def eval_xor_arith(inp, xor_prefix):
-        w1_or = model[f'{xor_prefix}.layer1.or.weight']
-        b1_or = model[f'{xor_prefix}.layer1.or.bias']
-        w1_nand = model[f'{xor_prefix}.layer1.nand.weight']
-        b1_nand = model[f'{xor_prefix}.layer1.nand.bias']
-        w2 = model[f'{xor_prefix}.layer2.weight']
-        b2 = model[f'{xor_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()
-
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def add_8bit(model, a, b):
-    """8-bit addition."""
-    carry = 0.0
-    result_bits = []
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(model, float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-    result = sum(result_bits[i] * (2**i) for i in range(8))
-    return result, int(carry)
-
-def test_boolean_gates(model):
-    """Test all basic Boolean gates, return (passed, failed, details)."""
-    failures = []
-
-    # AND
-    expected_and = {(0,0):0, (0,1):0, (1,0):0, (1,1):1}
-    for (a,b), exp in expected_and.items():
-        got = eval_gate(model, 'boolean.and', a, b)
-        if got != exp:
-            failures.append(('AND', a, b, exp, got))
-
-    # OR
-    expected_or = {(0,0):0, (0,1):1, (1,0):1, (1,1):1}
-    for (a,b), exp in expected_or.items():
-        got = eval_gate(model, 'boolean.or', a, b)
-        if got != exp:
-            failures.append(('OR', a, b, exp, got))
-
-    # NAND
-    expected_nand = {(0,0):1, (0,1):1, (1,0):1, (1,1):0}
-    for (a,b), exp in expected_nand.items():
-        got = eval_gate(model, 'boolean.nand', a, b)
-        if got != exp:
-            failures.append(('NAND', a, b, exp, got))
-
-    # NOR
-    expected_nor = {(0,0):1, (0,1):0, (1,0):0, (1,1):0}
-    for (a,b), exp in expected_nor.items():
-        got = eval_gate(model, 'boolean.nor', a, b)
-        if got != exp:
-            failures.append(('NOR', a, b, exp, got))
-
-    # XOR
-    expected_xor = {(0,0):0, (0,1):1, (1,0):1, (1,1):0}
-    for (a,b), exp in expected_xor.items():
-        got = eval_xor(model, a, b)
-        if got != exp:
-            failures.append(('XOR', a, b, exp, got))
-
-    total = 20  # 4 gates * 4 cases + XOR 4 cases
-    passed = total - len(failures)
-    return passed, len(failures), failures
-
-def test_addition_sample(model, n=100):
-    """Test a sample of additions."""
-    failures = []
-    for a in range(0, 256, 256//10):
-        for b in range(0, 256, 256//10):
-            result, _ = add_8bit(model, a, b)
-            expected = (a + b) % 256
-            if result != expected:
-                failures.append((a, b, expected, result))
-
-    return 100 - len(failures), len(failures), failures
-
-def perturb_weight(model, tensor_name, index, delta):
-    """Create a perturbed copy of the model."""
-    perturbed = {k: v.clone() for k, v in model.items()}
-
-    flat = perturbed[tensor_name].flatten()
-    old_val = flat[index].item()
-    flat[index] = old_val + delta
-    perturbed[tensor_name] = flat.view(model[tensor_name].shape)
-
-    return perturbed, old_val, old_val + delta
-
-# =============================================================================
-# PERTURBATION EXPERIMENTS
-# =============================================================================
-
-def experiment_perturb_and_gate():
-    """
-    Perturb the AND gate's first weight from 1 to 0.
-    Expected: AND becomes a threshold-1 gate (fires if b=1).
-    """
-    print("\n[EXPERIMENT 1] Perturb AND gate: w[0] = 1 -> 0")
-    print("-" * 60)
-
-    perturbed, old, new = perturb_weight(original_model, 'boolean.and.weight', 0, -1)
-
-    print(f"  Original: w={original_model['boolean.and.weight'].tolist()}, b={original_model['boolean.and.bias'].item()}")
-    print(f"  Perturbed: w={perturbed['boolean.and.weight'].tolist()}, b={perturbed['boolean.and.bias'].item()}")
-    print()
-
-    # Test AND gate directly
-    print("  AND gate truth table after perturbation:")
-    print("    Input    Expected  Got")
-    failures = []
-    expected_and = {(0,0):0, (0,1):0, (1,0):0, (1,1):1}
-    for (a,b), exp in expected_and.items():
-        got = eval_gate(perturbed, 'boolean.and', a, b)
-        status = "OK" if got == exp else "FAIL"
-        print(f"    ({a},{b})      {exp}        {got}    [{status}]")
-        if got != exp:
-            failures.append((a, b, exp, got))
-
-    print()
-    print(f"  Analysis: With w=[0,1], b=-2, gate fires when 0*a + 1*b >= 2")
-    print(f"            This is NEVER true (max sum = 1), so output is always 0")
-    print(f"            AND(1,1) now incorrectly returns 0")
-    print()
-
-    # Check cascade effect on adders
-    print("  Cascade effect on arithmetic (AND is used in carry logic):")
-    _, add_fails, add_details = test_addition_sample(perturbed)
-    print(f"    Addition failures: {add_fails}/100 sampled")
-
-    if add_fails > 0:
-        print(f"    Sample failures: {add_details[:3]}")
-
-    return len(failures), failures
-
-def experiment_perturb_or_gate():
-    """
-    Perturb the OR gate's bias from -1 to -2.
-    Expected: OR becomes AND (needs both inputs).
-    """
-    print("\n[EXPERIMENT 2] Perturb OR gate: bias = -1 -> -2")
-    print("-" * 60)
-
-    perturbed = {k: v.clone() for k, v in original_model.items()}
-    perturbed['boolean.or.bias'] = torch.tensor([-2.0])
-
-    print(f"  Original: w={original_model['boolean.or.weight'].tolist()}, b={original_model['boolean.or.bias'].item()}")
-    print(f"  Perturbed: w={perturbed['boolean.or.weight'].tolist()}, b={perturbed['boolean.or.bias'].item()}")
-    print()
-
-    print("  OR gate truth table after perturbation:")
-    print("    Input    Expected  Got")
-    failures = []
-    expected_or = {(0,0):0, (0,1):1, (1,0):1, (1,1):1}
-    for (a,b), exp in expected_or.items():
-        got = eval_gate(perturbed, 'boolean.or', a, b)
-        status = "OK" if got == exp else "FAIL"
-        print(f"    ({a},{b})      {exp}        {got}    [{status}]")
-        if got != exp:
-            failures.append((a, b, exp, got))
-
-    print()
-    print(f"  Analysis: With w=[1,1], b=-2, gate fires when a + b >= 2")
-    print(f"            This is AND, not OR. OR(0,1) and OR(1,0) now return 0")
-    print()
-
-    return len(failures), failures
-
-def experiment_perturb_xor_hidden():
-    """
-    Perturb XOR's first hidden neuron (OR) to become AND.
-    Expected: XOR becomes something else entirely.
-    """
-    print("\n[EXPERIMENT 3] Perturb XOR's hidden OR neuron: bias -1 -> -2")
-    print("-" * 60)
-
-    perturbed = {k: v.clone() for k, v in original_model.items()}
-    perturbed['boolean.xor.layer1.neuron1.bias'] = torch.tensor([-2.0])
-
-    print(f"  Original XOR hidden1 (OR): w={original_model['boolean.xor.layer1.neuron1.weight'].tolist()}, b={original_model['boolean.xor.layer1.neuron1.bias'].item()}")
-    print(f"  Perturbed: bias = -2 (now behaves as AND)")
-    print()
-
-    print("  XOR truth table after perturbation:")
-    print("    Input    Expected  Got")
-    failures = []
-    expected_xor = {(0,0):0, (0,1):1, (1,0):1, (1,1):0}
-    for (a,b), exp in expected_xor.items():
-        got = eval_xor(perturbed, a, b)
-        status = "OK" if got == exp else "FAIL"
-        print(f"    ({a},{b})      {exp}        {got}    [{status}]")
-        if got != exp:
-            failures.append((a, b, exp, got))
-
-    print()
-    print(f"  Analysis: XOR = AND(OR(a,b), NAND(a,b))")
-    print(f"            With OR->AND: XOR = AND(AND(a,b), NAND(a,b))")
-    print(f"            AND(a,b)=1 only when a=b=1, but NAND(1,1)=0")
-    print(f"            So AND(AND, NAND) = 0 for all inputs -> constant 0")
-    print()
-
-    return len(failures), failures
-
-def experiment_perturb_fa0_carry():
-    """
-    Perturb the first full adder's carry_or gate.
-    Expected: Carry propagation breaks at bit 0.
-    """
-    print("\n[EXPERIMENT 4] Perturb FA0 carry_or: bias 0 -> -2 (OR -> AND)")
-    print("-" * 60)
-
-    perturbed = {k: v.clone() for k, v in original_model.items()}
-    # Change carry_or from OR (b=-1) to AND (b=-2)
-    perturbed['arithmetic.ripplecarry8bit.fa0.carry_or.bias'] = torch.tensor([-2.0])
-
-    print(f"  Perturbation: FA0.carry_or bias changed from -1 to -2")
-    print(f"  Effect: OR gate becomes AND gate in carry chain")
-    print()
-
-    # Test specific carry-critical cases
-    test_cases = [
-        (1, 1, 2),      # 1+1=2, needs carry from bit 0
-        (3, 1, 4),      # 11+01=100, needs carry
-        (127, 1, 128),  # Carry through multiple bits
-        (255, 1, 0),    # Full carry chain
-        (128, 128, 0),  # High bit carry
-    ]
-
-    print("  Critical carry test cases:")
-    failures = []
-    for a, b, expected in test_cases:
-        result, _ = add_8bit(perturbed, a, b)
-        status = "OK" if result == expected else "FAIL"
-        print(f"    {a:3d} + {b:3d} = {result:3d} (expected {expected:3d}) [{status}]")
-        if result != expected:
-            failures.append((a, b, expected, result))
-
-    print()
-    print(f"  Analysis: FA0.carry_or computes c_out = ha1_carry OR ha2_carry")
-    print(f"            With OR->AND, carry only propagates when BOTH internal carries fire")
-    print(f"            This breaks 1+1 (ha1_carry=1, ha2_carry=0 -> AND gives 0)")
-    print()
-
-    return len(failures), failures
-
-def experiment_sign_flip():
-    """
-    Flip the sign of a weight.
-    Expected: Gate inverts its response to that input.
-    """
-    print("\n[EXPERIMENT 5] Sign flip: AND w[0] = 1 -> -1")
-    print("-" * 60)
-
-    perturbed, old, new = perturb_weight(original_model, 'boolean.and.weight', 0, -2)
-
-    print(f"  Original: w={original_model['boolean.and.weight'].tolist()}, b={original_model['boolean.and.bias'].item()}")
-    print(f"  Perturbed: w={perturbed['boolean.and.weight'].tolist()}, b={perturbed['boolean.and.bias'].item()}")
-    print()
-
-    print("  AND gate truth table after sign flip:")
-    print("    Input    Expected  Got       Analysis")
-    failures = []
-    expected_and = {(0,0):0, (0,1):0, (1,0):0, (1,1):1}
-    for (a,b), exp in expected_and.items():
-        got = eval_gate(perturbed, 'boolean.and', a, b)
-        weighted_sum = -1*a + 1*b - 2
-        status = "OK" if got == exp else "FAIL"
-        print(f"    ({a},{b})      {exp}        {got}        sum = -1*{a} + 1*{b} - 2 = {weighted_sum} [{status}]")
-        if got != exp:
-            failures.append((a, b, exp, got))
-
-    print()
-    print(f"  Analysis: With w=[-1,1], b=-2, fires when -a + b >= 2")
-    print(f"            Max value is -0 + 1 - 2 = -1, never >= 0")
-    print(f"            Gate becomes constant 0")
-    print()
-
-    return len(failures), failures
-
-def experiment_localization():
-    """
-    Perturb one gate, verify other gates are unaffected.
-    """
-    print("\n[EXPERIMENT 6] Failure Localization Test")
-    print("-" * 60)
-
-    # Perturb AND gate
-    perturbed = {k: v.clone() for k, v in original_model.items()}
-    perturbed['boolean.and.weight'] = torch.tensor([0.0, 1.0])
-
-    print("  Perturbation: AND gate w=[1,1] -> [0,1]")
-    print()
-
-    # Test each gate type
-    gates_status = {}
-
-    # AND (perturbed)
-    failures = []
-    for a in [0,1]:
-        for b in [0,1]:
-            got = eval_gate(perturbed, 'boolean.and', a, b)
-            exp = a & b
-            if got != exp:
-                failures.append((a,b))
-    gates_status['AND'] = 'BROKEN' if failures else 'OK'
-
-    # OR (should be unaffected)
-    failures = []
-    for a in [0,1]:
-        for b in [0,1]:
-            got = eval_gate(perturbed, 'boolean.or', a, b)
-            exp = a | b
-            if got != exp:
-                failures.append((a,b))
-    gates_status['OR'] = 'BROKEN' if failures else 'OK'
-
-    # NAND (should be unaffected)
-    failures = []
-    for a in [0,1]:
-        for b in [0,1]:
-            got = eval_gate(perturbed, 'boolean.nand', a, b)
-            exp = 1 - (a & b)
-            if got != exp:
-                failures.append((a,b))
-    gates_status['NAND'] = 'BROKEN' if failures else 'OK'
-
-    # NOR (should be unaffected)
-    failures = []
-    for a in [0,1]:
-        for b in [0,1]:
-            got = eval_gate(perturbed, 'boolean.nor', a, b)
-            exp = 1 - (a | b)
-            if got != exp:
-                failures.append((a,b))
-    gates_status['NOR'] = 'BROKEN' if failures else 'OK'
-
-    # XOR (should be unaffected - uses its own internal gates)
-    failures = []
-    for a in [0,1]:
-        for b in [0,1]:
-            got = eval_xor(perturbed, a, b)
-            exp = a ^ b
-            if got != exp:
-                failures.append((a,b))
-    gates_status['XOR'] = 'BROKEN' if failures else 'OK'
-
-    print("  Gate status after AND perturbation:")
-    for gate, status in gates_status.items():
-        indicator = "X" if status == 'BROKEN' else " "
-        print(f"    [{indicator}] {gate:6s} {status}")
-
-    print()
-    broken_count = sum(1 for s in gates_status.values() if s == 'BROKEN')
-    print(f"  Result: {broken_count}/5 gates affected")
-    print(f"  Localization: {'PASSED' if broken_count == 1 else 'FAILED'} - only perturbed gate broke")
-
-    return broken_count == 1
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #4: ADVERSARIAL WEIGHT PERTURBATION")
-    print(" Single-weight changes, localized and predictable failures")
-    print("=" * 70)
-
-    # First verify original model works
-    print("\n[BASELINE] Verifying original model...")
-    bool_passed, bool_failed, _ = test_boolean_gates(original_model)
-    add_passed, add_failed, _ = test_addition_sample(original_model)
-    print(f"  Boolean gates: {bool_passed}/{bool_passed + bool_failed} passed")
-    print(f"  Addition sample: {add_passed}/{add_passed + add_failed} passed")
-
-    if bool_failed > 0 or add_failed > 0:
-        print("  ERROR: Original model has failures!")
-        exit(1)
-    print("  Original model verified OK")
-
-    # Run experiments
-    results = []
-
-    n, _ = experiment_perturb_and_gate()
-    results.append(("AND w[0]: 1->0", n > 0, "Breaks AND(1,1)"))
-
-    n, _ = experiment_perturb_or_gate()
-    results.append(("OR bias: -1->-2", n > 0, "OR becomes AND"))
-
-    n, _ = experiment_perturb_xor_hidden()
-    results.append(("XOR hidden OR->AND", n > 0, "XOR becomes const 0"))
-
-    n, _ = experiment_perturb_fa0_carry()
-    results.append(("FA0 carry_or OR->AND", n > 0, "Carry chain breaks"))
-
-    n, _ = experiment_sign_flip()
-    results.append(("AND w[0] sign flip", n > 0, "AND becomes const 0"))
-
-    localized = experiment_localization()
-    results.append(("Failure localization", localized, "Only target gate breaks"))
-
-    print("\n" + "=" * 70)
-    print(" SUMMARY")
-    print("=" * 70)
-
-    all_passed = True
-    for name, passed, desc in results:
-        status = "PASS" if passed else "FAIL"
-        if not passed:
-            all_passed = False
-        print(f"  {name:25s} [{status}] - {desc}")
-
-    print()
-    if all_passed:
-        print("  STATUS: ALL PERTURBATIONS CAUSED PREDICTABLE, LOCALIZED FAILURES")
-    else:
-        print("  STATUS: SOME PERTURBATIONS DID NOT BEHAVE AS EXPECTED")
-
-    print("=" * 70)

tests/test_self_modifying.py

@@ -1,706 +0,0 @@
-"""
-TEST #7: Self-Modifying Code
-=============================
-Write a program that modifies its own instructions in memory,
-then executes the modified code correctly.
-
-A skeptic would demand: "Prove your CPU handles self-modification.
-Show instruction fetch after memory write sees the new value."
-
-This test implements a simple Von Neumann architecture simulation
-using threshold circuits for all operations.
-"""
-
-import torch
-from safetensors.torch import load_file
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-# =============================================================================
-# INSTRUCTION SET DEFINITION
-# =============================================================================
-"""
-Simple 8-bit instruction format:
-  [7:4] = opcode (16 possible operations)
-  [3:0] = operand (immediate value or register select)
-
-Opcodes:
-  0x0 = NOP          No operation
-  0x1 = LOAD_IMM     R0 = operand (immediate load)
-  0x2 = ADD_IMM      R0 = R0 + operand
-  0x3 = SUB_IMM      R0 = R0 - operand
-  0x4 = STORE        MEM[operand] = R0
-  0x5 = LOAD         R0 = MEM[operand]
-  0x6 = JMP          PC = operand
-  0x7 = JZ           if R0 == 0: PC = operand
-  0x8 = HALT         Stop execution
-  0x9 = XOR_IMM      R0 = R0 XOR operand
-  0xA = AND_IMM      R0 = R0 AND operand
-  0xB = INC          R0 = R0 + 1
-  0xC = DEC          R0 = R0 - 1
-  0xD = MOV_TO_R1    R1 = R0
-  0xE = ADD_R1       R0 = R0 + R1
-  0xF = STORE_CODE   CODE[operand] = R0 (self-modify!)
-"""
-
-OPCODES = {
-    0x0: 'NOP',
-    0x1: 'LOAD_IMM',
-    0x2: 'ADD_IMM',
-    0x3: 'SUB_IMM',
-    0x4: 'STORE',
-    0x5: 'LOAD',
-    0x6: 'JMP',
-    0x7: 'JZ',
-    0x8: 'HALT',
-    0x9: 'XOR_IMM',
-    0xA: 'AND_IMM',
-    0xB: 'INC',
-    0xC: 'DEC',
-    0xD: 'MOV_TO_R1',
-    0xE: 'ADD_R1',
-    0xF: 'STORE_CODE',
-}
-
-def make_instr(opcode, operand):
-    """Create instruction byte from opcode and operand."""
-    return ((opcode & 0xF) << 4) | (operand & 0xF)
-
-# =============================================================================
-# CIRCUIT PRIMITIVES
-# =============================================================================
-
-def eval_xor_arith(inp, prefix):
-    """Evaluate XOR for arithmetic circuits."""
-    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):
-    """Evaluate full adder."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def circuit_add(a, b):
-    """8-bit addition using threshold circuits."""
-    carry = 0.0
-    result_bits = []
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-    return sum(result_bits[i] * (2**i) for i in range(8))
-
-def circuit_sub(a, b):
-    """8-bit subtraction using threshold circuits (a - b)."""
-    not_b = (~b) & 0xFF
-    temp = circuit_add(a, not_b)
-    return circuit_add(temp, 1)
-
-def circuit_xor_byte(a, b):
-    """XOR two bytes using threshold circuits."""
-    result = 0
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        inp = torch.tensor([float(a_bit), float(b_bit)])
-        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()])
-        out = int(heaviside(hidden @ w2 + b2).item())
-        result |= (out << i)
-    return result
-
-def circuit_and_byte(a, b):
-    """AND two bytes using threshold circuits."""
-    result = 0
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        inp = torch.tensor([float(a_bit), float(b_bit)])
-        w = model['boolean.and.weight']
-        bias = model['boolean.and.bias']
-        out = int(heaviside(inp @ w + bias).item())
-        result |= (out << i)
-    return result
-
-def circuit_eq_zero(val):
-    """Check if byte equals zero using threshold circuits."""
-    # Zero when no bits are set
-    # Use NOR-like logic: output 1 only if all inputs are 0
-    for i in range(8):
-        if (val >> i) & 1:
-            return 0
-    return 1
-
-# =============================================================================
-# CPU SIMULATOR
-# =============================================================================
-
-class ThresholdCPU:
-    """
-    Simple CPU that uses threshold circuits for all operations.
-    Features Von Neumann architecture with self-modifying code support.
-    """
-
-    def __init__(self, code, trace=False):
-        """
-        Initialize CPU with code.
-        code: list of instruction bytes (max 16 bytes, addresses 0-15)
-        """
-        self.code = list(code) + [0] * (16 - len(code))  # Pad to 16
-        self.memory = [0] * 16  # 16 bytes of data memory
-        self.r0 = 0  # Accumulator
-        self.r1 = 0  # Secondary register
-        self.pc = 0  # Program counter
-        self.halted = False
-        self.trace = trace
-        self.cycle_count = 0
-        self.max_cycles = 1000  # Prevent infinite loops
-
-        # Execution trace for verification
-        self.execution_log = []
-
-    def fetch(self):
-        """Fetch instruction at PC."""
-        if self.pc < 0 or self.pc >= 16:
-            self.halted = True
-            return 0
-        return self.code[self.pc]
-
-    def decode(self, instr):
-        """Decode instruction into opcode and operand."""
-        opcode = (instr >> 4) & 0xF
-        operand = instr & 0xF
-        return opcode, operand
-
-    def execute_one(self):
-        """Execute one instruction cycle."""
-        if self.halted:
-            return False
-
-        if self.cycle_count >= self.max_cycles:
-            if self.trace:
-                print(f"  MAX CYCLES REACHED")
-            self.halted = True
-            return False
-
-        # Fetch
-        instr = self.fetch()
-        opcode, operand = self.decode(instr)
-        op_name = OPCODES.get(opcode, '???')
-
-        old_pc = self.pc
-        old_r0 = self.r0
-
-        # Execute
-        if opcode == 0x0:  # NOP
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x1:  # LOAD_IMM
-            self.r0 = operand
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x2:  # ADD_IMM
-            self.r0 = circuit_add(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x3:  # SUB_IMM
-            self.r0 = circuit_sub(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x4:  # STORE
-            self.memory[operand] = self.r0
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x5:  # LOAD
-            self.r0 = self.memory[operand]
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x6:  # JMP
-            self.pc = operand
-
-        elif opcode == 0x7:  # JZ
-            if circuit_eq_zero(self.r0):
-                self.pc = operand
-            else:
-                self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0x8:  # HALT
-            self.halted = True
-
-        elif opcode == 0x9:  # XOR_IMM
-            self.r0 = circuit_xor_byte(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xA:  # AND_IMM
-            self.r0 = circuit_and_byte(self.r0, operand)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xB:  # INC
-            self.r0 = circuit_add(self.r0, 1)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xC:  # DEC
-            self.r0 = circuit_sub(self.r0, 1)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xD:  # MOV_TO_R1
-            self.r1 = self.r0
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xE:  # ADD_R1
-            self.r0 = circuit_add(self.r0, self.r1)
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        elif opcode == 0xF:  # STORE_CODE (self-modify!)
-            self.code[operand] = self.r0
-            self.pc = circuit_add(self.pc, 1) & 0xF
-
-        # Log execution
-        log_entry = {
-            'cycle': self.cycle_count,
-            'pc': old_pc,
-            'instr': instr,
-            'op': op_name,
-            'operand': operand,
-            'r0_before': old_r0,
-            'r0_after': self.r0,
-        }
-        self.execution_log.append(log_entry)
-
-        if self.trace:
-            print(f"  [{self.cycle_count:3d}] PC={old_pc:2d} {op_name:12s} {operand:2d}  "
-                  f"R0: {old_r0:3d} -> {self.r0:3d}")
-
-        self.cycle_count += 1
-        return not self.halted
-
-    def run(self):
-        """Run until halted."""
-        while self.execute_one():
-            pass
-        return self.r0
-
-# =============================================================================
-# SELF-MODIFYING CODE TESTS
-# =============================================================================
-
-def test_basic_execution():
-    """Verify basic instruction execution works."""
-    print("\n[TEST 1] Basic Instruction Execution")
-    print("-" * 60)
-
-    # Simple program: LOAD 5, ADD 3, HALT -> R0 = 8
-    code = [
-        make_instr(0x1, 5),   # LOAD_IMM 5
-        make_instr(0x2, 3),   # ADD_IMM 3
-        make_instr(0x8, 0),   # HALT
-    ]
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    expected = 8
-    print(f"\n  Result: R0 = {result}, expected {expected}")
-
-    if result == expected:
-        print("  PASSED: Basic execution works")
-        return True
-    else:
-        print("  FAILED: Incorrect result")
-        return False
-
-def test_self_modify_simple():
-    """
-    Self-modifying code: change an instruction, then execute it.
-    """
-    print("\n[TEST 2] Simple Self-Modification")
-    print("-" * 60)
-
-    # Program:
-    # 0: LOAD_IMM 7       ; R0 = 7
-    # 1: STORE_CODE 3     ; CODE[3] = 7 (was NOP, becomes something)
-    # 2: JMP 3            ; Jump to modified instruction
-    # 3: NOP              ; Will be overwritten to 0x07 = JZ (but R0=7, won't jump)
-    #                     ; Actually 0x07 = JZ 7, which jumps to addr 7 if R0==0
-    #                     ; But R0=7, so no jump, falls through to...
-    # 4: HALT
-
-    # Actually, let's make it simpler and more verifiable:
-    # We'll write an ADD_IMM instruction
-
-    # 0: LOAD_IMM 5       ; R0 = 5
-    # 1: MOV_TO_R1        ; R1 = 5
-    # 2: LOAD_IMM 0x23    ; R0 = 0x23 = ADD_IMM 3 instruction
-    # 3: STORE_CODE 6     ; CODE[6] = 0x23 (ADD_IMM 3)
-    # 4: LOAD_IMM 10      ; R0 = 10
-    # 5: JMP 6            ; Jump to modified instruction
-    # 6: NOP              ; Will become ADD_IMM 3
-    # 7: HALT
-
-    code = [
-        make_instr(0x1, 5),    # 0: LOAD_IMM 5
-        make_instr(0xD, 0),    # 1: MOV_TO_R1 (R1 = 5)
-        make_instr(0x1, 0x2),  # 2: LOAD_IMM 2 (partial - need two steps)
-        make_instr(0x2, 1),    # 3: ADD_IMM 1 -> R0 = 3
-        # Now R0 = 3, we want instruction 0x23 = ADD_IMM 3
-        # 0x23 = 0010 0011 = opcode 2, operand 3
-        # Let's construct it: LOAD_IMM can only do 0-15
-        # We need R0 = 0x23 = 35
-    ]
-
-    # Simpler approach: just modify NOP to become INC
-    # INC = 0xB0 = 176, too big for immediate
-    # Let's use: modify to LOAD_IMM 9
-
-    # Simplest: patch an instruction at runtime
-    # Program that patches itself to add more:
-
-    # 0: LOAD_IMM 10      ; R0 = 10
-    # 1: STORE_CODE 4     ; CODE[4] = 10 (interpret as instruction 0x0A = AND_IMM 0)
-    # 2: LOAD_IMM 15      ; R0 = 15
-    # 3: JMP 4            ; Jump to patched location
-    # 4: NOP              ; Will become AND_IMM 0 (R0 = R0 AND 0 = 0)
-    # 5: HALT             ; But we're jumping to 4, then 5
-
-    # Wait, 10 = 0x0A = AND_IMM 10? Let me recheck
-    # 10 = 0b00001010 = opcode 0, operand 10 = NOP with weird operand = still NOP
-
-    # Let's use 0x1F = 31 = LOAD_IMM 15
-    # 31 = 0b00011111 = opcode 1, operand 15 = LOAD_IMM 15
-
-    code = [
-        make_instr(0x1, 0xF),  # 0: LOAD_IMM 15 -> R0 = 15
-        make_instr(0x2, 0xF),  # 1: ADD_IMM 15 -> R0 = 30
-        make_instr(0x2, 0x1),  # 2: ADD_IMM 1 -> R0 = 31 = 0x1F = LOAD_IMM 15
-        make_instr(0xF, 0x6),  # 3: STORE_CODE 6 -> CODE[6] = 31
-        make_instr(0x1, 0x0),  # 4: LOAD_IMM 0 -> R0 = 0
-        make_instr(0x6, 0x6),  # 5: JMP 6
-        make_instr(0x0, 0x0),  # 6: NOP (will become LOAD_IMM 15)
-        make_instr(0x8, 0x0),  # 7: HALT
-    ]
-
-    print("  Program:")
-    print("    0: LOAD_IMM 15      ; R0 = 15")
-    print("    1: ADD_IMM 15       ; R0 = 30")
-    print("    2: ADD_IMM 1        ; R0 = 31 (= LOAD_IMM 15 instruction)")
-    print("    3: STORE_CODE 6     ; Patch CODE[6] = 31")
-    print("    4: LOAD_IMM 0       ; R0 = 0")
-    print("    5: JMP 6            ; Execute patched instruction")
-    print("    6: NOP              ; (becomes LOAD_IMM 15)")
-    print("    7: HALT")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-
-    # Record code before
-    code_before = cpu.code[6]
-    print(f"\n  CODE[6] before: {code_before} (0x{code_before:02x}) = {OPCODES.get(code_before >> 4, '?')}")
-
-    result = cpu.run()
-
-    code_after = cpu.code[6]
-    print(f"  CODE[6] after:  {code_after} (0x{code_after:02x}) = {OPCODES.get(code_after >> 4, '?')}")
-    print(f"\n  Final R0 = {result}")
-
-    # If self-modification worked:
-    # - CODE[6] should have been patched from 0 to 31
-    # - After JMP 6, LOAD_IMM 15 executes, setting R0 = 15
-    # - Then HALT at address 7
-
-    expected = 15
-    code_modified = (code_after == 31)
-    result_correct = (result == expected)
-
-    if code_modified and result_correct:
-        print("  PASSED: Self-modification executed correctly")
-        return True
-    else:
-        if not code_modified:
-            print(f"  FAILED: CODE[6] not modified (expected 31, got {code_after})")
-        if not result_correct:
-            print(f"  FAILED: Wrong result (expected {expected}, got {result})")
-        return False
-
-def test_self_modify_loop():
-    """
-    Self-modifying loop: program modifies its own loop counter.
-    """
-    print("\n[TEST 3] Self-Modifying Loop")
-    print("-" * 60)
-
-    # Program that counts down by modifying its own counter instruction
-    # The "counter" is embedded as the operand of a LOAD_IMM instruction
-
-    # 0: NOP              ; Placeholder (will be LOAD_IMM n)
-    # 1: JZ 5             ; If R0 == 0, exit to HALT
-    # 2: DEC              ; R0 = R0 - 1
-    # 3: STORE_CODE 0     ; CODE[0] = R0 (new LOAD_IMM R0)
-    # 4: JMP 0            ; Loop
-    # 5: HALT
-
-    # Start with LOAD_IMM 3 at address 0
-    code = [
-        make_instr(0x1, 0x3),  # 0: LOAD_IMM 3
-        make_instr(0x7, 0x5),  # 1: JZ 5
-        make_instr(0xC, 0x0),  # 2: DEC
-        make_instr(0xF, 0x0),  # 3: STORE_CODE 0
-        make_instr(0x6, 0x0),  # 4: JMP 0
-        make_instr(0x8, 0x0),  # 5: HALT
-    ]
-
-    print("  Program: Self-modifying countdown")
-    print("    Counter embedded in instruction at address 0")
-    print("    Each iteration: DEC, write back to CODE[0], loop")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    # Should loop: 3 -> 2 -> 1 -> 0 -> exit
-    # Final R0 = 0
-
-    expected = 0
-    expected_cycles = 15  # Approximately
-
-    print(f"\n  Final R0 = {result}")
-    print(f"  Cycles: {cpu.cycle_count}")
-
-    # Verify CODE[0] was modified each iteration
-    final_code_0 = cpu.code[0]
-    print(f"  CODE[0] final: {final_code_0} (0x{final_code_0:02x})")
-
-    if result == expected:
-        print("  PASSED: Self-modifying loop executed correctly")
-        return True
-    else:
-        print(f"  FAILED: Expected R0 = {expected}, got {result}")
-        return False
-
-def test_code_generation():
-    """
-    Program generates new code at runtime and executes it.
-    """
-    print("\n[TEST 4] Runtime Code Generation")
-    print("-" * 60)
-
-    # Program that:
-    # 1. Computes an instruction (LOAD_IMM 7) from parts
-    # 2. Writes it to memory
-    # 3. Jumps to execute it
-
-    # LOAD_IMM 7 = 0x17 = 23
-    # Build 23 from: 15 + 8 = 23
-
-    code = [
-        make_instr(0x1, 0xF),  # 0: LOAD_IMM 15
-        make_instr(0x2, 0x8),  # 1: ADD_IMM 8 -> R0 = 23 = LOAD_IMM 7
-        make_instr(0xF, 0x6),  # 2: STORE_CODE 6
-        make_instr(0x1, 0x0),  # 3: LOAD_IMM 0 (clear R0)
-        make_instr(0x6, 0x6),  # 4: JMP 6
-        make_instr(0x8, 0x0),  # 5: HALT (unreached)
-        make_instr(0x0, 0x0),  # 6: NOP (becomes LOAD_IMM 7)
-        make_instr(0x8, 0x0),  # 7: HALT
-    ]
-
-    print("  Program: Generate LOAD_IMM 7 instruction at runtime")
-    print("    15 + 8 = 23 = 0x17 = LOAD_IMM 7")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    expected = 7
-    print(f"\n  Final R0 = {result}, expected {expected}")
-
-    if result == expected:
-        print("  PASSED: Runtime code generation works")
-        return True
-    else:
-        print("  FAILED: Wrong result")
-        return False
-
-def test_polymorphic_code():
-    """
-    Code that changes its own behavior based on input.
-    """
-    print("\n[TEST 5] Polymorphic Code")
-    print("-" * 60)
-
-    # Program that modifies itself to either ADD or SUB based on a flag
-
-    # Initial: flag in MEM[0], operation at CODE[4]
-    # If MEM[0] == 0: CODE[4] = ADD_IMM 5 (0x25 = 37)
-    # If MEM[0] != 0: CODE[4] = SUB_IMM 5 (0x35 = 53)
-
-    # Simplified: just demonstrate the modification mechanism
-
-    # Store test value in memory first
-    code = [
-        make_instr(0x1, 0x0),  # 0: LOAD_IMM 0 (flag = 0)
-        make_instr(0x4, 0x0),  # 1: STORE 0 (MEM[0] = 0)
-        make_instr(0x1, 0x2),  # 2: LOAD_IMM 2
-        make_instr(0x2, 0x3),  # 3: ADD_IMM 3 -> R0 = 5 = initial value
-        # Now decide: ADD or SUB?
-        # For simplicity, we'll just patch to ADD_IMM 3
-        make_instr(0x1, 0x2),  # 4: LOAD_IMM 2 (opcode for ADD_IMM, will build 0x23)
-        make_instr(0x2, 0x1),  # 5: ADD_IMM 1 -> R0 = 3
-        make_instr(0x2, 0xF),  # 6: ADD_IMM 15 -> R0 = 18
-        make_instr(0x2, 0xF),  # 7: ADD_IMM 15 -> R0 = 33
-        make_instr(0x2, 0x2),  # 8: ADD_IMM 2 -> R0 = 35 = 0x23 = ADD_IMM 3
-        make_instr(0xF, 0xC),  # 9: STORE_CODE 12
-        make_instr(0x1, 0xA),  # 10: LOAD_IMM 10 (base value)
-        make_instr(0x6, 0xC),  # 11: JMP 12
-        make_instr(0x0, 0x0),  # 12: NOP (becomes ADD_IMM 3)
-        make_instr(0x8, 0x0),  # 13: HALT
-    ]
-
-    print("  Program: Build ADD_IMM 3 instruction (0x23 = 35)")
-    print("    Then execute it on base value 10 -> expect 13")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    expected = 13  # 10 + 3
-    print(f"\n  Final R0 = {result}, expected {expected}")
-
-    if result == expected:
-        print("  PASSED: Polymorphic code modification works")
-        return True
-    else:
-        print("  FAILED: Wrong result")
-        return False
-
-def test_quine_like():
-    """
-    Program that reads its own code and verifies it.
-    """
-    print("\n[TEST 6] Code Self-Reading (Quine-like)")
-    print("-" * 60)
-
-    # This test verifies the CPU can read code memory via STORE_CODE/execution
-    # by having a program that modifies itself to effectively "read" code values
-
-    # Simple verification: execute an instruction, modify it to NOP,
-    # verify the modification took effect
-
-    code = [
-        make_instr(0x1, 0x7),  # 0: LOAD_IMM 7
-        make_instr(0x2, 0x3),  # 1: ADD_IMM 3 -> R0 = 10
-        make_instr(0x4, 0x0),  # 2: STORE 0 (MEM[0] = 10, save result)
-        make_instr(0x1, 0x0),  # 3: LOAD_IMM 0 (NOP instruction = 0x00)
-        make_instr(0xF, 0x1),  # 4: STORE_CODE 1 (patch out ADD_IMM 3)
-        make_instr(0x6, 0x0),  # 5: JMP 0 (re-execute from start)
-        # Second pass: ADD_IMM 3 is now NOP, so R0 = 7
-        # But wait, this creates infinite loop...
-    ]
-
-    # Simpler: verify code was modified by checking final state
-
-    code = [
-        make_instr(0x1, 0x5),  # 0: LOAD_IMM 5
-        make_instr(0xD, 0x0),  # 1: MOV_TO_R1 (R1 = 5)
-        make_instr(0x1, 0x0),  # 2: LOAD_IMM 0 (NOP = 0x00)
-        make_instr(0xF, 0x7),  # 3: STORE_CODE 7 (patch instruction at 7)
-        make_instr(0x1, 0x9),  # 4: LOAD_IMM 9
-        make_instr(0x6, 0x7),  # 5: JMP 7
-        make_instr(0x8, 0x0),  # 6: HALT (not reached directly)
-        make_instr(0xB, 0x0),  # 7: INC (will be patched to NOP)
-        make_instr(0x8, 0x0),  # 8: HALT
-    ]
-
-    print("  Program: Patch INC instruction to NOP")
-    print("    Original: LOAD_IMM 9, (INC), HALT -> expect 10")
-    print("    Patched:  LOAD_IMM 9, (NOP), HALT -> expect 9")
-    print()
-
-    cpu = ThresholdCPU(code, trace=True)
-    result = cpu.run()
-
-    # Without patch: 9 + 1 = 10
-    # With patch (INC -> NOP): 9
-    expected = 9
-
-    print(f"\n  Final R0 = {result}, expected {expected}")
-    print(f"  CODE[7] final = {cpu.code[7]} (was INC=0xB0, now NOP=0x00)")
-
-    if result == expected and cpu.code[7] == 0:
-        print("  PASSED: Successfully patched and executed modified code")
-        return True
-    else:
-        print("  FAILED")
-        return False
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #7: SELF-MODIFYING CODE")
-    print(" Programs that modify their own instructions at runtime")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Basic execution", test_basic_execution()))
-    results.append(("Simple self-modify", test_self_modify_simple()))
-    results.append(("Self-modifying loop", test_self_modify_loop()))
-    results.append(("Runtime code gen", test_code_generation()))
-    results.append(("Polymorphic code", test_polymorphic_code()))
-    results.append(("Code self-reading", test_quine_like()))
-
-    print("\n" + "=" * 70)
-    print(" 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} tests passed")
-
-    if passed == total:
-        print("\n  STATUS: SELF-MODIFYING CODE VERIFIED")
-        print("          The CPU correctly handles runtime code modification.")
-    else:
-        print("\n  STATUS: SOME SELF-MODIFICATION TESTS FAILED")
-
-    print("=" * 70)

tests/test_timing.py

@@ -1,510 +0,0 @@
-"""
-TEST #5: Timing Analysis
-=========================
-Build circuit DAG, compute critical path depth.
-Prove worst-case carry propagation takes exactly the expected number of layers.
-
-A skeptic would demand: "Show me the circuit depth. Prove the critical path."
-"""
-
-import torch
-from safetensors.torch import load_file
-from collections import defaultdict
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-# =============================================================================
-# CIRCUIT DEPTH DEFINITIONS
-# =============================================================================
-
-# Depth of primitive gates (in threshold layers)
-GATE_DEPTHS = {
-    'AND': 1,       # Single threshold neuron
-    'OR': 1,        # Single threshold neuron
-    'NOT': 1,       # Single threshold neuron
-    'NAND': 1,      # Single threshold neuron
-    'NOR': 1,       # Single threshold neuron
-    'XOR': 2,       # Two layers: (OR, NAND) -> AND
-    'XNOR': 2,      # Two layers: (NOR, AND) -> OR
-}
-
-def half_adder_depth():
-    """
-    Half adder: sum = XOR(a,b), carry = AND(a,b)
-    Critical path: max(XOR, AND) = max(2, 1) = 2
-    """
-    sum_depth = GATE_DEPTHS['XOR']  # 2
-    carry_depth = GATE_DEPTHS['AND']  # 1
-    return {
-        'sum': sum_depth,
-        'carry': carry_depth,
-        'critical': max(sum_depth, carry_depth)
-    }
-
-def full_adder_depth():
-    """
-    Full adder structure:
-      HA1: (a, b) -> (s1 = XOR, c1 = AND)
-      HA2: (s1, cin) -> (sum = XOR, c2 = AND)  [depends on s1]
-      cout = OR(c1, c2)  [depends on c1 and c2]
-
-    Critical path for sum:
-      XOR(a,b) [2] -> XOR(s1, cin) [2] = 4 layers
-
-    Critical path for carry:
-      Option 1: AND(a,b) [1] -> OR [1] = 2 layers
-      Option 2: XOR(a,b) [2] -> AND(s1,cin) [1] -> OR [1] = 4 layers
-      Critical: max = 4 layers
-    """
-    # Sum path
-    ha1_sum = GATE_DEPTHS['XOR']  # 2
-    ha2_sum = ha1_sum + GATE_DEPTHS['XOR']  # 2 + 2 = 4
-
-    # Carry path 1: through ha1_carry
-    ha1_carry = GATE_DEPTHS['AND']  # 1
-
-    # Carry path 2: through ha2
-    ha2_carry = ha1_sum + GATE_DEPTHS['AND']  # 2 + 1 = 3
-
-    # Final carry: OR of both carries
-    cout = max(ha1_carry, ha2_carry) + GATE_DEPTHS['OR']  # max(1, 3) + 1 = 4
-
-    return {
-        'ha1_sum': ha1_sum,
-        'ha1_carry': ha1_carry,
-        'ha2_sum': ha2_sum,
-        'ha2_carry': ha2_carry,
-        'sum': ha2_sum,
-        'carry': cout,
-        'critical': max(ha2_sum, cout)
-    }
-
-def ripple_carry_depth(n_bits):
-    """
-    Ripple carry adder: chain of n full adders.
-
-    FA0: sum[0], c0 (depth 4 each from inputs)
-    FA1: sum[1], c1 (depends on c0, so +4 for carry path)
-    ...
-    FA(n-1): sum[n-1], c(n-1)
-
-    Critical path is the carry chain:
-      c0 ready at depth 4
-      c1 = FA1.cout, depends on c0, adds 4 more (but only carry path matters)
-
-    Actually, let's trace more carefully:
-      FA_i.sum depends on FA_(i-1).cout
-      FA_i.cout depends on FA_(i-1).cout
-
-    Carry chain per FA after first:
-      - cin arrives
-      - XOR(a_i, b_i) was computed in parallel: 2 layers (can overlap)
-      - HA2: XOR(s1, cin): 2 more layers from cin
-      - OR(c1, c2): 1 more layer
-
-    So from cin to cout of one FA:
-      - If s1 is precomputed: 2 (HA2.XOR) + 1 (HA2.AND parallel) + 1 (OR) = 3?
-
-    Let me be more precise. Within FA_i:
-      - a_i, b_i available at time 0
-      - s1 = XOR(a_i, b_i) ready at time 2
-      - c1 = AND(a_i, b_i) ready at time 1
-      - When cin arrives at time T:
-        - s2 = XOR(s1, cin) ready at T + 2 (but s1 was ready at 2, so if T >= 2, it's T + 2)
-        - c2 = AND(s1, cin) ready at max(2, T) + 1
-        - cout = OR(c1, c2) ready at max(1, max(2,T)+1) + 1
-
-    For FA0, cin = 0 (constant), so effectively T = 0:
-      - sum[0] ready at 4
-      - cout[0] ready at 4
-
-    For FA1, cin = cout[0] arrives at T = 4:
-      - s1 was ready at 2 (precomputed)
-      - s2 = XOR(s1, cin) ready at 4 + 2 = 6
-      - c2 = AND(s1, cin) ready at max(2, 4) + 1 = 5
-      - cout[1] = OR(c1, c2) ready at max(1, 5) + 1 = 6
-
-    Pattern: cout[i] ready at 4 + 2*i for i >= 0
-
-    For 8-bit: cout[7] ready at 4 + 2*7 = 18 layers
-    But sum[7] = 4 + 2*7 = 18 layers too
-
-    Actually wait, let me re-examine. The carry propagation:
-      cout[i] = OR(AND(a_i, b_i), AND(XOR(a_i, b_i), cin[i]))
-
-    If we denote:
-      P_i = XOR(a_i, b_i)  -- propagate (ready at depth 2)
-      G_i = AND(a_i, b_i)  -- generate (ready at depth 1)
-
-    Then:
-      cout[i] = G_i OR (P_i AND cin[i])
-              = G_i OR (P_i AND cout[i-1])
-
-    Timing for cout[i] given cout[i-1] at time T:
-      - G_i ready at 1
-      - P_i ready at 2
-      - P_i AND cout[i-1] ready at max(2, T) + 1
-      - cout[i] ready at max(1, max(2, T) + 1) + 1 = max(2, T) + 2
-
-    For i=0: cout[0] = G_0 OR (P_0 AND 0) = G_0, ready at 1? No wait, cin=0 constant.
-      Actually if cin=0, then P_0 AND 0 = 0, so cout[0] = G_0 = AND(a_0, b_0), ready at depth 1.
-      But we still compute the full FA, so cout[0] ready at depth... let's see:
-        - G_0 ready at 1
-        - P_0 ready at 2
-        - HA2.carry = AND(P_0, 0) = 0, ready at max(2, 0) + 1 = 3 (but it's 0)
-        - cout[0] = OR(G_0, 0) = G_0, ready at max(1, 3) + 1 = 4
-
-    For i=1: cin[1] = cout[0] ready at 4
-      - G_1 ready at 1
-      - P_1 ready at 2
-      - P_1 AND cin[1] ready at max(2, 4) + 1 = 5
-      - cout[1] ready at max(1, 5) + 1 = 6
-
-    For i=2: cin[2] = cout[1] ready at 6
-      - cout[2] ready at max(2, 6) + 2 = 8
-
-    Pattern: cout[i] = 4 + 2*i for i >= 0
-      cout[0] = 4
-      cout[1] = 6
-      cout[7] = 4 + 14 = 18
-
-    And sum[i] = XOR(P_i, cin[i]):
-      sum[0] at max(2, 0) + 2 = 4
-      sum[i] at max(2, cout[i-1]) + 2 = cout[i-1] + 2 = 4 + 2*(i-1) + 2 = 4 + 2*i
-
-    So sum[7] ready at 4 + 14 = 18 layers.
-
-    Critical path for 8-bit ripple carry: 18 threshold layers.
-    """
-    fa_depth = full_adder_depth()
-
-    # First FA: inputs available at t=0, cin=0
-    depths = {
-        'fa0_sum': 4,
-        'fa0_cout': 4,
-    }
-
-    # Subsequent FAs: depend on previous carry
-    for i in range(1, n_bits):
-        cin_ready = depths[f'fa{i-1}_cout']
-        # P_i ready at 2, G_i ready at 1 (precomputed)
-        # sum[i] = XOR(P_i, cin) ready at max(2, cin_ready) + 2
-        # cout[i] ready at max(2, cin_ready) + 2
-        depths[f'fa{i}_sum'] = max(2, cin_ready) + 2
-        depths[f'fa{i}_cout'] = max(2, cin_ready) + 2
-
-    critical_path = max(depths.values())
-
-    return depths, critical_path
-
-def comparator_depth():
-    """
-    8-bit comparator uses weighted sum of bit differences.
-    Single threshold neuron comparing weighted sum to 0.
-    Depth: 1 (just one threshold comparison)
-    """
-    return 1
-
-# =============================================================================
-# TIMING TESTS
-# =============================================================================
-
-def test_primitive_gates():
-    """Verify primitive gate depths."""
-    print("\n[TEST 1] Primitive Gate Depths")
-    print("-" * 60)
-
-    print("  Gate     Layers  Structure")
-    print("  " + "-" * 40)
-
-    primitives = [
-        ('AND',  1, 'w*x + b >= 0'),
-        ('OR',   1, 'w*x + b >= 0'),
-        ('NOT',  1, 'w*x + b >= 0'),
-        ('NAND', 1, 'w*x + b >= 0'),
-        ('NOR',  1, 'w*x + b >= 0'),
-        ('XOR',  2, 'Layer1(OR,NAND) -> Layer2(AND)'),
-        ('XNOR', 2, 'Layer1(NOR,AND) -> Layer2(OR)'),
-    ]
-
-    for name, depth, structure in primitives:
-        print(f"  {name:6s}   {depth}      {structure}")
-
-    print()
-    print("  All single-layer gates: depth 1")
-    print("  XOR/XNOR (non-linearly-separable): depth 2")
-
-    return True
-
-def test_half_adder_depth():
-    """Analyze half adder depth."""
-    print("\n[TEST 2] Half Adder Depth Analysis")
-    print("-" * 60)
-
-    depths = half_adder_depth()
-
-    print("  Component      Depth   Notes")
-    print("  " + "-" * 45)
-    print(f"  sum (XOR)        {depths['sum']}      a XOR b")
-    print(f"  carry (AND)      {depths['carry']}      a AND b")
-    print(f"  Critical path    {depths['critical']}      max(sum, carry)")
-
-    print()
-    print("  Half adder critical path: 2 layers")
-
-    return depths['critical'] == 2
-
-def test_full_adder_depth():
-    """Analyze full adder depth."""
-    print("\n[TEST 3] Full Adder Depth Analysis")
-    print("-" * 60)
-
-    depths = full_adder_depth()
-
-    print("  Component        Depth   Path")
-    print("  " + "-" * 50)
-    print(f"  HA1.sum (XOR)      {depths['ha1_sum']}      XOR(a, b)")
-    print(f"  HA1.carry (AND)    {depths['ha1_carry']}      AND(a, b)")
-    print(f"  HA2.sum (XOR)      {depths['ha2_sum']}      XOR(HA1.sum, cin)")
-    print(f"  HA2.carry (AND)    {depths['ha2_carry']}      AND(HA1.sum, cin)")
-    print(f"  cout (OR)          {depths['carry']}      OR(HA1.carry, HA2.carry)")
-    print(f"  Critical path      {depths['critical']}      max(sum, cout)")
-
-    print()
-    print("  Full adder critical path: 4 layers")
-    print("  (XOR -> XOR for sum, or XOR -> AND -> OR for carry)")
-
-    return depths['critical'] == 4
-
-def test_ripple_carry_depth():
-    """Analyze n-bit ripple carry adder depths."""
-    print("\n[TEST 4] Ripple Carry Adder Depth Analysis")
-    print("-" * 60)
-
-    for n in [2, 4, 8]:
-        depths, critical = ripple_carry_depth(n)
-        print(f"\n  {n}-bit Ripple Carry Adder:")
-        print(f"    Critical path: {critical} layers")
-
-        # Show carry chain timing
-        carry_times = [depths[f'fa{i}_cout'] for i in range(n)]
-        print(f"    Carry chain: {carry_times}")
-
-        # Show sum timing
-        sum_times = [depths[f'fa{i}_sum'] for i in range(n)]
-        print(f"    Sum outputs: {sum_times}")
-
-    print()
-    print("  Pattern: depth = 4 + 2*(n-1) = 2n + 2")
-    print("  2-bit: 6 layers")
-    print("  4-bit: 10 layers")
-    print("  8-bit: 18 layers")
-
-    # Verify formula
-    for n, expected in [(2, 6), (4, 10), (8, 18)]:
-        _, actual = ripple_carry_depth(n)
-        if actual != expected:
-            print(f"  ERROR: {n}-bit expected {expected}, got {actual}")
-            return False
-
-    return True
-
-def test_worst_case_paths():
-    """Identify worst-case input patterns."""
-    print("\n[TEST 5] Worst-Case Carry Propagation Patterns")
-    print("-" * 60)
-
-    # Worst case: carry must propagate through all bits
-    worst_cases = [
-        (0b11111111, 0b00000001, "255 + 1: carry propagates 8 bits"),
-        (0b01111111, 0b00000001, "127 + 1: carry propagates 7 bits"),
-        (0b01111111, 0b10000000, "127 + 128: no carry propagation (bits don't overlap)"),
-        (0b10101010, 0b01010101, "170 + 85: no carry (complementary patterns)"),
-        (0b11111111, 0b11111111, "255 + 255: generate at each bit, propagate from bit 0"),
-    ]
-
-    print("  Input Pattern           Result  Carry Depth  Notes")
-    print("  " + "-" * 65)
-
-    for a, b, desc in worst_cases:
-        result = (a + b) % 256
-        carry_out = (a + b) >> 8
-
-        # Count how many bits need carry propagation
-        # Carry propagates through bit i if P_i = a_i XOR b_i = 1
-        propagate_bits = bin(a ^ b).count('1')
-
-        # Longest carry chain: consecutive propagate bits from LSB
-        chain_length = 0
-        for i in range(8):
-            if (a >> i) & 1 != (b >> i) & 1:  # P_i = 1
-                chain_length += 1
-            elif (a >> i) & 1 == 1 and (b >> i) & 1 == 1:  # G_i = 1
-                chain_length += 1  # Generates carry, continues chain
-                break  # Chain ends (or starts new)
-            else:
-                break  # Chain ends
-
-        print(f"  {a:3d} + {b:3d} = {result:3d}  c={carry_out}    {chain_length} bits         {desc[:40]}")
-
-    print()
-    print("  255 + 1 forces carry through all 8 full adders: worst case")
-    print("  127 + 128 has no overlapping bits: best case (no propagation)")
-
-    return True
-
-def test_comparator_depth():
-    """Analyze comparator depth."""
-    print("\n[TEST 6] Comparator Depth Analysis")
-    print("-" * 60)
-
-    print("  8-bit comparators use weighted positional comparison:")
-    print("    GT: sum((a_i - b_i) * 2^(7-i)) > 0")
-    print("    LT: sum((b_i - a_i) * 2^(7-i)) > 0")
-    print()
-    print("  Structure: Single threshold neuron")
-    print("  Depth: 1 layer (just weighted sum comparison)")
-    print()
-    print("  Note: This is O(1) depth regardless of bit width!")
-    print("  (Compared to ripple-carry which is O(n))")
-
-    return True
-
-def test_circuit_depth_summary():
-    """Summary of all circuit depths."""
-    print("\n[TEST 7] Circuit Depth Summary")
-    print("-" * 60)
-
-    circuits = [
-        ("AND/OR/NOT/NAND/NOR", 1),
-        ("XOR/XNOR", 2),
-        ("Half Adder", 2),
-        ("Full Adder", 4),
-        ("2-bit Ripple Carry", 6),
-        ("4-bit Ripple Carry", 10),
-        ("8-bit Ripple Carry", 18),
-        ("8-bit Comparator", 1),
-    ]
-
-    print("  Circuit                  Depth (layers)")
-    print("  " + "-" * 40)
-    for name, depth in circuits:
-        bar = "#" * depth
-        print(f"  {name:24s} {depth:3d}  {bar}")
-
-    print()
-    print("  Observations:")
-    print("    - Simple gates: O(1)")
-    print("    - Ripple carry: O(n) where n = bit width")
-    print("    - Comparator: O(1) - threshold logic advantage!")
-
-    return True
-
-def test_verify_actual_structure():
-    """Verify the actual tensor structure matches our depth analysis."""
-    print("\n[TEST 8] Verify Tensor Structure Matches Analysis")
-    print("-" * 60)
-
-    errors = []
-
-    # XOR should have layer1 and layer2
-    xor_tensors = [k for k in model.keys() if k.startswith('boolean.xor')]
-    has_layer1 = any('layer1' in k for k in xor_tensors)
-    has_layer2 = any('layer2' in k for k in xor_tensors)
-
-    if has_layer1 and has_layer2:
-        print("  XOR: Has layer1 and layer2 tensors [OK]")
-    else:
-        print("  XOR: Missing layer structure [FAIL]")
-        errors.append("XOR structure")
-
-    # Full adder should have ha1, ha2, carry_or
-    fa_tensors = [k for k in model.keys() if 'fulladder' in k]
-    has_ha1 = any('ha1' in k for k in fa_tensors)
-    has_ha2 = any('ha2' in k for k in fa_tensors)
-    has_carry_or = any('carry_or' in k for k in fa_tensors)
-
-    if has_ha1 and has_ha2 and has_carry_or:
-        print("  Full Adder: Has ha1, ha2, carry_or [OK]")
-    else:
-        print("  Full Adder: Missing components [FAIL]")
-        errors.append("FA structure")
-
-    # Ripple carry should have fa0 through fa7
-    rc8_tensors = [k for k in model.keys() if 'ripplecarry8bit' in k]
-    fa_indices = set()
-    for k in rc8_tensors:
-        for i in range(8):
-            if f'fa{i}' in k:
-                fa_indices.add(i)
-
-    if fa_indices == set(range(8)):
-        print(f"  8-bit Ripple Carry: Has fa0-fa7 [OK]")
-    else:
-        print(f"  8-bit Ripple Carry: Missing FAs, found {fa_indices} [FAIL]")
-        errors.append("RC8 structure")
-
-    # Comparator should be single layer (no layer1/layer2)
-    gt_tensors = [k for k in model.keys() if 'greaterthan8bit' in k]
-    gt_has_layers = any('layer' in k for k in gt_tensors)
-
-    if not gt_has_layers:
-        print("  8-bit Comparator: Single layer (no layer1/layer2) [OK]")
-    else:
-        print("  8-bit Comparator: Has unexpected layer structure [FAIL]")
-        errors.append("Comparator structure")
-
-    print()
-    if errors:
-        print(f"  Structure verification: {len(errors)} issues")
-        return False
-    else:
-        print("  Structure verification: All circuits match expected topology")
-        return True
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #5: TIMING ANALYSIS")
-    print(" Circuit depth and critical path analysis")
-    print("=" * 70)
-
-    results = []
-
-    results.append(("Primitive gates", test_primitive_gates()))
-    results.append(("Half adder depth", test_half_adder_depth()))
-    results.append(("Full adder depth", test_full_adder_depth()))
-    results.append(("Ripple carry depth", test_ripple_carry_depth()))
-    results.append(("Worst-case patterns", test_worst_case_paths()))
-    results.append(("Comparator depth", test_comparator_depth()))
-    results.append(("Depth summary", test_circuit_depth_summary()))
-    results.append(("Structure verification", test_verify_actual_structure()))
-
-    print("\n" + "=" * 70)
-    print(" 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} tests passed")
-
-    print("\n  Key Results:")
-    print("    - 8-bit ripple carry: 18 threshold layers")
-    print("    - 8-bit comparator: 1 threshold layer")
-    print("    - Critical path formula: depth = 2n + 2 for n-bit adder")
-
-    if passed == total:
-        print("\n  STATUS: TIMING ANALYSIS COMPLETE")
-    else:
-        print("\n  STATUS: SOME TIMING TESTS FAILED")
-
-    print("=" * 70)

tests/test_turing_complete.py

@@ -1,693 +0,0 @@
-"""
-TEST #8: Turing Completeness Proof
-===================================
-Demonstrate Turing completeness by implementing:
-1. Rule 110 cellular automaton (proven Turing complete by Matthew Cook, 2004)
-2. A Brainfuck interpreter
-
-If these run correctly on the threshold circuits, the system is Turing complete.
-
-A skeptic would demand: "Prove computational universality. Show me a known
-Turing-complete system running on your circuits."
-"""
-
-import torch
-from safetensors.torch import load_file
-
-# Load circuits
-model = load_file('neural_computer.safetensors')
-
-def heaviside(x):
-    return (x >= 0).float()
-
-# =============================================================================
-# CIRCUIT PRIMITIVES
-# =============================================================================
-
-def eval_and(a, b):
-    """AND gate using threshold circuits."""
-    inp = torch.tensor([float(a), float(b)])
-    w = model['boolean.and.weight']
-    bias = model['boolean.and.bias']
-    return int(heaviside(inp @ w + bias).item())
-
-def eval_or(a, b):
-    """OR gate using threshold circuits."""
-    inp = torch.tensor([float(a), float(b)])
-    w = model['boolean.or.weight']
-    bias = model['boolean.or.bias']
-    return int(heaviside(inp @ w + bias).item())
-
-def eval_not(a):
-    """NOT gate using threshold circuits."""
-    inp = torch.tensor([float(a)])
-    w = model['boolean.not.weight']
-    bias = model['boolean.not.bias']
-    return int(heaviside(inp @ w + bias).item())
-
-def eval_xor(a, b):
-    """XOR gate using threshold circuits."""
-    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_nand(a, b):
-    """NAND gate using threshold circuits."""
-    inp = torch.tensor([float(a), float(b)])
-    w = model['boolean.nand.weight']
-    bias = model['boolean.nand.bias']
-    return int(heaviside(inp @ w + bias).item())
-
-def eval_nor(a, b):
-    """NOR gate using threshold circuits."""
-    inp = torch.tensor([float(a), float(b)])
-    w = model['boolean.nor.weight']
-    bias = model['boolean.nor.bias']
-    return int(heaviside(inp @ w + bias).item())
-
-def eval_xor_arith(inp, prefix):
-    """Evaluate XOR for arithmetic circuits."""
-    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):
-    """Evaluate full adder."""
-    inp_ab = torch.tensor([a, b], dtype=torch.float32)
-    ha1_sum = eval_xor_arith(inp_ab, f'{prefix}.ha1.sum')
-    w_c1 = model[f'{prefix}.ha1.carry.weight']
-    b_c1 = model[f'{prefix}.ha1.carry.bias']
-    ha1_carry = heaviside(inp_ab @ w_c1 + b_c1).item()
-    inp_ha2 = torch.tensor([ha1_sum, cin], dtype=torch.float32)
-    ha2_sum = eval_xor_arith(inp_ha2, f'{prefix}.ha2.sum')
-    w_c2 = model[f'{prefix}.ha2.carry.weight']
-    b_c2 = model[f'{prefix}.ha2.carry.bias']
-    ha2_carry = heaviside(inp_ha2 @ w_c2 + b_c2).item()
-    inp_cout = torch.tensor([ha1_carry, ha2_carry], dtype=torch.float32)
-    w_or = model[f'{prefix}.carry_or.weight']
-    b_or = model[f'{prefix}.carry_or.bias']
-    cout = heaviside(inp_cout @ w_or + b_or).item()
-    return int(ha2_sum), int(cout)
-
-def circuit_add(a, b):
-    """8-bit addition using threshold circuits."""
-    carry = 0.0
-    result_bits = []
-    for i in range(8):
-        a_bit = (a >> i) & 1
-        b_bit = (b >> i) & 1
-        s, carry = eval_full_adder(float(a_bit), float(b_bit), carry,
-                                    f'arithmetic.ripplecarry8bit.fa{i}')
-        result_bits.append(s)
-    return sum(result_bits[i] * (2**i) for i in range(8))
-
-def circuit_sub(a, b):
-    """8-bit subtraction using threshold circuits."""
-    not_b = (~b) & 0xFF
-    temp = circuit_add(a, not_b)
-    return circuit_add(temp, 1)
-
-# =============================================================================
-# RULE 110 CELLULAR AUTOMATON
-# =============================================================================
-"""
-Rule 110 is proven Turing complete (Matthew Cook, 2004).
-
-Rule table (input pattern -> output):
-  111 -> 0
-  110 -> 1
-  101 -> 1
-  100 -> 0
-  011 -> 1
-  010 -> 1
-  001 -> 1
-  000 -> 0
-
-Binary: 01101110 = 110 (hence "Rule 110")
-
-The output can be computed as:
-  out = (center XOR right) OR (center AND (NOT left))
-
-Or equivalently:
-  out = NOT(left AND center AND right) AND (center OR right)
-"""
-
-def rule110_cell(left, center, right):
-    """
-    Compute Rule 110 for one cell using threshold circuits.
-
-    Rule 110: out = (center XOR right) OR (NOT left AND center)
-
-    Truth table verification:
-    L C R | out
-    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
-    """
-    # Compute using threshold gates
-    not_left = eval_not(left)
-    c_xor_r = eval_xor(center, right)
-    not_left_and_c = eval_and(not_left, center)
-    result = eval_or(c_xor_r, not_left_and_c)
-    return result
-
-def rule110_step(tape):
-    """Compute one step of Rule 110 on a tape (list of 0/1)."""
-    n = len(tape)
-    new_tape = []
-    for i in range(n):
-        left = tape[(i - 1) % n]
-        center = tape[i]
-        right = tape[(i + 1) % n]
-        new_tape.append(rule110_cell(left, center, right))
-    return new_tape
-
-def python_rule110_cell(left, center, right):
-    """Python reference implementation of Rule 110."""
-    pattern = (left << 2) | (center << 1) | right
-    # Rule 110 = 01101110 in binary
-    rule = 0b01101110
-    return (rule >> pattern) & 1
-
-def python_rule110_step(tape):
-    """Python reference implementation."""
-    n = len(tape)
-    return [python_rule110_cell(tape[(i-1)%n], tape[i], tape[(i+1)%n])
-            for i in range(n)]
-
-# =============================================================================
-# BRAINFUCK INTERPRETER
-# =============================================================================
-"""
-Brainfuck is a Turing-complete language with 8 commands:
-  >  Increment data pointer
-  <  Decrement data pointer
-  +  Increment byte at data pointer
-  -  Decrement byte at data pointer
-  .  Output byte at data pointer
-  ,  Input byte to data pointer
-  [  Jump forward past matching ] if byte is zero
-  ]  Jump back to matching [ if byte is nonzero
-"""
-
-class BrainfuckVM:
-    """Brainfuck interpreter using threshold circuits for all operations."""
-
-    def __init__(self, code, input_bytes=None, tape_size=256, max_steps=10000):
-        self.code = code
-        self.tape = [0] * tape_size
-        self.tape_size = tape_size
-        self.dp = 0  # Data pointer
-        self.ip = 0  # Instruction pointer
-        self.input_buffer = list(input_bytes) if input_bytes else []
-        self.output_buffer = []
-        self.max_steps = max_steps
-        self.steps = 0
-
-        # Precompute bracket matching
-        self.brackets = self._match_brackets()
-
-    def _match_brackets(self):
-        """Match [ and ] brackets."""
-        stack = []
-        matches = {}
-        for i, c in enumerate(self.code):
-            if c == '[':
-                stack.append(i)
-            elif c == ']':
-                if stack:
-                    j = stack.pop()
-                    matches[j] = i
-                    matches[i] = j
-        return matches
-
-    def step(self):
-        """Execute one instruction using threshold circuits."""
-        if self.ip >= len(self.code) or self.steps >= self.max_steps:
-            return False
-
-        cmd = self.code[self.ip]
-
-        if cmd == '>':
-            # Increment pointer using circuit
-            self.dp = circuit_add(self.dp, 1) % self.tape_size
-            self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == '<':
-            # Decrement pointer using circuit
-            self.dp = circuit_sub(self.dp, 1) % self.tape_size
-            self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == '+':
-            # Increment cell using circuit
-            self.tape[self.dp] = circuit_add(self.tape[self.dp], 1) & 0xFF
-            self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == '-':
-            # Decrement cell using circuit
-            self.tape[self.dp] = circuit_sub(self.tape[self.dp], 1) & 0xFF
-            self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == '.':
-            # Output
-            self.output_buffer.append(self.tape[self.dp])
-            self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == ',':
-            # Input
-            if self.input_buffer:
-                self.tape[self.dp] = self.input_buffer.pop(0)
-            else:
-                self.tape[self.dp] = 0
-            self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == '[':
-            # Jump if zero
-            if self.tape[self.dp] == 0:
-                self.ip = self.brackets.get(self.ip, self.ip) + 1
-            else:
-                self.ip = circuit_add(self.ip, 1)
-
-        elif cmd == ']':
-            # Jump if nonzero
-            if self.tape[self.dp] != 0:
-                self.ip = self.brackets.get(self.ip, self.ip)
-            else:
-                self.ip = circuit_add(self.ip, 1)
-        else:
-            # Skip non-command characters
-            self.ip = circuit_add(self.ip, 1)
-
-        self.steps += 1
-        return True
-
-    def run(self):
-        """Run until halted."""
-        while self.step():
-            pass
-        return self.output_buffer
-
-    def get_output_string(self):
-        """Get output as string."""
-        return ''.join(chr(b) for b in self.output_buffer if 32 <= b < 127)
-
-# =============================================================================
-# TESTS
-# =============================================================================
-
-def test_rule110_single_cell():
-    """Verify Rule 110 single-cell computation."""
-    print("\n[TEST 1] Rule 110 Single Cell Verification")
-    print("-" * 60)
-
-    # Test 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 = []
-    print("  L C R | Circuit | Python | Expected")
-    print("  " + "-" * 40)
-
-    for (l, c, r), exp in expected.items():
-        circuit_out = rule110_cell(l, c, r)
-        python_out = python_rule110_cell(l, c, r)
-
-        match = circuit_out == exp and python_out == exp
-        status = "OK" if match else "FAIL"
-
-        print(f"  {l} {c} {r} |    {circuit_out}    |   {python_out}    |    {exp}     [{status}]")
-
-        if not match:
-            errors.append((l, c, r, exp, circuit_out))
-
-    print()
-    if errors:
-        print(f"  FAILED: {len(errors)} errors")
-        return False
-    else:
-        print("  PASSED: All 8 Rule 110 patterns verified")
-        return True
-
-def test_rule110_evolution():
-    """Test Rule 110 tape evolution."""
-    print("\n[TEST 2] Rule 110 Tape Evolution")
-    print("-" * 60)
-
-    # Initial tape with single 1
-    tape_size = 20
-    tape = [0] * tape_size
-    tape[-2] = 1  # Single 1 near right edge
-
-    steps = 15
-
-    print(f"  Tape size: {tape_size}, Steps: {steps}")
-    print(f"  Initial: {''.join(str(b) for b in tape)}")
-    print()
-
-    circuit_tape = tape.copy()
-    python_tape = tape.copy()
-
-    all_match = True
-
-    for step in range(steps):
-        circuit_tape = rule110_step(circuit_tape)
-        python_tape = python_rule110_step(python_tape)
-
-        match = circuit_tape == python_tape
-        if not match:
-            all_match = False
-
-        # Visual display
-        visual = ''.join('#' if b else '.' for b in circuit_tape)
-        status = "" if match else " <-- MISMATCH"
-        print(f"  Step {step+1:2d}: {visual}{status}")
-
-    print()
-    if all_match:
-        print("  PASSED: Circuit evolution matches Python reference")
-        return True
-    else:
-        print("  FAILED: Evolution mismatch detected")
-        return False
-
-def test_rule110_known_pattern():
-    """Test Rule 110 produces known patterns."""
-    print("\n[TEST 3] Rule 110 Known Pattern Verification")
-    print("-" * 60)
-
-    # Rule 110 from a single cell produces a characteristic pattern
-    # The pattern should show the "triangular" growth typical of Rule 110
-
-    tape = [0] * 40
-    tape[-2] = 1
-
-    # Run for 20 steps
-    for _ in range(20):
-        tape = rule110_step(tape)
-
-    # Count active cells - should be growing in a specific way
-    active_cells = sum(tape)
-
-    print(f"  Final tape: {''.join('#' if b else '.' for b in tape)}")
-    print(f"  Active cells: {active_cells}")
-
-    # Rule 110 from single cell should have 10-15 active cells after 20 steps
-    # (this is approximate - the exact count depends on boundary conditions)
-
-    if 5 <= active_cells <= 25:
-        print("  PASSED: Pattern shows expected Rule 110 behavior")
-        return True
-    else:
-        print("  FAILED: Unexpected cell count")
-        return False
-
-def test_brainfuck_simple():
-    """Test simple Brainfuck program."""
-    print("\n[TEST 4] Brainfuck Simple Addition")
-    print("-" * 60)
-
-    # Program: Add 2 + 3
-    # Cell 0 = 2, Cell 1 = 3
-    # Move cell 1 to cell 0 (result: cell 0 = 5)
-
-    # ++       cell[0] = 2
-    # >+++     cell[1] = 3
-    # [<+>-]   move cell[1] to cell[0]
-    # <.       output cell[0]
-
-    code = "++>+++[<+>-]<."
-
-    print(f"  Code: {code}")
-    print("  Expected: Output byte 5 (2 + 3)")
-    print()
-
-    vm = BrainfuckVM(code)
-    output = vm.run()
-
-    print(f"  Output: {output}")
-    print(f"  Steps: {vm.steps}")
-
-    if output == [5]:
-        print("  PASSED: 2 + 3 = 5")
-        return True
-    else:
-        print(f"  FAILED: Expected [5], got {output}")
-        return False
-
-def test_brainfuck_multiply():
-    """Test Brainfuck multiplication."""
-    print("\n[TEST 5] Brainfuck Multiplication")
-    print("-" * 60)
-
-    # Multiply 3 * 4 = 12
-    # Uses nested loops
-
-    # +++          cell[0] = 3 (multiplicand)
-    # >++++        cell[1] = 4 (multiplier)
-    # [<           for each count in cell[1]:
-    #   [>+>+<<-]    copy cell[0] to cell[2], using cell[3] as temp
-    #   >>[-<<+>>]   move cell[3] back to cell[0]
-    #   <<
-    # >-]          decrement multiplier
-    # >>           move to result (cell[2])
-    # .            output
-
-    # Simpler version: 3 * 4 using basic loop
-    # Cell 0 = 3, Cell 1 = 4
-    # Result in Cell 2
-
-    code = "+++>++++[<[>>+<<-]>[>+<-]>[-<+<+>>]<<<-]>>."
-
-    # Even simpler: just compute 3 * 4 by adding 3 four times
-    # ++++ ++++ ++++  (12 plusses)
-    code_simple = "++++++++++++"  # 12 plusses
-    code_simple += "."
-
-    print(f"  Code: {code_simple}")
-    print("  Expected: Output byte 12")
-    print()
-
-    vm = BrainfuckVM(code_simple)
-    output = vm.run()
-
-    print(f"  Output: {output}")
-
-    if output == [12]:
-        print("  PASSED: Output is 12")
-        return True
-    else:
-        print(f"  FAILED: Expected [12], got {output}")
-        return False
-
-def test_brainfuck_loop():
-    """Test Brainfuck loops work correctly."""
-    print("\n[TEST 6] Brainfuck Loop Verification")
-    print("-" * 60)
-
-    # Count down from 5 to 0, output each value
-    # +++++    cell[0] = 5
-    # [.-]     while cell[0]: output, decrement
-
-    code = "+++++[.-]"
-
-    print(f"  Code: {code}")
-    print("  Expected: Output [5, 4, 3, 2, 1]")
-    print()
-
-    vm = BrainfuckVM(code)
-    output = vm.run()
-
-    print(f"  Output: {output}")
-    print(f"  Steps: {vm.steps}")
-
-    if output == [5, 4, 3, 2, 1]:
-        print("  PASSED: Loop countdown works")
-        return True
-    else:
-        print(f"  FAILED: Expected [5,4,3,2,1], got {output}")
-        return False
-
-def test_brainfuck_hello():
-    """Test Brainfuck Hello World (simplified)."""
-    print("\n[TEST 7] Brainfuck 'Hi' Output")
-    print("-" * 60)
-
-    # Output 'H' (72) and 'i' (105)
-    # Build 72: 8*9 = 72
-    # Build 105: 105 = 10*10 + 5
-
-    # Simpler: just increment to the values
-    # H = 72, i = 105
-
-    # Cell 0 -> 72 (H)
-    code_h = "+" * 72 + "."
-    # Cell 0 -> 105 (i) = 72 + 33
-    code_i = "+" * 33 + "."
-
-    code = code_h + code_i
-
-    print(f"  Code length: {len(code)} characters")
-    print("  Expected: 'Hi' (bytes 72, 105)")
-    print()
-
-    vm = BrainfuckVM(code, max_steps=50000)
-    output = vm.run()
-
-    output_str = ''.join(chr(b) for b in output)
-    print(f"  Output bytes: {output}")
-    print(f"  Output string: '{output_str}'")
-    print(f"  Steps: {vm.steps}")
-
-    if output == [72, 105]:
-        print("  PASSED: Output is 'Hi'")
-        return True
-    else:
-        print(f"  FAILED: Expected [72, 105], got {output}")
-        return False
-
-def test_brainfuck_nested_loops():
-    """Test nested loop handling."""
-    print("\n[TEST 8] Brainfuck Nested Loops")
-    print("-" * 60)
-
-    # Nested loop test:
-    # ++[>++[>++<-]<-]>>.
-    # This should compute 2 * 2 * 2 = 8 in cell 2
-
-    code = "++[>++[>++<-]<-]>>."
-
-    print(f"  Code: {code}")
-    print("  Expected: 2 * 2 * 2 = 8")
-    print()
-
-    vm = BrainfuckVM(code)
-    output = vm.run()
-
-    print(f"  Output: {output}")
-    print(f"  Steps: {vm.steps}")
-    print(f"  Tape[0:5]: {vm.tape[0:5]}")
-
-    if output == [8]:
-        print("  PASSED: Nested loops work correctly")
-        return True
-    else:
-        print(f"  FAILED: Expected [8], got {output}")
-        return False
-
-def test_turing_completeness_argument():
-    """Summarize the Turing completeness argument."""
-    print("\n[TEST 9] Turing Completeness Argument")
-    print("-" * 60)
-
-    print("""
-  CLAIM: The threshold logic computer is Turing complete.
-
-  PROOF:
-
-  1. Rule 110 cellular automaton is proven Turing complete
-     (Matthew Cook, 2004, published in Complex Systems).
-
-  2. We have demonstrated that our threshold circuits correctly
-     implement Rule 110:
-     - All 8 cell transition rules verified
-     - Multi-step evolution matches reference implementation
-     - Characteristic patterns emerge correctly
-
-  3. Brainfuck is a known Turing-complete language.
-
-  4. We have demonstrated a working Brainfuck interpreter
-     running on threshold circuits:
-     - Arithmetic (+/-) using ripple-carry adders
-     - Loops ([/]) with proper bracket matching
-     - Memory operations (>/<) using modular arithmetic
-     - I/O operations
-
-  5. Since our threshold circuits can simulate Turing-complete
-     systems, they are themselves Turing complete.
-
-  QED.
-
-  NOTE: True Turing completeness requires unbounded memory/time.
-  Our implementation is bounded (256-byte tape, max steps),
-  making it technically a Linear Bounded Automaton. However,
-  these limits are implementation choices, not fundamental
-  constraints of the threshold logic architecture.
-""")
-
-    return True
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #8: TURING COMPLETENESS PROOF")
-    print(" Demonstrating computational universality via Rule 110 and Brainfuck")
-    print("=" * 70)
-
-    results = []
-
-    # Rule 110 tests
-    results.append(("Rule 110 single cell", test_rule110_single_cell()))
-    results.append(("Rule 110 evolution", test_rule110_evolution()))
-    results.append(("Rule 110 patterns", test_rule110_known_pattern()))
-
-    # Brainfuck tests
-    results.append(("BF simple addition", test_brainfuck_simple()))
-    results.append(("BF multiplication", test_brainfuck_multiply()))
-    results.append(("BF loop countdown", test_brainfuck_loop()))
-    results.append(("BF 'Hi' output", test_brainfuck_hello()))
-    results.append(("BF nested loops", test_brainfuck_nested_loops()))
-
-    # Theoretical argument
-    results.append(("Completeness argument", test_turing_completeness_argument()))
-
-    print("\n" + "=" * 70)
-    print(" 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} tests passed")
-
-    if passed == total:
-        print("\n  STATUS: TURING COMPLETENESS DEMONSTRATED")
-        print("          Rule 110 and Brainfuck execute correctly on threshold circuits.")
-    else:
-        print("\n  STATUS: SOME COMPLETENESS TESTS FAILED")
-
-    print("=" * 70)