Upload test_overflow_chains.py with huggingface_hub

test_overflow_chains.py

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