"""T731 build checks, not an independent critic's verdict.

Run with production.json and pf-results.json beside this file; to check a live
readback, supply stored-rows.json instead of production.json using INPUT_JSON.
Sage/Arb checks the stored rectangles and a finite eta product with analytic
tail bounds. Independent mpmath PF checkpoints were computed by run_pf.py.
"""
import os,json,math
from pathlib import Path
from fractions import Fraction
from decimal import Decimal
import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.complex_arb import ComplexBallField
from sage.rings.real_arb import RealBallField
import mpmath as mp

C=ComplexBallField(640);R=RealBallField(640);mp.mp.dps=185


def rational(s):
    s=s.strip()
    return Fraction(s) if '/' in s else Fraction(Decimal(s))


def interval(s):
    s=s.strip()
    if s.startswith('['):
        lo,hi=s[1:-1].split(',');return rational(lo),rational(hi)
    v=rational(s)
    if '.' not in s and 'e' not in s.lower():return v,v
    d=Decimal(s);ulp=Fraction(Decimal(1).scaleb(d.as_tuple().exponent))
    return v-ulp,v+ulp


def parts(text):
    s=text.strip()
    if ' + i * ' in s:r,i=s.split(' + i * ',1)
    elif ' - i * ' in s:
        r,i=s.split(' - i * ',1);a,b=interval(i);return interval(r),(-b,-a)
    elif s.startswith('i * '):r,i='0',s[4:]
    elif ' + i*' in s:r,i=s.split(' + i*',1)
    else:raise ValueError('unexpected complex encoding')
    return interval(r),interval(i)


def rb(bounds):
    a,b=bounds
    if a>b:raise ValueError('reversed interval')
    return R(QQ((a+b).numerator)/QQ((a+b).denominator)/2).add_error(R(QQ((b-a).numerator)/QQ((b-a).denominator)/2))


def ball(text):
    a,b=parts(text);return C(rb(a),rb(b))


def mfrac(a):return mp.mpf(a.numerator)/a.denominator


def acceptable(text,expected,guard=mp.mpf('1e-125')):
    if not mp.isfinite(expected):return False
    try:coordinates=parts(text)
    except Exception:return False
    for (lo,hi),value in zip(coordinates,[expected.real,expected.imag]):
        if lo>hi or hi-lo>Fraction(1,10**98)*max(abs(lo),abs(hi),1):return False
        if not mfrac(lo)-guard<=value<=mfrac(hi)+guard:return False
    return True


def lift_ok(t,tau):
    if not all(x.is_finite() for x in [tau.real(),tau.imag()]):return False
    if not tau.imag()>0:return False
    if t==0:return tau.real().contains_exact(QQ(1)/2) and tau.imag().contains_exact(QQ(1)/2) and R(abs(tau-C(QQ(1)/2,QQ(1)/2)).upper())<R(10)**-95
    if t>1:return tau.real().is_zero() and tau.imag()>1/R(2).sqrt()
    return tau.real()>0 and tau.real()<QQ(1)/2 and (abs(tau)**2).contains_exact(QQ(1)/2)


def rho(tau,N=180):
    q=(2*C.pi()*C(0,1)*tau).exp();r=abs(q)
    if not r<1:raise ArithmeticError('eta product requires |q|<1')
    x=q;sm=C(0);qn=q
    for n in range(1,N+1):
        x*=(1+qn)**24
        sm+=n*qn/(1+qn)
        qn*=q
    E=24*r**(N+1)/((1-r)*(1-r**(N+1)))
    x=x.add_error(abs(x)*(E.exp()-1))
    tail=24*r**(N+1)*(N+1-N*r)/((1-r)**2*(1-r**(N+1)))
    dlog=(1+24*sm).add_error(tail)
    den=1+64*x
    if den.contains_zero():raise ArithmeticError('eta denominator not separated')
    value=256*x/den**2
    deriv=256*(2*C.pi()*C(0,1)*x*dlog)*(1-64*x)/den**3
    if not all(a.is_finite() for a in [value.real(),value.imag()]):raise ArithmeticError('nonfinite eta image')
    return value,deriv,E


def main():
    w=Path(__file__).parent
    data=json.load(open(w/os.environ.get('INPUT_JSON','production.json')))
    pf=json.load(open(w/'pf-results.json'))
    failures=[];rows=[];low=pf['145'];high=pf['180']
    for row in data['rows']:
        identity=row['t'];t=QQ(identity);text=row['number'];v=ball(text)
        p=mp.mpc(*high[identity]);p_low=mp.mpc(*low[identity]);agreement=abs(p-p_low)
        ok=acceptable(text,p) and agreement<mp.mpf('1e-130') and lift_ok(t,v)
        result={'t':identity,'stored_interval_pf_contains':bool(acceptable(text,p)),
                'pf_precision_difference':mp.nstr(agreement,12),'lift_ok':bool(lift_ok(t,v))}
        if t:
            image,deriv,tail=rho(v);z=C(t**-4)
            etaok=image.real().contains_exact(t**-4) and image.imag().contains_zero()
            cond=abs(deriv).lower();condok=cond>0
            result.update({'rho_contains_exact_z':bool(etaok),'rho_real_radius':str(image.real().rad()),
                           'rho_imag_radius':str(image.imag().rad()),'rho_derivative_abs_lower':str(cond),
                           'eta_log_tail_bound':str(tail.upper())})
            ok=ok and etaok and condok
        if not ok:failures.append(identity)
        rows.append(result)
    origin=acceptable('[1/2, 1/2] + i * [1/2, 1/2]',mp.mpc(mp.mpf(1)/2,mp.mpf(1)/2))
    cm,_,_=rho(C(QQ(1)/2,QQ(3)/2))
    cmok=cm.real().contains_exact(-QQ(1)/48) and cm.imag().contains_zero()
    lam=2*R(2).sqrt()-2
    limit=C(0,1)*(1-C(lam)).elliptic_k()/C(lam).elliptic_k()
    limitok=(limit-C(0,1)/R(2).sqrt()).real().contains_zero() and (limit-C(0,1)/R(2).sqrt()).imag().contains_zero()
    neg={}
    byid={r['t']:r for r in data['rows']}
    for identity in ['5/6','6/5','1/6','6']:
        p=mp.mpc(*high[identity]);text=byid[identity]['number'];v=ball(text);t=QQ(identity)
        neg[identity]={
            'swapped_K_rejected':not acceptable(text,-1/p),
            'missing_256_rejected':not acceptable(text,p+mp.log(256)/(2*mp.pi*1j)),
            'lower_bank_rejected': not acceptable(text,-p.conjugate()) if t<1 else True,
            'integer_shift_rejected':not acceptable(text,p+1) and not lift_ok(t,v+1)}
        shifted,_,_=rho(v+1)
        neg[identity]['integer_shift_still_has_same_modular_image']=bool(shifted.real().contains_exact(t**-4) and shifted.imag().contains_zero())
    neg['nan_rejected']=not acceptable(byid['6']['number'],mp.mpc(mp.nan))
    neg['vacuous_rejected']=not acceptable('[-100,100] + i * [-100,100]',mp.mpc(*high['6']))
    # A modulus/parameter error is tested from the actual algebraic pullback,
    # independently of production compute(): quartic lambda root at t=2.
    z=C(QQ(1)/16);u=((1-(1-z).sqrt())/2).sqrt();l=2*u/(1+u)
    wrong=C(0,1)*(1-l*l).elliptic_k()/(l*l).elliptic_k()
    neg['squared_parameter_rejected']=not wrong.overlaps(ball(byid['2']['number']))
    controls=origin and cmok and limitok
    negative=all(all(v.values()) if isinstance(v,dict) else v for v in neg.values())
    if not controls:failures.append('known-answer-control')
    if not negative:failures.append('negative-control')
    output={'checked_entries':len(rows),'total_entries':23,'failures':failures,
            'known_answer_control':bool(controls),'negative_control_rejected':bool(negative),
            'known_controls':{'origin':bool(origin),'rho_CM_minus_one_over_48':bool(cmok),'singular_limit':bool(limitok)},
            'negative_controls':neg,'rows':rows,
            'limitations':'PF checks are numerical at 145/180 dps. Eta and production share Arb arithmetic; PF does not. This build evidence is not an independent scientific-review verdict.',
            'skill_manifest':'../20261117T024513Z-build-skills/manifest.json'}
    print('CHECK_RESULT_JSON:'+json.dumps(output),flush=True)
    assert not failures, failures

if __name__=='__main__':main()
