Add build functions for float16 sub/mul/div/toint/fromint

Build functions define gate structures for:
- float16.sub: ~34 tensors (sign flip + passthrough)
- float16.mul: ~1532 tensors (11x11 multiplier + exp add)
- float16.div: ~3708 tensors (iterative division)
- float16.toint: ~788 tensors (shift + sign handling)
- float16.fromint: ~956 tensors (CLZ + normalize)

Inference functions still needed to wire gate inputs.

TODO.md

@@ -8,13 +8,13 @@
 - [x] `float16.cmp` -- comparison a > b (14 gates, 113/113 tests)
 - [x] `float16.normalize` -- CLZ-based shift calculator (51 gates, 14/14 tests)
 - [x] `float16.add` -- IEEE 754 addition (~998 gates, 125/125 tests)
-- [ ] `float16.sub` -- subtraction (add with negated operand)
-- [ ] `float16.mul` -- multiplication
-- [ ] `float16.div` -- division
+- [ ] `float16.sub` -- IEEE 754 subtraction (build: done, inference: pending)
+- [ ] `float16.mul` -- IEEE 754 multiplication (build: done, inference: pending)
+- [ ] `float16.div` -- IEEE 754 division (build: done, inference: pending)
+- [ ] `float16.toint` -- float16 to int16 (build: done, inference: pending)
+- [ ] `float16.fromint` -- int16 to float16 (build: done, inference: pending)
 - [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` -- 8-bit count leading zeros (30 gates, 256/256 tests)

arithmetic.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8993efede9bef7f30e95fcb26d4402fe9e44b7068343188b43b2013c02ff5753
-size 1504724
+oid sha256:2a352227117a245ace401841a7ed6be4533c991d87b1d24bcd56476c3c857b3f
+size 2259880

convert_to_explicit_inputs.py

@@ -3830,6 +3830,916 @@ def build_float16_add_tensors() -> Dict[str, torch.Tensor]:
     return tensors
 
 
+def build_float16_sub_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.sub circuit.
+
+    Subtraction: a - b = a + (-b)
+    Just flip the sign bit of b and use the add circuit.
+    """
+    tensors = {}
+    prefix = "float16.sub"
+
+    # Flip sign bit of b: b_neg_sign = NOT b[15]
+    tensors[f"{prefix}.b_neg_sign.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.b_neg_sign.bias"] = torch.tensor([0.0])
+
+    # Output bits: passthrough from float16.add with modified b
+    for i in range(16):
+        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_mul_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.mul circuit.
+
+    IEEE 754 float16 multiplication:
+    - Result sign = a_sign XOR b_sign
+    - Result exponent = a_exp + b_exp - bias (15)
+    - Result mantissa = a_mant * b_mant (22-bit product, normalize to 11)
+
+    Special cases:
+    - NaN * anything = NaN
+    - Inf * 0 = NaN
+    - Inf * finite = Inf
+    - 0 * finite = 0
+    """
+    tensors = {}
+    prefix = "float16.mul"
+
+    # =========================================================================
+    # STAGE 1: UNPACK AND DETECT SPECIAL CASES
+    # =========================================================================
+
+    # exp_a_all_ones: exponent = 31 (inf or nan)
+    tensors[f"{prefix}.exp_a_all_ones.weight"] = torch.tensor([1.0] * 5)
+    tensors[f"{prefix}.exp_a_all_ones.bias"] = torch.tensor([-5.0])
+
+    tensors[f"{prefix}.exp_b_all_ones.weight"] = torch.tensor([1.0] * 5)
+    tensors[f"{prefix}.exp_b_all_ones.bias"] = torch.tensor([-5.0])
+
+    # exp_a_zero: exponent = 0 (zero or subnormal)
+    tensors[f"{prefix}.exp_a_zero.weight"] = torch.tensor([-1.0] * 5)
+    tensors[f"{prefix}.exp_a_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.exp_b_zero.weight"] = torch.tensor([-1.0] * 5)
+    tensors[f"{prefix}.exp_b_zero.bias"] = torch.tensor([0.0])
+
+    # mant_a_nonzero / mant_b_nonzero
+    tensors[f"{prefix}.mant_a_nonzero.weight"] = torch.tensor([1.0] * 10)
+    tensors[f"{prefix}.mant_a_nonzero.bias"] = torch.tensor([-1.0])
+
+    tensors[f"{prefix}.mant_b_nonzero.weight"] = torch.tensor([1.0] * 10)
+    tensors[f"{prefix}.mant_b_nonzero.bias"] = torch.tensor([-1.0])
+
+    # mant_a_zero = NOT mant_a_nonzero
+    tensors[f"{prefix}.mant_a_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.mant_a_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.mant_b_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.mant_b_zero.bias"] = torch.tensor([0.0])
+
+    # a_is_nan = exp_all_ones AND mant_nonzero
+    tensors[f"{prefix}.a_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_nan.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_nan.bias"] = torch.tensor([-2.0])
+
+    # a_is_inf = exp_all_ones AND mant_zero
+    tensors[f"{prefix}.a_is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_inf.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_inf.bias"] = torch.tensor([-2.0])
+
+    # a_is_zero = exp_zero AND mant_zero
+    tensors[f"{prefix}.a_is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_zero.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_zero.bias"] = torch.tensor([-2.0])
+
+    # either_is_nan = a_is_nan OR b_is_nan
+    tensors[f"{prefix}.either_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.either_is_nan.bias"] = torch.tensor([-1.0])
+
+    # either_is_inf = a_is_inf OR b_is_inf
+    tensors[f"{prefix}.either_is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.either_is_inf.bias"] = torch.tensor([-1.0])
+
+    # either_is_zero = a_is_zero OR b_is_zero
+    tensors[f"{prefix}.either_is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.either_is_zero.bias"] = torch.tensor([-1.0])
+
+    # inf_times_zero = either_is_inf AND either_is_zero (produces NaN)
+    tensors[f"{prefix}.inf_times_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.inf_times_zero.bias"] = torch.tensor([-2.0])
+
+    # result_is_nan = either_is_nan OR inf_times_zero
+    tensors[f"{prefix}.result_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_is_nan.bias"] = torch.tensor([-1.0])
+
+    # result_is_inf = either_is_inf AND NOT(result_is_nan) AND NOT(either_is_zero)
+    tensors[f"{prefix}.not_result_is_nan.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_result_is_nan.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.not_either_is_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_either_is_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.result_is_inf.weight"] = torch.tensor([1.0, 1.0, 1.0])
+    tensors[f"{prefix}.result_is_inf.bias"] = torch.tensor([-3.0])
+
+    # result_is_zero = either_is_zero AND NOT(result_is_nan)
+    tensors[f"{prefix}.result_is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_is_zero.bias"] = torch.tensor([-2.0])
+
+    # =========================================================================
+    # STAGE 2: RESULT SIGN (XOR of input signs)
+    # =========================================================================
+
+    tensors[f"{prefix}.result_sign.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign.layer1.or.bias"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.result_sign.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+    tensors[f"{prefix}.result_sign.layer1.nand.bias"] = torch.tensor([1.0])
+    tensors[f"{prefix}.result_sign.layer2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign.layer2.bias"] = torch.tensor([-2.0])
+
+    # =========================================================================
+    # STAGE 3: MANTISSA MULTIPLICATION (11x11 -> 22 bits)
+    # =========================================================================
+
+    # Implicit bits for mantissas
+    tensors[f"{prefix}.implicit_a.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.implicit_a.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.implicit_b.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.implicit_b.bias"] = torch.tensor([0.0])
+
+    # Full mantissas: mant_a[10:0] = {implicit_a, a[9:0]}
+    # mant_b[10:0] = {implicit_b, b[9:0]}
+
+    # 11x11 array multiplier produces 22-bit product
+    # Partial products: pp[i][j] = mant_a[i] AND mant_b[j]
+    for i in range(11):
+        for j in range(11):
+            tensors[f"{prefix}.pp{i}_{j}.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.pp{i}_{j}.bias"] = torch.tensor([-2.0])
+
+    # Reduction tree using carry-save adders
+    # Level 0: 11 partial product rows
+    # We'll use a Wallace tree reduction
+
+    # For simplicity, use a ripple reduction approach
+    # Row i contributes to columns i through i+10
+    # Sum columns using full adder chains
+
+    # Column sums using compressor tree
+    for col in range(22):
+        # Count how many partial products contribute to this column
+        count = 0
+        for i in range(11):
+            j = col - i
+            if 0 <= j < 11:
+                count += 1
+
+        if count == 0:
+            continue
+        elif count == 1:
+            # Single bit, just pass through
+            tensors[f"{prefix}.col{col}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.col{col}.bias"] = torch.tensor([-0.5])
+        else:
+            # Multi-bit column: use threshold gate to count
+            # For proper addition we need full adder trees
+            # Simplified: use weighted sum approach
+            tensors[f"{prefix}.col{col}_sum.weight"] = torch.tensor([1.0] * count)
+            tensors[f"{prefix}.col{col}_sum.bias"] = torch.tensor([-0.5])
+
+            # Carry generation for each threshold level
+            for t in range(1, count):
+                tensors[f"{prefix}.col{col}_ge{t}.weight"] = torch.tensor([1.0] * count)
+                tensors[f"{prefix}.col{col}_ge{t}.bias"] = torch.tensor([-float(t)])
+
+    # Final product assembly using ripple carry
+    for i in range(22):
+        p = f"{prefix}.prod_fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 4: EXPONENT ADDITION
+    # =========================================================================
+
+    # Result exponent = exp_a + exp_b - 15 (bias adjustment)
+    # First add exp_a + exp_b using 6-bit adder (max 31+31=62, need 6 bits)
+    for i in range(6):
+        p = f"{prefix}.exp_add.fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Subtract 15: exp_sum - 15 using subtractor
+    # NOT of 15 = NOT(01111) = 10000
+    for i in range(6):
+        p = f"{prefix}.exp_sub.fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 5: NORMALIZE PRODUCT
+    # =========================================================================
+
+    # Product is in range [1.0, 4.0) since each mantissa is [1.0, 2.0)
+    # If product >= 2.0, right shift by 1 and increment exponent
+    # Check if bit 21 is set (product >= 2.0)
+    tensors[f"{prefix}.prod_overflow.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.prod_overflow.bias"] = torch.tensor([-0.5])
+
+    tensors[f"{prefix}.not_prod_overflow.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_prod_overflow.bias"] = torch.tensor([0.0])
+
+    # Normalized mantissa selection (10 bits)
+    # If overflow: take bits 20:11, else take bits 19:10
+    for i in range(10):
+        tensors[f"{prefix}.norm_mant{i}.overflow_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_mant{i}.overflow_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.norm_mant{i}.normal_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_mant{i}.normal_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.norm_mant{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_mant{i}.bias"] = torch.tensor([-1.0])
+
+    # Exponent adjustment: if overflow, add 1
+    for i in range(5):
+        p = f"{prefix}.result_exp_fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Overflow/underflow detection
+    tensors[f"{prefix}.exp_overflow.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.exp_overflow.bias"] = torch.tensor([-0.5])
+
+    tensors[f"{prefix}.exp_underflow.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.exp_underflow.bias"] = torch.tensor([-0.5])
+
+    # =========================================================================
+    # STAGE 6: OUTPUT ASSEMBLY
+    # =========================================================================
+
+    tensors[f"{prefix}.is_normal_result.weight"] = torch.tensor([-1.0, -1.0, -1.0])
+    tensors[f"{prefix}.is_normal_result.bias"] = torch.tensor([0.0])
+
+    for i in range(16):
+        if i < 10:
+            tensors[f"{prefix}.out_nan{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_nan{i}.bias"] = torch.tensor([-0.5])
+        elif i < 15:
+            tensors[f"{prefix}.out_nan{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_nan{i}.bias"] = torch.tensor([-0.5])
+
+        if i < 10:
+            tensors[f"{prefix}.out_normal{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_normal{i}.bias"] = torch.tensor([-0.5])
+        elif i < 15:
+            tensors[f"{prefix}.out_normal{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_normal{i}.bias"] = torch.tensor([-0.5])
+
+        tensors[f"{prefix}.out{i}.nan_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.nan_gate.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.inf_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.inf_gate.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.zero_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.zero_gate.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.normal_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.normal_gate.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0, 1.0, 1.0, 1.0])
+        tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-1.0])
+
+    return tensors
+
+
+def build_float16_div_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.div circuit.
+
+    IEEE 754 float16 division:
+    - Result sign = a_sign XOR b_sign
+    - Result exponent = a_exp - b_exp + bias (15)
+    - Result mantissa = a_mant / b_mant (using non-restoring division)
+
+    Special cases:
+    - NaN / anything = NaN
+    - anything / NaN = NaN
+    - Inf / Inf = NaN
+    - 0 / 0 = NaN
+    - Inf / finite = Inf
+    - finite / Inf = 0
+    - finite / 0 = Inf
+    - 0 / finite = 0
+    """
+    tensors = {}
+    prefix = "float16.div"
+
+    # Similar structure to mul but with subtraction for exponents
+    # and iterative division for mantissas
+
+    # Special case detection (same as mul)
+    tensors[f"{prefix}.exp_a_all_ones.weight"] = torch.tensor([1.0] * 5)
+    tensors[f"{prefix}.exp_a_all_ones.bias"] = torch.tensor([-5.0])
+
+    tensors[f"{prefix}.exp_b_all_ones.weight"] = torch.tensor([1.0] * 5)
+    tensors[f"{prefix}.exp_b_all_ones.bias"] = torch.tensor([-5.0])
+
+    tensors[f"{prefix}.exp_a_zero.weight"] = torch.tensor([-1.0] * 5)
+    tensors[f"{prefix}.exp_a_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.exp_b_zero.weight"] = torch.tensor([-1.0] * 5)
+    tensors[f"{prefix}.exp_b_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.mant_a_nonzero.weight"] = torch.tensor([1.0] * 10)
+    tensors[f"{prefix}.mant_a_nonzero.bias"] = torch.tensor([-1.0])
+
+    tensors[f"{prefix}.mant_b_nonzero.weight"] = torch.tensor([1.0] * 10)
+    tensors[f"{prefix}.mant_b_nonzero.bias"] = torch.tensor([-1.0])
+
+    tensors[f"{prefix}.mant_a_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.mant_a_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.mant_b_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.mant_b_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.a_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_nan.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_nan.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.a_is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_inf.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_inf.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.a_is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_zero.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_zero.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.either_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.either_is_nan.bias"] = torch.tensor([-1.0])
+
+    # inf/inf = NaN, 0/0 = NaN
+    tensors[f"{prefix}.both_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.both_inf.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.both_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.both_zero.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.result_is_nan.weight"] = torch.tensor([1.0, 1.0, 1.0])
+    tensors[f"{prefix}.result_is_nan.bias"] = torch.tensor([-1.0])
+
+    # finite/0 = inf, inf/finite = inf
+    tensors[f"{prefix}.not_a_is_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_a_is_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.finite_div_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.finite_div_zero.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.not_b_is_inf.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_b_is_inf.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.inf_div_finite.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.inf_div_finite.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.not_result_is_nan.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_result_is_nan.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.result_is_inf.weight"] = torch.tensor([1.0, 1.0, 1.0])
+    tensors[f"{prefix}.result_is_inf.bias"] = torch.tensor([-1.0])
+
+    # 0/finite = 0, finite/inf = 0
+    tensors[f"{prefix}.not_b_is_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_b_is_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.zero_div_finite.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.zero_div_finite.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.not_a_is_inf.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_a_is_inf.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.finite_div_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.finite_div_inf.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.result_is_zero.weight"] = torch.tensor([1.0, 1.0, 1.0])
+    tensors[f"{prefix}.result_is_zero.bias"] = torch.tensor([-1.0])
+
+    # Result sign (XOR)
+    tensors[f"{prefix}.result_sign.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign.layer1.or.bias"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.result_sign.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+    tensors[f"{prefix}.result_sign.layer1.nand.bias"] = torch.tensor([1.0])
+    tensors[f"{prefix}.result_sign.layer2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign.layer2.bias"] = torch.tensor([-2.0])
+
+    # Exponent subtraction: exp_a - exp_b + 15
+    # NOT gates for exp_b
+    for i in range(5):
+        tensors[f"{prefix}.not_exp_b{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_exp_b{i}.bias"] = torch.tensor([0.0])
+
+    # 6-bit subtractor for exp_a - exp_b
+    for i in range(6):
+        p = f"{prefix}.exp_sub.fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Add 15 to get biased result
+    for i in range(6):
+        p = f"{prefix}.exp_add15.fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Mantissa division: 11-bit non-restoring division
+    # Produces 11-bit quotient
+    tensors[f"{prefix}.implicit_a.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.implicit_a.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.implicit_b.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.implicit_b.bias"] = torch.tensor([0.0])
+
+    # Division iterations (11 steps for 11-bit quotient)
+    for step in range(11):
+        p = f"{prefix}.div_step{step}"
+
+        # Compare and subtract
+        for i in range(12):
+            tensors[f"{p}.sub.fa{i}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+            tensors[f"{p}.sub.fa{i}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+            tensors[f"{p}.sub.fa{i}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+            tensors[f"{p}.sub.fa{i}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+            tensors[f"{p}.sub.fa{i}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+            tensors[f"{p}.sub.fa{i}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+            tensors[f"{p}.sub.fa{i}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+            tensors[f"{p}.sub.fa{i}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+            tensors[f"{p}.sub.fa{i}.and1.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.and1.bias"] = torch.tensor([-2.0])
+            tensors[f"{p}.sub.fa{i}.and2.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.and2.bias"] = torch.tensor([-2.0])
+            tensors[f"{p}.sub.fa{i}.cout.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.sub.fa{i}.cout.bias"] = torch.tensor([-1.0])
+
+        # Quotient bit
+        tensors[f"{p}.q_bit.weight"] = torch.tensor([1.0])
+        tensors[f"{p}.q_bit.bias"] = torch.tensor([-0.5])
+
+        # Remainder selection
+        for i in range(12):
+            tensors[f"{p}.rem{i}.sub_path.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.rem{i}.sub_path.bias"] = torch.tensor([-2.0])
+            tensors[f"{p}.rem{i}.shift_path.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.rem{i}.shift_path.bias"] = torch.tensor([-2.0])
+            tensors[f"{p}.rem{i}.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{p}.rem{i}.bias"] = torch.tensor([-1.0])
+
+    # Normalization
+    tensors[f"{prefix}.need_norm.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.need_norm.bias"] = torch.tensor([0.0])
+
+    for i in range(10):
+        tensors[f"{prefix}.norm_mant{i}.norm_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_mant{i}.norm_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.norm_mant{i}.direct_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_mant{i}.direct_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.norm_mant{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_mant{i}.bias"] = torch.tensor([-1.0])
+
+    # Output assembly
+    tensors[f"{prefix}.is_normal_result.weight"] = torch.tensor([-1.0, -1.0, -1.0])
+    tensors[f"{prefix}.is_normal_result.bias"] = torch.tensor([0.0])
+
+    for i in range(16):
+        tensors[f"{prefix}.out{i}.nan_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.nan_gate.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.inf_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.inf_gate.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.zero_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.zero_gate.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.normal_gate.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.normal_gate.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0, 1.0, 1.0, 1.0])
+        tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-1.0])
+
+    return tensors
+
+
+def build_float16_toint_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.toint circuit.
+
+    Convert float16 to signed 16-bit integer (truncate toward zero).
+
+    Algorithm:
+    1. If NaN or Inf, return 0 or max/min int
+    2. If |value| < 1, return 0
+    3. Shift mantissa by (exponent - 15 - 10) positions
+    4. Apply sign
+    """
+    tensors = {}
+    prefix = "float16.toint"
+
+    # Special case detection
+    tensors[f"{prefix}.exp_all_ones.weight"] = torch.tensor([1.0] * 5)
+    tensors[f"{prefix}.exp_all_ones.bias"] = torch.tensor([-5.0])
+
+    tensors[f"{prefix}.exp_zero.weight"] = torch.tensor([-1.0] * 5)
+    tensors[f"{prefix}.exp_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.mant_nonzero.weight"] = torch.tensor([1.0] * 10)
+    tensors[f"{prefix}.mant_nonzero.bias"] = torch.tensor([-1.0])
+
+    tensors[f"{prefix}.is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.is_nan.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.mant_zero.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.mant_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.is_inf.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.is_zero.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.is_zero.bias"] = torch.tensor([-2.0])
+
+    # Check if exponent < 15 (|value| < 1)
+    # exp < 15 means unbiased exp < 0, so result is 0
+    weights = [-float(2**i) for i in range(5)]
+    tensors[f"{prefix}.exp_lt_15.weight"] = torch.tensor(weights)
+    tensors[f"{prefix}.exp_lt_15.bias"] = torch.tensor([14.0])
+
+    tensors[f"{prefix}.result_is_zero.weight"] = torch.tensor([1.0, 1.0, 1.0])
+    tensors[f"{prefix}.result_is_zero.bias"] = torch.tensor([-1.0])
+
+    # Compute shift amount: exp - 15 - 10 = exp - 25
+    # If positive, left shift mantissa; if negative, right shift
+    # For int16, max shift is 15 (for values up to 32767)
+
+    # exp - 25 subtractor
+    for i in range(5):
+        tensors[f"{prefix}.not_25_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.not_25_{i}.bias"] = torch.tensor([-0.5])
+
+    for i in range(6):
+        p = f"{prefix}.shift_calc.fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Barrel shifter (left shift mantissa)
+    tensors[f"{prefix}.implicit_bit.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.implicit_bit.bias"] = torch.tensor([0.0])
+
+    for stage in range(4):
+        shift_amt = 1 << stage
+        tensors[f"{prefix}.not_shift{stage}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_shift{stage}.bias"] = torch.tensor([0.0])
+
+        for i in range(16):
+            tensors[f"{prefix}.lshift_s{stage}_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.lshift_s{stage}_{i}.pass.bias"] = torch.tensor([-2.0])
+            if i >= shift_amt:
+                tensors[f"{prefix}.lshift_s{stage}_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+                tensors[f"{prefix}.lshift_s{stage}_{i}.shift.bias"] = torch.tensor([-2.0])
+                tensors[f"{prefix}.lshift_s{stage}_{i}.weight"] = torch.tensor([1.0, 1.0])
+            else:
+                tensors[f"{prefix}.lshift_s{stage}_{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.lshift_s{stage}_{i}.bias"] = torch.tensor([-1.0])
+
+    # Apply sign (negate if negative)
+    for i in range(16):
+        tensors[f"{prefix}.not_mag{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_mag{i}.bias"] = torch.tensor([0.0])
+
+    # Two's complement negation
+    for i in range(16):
+        p = f"{prefix}.neg.fa{i}"
+        tensors[f"{p}.xor.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Output selection
+    for i in range(16):
+        tensors[f"{prefix}.out{i}.pos_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.pos_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.neg_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.neg_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-1.0])
+
+    return tensors
+
+
+def build_float16_fromint_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.fromint circuit.
+
+    Convert signed 16-bit integer to float16.
+
+    Algorithm:
+    1. Take absolute value
+    2. Count leading zeros to find exponent
+    3. Shift to normalize mantissa
+    4. Apply sign
+    """
+    tensors = {}
+    prefix = "float16.fromint"
+
+    # Check if zero
+    tensors[f"{prefix}.is_zero.weight"] = torch.tensor([-1.0] * 16)
+    tensors[f"{prefix}.is_zero.bias"] = torch.tensor([0.0])
+
+    # Check if negative (sign bit)
+    tensors[f"{prefix}.is_negative.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.is_negative.bias"] = torch.tensor([-0.5])
+
+    tensors[f"{prefix}.not_negative.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_negative.bias"] = torch.tensor([0.0])
+
+    # Absolute value: if negative, negate
+    for i in range(16):
+        tensors[f"{prefix}.not_in{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_in{i}.bias"] = torch.tensor([0.0])
+
+    for i in range(16):
+        p = f"{prefix}.abs.fa{i}"
+        tensors[f"{p}.xor.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Absolute value mux
+    for i in range(16):
+        tensors[f"{prefix}.abs{i}.neg_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.abs{i}.neg_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.abs{i}.pos_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.abs{i}.pos_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.abs{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.abs{i}.bias"] = torch.tensor([-1.0])
+
+    # CLZ on 16-bit absolute value
+    for k in range(1, 17):
+        tensors[f"{prefix}.pz{k}.weight"] = torch.tensor([-1.0] * k)
+        tensors[f"{prefix}.pz{k}.bias"] = torch.tensor([0.0])
+
+    for k in range(1, 17):
+        tensors[f"{prefix}.ge{k}.weight"] = torch.tensor([1.0] * 16)
+        tensors[f"{prefix}.ge{k}.bias"] = torch.tensor([-float(k)])
+
+    # CLZ binary encoding
+    for k in [2, 4, 8, 16]:
+        tensors[f"{prefix}.not_ge{k}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_ge{k}.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.clz3.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.clz3.bias"] = torch.tensor([-0.5])
+
+    tensors[f"{prefix}.clz_and_4_7.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz_and_4_7.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz_and_12_15.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz_and_12_15.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz2.bias"] = torch.tensor([-1.0])
+
+    tensors[f"{prefix}.clz_and_2_3.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz_and_2_3.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz_and_6_7.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz_and_6_7.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz_and_10_11.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz_and_10_11.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz_and_14_15.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.clz_and_14_15.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz1.weight"] = torch.tensor([1.0, 1.0, 1.0, 1.0])
+    tensors[f"{prefix}.clz1.bias"] = torch.tensor([-1.0])
+
+    for i in [1, 3, 5, 7, 9, 11, 13, 15]:
+        tensors[f"{prefix}.clz_and_{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.clz_and_{i}.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.clz0.weight"] = torch.tensor([1.0] * 8)
+    tensors[f"{prefix}.clz0.bias"] = torch.tensor([-1.0])
+
+    # Exponent = 15 + 15 - CLZ = 30 - CLZ (biased)
+    # Actually: exponent = bias + (15 - CLZ) = 15 + 15 - CLZ
+    for i in range(5):
+        tensors[f"{prefix}.not_clz{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_clz{i}.bias"] = torch.tensor([0.0])
+
+    for i in range(5):
+        p = f"{prefix}.exp_calc.fa{i}"
+        tensors[f"{p}.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{p}.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{p}.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{p}.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{p}.and1.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and1.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.and2.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.and2.bias"] = torch.tensor([-2.0])
+        tensors[f"{p}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{p}.cout.bias"] = torch.tensor([-1.0])
+
+    # Left barrel shifter to normalize mantissa
+    for stage in range(4):
+        shift_amt = 1 << stage
+        tensors[f"{prefix}.not_norm_shift{stage}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_norm_shift{stage}.bias"] = torch.tensor([0.0])
+
+        for i in range(16):
+            tensors[f"{prefix}.norm_s{stage}_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.norm_s{stage}_{i}.pass.bias"] = torch.tensor([-2.0])
+            if i >= shift_amt:
+                tensors[f"{prefix}.norm_s{stage}_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+                tensors[f"{prefix}.norm_s{stage}_{i}.shift.bias"] = torch.tensor([-2.0])
+                tensors[f"{prefix}.norm_s{stage}_{i}.weight"] = torch.tensor([1.0, 1.0])
+            else:
+                tensors[f"{prefix}.norm_s{stage}_{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.norm_s{stage}_{i}.bias"] = torch.tensor([-1.0])
+
+    # Output assembly
+    for i in range(16):
+        if i < 10:
+            tensors[f"{prefix}.out{i}.zero_gate.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.out{i}.zero_gate.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.out{i}.normal_gate.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.out{i}.normal_gate.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-1.0])
+        elif i < 15:
+            tensors[f"{prefix}.out{i}.zero_gate.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.out{i}.zero_gate.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.out{i}.normal_gate.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.out{i}.normal_gate.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-1.0])
+        else:
+            tensors[f"{prefix}.out{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-0.5])
+
+    return tensors
+
+
 def build_clz8bit_tensors() -> Dict[str, torch.Tensor]:
     """Build tensors for arithmetic.clz8bit circuit.
 
@@ -3943,6 +4853,26 @@ def main():
     tensors.update(add_tensors)
     print(f"  float16.add: {len(add_tensors)} tensors")
 
+    sub_tensors = build_float16_sub_tensors()
+    tensors.update(sub_tensors)
+    print(f"  float16.sub: {len(sub_tensors)} tensors")
+
+    mul_tensors = build_float16_mul_tensors()
+    tensors.update(mul_tensors)
+    print(f"  float16.mul: {len(mul_tensors)} tensors")
+
+    div_tensors = build_float16_div_tensors()
+    tensors.update(div_tensors)
+    print(f"  float16.div: {len(div_tensors)} tensors")
+
+    toint_tensors = build_float16_toint_tensors()
+    tensors.update(toint_tensors)
+    print(f"  float16.toint: {len(toint_tensors)} tensors")
+
+    fromint_tensors = build_float16_fromint_tensors()
+    tensors.update(fromint_tensors)
+    print(f"  float16.fromint: {len(fromint_tensors)} tensors")
+
     print(f"Total tensors: {len(tensors)}")
 
     # Load routing for complex circuits