Add gate-level calculator UI and CLI expr mode

- Add calculator.py expression evaluator with JSON/strict output for float16 gate-only eval

- Add Gradio Space app.py + requirements.txt for proof-of-concept UI

- Update README with Space notes and expanded TODO/caveats

README.md

@@ -183,6 +183,33 @@ python eval.py --coverage --inputs-coverage
 
 `--inputs-coverage` evaluates gates via their `.inputs` tensors using seeded external inputs and explicit overrides, and fails if inputs cannot be resolved. This is for coverage and routing sanity, not a correctness proof.
 
+## Python Calculator Interface (Gate-Level)
+
+`calculator.py` provides a pure gate-level evaluator that uses only `.inputs` + `.weight`/`.bias` (no arithmetic shortcuts). This is intended as a rigorous proof-of-concept for using the weights as a calculator.
+Expression mode routes even constants through a circuit (via `float16.add` with +0) to ensure gate-level evaluation.
+
+Examples:
+
+```bash
+python calculator.py float16.add 1.0 2.0
+python calculator.py float16.sqrt 2.0
+python calculator.py float16.add --inputs a=0x3c00 b=0x4000 --hex
+python calculator.py --expr "1 + 1"
+python calculator.py "sin(pi / 2)"
+python calculator.py --expr "1 + 1" --json
+python calculator.py "pi" --strict
+```
+
+Programmatic use:
+
+```python
+from calculator import ThresholdCalculator
+
+calc = ThresholdCalculator("arithmetic.safetensors")
+out, _ = calc.float16_binop("add", 1.0, 2.0)
+print(out)
+```
+
 ## Development History
 
 Started as an 8-bit CPU project. Built boolean gates, then arithmetic (adders -> multipliers -> dividers), then CPU control logic. The CPU worked but the arithmetic core turned out to be the useful part, so it was extracted.
@@ -205,14 +232,33 @@ This began as an attempt to build a complete threshold-logic CPU. The CPU is in
 - Boolean, threshold, modular, pattern recognition, combinational
 
 **Next:**
-- TBD
+- Add a full scientific calculator function set (log10, asin/acos/atan, sinh/cosh, etc.) as gate-level circuits.
+- Add 32-bit integer arithmetic circuits (add/sub/shift/compare, then mul/div).
+- Add higher precision modes (float32 or fixed-point) for typical calculator accuracy.
 
 **Cleanup:**
 - None (8-bit arithmetic scaffolding removed)
 
 ## TODO (Unified)
 
-None.
+- Scientific functions missing from current weights (log10, asin/acos/atan, sinh/cosh, floor/ceil/round, etc.).
+- 32-bit integer circuits and an int32 calculator mode.
+- Degree-mode trig and implicit multiplication parsing.
+- Higher-precision arithmetic (float32 or fixed-point).
+- Complex-number support (or explicit domain errors).
+
+## Hugging Face Space (Proof of Concept)
+
+A minimal Space UI is included in `app.py`. It uses the gate-level evaluator only (no arithmetic shortcuts) and exposes a normal calculator-style expression input.
+
+Example expressions:
+- `1 + 1`
+- `sin(pi / 2)`
+- `exp(ln(2))`
+
+Notes:
+- All results are **float16** (IEEE-754 half) and may be rounded.
+- `pow` uses the `exp(b*ln(a))` definition; negative bases yield NaN.
 
 ## License
 

app.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Space: gate-level calculator for threshold-calculus.
+"""
+
+import gradio as gr
+
+from calculator import ThresholdCalculator, bits_to_int, float16_bits_to_float
+
+
+calc = ThresholdCalculator("arithmetic.safetensors")
+
+
+def eval_expression(expr: str):
+    expr = (expr or "").strip()
+    if not expr:
+        return "", "", "", ""
+    try:
+        result = calc.evaluate_expr(expr)
+        out_int = bits_to_int(result.bits)
+        out_float = float16_bits_to_float(out_int)
+        return (
+            f"{out_float}",
+            f"0x{out_int:04x}",
+            f"{result.gates_evaluated}",
+            f"{result.elapsed_s:.4f}s",
+        )
+    except Exception as exc:
+        return f"ERROR: {exc}", "", "", ""
+
+
+with gr.Blocks(title="Threshold Calculus Calculator") as demo:
+    gr.Markdown(
+        "# Threshold Calculus Calculator\n"
+        "Pure gate-level evaluation of float16 arithmetic (IEEE-754 half). "
+        "All results are float16 and may be rounded."
+    )
+    expr = gr.Textbox(
+        label="Expression",
+        placeholder="e.g., 1 + 1, sin(pi / 2), exp(ln(2))",
+    )
+    run = gr.Button("Evaluate")
+    out_val = gr.Textbox(label="Float16 Result", interactive=False)
+    out_bits = gr.Textbox(label="Result Bits (hex)", interactive=False)
+    out_gates = gr.Textbox(label="Gates Evaluated", interactive=False)
+    out_time = gr.Textbox(label="Elapsed", interactive=False)
+
+    run.click(eval_expression, inputs=[expr], outputs=[out_val, out_bits, out_gates, out_time])
+    expr.submit(eval_expression, inputs=[expr], outputs=[out_val, out_bits, out_gates, out_time])
+
+    gr.Markdown(
+        "Notes:\n"
+        "- Functions: sin, cos, tan, tanh, sqrt, rsqrt, exp, ln, log2, abs, neg\n"
+        "- Constants: pi, e, inf, nan\n"
+        "- Pow uses exp(b*ln(a)); negative bases yield NaN."
+    )
+
+if __name__ == "__main__":
+    demo.launch()

calculator.py

@@ -0,0 +1,568 @@
+#!/usr/bin/env python3
+"""
+Threshold-calculus gate-level calculator.
+
+Pure evaluation via .inputs + .weight/.bias only. No arithmetic shortcuts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import math
+import struct
+import time
+from dataclasses import dataclass, field
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple
+
+import torch
+from safetensors import safe_open
+
+
+def int_to_bits(val: int, width: int) -> List[float]:
+    """Convert integer to LSB-first bit list of length width."""
+    return [float((val >> i) & 1) for i in range(width)]
+
+
+def bits_to_int(bits: Sequence[float]) -> int:
+    """Convert LSB-first bit list to integer."""
+    return sum((1 << i) for i, b in enumerate(bits) if b >= 0.5)
+
+
+def float_to_float16_bits(val: float) -> int:
+    """Convert float to IEEE-754 float16 bits (with canonical NaN)."""
+    try:
+        packed = struct.pack(">e", float(val))
+        return struct.unpack(">H", packed)[0]
+    except (OverflowError, struct.error):
+        if val == float("inf"):
+            return 0x7C00
+        if val == float("-inf"):
+            return 0xFC00
+        if val != val:
+            return 0x7E00
+        return 0x7BFF if val > 0 else 0xFBFF
+
+
+def float16_bits_to_float(bits: int) -> float:
+    """Interpret 16-bit int as IEEE-754 float16."""
+    packed = struct.pack(">H", bits & 0xFFFF)
+    return struct.unpack(">e", packed)[0]
+
+
+def parse_external_name(name: str) -> Tuple[Optional[str], Optional[int], Optional[str]]:
+    """
+    Parse an external signal name into (base, index, full_key).
+    Examples:
+      "$a" -> ("a", None, "$a")
+      "float16.add.$a[3]" -> ("a", 3, "float16.add.$a")
+    """
+    if "$" not in name:
+        return None, None, None
+    full_key = name.split("[", 1)[0]
+    base_part = name.split("$", 1)[1]
+    base = base_part.split("[", 1)[0]
+    idx = None
+    if "[" in base_part and "]" in base_part:
+        try:
+            idx = int(base_part.split("[", 1)[1].split("]", 1)[0])
+        except ValueError:
+            idx = None
+    return base, idx, full_key
+
+
+def resolve_alias_target(name: str, gates: set) -> Optional[str]:
+    """Resolve common alias signal names to actual gate names."""
+    if name in gates:
+        return name
+    cand = name + ".layer2"
+    if cand in gates:
+        return cand
+    if name.endswith(".sum"):
+        cand = name[:-4] + ".xor2.layer2"
+        if cand in gates:
+            return cand
+    if name.endswith(".cout"):
+        for suffix in [".or_carry", ".carry_or"]:
+            cand = name[:-5] + suffix
+            if cand in gates:
+                return cand
+    return None
+
+
+def normalize_expr(expr: str) -> str:
+    """Normalize user-facing calculator syntax to Python AST syntax."""
+    expr = expr.replace("π", "pi")
+    expr = expr.replace("×", "*").replace("÷", "/").replace("−", "-")
+    if "^" in expr:
+        expr = expr.replace("^", "**")
+    return expr
+
+
+def looks_like_expression(text: str) -> bool:
+    tokens = ["+", "-", "*", "/", "(", ")", "^", "pi", "π"]
+    return any(tok in text for tok in tokens)
+
+
+@dataclass
+class EvalResult:
+    bits: List[float]
+    elapsed_s: float
+    gates_evaluated: int
+    non_gate_events: List[str] = field(default_factory=list)
+
+
+class ThresholdCalculator:
+    def __init__(self, model_path: str = "./arithmetic.safetensors") -> None:
+        self.model_path = model_path
+        self.tensors: Dict[str, torch.Tensor] = {}
+        self.gates: List[str] = []
+        self.name_to_id: Dict[str, int] = {}
+        self.id_to_name: Dict[int, str] = {}
+        self._gate_inputs: Dict[str, torch.Tensor] = {}
+        self._gate_set: set = set()
+        self._alias_to_gate: Dict[int, int] = {}
+        self._gate_to_alias: Dict[int, List[int]] = {}
+        self._id_to_gate: Dict[int, str] = {}
+        self._topo_cache: Dict[Tuple[str, Tuple[str, ...]], List[str]] = {}
+        self._load()
+
+    def _load(self) -> None:
+        with safe_open(self.model_path, framework="pt") as f:
+            for name in f.keys():
+                self.tensors[name] = f.get_tensor(name)
+            metadata = f.metadata()
+            if metadata and "signal_registry" in metadata:
+                registry_raw = json.loads(metadata["signal_registry"])
+                self.id_to_name = {int(k): v for k, v in registry_raw.items()}
+                self.name_to_id = {v: int(k) for k, v in registry_raw.items()}
+        self.gates = sorted({k.rsplit(".", 1)[0] for k in self.tensors.keys() if k.endswith(".weight")})
+        self._gate_set = set(self.gates)
+        for gate in self.gates:
+            inputs_key = f"{gate}.inputs"
+            if inputs_key in self.tensors:
+                self._gate_inputs[gate] = self.tensors[inputs_key].to(dtype=torch.long)
+        self._build_alias_maps()
+        for gate in self.gates:
+            gid = self.name_to_id.get(gate)
+            if gid is not None:
+                self._id_to_gate[gid] = gate
+
+    def _build_alias_maps(self) -> None:
+        gates = set(self.gates)
+        alias_to_gate: Dict[int, int] = {}
+        gate_to_alias: Dict[int, List[int]] = {}
+        for name, sid in self.name_to_id.items():
+            if name in ("#0", "#1"):
+                continue
+            if name.startswith("$") or ".$" in name:
+                continue
+            if name in gates:
+                continue
+            target = resolve_alias_target(name, gates)
+            if not target:
+                continue
+            target_id = self.name_to_id.get(target)
+            if target_id is None:
+                continue
+            alias_to_gate[sid] = target_id
+            gate_to_alias.setdefault(target_id, []).append(sid)
+        self._alias_to_gate = alias_to_gate
+        self._gate_to_alias = gate_to_alias
+
+    def _signal_to_gate(self, sid: int) -> Optional[str]:
+        if sid in self._id_to_gate:
+            return self._id_to_gate[sid]
+        alias_target = self._alias_to_gate.get(sid)
+        if alias_target is not None:
+            return self._id_to_gate.get(alias_target)
+        return None
+
+    def _default_outputs(self, prefix: str, out_bits: int) -> List[str]:
+        if f"{prefix}.out0.weight" in self.tensors:
+            return [f"{prefix}.out{i}" for i in range(out_bits)]
+        if prefix in self._gate_set:
+            return [prefix]
+        raise RuntimeError(f"{prefix}: no outputs found")
+
+    def _collect_required_gates(self, output_gates: Sequence[str]) -> List[str]:
+        required: set = set()
+        stack = list(output_gates)
+        while stack:
+            gate = stack.pop()
+            if gate in required:
+                continue
+            if gate not in self._gate_inputs:
+                raise RuntimeError(f"{gate}: missing .inputs tensor")
+            required.add(gate)
+            input_ids = self._gate_inputs[gate]
+            for sid in input_ids.tolist():
+                dep_gate = self._signal_to_gate(int(sid))
+                if dep_gate is not None and dep_gate not in required:
+                    stack.append(dep_gate)
+        return sorted(required)
+
+    def _topo_sort(self, gates: Sequence[str]) -> List[str]:
+        key = tuple(gates)
+        cache_key = ("__set__", key)
+        if cache_key in self._topo_cache:
+            return self._topo_cache[cache_key]
+        gate_set = set(gates)
+        deps: Dict[str, set] = {g: set() for g in gates}
+        rev: Dict[str, List[str]] = {g: [] for g in gates}
+        for gate in gates:
+            input_ids = self._gate_inputs[gate].tolist()
+            for sid in input_ids:
+                dep_gate = self._signal_to_gate(int(sid))
+                if dep_gate is not None and dep_gate in gate_set:
+                    deps[gate].add(dep_gate)
+                    rev[dep_gate].append(gate)
+        queue = sorted([g for g in gates if not deps[g]])
+        order: List[str] = []
+        while queue:
+            g = queue.pop(0)
+            order.append(g)
+            for child in rev[g]:
+                deps[child].remove(g)
+                if not deps[child]:
+                    queue.append(child)
+                    queue.sort()
+        if len(order) != len(gates):
+            raise RuntimeError("Dependency cycle or unresolved inputs in gate graph")
+        self._topo_cache[cache_key] = order
+        return order
+
+    def _required_externals(self, gates: Iterable[str]) -> List[int]:
+        externals: set = set()
+        for gate in gates:
+            for sid in self._gate_inputs[gate].tolist():
+                sid = int(sid)
+                name = self.id_to_name.get(sid, "")
+                if name.startswith("$") or ".$" in name:
+                    externals.add(sid)
+        return sorted(externals)
+
+    def _normalize_inputs(self, required_externals: List[int], inputs: Dict[str, object]) -> Dict[int, float]:
+        exact: Dict[str, object] = {}
+        base_inputs: Dict[str, object] = {}
+        for key, val in inputs.items():
+            if "$" in key:
+                exact[key] = val
+            else:
+                base_inputs[key] = val
+
+        width_full: Dict[str, int] = {}
+        width_base: Dict[str, int] = {}
+        for sid in required_externals:
+            name = self.id_to_name.get(sid, "")
+            base, idx, full_key = parse_external_name(name)
+            if base is None or full_key is None:
+                continue
+            w = (idx + 1) if idx is not None else 1
+            width_full[full_key] = max(width_full.get(full_key, 1), w)
+            width_base[base] = max(width_base.get(base, 1), w)
+
+        def ensure_bit_list(val: object, width: int) -> List[float]:
+            if isinstance(val, (list, tuple)):
+                bits = [float(b) for b in val]
+                if len(bits) < width:
+                    raise RuntimeError(f"input width {len(bits)} < required {width}")
+                return bits
+            if isinstance(val, int):
+                return int_to_bits(val, width)
+            if isinstance(val, float):
+                if width != 16:
+                    raise RuntimeError("float inputs only supported for 16-bit values")
+                bits_int = float_to_float16_bits(val)
+                return int_to_bits(bits_int, width)
+            raise RuntimeError("inputs must be list/tuple, int, or float16-compatible float")
+
+        normalized: Dict[int, float] = {}
+        for sid in required_externals:
+            name = self.id_to_name.get(sid, "")
+            base, idx, full_key = parse_external_name(name)
+            if base is None or full_key is None:
+                continue
+            if full_key in exact:
+                bits = ensure_bit_list(exact[full_key], width_full[full_key])
+            elif base in base_inputs:
+                bits = ensure_bit_list(base_inputs[base], width_base[base])
+            else:
+                raise RuntimeError(f"missing external input for {name}")
+            use_idx = idx if idx is not None else 0
+            normalized[sid] = float(bits[use_idx])
+        return normalized
+
+    def evaluate_prefix(
+        self,
+        prefix: str,
+        inputs: Dict[str, object],
+        out_bits: int = 16,
+        outputs: Optional[List[str]] = None,
+    ) -> EvalResult:
+        output_gates = outputs if outputs is not None else self._default_outputs(prefix, out_bits)
+        required_gates = self._collect_required_gates(output_gates)
+        gate_order = self._topo_sort(required_gates)
+        required_externals = self._required_externals(required_gates)
+
+        num_signals = len(self.id_to_name)
+        signals = torch.full((num_signals,), float("nan"))
+        if "#0" in self.name_to_id:
+            signals[self.name_to_id["#0"]] = 0.0
+        if "#1" in self.name_to_id:
+            signals[self.name_to_id["#1"]] = 1.0
+
+        seeded = self._normalize_inputs(required_externals, inputs)
+        for sid, val in seeded.items():
+            signals[sid] = val
+
+        start = time.time()
+        evaluated = 0
+        for gate in gate_order:
+            input_ids = self._gate_inputs[gate]
+            input_vals = signals[input_ids]
+            if torch.isnan(input_vals).any():
+                raise RuntimeError(f"{gate}: unresolved inputs")
+            weight = self.tensors[f"{gate}.weight"].float()
+            bias = self.tensors.get(f"{gate}.bias", torch.tensor([0.0])).float().item()
+            total = torch.dot(weight, input_vals.float()).item() + bias
+            out = 1.0 if total >= 0 else 0.0
+            gate_id = self.name_to_id.get(gate)
+            if gate_id is not None:
+                signals[gate_id] = out
+                for alias_id in self._gate_to_alias.get(gate_id, []):
+                    signals[alias_id] = out
+            evaluated += 1
+        elapsed = time.time() - start
+
+        bits: List[float] = []
+        for gate in output_gates:
+            gid = self.name_to_id.get(gate)
+            if gid is None or torch.isnan(signals[gid]):
+                raise RuntimeError(f"{prefix}: missing output {gate}")
+            bits.append(float(signals[gid]))
+        return EvalResult(bits=bits, elapsed_s=elapsed, gates_evaluated=evaluated)
+
+    # Float16 convenience wrappers (pure gate evaluation)
+    def float16_binop(self, op: str, a: float, b: float) -> Tuple[float, EvalResult]:
+        prefix = f"float16.{op}"
+        a_bits = int_to_bits(float_to_float16_bits(a), 16)
+        b_bits = int_to_bits(float_to_float16_bits(b), 16)
+        if op == "sub":
+            # float16.sub is defined as add with flipped sign bit on b
+            b_bits[15] = 1.0 - b_bits[15]
+        result = self.evaluate_prefix(prefix, {"a": a_bits, "b": b_bits}, out_bits=16)
+        out_int = bits_to_int(result.bits)
+        return float16_bits_to_float(out_int), result
+
+    def float16_unary(self, op: str, x: float) -> Tuple[float, EvalResult]:
+        prefix = f"float16.{op}"
+        x_bits = int_to_bits(float_to_float16_bits(x), 16)
+        # Unary LUT ops are wired through float16.lut.$x
+        result = self.evaluate_prefix(prefix, {"x": x_bits}, out_bits=16)
+        out_int = bits_to_int(result.bits)
+        return float16_bits_to_float(out_int), result
+
+    def float16_pow(self, a: float, b: float) -> Tuple[float, EvalResult]:
+        prefix = "float16.pow"
+        a_bits = int_to_bits(float_to_float16_bits(a), 16)
+        b_bits = int_to_bits(float_to_float16_bits(b), 16)
+        result = self.evaluate_prefix(prefix, {"a": a_bits, "b": b_bits}, out_bits=16)
+        out_int = bits_to_int(result.bits)
+        return float16_bits_to_float(out_int), result
+
+    def evaluate_expr(self, expr: str, force_gate_eval: bool = True) -> EvalResult:
+        """Evaluate a calculator expression using float16 circuits."""
+        expr = normalize_expr(expr)
+        tree = ast.parse(expr, mode="eval")
+
+        total_elapsed = 0.0
+        total_gates = 0
+        non_gate_events: List[str] = []
+
+        def run_prefix(prefix: str, inputs: Dict[str, object]) -> int:
+            nonlocal total_elapsed, total_gates
+            res = self.evaluate_prefix(prefix, inputs, out_bits=16)
+            total_elapsed += res.elapsed_s
+            total_gates += res.gates_evaluated
+            return bits_to_int(res.bits)
+
+        def eval_node(node: ast.AST) -> int:
+            if isinstance(node, ast.Expression):
+                return eval_node(node.body)
+            if isinstance(node, ast.Constant):
+                if isinstance(node.value, (int, float)):
+                    return float_to_float16_bits(float(node.value))
+                raise RuntimeError("unsupported literal")
+            if isinstance(node, ast.Name):
+                name = node.id
+                if name == "pi":
+                    return float_to_float16_bits(math.pi)
+                if name == "e":
+                    return float_to_float16_bits(math.e)
+                if name == "inf":
+                    return float_to_float16_bits(float("inf"))
+                if name == "nan":
+                    return float_to_float16_bits(float("nan"))
+                raise RuntimeError(f"unknown identifier: {name}")
+            if isinstance(node, ast.UnaryOp):
+                if isinstance(node.op, ast.UAdd):
+                    return eval_node(node.operand)
+                if isinstance(node.op, ast.USub):
+                    x = eval_node(node.operand)
+                    return run_prefix("float16.neg", {"x": x})
+                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})
+                if isinstance(node.op, ast.Sub):
+                    b_flip = b ^ 0x8000
+                    return run_prefix("float16.sub", {"a": a, "b": b_flip})
+                if isinstance(node.op, ast.Mult):
+                    return run_prefix("float16.mul", {"a": a, "b": b})
+                if isinstance(node.op, ast.Div):
+                    return run_prefix("float16.div", {"a": a, "b": b})
+                if isinstance(node.op, ast.Pow):
+                    return run_prefix("float16.pow", {"a": a, "b": b})
+                raise RuntimeError("unsupported binary operator")
+            if isinstance(node, ast.Call):
+                if not isinstance(node.func, ast.Name):
+                    raise RuntimeError("unsupported function")
+                fname = node.func.id
+                if len(node.args) != 1:
+                    raise RuntimeError(f"{fname} expects one argument")
+                x = eval_node(node.args[0])
+                if fname == "sqrt":
+                    return run_prefix("float16.sqrt", {"x": x})
+                if fname == "rsqrt":
+                    return run_prefix("float16.rsqrt", {"x": x})
+                if fname == "exp":
+                    return run_prefix("float16.exp", {"x": x})
+                if fname in ("ln", "log"):
+                    return run_prefix("float16.ln", {"x": x})
+                if fname == "log2":
+                    return run_prefix("float16.log2", {"x": x})
+                if fname == "sin":
+                    return run_prefix("float16.sin", {"x": x})
+                if fname == "cos":
+                    return run_prefix("float16.cos", {"x": x})
+                if fname == "tan":
+                    return run_prefix("float16.tan", {"x": x})
+                if fname == "tanh":
+                    return run_prefix("float16.tanh", {"x": x})
+                if fname == "abs":
+                    return run_prefix("float16.abs", {"x": x})
+                if fname == "neg":
+                    return run_prefix("float16.neg", {"x": x})
+                raise RuntimeError(f"unsupported function: {fname}")
+            raise RuntimeError("unsupported expression")
+
+        out_bits = eval_node(tree)
+        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})
+            else:
+                non_gate_events.append("constant_expression_no_gates")
+        return EvalResult(
+            bits=int_to_bits(out_bits, 16),
+            elapsed_s=total_elapsed,
+            gates_evaluated=total_gates,
+            non_gate_events=non_gate_events,
+        )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Gate-level calculator for threshold-calculus")
+    parser.add_argument("prefix", nargs="?", default="", help="Circuit prefix (e.g., float16.add) or expression")
+    parser.add_argument("values", nargs="*", help="Input values (float for float16, int otherwise)")
+    parser.add_argument("--model", default="./arithmetic.safetensors", help="Path to safetensors model")
+    parser.add_argument("--out-bits", type=int, default=16, help="Number of output bits")
+    parser.add_argument("--inputs", nargs="*", help="Explicit inputs as name=value (e.g., a=0x3c00)")
+    parser.add_argument("--hex", action="store_true", help="Parse numeric inputs as hex")
+    parser.add_argument("--expr", help="Evaluate expression using float16 circuits")
+    parser.add_argument("--json", action="store_true", help="Output JSON result")
+    parser.add_argument("--strict", action="store_true", help="Warn if any non-gate path is used")
+    args = parser.parse_args()
+
+    calc = ThresholdCalculator(args.model)
+
+    def emit_result(prefix: str, out_int: int, result: EvalResult, expr: Optional[str] = None) -> int:
+        out_float = float16_bits_to_float(out_int) if len(result.bits) == 16 else None
+        if args.strict and result.non_gate_events:
+            print(f"STRICT WARNING: non-gate path used: {result.non_gate_events}")
+        if args.json:
+            payload = {
+                "prefix": prefix,
+                "expr": expr,
+                "bits": f"0x{out_int:04x}",
+                "float16": out_float,
+                "gates": result.gates_evaluated,
+                "elapsed_s": result.elapsed_s,
+                "non_gate_events": result.non_gate_events,
+            }
+            print(json.dumps(payload))
+        else:
+            if expr:
+                print(f"expr={expr}")
+            print(f"bits=0x{out_int:04x} float16={out_float}")
+            print(f"gates={result.gates_evaluated} elapsed_s={result.elapsed_s:.4f}")
+        return 0
+
+    if args.expr or (args.prefix and not args.values and not args.inputs and looks_like_expression(args.prefix)):
+        expr = args.expr if args.expr else args.prefix
+        result = calc.evaluate_expr(expr)
+        out_int = bits_to_int(result.bits)
+        return emit_result("expr", out_int, result, expr=expr)
+
+    if not args.prefix:
+        raise RuntimeError("Provide a circuit prefix or use --expr")
+
+    if args.inputs:
+        inputs: Dict[str, object] = {}
+        for item in args.inputs:
+            if "=" not in item:
+                raise RuntimeError("inputs must be name=value")
+            key, val = item.split("=", 1)
+            if args.hex or val.startswith("0x"):
+                inputs[key] = int(val, 16)
+            else:
+                try:
+                    inputs[key] = int(val)
+                except ValueError:
+                    inputs[key] = float(val)
+        result = calc.evaluate_prefix(args.prefix, inputs, out_bits=args.out_bits)
+        out_int = bits_to_int(result.bits)
+        print(f"bits={result.bits}")
+        print(f"int=0x{out_int:0{(args.out_bits + 3) // 4}x}")
+        if args.out_bits == 16:
+            pass
+        return emit_result(args.prefix, out_int, result)
+
+    # Convenience mode for float16 binary/unary
+    prefix = args.prefix
+    if prefix.startswith("float16."):
+        op = prefix.split(".", 1)[1]
+        if op == "pow":
+            if len(args.values) != 2:
+                raise RuntimeError("float16.pow requires two values")
+            out, result = calc.float16_pow(float(args.values[0]), float(args.values[1]))
+        elif op in ("add", "sub", "mul", "div"):
+            if len(args.values) != 2:
+                raise RuntimeError(f"{prefix} requires two values")
+            out, result = calc.float16_binop(op, float(args.values[0]), float(args.values[1]))
+        else:
+            if len(args.values) != 1:
+                raise RuntimeError(f"{prefix} requires one value")
+            out, result = calc.float16_unary(op, float(args.values[0]))
+        out_bits = bits_to_int(result.bits)
+        return emit_result(prefix, out_bits, result)
+
+    raise RuntimeError("Provide --inputs for non-float16 circuits")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+torch
+safetensors