"""Independent SymPy verification of authored mathematical statements.

Only reads repository-generated fixtures, never student submissions. Conceptual
items are reported separately rather than counted as symbolic verification.
"""
import json, re, sys
from pathlib import Path
import sympy as S
from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application

x,y,t=S.symbols('x y t',real=True)
def expr(s):
    s=s.strip().rstrip('.').replace('−','-').replace('·','*').replace('×','*').replace('²','^2').replace('³','^3').replace('⁴','^4').replace('^','**')
    s=re.sub(r'√(\d+)',r'sqrt(\1)',s)
    if not re.fullmatch(r'[A-Za-z0-9+*/().,\s-]+',s): raise ValueError('Unsupported expression: '+s)
    local={c:S.Symbol(c,real=True) for c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'}
    local.update({'x':x,'y':y,'t':t,'sqrt':S.sqrt})
    return parse_expr(s,local_dict=local,transformations=standard_transformations+(implicit_multiplication_application,),evaluate=True)

def eq(a,b):
    difference=S.simplify(a-b)
    assert difference==0 or (not difference.free_symbols and abs(float(difference))<1e-7),f'{a} != {b}'
def pairs(s):return [(S.Rational(a),S.Rational(b)) for a,b in re.findall(r'\((-?\d+(?:\.\d+)?), (-?\d+(?:\.\d+)?)\)',s)]
def equation(s):
    a,b=s.split('=',1);return expr(a)-expr(b)
def verify(q):
    kind=q['kind'];question=q['question'].split('\n')[0];answer=q['answer']
    if kind in ['evaluate','order','rational','absolute','scientific','rational-exponent']:
        if kind=='evaluate':
            m=re.match(r'Evaluate (.+) when t = (.+)\.',question);expected=expr(m[1]).subs(t,expr(m[2]))
        elif kind=='order':expected=expr(question.removeprefix('Evaluate '))
        elif kind=='rational':expected=expr(question.removeprefix('Calculate '))
        elif kind=='absolute':expected=abs(int(re.search(r'−(\d+)',question)[1]))
        elif kind=='scientific':
            expected=S.Integer(re.search(r'Write (\d+)',question)[1]);assert 1<=float(answer.split(' × ')[0])<10
        else:expected=expr(question.removeprefix('Evaluate '))
        eq(expr(answer),expected);return True
    if kind in ['combine','distribute','exponent-product','exponent-power','exponent-quotient','radical','algebraic-rational','exponent-zero','exponent-negative','algebraic-negative']:
        original=question.split(' ',1)[1].split(', where')[0].split(' for x')[0].split(' using positive')[0].split('. State')[0].rstrip('.')
        if ' for x' in original:original=original.split(' for x')[0]
        if 'with positive exponents' in original:original=original.split(' with positive exponents')[0]
        if 'State its real-domain' in original:original=original.split(' State')[0]
        solution=answer.split(';')[0]
        # Rational variable powers are checked on their explicit nonnegative domain.
        if kind=='algebraic-rational':
            positive=S.Symbol('u',positive=True);eq(expr(original).subs(x,positive),expr(solution).subs(x,positive))
        else:eq(expr(original),expr(solution))
        return True
    if kind.startswith('equation'):
        if question.startswith('A rental'):
            rate,fee,total=map(int,re.findall(r'\$(\d+)',question));eq(rate*expr(answer)+fee,total);return True
        original=question.removeprefix('Solve ').split('. Explain')[0].rstrip('.')
        equation_expr=equation(original)
        if answer=='No solution':assert not equation_expr.free_symbols and equation_expr!=0
        elif answer=='All real numbers':eq(equation_expr,0)
        else:
            eq(equation_expr.subs(x,expr(answer)),0)
            assert S.degree(equation_expr,x)==1
        return True
    if kind=='literal':
        original=question.removeprefix('Solve ').split(' for w')[0];eq(equation(original).subs(S.Symbol('w',real=True),expr(answer.split('=',1)[1])),0);return True
    if kind=='ratio':
        count=int(re.search(r'(\d+) identical',question)[1]);cost=int(re.search(r'\$(\d+)',question)[1]);eq(expr(answer),S.Rational(cost,count));return True
    if kind=='percent':
        price=int(re.search(r'\$(\d+)',question)[1]);rate=int(re.search(r'(\d+)%',question)[1]);eq(expr(answer),S.Rational(price*(100-rate),100));return True
    if kind=='slope':
        p1,p2=pairs(question);eq(expr(answer),(p2[1]-p1[1])/(p2[0]-p1[0]));return True
    if kind in ['poly-add','poly-subtract']:
        original=question.split(': ',1)[1];eq(expr(original),expr(answer));return True
    if kind=='poly-multiply':eq(expr(question.removeprefix('Expand ')),expr(answer));return True
    if kind in ['poly-factor','poly-square','poly-difference','poly-common','real-factors']:
        original=question.removeprefix('Factor ').removeprefix('the greatest common factor from ').split(' over the real')[0].split(' into real')[0]
        eq(expr(original),expr(answer));return True
    if kind=='poly-divide':
        m=re.match(r'Divide (.+) by (.+?)\.(?: |$)',question);assert m
        dividend,divisor=expr(m[1]),expr(m[2]);quotient,remainder=S.div(dividend,divisor,x)
        if answer.startswith('Quotient '):
            a,b=answer.removeprefix('Quotient ').split('; remainder ');eq(expr(a),quotient);eq(expr(b),remainder)
        else:eq(expr(answer.split(';')[0]),S.cancel(dividend/divisor));eq(remainder,0)
        return True
    if kind in ['quad-solve','quad-complete','quad-formula','quad-square-root']:
        polynomial=equation(question.removeprefix('Solve ').split(' over the real')[0]);actual={expr(s) for s in answer.split(' or ')}
        assert actual==set(S.solve(polynomial,x)),(actual,S.solve(polynomial,x));return True
    if kind in ['quad-roots','quad-factors']:
        roots=list(map(int,re.findall(r'x=(-?\d+)',question)));model=expr(answer.split('=',1)[1]);assert set(S.solve(model,x))==set(roots);eq(S.Poly(model,x).LC(),1);return True
    if kind in ['quad-vertex','quad-axis','quad-extreme','quad-domain']:
        model=expr(question.split('f(x)=')[1].split(', find')[0].rstrip('.'))
        vertex_x=S.solve(S.diff(model,x),x)[0];vertex_y=model.subs(x,vertex_x)
        if kind=='quad-vertex':assert pairs(answer)==[(vertex_x,vertex_y)]
        elif kind=='quad-axis':eq(expr(answer.split('=')[1]),vertex_x)
        elif kind=='quad-extreme':
            m=re.match(r'Minimum (\d+) at x = (\d+)',answer);eq(expr(m[1]),vertex_y);eq(expr(m[2]),vertex_x);assert S.diff(model,x,2)>0
        else:eq(expr(answer.split('≤')[1]),vertex_y);assert S.diff(model,x,2)<0
        return True
    if kind=='quad-discriminant':
        polynomial=equation(question.split('discriminant of ')[1].split(' and state')[0]);A,B,C=S.Poly(polynomial,x).all_coeffs();eq(expr(answer.split(';')[0]),B*B-4*A*C);assert B*B-4*A*C<0;return True
    if kind in ['regression-exponential','regression-quadratic','choose-model']:
        data=pairs(question);model,prediction=answer.split('; y(4) = ');f=expr(model.split('=',1)[1]);
        for a,b in data:eq(f.subs(x,a),b)
        eq(f.subs(x,4),expr(prediction));return True
    if kind in ['data-table','regression-linear']:
        data=pairs(question);model,prediction=answer.split('; prediction ');f=expr(model.split('=',1)[1]);
        for a,b in data:eq(f.subs(x,a),b)
        at=expr(re.search(r'predict y at x=(.+)\.',question)[1]);eq(f.subs(x,at),expr(prediction));return True
    if kind in ['exp-growth','exp-decay']:
        if question.startswith('A lab'):
            initial=int(re.search(r'with (\d+) cells',question)[1]);at=int(re.search(r'after (\d+) hours',question)[1]);base=S.Rational(1,2) if 'halves' in question else 2;expected=initial*base**at
        elif question.startswith('Graph '):
            initial=int(re.search(r'f\(t\)=(\d+)',question)[1]);at=int(re.search(r'evaluate f\((\d+)\)',question)[1]);expected=initial*2**at
        else:
            m=re.match(r'For f\(t\)=(.+), find f\((\d+)\)',question);expected=expr(m[1]).subs(t,int(m[2]))
        eq(expr(answer.split(';')[0]),expected);return True
    if kind=='exp-interest':
        principal=int(re.search(r'\$(\d+)',question)[1]);rate=S.Rational(re.search(r'(\d+)%',question)[1],100);n=2 if 'semiannually' in question else 1;years=int(re.search(r'after (\d+) years',question)[1]);expected=principal*(1+rate/n)**(n*years);assert abs(float(answer[1:])-float(expected))<=0.00501;return True
    if kind=='correlation':
        data=pairs(question);n=len(data);mx=sum(z[0] for z in data)/n;my=sum(z[1] for z in data)/n
        numerator=sum((a-mx)*(b-my) for a,b in data);denominator=S.sqrt(sum((a-mx)**2 for a,b in data)*sum((b-my)**2 for a,b in data));eq(numerator/denominator,expr(answer.split(';')[0].split('=')[1]));return True
    if kind=='write-expression':
        fee,rate=map(int,re.findall(r'\$(\d+)',question));v=S.Symbol('v',real=True);eq(expr(answer),rate*v+fee);return True
    if kind=='variable':
        a,b=map(int,re.search(r'expression (\d+)x \+ (\d+)',question).groups());assert answer==f'Variable x; coefficient {a}; constant {b}';return True
    if kind=='property':
        statement=question.split('justifies ')[1].rstrip('?');eq(equation(statement),0);assert answer=='Distributive property';return True
    if kind=='points':
        a,b=map(int,re.search(r'Move (\d+) units left and (\d+) units up',question).groups());assert pairs(answer)==[(-a,b)];return True
    if kind=='independent':assert answer=='d (distance)' and 'where d is miles' in question;return True
    if kind=='polynomial':
        original=question.removeprefix('Classify ').split(' by degree')[0];poly=S.Poly(expr(original),x);assert poly.degree()==2 and len(poly.terms())==3 and answer=='Quadratic trinomial';return True
    if kind=='function':
        ps=pairs(question);mapping={};bad=False
        for a,b in ps:
            if a in mapping and mapping[a]!=b:bad=True
            mapping[a]=b
        assert bad and answer=='No; one input has two outputs';return True
    if kind in ['inequality-basic','inequality-negative','inequality-one','inequality-both']:
        if question.startswith('A club'):
            budget,fee,rate=map(int,re.findall(r'\$(\d+)',question));eq(expr(answer),S.floor(S.Rational(budget-fee,rate)));return True
        original=question.removeprefix('Solve ').split(' and describe')[0].rstrip('.')
        m=re.split(r'([≤≥])',original);a,b=expr(m[0]),expr(m[2]);relation=S.Le(a,b) if m[1]=='≤' else S.Ge(a,b)
        sol=S.solve_univariate_inequality(relation,x,relational=False)
        m=re.match(r'x ([≤≥]) (.+)',answer);bound=expr(m[2]);expected=S.Interval(-S.oo,bound) if m[1]=='≤' else S.Interval(bound,S.oo);assert sol==expected,(sol,expected);return True
    if kind=='inequality-compound':
        m=re.match(r'Solve (\d+) < x \+ (\d+) ≤ (\d+)',question);low,shift,high=map(int,m.groups());assert answer==f'{low-shift} < x ≤ {high-shift}';return True
    if kind=='inequality-word':
        budget,fee,rate=map(int,re.findall(r'\$(\d+)',question));n=int(re.search(r'maximum (\d+) kits',answer)[1]);assert n==S.floor(S.Rational(budget-fee,rate));assert '≤' in answer;return True
    if kind=='domain-linear':
        rate=int(re.search(r'makes (\d+) meters',question)[1]);end=int(re.search(r'0 ≤ t ≤ (\d+)',question)[1]);intercept=int(re.search(r'L=\d+t\+(\d+)',question)[1]);assert answer==f'0 ≤ t ≤ {end}; {intercept} ≤ L ≤ {rate*end+intercept}';return True
    if kind in ['line','line-table','line-point','line-standard','direct']:
        if kind=='line-standard':
            original=question.removeprefix('Rewrite ').split(' in standard')[0];assert S.simplify(equation(answer)/equation(original)) in [1,-1];return True
        if kind=='direct':
            count,cost=map(int,re.search(r'(\d+) kilograms cost \$(\d+)',question).groups());model=expr(answer.split('=',1)[1]);d=S.Symbol('d',real=True);eq(model.subs(d,count),cost);eq(model.subs(d,0),0);return True
        ps=pairs(question);model=equation(answer)
        if kind=='line-table':
            # Some table questions omit the space after the comma.
            ps=[(S.Rational(a),S.Rational(b)) for a,b in re.findall(r'\((-?\d+),\s*(-?\d+)\)',question)]
        for a,b in ps:eq(model.subs({x:a,y:b}),0)
        if kind=='line-point':eq(S.solve(model,y)[0].diff(x),int(re.search(r'slope (\d+)',question)[1]))
        assert ps;return True
    if kind=='intercept':
        rule=expr(question.split('y=')[1].split(', give')[0]);ps=pairs(answer);assert len(ps)==2
        for a,b in ps:eq(rule.subs(x,a),b)
        assert ps[0][1]==0 and ps[1][0]==0;return True
    if kind in ['parallel','perpendicular']:
        point=pairs(question)[0];old=expr(question.split('to y=')[1]);new=S.solve(equation(answer),y)[0]
        eq(new.subs(x,point[0]),point[1]);eq(new.diff(x),old.diff(x) if kind=='parallel' else -1/old.diff(x));return True
    if kind=='horizontal':
        point=pairs(question)[0];m=re.match(r'y = (\d+) \(slope 0\); x = (\d+) \(undefined slope\)',answer);assert (int(m[2]),int(m[1]))==point;return True
    if kind=='line-compare':
        m=re.search(r'A\(t\)=(.+) and B\(t\)=(.+)\. At',question);A,B=expr(m[1]),expr(m[2]);at=expr(re.search(r't = (\d+)',answer)[1]);eq((A-B).subs(t,at),0);assert S.diff(B-A,t)>0;return True
    if kind=='line-decay':
        initial,rate,at=map(int,re.search(r'starts with (\d+) liters and loses (\d+) liters each minute.*V\((\d+)\)',question).groups());model=expr(answer.split(';')[0].split('=')[1]);eq(model,initial-rate*t);eq(model.subs(t,at),int(re.search(r'V\(\d+\) = (\d+)',answer)[1]));return True
    if kind=='linear-transform':
        m=re.search(r'g\(x\)=(\d+)f\(x−(\d+)\)\+(\d+)',question);a,b,c=map(int,m.groups());eq(expr(answer),c-a*b);return True
    if kind in ['system','system-eliminate','system-graph','system-write']:
        px,py=pairs(answer)[0]
        if 'tickets include' in question:
            count=int(re.search(r'^(\d+) tickets',question)[1]);revenue=int(re.search(r'\$(\d+)\. Write',question)[1]);eq(px+py,count);eq(2*px+py,revenue)
        else:
            m=re.search(r'y=(.+) and x\+y=(\d+)',question);eq(expr(m[1]).subs(x,px),py);eq(px+py,int(m[2]))
        return True
    if kind in ['system-none','system-infinite']:
        m=re.search(r'y=(.+) and (.+)\.',question);first=y-expr(m[1]);second=equation(m[2]);ratio=S.diff(second,x)/S.diff(first,x);difference=S.simplify(second-ratio*first)
        assert (difference==0)==(answer=='Infinitely many solutions');assert not difference.free_symbols;return True
    if kind=='write-system-data':
        statements=answer.split('; ');f1,f2=map(equation,statements[:2]);point=pairs(statements[2])[0]
        eq(f1.subs({x:point[0],y:point[1]}),0);eq(f2.subs({x:point[0],y:point[1]}),0)
        # Verify the supplied table/graph points against their respective lines.
        ps=[(S.Rational(a),S.Rational(b)) for a,b in re.findall(r'\((-?\d+),\s*(-?\d+)\)',question)]
        for i,(a,b) in enumerate(ps):eq((f1 if i<2 else f2).subs({x:a,y:b}),0)
        return True
    if kind=='plane-inequality':assert 'Solid boundary' in answer and 'shade below' in answer and '≤' in question;return True
    if kind=='write-plane-inequality':
        model=expr(answer.split('≤')[1]);assert answer.startswith('y ≤')
        ps=[(S.Rational(a),S.Rational(b)) for a,b in re.findall(r'\((-?\d+),\s*(-?\d+)\)',question)]
        for a,b in ps:eq(model.subs(x,a),b)
        if not ps:
            b,a=map(int,re.search(r'allowance (\d+) plus (\d+)',question).groups());eq(model,a*x+b)
        return True
    if kind=='residual':
        model=expr(question.split('ŷ=')[1].split('. At')[0]);at=int(re.search(r'At x=(\d+)',question)[1]);observed=int(re.search(r'observed y is (\d+)',question)[1]);eq(expr(answer),observed-model.subs(x,at));return True
    if kind in ['sequence-arithmetic','sequence-geometric','sequence-recursive-arithmetic','sequence-recursive-geometric']:
        geometric='geometric' in kind;n=int(re.search(r'a(\d+) =',answer)[1]);rule,term=answer.split('; ');formula=expr(rule.split('=',1)[1].replace('n−1','n-1'));nvar=S.Symbol('n',real=True)
        eq(formula.subs(nvar,n),int(term.split('=')[1]))
        if 'starts ' in question:
            vals=list(map(int,re.search(r'starts (\d+), (\d+), (\d+)',question).groups()))
            for i,v in enumerate(vals):eq(formula.subs(nvar,i+1),v)
        else:
            first=int(re.search(r'a₁=(\d+)',question)[1]);eq(formula.subs(nvar,1),first);step=int(re.search(r'aₙ=(\d+)aₙ₋₁' if geometric else r'aₙ=aₙ₋₁\+(\d+)',question)[1]);eq(formula.subs(nvar,2),first*step if geometric else first+step)
        return True
    if kind=='exp-initial':
        rule=expr(question.split('f(t)=')[1].split(', find')[0]);eq(rule.subs(t,0),expr(answer.split(';')[0]));return True
    if kind=='exp-factor':
        rule=expr(question.split('P(t)=')[1].split('. What')[0]);initial=rule.subs(t,0);base=S.simplify(rule.subs(t,1)/initial);a,b=answer.split('; ');eq(expr(a),initial);eq(expr(b.rstrip('%')),100*(base-1));return True
    if kind=='exp-decay-factor':
        model=expr(question.split('Q(t)=')[1].split('. Give')[0]);base=S.simplify(model.subs(t,1)/model.subs(t,0));a,b=answer.split('; ');eq(expr(a),base);eq(expr(b.split('%')[0]),100*(1-base));return True
    if kind=='system-inequality':
        m=re.search(r'y ≥ (\d+)x and y ≤ \d+x \+ (\d+)',question);a,b=map(int,m.groups());px,py=pairs(question)[0];assert a*px<=py<=a*px+b and answer.startswith('Yes;');return True
    if kind=='quad-graph':
        f=expr(question.split('f(x)=')[1].split(', calculate')[0]);at=int(re.search(r'x=−(\d+)',question)[1]);expected=[f.subs(x,-at),f.subs(x,0),f.subs(x,at)];numbers=list(map(int,answer.split(';')[0].split(', ')));assert numbers==expected and S.diff(f,x,2)>0;return True
    if kind=='quad-write-vertex':
        ps=pairs(question);a,b=answer.split(' = ');f,g=expr(a),expr(b);eq(f,g)
        for px,py in ps:eq(f.subs(x,px),py)
        eq(S.diff(f,x).subs(x,ps[0][0]),0);return True
    if kind=='quad-intercept':
        f=expr(question.split('y=')[1].split(', find')[0]);ps=pairs(answer)
        for px,py in ps:eq(f.subs(x,px),py)
        assert {p[0] for p in ps[:2]}==set(S.solve(f,x)) and ps[2][0]==0;return True
    if kind=='quad-transform':
        model=expr(question.split('g(x)=')[1].split('. Describe')[0]);at=int(re.search(r'find g\((\d+)\)',question)[1]);eq(model.subs(x,at),expr(answer));return True
    if kind=='quad-compare':
        m=re.search(r'f\(x\)=(.+) and g\(x\)=(.+)\. Which',question);f,g=expr(m[1]),expr(m[2]);at=int(re.search(r'at x=(\d+)',question)[1]);equal_at=int(re.search(r'x = (\d+)',answer)[1]);assert g.subs(x,at)>f.subs(x,at);assert S.solve(f-g,x)==[equal_at];return True
    if kind=='quad-application':
        area,more=map(int,re.search(r'area (\d+) m².*length is (\d+) m more',question).groups());width,length=map(int,re.search(r'Width (\d+) m; length (\d+) m',answer).groups());assert width*length==area and length-width==more and min(width,length)>0;return True
    if kind=='sequence-compare':
        first,step=map(int,re.search(r'aₙ=(\d+)\+(\d+)\(n−1\)',question).groups());u,v=map(int,re.search(r'a₃ = (\d+); b₃ = (\d+)',answer).groups());assert u==first+step*2 and v==first*step**2;return True
    if kind=='exp-compare':
        m=re.search(r'L\(t\)=(.+) and E\(t\)=(.+)\. Which',question);L,E=expr(m[1]),expr(m[2]);at=int(re.search(r'at t=(\d+)',question)[1]);assert E.subs(t,at)>L.subs(t,at) and answer=='E(t)';return True
    if kind=='exp-domain':
        f=expr(question.split('f(x)=')[1]);assert f.subs(x,0)<0 and answer=='All real x; y < 0';assert S.limit(f,x,-S.oo)==0 and S.limit(f,x,S.oo)==-S.oo;return True
    if kind=='exp-asymptote':
        f=expr(question.split('f(x)=')[1].split(', state')[0]);assert S.limit(f,x,-S.oo)==0 and not S.solve(f,x) and answer=='y = 0; never reached';return True
    if kind=='causation':
        assert 'A study' in question and answer.startswith('No;') and 'could affect both' in answer
        return False # Logical study-design review, not symbolic calculation.
    if kind=='model-limit':
        end,at=map(int,re.search(r'1 ≤ x ≤ (\d+).*at x=(\d+)',question).groups());assert at>end and answer=='This is extrapolation; the relationship may not continue';return True
    return False

cases=json.loads(Path(sys.argv[1] if len(sys.argv)>1 else '.artifacts/algebra/math-cases.json').read_text(encoding='utf-8'))
verified=[];conceptual=[];failures=[]
for q in cases:
    try:
        (verified if verify(q) else conceptual).append(q)
    except Exception as e:failures.append({'kind':q['kind'],'topic':q['topic'],'question':q['question'],'answer':q['answer'],'error':str(e)})
result={'cases':len(cases),'independently_verified':len(verified),'conceptual_or_other_checks':len(conceptual),'conceptual_kinds':sorted(set(q['kind'] for q in conceptual)),'failures':failures}
Path(sys.argv[2] if len(sys.argv)>2 else 'reports/algebra/independent-math-verification.json').write_text(json.dumps(result,indent=2)+'\n',encoding='utf-8')
print(json.dumps(result,indent=2))
raise SystemExit(bool(failures))
