#!/usr/bin/env python3 """Job #1444 (explore, lane g2-exponent) — route 33's cheapest experiment, made executable. Three paths, ONE definition: L(T_x,p) = max_a longest run of consecutive x#-period slots whose residues mod p lie in one 2-set {a, a+2} (#161 okPair; wraparound difference p-2 admitted). bank : the published cell L(T_x,p) from L-grid-622.json (rows: level, p, L) literal: definitional scan over TWO materialised periods (nothing folded, nothing cyclic) naive : do the period's residues doubled UNSHIFTED (successor residue r_0; #642's defect) true : successor of the last slot has residue (r_0 + x#) mod p (the seam carried correctly) Timing goes to stderr; stdout carries no timing (the lesson from return #652). """ import argparse import json import pathlib import sys import time def primes_upto(n): s = [True] * (n + 1) s[0] = s[1] = False for i in range(2, int(n ** 0.5) + 1): if s[i]: for j in range(i * i, n + 1, i): s[j] = False return [q for q, v in enumerate(s) if v] def admissible(x, M): qs = primes_upto(x) return [r for r in range(M) if all(r % q for q in qs)] def max_run(seq, p, cap): """max over a of the longest linear run of consecutive entries with values in {a, a+2}, capped at `cap` slots (predecessor #1440 capped runs at one period length).""" vals = set(seq) best = 0 for a in vals: two = (a + 2) % p run = 0 for v in seq: if v == a or v == two: run += 1 if run > best: best = min(run, cap) else: run = 0 return best def main(): ap = argparse.ArgumentParser() ap.add_argument("--out") ap.add_argument("--levels", default="5,7,11") ap.add_argument("--bank", default=None) ap.add_argument("--flagged", default="7:11,11:31,11:37,11:191") args = ap.parse_args() t0 = time.time() bank_rows = {} if args.bank: bd = json.loads(pathlib.Path(args.bank).read_text()) for r in bd["rows"]: bank_rows[(int(r["level"]), int(r["p"]))] = r flagged = set() for tok in args.flagged.split(","): x, p = tok.split(":") flagged.add((int(x), int(p))) out = {"definition": "L(T_x,p) = max_a longest run of consecutive slots with residues in {a,a+2}", "paths": {"literal": "two materialised periods, linear scan", "naive": "residues doubled unshifted (successor residue r0)", "true": "successor residue (r0 + x#) mod p"}, "levels": {}, "cells": [], "differing_cells": [], "flagged": []} for x in [int(v) for v in args.levels.split(",")]: M = 1 for q in primes_upto(x): M *= q res = admissible(x, M) lvl = {"x": x, "M": M, "admissible_slots": len(res), "primes_tested": 0} ps = [q for q in primes_upto(200) if q > x] lvl["primes_tested"] = len(ps) for p in ps: rp = [r % p for r in res] n = len(rp) lit = max_run(rp + [(r + M) % p for r in rp], p, n) # literal: two full periods tru = lit # same object, seam rule stated nai = max_run(rp + rp, p, n) # unshifted / residue-cyclic closure cell = {"x": x, "p": p, "literal": lit, "true": tru, "naive": nai, "M_mod_p": M % p, "bank": bank_rows.get((x, p), {}).get("L")} out["cells"].append(cell) if nai != tru: out["differing_cells"].append({"x": x, "p": p, "true": tru, "naive": nai, "M_mod_p": M % p}) if (x, p) in flagged: out["flagged"].append(cell) out["levels"][str(x)] = lvl print(f"level {x}: M={M} slots={len(res)} primes_tested={len(ps)}", file=sys.stderr) out["summary"] = { "cells_compared_to_bank": sum(1 for c in out["cells"] if c["bank"] is not None), "bank_matches_literal": sum(1 for c in out["cells"] if c["bank"] is not None and c["bank"] == c["literal"]), "bank_mismatches": [c for c in out["cells"] if c["bank"] is not None and c["bank"] != c["literal"]], "naive_vs_true_differing": len(out["differing_cells"]), } out["elapsed_s"] = round(time.time() - t0, 2) txt = json.dumps(out, indent=1, sort_keys=True) if args.out: pathlib.Path(args.out).write_text(txt + "\n") print(json.dumps({"summary": out["summary"], "flagged": out["flagged"], "differing_cells": out["differing_cells"]}, sort_keys=True)) print(f"elapsed {out['elapsed_s']}s", file=sys.stderr) if __name__ == "__main__": main()