Add float16.normalize, neg, abs circuits

- float16.normalize: CLZ-based shift calculator (51 gates)
- float16.neg: sign flip (16 gates)
- float16.abs: clear sign bit (16 gates)
- All 100% pass rate

TODO.md

@@ -3,22 +3,22 @@
 ## High Priority
 
 ### Floating Point Circuits
-- [x] `float16.unpack` -- extract sign, exponent, mantissa from IEEE 754 half-precision
-- [x] `float16.pack` -- assemble from components
-- [ ] `float16.normalize` -- normalize after arithmetic
-- [ ] `float16.add` -- 16-bit IEEE 754 addition
-- [ ] `float16.sub` -- subtraction
+- [x] `float16.unpack` -- extract sign, exponent, mantissa (16 gates, 63/63 tests)
+- [x] `float16.pack` -- assemble from components (16 gates, 63/63 tests)
+- [x] `float16.cmp` -- comparison a > b (14 gates, 113/113 tests)
+- [x] `float16.normalize` -- CLZ-based shift calculator (51 gates, 14/14 tests)
+- [ ] `float16.add` -- IEEE 754 addition (requires normalize + align + add)
+- [ ] `float16.sub` -- subtraction (add with negated operand)
 - [ ] `float16.mul` -- multiplication
 - [ ] `float16.div` -- division
-- [x] `float16.cmp` -- comparison (>)
-- [ ] `float16.neg` -- negation
-- [ ] `float16.abs` -- absolute value
+- [x] `float16.neg` -- sign flip (16 gates, 58/58 tests)
+- [x] `float16.abs` -- clear sign bit (16 gates, 58/58 tests)
 - [ ] `float16.toint` -- convert to integer
 - [ ] `float16.fromint` -- convert from integer
 
 ### Supporting Infrastructure
-- [x] `arithmetic.clz8bit` -- count leading zeros (needed for float normalization)
-- [x] `arithmetic.clz16bit` -- 16-bit count leading zeros
+- [x] `arithmetic.clz8bit` -- 8-bit count leading zeros (30 gates, 256/256 tests)
+- [x] `arithmetic.clz16bit` -- 16-bit count leading zeros (63 gates, 217/217 tests)
 
 ## Medium Priority
 

arithmetic.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ebe8e155f964f27d26a8a35750f6af361556a65c1178a1c96e4dd5eea95a66c4
-size 1111188
+oid sha256:2b16619fd1cda08ab7c9ccf567ef77f8001ff7b6f76b8ed6852ad262fbc8d139
+size 1140364

arithmetic_legacy.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b53234c708c9f134e154f7e8ddbc251ea9a89e087fc34693c69963f3e21a6be0
+size 575300

convert_to_explicit_inputs.py

@@ -1052,11 +1052,53 @@ def infer_inputs_for_gate(gate: str, registry: SignalRegistry, routing: dict) ->
             return infer_float16_cmp_inputs(gate, registry)
         if 'normalize' in gate:
             return infer_float16_normalize_inputs(gate, registry)
+        if gate.startswith('float16.neg'):
+            return infer_float16_neg_inputs(gate, registry)
+        if gate.startswith('float16.abs'):
+            return infer_float16_abs_inputs(gate, registry)
 
     # Default: couldn't infer, return empty (will need manual fix or routing)
     return []
 
 
+def infer_float16_neg_inputs(gate: str, registry: SignalRegistry) -> List[int]:
+    """Infer inputs for float16.neg circuit."""
+    prefix = "float16.neg"
+
+    # Register 16-bit input
+    for i in range(16):
+        registry.register(f"{prefix}.$x[{i}]")
+
+    # Output gates
+    match = re.search(r'\.out(\d+)', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.get_id(f"{prefix}.$x[{i}]")]
+
+    return []
+
+
+def infer_float16_abs_inputs(gate: str, registry: SignalRegistry) -> List[int]:
+    """Infer inputs for float16.abs circuit."""
+    prefix = "float16.abs"
+
+    # Register 16-bit input
+    for i in range(16):
+        registry.register(f"{prefix}.$x[{i}]")
+
+    # Output gates
+    match = re.search(r'\.out(\d+)', gate)
+    if match:
+        i = int(match.group(1))
+        if i == 15:
+            # Sign bit output doesn't depend on input (always 0)
+            # But we still need an input for the gate structure
+            return [registry.get_id(f"{prefix}.$x[15]")]
+        return [registry.get_id(f"{prefix}.$x[{i}]")]
+
+    return []
+
+
 def infer_float16_normalize_inputs(gate: str, registry: SignalRegistry) -> List[int]:
     """Infer inputs for float16.normalize circuit."""
     prefix = "float16.normalize"
@@ -1106,7 +1148,7 @@ def infer_float16_normalize_inputs(gate: str, registry: SignalRegistry) -> List[
             k = int(match.group(1))
             return [registry.get_id(f"{prefix}.ge{k}")]
 
-    for k in [2, 4, 8]:
+    for k in [2, 4, 6, 8, 10, 12]:
         registry.register(f"{prefix}.not_ge{k}")
 
     # AND gates for ranges
@@ -1117,8 +1159,7 @@ def infer_float16_normalize_inputs(gate: str, registry: SignalRegistry) -> List[
     if '.and_6_7' in gate:
         return [registry.get_id(f"{prefix}.ge6"), registry.get_id(f"{prefix}.not_ge8")]
     if '.and_10_11' in gate:
-        return [registry.get_id(f"{prefix}.ge10"), registry.get_id(f"{prefix}.ge12")]
-        # Note: and_10_11 should be ge10 AND NOT ge12, but we don't have not_ge12
+        return [registry.get_id(f"{prefix}.ge10"), registry.get_id(f"{prefix}.not_ge12")]
 
     # Odd AND gates
     match = re.search(r'\.and_(\d+)$', gate)
@@ -1330,6 +1371,49 @@ def infer_float16_unpack_inputs(gate: str, registry: SignalRegistry) -> List[int
     return []
 
 
+def build_float16_neg_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.neg circuit.
+
+    Negates a float16 by flipping the sign bit.
+    All other bits pass through unchanged.
+    """
+    tensors = {}
+    prefix = "float16.neg"
+
+    # Sign bit: NOT of input sign
+    tensors[f"{prefix}.out15.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.out15.bias"] = torch.tensor([0.0])
+
+    # All other bits: pass through
+    for i in range(15):
+        tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-0.5])
+
+    return tensors
+
+
+def build_float16_abs_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.abs circuit.
+
+    Absolute value: clear the sign bit, pass all others.
+    """
+    tensors = {}
+    prefix = "float16.abs"
+
+    # Sign bit: always 0 (use constant #0)
+    # Actually, we can just not output bit 15, or output 0
+    # For consistency, let's output 0 by using bias that never fires
+    tensors[f"{prefix}.out15.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.out15.bias"] = torch.tensor([-2.0])  # never fires
+
+    # All other bits: pass through
+    for i in range(15):
+        tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-0.5])
+
+    return tensors
+
+
 def build_float16_normalize_tensors() -> Dict[str, torch.Tensor]:
     """Build tensors for float16.normalize circuit.
 
@@ -1733,6 +1817,18 @@ def main():
     tensors.update(cmp_tensors)
     print(f"  float16.cmp: {len(cmp_tensors)} tensors")
 
+    norm_tensors = build_float16_normalize_tensors()
+    tensors.update(norm_tensors)
+    print(f"  float16.normalize: {len(norm_tensors)} tensors")
+
+    neg_tensors = build_float16_neg_tensors()
+    tensors.update(neg_tensors)
+    print(f"  float16.neg: {len(neg_tensors)} tensors")
+
+    abs_tensors = build_float16_abs_tensors()
+    tensors.update(abs_tensors)
+    print(f"  float16.abs: {len(abs_tensors)} tensors")
+
     print(f"Total tensors: {len(tensors)}")
 
     # Load routing for complex circuits

eval.py

@@ -513,6 +513,125 @@ class CircuitEvaluator:
 
         return TestResult('float16.cmp', passed, len(test_cases), failures)
 
+    def test_float16_normalize(self) -> TestResult:
+        """Test float16.normalize shift amount calculation."""
+        prefix = 'float16.normalize'
+        failures = []
+        passed = 0
+
+        # Test cases: 13-bit mantissa values and expected shift amounts
+        # Shift amount = CLZ of bits 11:0 (excluding overflow bit 12)
+        test_cases = [
+            (0b1_000000000000, 0),   # Overflow bit set -> shift 0
+            (0b0_100000000000, 0),   # Bit 11 set -> CLZ=0
+            (0b0_010000000000, 1),   # Bit 10 set -> CLZ=1
+            (0b0_001000000000, 2),   # Bit 9 set -> CLZ=2
+            (0b0_000100000000, 3),   # etc
+            (0b0_000010000000, 4),
+            (0b0_000001000000, 5),
+            (0b0_000000100000, 6),
+            (0b0_000000010000, 7),
+            (0b0_000000001000, 8),
+            (0b0_000000000100, 9),
+            (0b0_000000000010, 10),
+            (0b0_000000000001, 11),
+            (0b0_000000000000, 12),  # All zeros -> CLZ=12 (max shift)
+        ]
+
+        for mant, expected_shift in test_cases:
+            overflow = (mant >> 12) & 1
+
+            # Set up inputs
+            ext = {}
+            for i in range(13):
+                ext[f'{prefix}.$m[{i}]'] = float((mant >> i) & 1)
+
+            values = self.eval_circuit(prefix, ext)
+
+            # Get shift amount (masked by not_overflow)
+            shift = 0
+            for i in range(4):
+                bit = int(values.get(f'{prefix}.out_shift{i}', 0))
+                shift |= (bit << i)
+
+            # Check overflow detection
+            got_overflow = int(values.get(f'{prefix}.overflow', 0))
+            is_zero = int(values.get(f'{prefix}.is_zero', 0))
+
+            # Expected: if overflow, shift output should be 0 (masked)
+            if overflow:
+                expected_out = 0
+            else:
+                expected_out = expected_shift
+
+            if shift == expected_out and got_overflow == overflow:
+                passed += 1
+            else:
+                if len(failures) < 10:
+                    failures.append((mant, expected_shift, shift, overflow, got_overflow))
+
+        return TestResult('float16.normalize', passed, len(test_cases), failures)
+
+    def test_float16_neg(self) -> TestResult:
+        """Test float16.neg (sign flip)."""
+        prefix = 'float16.neg'
+        failures = []
+        passed = 0
+
+        test_values = [0x0000, 0x8000, 0x3C00, 0xBC00, 0x4000, 0x7C00, 0xFC00, 0x7BFF]
+
+        import random
+        random.seed(42)
+        for _ in range(50):
+            test_values.append(random.randint(0, 0xFFFF))
+
+        for val in test_values:
+            # Expected: flip bit 15
+            expected = val ^ 0x8000
+
+            ext = {f'{prefix}.$x[{i}]': float((val >> i) & 1) for i in range(16)}
+            values = self.eval_circuit(prefix, ext)
+
+            result = sum(int(values.get(f'{prefix}.out{i}', 0)) << i for i in range(16))
+
+            if result == expected:
+                passed += 1
+            else:
+                if len(failures) < 10:
+                    failures.append((val, expected, result))
+
+        return TestResult('float16.neg', passed, len(test_values), failures)
+
+    def test_float16_abs(self) -> TestResult:
+        """Test float16.abs (clear sign bit)."""
+        prefix = 'float16.abs'
+        failures = []
+        passed = 0
+
+        test_values = [0x0000, 0x8000, 0x3C00, 0xBC00, 0x4000, 0x7C00, 0xFC00, 0x7BFF]
+
+        import random
+        random.seed(42)
+        for _ in range(50):
+            test_values.append(random.randint(0, 0xFFFF))
+
+        for val in test_values:
+            # Expected: clear bit 15
+            expected = val & 0x7FFF
+
+            ext = {f'{prefix}.$x[{i}]': float((val >> i) & 1) for i in range(16)}
+            values = self.eval_circuit(prefix, ext)
+
+            result = sum(int(values.get(f'{prefix}.out{i}', 0)) << i for i in range(16))
+
+            if result == expected:
+                passed += 1
+            else:
+                if len(failures) < 10:
+                    failures.append((val, expected, result))
+
+        return TestResult('float16.abs', passed, len(test_values), failures)
+
     # =========================================================================
     # ARITHMETIC TESTS (DIRECT EVALUATION)
     # =========================================================================
@@ -693,6 +812,21 @@ class Evaluator:
             self.results.append(result)
             if verbose:
                 self._print_result(result)
+        if 'float16.normalize.overflow.weight' in self.eval.tensors:
+            result = self.eval.test_float16_normalize()
+            self.results.append(result)
+            if verbose:
+                self._print_result(result)
+        if 'float16.neg.out0.weight' in self.eval.tensors:
+            result = self.eval.test_float16_neg()
+            self.results.append(result)
+            if verbose:
+                self._print_result(result)
+        if 'float16.abs.out0.weight' in self.eval.tensors:
+            result = self.eval.test_float16_abs()
+            self.results.append(result)
+            if verbose:
+                self._print_result(result)
 
         # Comparators
         if verbose: