Delete test_gate_reconstruction.py with huggingface_hub

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)