# Route 31 triage check (job #1405): the right factor C_{B,B}(m) with equal cutoffs collapses to a # function of m's B-smooth part s (plus Lambda(m) and log m). Brute force over m in a window, for # several B, against the derived formula; then the sign distribution of the true factor versus a # Mobius-randomized control (independent random signs per squarefree d, as in prereg-1403.md s3). # Deterministic: seed 1405. stdout is the artifact. import sys, math, json, random M = int(sys.argv[1]) if len(sys.argv) > 1 else 60000 LAMBDA = [0.0]*(M+1); SPF = [0]*(M+1) for p in range(2, M+1): if SPF[p] == 0: for q in range(p, M+1, p): if SPF[q] == 0: SPF[q] = p r = p while r <= M: LAMBDA[r] = math.log(p); r *= p def factor(m): f = {} while m > 1: p = SPF[m]; f[p] = f.get(p, 0) + 1; m //= p return f def divisors(f): ds = [1] for p, a in f.items(): ds = [d * p**j for d in ds for j in range(a+1)] return ds def mu(d, f): return 0 if any(a > 1 for p, a in f.items()) else (-1)**len(f) def beta(t, B): # sum_{r | t, r > B} Lambda(r) (the Lambda-sieve form used by #636's gate G3) return sum(LAMBDA[r] for r in divisors(factor(t)) if r > B) def C(m, B, musign): # sum_{d | m, d > B} mu(d) beta_B(m/d) f = factor(m); s = 0.0 for d in divisors(f): if d > B: fd = factor(d); md = mu(d, fd) if md: s += musign(d, md) * beta(m // d, B) return s def smooth_part(m, B): s = 1 for p, a in factor(m).items(): if p <= B: s *= p**a return s def M_B(u, B): # sum_{d | u, d <= B} mu(d) return sum(mu(d, factor(d)) for d in divisors(factor(u)) if d <= B) def predicted(m, B): # derived: Lambda(m) - M_B(s) log m + sum_{1 0: v += LAMBDA[r] * M_B(s // r, B) return v random.seed(1405) rnd = {} def musign_random(d, md): if d not in rnd: rnd[d] = random.choice((-1, 1)) return rnd[d] out = {"M_window": [M//2 + 1, M], "B": {}} for B in (1, 2, 3, 4, 5, 7, 10, 14, 27): lo, hi = M//2 + 1, M mism = 0; pos = neg = zero = 0; cpos = cneg = czero = 0; signs_by_s = {} for m in range(lo, hi + 1): t = C(m, B, lambda d, md: md); p = predicted(m, B) if abs(t - p) > 1e-9: mism += 1 sg = (t > 1e-12) - (t < -1e-12) pos += sg > 0; neg += sg < 0; zero += sg == 0 s = smooth_part(m, B) if LAMBDA[m] == 0: # composite non-prime-power: sign should depend on s only signs_by_s.setdefault(s, set()).add(sg) tc = C(m, B, musign_random) cpos += tc > 1e-12; cneg += tc < -1e-12; czero += abs(tc) <= 1e-12 n = hi - lo + 1 multi = sorted(s for s, v in signs_by_s.items() if len(v) > 1) out["B"][B] = {"formula_mismatches": mism, "true": {"pos": pos, "neg": neg, "zero": zero, "n": n}, "control": {"pos": cpos, "neg": cneg, "zero": czero}, "smooth_parts_with_more_than_one_sign_among_composites": multi[:20], "positive_smooth_parts": sorted(s for s, v in signs_by_s.items() if v == {1})[:20]} print(json.dumps(out, indent=1))