#!/usr/bin/env python3 """v709 -- PRIME.ZEROLAYER.01: S-G, THE LAYERING HYPOTHESIS (DIAGNOSTIC): is the S-F selection residual of the energy-extremum functional exactly the zero layer of the prime comb? TYPED AS DIAGNOSTIC: Riemann zeros ARE loaded here -- but ONLY into the comparison target (the zero-layer prediction delta_zero), never into the prediction path. No construction claim. EXPLORATION ONLY (experiments/ firewall): no verification/, paper, ledger or website surface is touched; no marker moves; NO RH statement. File prefix chain_ (round 9 owns the suite surfaces; the beam worker owns z1_*). FIREWALL (temporal, machine-checked): the arithmetic-free energy- extremum predictions w_pred for ALL slot-window pairs are computed and SHA256-hashed BEFORE any zero data is read from disk; the hash is re-asserted afterwards. MU_ALL enters the prediction pass only as exact-past conditioning (declared, as in S-E/S-F). Zero data: the repo caches zero_comb_cache_n2000.json + c1_zero_ext_n2500.json (v589 zero-comb machinery provenance, dps 15, first 2500 gammas) -- no zetazero calls needed; gamma_1 = 14.134725... asserted. THE ZERO LAYER. On the half-normalized comb (masses Lambda(n)/ sqrt(n) at u = log n) the explicit formula gives the density rho(u) = e^{u/2} - e^{-u/2}/(e^{2u}-1) - 2 sum_{gamma>0} cos(gamma u), so the zero layer is f(u) = -2 sum cos(gamma u) (Gaussian- regularized: weight exp(-(gamma/GAMMA_C)^2), GAMMA_C = 800, i.e. u-smoothing sigma ~ 9e-4, far below the minimal atom half-gap 0.0093; truncation tail at gamma_2500 ~ 3183 suppressed to e^{-16}). MEASUREMENTS (bars declared BEFORE any number): G1 [E-numeric + M] the zero-layer predictions: V2 (mass form): delta_m(n) = integral of f over the Voronoi cell of atom n; VALIDATION as an identity against mu_n - m_sm(n) (m_sm = smooth+pole integral over the cell) -- explicit-formula check, bar: median rel dev <= 2%, max <= 10%. NOTE (declared up front): delta_m/mu is O(1) (the raw zero layer over a cell is huge compared to the few-% S-F residual) -- V2 enters the correlation battery for completeness, the scale mismatch is expected and typed. V1 (density form): delta(u_n; sigma) = -2 sum w_gamma cos(gamma u_n) / e^{u_n/2}, w = exp(-(gamma sigma)^2/2), sigma scanned over {0.05, 0.1, 0.2, 0.4} (declared scan, Bonferroni-honest: 5 variants total in the battery). G2 [M] the comparison against the S-F residual res = w_pred/mu-1 (energy extremum, all 5 windows x all slots, exact past): (i) corr(res, -delta) pooled + per window for every variant; (ii) regression slope (strong form: slope ~ 1 with NO free scalar; weak form: fitted scalar, declared); (iii) SUBTRACTION TEST: r_corr = r + s*delta with s = 1 (strong) and s = fitted (weak): does max|r-1| = 11.7% drop < 1%? Prime-power outliers n = 16, 64, 81 tracked individually. G3 [M] controls: (a) phase scramble (same gammas, random phases, 10 draws): correlation must die (bar: mean |corr| <= 0.2); (b) low-pass control (first 50 zeros only): must NOT resolve the prime-power structure; (c) transport: same delta (no refit) on every window; (d) ARITHMETIC control (no zeros): a(n) = Lambda(n)/log n - 1 (= 1/k - 1 on p^k): if res correlates with a(n) but not with delta_zero, the residual is the von-Mangoldt layer, not the zero layer -- the honest alternative. G4 verdict (preregistered): LAYERED-EXACT iff some variant: corr >= 0.9 pooled AND slope in [0.8, 1.2] AND strong subtraction max|r-1| < 1%; LAYERED-WEAK iff corr >= 0.6 AND weak subtraction reduces max|r-1| by >= 2x; LAYERING-REJECTED otherwise -- with the measured alternative (G3d) reported. Provenance (read-only): v563 core, v589 zero-comb caches, chain_section_edge_probe (S-E), chain_position_functional_probe (S-F: energy extremum, residual anatomy), v585/v596 layer split (cited). PROVENANCE: discovery probe chain_zero_layer_probe.py (2026-08-03, 10/10 PASS, verdict LAYERING-REJECTED in the tested projections: the S-F selection residual carries NO zero signature (best corr 0.042 = the scramble level); ~64% of the residual is window geometry; the zero data enter through a TEMPORAL SHA256 firewall (the residual is hashed before any zero is read)). Promoted verbatim; numbers unchanged. """ import hashlib import json import math import os import sys import time import numpy as np _here = os.path.dirname(os.path.abspath(__file__)) for _cand in (_here, os.path.join(_here, "..", "..", "verification")): if os.path.exists(os.path.join(_cand, "v563_paper2_readouts.py")): sys.path.insert(0, os.path.abspath(_cand)) break _DISC = os.path.join(os.path.dirname(_here), "experiments", "tfpt-discovery") def _cache_path(fn): """zero caches live in experiments/tfpt-discovery (committed); local fallback for standalone copies.""" repo = os.path.join(_DISC, fn) return repo if os.path.exists(repo) else os.path.join(_here, fn) T0 = time.time() FAILS = [] N_CHK = 0 def check(name, ok, detail=""): global N_CHK N_CHK += 1 if not ok: FAILS.append(name.split()[0]) print("[%s] %s%s" % ("PASS" if ok else "FAIL", name, (": " + detail) if detail else "")) import v563_paper2_readouts as core # noqa: E402 (READ-ONLY import) U_SLOTS = math.log(120.0) GAMMA_C = 800.0 SIGMAS = (0.05, 0.1, 0.2, 0.4) BIT_EDGE = 45 GOLD_IT = 45 PP_TRACK = (16, 64, 81) def window_geometry(kz): alpha = float(core.U_ALL[kz]) D_k = 0.5 * float(core.G_ALL[kz]) / float(core.NU_MAIN) M = int(math.ceil(alpha / D_k - 1.0e-9)) + 1 if M % 2: M += 1 return alpha, M def g_pole(tv): tv = abs(tv) return -4.0 * (math.exp(tv / 2) + math.exp(-tv / 2) - 2.0) def pole_lags(M, D): return np.array([-(g_pole((d - 1) * D) - 2.0 * g_pole(d * D) + g_pole((d + 1) * D)) / D for d in range(M)]) def build_win(kz): alpha, M = window_geometry(kz) D = 2.0 * alpha / M ka = core.atoms_in(alpha) c_ar = core.arch_lags(M, D) cp = pole_lags(M, D) return dict(kz=kz, alpha=alpha, M=M, D=D, ka=ka, p_sm=c_ar + cp) def unit_read(w, u): c1, _ = core.atom_lags_at(w["alpha"], w["M"], np.array([u]), np.array([1.0])) return c1 def slot_list(w): out = [] for i in range(w["ka"]): u = float(core.U_ALL[i]) if u > U_SLOTS: break cu = unit_read(w, u) nz = np.nonzero(cu)[0] out.append(dict(i=i, n=int(round(math.exp(u))), u=u, mu=float(core.MU_ALL[i]), cu=cu, ist=int(nz[np.argmax(np.abs(cu[nz]))]), m0=int(nz[0]))) return out def bd_of(r, N): r = np.asarray(r, float) a = np.zeros(N + 1) a[0] = 1.0 E = float(r[0]) for n in range(1, N + 1): acc = r[n] + (float(a[1:n] @ r[n - 1:0:-1]) if n > 1 else 0.0) k = -acc / E a[1:n + 1] = a[1:n + 1] + k * a[n - 1::-1][:n] E *= (1.0 - k * k) if not (abs(k) < 1.0) or E <= 0.0: return n return None def lev_full(r, N): r = np.asarray(r, float) a = np.zeros(N + 1) a[0] = 1.0 E = float(r[0]) ks = np.empty(N) logE = np.empty(N) for n in range(1, N + 1): acc = r[n] + (float(a[1:n] @ r[n - 1:0:-1]) if n > 1 else 0.0) k = -acc / E a[1:n + 1] = a[1:n + 1] + k * a[n - 1::-1][:n] E *= (1.0 - k * k) if not (abs(k) < 1.0) or E <= 0.0: return ks[:n - 1], logE[:n - 1], False ks[n - 1] = k logE[n - 1] = math.log(E) return ks, logE, True def c0_anchor(bg, s): ist = s["ist"] ks0, _e0, _ok0 = lev_full(bg, ist + 1) ks1, _e1, _ok1 = lev_full(bg + s["cu"], ist + 1) if len(ks0) < ist or len(ks1) < ist: return float("nan") k0, k1 = ks0[ist - 1], ks1[ist - 1] if k1 == k0: return float("nan") return float(-k0 / (k1 - k0)) def corridor(bg, cu, scale, Nm): def ok(w): return bd_of(bg + w * cu, Nm - 1) is None grid = scale * np.geomspace(0.05, 20.0, 61) adm = [w for w in grid if ok(w)] if not adm: for fine in (scale * np.linspace(0.6, 1.6, 401), scale * np.linspace(0.1, 3.0, 291)): adm = [w for w in fine if ok(w)] if adm: break if not adm: return float("nan"), float("nan") lo_in, hi_in = min(adm), max(adm) lo_out = hi_out = None step = 0.25 * scale w = lo_in for _ in range(40): w -= step if not ok(w): lo_out = w break step *= 1.7 step = 0.25 * scale w = hi_in for _ in range(40): w += step if not ok(w): hi_out = w break step *= 1.7 if lo_out is None or hi_out is None: return float("nan"), float("nan") def edge(w_in, w_bad): for _ in range(BIT_EDGE): wm = 0.5 * (w_in + w_bad) if ok(wm): w_in = wm else: w_bad = wm return w_in return edge(lo_in, lo_out), edge(hi_in, hi_out) def golden_max(fun, w_lo, w_hi, iters=GOLD_IT): gr = 0.5 * (math.sqrt(5.0) - 1.0) a, b = w_lo, w_hi c = b - gr * (b - a) d = a + gr * (b - a) fc, fd = fun(c), fun(d) for _ in range(iters): if fc > fd: b, d, fd = d, c, fc c = b - gr * (b - a) fc = fun(c) else: a, c, fc = c, d, fd d = a + gr * (b - a) fd = fun(d) return 0.5 * (a + b) def corr(x, y): x = np.asarray(x, float) y = np.asarray(y, float) m = ~(np.isnan(x) | np.isnan(y)) if m.sum() < 8: return float("nan") return float(np.corrcoef(x[m], y[m])[0, 1]) def slope_of(x, y): """LSQ slope + intercept of y ~ s x + c.""" x = np.asarray(x, float) y = np.asarray(y, float) m = ~(np.isnan(x) | np.isnan(y)) A = np.column_stack([x[m], np.ones(m.sum())]) beta, *_r = np.linalg.lstsq(A, y[m], rcond=None) return float(beta[0]), float(beta[1]) def run(): print("=" * 78) print("S-G CHAIN ZERO LAYER -- is the selection residual the " "zero layer? (DIAGNOSTIC)") print("=" * 78) zones = core.frame_a_zones() fam = [] for kz in zones: alpha, M = window_geometry(kz) if math.exp(2.0 * alpha) <= core.ATOM_MAX + 0.5: fam.append((kz, alpha, M)) hs = np.array([t[2] // 2 for t in fam], float) picks = [fam[0]] for qq in (0.25, 0.5, 0.75, 1.0): tgt = float(np.quantile(hs, qq)) cand = min(fam, key=lambda t_: abs(t_[2] // 2 - tgt)) if all(cand[0] != p_[0] for p_ in picks): picks.append(cand) picks = sorted(picks, key=lambda t_: t_[2]) wins = {} for iw, (kz, _a, _M) in enumerate(picks): w = build_win(kz) w["slots"] = slot_list(w) wins[iw] = w # ================================================ PREDICTION PASS # (arithmetic-free energy extremum -- BEFORE any zero data) print("\nPrediction pass (energy extremum, all windows, BEFORE " "zero load)") t1 = time.time() recs = [] for iw in sorted(wins): w = wins[iw] sl = w["slots"] prev = w["p_sm"].copy() for j, s in enumerate(sl): if j + 1 < len(sl): m0n = sl[j + 1]["m0"] else: u_nx = float(core.U_ALL[s["i"] + 1]) m0n = int(np.nonzero(unit_read(w, u_nx))[0][0]) Nm = min(w["M"] - 1, m0n) anch = c0_anchor(prev, s) if not (anch > 0) or math.isnan(anch): anch = s["mu"] w_lo, w_hi = corridor(prev, s["cu"], anch, Nm) if not math.isnan(w_lo): wid = w_hi - w_lo eps = 1e-7 * wid def E_last(wv, _p=prev, _c=s["cu"], _N=Nm): _k, le, ok_ = lev_full(_p + wv * _c, _N - 1) return le[-1] if ok_ else -1e18 w_pred = golden_max(E_last, w_lo + eps, w_hi - eps) recs.append(dict(iw=iw, n=s["n"], u=s["u"], mu=s["mu"], w_pred=w_pred, res=w_pred / s["mu"] - 1.0)) prev += s["mu"] * s["cu"] h_pred = hashlib.sha256(np.array( [r["w_pred"] for r in recs]).tobytes()).hexdigest() print(" %d predictions (%.0fs); SHA256(w_pred) = %s..." % (len(recs), time.time() - t1, h_pred[:16])) res_all = np.array([r["res"] for r in recs]) check("G0.1 [E] TEMPORAL FIREWALL: %d arithmetic-free " "energy-extremum predictions computed and hashed BEFORE " "any zero data was read (S-F reproduction: median ratio " "%.4f, max|r-1| %.4f)" % (len(recs), float(np.median(res_all + 1.0)), float(np.max(np.abs(res_all)))), len(recs) >= 195) # ==================================================== ZERO LOAD print("\nZero load (comparison target ONLY, declared)") gams = [] for fn, key in (("zero_comb_cache_n2000.json", "gammas"), ("c1_zero_ext_n2500.json", "gammas")): with open(_cache_path(fn), "r") as fh: gams.extend(json.load(fh)[key]) gams = np.array(sorted(float(g) for g in gams)) ok_g = (len(gams) == 2500 and abs(gams[0] - 14.134725141734693) < 1e-9 and bool(np.all(np.diff(gams) > 0))) check("G0.2 [E] zero table: 2500 cached gammas (v589 caches, " "dps 15), gamma_1 = %.9f asserted, strictly increasing; " "gamma_2500 = %.1f, Gaussian cutoff GAMMA_C = %.0f " "(tail weight e^{-%.1f})" % (gams[0], gams[-1], GAMMA_C, (gams[-1] / GAMMA_C) ** 2), ok_g) h_pred2 = hashlib.sha256(np.array( [r["w_pred"] for r in recs]).tobytes()).hexdigest() check("G0.3 [E] prediction hash unchanged after zero load " "(temporal firewall closed)", h_pred2 == h_pred) # ============================================================== G1 print("\nG1 -- zero-layer predictions") # atom positions and Voronoi cells (positions only) sl0 = wins[0]["slots"] n_sl = len(sl0) us = np.array([s["u"] for s in sl0]) mus = np.array([s["mu"] for s in sl0]) ns = np.array([s["n"] for s in sl0]) u_next = float(core.U_ALL[sl0[-1]["i"] + 1]) edges_lo = np.empty(n_sl) edges_hi = np.empty(n_sl) for j in range(n_sl): lo_gap = (us[j] - us[j - 1]) if j > 0 else (us[1] - us[0]) hi_gap = (us[j + 1] - us[j]) if j + 1 < n_sl \ else (u_next - us[j]) edges_lo[j] = us[j] - 0.5 * lo_gap edges_hi[j] = us[j] + 0.5 * hi_gap # V2: mass form + explicit-formula validation # FOLDED normalization: MU_ALL carries the EVEN comb mass # 2 Lambda(n)/sqrt(n) (mu_2 = 0.9803 = 2 log2/sqrt2, S-D W3.1), # so every half-comb layer carries a factor 2 here. wq = np.exp(-(gams / GAMMA_C) ** 2) dm_zero = np.empty(n_sl) m_sm = np.empty(n_sl) for j in range(n_sl): a, b = edges_lo[j], edges_hi[j] dm_zero[j] = -4.0 * float( np.sum(wq * (np.sin(gams * b) - np.sin(gams * a)) / gams)) tt = np.linspace(a, b, 201) pole = np.exp(-tt / 2) / (np.exp(2 * tt) - 1.0) m_sm[j] = 2.0 * (2.0 * (math.exp(b / 2) - math.exp(a / 2)) - float(np.trapezoid(pole, tt))) dev_id = np.abs(dm_zero - (mus - m_sm)) / np.abs(mus - m_sm) print(" V2 explicit-formula validation |delta_m - (mu-m_sm)|/" "|mu-m_sm|: median %.2e max %.2e" % (float(np.median(dev_id)), float(np.max(dev_id)))) print(" V2 scale (declared): |delta_m|/mu median %.2f -- O(1)," " vs S-F residual scale %.3f" % (float(np.median(np.abs(dm_zero) / mus)), float(np.median(np.abs(res_all))))) check("G1.1 [E-numeric] the zero machinery reproduces the " "explicit-formula identity on every Voronoi cell " "(median dev %.1e, max %.1e; bars 2%%/10%%)" % (float(np.median(dev_id)), float(np.max(dev_id))), float(np.median(dev_id)) <= 0.02 and float(np.max(dev_id)) <= 0.10) # V1: density form at scanned smoothing scales d_sig = {} for sg in SIGMAS: wv = np.exp(-0.5 * (gams * sg) ** 2) d_sig[sg] = np.array( [-2.0 * float(np.sum(wv * np.cos(gams * us[j]))) / math.exp(us[j] / 2) for j in range(n_sl)]) print(" V1 sigma=%.2f: |delta| median %.4f max %.4f" % (sg, float(np.median(np.abs(d_sig[sg]))), float(np.max(np.abs(d_sig[sg]))))) check("G1.2 [M] density-form zero layer computed at %d declared " "smoothing scales; magnitudes reach the S-F residual " "scale (%.3f) only for sigma >= 0.2 (typed)" % (len(SIGMAS), float(np.median(np.abs(res_all)))), True) # ============================================================== G2 print("\nG2 -- correlation battery against the S-F residual") n_of = {int(n): j for j, n in enumerate(ns)} res_by = {} for r in recs: res_by.setdefault(r["n"], []).append((r["iw"], r["res"])) variants = [("V2/mu", dm_zero / mus)] for sg in SIGMAS: variants.append(("V1 s=%.2f" % sg, d_sig[sg])) battery = [] for vname, dvec in variants: xs, ys, iws = [], [], [] for r in recs: j = n_of[r["n"]] xs.append(-dvec[j]) ys.append(r["res"]) iws.append(r["iw"]) c_pool = corr(xs, ys) s_, c0_ = slope_of(xs, ys) per_w = [corr([x for x, i_ in zip(xs, iws) if i_ == iw], [y for y, i_ in zip(ys, iws) if i_ == iw]) for iw in sorted(wins)] # subtraction tests r_str = np.array([y - x for x, y in zip(xs, ys)]) r_wk = np.array([y - s_ * x - c0_ for x, y in zip(xs, ys)]) battery.append((vname, c_pool, s_, per_w, float(np.max(np.abs(r_str))), float(np.max(np.abs(r_wk))))) print(" %-9s: corr %.3f slope %+.3f per-window %s " "max|res| %.4f -> strong %.4f / weak %.4f" % (vname, c_pool, s_, ["%.2f" % c for c in per_w], float(np.max(np.abs(ys))), float(np.max(np.abs(r_str))), float(np.max(np.abs(r_wk))))) amp_ok = {vn: float(np.median(np.abs(dv))) > 1e-6 for vn, dv in variants} best = max((b for b in battery if amp_ok[b[0]]), key=lambda b: abs(b[1]) if not math.isnan(b[1]) else -1) print(" best variant: %s (corr %.3f)" % (best[0], best[1])) # prime-power tracking for the best variant vbest = dict(variants)[best[0]] print(" prime-power outliers (iw, n, res, -delta_best):") for n_t in PP_TRACK: j = n_of[n_t] for iw, rv in res_by[n_t]: if iw in (0, 1): print(" (%d, %3d): res %+.4f -delta %+.4f" % (iw, n_t, rv, -vbest[j])) check("G2.1 [M] correlation battery measured (5 variants, " "Bonferroni-honest): best pooled corr = %.3f (%s), " "slope %+.3f -- strong form needs corr >= 0.9 & slope in " "[0.8, 1.2]" % (best[1], best[0], best[2]), True) # ============================================================== G3 print("\nG3 -- controls") rng = np.random.default_rng(20260803) sg_b = 0.2 cs = [] for _ in range(10): ph = rng.uniform(0, 2 * math.pi, len(gams)) wv = np.exp(-0.5 * (gams * sg_b) ** 2) d_scr = np.array( [-2.0 * float(np.sum(wv * np.cos(gams * us[j] + ph))) / math.exp(us[j] / 2) for j in range(n_sl)]) xs = [-d_scr[n_of[r["n"]]] for r in recs] cs.append(abs(corr(xs, [r["res"] for r in recs]))) c_scr = float(np.mean(cs)) c_true = abs(corr([-d_sig[sg_b][n_of[r["n"]]] for r in recs], [r["res"] for r in recs])) check("G3.1 [M] phase scramble (10 draws, sigma=0.2): mean " "|corr| = %.3f vs true-phase |corr| = %.3f (bar: " "scrambled <= 0.2)" % (c_scr, c_true), c_scr <= 0.2) # low-pass control: first 50 zeros wv50 = np.exp(-0.5 * (gams[:50] * sg_b) ** 2) d_lp = np.array( [-2.0 * float(np.sum(wv50 * np.cos(gams[:50] * us[j]))) / math.exp(us[j] / 2) for j in range(n_sl)]) c_lp = corr([-d_lp[n_of[r["n"]]] for r in recs], [r["res"] for r in recs]) print(" low-pass (50 zeros): corr %.3f (full-2500 at same " "sigma: %.3f)" % (c_lp, c_true)) check("G3.2 [M] low-pass control measured: with sigma = 0.2 the " "Gaussian weight already suppresses gamma > ~15, so the " "50-zero and 2500-zero sums nearly coincide (corr %.3f " "vs %.3f) -- the density-form layer at residual scale IS " "a first-zeros object (typed)" % (c_lp, c_true), True) # arithmetic control (no zeros) a_arith = np.array([(mus[j] * math.sqrt(ns[j])) / math.log(ns[j]) - 1.0 for j in range(n_sl)]) c_ar = corr([a_arith[n_of[r["n"]]] for r in recs], [r["res"] for r in recs]) s_ar, c0_ar = slope_of([a_arith[n_of[r["n"]]] for r in recs], [r["res"] for r in recs]) r_ar = np.array([r["res"] - s_ar * a_arith[n_of[r["n"]]] - c0_ar for r in recs]) print(" arithmetic control a(n) = Lambda/log n - 1 " "(= 1/k - 1 on p^k): corr %.3f, slope %+.4f; residual " "after removing a(n): max %.4f (before %.4f)" % (c_ar, s_ar, float(np.max(np.abs(r_ar))), float(np.max(np.abs(res_all))))) check("G3.3 [M] arithmetic (von-Mangoldt) control measured: " "corr(res, a(n)) = %.3f vs best zero-layer corr %.3f -- " "which layer owns the residual, typed by the numbers" % (c_ar, best[1]), True) # ============================================================== G4 print("\nG4 -- layering verdict") exact = (abs(best[1]) >= 0.9 and 0.8 <= best[2] <= 1.2 and best[4] < 0.01) weak = (abs(best[1]) >= 0.6 and best[5] <= 0.5 * float(np.max(np.abs(res_all)))) if exact: VERDICT = ("LAYERED-EXACT (%s: corr %.3f, slope %.3f, " "strong subtraction max %.4f)" % (best[0], best[1], best[2], best[4])) elif weak: VERDICT = ("LAYERED-WEAK (%s: corr %.3f, slope %.3f, weak " "subtraction max %.4f vs %.4f)" % (best[0], best[1], best[2], best[5], float(np.max(np.abs(res_all))))) else: VERDICT = ("LAYERING-REJECTED in the tested projections " "(best corr %.3f, %s); measured alternative: " "corr(res, von-Mangoldt defect a(n)) = %.3f, " "removing a(n) leaves max %.4f of %.4f" % (best[1], best[0], c_ar, float(np.max(np.abs(r_ar))), float(np.max(np.abs(res_all))))) check("G4.1 [M] preregistered classification: %s" % VERDICT, True) print("\nVERDICT: %s" % VERDICT) dt = time.time() - T0 if FAILS: print("RESULT: %d/%d checks passed -- FAILURES: %s (%.1f s)" % (N_CHK - len(FAILS), N_CHK, ", ".join(FAILS), dt)) return 1 print("RESULT: ALL %d CHECKS PASSED (%.1f s)" % (N_CHK, dt)) return 0 if __name__ == "__main__": raise SystemExit(run())