Fix sbc8bit test: pass borrow input to subtractor eval

PROBLEM:
- arithmetic.sbc8bit was failing 67/134 tests
- Test had borrow variable but never passed it to eval_subtractor
- eval_subtractor defaulted to carry_in=1, which is correct for sub8bit
but wrong for sbc8bit which takes external borrow input

ANALYSIS:
- sbc8bit has $cin input (signal 2355) for borrow
- $cin goes directly into fa0.xor2 (first full adder's carry input)
- No carry_in gate like sub8bit has

FIX:
1. Modified eval_subtractor() to accept optional initial_carry parameter
2. Updated sbc8bit test to compute: initial_carry = 1.0 - borrow
- When borrow=0: carry_in=1, computes a - b
- When borrow=1: carry_in=0, computes a - b - 1

MATH:
- sbc computes: a - b - borrow
- Using two's complement: a + ~b + ~borrow
- So carry_in = ~borrow (inverted borrow)

RESULT:
- arithmetic.sbc8bit: 67/134 -> 134/134 PASS
- Overall: 206,124/206,124 (100.0000%)
- Fitness: 1.000000

All circuits now pass!

eval.py

@@ -662,20 +662,25 @@ 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.
+                    b_bits: List[float], initial_carry: float = None) -> Tuple[List[float], float]:
+    """Evaluate 8-bit subtractor (a - b) using full adders with b inverted + carry-in.
 
     The subtractor circuit has internal NOT gates (notb0-notb7) that invert b,
-    then uses full adders to compute a + ~b + 1.
+    then uses full adders to compute a + ~b + carry_in.
+
+    For sub8bit: carry_in = 1 (computes a - b)
+    For sbc8bit: carry_in = ~borrow (computes a - b - borrow)
     """
     n = len(a_bits)
     result = []
 
-    # Get initial carry (should be 1 for subtraction via two's complement)
-    if f"{prefix}.carry_in.weight" in ctx.tensors:
+    # Get initial carry
+    if initial_carry is not None:
+        carry = initial_carry
+    elif f"{prefix}.carry_in.weight" in ctx.tensors:
         carry = eval_gate_direct(ctx, f"{prefix}.carry_in", [1.0])
     else:
-        carry = 1.0
+        carry = 1.0  # Default for sub8bit
 
     # First, invert b bits using the circuit's NOT gates
     notb_bits = []
@@ -856,20 +861,24 @@ def test_adders(ctx: EvalContext) -> List[TestResult]:
         results.append(TestResult("arithmetic.adc8bit", passed, total))
 
     # 8-bit subtract with borrow (sbc8bit)
+    # sbc computes: a - b - borrow = a + ~b + ~borrow
+    # So carry_in = ~borrow (1 when borrow=0, 0 when borrow=1)
     if f"arithmetic.sbc8bit.fa0.xor1.layer1.or.weight" in ctx.tensors:
         passed, total = 0, 0
         test_cases = [(0, 0, 0), (0, 0, 1), (255, 1, 0), (255, 1, 1), (100, 50, 0), (100, 50, 1)]
         if not ctx.quick:
             test_cases.extend((a, b, c) for a in range(0, 256, 32) for b in range(0, 256, 32) for c in [0, 1])
 
-        for a, b, bin_val in test_cases:
+        for a, b, borrow in test_cases:
             a_bits = [float((a >> i) & 1) for i in range(8)]
             b_bits = [float((b >> i) & 1) for i in range(8)]
 
-            result_bits, _ = eval_subtractor(ctx, "arithmetic.sbc8bit", a_bits, b_bits)
+            # carry_in = ~borrow for sbc (inverted borrow)
+            initial_carry = 1.0 - float(borrow)
+            result_bits, _ = eval_subtractor(ctx, "arithmetic.sbc8bit", a_bits, b_bits, initial_carry)
             result = sum(int(bit) << i for i, bit in enumerate(result_bits))
             # sbc: a - b - borrow
-            expected = (a - b - bin_val) % 256
+            expected = (a - b - borrow) % 256
 
             total += 1
             if result == expected: