#!/usr/bin/env python3 """job1911-checks.py -- exact checks for the mirror-fixed-phase correction to return #41. Definitions are taken verbatim from the served note `research/anchored-windows.md` (ยง1) / `research/natal-cap-19-calm-lemma.md`, which return #41 cites: W(x) = 30 * prod_{7 <= p <= x} p y(x) = largest prime <= sqrt(W) Q(x) = { q prime : x < q <= y } ("scour primes") N_x = { r in [0,W) : r mod 30 in {11,17} and r mod p not in {0,p-2} for every prime 7 <= p <= x } phase t: each q in Q strikes the residue classes { t mod q, (t-2) mod q } G(t,q) = #{ r in N_x : r mod q in { t mod q, (t-2) mod q } } dev(t,q) = G(t,q) - 2|N_x|/q mirror mu(r) = W - 2 - r (involution of [0,W)) Everything asserted here is exact integer arithmetic; no sampling, no floats except when ranking the census. Emits one JSON object. """ import json import math OUT = {} def primes_upto(n): if n < 2: return [] s = bytearray([1]) * (n + 1) s[0] = s[1] = 0 for i in range(2, int(n ** 0.5) + 1): if s[i]: s[i * i::i] = bytearray(len(range(i * i, n + 1, i))) return [i for i in range(n + 1) if s[i]] def build(x): W = 30 for p in primes_upto(x): if p >= 7: W *= p root = math.isqrt(W) y = max(p for p in primes_upto(root) if p <= root) Q = [q for q in primes_upto(y) if q > x] wheel = [p for p in primes_upto(x) if p >= 7] Nx = [r for r in range(W) if r % 30 in (11, 17) and all(r % p not in (0, p - 2) for p in wheel)] return W, root, y, Q, Nx def classes(t, q): return {t % q, (t - 2) % q} def counts_by_class(q, Nx): """cnt[a] = #{ r in N_x : r mod q == a }.""" cnt = [0] * q for r in Nx: cnt[r % q] += 1 return cnt def G_of(t, q, Nx, CNT=None): if CNT is None: CNT = counts_by_class(q, Nx) return CNT[t % q] + CNT[(t - 2) % q] def survivors(t, Q, Nx): """N_x elements not struck at phase t by any scour prime.""" return [r for r in Nx if all(r % q not in classes(t, q) for q in Q)] def fixed(t, W, Q): """True iff the unordered strike pair at t is invariant under t -> W-t.""" return all(classes(t, q) == classes(W - t, q) for q in Q) def vr_of(t, Q, N, CNT, cache): if t in cache: return cache[t] num = 0.0 den = 0.0 scale = 2.0 * N for q in Q: d = G_of(t, q, None, CNT[q]) - scale / q num += d * d den += (scale / q) * (1.0 - 2.0 / q) val = num / den cache[t] = val return val # ---------------------------------------------------------------- per level for x in (11, 13): W, root, y, Q, Nx = build(x) N = len(Nx) assert N == 2 * math.prod(p - 2 for p in primes_upto(x) if p >= 7), (x, N) lvl = {"x": x, "W": W, "y": y, "n_scour": len(Q), "scour_first_last": [Q[0], Q[-1]], "N": N, "W_over_2": W // 2, "W_even": W % 2 == 0} # 1. mirror closes N_x exactly lvl["mirror_closes_comb"] = all(0 <= W - 2 - r < W for r in Nx) and \ sorted(W - 2 - r for r in Nx) == sorted(Nx) # 2. mirror covariance of the class counts, exact, over the enumerated window CNT = {q: counts_by_class(q, Nx) for q in Q} bad = 0 for t in range(1, W): for q in Q: if G_of(W - t, q, None, CNT[q]) != G_of(t, q, None, CNT[q]): bad += 1 lvl["mirror_covariance_G_exact_failures"] = bad lvl["mirror_covariance_checked_t"] = W - 1 # 3. the anchor's mirror partner t=W (outside the enumerated window [0,W)) lvl["G_at_W_equals_G_at_0"] = all(G_of(W, q, None, CNT[q]) == G_of(0, q, None, CNT[q]) for q in Q) lvl["S_at_W_equals_S_at_0"] = len(survivors(W, Q, Nx)) == len(survivors(0, Q, Nx)) # 4. which phases are mirror-FIXED (phase vector invariant, not just the count) lvl["fixed_t0"] = fixed(0, W, Q) lvl["fixed_tW_over_2"] = fixed(W // 2, W, Q) lvl["fixed_t0_failing_primes"] = [q for q in Q if classes(0, q) != classes(W, q)] lvl["fixed_W_over_2_failing_primes"] = [q for q in Q if classes(W // 2, q) != classes(W - W // 2, q)] # 5. the ensemble is not W-periodic as a phase family lvl["S_3"] = len(survivors(3, Q, Nx)) lvl["S_W_plus_3"] = len(survivors(W + 3, Q, Nx)) lvl["periodic"] = lvl["S_3"] == lvl["S_W_plus_3"] lvl["S_0"] = len(survivors(0, Q, Nx)) lvl["S_W_over_2"] = len(survivors(W // 2, Q, Nx)) lvl["G_W_over_2_all_even"] = all(G_of(W // 2, q, None, CNT[q]) % 2 == 0 for q in Q) # 6. exact census of the variance ratio on the enumerated window and one phase beyond if x == 11: cache = {} census = {t: vr_of(t, Q, N, CNT, cache) for t in list(range(0, W)) + [W]} order = sorted(census.values()) lvl["census_phases"] = len(census) rank = {} for t in (0, W // 2, W): v = census[t] rank[str(t)] = {"vr": round(v, 9), "rank": 1 + sum(1 for u in order if u < v), "of": len(order), "percentile": round(100.0 * (sum(1 for u in order if u < v) + 0.5) / len(order), 3)} lvl["rank_vr"] = rank lvl["vr0_equals_vrW"] = census[0] == census[W] lvl["max_vr_phase"] = max(census, key=lambda t: census[t]) lvl["calm_rank_0_le_W_over_2"] = rank["0"]["rank"] < rank[str(W // 2)]["rank"] OUT["x%d" % x] = lvl # 7. the reviewer's own counterexample, recomputed from the definitions W, root, y, Q, Nx = build(11) q = 13 r1, r2 = 167, 2141 OUT["counterexample_x11_q13"] = { "W": W, "q": q, "y": y, "167_in_comb": r1 in Nx, "2141_in_comb": r2 in Nx, "2141_is_mirror_of_167": (W - 2 - r1) == r2, "167_struck_at_0": r1 % q in classes(0, q), "2141_struck_at_0": r2 % q in classes(0, q), "pair_at_0": sorted(classes(0, q)), "mirror_pair_at_0": sorted(classes(W, q)), "pair_at_W_over_2": sorted(classes(W // 2, q)), "invariant_at_W_over_2": classes(W // 2, q) == classes(W - W // 2, q), "13_divides_W": W % q == 0, } OUT["all_pass"] = all( v.get("mirror_closes_comb") and v["mirror_covariance_G_exact_failures"] == 0 and v["G_at_W_equals_G_at_0"] and v["S_at_W_equals_S_at_0"] and v["fixed_t0"] is False and v["fixed_tW_over_2"] is True and v["periodic"] is False and v["G_W_over_2_all_even"] for k, v in OUT.items() if k.startswith("x") ) and OUT["counterexample_x11_q13"]["167_struck_at_0"] \ and not OUT["counterexample_x11_q13"]["2141_struck_at_0"] \ and OUT["counterexample_x11_q13"]["invariant_at_W_over_2"] is True print(json.dumps(OUT, indent=1, sort_keys=True))