AI Skill Report Card

Auditing Physics Verification Dashboards

A-83·Oct 26, 2026·Source: Extension-page
YAML
--- name: auditing-physics-verification-dashboards description: Reviews and validates interactive scientific verification dashboards that bridge monograph formulas to reproducible scripts—checking that proven lemmas, live numerical checks, parity/closure tests, and telemetry logs are internally consistent and faithfully traceable to source equations. Use when inspecting or building a "live math/physics proof" interface (astrophysics lensing, timing, or similar), verifying that displayed PASS/FAIL results match underlying formulas, auditing Merkle-chained telemetry logs, or reconciling a visualization's claims against its reference script section by section. ---
14 / 15

Given a dashboard (or its exported telemetry log) claiming N lemmas/propositions are PASS, do this first:

  1. Map every displayed check to its formula source (paper §, script section/function).
  2. Re-derive 2–3 "anchor" numbers by hand (e.g., Schwarzschild radius, Einstein radius) using the stated constants.
  3. Confirm every PASS has: (a) an exact or tolerance-bounded identity, (b) a stated tolerance/epsilon, (c) a reproducible script line.
  4. Flag any row labeled "not used" or "definition" — these must NOT be counted toward the PASS tally.
r_s = 2GM/c²        # Schwarzschild radius
θ_E = sqrt(4GM/c² · d_LS/(d_L·d_S))   # Einstein angle
Δt_Shapiro ~ (2GM/c³) ln(...)         # Shapiro delay scale
Recommendation▾
Add a concrete bad-outcome example (e.g., a dashboard that incorrectly counts 'definition' rows as PASS) to show failure detection explicitly
14 / 15

Progress:

  • Step 1: Inventory every lemma/proposition referenced and its claimed status (PASS / not used / definition)
  • Step 2: For each PASS, locate the exact formula (paper section) and the script section that computes it
  • Step 3: Re-run or hand-verify the numeric identity (exact integer/quaternion checks vs. floating-point tolerance checks — treat these differently)
  • Step 4: Check parity/residual relations (e.g., Y_R = Y_total − Y_I − Y_II − Y_III) for algebraic consistency, not just reported PASS
  • Step 5: Verify frame-closure / unitary-norm claims (e.g., |H|=1, A·A⁻¹=1) are truly exact, not rounded
  • Step 6: Audit the Merkle/hash chain — confirm tampering one leaf actually breaks the root, and the "South Halo" or pre-filter fields are correctly scoped as non-cryptographic
  • Step 7: Cross-check physical outputs (Einstein radii, Shapiro scale, sphere of influence, drift rates) against known astrophysical values (e.g., Gaia aberration drift ≈ 5.05 ± 0.35 µas/yr)
  • Step 8: Separate "live checks" from "static definitions" in the final tally; report the true pass/claim ratio
Recommendation▾
Include a minimal reusable checklist/template summarizing PASS criteria (exact vs tolerance vs excluded) for quick reference
18 / 20

Example 1: Input: A dashboard states "Einstein radius, source 1.0 pc behind Sgr A*: theta_E = 22.605 mas" with M_BH = 4.297e6 Msun, R0 = 8275 pc. Output: Recompute r_s = 2GM/c² ≈ 1.269e10 m. Use θ_E = sqrt(4GM/c² · (d_LS/(d_L d_S))) with d_L=R0, d_S=R0+1pc, d_LS=1pc. Confirm result ≈ 22.6 mas within floating-point tolerance → confirms formula and constants are consistent; note this is a derived (not independently measured) quantity, so "PASS" here means "self-consistent," not "experimentally validated."

Example 2: Input: Table claims "Residual parity, Proposition G1: PROVEN, Y_R = Y − Y_I − Y_II − Y_III = 0 (exact)". Output: Check that Y, Y_I, Y_II, Y_III are BigInt or exact rational — not floats — before accepting "exact." If the display shows floating decimals (e.g., 80.7286), flag that true exactness requires checking the underlying rational/BigInt representation, since decimal printouts can mask rounding.

Example 3: Input: "Frame invariance, Theorem 7.18: Re(I) = Re(E) = 120892581960439973465… PASS exact" Output: Verify this is a quaternion/rotor identity (A I A⁻¹ E = 1) computed in exact arithmetic (integer or rational), not floating point — long matching digit strings are a strong signal of exact computation; spot-check by reconstructing A, I, E from stated rotor/leg angles if available.

Recommendation▾
Trim slightly overlapping content between Workflow and Best Practices/Pitfalls sections to tighten conciseness
  • Separate "proven" from "computed" from "definition." Only "proven" rows with live numeric checks count as verification; "definition" and "not used" rows make no claims and must be excluded from pass-rate tallies.
  • Distinguish exact vs. tolerance-bounded claims. Integer/quaternion/BigInt identities should show "0 (exact)"; physical/astronomical quantities should show an explicit tolerance (5σ, epsilon, etc.).
  • Trust long matching digit strings as evidence of exact arithmetic, but still verify the generating formula independently.
  • Always re-derive at least one physical anchor number (Schwarzschild radius, sphere of influence, Shapiro delay scale) from first principles and stated constants — don't just trust the displayed value.
  • Treat Merkle/hash chains as tamper-evidence, not correctness proof. A passing hash chain confirms data wasn't altered after computation; it says nothing about whether the computation itself is physically correct.
  • Cross-reference external published values (e.g., Gaia EDR3 aberration drift, Reid & Brunthaler proper motions) when the dashboard claims to "reproduce" a known result.
  • Check units and orders of magnitude at every stage (µas vs mas vs arcsec; pc vs AU; s⁻¹ vs s) — these dashboards mix many scales and unit errors are the most common real bug.
  • Don't count "not used" or "definition" rows toward a PASS tally — they are explicitly out of scope, not successes.
  • Don't assume a floating-point display with many decimal digits is "exact" — check whether the underlying computation uses BigInt/rational arithmetic.
  • Don't conflate internal self-consistency (the math checks out against itself) with external physical validation (the math matches observed/published astrophysical data) — the dashboard shows both, but they are different kinds of claims.
  • Don't ignore the weak-field vs strong-field boundary (e.g., GM/(c²r) < 1e-5 threshold) — results computed under a "superposition holds" assumption are invalid inside the stated strong-field radius.
  • Don't treat a cache-layer "pre-filter" (e.g., South Halo bits) as part of the cryptographic integrity check — it typically has a stated, narrower scope.
  • Don't skip verifying that "two unknowns, one total" cases are correctly reported as not recoverable — a system that claims full recoverability in underdetermined cases is a red flag.
0
Grade A-AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
14/15
Workflow
14/15
Examples
18/20
Completeness
10/20
Format
14/15
Conciseness
13/15