"""Independent checks for logarithmic Mahler measures of P_d.

Run with SageMath and numberdb: sage -python checks.py entries.json
The input maps each degree string to its NumberDB decimal interval text.
The default uses Hurwitz zeta and cotangents, never polylogarithms or the
production generator. This derives from the absolutely convergent Clausen
Fourier series and its finite sine transform. It shares Arb arithmetic and
the published finite-sum theorem with the production computation.
Additional low-degree definition check: double-precision polynomial roots
and adaptive quadrature of Jensen's formula (NumPy/SciPy). This is heuristic,
not a 100-digit certification. All bounds and negative controls are checked.
"""
import json
import sys
from functools import lru_cache
from fractions import Fraction
from decimal import Decimal
import numberdb.sage as numberdb
from numberdb._write import to_text
from sage.rings.rational_field import QQ
from sage.rings.real_arb import RealBallField
from sage.rings.complex_arb import ComplexBallField
R = RealBallField(640)
C = ComplexBallField(640)

def rational_decimal(s):
    f = Fraction(Decimal(s))
    return QQ(f.numerator)/f.denominator

def decimal_bounds(s):
    dec = Decimal(s)
    q = rational_decimal(s)
    exponent = dec.as_tuple().exponent
    ulp = QQ(10)**exponent
    return q-ulp, q+ulp

def narrow(b):
    return b.is_finite() and R(b.rad()) < R(10)**(-140)

def contains(s, b):
    lo,hi=decimal_bounds(s)
    return narrow(b) and bool(b>lo) and bool(b<hi)

@lru_cache(maxsize=None)
def H(r):
    terms=[]
    for a in range(1,r):
        if 2*a==r:continue
        q=QQ(a)/r
        terms.append((R.pi()*q).cot()*C(2).zeta(C(q)).real())
    return sum(terms,R(0))

def independent(d):
    return 3*(H(d+2)-H(d+1))/(2*R.pi()*(d+1)*(d+2))

def L2(q, values):
    return sum((C(values[a])*C(2).zeta(C(QQ(a)/q)) for a in range(1,q)),C(0))/(q*q)

def jensen_check(d):
    import numpy as np
    from scipy.integrate import quad
    from math import pi,log
    def f(u):
        x=np.exp(2j*pi*u)
        coeff=[sum(x**i for i in range(d-j+1)) for j in range(d+1)]
        roots=np.polynomial.polynomial.polyroots(coeff)
        return sum(log(abs(z)) for z in roots if abs(z)>1)
    breaks=sorted({0.0,0.5}|{k/r for r in [d+1,d+2] for k in range(1,r) if 2*k<=r})
    intervals=[quad(f,a,b,epsabs=2e-12,epsrel=2e-12,limit=150) for a,b in zip(breaks,breaks[1:])]
    value=2*sum(v for v,e in intervals)
    err=2*sum(e for v,e in intervals)
    target=float(independent(d).mid())
    return {'d':d,'value':value,'estimated_quadrature_error':err,'absolute_error':abs(value-target),'breaks':breaks,'pass':abs(value-target)<2e-9}

def check(entries, with_jensen=True):
    assert list(entries)==[str(d) for d in range(1,101)]
    failures=[];rows=[]
    for d in range(1,101):
        b=independent(d);passed=contains(entries[str(d)],b)
        if not passed:failures.append('stored interval '+str(d))
        rows.append({'d':d,'stored':entries[str(d)],'independent_130_digits':to_text(b,digits=130),'accuracy_bits':int(b.accuracy()),'inside_stored_interval':passed})
    # Known nonzero arithmetic controls independent of both finite r sums.
    L3=L2(3,[0,1,-1]).real();G=L2(4,[0,1,0,-1]).real()
    m1=3*R(3).sqrt()*L3/(4*R.pi());m2=2*G/R.pi()-m1/2
    known=contains(entries['1'],m1) and contains(entries['2'],m2) and bool(m1>0) and bool(m2>0)
    # Nonreal Conrey character chi_5(2,.): chi(2)=i.
    chi=[C(0),C(1),C(0,1),C(0,-1),C(-1)]
    tau=sum((chi[a]*(C(0,1)*R.pi()*(QQ(2*a)/5)).exp() for a in range(1,5)),C(0))
    derivative=-C(0,1)*5*tau*L2(5,[z.conjugate() for z in chi])/(4*R.pi())
    m3=((C(9,-3)/10)*derivative).real()-QQ(3)/5*(2*G/R.pi())
    nonreal=contains(entries['3'],m3)
    relation=15*independent(4)+10*independent(3)+6*independent(2)-45*independent(1)
    relation_ok=narrow(relation) and relation.contains_zero()
    # S_r=3 H_r/r: swap the two outside denominators, a common transcription error.
    wrong_swapped=(3*H(3)/3/3-3*H(2)/2/2)/(2*R.pi())
    wrong_sign=-independent(1)
    wide=R(0).add_error(1000);nan=R('nan')
    negative=(not contains(entries['1'],wrong_swapped) and not contains(entries['1'],wrong_sign)
              and not contains(entries['1'],wide) and not contains(entries['1'],nan)
              and not contains(entries['3'],((C(9,-3)/10)*derivative.conjugate()).real()-QQ(3)/5*(2*G/R.pi())))
    # Independently test the finite sine transform at every nonzero residue for small orders.
    sine=[]
    for r in range(2,13):
        for a in range(1,r):
            lhs=sum(((r-2*k)*(2*R.pi()*QQ(a*k)/r).sin() for k in range(1,r)),R(0))
            rhs=R(0) if 2*a==r else r*(R.pi()*QQ(a)/r).cot()
            diff=lhs-rhs
            sine.append(diff.is_finite() and R(diff.rad())<R(10)**(-170) and diff.contains_zero())
    jensen=[jensen_check(d) for d in [1,2,3,4,6]] if with_jensen else []
    for name,passed in [('known-answer',known),('nonreal-character',nonreal),('published-relation',relation_ok),('negative-controls',negative),('sine-transform',all(sine))]:
        if not passed:failures.append(name)
    if any(not x['pass'] for x in jensen):failures.append('Jensen definition check')
    return {'checked_entries':100,'total_entries':100,'failures':failures,'known_answer_control':bool(known),'negative_control_rejected':bool(negative),'nonreal_character_control':bool(nonreal),'published_relation_control':bool(relation_ok),'finite_sine_transform_checks':len(sine),'finite_sine_transform_pass':bool(all(sine)),'minimum_independent_accuracy_bits':min(x['accuracy_bits'] for x in rows),'jensen_definition_checks':jensen,'rows':rows,'independence':'Hurwitz-zeta finite Fourier regrouping; shared Arb arithmetic and published finite-sum theorem; Jensen bypasses that theorem at double precision.'}

if __name__=='__main__':
    result=check(json.load(open(sys.argv[1])))
    print(json.dumps(result,indent=2))
    sys.exit(bool(result['failures']))
