#!/usr/bin/env python3
"""Independent mathematical checks for the OMEGA handoff.
Python 3.11+; standard library only. No files are written.
Run: python verify_handoff.py
Also run: python -O verify_handoff.py
This does not audit the separately reported Grok 0.2 files.
"""
from collections import Counter
from fractions import Fraction as F
from math import gcd, isqrt

Q, S = 339949771344778, 10**15
A, DMAX, DSTAR = 3*Q-S, 32767, 42189065
P = Q // gcd(Q, S)


def require(ok, label):
    if not ok:
        raise ValueError(label)


def T(d):
    return Q*d // S


def L(n):
    return (S*n+Q-1) // Q


def size(n):
    return L(n+1)-L(n)


def law(n):
    r = n*S % Q
    return 2 if 0 < r <= A else 3


def nk(k):
    return (k*Q+A-1)//A-1


def orbit(d):
    states, residues = [d], []
    while d:
        nxt, rho = divmod(Q*d, S)
        require(nxt < d, 'strict descent')
        states.append(nxt)
        residues.append(rho)
        d = nxt
    return states, residues


def floor_sum(n, m, a, b):
    total = 0
    while True:
        qa, a = divmod(a, m)
        qb, b = divmod(b, m)
        total += qa*n*(n-1)//2 + qb*n
        k, r = divmod(a*n+b, m)
        if k == 0:
            return total
        n, m, a, b = k, a, m, r


def atan_bounds(b):
    lower = sum((F((-1)**j, (2*j+1)*b**(2*j+1))
                 for j in range(64)), F(0))
    return lower, lower+F(1, 129*b**129)


def main():
    require(gcd(Q,S)==2 and 2*Q<S<3*Q, 'parameters')
    require(A==19849314034334, 'threshold')
    require(P==169974885672389, 'period')
    for n in range(100000):
        direct = ((n+1)*S-1)//Q-L(n)+1
        mechanical = 3-((n+1)*A//Q-n*A//Q)
        require(direct==size(n)==law(n)==mechanical,
                'fiber laws')
    for n in (0,P-2,P-1,P,P+1,2*P-1):
        require(size(n)==law(n), 'period boundary')
    require(size(P-1)==2 and size(P)==3, 'equality cases')
    require(nk(A//2)==P-1, 'Beatty integral boundary')
    actual = [n for n in range(1,50001) if size(n)==2]
    expected = [nk(k) for k in range(1,len(actual)+1)]
    require(actual==expected, 'Beatty sample')
    print('PASS fiber laws on 100000 bases and rational boundaries')
    print('PASS Beatty enumeration through base 50000')

    buckets = [[] for _ in range(DMAX+1)]
    depths = [0]*(DMAX+1)
    for d in range(DMAX+1):
        buckets[T(d)].append(d)
        if d:
            depths[d] = 1+depths[T(d)]
        states, residues = orbit(d)
        recovered = states[-1]
        for rho in reversed(residues):
            require(0<=rho<S, 'remainder bounds')
            recovered, residual = divmod(S*recovered+rho,Q)
            require(residual==0, 'reverse divisibility')
        require(recovered==d, 'ledger round trip')
    image = T(DMAX)+1
    for n in range(image):
        require(buckets[n]==list(range(L(n),
                min(L(n+1),DMAX+1))), 'restricted fibers')
    hist = Counter(len(b) for b in buckets if b)
    require(dict(hist)=={3:10489,2:650,1:1}, 'fiber counts')
    expected_depths = [1,2,6,18,53,156,459,1350,
                       3971,11681,15071]
    require([depths.count(k) for k in range(11)]
            ==expected_depths, 'depth histogram')
    require(sum(depths)==300871, 'depth sum')
    branch = Counter(tuple(len(buckets[d]) for d in b)
                     for b in buckets[:image])
    expected_branch = {
        (0,0,0):6923, (3,3,3):2938, (0,0):429,
        (3,2,3):213, (3,3,2):208, (2,3,3):206,
        (3,3):198, (2,3):12, (3,2):11,
        (3,3,1):1, (0,):1,
    }
    require(branch==expected_branch, 'branch signatures')
    require(sum(branch.values())==11140, 'branch coverage')
    print('PASS 32768 seeds and minimal ordered ledger round trips')
    print('PASS complete fiber depth and branch histograms')

    B = [0]
    for k in range(17):
        B.append((S*(B[-1]+1)-1)//Q)
    require([B[i] for i in (9,10,16,17)]
            ==[17696,52057,33728823,99217081], 'thresholds')
    for k in range(1,5):
        for n in range(30):
            lo, end = n,n+1
            for _ in range(k):
                lo,end = L(lo),L(end)
            for d in (lo-1,lo,end-1,end):
                if d<0:
                    continue
                x=d
                for _ in range(k):
                    x=T(x)
                require((x==n)==(lo<=d<end),
                        'iterated fiber boundary')
    print('PASS threshold values and 120 iterated fiber intervals')

    cover, block_images, hard = [], [], []
    for b in range(32):
        lo,hi = 1024*b,1024*b+1023
        cover.extend(range(lo,hi+1))
        distinct = len({T(d) for d in range(lo,hi+1)})
        require(distinct==T(hi)-T(lo)+1, 'block image formula')
        block_images.append(distinct)
        hard.append(sum(depths[d]==10 for d in range(lo,hi+1)))
    require(cover==list(range(DMAX+1)), 'disjoint exact cover')
    require(Counter(block_images)=={348:9,349:23}, 'block sizes')
    require(sum(block_images)==11159, 'image multiplicity')
    require(hard[:17]==[0]*17 and hard[17]==735
            and hard[18:]==[1024]*14, 'hard cover')
    require(orbit(399)[0]==[399,135,45,15,5,1,0], '399')
    require(len(orbit(DSTAR)[1])==17, 'dstar depth')
    require(list(range(L(T(DSTAR)),L(T(DSTAR)+1)))
            ==[42189063,42189064,42189065], 'dstar triple')
    require(list(range(L(T(DSTAR)+1),L(T(DSTAR)+2)))
            ==[42189066,42189067], 'next pair')
    require((2**63-1)//Q+1==27132, 'Int64 boundary')
    print('PASS 32 block cover and first disagreement cell geometry')

    scale = 10**80
    root = isqrt(5*scale*scale)
    require(root*root<5*scale*scale<(root+1)**2, 'sqrt bounds')
    phi_lo=(1+F(root,scale))/2
    phi_hi=(1+F(root+1,scale))/2
    a0,a1=atan_bounds(5)
    b0,b1=atan_bounds(239)
    pi_lo,pi_hi=16*a0-4*b1,16*a1-4*b0
    lam_lo=phi_lo/(phi_lo+pi_hi)
    lam_hi=phi_hi/(phi_hi+pi_lo)
    M=10**30
    low=339949771344778929576702809321
    high=low+1
    require(F(Q,S)<F(low,M)<lam_lo<lam_hi<F(high,M),
            'real parameter enclosure')
    total=floor_sum(DSTAR,S,Q,0)
    require(total==floor_sum(DSTAR,M,high,0)
            ==302541195258184, 'common floor sum')
    require(low*DSTAR//M==high*DSTAR//M==14342163,
            'real floor at dstar')
    require(T(DSTAR)==14342162, 'rational floor at dstar')
    d=DSTAR+1
    require(low*d//M==high*d//M==T(d)==14342163,
            'agreement resumes')
    print('PASS separate real versus rational first disagreement proof')
    print('RESULT PASS')
    print('SCOPE mathematical replay only not Grok release authentication')


if __name__=='__main__':
    try:
        main()
    except Exception as exc:
        raise SystemExit('FAIL: '+str(exc))