Add float16 domain flags

arithmetic.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6bc68cbb34ffc8d5a3dcdda3c63a2a806175e6e90ee83c7fe7ca37ed287e087d
-size 436688020
+oid sha256:a54f3c41068308469d61313565f8f8457799b84214eac14ff14588bd14309c92
+size 443768896

build.py

@@ -82,6 +82,24 @@ def compute_float16_unary_lut_outputs(op_fn: Callable[[torch.Tensor], torch.Tens
     return outputs
 
 
+def compute_float16_domain_flags(op: str) -> List[int]:
+    """Compute domain error flags (1=invalid) for all 65536 float16 inputs."""
+    flags: List[int] = [0] * 65536
+    for bits in range(65536):
+        val = float16_bits_to_float(bits)
+        invalid = False
+        if val != val:
+            invalid = True
+        elif op in ("sqrt", "rsqrt") and val < 0:
+            invalid = True
+        elif op in ("ln", "log2", "log10") and val <= 0:
+            invalid = True
+        elif op in ("asin", "acos", "asin_deg", "acos_deg") and abs(val) > 1.0:
+            invalid = True
+        flags[bits] = 1 if invalid else 0
+    return flags
+
+
 def unary_float32(op_fn: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
     """Wrap unary op to run in float32 for wider CPU support, returning float32."""
     def _fn(x: torch.Tensor) -> torch.Tensor:
@@ -129,6 +147,18 @@ def build_float16_lut_output_tensors(prefix: str, outputs: List[int]) -> Dict[st
     return tensors
 
 
+def build_float16_lut_flag_tensors(prefix: str, flags: List[int], flag_name: str = "domain") -> Dict[str, torch.Tensor]:
+    """Build a 1-bit LUT flag gate (prefix.{flag_name}) using one-hot match inputs."""
+    weights = torch.zeros(65536)
+    for idx, flag in enumerate(flags):
+        if flag:
+            weights[idx] = 1.0
+    tensors: Dict[str, torch.Tensor] = {}
+    tensors[f"{prefix}.{flag_name}.weight"] = weights
+    tensors[f"{prefix}.{flag_name}.bias"] = torch.tensor([-0.5])
+    return tensors
+
+
 def clone_prefix_tensors(src: Dict[str, torch.Tensor], old_prefix: str,
                          new_prefix: str) -> Dict[str, torch.Tensor]:
     """Clone tensors and rewrite the prefix in tensor names."""
@@ -209,6 +239,8 @@ def infer_float16_lut_match_inputs(gate: str, registry: SignalRegistry,
 
 def infer_float16_lut_out_inputs(gate: str, registry: SignalRegistry, match_prefix: str) -> List[int]:
     """Infer inputs for LUT output gates (one-hot match vector)."""
+    if gate.endswith(".domain"):
+        return get_lut_match_ids(registry, match_prefix)
     match = re.search(r'\.out(\d+)$', gate)
     if not match:
         return []
@@ -11233,6 +11265,17 @@ def main():
         "acos_deg": wrap_inv_trig_deg(torch.acos),
         "atan_deg": wrap_inv_trig_deg(torch.atan),
     }
+    domain_ops = [
+        "sqrt",
+        "rsqrt",
+        "ln",
+        "log2",
+        "log10",
+        "asin",
+        "acos",
+        "asin_deg",
+        "acos_deg",
+    ]
     lut_outputs: Dict[str, List[int]] = {}
     for name, fn in unary_ops.items():
         print(f"  computing float16.{name} LUT...")
@@ -11248,6 +11291,12 @@ def main():
         op_tensors = build_float16_lut_output_tensors(f"float16.{name}", outputs)
         tensors.update(op_tensors)
         print(f"  float16.{name}: {len(op_tensors)} tensors")
+    for name in domain_ops:
+        print(f"  computing float16.{name} domain flags...")
+        flags = compute_float16_domain_flags(name)
+        flag_tensors = build_float16_lut_flag_tensors(f"float16.{name}", flags, flag_name="domain")
+        tensors.update(flag_tensors)
+        print(f"  float16.{name}.domain: {len(flag_tensors)} tensors")
 
     # float16.pow (ln -> mul -> exp)
     pow_tensors = build_float16_pow_tensors(mul_tensors,

calculator.py

@@ -506,12 +506,12 @@ class ThresholdCalculator:
         angle_mode = (angle_mode or "rad").lower()
         use_degrees = angle_mode.startswith("deg")
 
-        def run_prefix(prefix: str, inputs: Dict[str, object]) -> int:
+        def run_prefix(prefix: str, inputs: Dict[str, object], outputs: Optional[List[str]] = None) -> EvalResult:
             nonlocal total_elapsed, total_gates
-            res = self.evaluate_prefix(prefix, inputs, out_bits=16)
+            res = self.evaluate_prefix(prefix, inputs, out_bits=16, outputs=outputs)
             total_elapsed += res.elapsed_s
             total_gates += res.gates_evaluated
-            return bits_to_int(res.bits)
+            return res
 
         def const_to_bits(tok: str) -> int:
             if tok == "pi":
@@ -562,7 +562,16 @@ class ThresholdCalculator:
                     prefix = f"float16.{tok}_deg"
                 elif use_degrees and tok in ("asin", "acos", "atan"):
                     prefix = f"float16.{tok}_deg"
-                out = run_prefix(prefix, {"x": x})
+                if f"{prefix}.domain.weight" in self.tensors:
+                    outs = [f"{prefix}.out{i}" for i in range(16)] + [f"{prefix}.domain"]
+                    res = run_prefix(prefix, {"x": x}, outputs=outs)
+                    if res.bits[16] >= 0.5:
+                        x_val = float16_bits_to_float(x)
+                        raise RuntimeError(f"domain error: {tok}({x_val})")
+                    out = bits_to_int(res.bits[:16])
+                else:
+                    res = run_prefix(prefix, {"x": x})
+                    out = bits_to_int(res.bits)
                 stack.append(out)
                 continue
             if tok in {"+", "-", "*", "/", "^"}:
@@ -571,16 +580,16 @@ class ThresholdCalculator:
                 b = stack.pop()
                 a = stack.pop()
                 if tok == "+":
-                    out = run_prefix("float16.add", {"a": a, "b": b})
+                    out = bits_to_int(run_prefix("float16.add", {"a": a, "b": b}).bits)
                 elif tok == "-":
                     b_flip = b ^ 0x8000
-                    out = run_prefix("float16.sub", {"a": a, "b": b_flip})
+                    out = bits_to_int(run_prefix("float16.sub", {"a": a, "b": b_flip}).bits)
                 elif tok == "*":
-                    out = run_prefix("float16.mul", {"a": a, "b": b})
+                    out = bits_to_int(run_prefix("float16.mul", {"a": a, "b": b}).bits)
                 elif tok == "/":
-                    out = run_prefix("float16.div", {"a": a, "b": b})
+                    out = bits_to_int(run_prefix("float16.div", {"a": a, "b": b}).bits)
                 else:
-                    out = run_prefix("float16.pow", {"a": a, "b": b})
+                    out = bits_to_int(run_prefix("float16.pow", {"a": a, "b": b}).bits)
                 stack.append(out)
                 continue
             stack.append(const_to_bits(tok))
@@ -591,7 +600,7 @@ class ThresholdCalculator:
         out_bits = stack.pop()
         if total_gates == 0:
             if force_gate_eval:
-                out_bits = run_prefix("float16.add", {"a": out_bits, "b": 0})
+                out_bits = bits_to_int(run_prefix("float16.add", {"a": out_bits, "b": 0}).bits)
             else:
                 non_gate_events.append("constant_expression_no_gates")
 
@@ -618,12 +627,22 @@ class ThresholdCalculator:
         total_gates = 0
         non_gate_events: List[str] = []
 
-        def run_prefix(prefix: str, inputs: Dict[str, object]) -> int:
+        def run_prefix(prefix: str, inputs: Dict[str, object], outputs: Optional[List[str]] = None) -> EvalResult:
             nonlocal total_elapsed, total_gates
-            res = self.evaluate_prefix(prefix, inputs, out_bits=16)
+            res = self.evaluate_prefix(prefix, inputs, out_bits=16, outputs=outputs)
             total_elapsed += res.elapsed_s
             total_gates += res.gates_evaluated
-            return bits_to_int(res.bits)
+            return res
+
+        def run_unary(prefix: str, x_bits: int, fname: str) -> int:
+            if f"{prefix}.domain.weight" in self.tensors:
+                outs = [f"{prefix}.out{i}" for i in range(16)] + [f"{prefix}.domain"]
+                res = run_prefix(prefix, {"x": x_bits}, outputs=outs)
+                if res.bits[16] >= 0.5:
+                    x_val = float16_bits_to_float(x_bits)
+                    raise RuntimeError(f"domain error: {fname}({x_val})")
+                return bits_to_int(res.bits[:16])
+            return bits_to_int(run_prefix(prefix, {"x": x_bits}).bits)
 
         def eval_node(node: ast.AST) -> int:
             if isinstance(node, ast.Expression):
@@ -648,22 +667,22 @@ class ThresholdCalculator:
                     return eval_node(node.operand)
                 if isinstance(node.op, ast.USub):
                     x = eval_node(node.operand)
-                    return run_prefix("float16.neg", {"x": x})
+                    return bits_to_int(run_prefix("float16.neg", {"x": x}).bits)
                 raise RuntimeError("unsupported unary operator")
             if isinstance(node, ast.BinOp):
                 a = eval_node(node.left)
                 b = eval_node(node.right)
                 if isinstance(node.op, ast.Add):
-                    return run_prefix("float16.add", {"a": a, "b": b})
+                    return bits_to_int(run_prefix("float16.add", {"a": a, "b": b}).bits)
                 if isinstance(node.op, ast.Sub):
                     b_flip = b ^ 0x8000
-                    return run_prefix("float16.sub", {"a": a, "b": b_flip})
+                    return bits_to_int(run_prefix("float16.sub", {"a": a, "b": b_flip}).bits)
                 if isinstance(node.op, ast.Mult):
-                    return run_prefix("float16.mul", {"a": a, "b": b})
+                    return bits_to_int(run_prefix("float16.mul", {"a": a, "b": b}).bits)
                 if isinstance(node.op, ast.Div):
-                    return run_prefix("float16.div", {"a": a, "b": b})
+                    return bits_to_int(run_prefix("float16.div", {"a": a, "b": b}).bits)
                 if isinstance(node.op, ast.Pow):
-                    return run_prefix("float16.pow", {"a": a, "b": b})
+                    return bits_to_int(run_prefix("float16.pow", {"a": a, "b": b}).bits)
                 raise RuntimeError("unsupported binary operator")
             if isinstance(node, ast.Call):
                 if not isinstance(node.func, ast.Name):
@@ -673,57 +692,51 @@ class ThresholdCalculator:
                     raise RuntimeError(f"{fname} expects one argument")
                 x = eval_node(node.args[0])
                 if fname == "sqrt":
-                    return run_prefix("float16.sqrt", {"x": x})
+                    return run_unary("float16.sqrt", x, fname)
                 if fname == "rsqrt":
-                    return run_prefix("float16.rsqrt", {"x": x})
+                    return run_unary("float16.rsqrt", x, fname)
                 if fname == "exp":
-                    return run_prefix("float16.exp", {"x": x})
+                    return run_unary("float16.exp", x, fname)
                 if fname in ("ln", "log"):
-                    return run_prefix("float16.ln", {"x": x})
+                    return run_unary("float16.ln", x, fname)
                 if fname == "log2":
-                    return run_prefix("float16.log2", {"x": x})
+                    return run_unary("float16.log2", x, fname)
                 if fname == "log10":
-                    return run_prefix("float16.log10", {"x": x})
+                    return run_unary("float16.log10", x, fname)
                 if fname == "sin":
                     prefix = "float16.sin_deg" if use_degrees else "float16.sin"
-                    return run_prefix(prefix, {"x": x})
+                    return run_unary(prefix, x, fname)
                 if fname == "cos":
                     prefix = "float16.cos_deg" if use_degrees else "float16.cos"
-                    return run_prefix(prefix, {"x": x})
+                    return run_unary(prefix, x, fname)
                 if fname == "tan":
                     prefix = "float16.tan_deg" if use_degrees else "float16.tan"
-                    return run_prefix(prefix, {"x": x})
+                    return run_unary(prefix, x, fname)
                 if fname == "tanh":
-                    return run_prefix("float16.tanh", {"x": x})
+                    return run_unary("float16.tanh", x, fname)
                 if fname == "asin":
                     prefix = "float16.asin_deg" if use_degrees else "float16.asin"
-                    return run_prefix(prefix, {"x": x})
+                    return run_unary(prefix, x, fname)
                 if fname == "acos":
                     prefix = "float16.acos_deg" if use_degrees else "float16.acos"
-                    return run_prefix(prefix, {"x": x})
+                    return run_unary(prefix, x, fname)
                 if fname == "atan":
                     prefix = "float16.atan_deg" if use_degrees else "float16.atan"
-                    return run_prefix(prefix, {"x": x})
-                if fname == "asin":
-                    return run_prefix("float16.asin", {"x": x})
-                if fname == "acos":
-                    return run_prefix("float16.acos", {"x": x})
-                if fname == "atan":
-                    return run_prefix("float16.atan", {"x": x})
+                    return run_unary(prefix, x, fname)
                 if fname == "sinh":
-                    return run_prefix("float16.sinh", {"x": x})
+                    return run_unary("float16.sinh", x, fname)
                 if fname == "cosh":
-                    return run_prefix("float16.cosh", {"x": x})
+                    return run_unary("float16.cosh", x, fname)
                 if fname == "floor":
-                    return run_prefix("float16.floor", {"x": x})
+                    return run_unary("float16.floor", x, fname)
                 if fname == "ceil":
-                    return run_prefix("float16.ceil", {"x": x})
+                    return run_unary("float16.ceil", x, fname)
                 if fname == "round":
-                    return run_prefix("float16.round", {"x": x})
+                    return run_unary("float16.round", x, fname)
                 if fname == "abs":
-                    return run_prefix("float16.abs", {"x": x})
+                    return run_unary("float16.abs", x, fname)
                 if fname == "neg":
-                    return run_prefix("float16.neg", {"x": x})
+                    return run_unary("float16.neg", x, fname)
                 raise RuntimeError(f"unsupported function: {fname}")
             raise RuntimeError("unsupported expression")
 
@@ -731,7 +744,7 @@ class ThresholdCalculator:
         if total_gates == 0:
             if force_gate_eval:
                 # Route constants through float16.add with +0 to ensure gate-level evaluation.
-                out_bits = run_prefix("float16.add", {"a": out_bits, "b": 0})
+                out_bits = bits_to_int(run_prefix("float16.add", {"a": out_bits, "b": 0}).bits)
             else:
                 non_gate_events.append("constant_expression_no_gates")
         return EvalResult(

eval.py

@@ -716,6 +716,33 @@ def eval_float16_lut_outputs(ctx: EvalContext, op_prefix: str,
     return outputs
 
 
+def eval_float16_lut_flag(ctx: EvalContext, op_prefix: str,
+                          bits: List[float],
+                          flag: str = "domain",
+                          match_prefix: str = "float16.lut") -> float:
+    """Evaluate a LUT-backed 1-bit flag using direct LUT indexing."""
+    idx = bits_to_int(bits)
+    match_gate = f"{match_prefix}.match{idx:04x}"
+    for suffix in (".weight", ".bias", ".inputs"):
+        key = match_gate + suffix
+        if key in ctx.tensors:
+            ctx.tested_tensors.add(key)
+
+    gate = f"{op_prefix}.{flag}"
+    weight_key = f"{gate}.weight"
+    bias_key = f"{gate}.bias"
+    inputs_key = f"{gate}.inputs"
+    ctx.tested_tensors.add(weight_key)
+    if bias_key in ctx.tensors:
+        ctx.tested_tensors.add(bias_key)
+    if inputs_key in ctx.tensors:
+        ctx.tested_tensors.add(inputs_key)
+
+    weight = ctx.tensors[weight_key][idx].item()
+    bias = ctx.tensors.get(bias_key, torch.tensor([0.0])).item()
+    return 1.0 if (weight + bias) >= 0 else 0.0
+
+
 def build_float16_pairs(rng: random.Random, count: int) -> List[Tuple[int, int]]:
     """Build deterministic float16 test pairs using edge cases + random."""
     edges = [
@@ -892,6 +919,20 @@ def float16_expected_bits_pow(a_bits: int, b_bits: int) -> Tuple[int, bool]:
     return float_to_int(float(out)), False
 
 
+def float16_expected_domain(op: str, a_bits: int) -> int:
+    """Compute expected domain flag (1=invalid) for unary ops."""
+    a = float16_int_to_float(a_bits)
+    if a != a:
+        return 1
+    if op in ("sqrt", "rsqrt") and a < 0:
+        return 1
+    if op in ("ln", "log2", "log10") and a <= 0:
+        return 1
+    if op in ("asin", "acos", "asin_deg", "acos_deg") and abs(a) > 1.0:
+        return 1
+    return 0
+
+
 # =============================================================================
 # BOOLEAN GATE TESTS
 # =============================================================================
@@ -2760,6 +2801,44 @@ def test_float16_unary(ctx: EvalContext) -> List[TestResult]:
     return results
 
 
+def test_float16_domain_flags(ctx: EvalContext) -> List[TestResult]:
+    """Test float16 domain flag outputs."""
+    results: List[TestResult] = []
+    rng = random.Random(1337)
+    values = build_float16_values(rng, 256)
+    ops = [
+        ("float16.sqrt", "sqrt"),
+        ("float16.rsqrt", "rsqrt"),
+        ("float16.ln", "ln"),
+        ("float16.log2", "log2"),
+        ("float16.log10", "log10"),
+        ("float16.asin", "asin"),
+        ("float16.acos", "acos"),
+        ("float16.asin_deg", "asin_deg"),
+        ("float16.acos_deg", "acos_deg"),
+    ]
+    for prefix, op in ops:
+        if f"{prefix}.domain.weight" not in ctx.tensors:
+            continue
+        passed, total = 0, 0
+        failures: List[Dict[str, Any]] = []
+        for a_bits in values:
+            bits_list = [float((a_bits >> i) & 1) for i in range(16)]
+            actual = eval_float16_lut_flag(ctx, prefix, bits_list)
+            expected = float16_expected_domain(op, a_bits)
+            total += 1
+            if int(actual) == expected:
+                passed += 1
+            elif len(failures) < 8:
+                failures.append({
+                    "input": hex(a_bits),
+                    "actual": int(actual),
+                    "expected": expected,
+                })
+        results.append(TestResult(f"{prefix}.domain", passed, total, failures))
+    return results
+
+
 def test_float16_pow(ctx: EvalContext) -> List[TestResult]:
     """Test float16.pow (defined as exp(b * ln(a)))."""
     results: List[TestResult] = []
@@ -2855,6 +2934,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_domain": ("Float16 - Domain Flags", test_float16_domain_flags),
     "float16_pow": ("Float16 - Pow", test_float16_pow),
 }