fp-stability: drop the MCA pass (redundant with the random-rounding sig-bits gate)

MCA (--backend=mcaquad) reported a significant-bits estimate that duplicated the metric the core random-rounding suite already produces for PASS/FAIL; on well-conditioned cases the two agree, so it added a slower second opinion without a distinct capability. Removed _run_mca_samples, the MCA pass + --no-mca flag + result keys + summary column. Cancellation/vprec/float-proxy/float-max and the PASS/FAIL core are unchanged. ~50 lines off; it was also the slowest pass (N extra mcaquad runs/case).

Author: sbryngelson

toolchain/mfc/cli/commands.py

@@ -917,7 +917,6 @@
         "  float proxy    One run with --rounding-mode=float (single-precision sensitivity)\n"
         "  vprec sweep    Runs at mantissa bits [52, 23, 16, 10] (precision floor curve)\n"
         "  cancellation   --check-cancellation origins, ranked by significant digits lost\n"
-        "  mca-sigbits    Monte Carlo Arithmetic (mcaquad) significant-bits lower bound\n"
         "  float-max      --check-max-float detection of double→float overflow sites\n"
     ),
     include_common=["mfc_config", "verbose", "debug_log"],
@@ -977,13 +976,6 @@
             default=False,
             dest="no_cancellation",
         ),
-        Argument(
-            name="no-mca",
-            help="Skip Monte Carlo Arithmetic (mcaquad) significant-bits estimate.",
-            action=ArgAction.STORE_TRUE,
-            default=False,
-            dest="no_mca",
-        ),
         Argument(
             name="no-float-max",
             help="Skip --check-max-float float32 overflow detection.",
@@ -1001,7 +993,7 @@
         ),
         Example("./mfc.sh fp-stability -N 10", "Run 10 random-rounding samples per case"),
         Example("./mfc.sh fp-stability --no-vprec --no-cancellation", "Skip VPREC sweep and cancellation detection"),
-        Example("./mfc.sh fp-stability --no-cancellation --no-mca --no-float-max", "Skip new analysis passes"),
+        Example("./mfc.sh fp-stability --no-cancellation --no-float-max", "Skip analysis passes"),
     ],
     key_options=[
         ("--sim-binary PATH", "Serial simulation binary (debug, no-MPI)"),
@@ -1011,7 +1003,6 @@
         ("--no-float-proxy", "Skip float-rounding proxy run"),
         ("--no-vprec", "Skip VPREC mantissa-bit sweep"),
         ("--no-cancellation", "Skip cancellation detection"),
-        ("--no-mca", "Skip MCA significant-bits estimate"),
         ("--no-float-max", "Skip float32 overflow detection"),
     ],
 )

toolchain/mfc/fp_stability.py

@@ -22,11 +22,7 @@
    .fpp line sits inside a #:for/#:def expansion is flagged as instance-ambiguous
    (the line maps to multiple generated instances).
 
-E. MCA significant-bits estimate (--no-mca to skip)
-   N runs with --backend=mcaquad; max deviation vs nearest-rounding
-   reference gives a lower bound on significant bits: s = -log2(dev/scale).
-
-F. Float-max overflow detection (--no-float-max to skip)
+E. Float-max overflow detection (--no-float-max to skip)
    One run with --check-max-float=yes; reports locations where a
    double→float conversion would overflow to ±Inf.
 
@@ -80,7 +76,6 @@
     _run_cancellation_check,
     _run_float_max_check,
     _run_float_proxy,
-    _run_mca_samples,
     _run_preprocess,
     _run_simulation_verrou,
     _run_vprec_sweep,
@@ -372,8 +367,6 @@ def _blank_result(name: str) -> dict:
         "cancellation_locs": [],
         "cancellation_bits": {},
         "cancellation_macro": {},
-        "mca_dev": None,
-        "mca_sigbits": None,
         "float_max_locs": [],
     }
 
@@ -387,7 +380,6 @@ def _run_case(
     run_float: bool,
     run_vprec: bool,
     run_cancellation: bool,
-    run_mca: bool,
     run_float_max: bool,
 ) -> dict:
     name = case["name"]
@@ -494,22 +486,7 @@ def _run_case(
             except Exception as exc:
                 cons.print(f"  [bold yellow]cancellation check error[/bold yellow]: {exc}")
 
-        # --- E: MCA significant-bits estimate ---
-        if run_mca:
-            cons.print(f"  [dim]MCA significant-bits estimate (N={n_samples})...[/dim]")
-            try:
-                mca_dev, mca_sigbits, n_ok = _run_mca_samples(case, verrou_bin, sim_bin, work_dir, ref_dir, n_samples)
-                if n_ok == 0:
-                    cons.print(f"  [bold yellow]MCA: no samples completed (0/{n_samples}; see logs)[/bold yellow]")
-                else:
-                    result["mca_dev"] = mca_dev
-                    result["mca_sigbits"] = mca_sigbits
-                    bits_str = f"~{mca_sigbits} sig bits" if mca_sigbits is not None else "n/a"
-                    cons.print(f"  MCA: dev={mca_dev:.3e}  ({bits_str})  [{n_ok}/{n_samples} samples]")
-            except Exception as exc:
-                cons.print(f"  [bold yellow]MCA error[/bold yellow]: {exc}")
-
-        # --- F: float-max overflow detection ---
+        # --- E: float-max overflow detection ---
         if run_float_max:
             cons.print("  [dim]float-max overflow check...[/dim]")
             try:
@@ -610,7 +587,6 @@ def fp_stability():
     run_float = not ARG("no_float_proxy")
     run_vprec = not ARG("no_vprec")
     run_cancellation = not ARG("no_cancellation")
-    run_mca = not ARG("no_mca")
     run_float_max = not ARG("no_float_max")
 
     cases_to_run = [_load_user_case(ARG("input"))] if ARG("input") else CASES
@@ -633,8 +609,6 @@ def fp_stability():
         features.append("vprec-sweep")
     if run_cancellation:
         features.append("cancellation")
-    if run_mca:
-        features.append("mca-sigbits")
     if run_float_max:
         features.append("float-max")
     cons.print(f"  features:    {', '.join(features) if features else 'stability only'}")
@@ -654,7 +628,6 @@ def fp_stability():
                 run_float,
                 run_vprec,
                 run_cancellation,
-                run_mca,
                 run_float_max,
             )
         except MFCException as exc:

toolchain/mfc/fp_stability_report.py

@@ -80,14 +80,13 @@ def _emit_github_summary(results: list, n_samples: int):
 
     # Main results table — pass/fail is scale-free: bits retained vs a single floor
     md.append(f"_Pass = at least **{MIN_SIG_BITS} significant bits** retained under random rounding (scale-free; no per-case threshold)._\n")
-    md.append("| Case | Status | bits retained | max\\_dev | Float proxy | MCA sig bits |")
-    md.append("|------|:------:|:------:|--------:|--------:|:------:|")
+    md.append("| Case | Status | bits retained | max\\_dev | Float proxy |")
+    md.append("|------|:------:|:------:|--------:|--------:|")
     for r in results:
         status = "✅" if r["passed"] else "❌"
         bits = f"{r['sig_bits']:.1f}" if r.get("sig_bits") is not None else "—"
         fp = f"{r['float_proxy']:.2e}" if r["float_proxy"] is not None else "—"
-        sb = str(r["mca_sigbits"]) if r.get("mca_sigbits") is not None else "—"
-        md.append(f"| `{r['name']}` | {status} | {bits} / {MIN_SIG_BITS} | {r['max_dev']:.2e} | {fp} | {sb} |")
+        md.append(f"| `{r['name']}` | {status} | {bits} / {MIN_SIG_BITS} | {r['max_dev']:.2e} | {fp} |")
     md.append("")
 
     # Cancellation ORIGINS — where ill-conditioning actually arises, led with the

toolchain/mfc/fp_stability_runners.py

@@ -5,7 +5,6 @@
 """
 
 import glob
-import math
 import os
 import shutil
 import subprocess
@@ -14,7 +13,6 @@
 from .common import MFC_ROOT_DIR, MFCException
 from .fp_stability_metrics import (
     VPREC_MANTISSA_BITS,
-    _max_abs_np,
     _max_diff_np,
     _parse_cancel_gen,
     _parse_vg_error_locs,
@@ -147,36 +145,6 @@ def _run_cancellation_check(verrou_bin: str, sim_bin: str, work_dir: str, thresh
     return _parse_cancel_gen(gen_path)
 
 
-def _run_mca_samples(
-    case: dict,
-    verrou_bin: str,
-    sim_bin: str,
-    work_dir: str,
-    ref_dir: str,
-    n_mca: int,
-) -> tuple:
-    """Run N mcaquad samples; return (max_dev, sig_bits_lower_bound, n_ok) where
-    n_ok is how many samples actually completed (0 => no usable measurement)."""
-    compare = case["compare"]
-    ref_scale = _max_abs_np(ref_dir, compare)
-    max_dev = 0.0
-    n_ok = 0
-    flags = ["--backend=mcaquad", "--mca-mode=mca"]
-    for i in range(n_mca):
-        run_dir = os.path.join(work_dir, f"mca_{i:02d}")
-        os.makedirs(run_dir, exist_ok=True)
-        try:
-            _run_simulation_verrou(verrou_bin, sim_bin, work_dir, run_dir, extra_flags=flags)
-            max_dev = max(max_dev, _max_diff_np(ref_dir, run_dir, compare))
-            n_ok += 1
-        except MFCException as exc:
-            cons.print(f"  [dim]MCA sample {i} failed: {exc}[/dim]")
-    sig_bits = None
-    if n_ok and max_dev > 0.0 and ref_scale > 0.0:
-        sig_bits = max(0, int(math.floor(-math.log2(max_dev / ref_scale))))
-    return max_dev, sig_bits, n_ok
-
-
 def _run_float_max_check(verrou_bin: str, sim_bin: str, work_dir: str):
     """Run with --check-max-float=yes; return [(fname, line)] of overflow sites,
     or None if the run failed (distinct from [] = ran and found none)."""