Delete test_overflow_chains.py with huggingface_hub

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)