from sympy.core.symbol import symbols from sympy.functions.elementary.trigonometric import (cos, sin) from sympy.polys import QQ, ZZ from sympy.polys.polytools import Poly from sympy.polys.polyerrors import NotInvertible from sympy.polys.agca.extensions import FiniteExtension from sympy.polys.domainmatrix import DomainMatrix from sympy.testing.pytest import raises from sympy.abc import x, y, t def test_FiniteExtension(): # Gaussian integers A = FiniteExtension(Poly(x**2 + 1, x)) assert A.rank == 2 assert str(A) == 'ZZ[x]/(x**2 + 1)' i = A.generator assert i.parent() is A assert i*i == A(-1) raises(TypeError, lambda: i*()) assert A.basis == (A.one, i) assert A(1) == A.one assert i**2 == A(-1) assert i**2 != -1 # no coercion assert (2 + i)*(1 - i) == 3 - i assert (1 + i)**8 == A(16) assert A(1).inverse() == A(1) raises(NotImplementedError, lambda: A(2).inverse()) # Finite field of order 27 F = FiniteExtension(Poly(x**3 - x + 1, x, modulus=3)) assert F.rank == 3 a = F.generator # also generates the cyclic group F - {0} assert F.basis == (F(1), a, a**2) assert a**27 == a assert a**26 == F(1) assert a**13 == F(-1) assert a**9 == a + 1 assert a**3 == a - 1 assert a**6 == a**2 + a + 1 assert F(x**2 + x).inverse() == 1 - a assert F(x + 2)**(-1) == F(x + 2).inverse() assert a**19 * a**(-19) == F(1) assert (a - 1) / (2*a**2 - 1) == a**2 + 1 assert (a - 1) // (2*a**2 - 1) == a**2 + 1 assert 2/(a**2 + 1) == a**2 - a + 1 assert (a**2 + 1)/2 == -a**2 - 1 raises(NotInvertible, lambda: F(0).inverse()) # Function field of an elliptic curve K = FiniteExtension(Poly(t**2 - x**3 - x + 1, t, field=True)) assert K.rank == 2 assert str(K) == 'ZZ(x)[t]/(t**2 - x**3 - x + 1)' y = K.generator c = 1/(x**3 - x**2 + x - 1) assert ((y + x)*(y - x)).inverse() == K(c) assert (y + x)*(y - x)*c == K(1) # explicit inverse of y + x def test_FiniteExtension_eq_hash(): # Test eq and hash p1 = Poly(x**2 - 2, x, domain=ZZ) p2 = Poly(x**2 - 2, x, domain=QQ) K1 = FiniteExtension(p1) K2 = FiniteExtension(p2) assert K1 == FiniteExtension(Poly(x**2 - 2)) assert K2 != FiniteExtension(Poly(x**2 - 2)) assert len({K1, K2, FiniteExtension(p1)}) == 2 def test_FiniteExtension_mod(): # Test mod K = FiniteExtension(Poly(x**3 + 1, x, domain=QQ)) xf = K(x) assert (xf**2 - 1) % 1 == K.zero assert 1 % (xf**2 - 1) == K.zero assert (xf**2 - 1) / (xf - 1) == xf + 1 assert (xf**2 - 1) // (xf - 1) == xf + 1 assert (xf**2 - 1) % (xf - 1) == K.zero raises(ZeroDivisionError, lambda: (xf**2 - 1) % 0) raises(TypeError, lambda: xf % []) raises(TypeError, lambda: [] % xf) # Test mod over ring K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ)) xf = K(x) assert (xf**2 - 1) % 1 == K.zero raises(NotImplementedError, lambda: (xf**2 - 1) % (xf - 1)) def test_FiniteExtension_from_sympy(): # Test to_sympy/from_sympy K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ)) xf = K(x) assert K.from_sympy(x) == xf assert K.to_sympy(xf) == x def test_FiniteExtension_set_domain(): KZ = FiniteExtension(Poly(x**2 + 1, x, domain='ZZ')) KQ = FiniteExtension(Poly(x**2 + 1, x, domain='QQ')) assert KZ.set_domain(QQ) == KQ def test_FiniteExtension_exquo(): # Test exquo K = FiniteExtension(Poly(x**4 + 1)) xf = K(x) assert K.exquo(xf**2 - 1, xf - 1) == xf + 1 def test_FiniteExtension_convert(): # Test from_MonogenicFiniteExtension K1 = FiniteExtension(Poly(x**2 + 1)) K2 = QQ[x] x1, x2 = K1(x), K2(x) assert K1.convert(x2) == x1 assert K2.convert(x1) == x2 K = FiniteExtension(Poly(x**2 - 1, domain=QQ)) assert K.convert_from(QQ(1, 2), QQ) == K.one/2 def test_FiniteExtension_division_ring(): # Test division in FiniteExtension over a ring KQ = FiniteExtension(Poly(x**2 - 1, x, domain=QQ)) KZ = FiniteExtension(Poly(x**2 - 1, x, domain=ZZ)) KQt = FiniteExtension(Poly(x**2 - 1, x, domain=QQ[t])) KQtf = FiniteExtension(Poly(x**2 - 1, x, domain=QQ.frac_field(t))) assert KQ.is_Field is True assert KZ.is_Field is False assert KQt.is_Field is False assert KQtf.is_Field is True for K in KQ, KZ, KQt, KQtf: xK = K.convert(x) assert xK / K.one == xK assert xK // K.one == xK assert xK % K.one == K.zero raises(ZeroDivisionError, lambda: xK / K.zero) raises(ZeroDivisionError, lambda: xK // K.zero) raises(ZeroDivisionError, lambda: xK % K.zero) if K.is_Field: assert xK / xK == K.one assert xK // xK == K.one assert xK % xK == K.zero else: raises(NotImplementedError, lambda: xK / xK) raises(NotImplementedError, lambda: xK // xK) raises(NotImplementedError, lambda: xK % xK) def test_FiniteExtension_Poly(): K = FiniteExtension(Poly(x**2 - 2)) p = Poly(x, y, domain=K) assert p.domain == K assert p.as_expr() == x assert (p**2).as_expr() == 2 K = FiniteExtension(Poly(x**2 - 2, x, domain=QQ)) K2 = FiniteExtension(Poly(t**2 - 2, t, domain=K)) assert str(K2) == 'QQ[x]/(x**2 - 2)[t]/(t**2 - 2)' eK = K2.convert(x + t) assert K2.to_sympy(eK) == x + t assert K2.to_sympy(eK ** 2) == 4 + 2*x*t p = Poly(x + t, y, domain=K2) assert p**2 == Poly(4 + 2*x*t, y, domain=K2) def test_FiniteExtension_sincos_jacobian(): # Use FiniteExtensino to compute the Jacobian of a matrix involving sin # and cos of different symbols. r, p, t = symbols('rho, phi, theta') elements = [ [sin(p)*cos(t), r*cos(p)*cos(t), -r*sin(p)*sin(t)], [sin(p)*sin(t), r*cos(p)*sin(t), r*sin(p)*cos(t)], [ cos(p), -r*sin(p), 0], ] def make_extension(K): K = FiniteExtension(Poly(sin(p)**2+cos(p)**2-1, sin(p), domain=K[cos(p)])) K = FiniteExtension(Poly(sin(t)**2+cos(t)**2-1, sin(t), domain=K[cos(t)])) return K Ksc1 = make_extension(ZZ[r]) Ksc2 = make_extension(ZZ)[r] for K in [Ksc1, Ksc2]: elements_K = [[K.convert(e) for e in row] for row in elements] J = DomainMatrix(elements_K, (3, 3), K) det = J.charpoly()[-1] * (-K.one)**3 assert det == K.convert(r**2*sin(p))