"""Check the standalone T659 Programs recipe; never writes to NumberDB.

Run with SageMath, program.py and skill-evidence.json beside this file:
    sage -python program-check.py table.json
Here table.json is GET /api/table?id=T659, authenticated for a private draft.
The campaign wrapper mounts table-before.json instead of forwarding arguments.
"""
import json, sys, hashlib, time
from pathlib import Path
from decimal import Decimal
import sage.version
import mpmath as mp
from sage.all import QQ, RealBallField
from program import jensen_roots
here=Path(__file__).parent
path=Path(sys.argv[1]) if len(sys.argv)>1 else here/'table-before.json'
doc=json.loads(path.read_text())
evidence={'table':'T659','skill_evidence':json.loads((here/'skill-evidence.json').read_text()),
          'program_sha256':hashlib.sha256((here/'program.py').read_bytes()).hexdigest(),
          'table_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),
          'versions':{'sage':sage.version.version,'python':sys.version.split()[0],'mpmath':mp.__version__},
          'method':'Arb analytic-series coefficient enclosures propagated through strict endpoint signs; every returned root ball must be contained in its stored decimal interval. No stored numbers are changed.'}
def rational_decimal(text):
    t=Decimal(str(text)).as_tuple()
    mant=int(''.join(str(x) for x in t.digits))*(-1 if t.sign else 1)
    return QQ(mant)*QQ(10)**t.exponent, QQ(10)**t.exponent
# Controls for the independent low-order derivative formula come first.
mp.mp.dps=170
assert mp.diff(lambda x:x**4,mp.mpf(2),2)==48
assert mp.diff(lambda x:x**4,mp.mpf(2),1)==32

def xi(z):
    s=mp.mpf('0.5')+z
    return s*(s-1)*mp.power(mp.pi,-s/2)*mp.gamma(s/2)*mp.zeta(s)/2

for d in (1,2):
    gamma=[mp.diff(xi,mp.mpf(0),2*j)*mp.factorial(j)/mp.factorial(2*j) for j in range(d+1)]
    if d==1:
        expected=[-gamma[0]/gamma[1]]
    else:
        delta=mp.sqrt(gamma[1]**2-gamma[0]*gamma[2])
        expected=[(-gamma[1]-delta)/gamma[2],(-gamma[1]+delta)/gamma[2]]
    for actual, target in zip(jensen_roots(d,0), expected):
        midpoint=mp.mpf(str(actual.mid()))
        assert abs((midpoint-target)/target)<mp.mpf('1e-140')
print('Independent low-order derivative and closed-form controls passed',flush=True)
count=0
min_bits=10000
start=time.monotonic()
for d_s, shifts in doc['Numbers'].items():
    d=int(d_s)
    for n_s, entries in shifts.items():
        n=int(n_s)
        roots=jensen_roots(d,n)
        assert len(entries)==d
        for k_s, text in entries.items():
            if isinstance(text,dict): text=text['number']
            midpoint,unit=rational_decimal(text)
            root=roots[int(k_s)-1]
            assert root.is_finite() and root.accuracy()>=440
            assert QQ(root.lower())>midpoint-unit and QQ(root.upper())<midpoint+unit
            min_bits=min(min_bits,int(root.accuracy()))
            count+=1
    print('Verified degree',d,'cumulative roots',count,flush=True)
# Demonstrate one calculation beyond each original generator cutoff.
extra=[]
for d,n in ((9,0),(1,21)):
    roots=jensen_roots(d,n)
    high=jensen_roots(d,n,1024)
    assert len(roots)==len(high)==d
    assert all(a.overlaps(b) and a.accuracy()>=440 and b.accuracy()>=500 for a,b in zip(roots,high))
    extra.append({'d':d,'n':n,'root_count':d,'minimum_accuracy_bits':min(int(a.accuracy()) for a in roots),'higher_precision_overlap':True})
evidence.update(all_stored_intervals_checked=count,all_passed=True,minimum_accuracy_bits=min_bits,
                low_order_independent_controls=3,extra_calculations=extra,elapsed_seconds=time.monotonic()-start)
assert count==756
print('EVIDENCE_JSON '+json.dumps(evidence,sort_keys=True),flush=True)
