Add float16 constant circuits

arithmetic.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a94399cf37d56ba839e1dbae35510cfa6eccebc6e413e5200c8df54d707552f0
-size 443825664
+oid sha256:d97b4a0b0f1f8d8c858c46e3077140092e54fb7648021aa757d08284e920e2a0
+size 443848032

build.py

@@ -69,6 +69,21 @@ def float16_float_to_bits(val: float) -> int:
         return 0x7BFF if val > 0 else 0xFBFF
 
 
+def build_float16_const_tensors(prefix: str, value: float) -> Dict[str, torch.Tensor]:
+    """Build constant float16 outputs (prefix.out0..out15) using #1 input."""
+    tensors: Dict[str, torch.Tensor] = {}
+    bits = float16_float_to_bits(value)
+    for i in range(16):
+        bit = (bits >> i) & 1
+        if bit:
+            tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-0.5])
+        else:
+            tensors[f"{prefix}.out{i}.weight"] = torch.tensor([-1.0])
+            tensors[f"{prefix}.out{i}.bias"] = torch.tensor([0.0])
+    return tensors
+
+
 def compute_float16_unary_lut_outputs(op_fn: Callable[[torch.Tensor], torch.Tensor]) -> List[int]:
     """Compute output bits for all 65536 float16 inputs using a unary op."""
     outputs: List[int] = [0] * 65536
@@ -1353,6 +1368,8 @@ def infer_inputs_for_gate(gate: str, registry: SignalRegistry, routing: dict) ->
 
     # Float16 circuits
     if gate.startswith('float16.'):
+        if gate.startswith('float16.const_'):
+            return [registry.get_id("#1")]
         if gate.endswith('.domain_not'):
             prefix = gate[:-len('.domain_not')]
             registry.register(f"{prefix}.domain")
@@ -11260,6 +11277,17 @@ def main():
     tensors.update(fromint_tensors)
     print(f"  float16.fromint: {len(fromint_tensors)} tensors")
 
+    const_map = {
+        "pi": math.pi,
+        "e": math.e,
+        "deg2rad": math.pi / 180.0,
+        "rad2deg": 180.0 / math.pi,
+    }
+    for name, value in const_map.items():
+        const_tensors = build_float16_const_tensors(f"float16.const_{name}", value)
+        tensors.update(const_tensors)
+        print(f"  float16.const_{name}: {len(const_tensors)} tensors")
+
     # Shared LUT match gates
     lut_match_tensors = build_float16_lut_match_tensors("float16.lut")
     tensors.update(lut_match_tensors)

calculator.py

@@ -159,6 +159,7 @@ class ThresholdCalculator:
         self._id_to_gate: Dict[int, str] = {}
         self._topo_cache: Dict[Tuple[str, Tuple[str, ...]], List[str]] = {}
         self._compiled: Dict[Tuple[str, Tuple[str, ...]], CompiledCircuit] = {}
+        self._const_cache: Dict[str, int] = {}
         self._load()
 
     def _load(self) -> None:
@@ -493,6 +494,17 @@ class ThresholdCalculator:
         out_int = bits_to_int(result.bits)
         return float16_bits_to_float(out_int), result
 
+    def _const_bits(self, name: str, fallback: float) -> int:
+        if name in self._const_cache:
+            return self._const_cache[name]
+        prefix = f"float16.const_{name}"
+        if f"{prefix}.out0.weight" in self.tensors:
+            res = self.evaluate_prefix(prefix, {}, out_bits=16)
+            self._const_cache[name] = bits_to_int(res.bits)
+        else:
+            self._const_cache[name] = float_to_float16_bits(fallback)
+        return self._const_cache[name]
+
     def evaluate_rpn(
         self,
         tokens: Sequence[str],
@@ -525,9 +537,13 @@ class ThresholdCalculator:
 
         def const_to_bits(tok: str) -> int:
             if tok == "pi":
-                return float_to_float16_bits(math.pi)
+                return self._const_bits("pi", math.pi)
             if tok == "e":
-                return float_to_float16_bits(math.e)
+                return self._const_bits("e", math.e)
+            if tok == "deg2rad":
+                return self._const_bits("deg2rad", math.pi / 180.0)
+            if tok == "rad2deg":
+                return self._const_bits("rad2deg", 180.0 / math.pi)
             if tok == "inf":
                 return float_to_float16_bits(float("inf"))
             if tok == "nan":
@@ -671,9 +687,13 @@ class ThresholdCalculator:
             if isinstance(node, ast.Name):
                 name = node.id
                 if name == "pi":
-                    return float_to_float16_bits(math.pi)
+                    return self._const_bits("pi", math.pi)
                 if name == "e":
-                    return float_to_float16_bits(math.e)
+                    return self._const_bits("e", math.e)
+                if name == "deg2rad":
+                    return self._const_bits("deg2rad", math.pi / 180.0)
+                if name == "rad2deg":
+                    return self._const_bits("rad2deg", 180.0 / math.pi)
                 if name == "inf":
                     return float_to_float16_bits(float("inf"))
                 if name == "nan":

eval.py

@@ -936,6 +936,32 @@ def float16_expected_domain(op: str, a_bits: int) -> int:
     return 0
 
 
+def test_float16_constants(ctx: EvalContext) -> List[TestResult]:
+    """Test float16 constant-output circuits."""
+    results: List[TestResult] = []
+    consts = {
+        "float16.const_pi": math.pi,
+        "float16.const_e": math.e,
+        "float16.const_deg2rad": math.pi / 180.0,
+        "float16.const_rad2deg": 180.0 / math.pi,
+    }
+    for prefix, value in consts.items():
+        if f"{prefix}.out0.weight" not in ctx.tensors:
+            continue
+        expected = float_to_int(value)
+        actual_bits = eval_prefix_outputs(ctx, prefix, {})
+        actual = bits_to_int(actual_bits)
+        passed = 1 if actual == expected else 0
+        failures = []
+        if not passed:
+            failures.append({
+                "expected": hex(expected),
+                "actual": hex(actual),
+            })
+        results.append(TestResult(prefix, passed, 1, failures))
+    return results
+
+
 # =============================================================================
 # BOOLEAN GATE TESTS
 # =============================================================================
@@ -2994,6 +3020,7 @@ CATEGORIES = {
     "float16_arith": ("Float16 - Arithmetic", test_float16_arithmetic),
     "float16_conv": ("Float16 - Conversion", test_float16_conversion),
     "float16_unary": ("Float16 - Unary LUT", test_float16_unary),
+    "float16_constants": ("Float16 - Constants", test_float16_constants),
     "float16_domain": ("Float16 - Domain Flags", test_float16_domain_flags),
     "float16_checked": ("Float16 - Checked Outputs", test_float16_checked_outputs),
     "float16_pow": ("Float16 - Pow", test_float16_pow),