"""Independent exact checks for Generalized Okamoto polynomials, T559.

Run: sage -python checks.py
Read and test the live draft: NUMBERDB_CHECK_STORED=1 sage -python checks.py
The draft read needs NUMBERDB_API_KEY, or NUMBERDB_KEY_FROM_STDIN=1 with
one token piped on stdin. No action in this file writes to the website.

The independent construction solves the polynomial differential equation
P''Q - 2P'Q' + PQ'' - 2x(P'Q - PQ') + 2(deg(P)-deg(Q))PQ = 0
coefficient by coefficient, with monic P. This is the Darboux eigenstate
identity for the harmonic oscillator (Clarkson 2009, Theorems 3.6 and 3.7,
equation (3.15)); it does not evaluate any Wronskian. Degree and leading term
make the coefficient system triangular. Known Hermite cases and deliberately
perturbed polynomials test the verifier. The source's equation (2.14) is not
used; the attached numerical evidence documents its indexing inconsistency.
"""
import json
import os
import re
import sys
from functools import lru_cache
from math import factorial

import numberdb.sage as numberdb
from sage.rings.rational_field import QQ
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
from sage.env import SAGE_VERSION

S = PolynomialRing(QQ, 'x')
z = S.gen()


def index_degree(m,n):
    r=m+n
    return sum(range(1,3*m,3)) + sum(range(2,3*n,3)) - r*(r-1)//2


def oscillator_residual(p,q):
    delta=p.degree()-q.degree()
    return (p.derivative(2)*q - 2*p.derivative()*q.derivative()
            + p*q.derivative(2) - 2*z*(p.derivative()*q-p*q.derivative())
            + 2*delta*p*q)


def extend(q,d):
    p=z**d
    for j in range(d-1,-1,-1):
        residual=oscillator_residual(p,q)
        coefficient=-residual[j+q.degree()]/QQ(2*(d-j))
        p += coefficient*z**j
    if oscillator_residual(p,q):
        raise ArithmeticError('no monic polynomial satisfies the Darboux equation')
    return p


@lru_cache(None)
def independent(m,n):
    if m==0 and n==0:
        return S.one()
    previous = independent(m,n-1) if n else independent(m-1,0)
    return extend(previous,index_degree(m,n))


def closed_monic_hermite(k):
    return sum((QQ((-1)**j*factorial(k))/QQ(4**j*factorial(j)*factorial(k-2*j)))
               *z**(k-2*j) for j in range(k//2+1))


def controls():
    assert extend(S.one(),0)==1
    assert extend(S.one(),1)==z
    assert extend(S.one(),2)==z*z-QQ(1)/2
    for k in range(26):
        assert extend(S.one(),k)==closed_monic_hermite(k)
    assert independent(1,1)==z*z+QQ(1)/2
    assert independent(2,0)==z**4-z*z-QQ(1)/4
    assert independent(2,1)==z**4+z*z-QQ(1)/4
    assert independent(1,2)==z**5-QQ(5)/4*z
    assert oscillator_residual(z*z+QQ(1)/2,S.one()) != 0
    # The positive-index case m=n=1 also refutes the printed (2.14a).
    p,q=independent(2,1),independent(1,1)
    printed=(p.derivative(2)*q-2*p.derivative()*q.derivative()+p*q.derivative(2)
             -2*z*(p.derivative()*q-p*q.derivative())+2*p*q)
    assert printed == -2*p*q and printed != 0
    print('Controls: H_0 through H_25; four small Okamoto cases; wrong-sign rejection; source (2.14a) counterexample.')


def inspect_values(values):
    controls()
    expected={(m,n) for m in range(20) for n in range(20)
              if index_degree(m,n)<=60}
    assert set(values)==expected
    ordered=sorted(expected,key=lambda p:(index_degree(*p),*p))
    assert list(values)==ordered
    count_m=count_n=0
    for (m,n),p in values.items():
        assert p == independent(m,n), ('independent coefficients',m,n)
        d=index_degree(m,n)
        assert p.degree()==d and p.leading_coefficient()==1
        assert p(-z)==(-1)**d*p
        # Use stored neighbors wherever present, independent ones outside range.
        next_m=values[(m+1,n)] if (m+1,n) in values else independent(m+1,n)
        next_n=values[(m,n+1)] if (m,n+1) in values else independent(m,n+1)
        assert oscillator_residual(next_m,p)==0, ('m direction',m,n)
        assert oscillator_residual(next_n,p)==0, ('n direction',m,n)
        count_m+=1
        count_n+=1
        # A changed coefficient must disagree with the independent reconstruction.
        assert p+1 != independent(m,n)
    print('Entries checked:',len(values))
    print('Independent coefficient comparisons, degree, monicity, parity: all passed.')
    print('Darboux equations:',count_m,'m-neighbor pairs;',count_n,'n-neighbor pairs.')
    print('Numerical precision: exact rational coefficients throughout; no rounding.')


def authenticate():
    if os.environ.get('NUMBERDB_KEY_FROM_STDIN')=='1':
        key=sys.stdin.read().strip()
        if re.match(r'^[A-Z_][A-Z0-9_]*\s*=',key):
            key=key.split('=',1)[1].strip().strip('\"\'')
        numberdb.configure(api_key=key)


if __name__=='__main__':
    authenticate()
    print('Sage',SAGE_VERSION,'numberdb',numberdb.__version__)
    if os.environ.get('NUMBERDB_CHECK_STORED')=='1' or '--stored' in sys.argv:
        doc=numberdb.table('T559')
        assert isinstance(doc['Numbers'],list)
        values={(int(row['params']['m']),int(row['params']['n'])):S(row['number'])
                for row in doc['Numbers']}
        print('Source: values read from T559 through the NumberDB API.')
    else:
        from generate import GeneralizedOkamoto
        gen=GeneralizedOkamoto()
        values={(p['m'],p['n']):S(gen.value(p,100)) for p in gen.enumerate()}
        print('Source: local generator.')
    inspect_values(values)
