float mul: full IEEE subnormal support via a unified right-shift renormalizer (right-shift the product by F+1-min(nlz,exp_base)); oracle validated bit-exact against numpy over all classes including deep underflow; all float variants rebuilt

neural_computer.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f3168c466f9fc791c09b76e1c61d92290db6c2e4861a9f3a918538a5e5739f1b
-size 32744930
+oid sha256:9340602703da2e7563954a45a2febb1d8ed026ac861b493883add2d5311f1f9d
+size 33592582

src/build.py

@@ -1334,18 +1334,16 @@ def add_float_mul(tensors: Dict[str, torch.Tensor], family: str,
 
     Self-contained circuit; external inputs are the raw operand words
     $a[0..W-1] / $b[0..W-1] (MSB-first). Contract: exact IEEE specials
-    (NaN, infinities, signed zeros), flush-to-zero for subnormal operands
-    and results, round-to-nearest-even for the mantissa.
+    (NaN, infinities, signed zeros), subnormal operands and gradual-underflow
+    subnormal results, round-to-nearest-even for the mantissa.
 
     Datapath: (F+1)x(F+1) partial products accumulated shift-add into the
-    2F+2-bit product, a one-bit normalize mux, guard/round/sticky extraction
-    with a round-to-nearest-even incrementer on the fraction, an
-    E+2-bit two's-complement exponent chain computing exp_a + exp_b - bias
-    + msb plus a rounding-overflow carry, range detectors, and a one-hot
-    specials selection network producing the output word.
-
-    Rounding: round-to-nearest-even (RNE). Underflow still flushes to zero
-    and NaN/Inf specials are exact.
+    2F+2-bit product; a leading-zero count and an E+2-bit exponent chain give
+    exp_base = exp_a + exp_b - bias and a signed clamp min(nlz, exp_base); the
+    product is right-shifted by (F+1) - that clamp (one shifter that normalizes
+    normal results, denormalizes subnormal ones, and drives deeply underflowing
+    products to zero), then round-to-nearest-even and a one-hot specials network
+    produce the output word.
     """
     E, F = exp_bits, frac_bits
     prefix = f"{family}.mul"
@@ -1354,14 +1352,19 @@ def add_float_mul(tensors: Dict[str, torch.Tensor], family: str,
     add_gate(tensors, f"{prefix}.sign_xor.layer1.nand", [-1.0, -1.0], [1.0])
     add_gate(tensors, f"{prefix}.sign_xor.layer2", [1.0, 1.0], [-2.0])
 
-    # Operand classification (FTZ: exp == 0 means the operand is zero).
+    # Operand classification. Subnormals (exp==0, frac!=0) are nonzero datapath
+    # operands with implicit bit 0 and effective exponent 1.
     for op in ("a", "b"):
         add_gate(tensors, f"{prefix}.{op}.exp_zero", [-1.0] * E, [0.0])
+        add_gate(tensors, f"{prefix}.{op}.exp_nzero", [1.0] * E, [-1.0])
         add_gate(tensors, f"{prefix}.{op}.exp_max", [1.0] * E, [-float(E)])
         add_gate(tensors, f"{prefix}.{op}.frac_nz", [1.0] * F, [-1.0])
         add_gate(tensors, f"{prefix}.{op}.frac_zero", [-1.0] * F, [0.0])
         add_gate(tensors, f"{prefix}.{op}.is_nan", [1.0, 1.0], [-2.0])
         add_gate(tensors, f"{prefix}.{op}.is_inf", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{prefix}.{op}.is_zero", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{prefix}.{op}.nonzero", [-1.0], [0.0])
+        add_gate(tensors, f"{prefix}.{op}.eexp_lsb", [1.0, 1.0], [-1.0])
 
     # exp_add: exp_a + exp_b in E+1 bits.
     for bit in range(E + 1):
@@ -1377,46 +1380,75 @@ def add_float_mul(tensors: Dict[str, torch.Tensor], family: str,
         for bit in range(2 * F + 2):
             add_full_adder(tensors, f"{prefix}.mant_mul.acc.s{stage}.fa{bit}")
 
-    # Normalize by one: product in [1, 4); frac output muxes.
+    # exp_base = exp_a + exp_b - bias (E+2-bit signed). Right-shift the product
+    # by rshift = (F+1) - min(nlz, exp_base): places the mantissa for normal
+    # results, denormalizes for subnormal ones; a deeply negative exp_base makes
+    # rshift exceed the product width and the result becomes zero.
+    RESM = 2 * F + 2
+    nlzb = 0
+    while (1 << nlzb) <= RESM:
+        nlzb += 1
+    RB = 0
+    while (1 << RB) < RESM:
+        RB += 1
+    for bit in range(E + 2):
+        add_full_adder(tensors, f"{prefix}.expb.fa{bit}")
+    for pos in range(1, RESM):
+        add_gate(tensors, f"{prefix}.lzc.any_higher{pos}", [1.0] * pos, [-1.0])
+        add_gate(tensors, f"{prefix}.lzc.is_highest{pos}.not_higher", [-1.0], [0.0])
+        add_gate(tensors, f"{prefix}.lzc.is_highest{pos}.and", [1.0, 1.0], [-2.0])
+    add_gate(tensors, f"{prefix}.lzc.nz", [1.0] * RESM, [-1.0])
+    add_gate(tensors, f"{prefix}.lzc.not_nz", [-1.0], [0.0])
+    for bbit in range(nlzb):
+        fan = sum(1 for pos in range(1, RESM) if (pos >> bbit) & 1)
+        add_gate(tensors, f"{prefix}.lzc.nlz.bit{bbit}", [1.0] * max(1, fan), [-1.0])
+    for bbit in range(nlzb):
+        add_gate(tensors, f"{prefix}.exp_nnlz.bit{bbit}", [-1.0], [0.0])
+    for k in range(E + 2):
+        add_full_adder(tensors, f"{prefix}.exp_s1.fa{k}")            # exp_base - nlz
+        add_full_adder(tensors, f"{prefix}.exp_r.fa{k}")             # + 1
+    add_gate(tensors, f"{prefix}.er.zero", [-1.0] * (E + 2), [0.0])
+    add_gate(tensors, f"{prefix}.er.underflow", [1.0, 1.0], [-1.0])
+    add_gate(tensors, f"{prefix}.er.not_underflow", [-1.0], [0.0])
+    for k in range(E + 2):
+        add_gate(tensors, f"{prefix}.exprc.bit{k}", [1.0, 1.0], [-2.0])   # er clamped >= 0
+    for k in range(E + 2):                                                # nsh = min(nlz, exp_base)
+        add_gate(tensors, f"{prefix}.nsh.bit{k}.not_sel", [-1.0], [0.0])
+        add_gate(tensors, f"{prefix}.nsh.bit{k}.and_a", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{prefix}.nsh.bit{k}.and_b", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{prefix}.nsh.bit{k}.or", [1.0, 1.0], [-1.0])
+    for k in range(E + 2):
+        add_gate(tensors, f"{prefix}.nshc.bit{k}", [-1.0], [0.0])   # ~nsh
+        add_full_adder(tensors, f"{prefix}.rsh.fa{k}")             # rsh = F + ~nsh + 1 = F - nsh
+    add_gate(tensors, f"{prefix}.too_deep", [1.0] * (E + 2 - RB), [-1.0])
+    add_gate(tensors, f"{prefix}.not_deep", [-1.0], [0.0])
+    for j in range(RB):                                            # right-barrel by rshift
+        add_gate(tensors, f"{prefix}.rbar.s{j}.drop", [1.0] * (1 << j), [-1.0])
+        add_gate(tensors, f"{prefix}.rbar.s{j}.st_and", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{prefix}.rbar.s{j}.sticky", [1.0, 1.0], [-1.0])
+        for k in range(RESM + 1):                                  # product widened by 1 low bit
+            add_gate(tensors, f"{prefix}.rbar.s{j}.bit{k}.not_sel", [-1.0], [0.0])
+            add_gate(tensors, f"{prefix}.rbar.s{j}.bit{k}.and_a", [1.0, 1.0], [-2.0])
+            add_gate(tensors, f"{prefix}.rbar.s{j}.bit{k}.and_b", [1.0, 1.0], [-2.0])
+            add_gate(tensors, f"{prefix}.rbar.s{j}.bit{k}.or", [1.0, 1.0], [-1.0])
     for k in range(F):
-        add_gate(tensors, f"{prefix}.norm.bit{k}.not_sel", [-1.0], [0.0])
-        add_gate(tensors, f"{prefix}.norm.bit{k}.and_a", [1.0, 1.0], [-2.0])
-        add_gate(tensors, f"{prefix}.norm.bit{k}.and_b", [1.0, 1.0], [-2.0])
-        add_gate(tensors, f"{prefix}.norm.bit{k}.or", [1.0, 1.0], [-1.0])
-
-    # Round-to-nearest-even. Guard/round selected on the normalize bit; sticky
-    # ORs the product tail; round-up = G AND (L OR R OR S); the fraction is
-    # incremented, with the carry-out bumping the exponent.
-    for nm in ("g", "r"):
-        add_gate(tensors, f"{prefix}.round.{nm}.not_sel", [-1.0], [0.0])
-        add_gate(tensors, f"{prefix}.round.{nm}.and_a", [1.0, 1.0], [-2.0])
-        add_gate(tensors, f"{prefix}.round.{nm}.and_b", [1.0, 1.0], [-2.0])
-        add_gate(tensors, f"{prefix}.round.{nm}.or", [1.0, 1.0], [-1.0])
-    add_gate(tensors, f"{prefix}.round.sticky_base", [1.0] * (F - 2), [-1.0])
-    add_gate(tensors, f"{prefix}.round.sticky_extra", [1.0, 1.0], [-2.0])
-    add_gate(tensors, f"{prefix}.round.sticky", [1.0, 1.0], [-1.0])
-    add_gate(tensors, f"{prefix}.round.rsl", [1.0, 1.0, 1.0], [-1.0])
-    add_gate(tensors, f"{prefix}.round.up", [1.0, 1.0], [-2.0])
+        add_gate(tensors, f"{prefix}.sig.bit{k}", [1.0, 1.0], [-2.0])       # shifted[k+1] AND not_deep
+    add_gate(tensors, f"{prefix}.round.guard", [1.0, 1.0], [-2.0])          # shifted[0] AND not_deep
+    add_gate(tensors, f"{prefix}.deep_nz", [1.0, 1.0], [-2.0])              # too_deep AND product nonzero
+    add_gate(tensors, f"{prefix}.round.sticky", [1.0, 1.0], [-1.0])         # barrel sticky OR deep_nz
+    add_gate(tensors, f"{prefix}.round.rsl", [1.0, 1.0], [-1.0])            # sticky OR lsb
+    add_gate(tensors, f"{prefix}.round.up", [1.0, 1.0], [-2.0])             # guard AND rsl
     for k in range(F):
         add_gate(tensors, f"{prefix}.rnd.bit{k}.xor.layer1.or", [1.0, 1.0], [-1.0])
         add_gate(tensors, f"{prefix}.rnd.bit{k}.xor.layer1.nand", [-1.0, -1.0], [1.0])
         add_gate(tensors, f"{prefix}.rnd.bit{k}.xor.layer2", [1.0, 1.0], [-2.0])
         add_gate(tensors, f"{prefix}.rnd.bit{k}.carry", [1.0, 1.0], [-2.0])
-
-    # exp_r = exp_add + msb + (2^(E+2) - bias), E+2-bit two's complement.
-    for bit in range(E + 2):
-        add_full_adder(tensors, f"{prefix}.exp_r.fa{bit}")
-
-    # exp_final = exp_r + rounding carry-out (E+2-bit incrementer).
     for bit in range(E + 2):
         add_gate(tensors, f"{prefix}.exp_round.bit{bit}.xor.layer1.or", [1.0, 1.0], [-1.0])
         add_gate(tensors, f"{prefix}.exp_round.bit{bit}.xor.layer1.nand", [-1.0, -1.0], [1.0])
         add_gate(tensors, f"{prefix}.exp_round.bit{bit}.xor.layer2", [1.0, 1.0], [-2.0])
         add_gate(tensors, f"{prefix}.exp_round.bit{bit}.carry", [1.0, 1.0], [-2.0])
-
-    # Range detectors on exp_final.
     add_gate(tensors, f"{prefix}.exp_r.zero", [-1.0] * (E + 2), [0.0])
-    add_gate(tensors, f"{prefix}.exp_r.underflow", [1.0, 1.0], [-1.0])
     add_gate(tensors, f"{prefix}.exp_r.not_neg", [-1.0], [0.0])
     add_gate(tensors, f"{prefix}.exp_r.and_low", [1.0] * E, [-float(E)])
     add_gate(tensors, f"{prefix}.exp_r.ge_emax", [1.0, 1.0], [-1.0])
@@ -2989,13 +3021,14 @@ def infer_float_mul_inputs(gate: str, reg: SignalRegistry, family: str,
     one = reg.get_id("#1")
 
     def m_a(k: int) -> int:
-        return one if k == F else a(W - 1 - k)
+        return R("a.exp_nzero") if k == F else a(W - 1 - k)
 
     def m_b(k: int) -> int:
-        return one if k == F else b(W - 1 - k)
+        return R("b.exp_nzero") if k == F else b(W - 1 - k)
 
-    def exp_sig(word, k: int) -> int:
-        return word(E - k) if k < E else zero
+    def eexp(op, k: int) -> int:
+        w = a if op == "a" else b
+        return R(f"{op}.eexp_lsb") if k == 0 else (w(E - k) if k < E else zero)
 
     def P(k: int) -> int:
         return R(f"mant_mul.acc.s{F - 1}.fa{k}.ha2.sum.layer2")
@@ -3004,47 +3037,67 @@ def infer_float_mul_inputs(gate: str, reg: SignalRegistry, family: str,
     exp_b_field = [b(1 + i) for i in range(E)]
     frac_a_field = [a(1 + E + i) for i in range(F)]
     frac_b_field = [b(1 + E + i) for i in range(F)]
-
     suffix = gate[len(prefix) + 1:] if gate != prefix else ""
-
     bias = (1 << (E - 1)) - 1
-    K = (1 << (E + 2)) - bias
+    RESM = 2 * F + 2
+    nlzb = 0
+    while (1 << nlzb) <= RESM:
+        nlzb += 1
+    RB = 0
+    while (1 << RB) < RESM:
+        RB += 1
+
+    def exp_l(k: int) -> int:                    # exp_base = exp_a + exp_b - bias
+        return R(f"expb.fa{k}.ha2.sum.layer2") if k < E + 2 else zero
+
+    def shifted(k: int) -> int:                  # product right-shifted by rsh
+        return R(f"rbar.s{RB - 1}.bit{k}.or")
 
     table = {
         "sign_xor.layer1.or": [a(0), b(0)],
         "sign_xor.layer1.nand": [a(0), b(0)],
         "sign_xor.layer2": [R("sign_xor.layer1.or"), R("sign_xor.layer1.nand")],
-        "a.exp_zero": exp_a_field, "a.exp_max": exp_a_field,
+        "a.exp_zero": exp_a_field, "a.exp_nzero": exp_a_field, "a.exp_max": exp_a_field,
         "a.frac_nz": frac_a_field, "a.frac_zero": frac_a_field,
         "a.is_nan": [R("a.exp_max"), R("a.frac_nz")],
         "a.is_inf": [R("a.exp_max"), R("a.frac_zero")],
-        "b.exp_zero": exp_b_field, "b.exp_max": exp_b_field,
+        "a.is_zero": [R("a.exp_zero"), R("a.frac_zero")], "a.nonzero": [R("a.is_zero")],
+        "a.eexp_lsb": [a(E), R("a.exp_zero")],
+        "b.exp_zero": exp_b_field, "b.exp_nzero": exp_b_field, "b.exp_max": exp_b_field,
         "b.frac_nz": frac_b_field, "b.frac_zero": frac_b_field,
         "b.is_nan": [R("b.exp_max"), R("b.frac_nz")],
         "b.is_inf": [R("b.exp_max"), R("b.frac_zero")],
+        "b.is_zero": [R("b.exp_zero"), R("b.frac_zero")], "b.nonzero": [R("b.is_zero")],
+        "b.eexp_lsb": [b(E), R("b.exp_zero")],
+        "lzc.nz": [P(k) for k in range(RESM)],
+        "lzc.not_nz": [R("lzc.nz")],
+        "er.zero": [R(f"exp_r.fa{k}.ha2.sum.layer2") for k in range(E + 2)],
+        "er.underflow": [R(f"exp_r.fa{E + 1}.ha2.sum.layer2"), R("er.zero")],
+        "er.not_underflow": [R("er.underflow")],
+        "too_deep": [R(f"rsh.fa{k}.ha2.sum.layer2") for k in range(RB, E + 2)],
+        "not_deep": [R("too_deep")],
+        "deep_nz": [R("too_deep"), R("lzc.nz")],
+        "round.guard": [shifted(0), R("not_deep")],
+        "round.sticky": [R(f"rbar.s{RB - 1}.sticky"), R("deep_nz")],
+        "round.rsl": [R("round.sticky"), R("sig.bit0")],
+        "round.up": [R("round.guard"), R("round.rsl")],
         "exp_r.zero": [R(f"exp_round.bit{k}.xor.layer2") for k in range(E + 2)],
-        "exp_r.underflow": [R(f"exp_round.bit{E + 1}.xor.layer2"), R("exp_r.zero")],
         "exp_r.not_neg": [R(f"exp_round.bit{E + 1}.xor.layer2")],
         "exp_r.and_low": [R(f"exp_round.bit{k}.xor.layer2") for k in range(E)],
         "exp_r.ge_emax": [R(f"exp_round.bit{E}.xor.layer2"), R("exp_r.and_low")],
         "exp_r.overflow": [R("exp_r.not_neg"), R("exp_r.ge_emax")],
-        "round.sticky_base": [P(k) for k in range(F - 2)],
-        "round.sticky_extra": [P(2 * F + 1), P(F - 2)],
-        "round.sticky": [R("round.sticky_base"), R("round.sticky_extra")],
-        "round.rsl": [R("round.r.or"), R("round.sticky"), R("norm.bit0.or")],
-        "round.up": [R("round.g.or"), R("round.rsl")],
         "sel.inputs_nan": [R("a.is_nan"), R("b.is_nan")],
-        "sel.inf_zero1": [R("a.is_inf"), R("b.exp_zero")],
-        "sel.inf_zero2": [R("b.is_inf"), R("a.exp_zero")],
+        "sel.inf_zero1": [R("a.is_inf"), R("b.is_zero")],
+        "sel.inf_zero2": [R("b.is_inf"), R("a.is_zero")],
         "sel.inf_zero": [R("sel.inf_zero1"), R("sel.inf_zero2")],
         "sel.nan": [R("sel.inputs_nan"), R("sel.inf_zero")],
         "sel.not_nan": [R("sel.nan")],
         "sel.inf_in": [R("a.is_inf"), R("b.is_inf")],
-        "sel.zero_in": [R("a.exp_zero"), R("b.exp_zero")],
+        "sel.zero_in": [R("a.is_zero"), R("b.is_zero")],
         "sel.inf_or_ovf": [R("sel.inf_in"), R("exp_r.overflow")],
         "sel.not_inf_path": [R("sel.inf_or_ovf")],
         "sel.inf": [R("sel.not_nan"), R("sel.inf_or_ovf")],
-        "sel.zero_or_unf": [R("sel.zero_in"), R("exp_r.underflow")],
+        "sel.zero_or_unf": [R("sel.zero_in"), R("sel.zero_in")],
         "sel.not_zero_unf": [R("sel.zero_or_unf")],
         "sel.zero": [R("sel.not_nan"), R("sel.not_inf_path"), R("sel.zero_or_unf")],
         "sel.norm": [R("sel.not_nan"), R("sel.not_inf_path"), R("sel.not_zero_unf")],
@@ -3062,7 +3115,15 @@ def infer_float_mul_inputs(gate: str, reg: SignalRegistry, family: str,
         k = int(m.group(1))
         cin = zero if k == 0 else R(f"exp_add.fa{k - 1}.carry_or")
         return _fa_member_inputs(m.group(2), f"{prefix}.exp_add.fa{k}",
-                                 exp_sig(a, k), exp_sig(b, k), cin, reg)
+                                 eexp("a", k), eexp("b", k), cin, reg)
+
+    m = re.match(r"^expb\.fa(\d+)\.(.+)$", suffix)          # exp_base = exp_add - bias
+    if m:
+        k = int(m.group(1))
+        a_sig = R(f"exp_add.fa{k}.ha2.sum.layer2") if k <= E else zero
+        b_sig = zero if (bias >> k) & 1 else one
+        cin = one if k == 0 else R(f"expb.fa{k - 1}.carry_or")
+        return _fa_member_inputs(m.group(2), f"{prefix}.expb.fa{k}", a_sig, b_sig, cin, reg)
 
     m = re.match(r"^mant_mul\.acc\.s(\d+)\.fa(\d+)\.(.+)$", suffix)
     if m:
@@ -3078,50 +3139,102 @@ def infer_float_mul_inputs(gate: str, reg: SignalRegistry, family: str,
         return _fa_member_inputs(m.group(3), f"{prefix}.mant_mul.acc.s{t}.fa{k}",
                                  a_sig, b_sig, cin, reg)
 
-    m = re.match(r"^norm\.bit(\d+)\.(not_sel|and_a|and_b|or)$", suffix)
+    m = re.match(r"^lzc\.any_higher(\d+)$", suffix)
+    if m:
+        pos = int(m.group(1))
+        return [P(RESM - 1 - t) for t in range(pos)]
+    m = re.match(r"^lzc\.is_highest(\d+)\.(not_higher|and)$", suffix)
+    if m:
+        pos = int(m.group(1))
+        if m.group(2) == "not_higher":
+            return [R(f"lzc.any_higher{pos}")]
+        return [P(RESM - 1 - pos), R(f"lzc.is_highest{pos}.not_higher")]
+    m = re.match(r"^lzc\.nlz\.bit(\d+)$", suffix)
+    if m:
+        bbit = int(m.group(1))
+        srcs = [R(f"lzc.is_highest{pos}.and") for pos in range(1, RESM) if (pos >> bbit) & 1]
+        return srcs if srcs else [zero]
+    m = re.match(r"^exp_nnlz\.bit(\d+)$", suffix)
+    if m:
+        return [R(f"lzc.nlz.bit{int(m.group(1))}")]
+    m = re.match(r"^exp_s1\.fa(\d+)\.(.+)$", suffix)          # exp_base - nlz
+    if m:
+        k = int(m.group(1))
+        b_sig = R(f"exp_nnlz.bit{k}") if k < nlzb else one
+        cin = one if k == 0 else R(f"exp_s1.fa{k - 1}.carry_or")
+        return _fa_member_inputs(m.group(2), f"{prefix}.exp_s1.fa{k}", exp_l(k), b_sig, cin, reg)
+    m = re.match(r"^exp_r\.fa(\d+)\.(.+)$", suffix)          # + 1
+    if m:
+        k = int(m.group(1))
+        a_sig = R(f"exp_s1.fa{k}.ha2.sum.layer2")
+        cin = one if k == 0 else R(f"exp_r.fa{k - 1}.carry_or")
+        return _fa_member_inputs(m.group(2), f"{prefix}.exp_r.fa{k}", a_sig, zero, cin, reg)
+    m = re.match(r"^exprc\.bit(\d+)$", suffix)               # er clamped to >= 0
+    if m:
+        k = int(m.group(1))
+        return [R(f"exp_r.fa{k}.ha2.sum.layer2"), R("er.not_underflow")]
+    m = re.match(r"^nsh\.bit(\d+)\.(not_sel|and_a|and_b|or)$", suffix)     # min(nlz, exp_base)
     if m:
         k = int(m.group(1))
         kind = m.group(2)
-        msb = P(2 * F + 1)
+        nlz_bit = R(f"lzc.nlz.bit{k}") if k < nlzb else zero
         if kind == "not_sel":
-            return [msb]
+            return [R("er.underflow")]
         if kind == "and_a":
-            return [P(F + k), R(f"norm.bit{k}.not_sel")]
+            return [nlz_bit, R(f"nsh.bit{k}.not_sel")]
         if kind == "and_b":
-            return [P(F + 1 + k), msb]
-        return [R(f"norm.bit{k}.and_a"), R(f"norm.bit{k}.and_b")]
-
-    m = re.match(r"^exp_r\.fa(\d+)\.(.+)$", suffix)
+            return [exp_l(k), R("er.underflow")]
+        return [R(f"nsh.bit{k}.and_a"), R(f"nsh.bit{k}.and_b")]
+    m = re.match(r"^nshc\.bit(\d+)$", suffix)                # ~nsh
+    if m:
+        return [R(f"nsh.bit{int(m.group(1))}.or")]
+    m = re.match(r"^rsh\.fa(\d+)\.(.+)$", suffix)            # rshift = (F+1) + ~nsh + 1
     if m:
         k = int(m.group(1))
-        a_sig = R(f"exp_add.fa{k}.ha2.sum.layer2") if k <= E else zero
-        b_sig = one if (K >> k) & 1 else zero
-        cin = P(2 * F + 1) if k == 0 else R(f"exp_r.fa{k - 1}.carry_or")
-        return _fa_member_inputs(m.group(2), f"{prefix}.exp_r.fa{k}",
-                                 a_sig, b_sig, cin, reg)
+        a_sig = one if ((F + 1) >> k) & 1 else zero
+        cin = one if k == 0 else R(f"rsh.fa{k - 1}.carry_or")
+        return _fa_member_inputs(m.group(2), f"{prefix}.rsh.fa{k}", a_sig, R(f"nshc.bit{k}"), cin, reg)
+    m = re.match(r"^rbar\.s(\d+)\.(.+)$", suffix)            # right-barrel shift by rshift
+    if m:
+        j = int(m.group(1))
+        rest = m.group(2)
+        sel = R(f"rsh.fa{j}.ha2.sum.layer2")
 
-    # RNE guard/round selection muxes on the normalize bit.
-    m = re.match(r"^round\.(g|r)\.(not_sel|and_a|and_b|or)$", suffix)
+        def rin(k: int) -> int:                              # widened product Pw = P << 1
+            if k < 0 or k > RESM:
+                return zero
+            if j == 0:
+                return zero if k == 0 else P(k - 1)
+            return R(f"rbar.s{j - 1}.bit{k}.or")
+
+        if rest == "drop":
+            return [rin(k) for k in range(1 << j)]
+        if rest == "st_and":
+            return [sel, R(f"rbar.s{j}.drop")]
+        if rest == "sticky":
+            prev = zero if j == 0 else R(f"rbar.s{j - 1}.sticky")
+            return [prev, R(f"rbar.s{j}.st_and")]
+        mm = re.match(r"^bit(\d+)\.(not_sel|and_a|and_b|or)$", rest)
+        if mm:
+            k = int(mm.group(1))
+            kind = mm.group(2)
+            if kind == "not_sel":
+                return [sel]
+            if kind == "and_a":
+                return [rin(k), R(f"rbar.s{j}.bit{k}.not_sel")]
+            if kind == "and_b":
+                return [rin(k + (1 << j)), sel]
+            return [R(f"rbar.s{j}.bit{k}.and_a"), R(f"rbar.s{j}.bit{k}.and_b")]
+    m = re.match(r"^sig\.bit(\d+)$", suffix)                 # mantissa frac bit (masked)
     if m:
-        nm, kind = m.group(1), m.group(2)
-        sel = P(2 * F + 1)
-        lo = P(F - 1) if nm == "g" else P(F - 2)   # MSB-clear source
-        hi = P(F) if nm == "g" else P(F - 1)         # MSB-set source
-        if kind == "not_sel":
-            return [sel]
-        if kind == "and_a":
-            return [lo, R(f"round.{nm}.not_sel")]
-        if kind == "and_b":
-            return [hi, sel]
-        return [R(f"round.{nm}.and_a"), R(f"round.{nm}.and_b")]
+        return [shifted(int(m.group(1)) + 1), R("not_deep")]
 
-    # Fraction round-up incrementer.
     m = re.match(r"^rnd\.bit(\d+)\.(.+)$", suffix)
     if m:
         k = int(m.group(1))
         rest = m.group(2)
         cin = R("round.up") if k == 0 else R(f"rnd.bit{k - 1}.carry")
-        f_bit = R(f"norm.bit{k}.or")
+        f_bit = R(f"sig.bit{k}")
         if rest == "xor.layer1.or" or rest == "xor.layer1.nand":
             return [f_bit, cin]
         if rest == "xor.layer2":
@@ -3129,13 +3242,12 @@ def infer_float_mul_inputs(gate: str, reg: SignalRegistry, family: str,
         if rest == "carry":
             return [f_bit, cin]
 
-    # Exponent rounding incrementer: exp_r + fraction carry-out.
     m = re.match(r"^exp_round\.bit(\d+)\.(.+)$", suffix)
     if m:
         k = int(m.group(1))
         rest = m.group(2)
         cin = R(f"rnd.bit{F - 1}.carry") if k == 0 else R(f"exp_round.bit{k - 1}.carry")
-        e_bit = R(f"exp_r.fa{k}.ha2.sum.layer2")
+        e_bit = R(f"exprc.bit{k}")
         if rest == "xor.layer1.or" or rest == "xor.layer1.nand":
             return [e_bit, cin]
         if rest == "xor.layer2":

src/eval.py

@@ -685,8 +685,9 @@ def float_test_words(exp_bits: int, frac_bits: int) -> Tuple[List[int], List[int
 
 def float_mul_oracle(aw: int, bw: int, exp_bits: int, frac_bits: int) -> int:
     """Expected product word under the documented contract: exact IEEE
-    specials (NaN, infinities, signed zeros), flush-to-zero subnormals,
-    round-to-nearest-even mantissa. Pure integer arithmetic, so exact."""
+    specials (NaN, infinities, signed zeros), subnormal operands and
+    gradual-underflow subnormal results, round-to-nearest-even mantissa.
+    Pure integer arithmetic, so exact."""
     E, F = exp_bits, frac_bits
     emax = (1 << E) - 1
     fmask = (1 << F) - 1
@@ -699,35 +700,55 @@ def float_mul_oracle(aw: int, bw: int, exp_bits: int, frac_bits: int) -> int:
     b_nan = eb == emax and fb != 0
     a_inf = ea == emax and fa == 0
     b_inf = eb == emax and fb == 0
-    a_zero = ea == 0  # flush-to-zero
-    b_zero = eb == 0
-    inf_w = (s << (E + F)) | (emax << F)
-    zero_w = s << (E + F)
+    a_zero = ea == 0 and fa == 0
+    b_zero = eb == 0 and fb == 0
     if a_nan or b_nan or (a_inf and b_zero) or (b_inf and a_zero):
         return qnan
     if a_inf or b_inf:
-        return inf_w
+        return (s << (E + F)) | (emax << F)
     if a_zero or b_zero:
-        return zero_w
-    Ma, Mb = (1 << F) | fa, (1 << F) | fb
+        return s << (E + F)
+    Ma = ((1 << F) if ea else 0) | fa
+    Mb = ((1 << F) if eb else 0) | fb
+    eea = ea if ea else 1
+    eeb = eb if eb else 1
     P = Ma * Mb
-    exp_r = ea + eb - bias
-    shift = F + 1 if P >= (1 << (2 * F + 1)) else F
-    if shift == F + 1:
-        exp_r += 1
-    frac = (P >> shift) & fmask
-    guard = (P >> (shift - 1)) & 1
-    below = P & ((1 << (shift - 1)) - 1)
-    if guard and ((frac & 1) or below):     # round-to-nearest-even
-        frac += 1
-        if frac > fmask:
-            frac = 0
-            exp_r += 1
-    if exp_r >= emax:
-        return inf_w
-    if exp_r <= 0:
-        return zero_w
-    return (s << (E + F)) | (exp_r << F) | frac
+    t = P.bit_length() - 1
+    er = t + eea + eeb - bias - 2 * F
+    if er >= 1:
+        drop = t - F
+        if drop <= 0:
+            mant = P << (-drop)
+            guard = sticky = 0
+        else:
+            mant = P >> drop
+            guard = (P >> (drop - 1)) & 1
+            sticky = 1 if (P & ((1 << (drop - 1)) - 1)) else 0
+        frac = mant & fmask
+        if guard and ((frac & 1) or sticky):
+            frac += 1
+            if frac > fmask:
+                frac = 0
+                er += 1
+        if er >= emax:
+            return (s << (E + F)) | (emax << F)
+        return (s << (E + F)) | (er << F) | frac
+    sh_q = eea + eeb - bias - F - 1               # subnormal: value in quanta
+    if sh_q >= 0:
+        sig = P << sh_q
+        guard = sticky = 0
+    else:
+        r = -sh_q
+        sig = P >> r
+        guard = (P >> (r - 1)) & 1
+        sticky = 1 if (P & ((1 << (r - 1)) - 1)) else 0
+    if guard and ((sig & 1) or sticky):
+        sig += 1
+    if sig == 0:
+        return s << (E + F)
+    if sig >= (1 << F):
+        return (s << (E + F)) | (1 << F)
+    return (s << (E + F)) | sig
 
 
 def float_div_oracle(aw: int, bw: int, exp_bits: int, frac_bits: int) -> int:

tools/build_all.py

@@ -59,7 +59,7 @@ def build_variant(bits: int, profile: str) -> Path:
         "--model", str(out),
         "all",
     ]
-    rc, log = run(cmd, timeout=900)
+    rc, log = run(cmd, timeout=2400)
     if rc != 0:
         raise RuntimeError(f"build failed for bits={bits} profile={profile}:\n{log[-1500:]}")
     return out

variants/neural_alu16.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e92fb3263f1948b0cd938f78594ce2baca3b053ad7939e64667a5ae8e6e182e3
-size 25822959
+oid sha256:802a94ce8fe13fb1a65948d129b1a7ce867854d12a7e6c9ea29ad07cbf80101c
+size 26669131

variants/neural_alu32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2fcbf8a56e08e0d6f72ec61c68868484ff1038b85785ce57f83719c5c43e05ed
-size 24208884
+oid sha256:7d356eacda47b4d7854ddf6cf2ef1959099874e2a52f189f3bbf079112a4ce9d
+size 25056244

variants/neural_alu8.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d4e40b7c4dbf79ddcd6feca6db9ac853fbfea65b13ee84ec268118f68ed858f3
-size 24208884
+oid sha256:1b20bb8b51f6461b377ef7075d143fc722d373cc1f8a788ed784bbb38926d69d
+size 25056244

variants/neural_computer16.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5a50dfd96e816f5dfecbf9742ba47dc7dc85b0b731d77b7e9559a99416076450
-size 34340029
+oid sha256:af69d406922aa5bd6951fc26107e926a3952fe6500c9bb8764dc372719dc3015
+size 35185717

variants/neural_computer16_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e94b82694608f25c51025589607a1367bfa4f1a386ce49e439e410c943c98a2b
-size 26528605
+oid sha256:c905b9f7dc4777b30c5f48b055ed285b1fc33b12d93a476f7423427b5e815fc1
+size 27374453

variants/neural_computer16_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:da356d6e85d0ca1f8974da875443bfaa44fe2ecd04e99fbaf8b76deee3708de8
-size 25909241
+oid sha256:1efb427160154a95592968ddeb2c9bb9ef52317abc2ac918308a690759fd8c47
+size 26755145

variants/neural_computer16_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:532d6b74bc92a29964f913a6e0ac1ccdaceba9493c1756777917eba27bf70da1
-size 25993225
+oid sha256:225e933c57d6367695138523e76c069941895ad459621b7d52c8ed25739201a5
+size 26839997

variants/neural_computer16_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:abaef8566344b04e4fd2337f3e1f42a20c75ea3d4086fa3929b4ecd2cb189efb
-size 26113273
+oid sha256:9b23b977f92f953d9f85f4aeec991163f325f2e881871ec567c8292a3315122e
+size 26959213

variants/neural_computer32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f3168c466f9fc791c09b76e1c61d92290db6c2e4861a9f3a918538a5e5739f1b
-size 32744930
+oid sha256:9340602703da2e7563954a45a2febb1d8ed026ac861b493883add2d5311f1f9d
+size 33592582

variants/neural_computer32_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:77c6058877d8f45bce5b4f9d1de23fab27778f40e61664b14af8da7f40bc425a
-size 24933450
+oid sha256:9fa760a30def5486195c584adc51816bf289496c8d5faaadb728a17bed0201d5
+size 25781462

variants/neural_computer32_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8f0f9d4a406245d90f7af61efeb06d278622d1d6e1f092352e42570c5d5dec22
-size 24314842
+oid sha256:15bf955559b534d3fd6243b45f89d42ae6d12a8784464536dc08ec745befbc84
+size 25162246

variants/neural_computer32_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:23954f1ed95013c22fb0615b51f067af577d70d73d2272e65dac340fe8cfa6c6
-size 24398894
+oid sha256:495bca1533a313103fb30eaff2400899ccabf4911a4c08543e6d66252febf498
+size 25246246

variants/neural_computer32_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:541486f8f9d4c97fc15d1b570fbe4755b86caa427f298497210caa64b701086c
-size 24518134
+oid sha256:38d52839bac1d351804c76403dc5f51bf9d2bf22eaa5a7d3f8fac25dc9f2a84e
+size 25365434

variants/neural_computer8.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a96383445eb0444762581d2367f7f267cd5c4df11ed134418e6bacb411ebb191
-size 32716722
+oid sha256:af719c6b6499b85dba19ba425dcb15c9a06c19f6cbb8ed160bfe78484dea5b1a
+size 33564518

variants/neural_computer8_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:05cb6b712995dcf03e5c255549acae4164648deac2a3eb0e9020610d006a4de9
-size 24905274
+oid sha256:e4a3ffff1d0d89ed5f7b5cb1a5bd21b06a89efa834e5daebe7296f19bd750c44
+size 25752570

variants/neural_computer8_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aab74497c840464b01468cd11b2b6306ab560160a9884a1600104a8557b9c979
-size 24285846
+oid sha256:9287c670af87dc6e7682d670d9d671bcf5d021065c7fdc77a0c3336e8f45ace7
+size 25134066

variants/neural_computer8_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0bfe7fe7d52b329188f0715fc16c54b862f125979fbe4a3baf0361236a43b2ff
-size 24370694
+oid sha256:d468d051f2b58c8b2cfb360be2022a67f344cfc8d3f51fee51dc02ebb3384c7a
+size 25218118

variants/neural_computer8_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8dec1874af2d8fffe46aa710d9c73922cfb0188c460ca1595af5d6a84d3c01e4
-size 24489934
+oid sha256:6ec97c8709bfa2f5916849776cf65b2f0dcbd771b45a2c099e39dca7087e8846
+size 25337262