Upload test_gate_reconstruction.py with huggingface_hub

test_gate_reconstruction.py

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