fp-stability: ascii-only — convert em-dash/arrow/math glyphs in comments + output

Replaced non-ASCII in the toolchain (em-dash/en-dash -> '-', '->' for arrows, '>=' for >=, '+/-', '~' for approx, 'inf'/'Linf' for the infinity glyph, '...' for ellipsis) across fp_stability*.py, verrou.sh, and the fp-stability command help. Display/comment text only; no logic change. The viz command's pre-existing glyphs are left untouched (not part of this PR).

Author: sbryngelson

toolchain/bootstrap/verrou.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 #
 # Opt-in installer for Verrou (the Valgrind FP-perturbation tool used by
-# `./mfc.sh fp-stability`). Verrou is NOT a Python/pip package — it is a fork of
+# `./mfc.sh fp-stability`). Verrou is NOT a Python/pip package - it is a fork of
 # Valgrind. By default this downloads a prebuilt, hash-verified artifact (seconds);
 # if none is available for this tag/arch it falls back to a source build (~20 min).
 # fp-stability auto-runs this on first use when Verrou is absent (printing what it
@@ -19,7 +19,7 @@ set -euo pipefail
 VALGRIND_VERSION="3.26.0"
 VERROU_COMMIT="a58d434"
 # Prebuilt artifacts (built once per arch) live in a small companion repo. The tag
-# pins to the (valgrind, verrou) pair above — bump all three together.
+# pins to the (valgrind, verrou) pair above - bump all three together.
 VERROU_DIST_REPO="${VERROU_DIST_REPO:-sbryngelson/verrou-dist}"
 VERROU_DIST_TAG="${VERROU_DIST_TAG:-v1}"
 PREFIX="${VERROU_HOME:-$HOME/.local/verrou}"
@@ -46,7 +46,7 @@ case "$(uname -m)" in
     aarch64|arm64)
         arch_tag="aarch64"
         echo "WARNING: $(uname -m) detected. Valgrind builds here, but Verrou's FP backends are" >&2
-        echo "         best-validated on x86_64 — treat results as experimental on this arch." >&2
+        echo "         best-validated on x86_64 - treat results as experimental on this arch." >&2
         ;;
     *)
         echo "WARNING: unrecognised arch $(uname -m); the build may fail. Proceeding anyway." >&2
@@ -73,39 +73,39 @@ try_prebuilt() {
         if command -v curl >/dev/null 2>&1; then curl -fsSL -o "$2" "$1"; else wget -q -O "$2" "$1"; fi
     }
     if ! _fetch "$base" "$dl/$asset" || ! _fetch "$base.sha256" "$dl/$asset.sha256"; then
-        echo "==> No prebuilt for this tag/arch — building from source instead."
+        echo "==> No prebuilt for this tag/arch - building from source instead."
         rm -rf "$dl"; return 1
     fi
     if ! ( cd "$dl" && sha256sum -c "$asset.sha256" >/dev/null 2>&1 ); then
-        echo "WARNING: prebuilt checksum mismatch — building from source instead." >&2
+        echo "WARNING: prebuilt checksum mismatch - building from source instead." >&2
         rm -rf "$dl"; return 1
     fi
 
     # Extract + verify in a staging dir, then swap into $PREFIX atomically. set -e
     # is suppressed inside a function used as an `if` condition, so check each step
-    # explicitly — otherwise a failed extract would fall through and the source
+    # explicitly - otherwise a failed extract would fall through and the source
     # build would install on top of a half-written tree (or a stale one on --force).
     local stage="$dl/stage"
     mkdir -p "$stage"
     if tar --zstd --help >/dev/null 2>&1; then
-        tar -C "$stage" --zstd -xf "$dl/$asset" || { echo "WARNING: prebuilt extract failed — building from source instead." >&2; rm -rf "$dl"; return 1; }
+        tar -C "$stage" --zstd -xf "$dl/$asset" || { echo "WARNING: prebuilt extract failed - building from source instead." >&2; rm -rf "$dl"; return 1; }
     else
-        zstd -dc "$dl/$asset" | tar -C "$stage" -xf - || { echo "WARNING: prebuilt extract failed — building from source instead." >&2; rm -rf "$dl"; return 1; }
+        zstd -dc "$dl/$asset" | tar -C "$stage" -xf - || { echo "WARNING: prebuilt extract failed - building from source instead." >&2; rm -rf "$dl"; return 1; }
     fi
 
     # Valgrind bakes its build prefix into the binary; the artifact's env.sh sets
     # VALGRIND_LIB relative to the tree so the relocated install works. Verify the
     # staged tree runs before committing it.
     if ! ( . "${stage}/env.sh" && "${stage}/bin/valgrind" --tool=verrou --version >/dev/null 2>&1 ); then
-        echo "WARNING: prebuilt did not run — building from source instead." >&2
+        echo "WARNING: prebuilt did not run - building from source instead." >&2
         rm -rf "$dl"; return 1
     fi
 
     # Commit only now: replace any existing $PREFIX atomically.
     mkdir -p "$(dirname "$PREFIX")"
     rm -rf "$PREFIX"
     if ! mv "$stage" "$PREFIX"; then
-        echo "WARNING: could not install prebuilt to ${PREFIX} — building from source instead." >&2
+        echo "WARNING: could not install prebuilt to ${PREFIX} - building from source instead." >&2
         rm -rf "$dl"; return 1
     fi
     rm -rf "$dl"

toolchain/mfc/cli/commands.py

@@ -899,25 +899,25 @@
     help="Run floating-point stability tests using Verrou.",
     description=(
         "Runs Verrou random-rounding stability analysis on a built-in suite of small "
-        "1-D cases, or — given a case .py (positional INPUT) — on your own case. Each "
+        "1-D cases, or - given a case .py (positional INPUT) - on your own case. Each "
         "case is run N times under Verrou's random IEEE-754 rounding and compared "
         "against a nearest-rounding reference. PASS/FAIL is scale-free: a case must "
         "retain at least ~24 significant bits (single precision) under random rounding "
         "(no per-case thresholds).\n\n"
         "With a case .py, that case is run as a SINGLE serial CPU process under Verrou "
-        "(~30x slower, and run many times), so it must be a small, short proxy — large "
+        "(~30x slower, and run many times), so it must be a small, short proxy - large "
         "grids or long runs are rejected with guidance; serial .dat I/O is forced. "
         "Example: ./mfc.sh fp-stability my_case.py\n\n"
         "Uses a Verrou-enabled Valgrind at $VERROU_HOME/bin/valgrind (defaults to "
         "$HOME/.local/verrou); if absent it is installed automatically (a pinned, "
-        "hash-verified prebuilt is downloaded, with a source build as fallback) — "
+        "hash-verified prebuilt is downloaded, with a source build as fallback) - "
         "aborts if that install fails. The simulation and pre_process binaries must "
         "be serial (no-MPI, no-GPU) debug builds.\n\n"
         "Analysis passes (skip with --no-* flags):\n"
         "  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"
-        "  float-max      --check-max-float detection of double→float overflow sites\n"
+        "  float-max      --check-max-float detection of double->float overflow sites\n"
     ),
     include_common=["mfc_config", "verbose", "debug_log"],
     positionals=[

toolchain/mfc/fp_stability.py

@@ -8,7 +8,7 @@
    (scale-free: -log2(max_dev/scale) vs one global floor, no per-case threshold).
 
 B. Float proxy (--no-float-proxy to skip)
-   One run with --rounding-mode=float — deterministic proxy for
+   One run with --rounding-mode=float - deterministic proxy for
    single-precision sensitivity without recompiling.
 
 C. VPREC precision sweep (--no-vprec to skip)
@@ -24,7 +24,7 @@
 
 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.
+   double->float conversion would overflow to +/-Inf.
 
 Logs are saved to fp-stability-logs/ and uploaded as CI artifacts.
 On GitHub Actions: a step summary table and ::warning:: file annotations
@@ -334,7 +334,7 @@ def _merge(*dicts):
         "name": "low_mach",
         "description": "1-D water shock with low_Mach=1 HLLC correction active",
         "compare": ["cons.1.00.000050.dat", "prim.3.00.000050.dat"],
-        "ill_cond": "low_Mach correction: velocity perturbation ~u/c cancels severely at M≈0",
+        "ill_cond": "low_Mach correction: velocity perturbation ~u/c cancels severely at M~0",
         "pre": _merge(
             _BASE_PRE,
             _WATER_EOS,
@@ -475,10 +475,10 @@ def _run_case(
                     result["cancellation_macro"] = {(path, line): macro for (path, line) in locs if (macro := _macro_context(path, line))}
                     if locs:
                         worst = max(bits.values()) if bits else 0
-                        cons.print(f"  cancellation: {len(locs)} site(s), worst loses ≥ {worst / math.log2(10):.0f} of ~16 digits")
+                        cons.print(f"  cancellation: {len(locs)} site(s), worst loses >= {worst / math.log2(10):.0f} of ~16 digits")
                         n_macro = len(result["cancellation_macro"])
                         if n_macro:
-                            cons.print(f"  [dim]{n_macro} inside fypp expansions — line maps to multiple instances[/dim]")
+                            cons.print(f"  [dim]{n_macro} inside fypp expansions - line maps to multiple instances[/dim]")
                     else:
                         cons.print("  cancellation: none detected")
             except Exception as exc:
@@ -518,7 +518,7 @@ def _load_user_case(input_path: str) -> dict:
     """Build a single fp-stability case from a user case .py.
 
     The case is run as ONE serial CPU process under Verrou (so it must be small
-    and short — a coarsened proxy of a production run, not the real thing); a grid
+    and short - a coarsened proxy of a production run, not the real thing); a grid
     too large to be feasible errors. The output files to compare are auto-detected
     from the reference run, so 'compare' is left empty here.
     """
@@ -533,14 +533,14 @@ def _load_user_case(input_path: str) -> dict:
     t_stop = int(params.get("t_step_stop", 0) or 0)
     work = cells * max(t_stop, 1)
     if cells > FP_CASE_MAX_CELLS:
-        raise MFCException(f"case has {cells:,} cells — too large for Verrou (~30x slowdown, run many times). " f"Use a coarsened proxy (<= {FP_CASE_MAX_CELLS:,} cells).")
+        raise MFCException(f"case has {cells:,} cells - too large for Verrou (~30x slowdown, run many times). " f"Use a coarsened proxy (<= {FP_CASE_MAX_CELLS:,} cells).")
     if work > FP_CASE_MAX_WORK:
         raise MFCException(
-            f"case is ~{work:,} cell-steps ({cells:,} cells x {t_stop} time steps) — too slow under "
+            f"case is ~{work:,} cell-steps ({cells:,} cells x {t_stop} time steps) - too slow under "
             f"Verrou (~30x, run many times). Reduce m/n/p or t_step_stop (target <= {FP_CASE_MAX_WORK:,} cell-steps)."
         )
     stem = os.path.splitext(os.path.basename(input_path))[0]
-    if stem == "case":  # examples/<name>/case.py — the dir name is more telling
+    if stem == "case":  # examples/<name>/case.py - the dir name is more telling
         stem = os.path.basename(os.path.dirname(os.path.abspath(input_path))) or stem
     return {
         "name": stem,
@@ -554,10 +554,10 @@ def _load_user_case(input_path: str) -> dict:
 
 def _install_verrou() -> str:
     """Verrou is absent: install it via the bootstrap (downloads a pinned, hash-verified
-    prebuilt; source build as fallback) and return the valgrind path. Aborts on failure —
+    prebuilt; source build as fallback) and return the valgrind path. Aborts on failure -
     fp-stability cannot run without Verrou, so this is a hard error, not a skip."""
     script = os.path.join(MFC_ROOT_DIR, "toolchain", "bootstrap", "verrou.sh")
-    cons.print("[bold]Verrou not found — installing it (downloads a prebuilt artifact, ~seconds; source build as fallback)...[/bold]")
+    cons.print("[bold]Verrou not found - installing it (downloads a prebuilt artifact, ~seconds; source build as fallback)...[/bold]")
     if subprocess.run(["bash", script], check=False).returncode != 0:
         raise MFCException("Verrou install failed (see output above). Fix the issue and re-run, install manually with `bash toolchain/bootstrap/verrou.sh`, or pass --verrou-binary PATH.")
     verrou_bin = _find_verrou()

toolchain/mfc/fp_stability_metrics.py

@@ -155,7 +155,7 @@ def _max_abs_np(ref_dir: str, compare_files: list) -> float:
 
 
 def _parse_cancel_gen(gen_path: str) -> list:
-    """Parse cc-gen-file TSV (file\\tline\\tsymbol) → sorted unique [(fname, line)] for MFC sources."""
+    """Parse cc-gen-file TSV (file\\tline\\tsymbol) -> sorted unique [(fname, line)] for MFC sources."""
     if not os.path.isfile(gen_path):
         return []
     locs = []
@@ -215,7 +215,7 @@ def _parse_vg_error_locs(log_path: str, error_keyword: str) -> list:
 # Verrou exposes no per-site bit-count, but --cc-threshold-double is a severity
 # filter: a site is reported only if it lost >= the threshold bits. Sweeping these
 # levels and taking the highest each site survives gives a per-site "bits lost"
-# severity (a lower bound — no false positives). 48 is near the full 53-bit
+# severity (a lower bound - no false positives). 48 is near the full 53-bit
 # double mantissa (the top of the sweep), not the mantissa width itself.
 CANCEL_BIT_LEVELS = [10, 20, 30, 40, 48]
 

toolchain/mfc/fp_stability_report.py

@@ -36,10 +36,10 @@ def _emit_github_annotations(results: list):
             note = "catastrophic cancellation site"
             bits = site_bits.get((fname, lineno))
             if bits:
-                note += f" — loses ≥ {bits / math.log2(10):.0f} of ~16 digits"
+                note += f" - loses >= {bits / math.log2(10):.0f} of ~16 digits"
             macro = macro_sites.get((fname, lineno))
             if macro:
-                note += f" — inside a {macro}-expanded line, may represent multiple instances"
+                note += f" - inside a {macro}-expanded line, may represent multiple instances"
             print(f"::notice {loc},title={title}::{note}", flush=True)
         n_cc = len(r.get("cancellation_locs", []))
         if n_cc > 3:
@@ -51,7 +51,7 @@ def _more_md(total: int, shown: int, noun: str) -> str:
     or '' when nothing was truncated."""
     if total <= shown:
         return ""
-    return f"- …and {total - shown} more {noun}; see `fp-stability-logs/`"
+    return f"- ...and {total - shown} more {noun}; see `fp-stability-logs/`"
 
 
 def _emit_github_summary(results: list, n_samples: int):
@@ -70,26 +70,26 @@ def _emit_github_summary(results: list, n_samples: int):
 
     md = []
     md.append("## FP Stability Results\n")
-    md.append(f"**{n_pass} passed, {n_fail} failed** — {n_samples} random-rounding samples per case\n")
+    md.append(f"**{n_pass} passed, {n_fail} failed** - {n_samples} random-rounding samples per case\n")
     md.append(
         f"> **Coverage:** {len(results)} one-dimensional case(s) "
         f"({', '.join(r['name'] for r in results)}). A pass means stable in the code paths these "
-        "cases exercise — not a guarantee for multi-D, viscous, MHD, IGR, or bubble-dynamics paths "
+        "cases exercise - not a guarantee for multi-D, viscous, MHD, IGR, or bubble-dynamics paths "
         "they do not reach.\n"
     )
 
-    # Main results table — pass/fail is scale-free: bits retained vs a single floor
+    # 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 |")
     md.append("|------|:------:|:------:|--------:|--------:|")
     for r in results:
         status = "PASS" if r["passed"] else "FAIL"
-        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 "—"
+        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 "-"
         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
+    # Cancellation ORIGINS - where ill-conditioning actually arises, led with the
     # most severe (most bits lost).
     cases_with_cancel = [r for r in results if r.get("cancellation_locs")]
     if cases_with_cancel:
@@ -98,7 +98,7 @@ def _emit_github_summary(results: list, n_samples: int):
             "> Subtraction of nearly-equal values loses leading significant digits. A double carries "
             "~**16 significant digits** (53 bits); each entry shows how many that subtraction throws away "
             "(worst case, a lower bound). Losing ~8 digits halves your accuracy; losing ~13+ leaves only "
-            "single-precision trust. Site *count* is not severity — one site losing many digits outweighs "
+            "single-precision trust. Site *count* is not severity - one site losing many digits outweighs "
             "many mild ones.\n"
         )
         for r in cases_with_cancel:
@@ -108,17 +108,17 @@ def _emit_github_summary(results: list, n_samples: int):
             ordered = sorted(sites, key=lambda e: (-e["bits"], e["where"]))
             if ordered:
                 w = ordered[0]
-                md.append(f"**`{r['name']}`** — {len(ordered)} site(s); worst loses ≥ {w['bits'] / math.log2(10):.0f} of ~16 digits\n")
+                md.append(f"**`{r['name']}`** - {len(ordered)} site(s); worst loses >= {w['bits'] / math.log2(10):.0f} of ~16 digits\n")
             for e in ordered[:15]:
                 lost = e["bits"] / math.log2(10)
-                ambiguous = f" — _{e['macro']}-expanded, may represent multiple instances_" if e["macro"] else ""
-                md.append(f"- **≥ {lost:.0f} digits lost** (~{_digits_left(e['bits']):.0f} of 16 left) — `{e['where']}`{ambiguous}")
+                ambiguous = f" - _{e['macro']}-expanded, may represent multiple instances_" if e["macro"] else ""
+                md.append(f"- **>= {lost:.0f} digits lost** (~{_digits_left(e['bits']):.0f} of 16 left) - `{e['where']}`{ambiguous}")
             footer = _more_md(len(ordered), 15, "site(s)")
             if footer:
                 md.append(footer)
             md.append("")
 
-    # VPREC sweep — one column per mantissa-bit level showing the L∞ deviation at
+    # VPREC sweep - one column per mantissa-bit level showing the Linf deviation at
     # that reduced precision ("crash" = run diverged/failed; dash = not measured).
     if any(r["vprec"] for r in results):
         _labels = {52: "52b", 23: "23b", 16: "16b", 10: "10b"}
@@ -133,7 +133,7 @@ def _emit_github_summary(results: list, n_samples: int):
             for b in VPREC_MANTISSA_BITS:
                 d = vmap.get(b)
                 if d is None:
-                    cols.append("—")
+                    cols.append("-")
                 elif d == float("inf"):
                     cols.append("crash")
                 else:
@@ -146,7 +146,7 @@ def _emit_github_summary(results: list, n_samples: int):
     if cases_with_fmax:
         md.append("### Float32 overflow sites (check\\_max\\_float)\n")
         for r in cases_with_fmax:
-            md.append(f"**`{r['name']}`** — {len(r['float_max_locs'])} site(s)\n")
+            md.append(f"**`{r['name']}`** - {len(r['float_max_locs'])} site(s)\n")
             for fname, lineno in r["float_max_locs"][:10]:
                 md.append(f"- `{fname}:{lineno}`")
             footer = _more_md(len(r["float_max_locs"]), 10, "site(s)")