Make inputs coverage strict and document full verbose runs

README.md

@@ -115,6 +115,7 @@ python eval.py
 ```
 
 Tests all circuits exhaustively. 8-bit operations test all 256 or 65,536 input combinations. Float16 tests cover special cases (NaN, Inf, ±0, subnormals) plus normal arithmetic.
+Eval runs full + verbose by default; there is no quick/verbose mode. Use --circuit to filter reported circuits.
 
 For coverage and input-routing validation:
 
@@ -122,7 +123,7 @@ For coverage and input-routing validation:
 python eval.py --coverage --inputs-coverage
 ```
 
-`--inputs-coverage` evaluates gates via their `.inputs` tensors (using seeded/randomized external inputs to complete missing dependencies). This is for coverage and routing sanity, not a correctness proof.
+`--inputs-coverage` evaluates gates via their `.inputs` tensors using seeded external inputs and explicit overrides, and fails if inputs cannot be resolved. This is for coverage and routing sanity, not a correctness proof.
 
 ## Development History
 

eval.py

@@ -3,11 +3,8 @@
 Unified evaluator for threshold-calculus circuits.
 
 Usage:
-    python eval.py                     # Run all tests
-    python eval.py --category float16  # Run only float16 tests
+    python eval.py                     # Run all tests (always full + verbose)
     python eval.py --circuit float16.add  # Run specific circuit
-    python eval.py --quick             # Quick mode (fewer test cases)
-    python eval.py --verbose           # Show all test details
     python eval.py --json              # Output JSON for CI
     python eval.py --coverage          # Show detailed coverage report
     python eval.py --inputs-coverage   # Sweep all gates using .inputs tensors
@@ -160,7 +157,8 @@ def evaluate_circuit(ctx: EvalContext, prefix: str, input_bits: torch.Tensor,
     return torch.stack(outputs, dim=-1) if outputs else torch.tensor([])
 
 
-def seed_external_signals(ctx: EvalContext, rng: random.Random) -> Dict[int, float]:
+def seed_external_signals(ctx: EvalContext, rng: random.Random,
+                          extra_names: Optional[List[str]] = None) -> Dict[int, float]:
     """Seed external input signals and constants with random 0/1 values."""
     signals: Dict[int, float] = {}
 
@@ -176,20 +174,68 @@ def seed_external_signals(ctx: EvalContext, rng: random.Random) -> Dict[int, flo
             if sid not in signals:
                 signals[sid] = float(rng.getrandbits(1))
 
+    if extra_names:
+        for name in extra_names:
+            sid = ctx.name_to_id.get(name)
+            if sid is not None and sid not in signals:
+                signals[sid] = float(rng.getrandbits(1))
+
     return signals
 
 
+def resolve_alias_target(name: str, gates: set) -> Optional[str]:
+    """Resolve common alias signal names to actual gate names."""
+    if name in gates:
+        return name
+    cand = name + ".layer2"
+    if cand in gates:
+        return cand
+    if name.endswith(".sum"):
+        cand = name[:-4] + ".xor2.layer2"
+        if cand in gates:
+            return cand
+    if name.endswith(".cout"):
+        for suffix in [".or_carry", ".carry_or"]:
+            cand = name[:-5] + suffix
+            if cand in gates:
+                return cand
+    return None
+
+
+def build_alias_maps(ctx: EvalContext) -> Tuple[Dict[int, int], Dict[int, List[int]]]:
+    """Build alias maps from orphan signals to actual gate outputs."""
+    gates = set(ctx.gates)
+    alias_to_gate: Dict[int, int] = {}
+    gate_to_alias: Dict[int, List[int]] = {}
+
+    for name, sid in ctx.name_to_id.items():
+        if name in ("#0", "#1"):
+            continue
+        if name.startswith("$") or ".$" in name:
+            continue
+        if name in gates:
+            continue
+        target = resolve_alias_target(name, gates)
+        if not target:
+            continue
+        target_id = ctx.name_to_id.get(target)
+        if target_id is None:
+            continue
+        alias_to_gate[sid] = target_id
+        gate_to_alias.setdefault(target_id, []).append(sid)
+
+    return alias_to_gate, gate_to_alias
+
+
 def evaluate_gates_from_inputs(ctx: EvalContext, signals: Dict[int, float],
-                               gate_list: Optional[List[str]] = None,
-                               rng: Optional[random.Random] = None,
-                               fill_missing: bool = False) -> Tuple[int, List[str], List[str], int]:
-    """Evaluate gates using explicit .inputs tensors. Returns (evaluated, missing_inputs, unresolved, filled_ids)."""
+                               gate_list: Optional[List[str]] = None) -> Tuple[int, List[str], List[str]]:
+    """Evaluate gates using explicit .inputs tensors. Returns (evaluated, missing_inputs, unresolved)."""
     gates = gate_list if gate_list is not None else ctx.gates
     remaining = set(gates)
     missing_inputs: List[str] = []
     unresolved: List[str] = []
     evaluated = 0
-    filled_ids = 0
+    alias_to_gate, gate_to_alias = build_alias_maps(ctx)
 
     progress = True
     while progress and remaining:
@@ -205,7 +251,17 @@ def evaluate_gates_from_inputs(ctx: EvalContext, signals: Dict[int, float],
                 continue
 
             input_ids = [int(x) for x in ctx.tensors[inputs_key].tolist()]
-            if not all(sid in signals for sid in input_ids):
+            ready = True
+            for sid in input_ids:
+                if sid in signals:
+                    continue
+                alias_gate = alias_to_gate.get(sid)
+                if alias_gate is not None and alias_gate in signals:
+                    signals[sid] = signals[alias_gate]
+                    continue
+                ready = False
+                break
+            if not ready:
                 continue
 
             weight = ctx.tensors[weight_key].tolist()
@@ -216,6 +272,8 @@ def evaluate_gates_from_inputs(ctx: EvalContext, signals: Dict[int, float],
             gate_id = ctx.name_to_id.get(gate)
             if gate_id is not None:
                 signals[gate_id] = out
+                for alias_id in gate_to_alias.get(gate_id, []):
+                    signals[alias_id] = out
 
             if inputs_key in ctx.tensors:
                 ctx.tested_tensors.add(inputs_key)
@@ -228,26 +286,10 @@ def evaluate_gates_from_inputs(ctx: EvalContext, signals: Dict[int, float],
             remaining.remove(gate)
             progress = True
 
-        if not progress and remaining and fill_missing and rng is not None:
-            missing_ids = set()
-            for gate in remaining:
-                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()]
-                for sid in input_ids:
-                    if sid not in signals:
-                        missing_ids.add(sid)
-            if missing_ids:
-                for sid in missing_ids:
-                    signals[sid] = float(rng.getrandbits(1))
-                filled_ids += len(missing_ids)
-                progress = True
-
     if remaining:
         unresolved = sorted(remaining)
 
-    return evaluated, missing_inputs, unresolved, filled_ids
+    return evaluated, missing_inputs, unresolved
 
 
 # =============================================================================
@@ -341,11 +383,12 @@ def inputs_coverage_sweep(ctx: EvalContext, seed: int = 0, verbose: bool = False
                           quiet: bool = False) -> None:
     """Evaluate all gates via .inputs to improve coverage."""
     rng = random.Random(seed)
-    signals = seed_external_signals(ctx, rng)
+    extra_names = []
+    for names in EXTERNAL_INPUT_OVERRIDES.values():
+        extra_names.extend(names)
+    signals = seed_external_signals(ctx, rng, extra_names=extra_names)
 
-    evaluated, missing_inputs, unresolved, filled_ids = evaluate_gates_from_inputs(
-        ctx, signals, rng=rng, fill_missing=True
-    )
+    evaluated, missing_inputs, unresolved = evaluate_gates_from_inputs(ctx, signals)
     total = len(ctx.gates)
 
     orphan_tensors = 0
@@ -357,12 +400,17 @@ def inputs_coverage_sweep(ctx: EvalContext, seed: int = 0, verbose: bool = False
         ctx.tested_tensors.add(name)
         orphan_tensors += 1
 
+    # Hard failure on unresolved inputs
+    if missing_inputs or unresolved:
+        raise RuntimeError(
+            f"Unresolved inputs in input-coverage sweep: "
+            f"missing_inputs={len(missing_inputs)} unresolved={len(unresolved)}"
+        )
+
     if quiet:
         return
 
     print(f"\nInput-coverage sweep: evaluated {evaluated}/{total} gates")
-    if filled_ids:
-        print(f"  Filled missing signal IDs: {filled_ids}")
     if orphan_tensors:
         print(f"  Orphan tensors touched: {orphan_tensors}")
     if missing_inputs:
@@ -444,6 +492,19 @@ def bits_to_int_msb(bits: List[float]) -> int:
     return val
 
 
+# Explicit external signals needed to resolve orphan wiring (per circuit)
+EXTERNAL_INPUT_OVERRIDES = {
+    "arithmetic.multiplier8x8": [
+        "arithmetic.multiplier8x8.stage0.bit9.ha2.sum.layer2",
+        "arithmetic.multiplier8x8.stage1.bit10.ha2.sum.layer2",
+        "arithmetic.multiplier8x8.stage2.bit11.ha2.sum.layer2",
+        "arithmetic.multiplier8x8.stage3.bit12.ha2.sum.layer2",
+        "arithmetic.multiplier8x8.stage4.bit13.ha2.sum.layer2",
+        "arithmetic.multiplier8x8.stage5.bit14.ha2.sum.layer2",
+    ],
+}
+
+
 def int_to_bits(val: int, n: int, signed: bool = False) -> List[float]:
     """Convert integer to n bits."""
     if signed and val < 0:
@@ -2151,10 +2212,7 @@ def print_summary(results: List[TestResult], ctx: EvalContext,
 def main():
     parser = argparse.ArgumentParser(description="Unified evaluator for threshold-calculus circuits")
     parser.add_argument("--model", default="./arithmetic.safetensors", help="Path to model file")
-    parser.add_argument("--category", "-c", action="append", help="Test specific category (can repeat)")
     parser.add_argument("--circuit", action="append", help="Test specific circuit (can repeat)")
-    parser.add_argument("--quick", "-q", action="store_true", help="Quick mode (fewer test cases)")
-    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
     parser.add_argument("--json", "-j", action="store_true", help="Output JSON for CI")
     parser.add_argument("--coverage", action="store_true", help="Show detailed coverage")
     parser.add_argument("--inputs-coverage", action="store_true", help="Sweep all gates using .inputs tensors")
@@ -2179,15 +2237,15 @@ def main():
         signals=signals,
         name_to_id=name_to_id,
         id_to_name=id_to_name,
-        verbose=args.verbose,
-        quick=args.quick,
+        verbose=True,
+        quick=False,
     )
 
     start = time.time()
-    results = run_tests(ctx, categories=args.category, circuits=args.circuit)
+    results = run_tests(ctx, categories=None, circuits=args.circuit)
 
     if args.coverage or args.inputs_coverage:
-        inputs_coverage_sweep(ctx, seed=0, verbose=args.verbose, quiet=args.json)
+        inputs_coverage_sweep(ctx, seed=0, verbose=True, quiet=args.json)
     elapsed = time.time() - start
 
     if args.json:
@@ -2200,7 +2258,7 @@ def main():
         }
         print(json.dumps(output, indent=2))
     else:
-        print_summary(results, ctx, elapsed, verbose=args.verbose or args.coverage)
+        print_summary(results, ctx, elapsed, verbose=True)
 
     # Return exit code based on failures
     failed = [r for r in results if not r.success]