Add randomized float16 tests and document open issues

README.md

@@ -153,6 +153,15 @@ This began as an attempt to build a complete threshold-logic CPU. The CPU is in
 - Rip out 8-bit integer circuits, replace with 16-bit
 - 8-bit was scaffolding for float16 development, not the product
 
+## TODO (Unified)
+
+1. Fix float16 add/sub correctness for subnormals/zero, opposite-sign cancellation, and overflow/infinity sign handling.
+2. Fix float16 mul/div correctness for subnormals/zero, sign propagation, and special-case handling.
+3. Fix float16 toint/fromint correctness: stop zeroing valid values, define rounding (truncate vs round-to-nearest-even), and align tests with the chosen spec.
+4. Define accuracy/rounding specs and implement float16 sqrt/rsqrt/pow/exp/ln/log2.
+5. Implement float16 trig (sin/cos/tan via CORDIC) and tanh with explicit accuracy targets.
+6. Replace 8-bit integer circuits with 16-bit and remove 8-bit scaffolding.
+
 ## License
 
 Apache 2.0

eval.py

@@ -512,6 +512,128 @@ def int_to_bits(val: int, n: int, signed: bool = False) -> List[float]:
     return [float((val >> i) & 1) for i in range(n)]
 
 
+def float16_int_to_float(val: int) -> float:
+    """Interpret a 16-bit int as IEEE-754 float16."""
+    packed = struct.pack('>H', val & 0xFFFF)
+    return struct.unpack('>e', packed)[0]
+
+
+def float16_is_nan_bits(val: int) -> bool:
+    """Return True if the 16-bit pattern encodes a NaN."""
+    return (val & 0x7C00) == 0x7C00 and (val & 0x03FF) != 0
+
+
+def seed_prefix_bits(ctx: EvalContext, prefix: str, base: str,
+                     bits: List[float], signals: Dict[int, float]) -> None:
+    """Seed signals for prefix.$base[i] inputs using bits list."""
+    names = [n for n in ctx.name_to_id.keys() if n.startswith(f"{prefix}.${base}[")]
+    if not names:
+        raise RuntimeError(f"{prefix}: no inputs found for ${base}")
+    for name in names:
+        try:
+            idx = int(name.split("[", 1)[1].split("]", 1)[0])
+        except (IndexError, ValueError):
+            raise RuntimeError(f"{prefix}: bad input name {name}")
+        if idx >= len(bits):
+            raise RuntimeError(f"{prefix}: missing bit {idx} for ${base}")
+        signals[ctx.name_to_id[name]] = float(bits[idx])
+
+
+def eval_prefix_outputs(ctx: EvalContext, prefix: str,
+                        inputs: Dict[str, List[float]],
+                        gate_list: Optional[List[str]] = None,
+                        out_bits: int = 16) -> List[float]:
+    """Evaluate a circuit prefix using .inputs routing and return output bits."""
+    signals: Dict[int, float] = {}
+    if "#0" in ctx.name_to_id:
+        signals[ctx.name_to_id["#0"]] = 0.0
+    if "#1" in ctx.name_to_id:
+        signals[ctx.name_to_id["#1"]] = 1.0
+
+    for base, bits in inputs.items():
+        seed_prefix_bits(ctx, prefix, base, bits, signals)
+
+    gates = gate_list if gate_list is not None else [g for g in ctx.gates if g.startswith(prefix + ".")]
+    evaluated, missing_inputs, unresolved = evaluate_gates_from_inputs(ctx, signals, gate_list=gates)
+    if missing_inputs or unresolved:
+        raise RuntimeError(
+            f"{prefix}: unresolved inputs (missing={len(missing_inputs)} unresolved={len(unresolved)})"
+        )
+
+    outputs: List[float] = []
+    for i in range(out_bits):
+        gate = f"{prefix}.out{i}"
+        sid = ctx.name_to_id.get(gate)
+        if sid is not None and sid in signals:
+            outputs.append(float(signals[sid]))
+            continue
+        inputs_key = f"{gate}.inputs"
+        if inputs_key not in ctx.tensors:
+            raise RuntimeError(f"{prefix}: missing outputs for {gate}")
+        input_ids = [int(x) for x in ctx.tensors[inputs_key].tolist()]
+        input_vals = [signals[sid] for sid in input_ids]
+        outputs.append(eval_gate_direct(ctx, gate, input_vals))
+
+    return outputs
+
+
+def build_float16_pairs(rng: random.Random, count: int) -> List[Tuple[int, int]]:
+    """Build deterministic float16 test pairs using edge cases + random."""
+    edges = [
+        0x0000,  # +0
+        0x8000,  # -0
+        0x3C00,  # 1.0
+        0xBC00,  # -1.0
+        0x4000,  # 2.0
+        0xC000,  # -2.0
+        0x3E00,  # 1.5
+        0x3555,  # ~0.333
+        0x7BFF,  # max finite
+        0xFBFF,  # min finite
+        0x0400,  # min normal
+        0x0001,  # min subnormal
+        0x03FF,  # max subnormal
+        0x7C00,  # +inf
+        0xFC00,  # -inf
+        0x7E00,  # NaN
+    ]
+    pairs = [(a, b) for a in edges for b in edges]
+    rng.shuffle(pairs)
+    pairs = pairs[:min(len(pairs), count)]
+
+    seen = set(pairs)
+    while len(pairs) < count:
+        a = rng.getrandbits(16)
+        b = rng.getrandbits(16)
+        if (a, b) in seen:
+            continue
+        seen.add((a, b))
+        pairs.append((a, b))
+
+    return pairs
+
+
+def float16_expected_bits_binary(op: str, a_bits: int, b_bits: int) -> Tuple[int, bool]:
+    """Compute expected float16 bits for a binary op and whether it's NaN."""
+    a = float16_int_to_float(a_bits)
+    b = float16_int_to_float(b_bits)
+    a16 = torch.tensor(a, dtype=torch.float16)
+    b16 = torch.tensor(b, dtype=torch.float16)
+    if op == "add":
+        out = (a16 + b16).item()
+    elif op == "sub":
+        out = (a16 - b16).item()
+    elif op == "mul":
+        out = (a16 * b16).item()
+    elif op == "div":
+        out = (a16 / b16).item()
+    else:
+        raise ValueError(f"unknown op: {op}")
+    if out != out:
+        return 0x7E00, True
+    return float_to_int(float(out)), False
+
+
 # =============================================================================
 # BOOLEAN GATE TESTS
 # =============================================================================
@@ -1901,177 +2023,125 @@ def test_float16_arithmetic(ctx: EvalContext) -> List[TestResult]:
     """Test float16 arithmetic operations."""
     results = []
 
-    # Addition - mark tensors as tested
+    rng = random.Random(0xF00D)
+    light_pairs = build_float16_pairs(rng, 256)
+    heavy_pairs = build_float16_pairs(rng, 128)
+
+    # Addition - randomized evaluation
     if f"float16.add.exp_a_all_ones.weight" in ctx.tensors:
         passed, total = 0, 0
-        test_pairs = [
-            (0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0),
-            (1.0, -1.0), (-1.0, 1.0), (0.5, 0.5), (0.5, 0.25),
-            (100.0, 200.0), (-100.0, -200.0), (65504.0, 0.0),
-        ]
-        if not ctx.quick:
-            test_pairs.extend([(1.0, 2.0), (3.0, 4.0), (10.0, 20.0)])
+        failures: List[Dict[str, Any]] = []
+        gate_list = sorted([g for g in ctx.gates if g.startswith("float16.add.")])
 
-        for a, b in test_pairs:
-            a_bits = float_to_bits(a)
-            b_bits = float_to_bits(b)
-
-            # Mark key tensors as tested
-            for tensor_name in ["exp_a_all_ones", "exp_b_all_ones", "exp_a_zero", "exp_b_zero",
-                               "mant_a_nonzero", "mant_b_nonzero", "a_is_nan", "b_is_nan"]:
-                ctx.tested_tensors.add(f"float16.add.{tensor_name}.weight")
-                ctx.tested_tensors.add(f"float16.add.{tensor_name}.bias")
+        for a_bits, b_bits in light_pairs:
+            a_list = int_to_bits(a_bits, 16)
+            b_list = int_to_bits(b_bits, 16)
+            actual_bits = eval_prefix_outputs(ctx, "float16.add", {"a": a_list, "b": b_list}, gate_list=gate_list)
+            actual_int = bits_to_int(actual_bits)
+            expected_int, expected_nan = float16_expected_bits_binary("add", a_bits, b_bits)
+            ok = float16_is_nan_bits(actual_int) if expected_nan else actual_int == expected_int
 
             total += 1
-            passed += 1  # Simplified
+            if ok:
+                passed += 1
+            elif len(failures) < 10:
+                failures.append({
+                    "a_bits": hex(a_bits),
+                    "b_bits": hex(b_bits),
+                    "expected": hex(expected_int),
+                    "actual": hex(actual_int),
+                })
 
-        results.append(TestResult("float16.add", passed, total))
+        results.append(TestResult("float16.add", passed, total, failures))
 
-    # Subtraction
+    # Subtraction - randomized evaluation
     if f"float16.sub.b_neg_sign.weight" in ctx.tensors:
         passed, total = 0, 0
-        test_pairs = [(1.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (1.0, 2.0)]
+        failures = []
+        add_gate_list = sorted([g for g in ctx.gates if g.startswith("float16.add.")])
+
+        for a_bits, b_bits in light_pairs:
+            a_list = int_to_bits(a_bits, 16)
+            b_list = int_to_bits(b_bits, 16)
+            # float16.sub is a wrapper over float16.add with inverted sign bit
+            b_list_mod = list(b_list)
+            b_list_mod[15] = 1.0 - b_list_mod[15]
+            actual_bits = eval_prefix_outputs(ctx, "float16.add", {"a": a_list, "b": b_list_mod}, gate_list=add_gate_list)
+            actual_int = bits_to_int(actual_bits)
+            expected_int, expected_nan = float16_expected_bits_binary("sub", a_bits, b_bits)
+            ok = float16_is_nan_bits(actual_int) if expected_nan else actual_int == expected_int
+
+            # Also validate the sign flip gate
+            neg_sign = eval_gate_direct(ctx, "float16.sub.b_neg_sign", [b_list[15]])
+            if neg_sign != (1.0 - b_list[15]):
+                ok = False
 
-        for a, b in test_pairs:
-            ctx.tested_tensors.add("float16.sub.b_neg_sign.weight")
             total += 1
-            passed += 1
+            if ok:
+                passed += 1
+            elif len(failures) < 10:
+                failures.append({
+                    "a_bits": hex(a_bits),
+                    "b_bits": hex(b_bits),
+                    "expected": hex(expected_int),
+                    "actual": hex(actual_int),
+                })
 
-        results.append(TestResult("float16.sub", passed, total))
+        results.append(TestResult("float16.sub", passed, total, failures))
 
-    # Multiplication - actual circuit evaluation
+    # Multiplication - randomized evaluation
     if f"float16.mul.exp_a_all_ones.weight" in ctx.tensors:
         passed, total = 0, 0
-        test_pairs = [(0.0, 0.0), (1.0, 1.0), (2.0, 3.0), (0.5, 2.0), (-1.0, 1.0),
-                      (2.0, 2.0), (1.5, 2.0), (-1.0, -1.0), (3.14, 2.0), (100.0, 0.01)]
-
-        mul_gates = sorted([k.rsplit('.weight', 1)[0] for k in ctx.tensors.keys()
-                           if k.startswith('float16.mul.') and k.endswith('.weight')])
+        failures = []
+        gate_list = sorted([g for g in ctx.gates if g.startswith("float16.mul.")])
 
-        for a, b in test_pairs:
-            a_bits = float_to_int(a)
-            b_bits = float_to_int(b)
-            expected_bits = float_to_int(a * b)
-
-            # Evaluate circuit
-            signals = {0: 0, 1: 1}
-            for i in range(16):
-                aid = ctx.name_to_id.get(f'float16.mul.$a[{i}]')
-                bid = ctx.name_to_id.get(f'float16.mul.$b[{i}]')
-                if aid: signals[aid] = (a_bits >> i) & 1
-                if bid: signals[bid] = (b_bits >> i) & 1
-
-            evaluated = set()
-            for _ in range(len(mul_gates) * 3):
-                progress = False
-                for gate in mul_gates:
-                    if gate in evaluated:
-                        continue
-                    inputs_key = f'{gate}.inputs'
-                    if inputs_key not in ctx.tensors:
-                        continue
-                    input_ids = [int(x) for x in ctx.tensors[inputs_key].tolist()]
-                    if not all(sid in signals for sid in input_ids):
-                        continue
-                    weight = ctx.tensors[f'{gate}.weight'].tolist()
-                    bias = ctx.tensors.get(f'{gate}.bias', torch.tensor([0.0])).item()
-                    total_sum = bias + sum(w * signals[sid] for w, sid in zip(weight, input_ids))
-                    result = 1 if total_sum >= 0 else 0
-                    gate_id = ctx.name_to_id.get(gate)
-                    if gate_id is not None:
-                        signals[gate_id] = result
-                    evaluated.add(gate)
-                    ctx.tested_tensors.add(f'{gate}.weight')
-                    ctx.tested_tensors.add(f'{gate}.bias')
-                    progress = True
-                if not progress:
-                    break
-
-            result_bits = 0
-            for i in range(16):
-                gate = f'float16.mul.out{i}'
-                inputs_key = f'{gate}.inputs'
-                if inputs_key in ctx.tensors:
-                    input_ids = [int(x) for x in ctx.tensors[inputs_key].tolist()]
-                    if all(sid in signals for sid in input_ids):
-                        weight = ctx.tensors[f'{gate}.weight'].tolist()
-                        bias = ctx.tensors.get(f'{gate}.bias', torch.tensor([0.0])).item()
-                        total_sum = bias + sum(w * signals[sid] for w, sid in zip(weight, input_ids))
-                        if total_sum >= 0:
-                            result_bits |= (1 << i)
+        for a_bits, b_bits in heavy_pairs:
+            a_list = int_to_bits(a_bits, 16)
+            b_list = int_to_bits(b_bits, 16)
+            actual_bits = eval_prefix_outputs(ctx, "float16.mul", {"a": a_list, "b": b_list}, gate_list=gate_list)
+            actual_int = bits_to_int(actual_bits)
+            expected_int, expected_nan = float16_expected_bits_binary("mul", a_bits, b_bits)
+            ok = float16_is_nan_bits(actual_int) if expected_nan else actual_int == expected_int
 
             total += 1
-            if result_bits == expected_bits:
+            if ok:
                 passed += 1
+            elif len(failures) < 10:
+                failures.append({
+                    "a_bits": hex(a_bits),
+                    "b_bits": hex(b_bits),
+                    "expected": hex(expected_int),
+                    "actual": hex(actual_int),
+                })
 
-        results.append(TestResult("float16.mul", passed, total))
+        results.append(TestResult("float16.mul", passed, total, failures))
 
-    # Division - actual circuit evaluation
+    # Division - randomized evaluation
     if f"float16.div.exp_a_all_ones.weight" in ctx.tensors:
         passed, total = 0, 0
-        test_pairs = [(0.0, 1.0), (1.0, 1.0), (4.0, 2.0), (1.0, 2.0),
-                      (8.0, -2.0), (2.0, 4.0), (-4.0, -2.0)]
-
-        div_gates = sorted([k.rsplit('.weight', 1)[0] for k in ctx.tensors.keys()
-                           if k.startswith('float16.div.') and k.endswith('.weight')])
-
-        for a, b in test_pairs:
-            a_bits = float_to_int(a)
-            b_bits = float_to_int(b)
-            expected = a / b if b != 0 else float('inf')
-            expected_bits = float_to_int(expected)
-
-            signals = {0: 0, 1: 1}
-            for i in range(16):
-                aid = ctx.name_to_id.get(f'float16.div.$a[{i}]')
-                bid = ctx.name_to_id.get(f'float16.div.$b[{i}]')
-                if aid: signals[aid] = (a_bits >> i) & 1
-                if bid: signals[bid] = (b_bits >> i) & 1
-
-            evaluated = set()
-            for _ in range(len(div_gates) * 3):
-                progress = False
-                for gate in div_gates:
-                    if gate in evaluated:
-                        continue
-                    inputs_key = f'{gate}.inputs'
-                    if inputs_key not in ctx.tensors:
-                        continue
-                    input_ids = [int(x) for x in ctx.tensors[inputs_key].tolist()]
-                    if not all(sid in signals for sid in input_ids):
-                        continue
-                    weight = ctx.tensors[f'{gate}.weight'].tolist()
-                    bias = ctx.tensors.get(f'{gate}.bias', torch.tensor([0.0])).item()
-                    total_sum = bias + sum(w * signals[sid] for w, sid in zip(weight, input_ids))
-                    result = 1 if total_sum >= 0 else 0
-                    gate_id = ctx.name_to_id.get(gate)
-                    if gate_id is not None:
-                        signals[gate_id] = result
-                    evaluated.add(gate)
-                    ctx.tested_tensors.add(f'{gate}.weight')
-                    ctx.tested_tensors.add(f'{gate}.bias')
-                    progress = True
-                if not progress:
-                    break
+        failures = []
+        gate_list = sorted([g for g in ctx.gates if g.startswith("float16.div.")])
 
-            result_bits = 0
-            for i in range(16):
-                gate = f'float16.div.out{i}'
-                inputs_key = f'{gate}.inputs'
-                if inputs_key in ctx.tensors:
-                    input_ids = [int(x) for x in ctx.tensors[inputs_key].tolist()]
-                    if all(sid in signals for sid in input_ids):
-                        weight = ctx.tensors[f'{gate}.weight'].tolist()
-                        bias = ctx.tensors.get(f'{gate}.bias', torch.tensor([0.0])).item()
-                        total_sum = bias + sum(w * signals[sid] for w, sid in zip(weight, input_ids))
-                        if total_sum >= 0:
-                            result_bits |= (1 << i)
+        for a_bits, b_bits in heavy_pairs:
+            a_list = int_to_bits(a_bits, 16)
+            b_list = int_to_bits(b_bits, 16)
+            actual_bits = eval_prefix_outputs(ctx, "float16.div", {"a": a_list, "b": b_list}, gate_list=gate_list)
+            actual_int = bits_to_int(actual_bits)
+            expected_int, expected_nan = float16_expected_bits_binary("div", a_bits, b_bits)
+            ok = float16_is_nan_bits(actual_int) if expected_nan else actual_int == expected_int
 
             total += 1
-            if result_bits == expected_bits:
+            if ok:
                 passed += 1
+            elif len(failures) < 10:
+                failures.append({
+                    "a_bits": hex(a_bits),
+                    "b_bits": hex(b_bits),
+                    "expected": hex(expected_int),
+                    "actual": hex(actual_int),
+                })
 
-        results.append(TestResult("float16.div", passed, total))
+        results.append(TestResult("float16.div", passed, total, failures))
 
     return results
 
@@ -2080,42 +2150,80 @@ def test_float16_conversion(ctx: EvalContext) -> List[TestResult]:
     """Test float16 conversion operations."""
     results = []
 
+    rng = random.Random(0xC0DE)
+
     # toint
     if f"float16.toint.exp_all_ones.weight" in ctx.tensors:
         passed, total = 0, 0
-        test_values = [0.0, 1.0, -1.0, 2.0, -2.0, 0.5, -0.5, 100.0, -100.0, 32767.0]
+        failures: List[Dict[str, Any]] = []
+        gate_list = sorted([g for g in ctx.gates if g.startswith("float16.toint.")])
 
-        for val in test_values:
-            bits = float_to_bits(val)
+        # Build deterministic input set: edge cases + filtered random patterns
+        edge_vals = [
+            0x0000, 0x8000, 0x3C00, 0xBC00, 0x4000, 0xC000,
+            0x0400, 0x0001, 0x03FF, 0x3555, 0x3E00,
+        ]
+        test_bits = list(edge_vals)
+        while len(test_bits) < 256:
+            v = rng.getrandbits(16)
+            if float16_is_nan_bits(v):
+                continue
+            test_bits.append(v)
+
+        for bits_int in test_bits:
+            val = float16_int_to_float(bits_int)
+            if val != val:
+                continue
+            if val == float('inf') or val == float('-inf'):
+                continue
+            expected = int(val)
+            if expected < -32768 or expected > 32767:
+                continue
 
-            # Mark tensors as tested
-            for name in ["exp_all_ones", "exp_zero", "mant_nonzero", "is_nan", "is_inf"]:
-                ctx.tested_tensors.add(f"float16.toint.{name}.weight")
-                ctx.tested_tensors.add(f"float16.toint.{name}.bias")
+            bits = int_to_bits(bits_int, 16)
+            actual_bits = eval_prefix_outputs(ctx, "float16.toint", {"x": bits}, gate_list=gate_list)
+            actual = bits_to_int(actual_bits, signed=True)
 
-            expected = int(val) if -32768 <= val <= 32767 else 0
             total += 1
-            passed += 1  # Simplified
+            if actual == expected:
+                passed += 1
+            elif len(failures) < 10:
+                failures.append({
+                    "in_bits": hex(bits_int),
+                    "expected": expected,
+                    "actual": actual,
+                })
 
-        results.append(TestResult("float16.toint", passed, total))
+        results.append(TestResult("float16.toint", passed, total, failures))
 
     # fromint
     if f"float16.fromint.is_zero.weight" in ctx.tensors:
         passed, total = 0, 0
-        test_values = [0, 1, -1, 2, -2, 100, -100, 32767, -32768]
+        failures = []
+        gate_list = sorted([g for g in ctx.gates if g.startswith("float16.fromint.")])
 
-        for val in test_values:
-            bits = int_to_bits(val, 16, signed=True)
+        edge_ints = [0, 1, -1, 2, -2, 100, -100, 32767, -32768]
+        test_vals = list(edge_ints)
+        while len(test_vals) < 256:
+            test_vals.append(rng.randint(-32768, 32767))
 
-            # Mark tensors as tested
-            for name in ["is_zero", "is_negative"]:
-                ctx.tested_tensors.add(f"float16.fromint.{name}.weight")
-                ctx.tested_tensors.add(f"float16.fromint.{name}.bias")
+        for val in test_vals:
+            bits = int_to_bits(val, 16, signed=True)
+            actual_bits = eval_prefix_outputs(ctx, "float16.fromint", {"x": bits}, gate_list=gate_list)
+            actual_int = bits_to_int(actual_bits)
 
+            expected_bits = float_to_int(float(val))
             total += 1
-            passed += 1  # Simplified
-
-        results.append(TestResult("float16.fromint", passed, total))
+            if actual_int == expected_bits:
+                passed += 1
+            elif len(failures) < 10:
+                failures.append({
+                    "in_val": val,
+                    "expected": hex(expected_bits),
+                    "actual": hex(actual_int),
+                })
+
+        results.append(TestResult("float16.fromint", passed, total, failures))
 
     return results