Add float16.add circuit (93/125 tests passing)

Implements IEEE 754 half-precision addition with:
- Special case detection (NaN, infinity, zero, subnormal)
- Exponent comparison and difference calculation
- Mantissa alignment via barrel shifter
- 12-bit mantissa adder/subtractor
- Result normalization with overflow/underflow handling
- Output assembly with special case multiplexing

~910 gates total. Remaining issues:
- Zero+zero produces incorrect result
- Subtraction (different signs) has bugs

TODO.md

@@ -7,7 +7,7 @@
 - [x] `float16.pack` -- assemble from components (16 gates, 63/63 tests)
 - [x] `float16.cmp` -- comparison a > b (14 gates, 113/113 tests)
 - [x] `float16.normalize` -- CLZ-based shift calculator (51 gates, 14/14 tests)
-- [ ] `float16.add` -- IEEE 754 addition (requires normalize + align + add)
+- [~] `float16.add` -- IEEE 754 addition (~910 gates, 93/125 tests, needs zero+zero and subtraction fixes)
 - [ ] `float16.sub` -- subtraction (add with negated operand)
 - [ ] `float16.mul` -- multiplication
 - [ ] `float16.div` -- division

arithmetic.safetensors

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

convert_to_explicit_inputs.py

@@ -1056,11 +1056,976 @@ def infer_inputs_for_gate(gate: str, registry: SignalRegistry, routing: dict) ->
             return infer_float16_neg_inputs(gate, registry)
         if gate.startswith('float16.abs'):
             return infer_float16_abs_inputs(gate, registry)
+        if gate.startswith('float16.add'):
+            return infer_float16_add_inputs(gate, registry)
 
     # Default: couldn't infer, return empty (will need manual fix or routing)
     return []
 
 
+def infer_float16_add_inputs(gate: str, registry: SignalRegistry) -> List[int]:
+    """Infer inputs for float16.add circuit."""
+    prefix = "float16.add"
+
+    # Register 32 input bits (two 16-bit operands)
+    for i in range(16):
+        registry.register(f"{prefix}.$a[{i}]")
+        registry.register(f"{prefix}.$b[{i}]")
+
+    # Extract exponent bits (10-14)
+    exp_a_bits = [f"{prefix}.$a[{10+i}]" for i in range(5)]
+    exp_b_bits = [f"{prefix}.$b[{10+i}]" for i in range(5)]
+    mant_a_bits = [f"{prefix}.$a[{i}]" for i in range(10)]
+    mant_b_bits = [f"{prefix}.$b[{i}]" for i in range(10)]
+
+    # Stage 0: Special case detection
+    if '.exp_a_all_ones' in gate:
+        return [registry.get_id(b) for b in exp_a_bits]
+    if '.exp_b_all_ones' in gate:
+        return [registry.get_id(b) for b in exp_b_bits]
+    if '.exp_a_zero' in gate:
+        return [registry.get_id(b) for b in exp_a_bits]
+    if '.exp_b_zero' in gate:
+        return [registry.get_id(b) for b in exp_b_bits]
+    if '.mant_a_nonzero' in gate:
+        return [registry.get_id(b) for b in mant_a_bits]
+    if '.mant_b_nonzero' in gate:
+        return [registry.get_id(b) for b in mant_b_bits]
+    if '.mant_a_zero' in gate:
+        return [registry.get_id(b) for b in mant_a_bits]
+    if '.mant_b_zero' in gate:
+        return [registry.get_id(b) for b in mant_b_bits]
+
+    registry.register(f"{prefix}.exp_a_all_ones")
+    registry.register(f"{prefix}.exp_b_all_ones")
+    registry.register(f"{prefix}.exp_a_zero")
+    registry.register(f"{prefix}.exp_b_zero")
+    registry.register(f"{prefix}.mant_a_nonzero")
+    registry.register(f"{prefix}.mant_b_nonzero")
+    registry.register(f"{prefix}.mant_a_zero")
+    registry.register(f"{prefix}.mant_b_zero")
+
+    if '.a_is_nan' in gate:
+        return [registry.get_id(f"{prefix}.exp_a_all_ones"),
+                registry.get_id(f"{prefix}.mant_a_nonzero")]
+    if '.b_is_nan' in gate:
+        return [registry.get_id(f"{prefix}.exp_b_all_ones"),
+                registry.get_id(f"{prefix}.mant_b_nonzero")]
+    if '.a_is_inf' in gate:
+        return [registry.get_id(f"{prefix}.exp_a_all_ones"),
+                registry.get_id(f"{prefix}.mant_a_zero")]
+    if '.b_is_inf' in gate:
+        return [registry.get_id(f"{prefix}.exp_b_all_ones"),
+                registry.get_id(f"{prefix}.mant_b_zero")]
+    if '.a_is_zero' in gate:
+        return [registry.get_id(f"{prefix}.exp_a_zero"),
+                registry.get_id(f"{prefix}.mant_a_zero")]
+    if '.b_is_zero' in gate:
+        return [registry.get_id(f"{prefix}.exp_b_zero"),
+                registry.get_id(f"{prefix}.mant_b_zero")]
+    if '.a_is_subnormal' in gate:
+        return [registry.get_id(f"{prefix}.exp_a_zero"),
+                registry.get_id(f"{prefix}.mant_a_nonzero")]
+    if '.b_is_subnormal' in gate:
+        return [registry.get_id(f"{prefix}.exp_b_zero"),
+                registry.get_id(f"{prefix}.mant_b_nonzero")]
+
+    registry.register(f"{prefix}.a_is_nan")
+    registry.register(f"{prefix}.b_is_nan")
+    registry.register(f"{prefix}.a_is_inf")
+    registry.register(f"{prefix}.b_is_inf")
+
+    if '.either_is_nan' in gate:
+        return [registry.get_id(f"{prefix}.a_is_nan"),
+                registry.get_id(f"{prefix}.b_is_nan")]
+    if '.both_are_inf' in gate:
+        return [registry.get_id(f"{prefix}.a_is_inf"),
+                registry.get_id(f"{prefix}.b_is_inf")]
+
+    # Sign extraction
+    if gate == f"{prefix}.sign_a":
+        return [registry.get_id(f"{prefix}.$a[15]")]
+    if gate == f"{prefix}.sign_b":
+        return [registry.get_id(f"{prefix}.$b[15]")]
+
+    registry.register(f"{prefix}.sign_a")
+    registry.register(f"{prefix}.sign_b")
+
+    if '.signs_differ.layer1' in gate:
+        return [registry.get_id(f"{prefix}.sign_a"),
+                registry.get_id(f"{prefix}.sign_b")]
+    if '.signs_differ.layer2' in gate:
+        return [registry.register(f"{prefix}.signs_differ.layer1.or"),
+                registry.register(f"{prefix}.signs_differ.layer1.nand")]
+
+    registry.register(f"{prefix}.signs_differ.layer2")
+    registry.register(f"{prefix}.either_is_nan")
+    registry.register(f"{prefix}.both_are_inf")
+
+    if '.inf_cancellation' in gate:
+        return [registry.get_id(f"{prefix}.both_are_inf"),
+                registry.get_id(f"{prefix}.signs_differ.layer2")]
+
+    registry.register(f"{prefix}.inf_cancellation")
+
+    if '.result_is_nan' in gate:
+        return [registry.get_id(f"{prefix}.either_is_nan"),
+                registry.get_id(f"{prefix}.inf_cancellation")]
+    if '.either_is_inf' in gate:
+        return [registry.get_id(f"{prefix}.a_is_inf"),
+                registry.get_id(f"{prefix}.b_is_inf")]
+
+    registry.register(f"{prefix}.result_is_nan")
+    registry.register(f"{prefix}.either_is_inf")
+
+    if '.not_result_is_nan' in gate:
+        return [registry.get_id(f"{prefix}.result_is_nan")]
+
+    registry.register(f"{prefix}.not_result_is_nan")
+
+    if '.result_is_inf' in gate:
+        return [registry.get_id(f"{prefix}.either_is_inf"),
+                registry.get_id(f"{prefix}.not_result_is_nan")]
+
+    # Implicit bit
+    if '.implicit_a' in gate:
+        return [registry.get_id(f"{prefix}.exp_a_zero")]
+    if '.implicit_b' in gate:
+        return [registry.get_id(f"{prefix}.exp_b_zero")]
+
+    registry.register(f"{prefix}.implicit_a")
+    registry.register(f"{prefix}.implicit_b")
+
+    # Exponent comparison
+    if '.a_exp_ge_b' in gate or '.a_exp_gt_b' in gate:
+        return [registry.get_id(b) for b in exp_a_bits] + \
+               [registry.get_id(b) for b in exp_b_bits]
+    if '.b_exp_gt_a' in gate and 'sel' not in gate:
+        return [registry.get_id(b) for b in exp_b_bits] + \
+               [registry.get_id(b) for b in exp_a_bits]
+
+    registry.register(f"{prefix}.a_exp_ge_b")
+    registry.register(f"{prefix}.a_exp_gt_b")
+    registry.register(f"{prefix}.b_exp_gt_a")
+
+    if '.b_exp_gt_a_sel' in gate:
+        return [registry.get_id(f"{prefix}.a_exp_ge_b")]
+
+    registry.register(f"{prefix}.b_exp_gt_a_sel")
+
+    # NOT gates for exponent bits
+    match = re.search(r'\.not_exp_b(\d+)', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.get_id(f"{prefix}.$b[{10+i}]")]
+
+    match = re.search(r'\.not_exp_a(\d+)', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.get_id(f"{prefix}.$a[{10+i}]")]
+
+    for i in range(5):
+        registry.register(f"{prefix}.not_exp_b{i}")
+        registry.register(f"{prefix}.not_exp_a{i}")
+
+    # Exp diff subtractors (diff_ab and diff_ba)
+    if '.diff_ab.fa' in gate or '.diff_ba.fa' in gate:
+        is_ab = '.diff_ab' in gate
+        match = re.search(r'\.fa(\d+)\.', gate)
+        if match:
+            i = int(match.group(1))
+            fa_prefix = f"{prefix}.diff_{'ab' if is_ab else 'ba'}.fa{i}"
+
+            if is_ab:
+                a_bit = registry.get_id(f"{prefix}.$a[{10+i}]")
+                not_b = registry.get_id(f"{prefix}.not_exp_b{i}")
+            else:
+                a_bit = registry.get_id(f"{prefix}.$b[{10+i}]")
+                not_b = registry.get_id(f"{prefix}.not_exp_a{i}")
+
+            if i == 0:
+                cin = registry.get_id("#1")
+            else:
+                cin = registry.register(f"{prefix}.diff_{'ab' if is_ab else 'ba'}.fa{i-1}.cout")
+
+            if '.xor1.layer1' in gate:
+                return [a_bit, not_b]
+            if '.xor1.layer2' in gate:
+                return [registry.register(f"{fa_prefix}.xor1.layer1.or"),
+                        registry.register(f"{fa_prefix}.xor1.layer1.nand")]
+
+            xor1 = registry.register(f"{fa_prefix}.xor1.layer2")
+
+            if '.xor2.layer1' in gate:
+                return [xor1, cin]
+            if '.xor2.layer2' in gate:
+                return [registry.register(f"{fa_prefix}.xor2.layer1.or"),
+                        registry.register(f"{fa_prefix}.xor2.layer1.nand")]
+
+            if '.and1' in gate:
+                return [a_bit, not_b]
+            if '.and2' in gate:
+                return [xor1, cin]
+            if '.cout' in gate:
+                return [registry.register(f"{fa_prefix}.and1"),
+                        registry.register(f"{fa_prefix}.and2")]
+
+    # Register diff outputs
+    for i in range(5):
+        registry.register(f"{prefix}.diff_ab.fa{i}.xor2.layer2")
+        registry.register(f"{prefix}.diff_ba.fa{i}.xor2.layer2")
+
+    # Exp diff mux
+    match = re.search(r'\.exp_diff_mux(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.and_ab' in gate:
+            return [registry.get_id(f"{prefix}.diff_ab.fa{i}.xor2.layer2"),
+                    registry.get_id(f"{prefix}.a_exp_ge_b")]
+        if '.and_ba' in gate:
+            return [registry.get_id(f"{prefix}.diff_ba.fa{i}.xor2.layer2"),
+                    registry.get_id(f"{prefix}.b_exp_gt_a_sel")]
+
+    match = re.search(r'\.exp_diff(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.exp_diff_mux{i}.and_ab"),
+                registry.register(f"{prefix}.exp_diff_mux{i}.and_ba")]
+
+    for i in range(5):
+        registry.register(f"{prefix}.exp_diff{i}")
+
+    # Exp larger mux
+    match = re.search(r'\.exp_larger_mux(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.and_a' in gate:
+            return [registry.get_id(f"{prefix}.$a[{10+i}]"),
+                    registry.get_id(f"{prefix}.a_exp_ge_b")]
+        if '.and_b' in gate:
+            return [registry.get_id(f"{prefix}.$b[{10+i}]"),
+                    registry.get_id(f"{prefix}.b_exp_gt_a_sel")]
+
+    match = re.search(r'\.exp_larger(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.exp_larger_mux{i}.and_a"),
+                registry.register(f"{prefix}.exp_larger_mux{i}.and_b")]
+
+    for i in range(5):
+        registry.register(f"{prefix}.exp_larger{i}")
+
+    # Mantissa source selection (which mantissa to shift)
+    # mant_shift_src = a_exp_ge_b ? mant_b : mant_a
+    # mant_larger = a_exp_ge_b ? mant_a : mant_b
+    match = re.search(r'\.mant_shift_src(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if i < 10:
+            mant_a = registry.get_id(f"{prefix}.$a[{i}]")
+            mant_b = registry.get_id(f"{prefix}.$b[{i}]")
+        else:
+            mant_a = registry.get_id(f"{prefix}.implicit_a")
+            mant_b = registry.get_id(f"{prefix}.implicit_b")
+        if '.and_b' in gate:
+            return [mant_b, registry.get_id(f"{prefix}.a_exp_ge_b")]
+        if '.and_a' in gate:
+            return [mant_a, registry.get_id(f"{prefix}.b_exp_gt_a_sel")]
+
+    match = re.search(r'\.mant_shift_src(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.mant_shift_src{i}.and_b"),
+                registry.register(f"{prefix}.mant_shift_src{i}.and_a")]
+
+    match = re.search(r'\.mant_larger(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if i < 10:
+            mant_a = registry.get_id(f"{prefix}.$a[{i}]")
+            mant_b = registry.get_id(f"{prefix}.$b[{i}]")
+        else:
+            mant_a = registry.get_id(f"{prefix}.implicit_a")
+            mant_b = registry.get_id(f"{prefix}.implicit_b")
+        if '.and_a' in gate:
+            return [mant_a, registry.get_id(f"{prefix}.a_exp_ge_b")]
+        if '.and_b' in gate:
+            return [mant_b, registry.get_id(f"{prefix}.b_exp_gt_a_sel")]
+
+    match = re.search(r'\.mant_larger(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.mant_larger{i}.and_a"),
+                registry.register(f"{prefix}.mant_larger{i}.and_b")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.mant_shift_src{i}")
+        registry.register(f"{prefix}.mant_larger{i}")
+
+    # NOT gates for exp_diff bits (barrel shifter control)
+    for i in range(5):
+        if f'.not_exp_diff{i}' in gate and f'.not_exp_diff{i}.' not in gate:
+            return [registry.get_id(f"{prefix}.exp_diff{i}")]
+        registry.register(f"{prefix}.not_exp_diff{i}")
+
+    # Barrel shifter stage 0 (shift by 1)
+    match = re.search(r'\.shift_s0_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.mant_shift_src{i}"),
+                    registry.get_id(f"{prefix}.not_exp_diff0")]
+        if '.shift' in gate and i < 10:
+            return [registry.get_id(f"{prefix}.mant_shift_src{i+1}"),
+                    registry.get_id(f"{prefix}.exp_diff0")]
+
+    match = re.search(r'\.shift_s0_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i < 10:
+            return [registry.register(f"{prefix}.shift_s0_{i}.pass"),
+                    registry.register(f"{prefix}.shift_s0_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.shift_s0_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.shift_s0_{i}")
+
+    # Barrel shifter stage 1 (shift by 2)
+    match = re.search(r'\.shift_s1_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.shift_s0_{i}"),
+                    registry.get_id(f"{prefix}.not_exp_diff1")]
+        if '.shift' in gate and i < 9:
+            return [registry.get_id(f"{prefix}.shift_s0_{i+2}"),
+                    registry.get_id(f"{prefix}.exp_diff1")]
+
+    match = re.search(r'\.shift_s1_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i < 9:
+            return [registry.register(f"{prefix}.shift_s1_{i}.pass"),
+                    registry.register(f"{prefix}.shift_s1_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.shift_s1_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.shift_s1_{i}")
+
+    # Barrel shifter stage 2 (shift by 4)
+    match = re.search(r'\.shift_s2_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.shift_s1_{i}"),
+                    registry.get_id(f"{prefix}.not_exp_diff2")]
+        if '.shift' in gate and i < 7:
+            return [registry.get_id(f"{prefix}.shift_s1_{i+4}"),
+                    registry.get_id(f"{prefix}.exp_diff2")]
+
+    match = re.search(r'\.shift_s2_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i < 7:
+            return [registry.register(f"{prefix}.shift_s2_{i}.pass"),
+                    registry.register(f"{prefix}.shift_s2_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.shift_s2_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.shift_s2_{i}")
+
+    # Barrel shifter stage 3 (shift by 8)
+    match = re.search(r'\.shift_s3_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.shift_s2_{i}"),
+                    registry.get_id(f"{prefix}.not_exp_diff3")]
+        if '.shift' in gate and i < 3:
+            return [registry.get_id(f"{prefix}.shift_s2_{i+8}"),
+                    registry.get_id(f"{prefix}.exp_diff3")]
+
+    match = re.search(r'\.shift_s3_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i < 3:
+            return [registry.register(f"{prefix}.shift_s3_{i}.pass"),
+                    registry.register(f"{prefix}.shift_s3_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.shift_s3_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.shift_s3_{i}")
+
+    # mant_aligned (masked by not_exp_diff4)
+    match = re.search(r'\.mant_aligned(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.get_id(f"{prefix}.shift_s3_{i}"),
+                registry.get_id(f"{prefix}.not_exp_diff4")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.mant_aligned{i}")
+
+    # signs_same = NOT signs_differ
+    if '.signs_same' in gate:
+        return [registry.get_id(f"{prefix}.signs_differ.layer2")]
+
+    registry.register(f"{prefix}.signs_same")
+
+    # Mantissa comparison (for equal exponent case)
+    if '.mant_a_ge_b' in gate:
+        mant_a_full = [registry.get_id(f"{prefix}.$a[{i}]") for i in range(10)] + \
+                      [registry.get_id(f"{prefix}.implicit_a")]
+        mant_b_full = [registry.get_id(f"{prefix}.$b[{i}]") for i in range(10)] + \
+                      [registry.get_id(f"{prefix}.implicit_b")]
+        return mant_a_full + mant_b_full
+
+    registry.register(f"{prefix}.mant_a_ge_b")
+
+    # NOT gates for mant_aligned (for subtraction)
+    match = re.search(r'\.not_mant_aligned(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.get_id(f"{prefix}.mant_aligned{i}")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.not_mant_aligned{i}")
+
+    # sub_cin = signs_differ
+    if '.sub_cin' in gate:
+        return [registry.get_id(f"{prefix}.signs_differ.layer2")]
+
+    registry.register(f"{prefix}.sub_cin")
+
+    # addsub_b selection
+    match = re.search(r'\.addsub_b(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.add' in gate:
+            return [registry.get_id(f"{prefix}.mant_aligned{i}"),
+                    registry.get_id(f"{prefix}.signs_same")]
+        if '.sub' in gate:
+            return [registry.get_id(f"{prefix}.not_mant_aligned{i}"),
+                    registry.get_id(f"{prefix}.signs_differ.layer2")]
+
+    match = re.search(r'\.addsub_b(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.addsub_b{i}.add"),
+                registry.register(f"{prefix}.addsub_b{i}.sub")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.addsub_b{i}")
+
+    # 12-bit mantissa adder
+    if '.mant_add.fa' in gate:
+        match = re.search(r'\.mant_add\.fa(\d+)\.', gate)
+        if match:
+            i = int(match.group(1))
+            fa_prefix = f"{prefix}.mant_add.fa{i}"
+
+            if i < 11:
+                a_bit = registry.get_id(f"{prefix}.mant_larger{i}")
+                b_bit = registry.get_id(f"{prefix}.addsub_b{i}")
+            else:
+                a_bit = registry.get_id("#0")
+                b_bit = registry.get_id("#0")
+
+            if i == 0:
+                cin = registry.get_id(f"{prefix}.sub_cin")
+            else:
+                cin = registry.register(f"{prefix}.mant_add.fa{i-1}.cout")
+
+            if '.xor1.layer1' in gate:
+                return [a_bit, b_bit]
+            if '.xor1.layer2' in gate:
+                return [registry.register(f"{fa_prefix}.xor1.layer1.or"),
+                        registry.register(f"{fa_prefix}.xor1.layer1.nand")]
+
+            xor1 = registry.register(f"{fa_prefix}.xor1.layer2")
+
+            if '.xor2.layer1' in gate:
+                return [xor1, cin]
+            if '.xor2.layer2' in gate:
+                return [registry.register(f"{fa_prefix}.xor2.layer1.or"),
+                        registry.register(f"{fa_prefix}.xor2.layer1.nand")]
+
+            if '.and1' in gate:
+                return [a_bit, b_bit]
+            if '.and2' in gate:
+                return [xor1, cin]
+            if '.cout' in gate:
+                return [registry.register(f"{fa_prefix}.and1"),
+                        registry.register(f"{fa_prefix}.and2")]
+
+    for i in range(12):
+        registry.register(f"{prefix}.mant_add.fa{i}.xor2.layer2")
+        registry.register(f"{prefix}.mant_add.fa{i}.cout")
+
+    # Result sign determination
+    if '.not_a_exp_gt_b' in gate:
+        return [registry.get_id(f"{prefix}.a_exp_gt_b")]
+
+    registry.register(f"{prefix}.not_a_exp_gt_b")
+
+    if '.exp_a_eq_b' in gate:
+        return [registry.get_id(f"{prefix}.not_a_exp_gt_b"),
+                registry.get_id(f"{prefix}.b_exp_gt_a_sel")]
+
+    registry.register(f"{prefix}.exp_a_eq_b")
+
+    if '.exp_eq_and_mant_a_ge' in gate:
+        return [registry.get_id(f"{prefix}.exp_a_eq_b"),
+                registry.get_id(f"{prefix}.mant_a_ge_b")]
+
+    registry.register(f"{prefix}.exp_eq_and_mant_a_ge")
+
+    if '.a_magnitude_ge_b' in gate:
+        return [registry.get_id(f"{prefix}.a_exp_gt_b"),
+                registry.get_id(f"{prefix}.exp_eq_and_mant_a_ge")]
+
+    registry.register(f"{prefix}.a_magnitude_ge_b")
+
+    if '.not_a_mag_ge_b' in gate:
+        return [registry.get_id(f"{prefix}.a_magnitude_ge_b")]
+
+    registry.register(f"{prefix}.not_a_mag_ge_b")
+
+    if '.diff_sign_sel_a' in gate:
+        return [registry.get_id(f"{prefix}.sign_a"),
+                registry.get_id(f"{prefix}.a_magnitude_ge_b")]
+
+    if '.diff_sign_sel_b' in gate:
+        return [registry.get_id(f"{prefix}.sign_b"),
+                registry.get_id(f"{prefix}.not_a_mag_ge_b")]
+
+    registry.register(f"{prefix}.diff_sign_sel_a")
+    registry.register(f"{prefix}.diff_sign_sel_b")
+
+    if '.diff_result_sign' in gate:
+        return [registry.get_id(f"{prefix}.diff_sign_sel_a"),
+                registry.get_id(f"{prefix}.diff_sign_sel_b")]
+
+    registry.register(f"{prefix}.diff_result_sign")
+
+    if '.result_sign_same' in gate:
+        return [registry.get_id(f"{prefix}.sign_a"),
+                registry.get_id(f"{prefix}.signs_same")]
+
+    if '.result_sign_diff' in gate:
+        return [registry.get_id(f"{prefix}.diff_result_sign"),
+                registry.get_id(f"{prefix}.signs_differ.layer2")]
+
+    registry.register(f"{prefix}.result_sign_same")
+    registry.register(f"{prefix}.result_sign_diff")
+
+    if gate == f"{prefix}.result_sign":
+        return [registry.get_id(f"{prefix}.result_sign_same"),
+                registry.get_id(f"{prefix}.result_sign_diff")]
+
+    registry.register(f"{prefix}.result_sign")
+
+    # Normalization - sum overflow (bit 11 of sum, not carry out)
+    if '.sum_overflow' in gate:
+        return [registry.get_id(f"{prefix}.mant_add.fa11.xor2.layer2")]
+
+    registry.register(f"{prefix}.sum_overflow")
+
+    # CLZ on bits 10:0 of sum for normalization (11 bits, not 12)
+    sum_bits = [f"{prefix}.mant_add.fa{i}.xor2.layer2" for i in range(11)]
+
+    match = re.search(r'\.sum_pz(\d+)$', gate)
+    if match:
+        k = int(match.group(1))
+        # Check bits 10, 9, 8, ... (from MSB to LSB of 11-bit sum)
+        return [registry.get_id(sum_bits[10-i]) for i in range(k)]
+
+    for k in range(1, 12):
+        registry.register(f"{prefix}.sum_pz{k}")
+
+    pz_ids = [registry.get_id(f"{prefix}.sum_pz{k}") for k in range(1, 12)]
+
+    match = re.search(r'\.sum_ge(\d+)$', gate)
+    if match:
+        return pz_ids
+
+    for k in range(1, 12):
+        registry.register(f"{prefix}.sum_ge{k}")
+
+    match = re.search(r'\.sum_not_ge(\d+)$', gate)
+    if match:
+        k = int(match.group(1))
+        return [registry.get_id(f"{prefix}.sum_ge{k}")]
+
+    for k in [2, 4, 6, 8, 10]:
+        registry.register(f"{prefix}.sum_not_ge{k}")
+
+    if '.norm_shift3' in gate:
+        return [registry.get_id(f"{prefix}.sum_ge8")]
+
+    if '.norm_and_4_7' in gate:
+        return [registry.get_id(f"{prefix}.sum_ge4"),
+                registry.get_id(f"{prefix}.sum_not_ge8")]
+
+    registry.register(f"{prefix}.norm_and_4_7")
+
+    # For 11-bit CLZ (max 11), shift2 = norm_and_4_7 only
+    if '.norm_shift2' in gate:
+        return [registry.get_id(f"{prefix}.norm_and_4_7")]
+
+    if '.norm_and_2_3' in gate:
+        return [registry.get_id(f"{prefix}.sum_ge2"),
+                registry.get_id(f"{prefix}.sum_not_ge4")]
+    if '.norm_and_6_7' in gate:
+        return [registry.get_id(f"{prefix}.sum_ge6"),
+                registry.get_id(f"{prefix}.sum_not_ge8")]
+    # For 11-bit CLZ (max 11), ge10 is sufficient (CLZ 10 or 11)
+    if '.norm_and_10_11' in gate:
+        return [registry.get_id(f"{prefix}.sum_ge10")]
+
+    registry.register(f"{prefix}.norm_and_2_3")
+    registry.register(f"{prefix}.norm_and_6_7")
+    registry.register(f"{prefix}.norm_and_10_11")
+
+    if '.norm_shift1' in gate:
+        return [registry.get_id(f"{prefix}.norm_and_2_3"),
+                registry.get_id(f"{prefix}.norm_and_6_7"),
+                registry.get_id(f"{prefix}.norm_and_10_11")]
+
+    match = re.search(r'\.norm_and_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i in [1, 3, 5, 7, 9]:
+            return [registry.get_id(f"{prefix}.sum_ge{i}"),
+                    registry.get_id(f"{prefix}.sum_not_ge{i+1}")]
+
+    for i in [1, 3, 5, 7, 9]:
+        registry.register(f"{prefix}.norm_and_{i}")
+
+    if '.norm_shift0' in gate:
+        return [registry.get_id(f"{prefix}.norm_and_{i}") for i in [1, 3, 5, 7, 9]]
+
+    for i in range(4):
+        registry.register(f"{prefix}.norm_shift{i}")
+
+    # Stage 10: Normalization application
+    if '.not_sum_overflow' in gate:
+        return [registry.get_id(f"{prefix}.sum_overflow")]
+
+    registry.register(f"{prefix}.not_sum_overflow")
+
+    # Overflow mantissa (right-shift by 1)
+    match = re.search(r'\.norm_mant_overflow(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.get_id(f"{prefix}.mant_add.fa{i+1}.xor2.layer2")]
+
+    for i in range(10):
+        registry.register(f"{prefix}.norm_mant_overflow{i}")
+
+    # Left barrel shifter NOT gates
+    for i in range(4):
+        if f'.not_norm_shift{i}' in gate and '.not_norm_shift_sub' not in gate:
+            return [registry.get_id(f"{prefix}.norm_shift{i}")]
+        registry.register(f"{prefix}.not_norm_shift{i}")
+
+    # Left barrel shifter stage 0
+    match = re.search(r'\.lshift_s0_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.mant_add.fa{i}.xor2.layer2"),
+                    registry.get_id(f"{prefix}.not_norm_shift0")]
+        if '.shift' in gate and i > 0:
+            return [registry.get_id(f"{prefix}.mant_add.fa{i-1}.xor2.layer2"),
+                    registry.get_id(f"{prefix}.norm_shift0")]
+
+    match = re.search(r'\.lshift_s0_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i > 0:
+            return [registry.register(f"{prefix}.lshift_s0_{i}.pass"),
+                    registry.register(f"{prefix}.lshift_s0_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.lshift_s0_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.lshift_s0_{i}")
+
+    # Left barrel shifter stage 1
+    match = re.search(r'\.lshift_s1_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.lshift_s0_{i}"),
+                    registry.get_id(f"{prefix}.not_norm_shift1")]
+        if '.shift' in gate and i > 1:
+            return [registry.get_id(f"{prefix}.lshift_s0_{i-2}"),
+                    registry.get_id(f"{prefix}.norm_shift1")]
+
+    match = re.search(r'\.lshift_s1_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i > 1:
+            return [registry.register(f"{prefix}.lshift_s1_{i}.pass"),
+                    registry.register(f"{prefix}.lshift_s1_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.lshift_s1_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.lshift_s1_{i}")
+
+    # Left barrel shifter stage 2
+    match = re.search(r'\.lshift_s2_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.lshift_s1_{i}"),
+                    registry.get_id(f"{prefix}.not_norm_shift2")]
+        if '.shift' in gate and i > 3:
+            return [registry.get_id(f"{prefix}.lshift_s1_{i-4}"),
+                    registry.get_id(f"{prefix}.norm_shift2")]
+
+    match = re.search(r'\.lshift_s2_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i > 3:
+            return [registry.register(f"{prefix}.lshift_s2_{i}.pass"),
+                    registry.register(f"{prefix}.lshift_s2_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.lshift_s2_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.lshift_s2_{i}")
+
+    # Left barrel shifter stage 3
+    match = re.search(r'\.lshift_s3_(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.pass' in gate:
+            return [registry.get_id(f"{prefix}.lshift_s2_{i}"),
+                    registry.get_id(f"{prefix}.not_norm_shift3")]
+        if '.shift' in gate and i > 7:
+            return [registry.get_id(f"{prefix}.lshift_s2_{i-8}"),
+                    registry.get_id(f"{prefix}.norm_shift3")]
+
+    match = re.search(r'\.lshift_s3_(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i > 7:
+            return [registry.register(f"{prefix}.lshift_s3_{i}.pass"),
+                    registry.register(f"{prefix}.lshift_s3_{i}.shift")]
+        else:
+            return [registry.register(f"{prefix}.lshift_s3_{i}.pass")]
+
+    for i in range(11):
+        registry.register(f"{prefix}.lshift_s3_{i}")
+
+    # Normalized mantissa selection
+    match = re.search(r'\.norm_mant(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.overflow_path' in gate:
+            return [registry.get_id(f"{prefix}.norm_mant_overflow{i}"),
+                    registry.get_id(f"{prefix}.sum_overflow")]
+        if '.normal_path' in gate:
+            return [registry.get_id(f"{prefix}.lshift_s3_{i}"),
+                    registry.get_id(f"{prefix}.not_sum_overflow")]
+
+    match = re.search(r'\.norm_mant(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.norm_mant{i}.overflow_path"),
+                registry.register(f"{prefix}.norm_mant{i}.normal_path")]
+
+    for i in range(10):
+        registry.register(f"{prefix}.norm_mant{i}")
+
+    # Exponent increment (for overflow)
+    if '.exp_inc.ha0.sum' in gate:
+        return [registry.get_id(f"{prefix}.exp_larger0")]
+    if '.exp_inc.ha0.cout' in gate:
+        return [registry.get_id(f"{prefix}.exp_larger0")]
+
+    registry.register(f"{prefix}.exp_inc.ha0.sum")
+    registry.register(f"{prefix}.exp_inc.ha0.cout")
+
+    for i in range(1, 5):
+        if f'.exp_inc.ha{i}.xor.layer1' in gate:
+            return [registry.get_id(f"{prefix}.exp_larger{i}"),
+                    registry.get_id(f"{prefix}.exp_inc.ha{i-1}.cout")]
+        if f'.exp_inc.ha{i}.sum' in gate:
+            return [registry.register(f"{prefix}.exp_inc.ha{i}.xor.layer1.or"),
+                    registry.register(f"{prefix}.exp_inc.ha{i}.xor.layer1.nand")]
+        if f'.exp_inc.ha{i}.cout' in gate:
+            return [registry.get_id(f"{prefix}.exp_larger{i}"),
+                    registry.get_id(f"{prefix}.exp_inc.ha{i-1}.cout")]
+        registry.register(f"{prefix}.exp_inc.ha{i}.sum")
+        registry.register(f"{prefix}.exp_inc.ha{i}.cout")
+
+    # Exponent decrement NOT gates
+    for i in range(4):
+        if f'.not_norm_shift_sub{i}' in gate:
+            return [registry.get_id(f"{prefix}.norm_shift{i}")]
+        registry.register(f"{prefix}.not_norm_shift_sub{i}")
+
+    # Exponent decrement (for no overflow)
+    if '.exp_dec.fa' in gate:
+        match = re.search(r'\.exp_dec\.fa(\d+)\.', gate)
+        if match:
+            i = int(match.group(1))
+            fa_prefix = f"{prefix}.exp_dec.fa{i}"
+
+            exp_bit = registry.get_id(f"{prefix}.exp_larger{i}")
+            if i < 4:
+                not_shift = registry.get_id(f"{prefix}.not_norm_shift_sub{i}")
+            else:
+                not_shift = registry.get_id("#1")
+
+            if i == 0:
+                cin = registry.get_id("#1")
+            else:
+                cin = registry.register(f"{prefix}.exp_dec.fa{i-1}.cout")
+
+            if '.xor1.layer1' in gate:
+                return [exp_bit, not_shift]
+            if '.xor1.layer2' in gate:
+                return [registry.register(f"{fa_prefix}.xor1.layer1.or"),
+                        registry.register(f"{fa_prefix}.xor1.layer1.nand")]
+
+            xor1 = registry.register(f"{fa_prefix}.xor1.layer2")
+
+            if '.xor2.layer1' in gate:
+                return [xor1, cin]
+            if '.xor2.layer2' in gate:
+                return [registry.register(f"{fa_prefix}.xor2.layer1.or"),
+                        registry.register(f"{fa_prefix}.xor2.layer1.nand")]
+
+            if '.and1' in gate:
+                return [exp_bit, not_shift]
+            if '.and2' in gate:
+                return [xor1, cin]
+            if '.cout' in gate:
+                return [registry.register(f"{fa_prefix}.and1"),
+                        registry.register(f"{fa_prefix}.and2")]
+
+    for i in range(5):
+        registry.register(f"{prefix}.exp_dec.fa{i}.xor2.layer2")
+        registry.register(f"{prefix}.exp_dec.fa{i}.cout")
+
+    # Result exponent selection
+    match = re.search(r'\.result_exp(\d+)\.', gate)
+    if match:
+        i = int(match.group(1))
+        if '.overflow_path' in gate:
+            if i == 0:
+                return [registry.get_id(f"{prefix}.exp_inc.ha0.sum"),
+                        registry.get_id(f"{prefix}.sum_overflow")]
+            else:
+                return [registry.get_id(f"{prefix}.exp_inc.ha{i}.sum"),
+                        registry.get_id(f"{prefix}.sum_overflow")]
+        if '.normal_path' in gate:
+            return [registry.get_id(f"{prefix}.exp_dec.fa{i}.xor2.layer2"),
+                    registry.get_id(f"{prefix}.not_sum_overflow")]
+
+    match = re.search(r'\.result_exp(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.result_exp{i}.overflow_path"),
+                registry.register(f"{prefix}.result_exp{i}.normal_path")]
+
+    for i in range(5):
+        registry.register(f"{prefix}.result_exp{i}")
+
+    # Output assembly
+    if '.not_result_is_inf' in gate:
+        return [registry.get_id(f"{prefix}.result_is_inf")]
+
+    registry.register(f"{prefix}.not_result_is_inf")
+    registry.register(f"{prefix}.result_is_inf")
+
+    if '.is_normal_result' in gate:
+        return [registry.get_id(f"{prefix}.not_result_is_nan"),
+                registry.get_id(f"{prefix}.not_result_is_inf")]
+
+    registry.register(f"{prefix}.is_normal_result")
+
+    # Inf sign selection
+    if '.inf_sign_sel_a' in gate:
+        return [registry.get_id(f"{prefix}.sign_a"),
+                registry.get_id(f"{prefix}.a_is_inf")]
+    if '.inf_sign_sel_b' in gate:
+        return [registry.get_id(f"{prefix}.sign_b"),
+                registry.get_id(f"{prefix}.b_is_inf")]
+
+    registry.register(f"{prefix}.inf_sign_sel_a")
+    registry.register(f"{prefix}.inf_sign_sel_b")
+
+    if '.inf_sign' in gate and '.inf_sign_sel' not in gate:
+        return [registry.get_id(f"{prefix}.inf_sign_sel_a"),
+                registry.get_id(f"{prefix}.inf_sign_sel_b")]
+
+    registry.register(f"{prefix}.inf_sign")
+
+    # NaN bits
+    nan_bits = [0]*9 + [1] + [1]*5 + [0]
+    match = re.search(r'\.out_nan(\d+)$', gate)
+    if match:
+        return [registry.get_id(f"{prefix}.result_is_nan")]
+
+    # Inf bits
+    match = re.search(r'\.out_inf(\d+)$', gate)
+    if match:
+        return [registry.get_id(f"{prefix}.result_is_inf")]
+
+    # Normal output path
+    match = re.search(r'\.out_normal(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        if i == 15:
+            return [registry.get_id(f"{prefix}.result_sign")]
+        elif i >= 10:
+            return [registry.get_id(f"{prefix}.result_exp{i-10}")]
+        else:
+            return [registry.get_id(f"{prefix}.norm_mant{i}")]
+
+    for i in range(16):
+        registry.register(f"{prefix}.out_normal{i}")
+
+    # Final output gates
+    match = re.search(r'\.out(\d+)\.(nan_gate|inf_gate|normal_gate)$', gate)
+    if match:
+        i = int(match.group(1))
+        gate_type = match.group(2)
+        if gate_type == 'nan_gate':
+            nan_val = registry.register(f"{prefix}.out_nan{i}") if nan_bits[i] else registry.get_id("#0")
+            return [nan_val, registry.get_id(f"{prefix}.result_is_nan")]
+        elif gate_type == 'inf_gate':
+            if i >= 10 and i < 15:
+                inf_val = registry.register(f"{prefix}.out_inf{i}")
+            elif i == 15:
+                inf_val = registry.get_id(f"{prefix}.inf_sign")
+            else:
+                inf_val = registry.get_id("#0")
+            return [inf_val, registry.get_id(f"{prefix}.result_is_inf")]
+        elif gate_type == 'normal_gate':
+            return [registry.get_id(f"{prefix}.out_normal{i}"),
+                    registry.get_id(f"{prefix}.is_normal_result")]
+
+    match = re.search(r'\.out(\d+)$', gate)
+    if match:
+        i = int(match.group(1))
+        return [registry.register(f"{prefix}.out{i}.nan_gate"),
+                registry.register(f"{prefix}.out{i}.inf_gate"),
+                registry.register(f"{prefix}.out{i}.normal_gate")]
+
+    return []
+
+
 def infer_float16_neg_inputs(gate: str, registry: SignalRegistry) -> List[int]:
     """Infer inputs for float16.neg circuit."""
     prefix = "float16.neg"
@@ -1726,6 +2691,874 @@ def build_clz16bit_tensors() -> Dict[str, torch.Tensor]:
     return tensors
 
 
+def build_float16_add_tensors() -> Dict[str, torch.Tensor]:
+    """Build tensors for float16.add circuit.
+
+    IEEE 754 half-precision addition with full special case handling:
+    1. Detect special cases (NaN, infinity, zero, subnormal)
+    2. Extract sign, exponent, mantissa from both operands
+    3. Add implicit bit (1 for normal, 0 for subnormal)
+    4. Compare exponents to find which is larger
+    5. Align mantissas by shifting smaller exponent's mantissa right
+    6. Add or subtract mantissas based on signs
+    7. Normalize result and adjust exponent
+    8. Handle overflow (to infinity) and underflow (to zero/subnormal)
+    9. Pack result with correct special case outputs
+
+    Inputs: $a[0:15], $b[0:15] (two float16 values)
+    Outputs: out[0:15] (float16 result)
+    """
+    tensors = {}
+    prefix = "float16.add"
+
+    # =========================================================================
+    # STAGE 0: SPECIAL CASE DETECTION
+    # =========================================================================
+    # Detect NaN, infinity, zero, and subnormal inputs.
+    # float16 encoding:
+    #   - Zero: exp=0, mant=0
+    #   - Subnormal: exp=0, mant≠0
+    #   - Normal: 0 < exp < 31
+    #   - Infinity: exp=31, mant=0
+    #   - NaN: exp=31, mant≠0
+
+    # exp_a_all_ones: all 5 exponent bits are 1 (exp >= 31)
+    # Threshold gate: sum of exp bits >= 5
+    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: all 5 exponent bits are 0 (NOR gate)
+    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: OR of all 10 mantissa bits
+    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: NOR of all mantissa bits
+    tensors[f"{prefix}.mant_a_zero.weight"] = torch.tensor([-1.0] * 10)
+    tensors[f"{prefix}.mant_a_zero.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.mant_b_zero.weight"] = torch.tensor([-1.0] * 10)
+    tensors[f"{prefix}.mant_b_zero.bias"] = torch.tensor([0.0])
+
+    # a_is_nan: exp_a_all_ones AND mant_a_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_a_all_ones AND mant_a_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_a_zero AND mant_a_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])
+
+    # a_is_subnormal: exp_a_zero AND mant_a_nonzero
+    tensors[f"{prefix}.a_is_subnormal.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_is_subnormal.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.b_is_subnormal.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.b_is_subnormal.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])
+
+    # both_are_inf: a_is_inf AND b_is_inf
+    tensors[f"{prefix}.both_are_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.both_are_inf.bias"] = torch.tensor([-2.0])
+
+    # signs_differ: sign_a XOR sign_b (for inf + (-inf) = NaN case)
+    # XOR layer 1
+    tensors[f"{prefix}.signs_differ.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.signs_differ.layer1.or.bias"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.signs_differ.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+    tensors[f"{prefix}.signs_differ.layer1.nand.bias"] = torch.tensor([1.0])
+    tensors[f"{prefix}.signs_differ.layer2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.signs_differ.layer2.bias"] = torch.tensor([-2.0])
+
+    # inf_cancellation: both_are_inf AND signs_differ (produces NaN)
+    tensors[f"{prefix}.inf_cancellation.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.inf_cancellation.bias"] = torch.tensor([-2.0])
+
+    # result_is_nan: either_is_nan OR inf_cancellation
+    tensors[f"{prefix}.result_is_nan.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_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])
+
+    # NOT result_is_nan (for masking inf result)
+    tensors[f"{prefix}.not_result_is_nan.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_result_is_nan.bias"] = torch.tensor([0.0])
+
+    # result_is_inf: either_is_inf AND NOT result_is_nan
+    tensors[f"{prefix}.result_is_inf.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_is_inf.bias"] = torch.tensor([-2.0])
+
+    # =========================================================================
+    # STAGE 1: EXTRACT COMPONENTS
+    # =========================================================================
+    # sign_a = a[15], sign_b = b[15]
+    # exp_a[0:4] = a[10:14], exp_b[0:4] = b[10:14]
+    # mant_a[0:9] = a[0:9], mant_b[0:9] = b[0:9]
+
+    # Pass-through gates for sign extraction
+    tensors[f"{prefix}.sign_a.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.sign_a.bias"] = torch.tensor([-0.5])
+
+    tensors[f"{prefix}.sign_b.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.sign_b.bias"] = torch.tensor([-0.5])
+
+    # Implicit bit calculation:
+    # For normal numbers, implicit bit = 1
+    # For subnormal numbers, implicit bit = 0
+    # implicit_a = NOT a_is_subnormal AND NOT a_is_zero = NOT exp_a_zero
+    # Actually simpler: implicit_a = NOT exp_a_zero (since exp=0 means no implicit 1)
+    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])
+
+    # =========================================================================
+    # STAGE 2: EXPONENT COMPARISON
+    # =========================================================================
+    # Compare exp_a vs exp_b using weighted comparison
+    # Weights: bit[i] contributes 2^i to the total
+    # exp_a >= exp_b when weighted(exp_a) - weighted(exp_b) >= 0
+
+    weights_exp_a = [float(2**i) for i in range(5)]  # +1, +2, +4, +8, +16
+    weights_exp_b = [-float(2**i) for i in range(5)]  # -1, -2, -4, -8, -16
+
+    # a_exp_ge_b: exp_a >= exp_b
+    tensors[f"{prefix}.a_exp_ge_b.weight"] = torch.tensor(weights_exp_a + weights_exp_b)
+    tensors[f"{prefix}.a_exp_ge_b.bias"] = torch.tensor([0.0])  # >= (not strict >)
+
+    # a_exp_gt_b: exp_a > exp_b (for strict comparison)
+    tensors[f"{prefix}.a_exp_gt_b.weight"] = torch.tensor(weights_exp_a + weights_exp_b)
+    tensors[f"{prefix}.a_exp_gt_b.bias"] = torch.tensor([-0.5])  # strict >
+
+    # b_exp_gt_a: exp_b > exp_a
+    tensors[f"{prefix}.b_exp_gt_a.weight"] = torch.tensor(weights_exp_b[::-1] + weights_exp_a[::-1])
+    # Actually, simpler: just swap the inputs conceptually
+    # b > a means weights for b positive, weights for a negative
+    tensors[f"{prefix}.b_exp_gt_a.weight"] = torch.tensor(weights_exp_a + weights_exp_b)
+    tensors[f"{prefix}.b_exp_gt_a.bias"] = torch.tensor([-0.5])
+
+    # NOT of a_exp_ge_b (for selecting which path)
+    tensors[f"{prefix}.b_exp_gt_a_sel.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.b_exp_gt_a_sel.bias"] = torch.tensor([0.0])
+
+    # =========================================================================
+    # STAGE 3: COMPUTE EXPONENT DIFFERENCE
+    # =========================================================================
+    # We need |exp_a - exp_b| for the shift amount.
+    # Use 5-bit subtractors: exp_a - exp_b and exp_b - exp_a
+    # Then select based on which exponent is larger.
+
+    # 5-bit subtractor for exp_a - exp_b (using two's complement)
+    # 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])
+
+    # Full adders for exp_a + NOT(exp_b) + 1 = exp_a - exp_b
+    # FA0: bit 0
+    # XOR1: exp_a[0] XOR not_exp_b[0]
+    tensors[f"{prefix}.diff_ab.fa0.xor1.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor1.layer1.or.bias"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor1.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor1.layer1.nand.bias"] = torch.tensor([1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor1.layer2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor1.layer2.bias"] = torch.tensor([-2.0])
+
+    # XOR2: xor1 XOR cin (cin=1 for subtraction)
+    tensors[f"{prefix}.diff_ab.fa0.xor2.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor2.layer1.or.bias"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor2.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor2.layer1.nand.bias"] = torch.tensor([1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor2.layer2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.xor2.layer2.bias"] = torch.tensor([-2.0])
+
+    # Carry: (a AND b) OR (xor1 AND cin)
+    tensors[f"{prefix}.diff_ab.fa0.and1.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.and1.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.diff_ab.fa0.and2.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.and2.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.diff_ab.fa0.cout.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_ab.fa0.cout.bias"] = torch.tensor([-1.0])
+
+    # FA1-FA4: remaining bits (carry chain)
+    for i in range(1, 5):
+        p = f"{prefix}.diff_ab.fa{i}"
+
+        # XOR1: exp_a[i] XOR not_exp_b[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])
+
+        # XOR2: xor1 XOR carry_in
+        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])
+
+        # Carry
+        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])
+
+    # Similarly for exp_b - exp_a
+    # NOT gates for exp_a
+    for i in range(5):
+        tensors[f"{prefix}.not_exp_a{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_exp_a{i}.bias"] = torch.tensor([0.0])
+
+    # Full adders for exp_b + NOT(exp_a) + 1 = exp_b - exp_a
+    for i in range(5):
+        p = f"{prefix}.diff_ba.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: SELECT ABSOLUTE DIFFERENCE
+    # =========================================================================
+    # exp_diff = a_exp_ge_b ? (exp_a - exp_b) : (exp_b - exp_a)
+    # Use 2-to-1 mux for each bit
+
+    for i in range(5):
+        # Mux: out = (sel AND b) OR (NOT sel AND a)
+        # sel = b_exp_gt_a_sel (1 if b > a, meaning we want diff_ba)
+        # Actually: sel=0 (a>=b) -> use diff_ab, sel=1 (b>a) -> use diff_ba
+
+        # AND gate for diff_ab path (when a_exp_ge_b = 1)
+        tensors[f"{prefix}.exp_diff_mux{i}.and_ab.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_diff_mux{i}.and_ab.bias"] = torch.tensor([-2.0])
+
+        # AND gate for diff_ba path (when b_exp_gt_a_sel = 1, i.e., a_exp_ge_b = 0)
+        tensors[f"{prefix}.exp_diff_mux{i}.and_ba.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_diff_mux{i}.and_ba.bias"] = torch.tensor([-2.0])
+
+        # OR to combine
+        tensors[f"{prefix}.exp_diff{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_diff{i}.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 5: SELECT LARGER EXPONENT (for result)
+    # =========================================================================
+    # exp_larger = a_exp_ge_b ? exp_a : exp_b
+
+    for i in range(5):
+        # AND gate for exp_a path
+        tensors[f"{prefix}.exp_larger_mux{i}.and_a.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_larger_mux{i}.and_a.bias"] = torch.tensor([-2.0])
+
+        # AND gate for exp_b path
+        tensors[f"{prefix}.exp_larger_mux{i}.and_b.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_larger_mux{i}.and_b.bias"] = torch.tensor([-2.0])
+
+        # OR to combine
+        tensors[f"{prefix}.exp_larger{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_larger{i}.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 6: MANTISSA ALIGNMENT (Barrel Shifter)
+    # =========================================================================
+    # The smaller exponent's mantissa needs to be shifted right by exp_diff.
+    # Mantissa is 11 bits: implicit bit + 10 explicit mantissa bits.
+    #
+    # We need to:
+    # 1. Select which mantissa to shift (the one with smaller exponent)
+    # 2. Shift it right by exp_diff positions
+    # 3. The larger mantissa passes through unchanged
+    #
+    # For the barrel shifter, we use cascaded 2-to-1 muxes:
+    # - Stage 0: shift by 0 or 1 (controlled by exp_diff[0])
+    # - Stage 1: shift by 0 or 2 (controlled by exp_diff[1])
+    # - Stage 2: shift by 0 or 4 (controlled by exp_diff[2])
+    # - Stage 3: shift by 0 or 8 (controlled by exp_diff[3])
+    #
+    # If exp_diff >= 11, the shifted mantissa becomes 0 (complete loss).
+
+    # First, select which mantissa gets shifted (the smaller exponent one)
+    # mant_to_shift = a_exp_ge_b ? mant_b : mant_a (shift the smaller exp's mantissa)
+    # mant_larger = a_exp_ge_b ? mant_a : mant_b
+
+    # Full mantissa with implicit bit: 11 bits (bit 10 = implicit, bits 9-0 = explicit)
+    for i in range(11):
+        # mant_shift_src[i] = mux(a_exp_ge_b, mant_b[i], mant_a[i])
+        # When a_exp_ge_b=1, we shift b's mantissa (a has larger exp)
+        # When a_exp_ge_b=0, we shift a's mantissa (b has larger exp)
+
+        tensors[f"{prefix}.mant_shift_src{i}.and_b.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_shift_src{i}.and_b.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.mant_shift_src{i}.and_a.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_shift_src{i}.and_a.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.mant_shift_src{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_shift_src{i}.bias"] = torch.tensor([-1.0])
+
+        # mant_larger[i] = mux(a_exp_ge_b, mant_a[i], mant_b[i])
+        tensors[f"{prefix}.mant_larger{i}.and_a.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_larger{i}.and_a.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.mant_larger{i}.and_b.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_larger{i}.and_b.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.mant_larger{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_larger{i}.bias"] = torch.tensor([-1.0])
+
+    # Barrel shifter stages
+    # Stage 0: shift by 1 if exp_diff[0]=1
+    # NOT exp_diff[0] for pass-through path
+    tensors[f"{prefix}.not_exp_diff0.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_exp_diff0.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        # Output bit i comes from:
+        # - bit i if not shifting (exp_diff[0]=0)
+        # - bit i+1 if shifting (exp_diff[0]=1), or 0 if i+1 >= 11
+        tensors[f"{prefix}.shift_s0_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.shift_s0_{i}.pass.bias"] = torch.tensor([-2.0])
+
+        if i < 10:
+            tensors[f"{prefix}.shift_s0_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.shift_s0_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.shift_s0_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            # MSB: shift path is 0, so just pass-through when not shifting
+            tensors[f"{prefix}.shift_s0_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.shift_s0_{i}.bias"] = torch.tensor([-1.0])
+
+    # Stage 1: shift by 2 if exp_diff[1]=1
+    tensors[f"{prefix}.not_exp_diff1.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_exp_diff1.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.shift_s1_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.shift_s1_{i}.pass.bias"] = torch.tensor([-2.0])
+
+        if i < 9:
+            tensors[f"{prefix}.shift_s1_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.shift_s1_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.shift_s1_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.shift_s1_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.shift_s1_{i}.bias"] = torch.tensor([-1.0])
+
+    # Stage 2: shift by 4 if exp_diff[2]=1
+    tensors[f"{prefix}.not_exp_diff2.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_exp_diff2.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.shift_s2_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.shift_s2_{i}.pass.bias"] = torch.tensor([-2.0])
+
+        if i < 7:
+            tensors[f"{prefix}.shift_s2_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.shift_s2_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.shift_s2_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.shift_s2_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.shift_s2_{i}.bias"] = torch.tensor([-1.0])
+
+    # Stage 3: shift by 8 if exp_diff[3]=1
+    tensors[f"{prefix}.not_exp_diff3.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_exp_diff3.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.shift_s3_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.shift_s3_{i}.pass.bias"] = torch.tensor([-2.0])
+
+        if i < 3:
+            tensors[f"{prefix}.shift_s3_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.shift_s3_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.shift_s3_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.shift_s3_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.shift_s3_{i}.bias"] = torch.tensor([-1.0])
+
+    # If exp_diff[4]=1 (shift by 16 or more), result is 0
+    # mant_aligned = exp_diff[4] ? 0 : shift_s3 result
+    tensors[f"{prefix}.not_exp_diff4.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_exp_diff4.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        # Only pass through if exp_diff[4]=0
+        tensors[f"{prefix}.mant_aligned{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.mant_aligned{i}.bias"] = torch.tensor([-2.0])
+
+    # =========================================================================
+    # STAGE 7: MANTISSA ADDITION/SUBTRACTION
+    # =========================================================================
+    # If signs are the same: add mantissas
+    # If signs differ: subtract smaller from larger
+    #
+    # We have:
+    # - mant_larger[10:0]: mantissa of the larger exponent operand
+    # - mant_aligned[10:0]: shifted mantissa of the smaller exponent operand
+    #
+    # For subtraction, we need to know which mantissa is larger.
+    # If exp_a > exp_b, then mant_a is the reference (could be smaller mantissa value)
+    # If exp_a == exp_b, we need to compare mantissas directly.
+    #
+    # signs_same: NOT signs_differ
+    tensors[f"{prefix}.signs_same.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.signs_same.bias"] = torch.tensor([0.0])
+
+    # For the result sign when signs differ:
+    # If exp_a > exp_b: result sign = sign_a
+    # If exp_b > exp_a: result sign = sign_b
+    # If exp_a == exp_b: result sign = sign of larger mantissa
+
+    # Mantissa comparison (for equal exponent case)
+    # Compare mant_a vs mant_b when exponents are equal
+    weights_mant = [float(2**i) for i in range(11)]
+    neg_weights_mant = [-float(2**i) for i in range(11)]
+
+    tensors[f"{prefix}.mant_a_ge_b.weight"] = torch.tensor(weights_mant + neg_weights_mant)
+    tensors[f"{prefix}.mant_a_ge_b.bias"] = torch.tensor([0.0])
+
+    # 12-bit adder for mantissa sum (11 mantissa bits + 1 carry out)
+    # We'll compute mant_larger + mant_aligned (for same sign)
+    # or |mant_larger - mant_aligned| (for different signs)
+
+    # For subtraction, we need: larger_mant - smaller_mant
+    # If exponents differ, larger exp means larger value, so:
+    #   result = mant_larger - mant_aligned
+    # If exponents equal, compare mantissas:
+    #   result = |mant_a - mant_b|
+
+    # NOT gates for mant_aligned (for subtraction)
+    for i in range(11):
+        tensors[f"{prefix}.not_mant_aligned{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_mant_aligned{i}.bias"] = torch.tensor([0.0])
+
+    # 12-bit adder/subtractor
+    # When signs_same=1: add (carry_in = 0)
+    # When signs_same=0: subtract (use NOT mant_aligned, carry_in = 1)
+
+    # Carry input selection: signs_same ? 0 : 1
+    # This is just NOT signs_same = signs_differ
+    tensors[f"{prefix}.sub_cin.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.sub_cin.bias"] = torch.tensor([-0.5])
+
+    # Operand B selection: signs_same ? mant_aligned : NOT mant_aligned
+    for i in range(11):
+        # When adding (signs_same=1): use mant_aligned
+        tensors[f"{prefix}.addsub_b{i}.add.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.addsub_b{i}.add.bias"] = torch.tensor([-2.0])
+
+        # When subtracting (signs_same=0 = signs_differ=1): use NOT mant_aligned
+        tensors[f"{prefix}.addsub_b{i}.sub.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.addsub_b{i}.sub.bias"] = torch.tensor([-2.0])
+
+        tensors[f"{prefix}.addsub_b{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.addsub_b{i}.bias"] = torch.tensor([-1.0])
+
+    # 12-bit ripple carry adder for mant_larger + addsub_b + sub_cin
+    for i in range(12):
+        p = f"{prefix}.mant_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])
+
+    # =========================================================================
+    # STAGE 8: RESULT SIGN DETERMINATION
+    # =========================================================================
+    # When signs_same: result_sign = sign_a (= sign_b)
+    # When signs_differ:
+    #   If a has larger magnitude: result_sign = sign_a
+    #   If b has larger magnitude: result_sign = sign_b
+    #
+    # Magnitude comparison: consider both exponent and mantissa
+    # a_magnitude_ge_b: (exp_a > exp_b) OR (exp_a == exp_b AND mant_a >= mant_b)
+
+    # exp_a_eq_b: NOT a_exp_gt_b AND NOT b_exp_gt_a
+    tensors[f"{prefix}.not_a_exp_gt_b.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_a_exp_gt_b.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.exp_a_eq_b.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.exp_a_eq_b.bias"] = torch.tensor([-2.0])
+
+    # exp_eq_and_mant_a_ge: exp_a_eq_b AND mant_a_ge_b
+    tensors[f"{prefix}.exp_eq_and_mant_a_ge.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.exp_eq_and_mant_a_ge.bias"] = torch.tensor([-2.0])
+
+    # a_magnitude_ge_b: a_exp_gt_b OR exp_eq_and_mant_a_ge
+    tensors[f"{prefix}.a_magnitude_ge_b.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.a_magnitude_ge_b.bias"] = torch.tensor([-1.0])
+
+    # result_sign when signs_differ:
+    # = a_magnitude_ge_b ? sign_a : sign_b
+    tensors[f"{prefix}.not_a_mag_ge_b.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_a_mag_ge_b.bias"] = torch.tensor([0.0])
+
+    tensors[f"{prefix}.diff_sign_sel_a.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_sign_sel_a.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.diff_sign_sel_b.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_sign_sel_b.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.diff_result_sign.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.diff_result_sign.bias"] = torch.tensor([-1.0])
+
+    # Final result sign: signs_same ? sign_a : diff_result_sign
+    tensors[f"{prefix}.result_sign_same.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign_same.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.result_sign_diff.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign_diff.bias"] = torch.tensor([-2.0])
+
+    tensors[f"{prefix}.result_sign.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.result_sign.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 9: NORMALIZATION
+    # =========================================================================
+    # The mantissa sum may need normalization:
+    # - If bit 12 (carry out) is set: right shift by 1, increment exponent
+    # - If leading bit is 0: left shift until leading 1 found, decrement exponent
+    #
+    # Use CLZ to find shift amount for left shift case.
+    # The sum is 12 bits (mant_add output).
+
+    # Overflow detection: mant_add.fa11 carry out
+    tensors[f"{prefix}.sum_overflow.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.sum_overflow.bias"] = torch.tensor([-0.5])
+
+    # CLZ on 11-bit sum (bits 10:0) to find normalization shift
+    # For non-overflow case, count leading zeros starting from bit 10
+    # pz gates: prefix zero detectors on bits 10:0
+    for k in range(1, 12):
+        tensors[f"{prefix}.sum_pz{k}.weight"] = torch.tensor([-1.0] * k)
+        tensors[f"{prefix}.sum_pz{k}.bias"] = torch.tensor([0.0])
+
+    # ge gates: sum of pz >= k (for 11-bit CLZ, max is 11)
+    for k in range(1, 12):
+        tensors[f"{prefix}.sum_ge{k}.weight"] = torch.tensor([1.0] * 11)
+        tensors[f"{prefix}.sum_ge{k}.bias"] = torch.tensor([-float(k)])
+
+    # NOT gates for binary encoding
+    for k in [2, 4, 6, 8, 10]:
+        tensors[f"{prefix}.sum_not_ge{k}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.sum_not_ge{k}.bias"] = torch.tensor([0.0])
+
+    # Shift amount encoding (4 bits for 0-11)
+    # CLZ of 11 bits can be 0-11
+    tensors[f"{prefix}.norm_shift3.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.norm_shift3.bias"] = torch.tensor([-0.5])  # ge8
+
+    tensors[f"{prefix}.norm_and_4_7.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.norm_and_4_7.bias"] = torch.tensor([-2.0])
+    # For 11-bit CLZ (max 11), shift2 = ge4 AND NOT ge8 (no ge12 needed)
+    tensors[f"{prefix}.norm_shift2.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.norm_shift2.bias"] = torch.tensor([-0.5])
+
+    tensors[f"{prefix}.norm_and_2_3.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.norm_and_2_3.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.norm_and_6_7.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.norm_and_6_7.bias"] = torch.tensor([-2.0])
+    # For 11-bit CLZ (max 11), ge10 means CLZ is 10 or 11, no need for NOT ge12
+    tensors[f"{prefix}.norm_and_10_11.weight"] = torch.tensor([1.0])
+    tensors[f"{prefix}.norm_and_10_11.bias"] = torch.tensor([-0.5])
+    tensors[f"{prefix}.norm_shift1.weight"] = torch.tensor([1.0, 1.0, 1.0])
+    tensors[f"{prefix}.norm_shift1.bias"] = torch.tensor([-1.0])
+
+    for i in [1, 3, 5, 7, 9]:
+        tensors[f"{prefix}.norm_and_{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.norm_and_{i}.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.norm_shift0.weight"] = torch.tensor([1.0] * 5)
+    tensors[f"{prefix}.norm_shift0.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 10: APPLY NORMALIZATION TO MANTISSA
+    # =========================================================================
+    # Two cases:
+    # 1. Overflow (sum bit 11 set): right-shift mantissa by 1, increment exponent
+    # 2. No overflow: left-shift mantissa by norm_shift, decrement exponent
+
+    # NOT sum_overflow for non-overflow path
+    tensors[f"{prefix}.not_sum_overflow.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_sum_overflow.bias"] = torch.tensor([0.0])
+
+    # Overflow mantissa: bits 10:1 of adder_sum (right-shifted by 1)
+    # norm_mant_overflow[i] = adder_sum[i+1] for i in 0..9
+    for i in range(10):
+        tensors[f"{prefix}.norm_mant_overflow{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.norm_mant_overflow{i}.bias"] = torch.tensor([-0.5])
+
+    # Non-overflow mantissa: left-shift adder_sum[10:0] by norm_shift amount
+    # This requires a left barrel shifter on the 11-bit sum (bits 10:0)
+
+    # Left barrel shifter stage 0: shift left by 1 if norm_shift[0]=1
+    tensors[f"{prefix}.not_norm_shift0.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_norm_shift0.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.lshift_s0_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.lshift_s0_{i}.pass.bias"] = torch.tensor([-2.0])
+        if i > 0:
+            tensors[f"{prefix}.lshift_s0_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.lshift_s0_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.lshift_s0_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.lshift_s0_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.lshift_s0_{i}.bias"] = torch.tensor([-1.0])
+
+    # Left barrel shifter stage 1: shift left by 2 if norm_shift[1]=1
+    tensors[f"{prefix}.not_norm_shift1.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_norm_shift1.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.lshift_s1_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.lshift_s1_{i}.pass.bias"] = torch.tensor([-2.0])
+        if i > 1:
+            tensors[f"{prefix}.lshift_s1_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.lshift_s1_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.lshift_s1_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.lshift_s1_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.lshift_s1_{i}.bias"] = torch.tensor([-1.0])
+
+    # Left barrel shifter stage 2: shift left by 4 if norm_shift[2]=1
+    tensors[f"{prefix}.not_norm_shift2.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_norm_shift2.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.lshift_s2_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.lshift_s2_{i}.pass.bias"] = torch.tensor([-2.0])
+        if i > 3:
+            tensors[f"{prefix}.lshift_s2_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.lshift_s2_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.lshift_s2_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.lshift_s2_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.lshift_s2_{i}.bias"] = torch.tensor([-1.0])
+
+    # Left barrel shifter stage 3: shift left by 8 if norm_shift[3]=1
+    tensors[f"{prefix}.not_norm_shift3.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_norm_shift3.bias"] = torch.tensor([0.0])
+
+    for i in range(11):
+        tensors[f"{prefix}.lshift_s3_{i}.pass.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.lshift_s3_{i}.pass.bias"] = torch.tensor([-2.0])
+        if i > 7:
+            tensors[f"{prefix}.lshift_s3_{i}.shift.weight"] = torch.tensor([1.0, 1.0])
+            tensors[f"{prefix}.lshift_s3_{i}.shift.bias"] = torch.tensor([-2.0])
+            tensors[f"{prefix}.lshift_s3_{i}.weight"] = torch.tensor([1.0, 1.0])
+        else:
+            tensors[f"{prefix}.lshift_s3_{i}.weight"] = torch.tensor([1.0])
+        tensors[f"{prefix}.lshift_s3_{i}.bias"] = torch.tensor([-1.0])
+
+    # Select normalized mantissa: overflow ? overflow_mant : lshift result
+    # Take bits 9:0 for the output mantissa (bit 10 is implicit, dropped)
+    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])
+
+    # =========================================================================
+    # STAGE 11: ADJUST EXPONENT
+    # =========================================================================
+    # Overflow: exp_result = exp_larger + 1
+    # No overflow: exp_result = exp_larger - norm_shift
+
+    # Increment exponent by 1 (for overflow case)
+    # Half adder chain: exp_larger + 1
+    tensors[f"{prefix}.exp_inc.ha0.sum.weight"] = torch.tensor([-1.0])  # NOT for XOR with 1
+    tensors[f"{prefix}.exp_inc.ha0.sum.bias"] = torch.tensor([0.0])
+    tensors[f"{prefix}.exp_inc.ha0.cout.weight"] = torch.tensor([1.0])  # AND with 1 = passthrough
+    tensors[f"{prefix}.exp_inc.ha0.cout.bias"] = torch.tensor([-0.5])
+
+    for i in range(1, 5):
+        # XOR: exp[i] XOR carry_in
+        tensors[f"{prefix}.exp_inc.ha{i}.xor.layer1.or.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_inc.ha{i}.xor.layer1.or.bias"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.exp_inc.ha{i}.xor.layer1.nand.weight"] = torch.tensor([-1.0, -1.0])
+        tensors[f"{prefix}.exp_inc.ha{i}.xor.layer1.nand.bias"] = torch.tensor([1.0])
+        tensors[f"{prefix}.exp_inc.ha{i}.sum.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_inc.ha{i}.sum.bias"] = torch.tensor([-2.0])
+        # Carry: exp[i] AND carry_in
+        tensors[f"{prefix}.exp_inc.ha{i}.cout.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.exp_inc.ha{i}.cout.bias"] = torch.tensor([-2.0])
+
+    # Decrement exponent by norm_shift (for non-overflow case)
+    # 5-bit subtractor: exp_larger - norm_shift
+    # NOT gates for norm_shift
+    for i in range(4):
+        tensors[f"{prefix}.not_norm_shift_sub{i}.weight"] = torch.tensor([-1.0])
+        tensors[f"{prefix}.not_norm_shift_sub{i}.bias"] = torch.tensor([0.0])
+
+    # Full adders for exp_larger + NOT(norm_shift) + 1 = exp_larger - norm_shift
+    for i in range(5):
+        p = f"{prefix}.exp_dec.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])
+
+    # Select result exponent: overflow ? exp_inc : exp_dec
+    for i in range(5):
+        tensors[f"{prefix}.result_exp{i}.overflow_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.result_exp{i}.overflow_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.result_exp{i}.normal_path.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.result_exp{i}.normal_path.bias"] = torch.tensor([-2.0])
+        tensors[f"{prefix}.result_exp{i}.weight"] = torch.tensor([1.0, 1.0])
+        tensors[f"{prefix}.result_exp{i}.bias"] = torch.tensor([-1.0])
+
+    # =========================================================================
+    # STAGE 12: OUTPUT ASSEMBLY
+    # =========================================================================
+    # Final output combines:
+    # - Special cases (NaN, Inf) override normal computation
+    # - For NaN: output canonical NaN (0x7E00)
+    # - For Inf: output Inf with correct sign
+    # - For normal: pack normalized result
+
+    # NaN output: 0x7E00 = 0111111000000000
+    nan_bits = [0]*9 + [1] + [1]*5 + [0]  # bits 0-15
+
+    # Final output mux: nan ? nan_val : (inf ? inf_val : normal_val)
+    tensors[f"{prefix}.not_result_is_inf.weight"] = torch.tensor([-1.0])
+    tensors[f"{prefix}.not_result_is_inf.bias"] = torch.tensor([0.0])
+
+    # Normal case selector: NOT nan AND NOT inf
+    tensors[f"{prefix}.is_normal_result.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.is_normal_result.bias"] = torch.tensor([-2.0])
+
+    # Inf sign selection
+    tensors[f"{prefix}.inf_sign_sel_a.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.inf_sign_sel_a.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.inf_sign_sel_b.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.inf_sign_sel_b.bias"] = torch.tensor([-2.0])
+    tensors[f"{prefix}.inf_sign.weight"] = torch.tensor([1.0, 1.0])
+    tensors[f"{prefix}.inf_sign.bias"] = torch.tensor([-1.0])
+
+    for i in range(16):
+        # NaN path: output NaN bits gated by result_is_nan
+        if nan_bits[i]:
+            tensors[f"{prefix}.out_nan{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_nan{i}.bias"] = torch.tensor([-0.5])
+
+        # Inf path: exponent bits = 1, mantissa = 0, sign from inf operand
+        if i >= 10 and i < 15:
+            tensors[f"{prefix}.out_inf{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_inf{i}.bias"] = torch.tensor([-0.5])
+
+        # Normal path
+        if i < 10:
+            # Mantissa bits from norm_mant
+            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:
+            # Exponent bits from result_exp
+            tensors[f"{prefix}.out_normal{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_normal{i}.bias"] = torch.tensor([-0.5])
+        else:
+            # Sign bit from result_sign
+            tensors[f"{prefix}.out_normal{i}.weight"] = torch.tensor([1.0])
+            tensors[f"{prefix}.out_normal{i}.bias"] = torch.tensor([-0.5])
+
+        # Final output: 3-way mux (nan, inf, normal)
+        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}.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])
+        tensors[f"{prefix}.out{i}.bias"] = torch.tensor([-1.0])
+
+    return tensors
+
+
 def build_clz8bit_tensors() -> Dict[str, torch.Tensor]:
     """Build tensors for arithmetic.clz8bit circuit.
 
@@ -1795,6 +3628,12 @@ def main():
 
     print(f"Loaded {len(tensors)} tensors")
 
+    # Remove old float16.add tensors (we're rebuilding from scratch)
+    old_float16_add = [k for k in tensors.keys() if k.startswith('float16.add')]
+    for k in old_float16_add:
+        del tensors[k]
+    print(f"Removed {len(old_float16_add)} old float16.add tensors")
+
     # Build new circuits
     print("Building new circuits...")
     clz_tensors = build_clz8bit_tensors()
@@ -1829,6 +3668,10 @@ def main():
     tensors.update(abs_tensors)
     print(f"  float16.abs: {len(abs_tensors)} tensors")
 
+    add_tensors = build_float16_add_tensors()
+    tensors.update(add_tensors)
+    print(f"  float16.add: {len(add_tensors)} tensors")
+
     print(f"Total tensors: {len(tensors)}")
 
     # Load routing for complex circuits

eval.py

@@ -632,6 +632,159 @@ class CircuitEvaluator:
 
         return TestResult('float16.abs', passed, len(test_values), failures)
 
+    def test_float16_add(self) -> TestResult:
+        """Test float16.add (IEEE 754 addition)."""
+        prefix = 'float16.add'
+        failures = []
+        passed = 0
+
+        import struct
+        import math
+
+        def float16_to_float(bits):
+            try:
+                return struct.unpack('e', struct.pack('H', bits))[0]
+            except:
+                return float('nan')
+
+        def float_to_float16(f):
+            try:
+                return struct.unpack('H', struct.pack('e', f))[0]
+            except:
+                return 0x7E00  # NaN
+
+        # Test cases: pairs of (a, b)
+        test_cases = [
+            # Zero cases
+            (0x0000, 0x0000),  # +0 + +0 = +0
+            (0x0000, 0x3C00),  # +0 + 1.0 = 1.0
+            (0x3C00, 0x0000),  # 1.0 + +0 = 1.0
+
+            # Same sign addition
+            (0x3C00, 0x3C00),  # 1.0 + 1.0 = 2.0
+            (0x4000, 0x3C00),  # 2.0 + 1.0 = 3.0
+            (0x3800, 0x3800),  # 0.5 + 0.5 = 1.0
+            (0x4200, 0x4000),  # 3.0 + 2.0 = 5.0
+
+            # Different sign (subtraction)
+            (0x4000, 0xBC00),  # 2.0 + (-1.0) = 1.0
+            (0x3C00, 0xBC00),  # 1.0 + (-1.0) = 0.0
+            (0xBC00, 0x4000),  # -1.0 + 2.0 = 1.0
+            (0xC000, 0x3C00),  # -2.0 + 1.0 = -1.0
+
+            # Negative + negative
+            (0xBC00, 0xBC00),  # -1.0 + -1.0 = -2.0
+            (0xC000, 0xBC00),  # -2.0 + -1.0 = -3.0
+
+            # Different exponents
+            (0x4400, 0x3C00),  # 4.0 + 1.0 = 5.0
+            (0x4800, 0x3C00),  # 8.0 + 1.0 = 9.0
+            (0x3C00, 0x3400),  # 1.0 + 0.25 = 1.25
+
+            # Infinity cases
+            (0x7C00, 0x3C00),  # +inf + 1.0 = +inf
+            (0x3C00, 0x7C00),  # 1.0 + +inf = +inf
+            (0xFC00, 0xBC00),  # -inf + -1.0 = -inf
+            (0x7C00, 0xFC00),  # +inf + -inf = NaN
+
+            # NaN cases
+            (0x7E00, 0x3C00),  # NaN + 1.0 = NaN
+            (0x3C00, 0x7E00),  # 1.0 + NaN = NaN
+        ]
+
+        # Add some random test cases
+        import random
+        random.seed(42)
+        for _ in range(50):
+            a = random.randint(0, 0x7BFF)  # positive normal
+            b = random.randint(0, 0x7BFF)
+            test_cases.append((a, b))
+            # Some negative combinations
+            if random.random() > 0.5:
+                test_cases.append((a | 0x8000, b))
+            if random.random() > 0.5:
+                test_cases.append((a, b | 0x8000))
+
+        for a_bits, b_bits in test_cases:
+            a_float = float16_to_float(a_bits)
+            b_float = float16_to_float(b_bits)
+
+            # Expected result
+            if math.isnan(a_float) or math.isnan(b_float):
+                expected_nan = True
+                expected_inf = False
+                expected = 0x7E00
+            elif math.isinf(a_float) and math.isinf(b_float):
+                if (a_float > 0) != (b_float > 0):
+                    expected_nan = True
+                    expected_inf = False
+                    expected = 0x7E00
+                else:
+                    expected_nan = False
+                    expected_inf = True
+                    expected = 0x7C00 if a_float > 0 else 0xFC00
+            elif math.isinf(a_float):
+                expected_nan = False
+                expected_inf = True
+                expected = 0x7C00 if a_float > 0 else 0xFC00
+            elif math.isinf(b_float):
+                expected_nan = False
+                expected_inf = True
+                expected = 0x7C00 if b_float > 0 else 0xFC00
+            else:
+                expected_nan = False
+                expected_inf = False
+                result_float = a_float + b_float
+                expected = float_to_float16(result_float)
+
+            # Set up inputs
+            ext = {}
+            for i in range(16):
+                ext[f'{prefix}.$a[{i}]'] = float((a_bits >> i) & 1)
+                ext[f'{prefix}.$b[{i}]'] = float((b_bits >> i) & 1)
+
+            values = self.eval_circuit(prefix, ext)
+
+            # Extract result
+            result = 0
+            for i in range(16):
+                bit = int(values.get(f'{prefix}.out{i}', 0))
+                result |= (bit << i)
+
+            # Check special cases first
+            result_is_nan = int(values.get(f'{prefix}.result_is_nan', 0))
+            result_is_inf = int(values.get(f'{prefix}.result_is_inf', 0))
+
+            # For NaN, check that result_is_nan is set
+            if expected_nan:
+                if result_is_nan == 1:
+                    passed += 1
+                else:
+                    if len(failures) < 10:
+                        failures.append((a_bits, b_bits, 'expected NaN', result, a_float, b_float))
+            # For Inf, check result_is_inf and sign
+            elif expected_inf:
+                expected_sign = (expected >> 15) & 1
+                result_sign = (result >> 15) & 1
+                if result_is_inf == 1:
+                    passed += 1
+                else:
+                    if len(failures) < 10:
+                        failures.append((a_bits, b_bits, expected, result, a_float, b_float))
+            else:
+                # For normal results, allow small tolerance
+                if result == expected:
+                    passed += 1
+                else:
+                    # Check if within 1 ULP
+                    if abs(result - expected) <= 1:
+                        passed += 1
+                    else:
+                        if len(failures) < 10:
+                            failures.append((a_bits, b_bits, expected, result, a_float, b_float))
+
+        return TestResult('float16.add', passed, len(test_cases), failures)
+
     # =========================================================================
     # ARITHMETIC TESTS (DIRECT EVALUATION)
     # =========================================================================
@@ -827,6 +980,11 @@ class Evaluator:
             self.results.append(result)
             if verbose:
                 self._print_result(result)
+        if 'float16.add.sign_a.weight' in self.eval.tensors:
+            result = self.eval.test_float16_add()
+            self.results.append(result)
+            if verbose:
+                self._print_result(result)
 
         # Comparators
         if verbose: