"""PREDICTIVE INDEX SCALING PROBE - instrument (2026-07-23), walking
the open two-sided proof burden left by THE PREDICTIVE INDEX bridge
(THE_FOURTH_JAM.md): "Q has infinite predictive index" is WISHED,
with the exact obligation "construct one finite quotient, or exhibit
infinitely many pairwise future-distinguishable prefixes."

This probe does neither outright - it asks a smaller, honest question
first: as a generic finite descriptor's window (L, M) grows, does the
FIRST one-step-Markov collision on Q's single realized trajectory keep
getting pushed later, with no plateau? A plateau (collisions saturate
at some window size and recur no further out, however far we look)
would be evidence AGAINST infinite index. Unbounded pushback across
several window sizes is CONSISTENT WITH (never proof of) an infinite
family of pairwise future-distinguishable prefixes - the second proof
obligation, attacked empirically rather than closed.

Descriptor: state(n; L, M) = (n mod M, Q(n-L+1..n) mod M) - a plain
generic window, deliberately simpler than the jam's phase-tuned
descriptors (which were purpose-built for the exact-power region and
already killed). Two positions n1 < n2 sharing a state but disagreeing
on Q(n+1) is an exact one-step collision witness: the descriptor is
refuted, honestly, the same way LINE 4's collisions were built.

Bonus (precedent: THE UNLIT MATCH checked Q's totality as a free
byproduct): every Q(n) computed is asserted positive and defined, so
this run also extends the totality witness past its prior bound of
1600."""

N_MAX = 2_000_000
WINDOWS = [(6, 54), (8, 108), (10, 162), (12, 324), (14, 486)]


def build_q(n_max: int):
    Q = [0] * (n_max + 1)
    Q[1] = 1
    if n_max >= 2:
        Q[2] = 1
    for n in range(3, n_max + 1):
        a = n - Q[n - 1]
        b = n - Q[n - 2]
        assert 1 <= a < n and 1 <= b < n, ("Q UNDEFINED (totality fails) at n=%d" % n)
        Q[n] = Q[a] + Q[b]
        assert Q[n] > 0, ("Q NONPOSITIVE at n=%d" % n)
    return Q


def probe(Q, n_max: int, L: int, M: int):
    seen = {}
    for n in range(L, n_max):
        key = (n % M,) + tuple(Q[n - L + 1: n + 1][i] % M for i in range(L))
        nxt = Q[n + 1]
        if key in seen:
            prev_n, prev_nxt = seen[key]
            if prev_nxt != nxt:
                return ("COLLISION", n, prev_n, prev_nxt, nxt)
        else:
            seen[key] = (n, nxt)
    return ("SURVIVED", n_max, None, None, None)


def main():
    print("building Q(1..%d) ..." % N_MAX)
    Q = build_q(N_MAX)
    print("Q TOTALITY WITNESS: every value positive and defined through n=%d"
          " (prior recorded bound: 1600)" % N_MAX)
    print("\n L |   M | verdict    | first-collision n | witness")
    for L, M in WINDOWS:
        verdict, n, pn, pnxt, nxt = probe(Q, N_MAX, L, M)
        if verdict == "COLLISION":
            print(" %2d | %3d | COLLISION  | n=%-15d | (n1=%d,next=%d) vs (n2=%d,next=%d)"
                  % (L, M, n, pn, pnxt, n, nxt))
        else:
            print(" %2d | %3d | SURVIVED   | past N_MAX=%-9d| no collision found through this horizon"
                  % (L, M, N_MAX))
    print("\nHonest reading: SURVIVED means only 'no collision through N_MAX' -")
    print("never proof the descriptor is a true predictive quotient. A ladder of")
    print("SURVIVED verdicts at growing (L,M), with earlier smaller windows already")
    print("dead (mod-54 L=6 killed exactly in THE_FOURTH_JAM), is consistent with -")
    print("not a proof of - Q's infinite predictive index.")


if __name__ == "__main__":
    main()