Fix broken circuits: bitwise shifts, symmetry8bit, subtractor eval

CIRCUIT FIXES (convert_to_explicit_inputs.py):

1. BITWISE SHIFT CIRCUITS (asr8bit, rol8bit, ror8bit):
- Old weights were all [1.0] selecting only x[0] for every output
- Added build_bitwise_shift_tensors() with correct weights:
* ASR: bit[i] = x[i+1] for i<7, bit[7] = x[7] (sign extension)
* ROL: bit[0] = x[7], bit[i] = x[i-1] for i>0
* ROR: bit[i] = x[i+1] for i<7, bit[7] = x[0]
- Each output gate now has proper weight vector to select correct input bit

2. SYMMETRY8BIT CIRCUIT:
- Old XNOR gates had weights [1,1] with no bias (acted as OR, not XNOR)
- Added build_symmetry8bit_tensors() with proper 2-layer XNOR:
* Layer 1: AND gate (weight selects pair, bias -1.5 requires both)
* Layer 1: NOR gate (negative weights, bias 0 fires when both 0)
* Layer 2: OR of AND and NOR outputs (fires when a==b)
- Final AND gate combines 4 XNOR results (bias -3.5 requires all 4)

3. SUBTRACTOR EVAL FIX (eval.py):
- eval_subtractor() now properly handles internal NOT gates
- Circuit has notb0-notb7 gates that invert b internally
- Eval now: (1) evaluates notb gates, (2) passes inverted b to full adders
- Fixes arithmetic.sub8bit: 0/65536 -> 65536/65536 PASS

MAIN() UPDATES:
- Remove old broken asr8bit/rol8bit/ror8bit tensors before rebuild
- Remove old broken symmetry8bit tensors before rebuild
- Add build_bitwise_shift_tensors() call (54 tensors)
- Add build_symmetry8bit_tensors() call (26 tensors)

EVAL.PY UPDATES:
- Updated symmetry8bit test to use new 2-layer XNOR structure
- Test now evaluates: layer1.and, layer1.nor -> layer2 for each XNOR

RESULTS:
Before: 67.65% (139,452/206,124) - 6 circuits failing
After: 99.97% (206,057/206,124) - 1 circuit failing

PASSING NOW:
- arithmetic.sub8bit: 65536/65536 ✓
- arithmetic.asr8bit: 256/256 ✓
- arithmetic.rol8bit: 256/256 ✓
- arithmetic.ror8bit: 256/256 ✓
- pattern_recognition.symmetry8bit: 256/256 ✓

STILL FAILING:
- arithmetic.sbc8bit: 67/134 (test logic issue, not circuit)

arithmetic.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dea2cbf40adf3e1044955d057efd6465759520a65192690815f22ad404d1f945
-size 3057764
+oid sha256:cd147a9a27df47020615265d1c0a62b10cd4839d2a6252b1f19c8c2dbf83790d
+size 3062104

convert_to_explicit_inputs.py

@@ -6635,6 +6635,127 @@ def build_modular_power2_tensors() -> Dict[str, torch.Tensor]:
     return tensors
 
 
+def build_bitwise_shift_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for arithmetic.asr8bit, rol8bit, ror8bit circuits.
+
+    ASR (Arithmetic Shift Right by 1):
+    - bit[i] = x[i+1] for i in 0..6
+    - bit[7] = x[7] (sign extension)
+    - shiftout = x[0]
+
+    ROL (Rotate Left by 1):
+    - bit[0] = x[7] (wrap around)
+    - bit[i] = x[i-1] for i in 1..7
+    - cout = x[7]
+
+    ROR (Rotate Right by 1):
+    - bit[i] = x[i+1] for i in 0..6
+    - bit[7] = x[0] (wrap around)
+    - cout = x[0]
+    """
+    tensors = {}
+
+    # ASR8BIT - Arithmetic Shift Right by 1
+    prefix = "arithmetic.asr8bit"
+    for i in range(8):
+        if i < 7:
+            # bit[i] gets x[i+1] (shift right)
+            w = [0.0] * 8
+            w[i + 1] = 1.0
+        else:
+            # bit[7] gets x[7] (sign extension)
+            w = [0.0] * 8
+            w[7] = 1.0
+        tensors[f"{prefix}.bit{i}.weight"] = torch.tensor(w)
+        tensors[f"{prefix}.bit{i}.bias"] = torch.tensor([-0.5])
+    # shiftout gets x[0]
+    w = [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    tensors[f"{prefix}.shiftout.weight"] = torch.tensor(w)
+    tensors[f"{prefix}.shiftout.bias"] = torch.tensor([-0.5])
+
+    # ROL8BIT - Rotate Left by 1
+    prefix = "arithmetic.rol8bit"
+    for i in range(8):
+        w = [0.0] * 8
+        if i == 0:
+            # bit[0] gets x[7] (wrap around)
+            w[7] = 1.0
+        else:
+            # bit[i] gets x[i-1]
+            w[i - 1] = 1.0
+        tensors[f"{prefix}.bit{i}.weight"] = torch.tensor(w)
+        tensors[f"{prefix}.bit{i}.bias"] = torch.tensor([-0.5])
+    # cout gets x[7]
+    w = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
+    tensors[f"{prefix}.cout.weight"] = torch.tensor(w)
+    tensors[f"{prefix}.cout.bias"] = torch.tensor([-0.5])
+
+    # ROR8BIT - Rotate Right by 1
+    prefix = "arithmetic.ror8bit"
+    for i in range(8):
+        w = [0.0] * 8
+        if i < 7:
+            # bit[i] gets x[i+1]
+            w[i + 1] = 1.0
+        else:
+            # bit[7] gets x[0] (wrap around)
+            w[0] = 1.0
+        tensors[f"{prefix}.bit{i}.weight"] = torch.tensor(w)
+        tensors[f"{prefix}.bit{i}.bias"] = torch.tensor([-0.5])
+    # cout gets x[0]
+    w = [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    tensors[f"{prefix}.cout.weight"] = torch.tensor(w)
+    tensors[f"{prefix}.cout.bias"] = torch.tensor([-0.5])
+
+    return tensors
+
+
+def build_symmetry8bit_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for pattern_recognition.symmetry8bit circuit.
+
+    Checks if an 8-bit input is a palindrome (symmetric).
+    bit[0] == bit[7], bit[1] == bit[6], bit[2] == bit[5], bit[3] == bit[4]
+
+    XNOR as threshold gate: XNOR(a,b) = 1 if a==b
+    This requires a 2-layer structure per XNOR:
+    - Layer 1: AND(a,b) and NOR(a,b)
+    - Layer 2: OR of AND and NOR outputs
+
+    Then final AND of all 4 XNOR results.
+    """
+    tensors = {}
+    prefix = "pattern_recognition.symmetry8bit"
+
+    # XNOR gates for comparing bit pairs: (0,7), (1,6), (2,5), (3,4)
+    pairs = [(0, 7), (1, 6), (2, 5), (3, 4)]
+
+    for i, (lo, hi) in enumerate(pairs):
+        # Layer 1: AND(a,b) - fires when both are 1
+        # Weight: select bits lo and hi from 8-bit input
+        w_and = [0.0] * 8
+        w_and[lo] = 1.0
+        w_and[hi] = 1.0
+        tensors[f"{prefix}.xnor{i}.layer1.and.weight"] = torch.tensor(w_and)
+        tensors[f"{prefix}.xnor{i}.layer1.and.bias"] = torch.tensor([-1.5])  # Need both
+
+        # Layer 1: NOR(a,b) - fires when both are 0
+        w_nor = [0.0] * 8
+        w_nor[lo] = -1.0
+        w_nor[hi] = -1.0
+        tensors[f"{prefix}.xnor{i}.layer1.nor.weight"] = torch.tensor(w_nor)
+        tensors[f"{prefix}.xnor{i}.layer1.nor.bias"] = torch.tensor([0.0])  # Fire when sum < 0
+
+        # Layer 2: OR of AND and NOR - fires when either is 1 (i.e., a==b)
+        tensors[f"{prefix}.xnor{i}.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.xnor{i}.layer2.bias"] = torch.tensor([-0.5])
+
+    # Final AND of all 4 XNOR results
+    tensors[f"{prefix}.and.weight"] = torch.tensor([1.0, 1.0, 1.0, 1.0])
+    tensors[f"{prefix}.and.bias"] = torch.tensor([-3.5])  # Need all 4
+
+    return tensors
+
+
 def build_clz8bit_tensors() -> Dict[str, torch.Tensor]:
     """Build tensors for arithmetic.clz8bit circuit.
 
@@ -6722,6 +6843,19 @@ def main():
         del tensors[k]
     print(f"Removed {len(old_mod_power2)} old mod2/mod4/mod8 tensors")
 
+    # Remove broken bitwise shift tensors
+    old_bitwise = [k for k in tensors.keys() if k.startswith('arithmetic.asr8bit') or
+                   k.startswith('arithmetic.rol8bit') or k.startswith('arithmetic.ror8bit')]
+    for k in old_bitwise:
+        del tensors[k]
+    print(f"Removed {len(old_bitwise)} old asr8bit/rol8bit/ror8bit tensors")
+
+    # Remove broken symmetry8bit tensors
+    old_symmetry = [k for k in tensors.keys() if k.startswith('pattern_recognition.symmetry8bit')]
+    for k in old_symmetry:
+        del tensors[k]
+    print(f"Removed {len(old_symmetry)} old symmetry8bit tensors")
+
     # Build new circuits
     print("Building new circuits...")
     clz_tensors = build_clz8bit_tensors()
@@ -6784,6 +6918,14 @@ def main():
     tensors.update(mod_power2_tensors)
     print(f"  modular.mod2/4/8: {len(mod_power2_tensors)} tensors")
 
+    bitwise_tensors = build_bitwise_shift_tensors()
+    tensors.update(bitwise_tensors)
+    print(f"  bitwise shifts: {len(bitwise_tensors)} tensors")
+
+    symmetry_tensors = build_symmetry8bit_tensors()
+    tensors.update(symmetry_tensors)
+    print(f"  symmetry8bit: {len(symmetry_tensors)} tensors")
+
     print(f"Total tensors: {len(tensors)}")
 
     # Load routing for complex circuits

eval.py

@@ -663,7 +663,11 @@ def test_clz(ctx: EvalContext) -> List[TestResult]:
 
 def eval_subtractor(ctx: EvalContext, prefix: str, a_bits: List[float],
                     b_bits: List[float]) -> Tuple[List[float], float]:
-    """Evaluate 8-bit subtractor (a - b) using full adders with b inverted + carry-in=1."""
+    """Evaluate 8-bit subtractor (a - b) using full adders with b inverted + carry-in=1.
+
+    The subtractor circuit has internal NOT gates (notb0-notb7) that invert b,
+    then uses full adders to compute a + ~b + 1.
+    """
     n = len(a_bits)
     result = []
 
@@ -673,10 +677,18 @@ def eval_subtractor(ctx: EvalContext, prefix: str, a_bits: List[float],
     else:
         carry = 1.0
 
+    # First, invert b bits using the circuit's NOT gates
+    notb_bits = []
     for i in range(n):
-        # b is inverted for subtraction, so we compute a + ~b + 1
-        # The NOT of b[i] is handled internally by the subtractor circuit
-        sum_bit, carry = eval_full_adder(ctx, f"{prefix}.fa{i}", a_bits[i], b_bits[i], carry)
+        if f"{prefix}.notb{i}.weight" in ctx.tensors:
+            notb = eval_gate_direct(ctx, f"{prefix}.notb{i}", [b_bits[i]])
+        else:
+            notb = 1.0 - b_bits[i]  # Manual NOT
+        notb_bits.append(notb)
+
+    # Now evaluate full adders with a and inverted b
+    for i in range(n):
+        sum_bit, carry = eval_full_adder(ctx, f"{prefix}.fa{i}", a_bits[i], notb_bits[i], carry)
         result.append(sum_bit)
 
     return result, carry
@@ -1403,19 +1415,23 @@ def test_pattern_recognition(ctx: EvalContext) -> List[TestResult]:
         results.append(TestResult("pattern_recognition.alternating8bit", 2, 2))
 
     # Symmetry - checks if bit pattern is a palindrome
-    if f"pattern_recognition.symmetry8bit.xnor0.weight" in ctx.tensors:
+    # Uses 2-layer XNOR structure: layer1.and + layer1.nor -> layer2
+    if f"pattern_recognition.symmetry8bit.xnor0.layer1.and.weight" in ctx.tensors:
         passed, total = 0, 0
         test_range = range(256) if not ctx.quick else range(0, 256, 16)
 
         for val in test_range:
             bits = [float((val >> i) & 1) for i in range(8)]
 
-            # Evaluate XNOR for each pair: bit0 vs bit7, bit1 vs bit6, etc.
+            # Evaluate XNOR for each pair: (0,7), (1,6), (2,5), (3,4)
             xnor_results = []
             for i in range(4):
-                # XNOR of bits[i] and bits[7-i]
-                xnor_val = eval_gate_direct(ctx, f"pattern_recognition.symmetry8bit.xnor{i}",
-                                           [bits[i], bits[7-i]])
+                prefix = f"pattern_recognition.symmetry8bit.xnor{i}"
+                # Layer 1: AND and NOR take all 8 bits (weights select the pair)
+                and_val = eval_gate_direct(ctx, f"{prefix}.layer1.and", bits)
+                nor_val = eval_gate_direct(ctx, f"{prefix}.layer1.nor", bits)
+                # Layer 2: OR of AND and NOR
+                xnor_val = eval_gate_direct(ctx, f"{prefix}.layer2", [and_val, nor_val])
                 xnor_results.append(xnor_val)
 
             # Final AND of all XNOR results