phanerozoic
/

8bit-threshold-computer

@@ -1,510 +0,0 @@
-"""
-TEST #5: Timing Analysis
-=========================
-Build circuit DAG, compute critical path depth.
-Prove worst-case carry propagation takes exactly the expected number of layers.
-A skeptic would demand: "Show me the circuit depth. Prove the critical path."
-"""
-import torch
-from safetensors.torch import load_file
-from collections import defaultdict
-# Load circuits
-model = load_file('neural_computer.safetensors')
-# =============================================================================
-# CIRCUIT DEPTH DEFINITIONS
-# =============================================================================
-# Depth of primitive gates (in threshold layers)
-GATE_DEPTHS = {
-    'AND': 1,       # Single threshold neuron
-    'OR': 1,        # Single threshold neuron
-    'NOT': 1,       # Single threshold neuron
-    'NAND': 1,      # Single threshold neuron
-    'NOR': 1,       # Single threshold neuron
-    'XOR': 2,       # Two layers: (OR, NAND) -> AND
-    'XNOR': 2,      # Two layers: (NOR, AND) -> OR
-}
-def half_adder_depth():
-    """
-    Half adder: sum = XOR(a,b), carry = AND(a,b)
-    Critical path: max(XOR, AND) = max(2, 1) = 2
-    """
-    sum_depth = GATE_DEPTHS['XOR']  # 2
-    carry_depth = GATE_DEPTHS['AND']  # 1
-    return {
-        'sum': sum_depth,
-        'carry': carry_depth,
-        'critical': max(sum_depth, carry_depth)
-    }
-def full_adder_depth():
-    """
-    Full adder structure:
-      HA1: (a, b) -> (s1 = XOR, c1 = AND)
-      HA2: (s1, cin) -> (sum = XOR, c2 = AND)  [depends on s1]
-      cout = OR(c1, c2)  [depends on c1 and c2]
-    Critical path for sum:
-      XOR(a,b) [2] -> XOR(s1, cin) [2] = 4 layers
-    Critical path for carry:
-      Option 1: AND(a,b) [1] -> OR [1] = 2 layers
-      Option 2: XOR(a,b) [2] -> AND(s1,cin) [1] -> OR [1] = 4 layers
-      Critical: max = 4 layers
-    """
-    # Sum path
-    ha1_sum = GATE_DEPTHS['XOR']  # 2
-    ha2_sum = ha1_sum + GATE_DEPTHS['XOR']  # 2 + 2 = 4
-    # Carry path 1: through ha1_carry
-    ha1_carry = GATE_DEPTHS['AND']  # 1
-    # Carry path 2: through ha2
-    ha2_carry = ha1_sum + GATE_DEPTHS['AND']  # 2 + 1 = 3
-    # Final carry: OR of both carries
-    cout = max(ha1_carry, ha2_carry) + GATE_DEPTHS['OR']  # max(1, 3) + 1 = 4
-    return {
-        'ha1_sum': ha1_sum,
-        'ha1_carry': ha1_carry,
-        'ha2_sum': ha2_sum,
-        'ha2_carry': ha2_carry,
-        'sum': ha2_sum,
-        'carry': cout,
-        'critical': max(ha2_sum, cout)
-    }
-def ripple_carry_depth(n_bits):
-    """
-    Ripple carry adder: chain of n full adders.
-    FA0: sum[0], c0 (depth 4 each from inputs)
-    FA1: sum[1], c1 (depends on c0, so +4 for carry path)
-    ...
-    FA(n-1): sum[n-1], c(n-1)
-    Critical path is the carry chain:
-      c0 ready at depth 4
-      c1 = FA1.cout, depends on c0, adds 4 more (but only carry path matters)
-    Actually, let's trace more carefully:
-      FA_i.sum depends on FA_(i-1).cout
-      FA_i.cout depends on FA_(i-1).cout
-    Carry chain per FA after first:
-      - cin arrives
-      - XOR(a_i, b_i) was computed in parallel: 2 layers (can overlap)
-      - HA2: XOR(s1, cin): 2 more layers from cin
-      - OR(c1, c2): 1 more layer
-    So from cin to cout of one FA:
-      - If s1 is precomputed: 2 (HA2.XOR) + 1 (HA2.AND parallel) + 1 (OR) = 3?
-    Let me be more precise. Within FA_i:
-      - a_i, b_i available at time 0
-      - s1 = XOR(a_i, b_i) ready at time 2
-      - c1 = AND(a_i, b_i) ready at time 1
-      - When cin arrives at time T:
-        - s2 = XOR(s1, cin) ready at T + 2 (but s1 was ready at 2, so if T >= 2, it's T + 2)
-        - c2 = AND(s1, cin) ready at max(2, T) + 1
-        - cout = OR(c1, c2) ready at max(1, max(2,T)+1) + 1
-    For FA0, cin = 0 (constant), so effectively T = 0:
-      - sum[0] ready at 4
-      - cout[0] ready at 4
-    For FA1, cin = cout[0] arrives at T = 4:
-      - s1 was ready at 2 (precomputed)
-      - s2 = XOR(s1, cin) ready at 4 + 2 = 6
-      - c2 = AND(s1, cin) ready at max(2, 4) + 1 = 5
-      - cout[1] = OR(c1, c2) ready at max(1, 5) + 1 = 6
-    Pattern: cout[i] ready at 4 + 2*i for i >= 0
-    For 8-bit: cout[7] ready at 4 + 2*7 = 18 layers
-    But sum[7] = 4 + 2*7 = 18 layers too
-    Actually wait, let me re-examine. The carry propagation:
-      cout[i] = OR(AND(a_i, b_i), AND(XOR(a_i, b_i), cin[i]))
-    If we denote:
-      P_i = XOR(a_i, b_i)  -- propagate (ready at depth 2)
-      G_i = AND(a_i, b_i)  -- generate (ready at depth 1)
-    Then:
-      cout[i] = G_i OR (P_i AND cin[i])
-              = G_i OR (P_i AND cout[i-1])
-    Timing for cout[i] given cout[i-1] at time T:
-      - G_i ready at 1
-      - P_i ready at 2
-      - P_i AND cout[i-1] ready at max(2, T) + 1
-      - cout[i] ready at max(1, max(2, T) + 1) + 1 = max(2, T) + 2
-    For i=0: cout[0] = G_0 OR (P_0 AND 0) = G_0, ready at 1? No wait, cin=0 constant.
-      Actually if cin=0, then P_0 AND 0 = 0, so cout[0] = G_0 = AND(a_0, b_0), ready at depth 1.
-      But we still compute the full FA, so cout[0] ready at depth... let's see:
-        - G_0 ready at 1
-        - P_0 ready at 2
-        - HA2.carry = AND(P_0, 0) = 0, ready at max(2, 0) + 1 = 3 (but it's 0)
-        - cout[0] = OR(G_0, 0) = G_0, ready at max(1, 3) + 1 = 4
-    For i=1: cin[1] = cout[0] ready at 4
-      - G_1 ready at 1
-      - P_1 ready at 2
-      - P_1 AND cin[1] ready at max(2, 4) + 1 = 5
-      - cout[1] ready at max(1, 5) + 1 = 6
-    For i=2: cin[2] = cout[1] ready at 6
-      - cout[2] ready at max(2, 6) + 2 = 8
-    Pattern: cout[i] = 4 + 2*i for i >= 0
-      cout[0] = 4
-      cout[1] = 6
-      cout[7] = 4 + 14 = 18
-    And sum[i] = XOR(P_i, cin[i]):
-      sum[0] at max(2, 0) + 2 = 4
-      sum[i] at max(2, cout[i-1]) + 2 = cout[i-1] + 2 = 4 + 2*(i-1) + 2 = 4 + 2*i
-    So sum[7] ready at 4 + 14 = 18 layers.
-    Critical path for 8-bit ripple carry: 18 threshold layers.
-    """
-    fa_depth = full_adder_depth()
-    # First FA: inputs available at t=0, cin=0
-    depths = {
-        'fa0_sum': 4,
-        'fa0_cout': 4,
-    }
-    # Subsequent FAs: depend on previous carry
-    for i in range(1, n_bits):
-        cin_ready = depths[f'fa{i-1}_cout']
-        # P_i ready at 2, G_i ready at 1 (precomputed)
-        # sum[i] = XOR(P_i, cin) ready at max(2, cin_ready) + 2
-        # cout[i] ready at max(2, cin_ready) + 2
-        depths[f'fa{i}_sum'] = max(2, cin_ready) + 2
-        depths[f'fa{i}_cout'] = max(2, cin_ready) + 2
-    critical_path = max(depths.values())
-    return depths, critical_path
-def comparator_depth():
-    """
-    8-bit comparator uses weighted sum of bit differences.
-    Single threshold neuron comparing weighted sum to 0.
-    Depth: 1 (just one threshold comparison)
-    """
-    return 1
-# =============================================================================
-# TIMING TESTS
-# =============================================================================
-def test_primitive_gates():
-    """Verify primitive gate depths."""
-    print("\n[TEST 1] Primitive Gate Depths")
-    print("-" * 60)
-    print("  Gate     Layers  Structure")
-    print("  " + "-" * 40)
-    primitives = [
-        ('AND',  1, 'w*x + b >= 0'),
-        ('OR',   1, 'w*x + b >= 0'),
-        ('NOT',  1, 'w*x + b >= 0'),
-        ('NAND', 1, 'w*x + b >= 0'),
-        ('NOR',  1, 'w*x + b >= 0'),
-        ('XOR',  2, 'Layer1(OR,NAND) -> Layer2(AND)'),
-        ('XNOR', 2, 'Layer1(NOR,AND) -> Layer2(OR)'),
-    ]
-    for name, depth, structure in primitives:
-        print(f"  {name:6s}   {depth}      {structure}")
-    print()
-    print("  All single-layer gates: depth 1")
-    print("  XOR/XNOR (non-linearly-separable): depth 2")
-    return True
-def test_half_adder_depth():
-    """Analyze half adder depth."""
-    print("\n[TEST 2] Half Adder Depth Analysis")
-    print("-" * 60)
-    depths = half_adder_depth()
-    print("  Component      Depth   Notes")
-    print("  " + "-" * 45)
-    print(f"  sum (XOR)        {depths['sum']}      a XOR b")
-    print(f"  carry (AND)      {depths['carry']}      a AND b")
-    print(f"  Critical path    {depths['critical']}      max(sum, carry)")
-    print()
-    print("  Half adder critical path: 2 layers")
-    return depths['critical'] == 2
-def test_full_adder_depth():
-    """Analyze full adder depth."""
-    print("\n[TEST 3] Full Adder Depth Analysis")
-    print("-" * 60)
-    depths = full_adder_depth()
-    print("  Component        Depth   Path")
-    print("  " + "-" * 50)
-    print(f"  HA1.sum (XOR)      {depths['ha1_sum']}      XOR(a, b)")
-    print(f"  HA1.carry (AND)    {depths['ha1_carry']}      AND(a, b)")
-    print(f"  HA2.sum (XOR)      {depths['ha2_sum']}      XOR(HA1.sum, cin)")
-    print(f"  HA2.carry (AND)    {depths['ha2_carry']}      AND(HA1.sum, cin)")
-    print(f"  cout (OR)          {depths['carry']}      OR(HA1.carry, HA2.carry)")
-    print(f"  Critical path      {depths['critical']}      max(sum, cout)")
-    print()
-    print("  Full adder critical path: 4 layers")
-    print("  (XOR -> XOR for sum, or XOR -> AND -> OR for carry)")
-    return depths['critical'] == 4
-def test_ripple_carry_depth():
-    """Analyze n-bit ripple carry adder depths."""
-    print("\n[TEST 4] Ripple Carry Adder Depth Analysis")
-    print("-" * 60)
-    for n in [2, 4, 8]:
-        depths, critical = ripple_carry_depth(n)
-        print(f"\n  {n}-bit Ripple Carry Adder:")
-        print(f"    Critical path: {critical} layers")
-        # Show carry chain timing
-        carry_times = [depths[f'fa{i}_cout'] for i in range(n)]
-        print(f"    Carry chain: {carry_times}")
-        # Show sum timing
-        sum_times = [depths[f'fa{i}_sum'] for i in range(n)]
-        print(f"    Sum outputs: {sum_times}")
-    print()
-    print("  Pattern: depth = 4 + 2*(n-1) = 2n + 2")
-    print("  2-bit: 6 layers")
-    print("  4-bit: 10 layers")
-    print("  8-bit: 18 layers")
-    # Verify formula
-    for n, expected in [(2, 6), (4, 10), (8, 18)]:
-        _, actual = ripple_carry_depth(n)
-        if actual != expected:
-            print(f"  ERROR: {n}-bit expected {expected}, got {actual}")
-            return False
-    return True
-def test_worst_case_paths():
-    """Identify worst-case input patterns."""
-    print("\n[TEST 5] Worst-Case Carry Propagation Patterns")
-    print("-" * 60)
-    # Worst case: carry must propagate through all bits
-    worst_cases = [
-        (0b11111111, 0b00000001, "255 + 1: carry propagates 8 bits"),
-        (0b01111111, 0b00000001, "127 + 1: carry propagates 7 bits"),
-        (0b01111111, 0b10000000, "127 + 128: no carry propagation (bits don't overlap)"),
-        (0b10101010, 0b01010101, "170 + 85: no carry (complementary patterns)"),
-        (0b11111111, 0b11111111, "255 + 255: generate at each bit, propagate from bit 0"),
-    ]
-    print("  Input Pattern           Result  Carry Depth  Notes")
-    print("  " + "-" * 65)
-    for a, b, desc in worst_cases:
-        result = (a + b) % 256
-        carry_out = (a + b) >> 8
-        # Count how many bits need carry propagation
-        # Carry propagates through bit i if P_i = a_i XOR b_i = 1
-        propagate_bits = bin(a ^ b).count('1')
-        # Longest carry chain: consecutive propagate bits from LSB
-        chain_length = 0
-        for i in range(8):
-            if (a >> i) & 1 != (b >> i) & 1:  # P_i = 1
-                chain_length += 1
-            elif (a >> i) & 1 == 1 and (b >> i) & 1 == 1:  # G_i = 1
-                chain_length += 1  # Generates carry, continues chain
-                break  # Chain ends (or starts new)
-            else:
-                break  # Chain ends
-        print(f"  {a:3d} + {b:3d} = {result:3d}  c={carry_out}    {chain_length} bits         {desc[:40]}")
-    print()
-    print("  255 + 1 forces carry through all 8 full adders: worst case")
-    print("  127 + 128 has no overlapping bits: best case (no propagation)")
-    return True
-def test_comparator_depth():
-    """Analyze comparator depth."""
-    print("\n[TEST 6] Comparator Depth Analysis")
-    print("-" * 60)
-    print("  8-bit comparators use weighted positional comparison:")
-    print("    GT: sum((a_i - b_i) * 2^(7-i)) > 0")
-    print("    LT: sum((b_i - a_i) * 2^(7-i)) > 0")
-    print()
-    print("  Structure: Single threshold neuron")
-    print("  Depth: 1 layer (just weighted sum comparison)")
-    print()
-    print("  Note: This is O(1) depth regardless of bit width!")
-    print("  (Compared to ripple-carry which is O(n))")
-    return True
-def test_circuit_depth_summary():
-    """Summary of all circuit depths."""
-    print("\n[TEST 7] Circuit Depth Summary")
-    print("-" * 60)
-    circuits = [
-        ("AND/OR/NOT/NAND/NOR", 1),
-        ("XOR/XNOR", 2),
-        ("Half Adder", 2),
-        ("Full Adder", 4),
-        ("2-bit Ripple Carry", 6),
-        ("4-bit Ripple Carry", 10),
-        ("8-bit Ripple Carry", 18),
-        ("8-bit Comparator", 1),
-    ]
-    print("  Circuit                  Depth (layers)")
-    print("  " + "-" * 40)
-    for name, depth in circuits:
-        bar = "#" * depth
-        print(f"  {name:24s} {depth:3d}  {bar}")
-    print()
-    print("  Observations:")
-    print("    - Simple gates: O(1)")
-    print("    - Ripple carry: O(n) where n = bit width")
-    print("    - Comparator: O(1) - threshold logic advantage!")
-    return True
-def test_verify_actual_structure():
-    """Verify the actual tensor structure matches our depth analysis."""
-    print("\n[TEST 8] Verify Tensor Structure Matches Analysis")
-    print("-" * 60)
-    errors = []
-    # XOR should have layer1 and layer2
-    xor_tensors = [k for k in model.keys() if k.startswith('boolean.xor')]
-    has_layer1 = any('layer1' in k for k in xor_tensors)
-    has_layer2 = any('layer2' in k for k in xor_tensors)
-    if has_layer1 and has_layer2:
-        print("  XOR: Has layer1 and layer2 tensors [OK]")
-    else:
-        print("  XOR: Missing layer structure [FAIL]")
-        errors.append("XOR structure")
-    # Full adder should have ha1, ha2, carry_or
-    fa_tensors = [k for k in model.keys() if 'fulladder' in k]
-    has_ha1 = any('ha1' in k for k in fa_tensors)
-    has_ha2 = any('ha2' in k for k in fa_tensors)
-    has_carry_or = any('carry_or' in k for k in fa_tensors)
-    if has_ha1 and has_ha2 and has_carry_or:
-        print("  Full Adder: Has ha1, ha2, carry_or [OK]")
-    else:
-        print("  Full Adder: Missing components [FAIL]")
-        errors.append("FA structure")
-    # Ripple carry should have fa0 through fa7
-    rc8_tensors = [k for k in model.keys() if 'ripplecarry8bit' in k]
-    fa_indices = set()
-    for k in rc8_tensors:
-        for i in range(8):
-            if f'fa{i}' in k:
-                fa_indices.add(i)
-    if fa_indices == set(range(8)):
-        print(f"  8-bit Ripple Carry: Has fa0-fa7 [OK]")
-    else:
-        print(f"  8-bit Ripple Carry: Missing FAs, found {fa_indices} [FAIL]")
-        errors.append("RC8 structure")
-    # Comparator should be single layer (no layer1/layer2)
-    gt_tensors = [k for k in model.keys() if 'greaterthan8bit' in k]
-    gt_has_layers = any('layer' in k for k in gt_tensors)
-    if not gt_has_layers:
-        print("  8-bit Comparator: Single layer (no layer1/layer2) [OK]")
-    else:
-        print("  8-bit Comparator: Has unexpected layer structure [FAIL]")
-        errors.append("Comparator structure")
-    print()
-    if errors:
-        print(f"  Structure verification: {len(errors)} issues")
-        return False
-    else:
-        print("  Structure verification: All circuits match expected topology")
-        return True
-# =============================================================================
-# MAIN
-# =============================================================================
-if __name__ == "__main__":
-    print("=" * 70)
-    print(" TEST #5: TIMING ANALYSIS")
-    print(" Circuit depth and critical path analysis")
-    print("=" * 70)
-    results = []
-    results.append(("Primitive gates", test_primitive_gates()))
-    results.append(("Half adder depth", test_half_adder_depth()))
-    results.append(("Full adder depth", test_full_adder_depth()))
-    results.append(("Ripple carry depth", test_ripple_carry_depth()))
-    results.append(("Worst-case patterns", test_worst_case_paths()))
-    results.append(("Comparator depth", test_comparator_depth()))
-    results.append(("Depth summary", test_circuit_depth_summary()))
-    results.append(("Structure verification", test_verify_actual_structure()))
-    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")
-    print("\n  Key Results:")
-    print("    - 8-bit ripple carry: 18 threshold layers")
-    print("    - 8-bit comparator: 1 threshold layer")
-    print("    - Critical path formula: depth = 2n + 2 for n-bit adder")
-    if passed == total:
-        print("\n  STATUS: TIMING ANALYSIS COMPLETE")
-    else:
-        print("\n  STATUS: SOME TIMING TESTS FAILED")
-    print("=" * 70)