phanerozoic
/

8bit-threshold-computer

@@ -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)