Classifying 0/0 Limits — Acceptance Tests — Operational diagnostics and registry (ties, flags, print grammar) (6B)

Windows: {W_r} with radii r_1 > r_2 > ... > r_R shrinking to x0
median_by_window(u)_r := median( { u(t) : t in W_r } )
median_tail(u)        := median( median_by_window(u)_{R-K+1..R} )
var_tail(u)           := variance( median_by_window(u)_{R-K+1..R} )
monotone_up(u)        := true iff for j=R-K+1..R-1:
                         median_by_window(u)_{j+1} >= median_by_window(u)_{j} * (1 - eta_mono)
Defaults: K = 5, eta_mono = 0.01
Same-window comparability: evaluate f and g on the same x-samples in each W_r

If robust SEs available:
  T_p := z_sep * sqrt( sigma_pf^2 + sigma_pg^2 )
  T_q := z_sep * sqrt( sigma_qf^2 + sigma_qg^2 )    # z_sep = 3.0
Decide by p if |p_f - p_g| > T_p; else try q with T_q.

If SEs unavailable/unreliable:
  fallback to absolute bands (T_p_abs, T_q_abs) and bootstrap %agree.

Lexicographic with near-ties (per 4A):
  Delta_p_eff := 0 if |Delta_p| <= T_p else Delta_p
  Delta_q_eff := 0 if |Delta_q| <= T_q else Delta_q
  Compare (Delta_p_eff, Delta_q_eff)
Lite defaults: T_p = 1e-3, T_q = 1e-3   # declare once

REG = SIDED  # left vs right neighborhoods give different classes; print both one-sided results
REG = OSC    # persistent oscillation on shrinking windows; do not print VAL[.]
REG = MULTI  # model-chooser ties/incompatibility or inconclusive finite-ratio test
REG = NOFIT  # no family reaches quality floor (e.g., all R2 < R2_min)

EDGE(p)      # exponent tie or near-tie triggered tie policy
EDGE(q)      # log-modifier tie or near-tie (only if log tie-break was evaluated)
EDGE(model)  # model-chooser scores tie within delta_score (e.g., <= 2.0)
STAB[%]      # optional bootstrap or priors-sweep agreement for headline class

Canonical (single-winner, non-OSC, non-SIDED):
SSMS: {CLASS}@{A-tag}  DIV[a_div]@{A-tag}  {DIR?}  {REG?}  {BADGES?}

Rules:
  {CLASS} ∈ { Z , VAL[v] , INF+ , INF- }
  {A-tag} from band of a_div ∈ { A++ , A+ , A0 , A- , A-- }
  DIV[a_div] repeats the same @{A-tag}
  DIR policy: INF -> DIR+ / DIR- required; FINITE -> DIR optional; ZERO -> omit (or DIR0 if desired)
  {REG?} may include SIDED, OSC, NOFIT, MULTI
  {BADGES?} may include EDGE(p), EDGE(q), EDGE(model), STAB[%]

OSC (no class):
  SSMS: REG=OSC  DIV[a_div]@{A-tag}  {BADGES?}

SIDED (two one-sided lines):
  SSMS (x->x0-): {CLASS_-}@{A-tag_-}  DIV[a_div_-]@{A-tag_-}  {DIR-?}
  SSMS (x->x0+): {CLASS_+}@{A-tag_+}  DIV[a_div_+]@{A-tag_+}  {DIR+?}
  SSMS: REG=SIDED  {BADGES?}

NOFIT (optional class withholding):
  SSMS: REG=NOFIT  DIV[a_div]@{A-tag}  {BADGES?}

MULTI (conservative headline order):
  Use canonical line with conservative class (ZERO < FINITE < INF) and append REG=MULTI
  Add EDGE(model) if chooser tied within delta_score

1) If sidedness differs -> REG = SIDED; print both one-sided results
2) Else if oscillation -> REG = OSC; do not print VAL[.]
3) Else if no lens passes quality -> REG = NOFIT; pick conservative headline or withhold value
4) Else if chooser tie/incompatibility -> REG = MULTI; conservative headline
5) Else print single-winner headline per rate rule

Clamp before rapidity ops:
  a := clamp(a, -1 + eps_a, +1 - eps_a)   # eps_a = 1e-6
Guard denominators/weights when pooling:
  w := max(w, eps_w)                       # eps_w = 1e-12
INF certification:
  require median_tail(|f/g|) >= M_large and monotone_up(|f/g|)
ZERO certification:
  require median_tail(|f/g|) <= tol_0
FINITE certification:
  require median_tail(| f/g - c_f/c_g |) <= tol_m

Run the entire pipeline on x->x0- and x->x0+ using mirrored windows.
If classes or values differ materially -> REG = SIDED and print both one-sided one-liners.

Consider an essential lens only if power and power*log fail quality and tails suggest extreme flatness/blow-up.
If both sides fit essential with comparable order -> allow ZERO/INF.
Otherwise prefer REG = MULTI.