Upload test_cryptographic_selftest.py with huggingface_hub

test_cryptographic_selftest.py

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