import sympy as sp
import pytest
from noulith import *

@pytest.mark.parametrize('m',[2,3,4])
def test_penultimate_ideal_universality(m):
    a,b=sp.symbols('a b')
    generators=[a*a,b*b,a*b,a**3+b**4,a*a*b,b**5][:m*(m-1)//2]
    alg=universal_algebra(generators,m=m)
    sh=alg.shuffle_table()
    full=(1<<m)-1
    actual=ideal_generators(sh,full,m-1)
    assert equal_polynomial_ideals(actual,generators,[a,b])
    for mask in range(full):
        assert 1 in ideal_generators(sh,mask,m-1)


def test_arc_blind_pair_exact_ideals():
    a,b=sp.symbols('a b')
    left=universal_algebra([a*a,b*b,0],m=3)
    right=universal_algebra([a*a,b*b,a*b],m=3)
    il=ideal_generators(left.shuffle_table(),7,2)
    ir=ideal_generators(right.shuffle_table(),7,2)
    assert equal_polynomial_ideals(il,[a*a,b*b],[a,b])
    assert equal_polynomial_ideals(ir,[a*a,a*b,b*b],[a,b])
    assert not equal_polynomial_ideals(il,ir,[a,b])
    assert sp.groebner(il,a,b).reduce(a*b)[1]==a*b
    assert sp.groebner(ir,a,b).reduce(a*b)[1]==0

@pytest.mark.parametrize('p',range(2,13))
def test_arbitrarily_large_arc_blind_defect_gap(p):
    j=[(p,0),(0,p)]
    k=[(i,p-i) for i in range(p+1)]
    sj=standard_monomials(j,2*p)
    sk=standard_monomials(k,2*p)
    assert len(sj)==p*p
    assert len(sk)==p*(p+1)//2
    assert len(sj)-len(sk)==p*(p-1)//2

@pytest.mark.parametrize('order_a',range(1,10))
@pytest.mark.parametrize('order_b',range(1,10))
def test_arc_valuation_equality_monomial_oracle(order_a,order_b):
    for p in range(2,10):
        lhs=min(p*order_a,p*order_b)
        rhs=min(i*order_a+(p-i)*order_b for i in range(p+1))
        assert lhs==rhs


def test_nonlinear_arc_substitution_with_cancellation_inside_coordinates():
    a,b,t=sp.symbols('a b t')
    arcs=[(t**2+t**4,t**3-t**5),(t**4,t**4+t**7),(0,t**5),(t**3,0),(0,0)]
    for at,bt in arcs:
        left=min(valuation(at**2,t),valuation(bt**2,t))
        right=min(valuation(at**2,t),valuation(at*bt,t),valuation(bt**2,t))
        assert left==right


def test_hilbert_functions_and_generator_minimality():
    sj=standard_monomials([(2,0),(0,2)],5)
    sk=standard_monomials([(2,0),(1,1),(0,2)],5)
    assert [sum(sum(x)==k for x in sj) for k in range(4)]==[1,2,1,0]
    assert [sum(sum(x)==k for x in sk) for k in range(4)]==[1,2,0,0]
    assert len(sj)==4 and len(sk)==3


def test_exact_first_and_second_betti_certificates():
    a,b=sp.symbols('a b')
    row=sp.Matrix([[a*a,a*b,b*b]])
    syzygy=sp.Matrix([[-b,0],[a,-b],[0,a]])
    assert row*syzygy==sp.zeros(1,2)
    assert [sp.expand(syzygy.extract(rows,[0,1]).det()) for rows in [[1,2],[0,2],[0,1]]]==[a*a,-a*b,b*b]