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(): # 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 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) # 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 # 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) * 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_drop(): assert ZZ.drop(x) == ZZ assert ZZ[x].drop(x) == ZZ assert ZZ[x, y].drop(x) == ZZ[y] assert ZZ.frac_field(x).drop(x) == ZZ assert ZZ.frac_field(x, y).drop(x) == ZZ.frac_field(y) assert ZZ[x][y].drop(y) == ZZ[x] assert ZZ[x][y].drop(x) == ZZ[y] assert ZZ.frac_field(x)[y].drop(x) == ZZ[y] assert ZZ.frac_field(x)[y].drop(y) == ZZ.frac_field(x) Ky = FiniteExtension(Poly(x**2-1, x, domain=ZZ[y])) K = FiniteExtension(Poly(x**2-1, x, domain=ZZ)) assert Ky.drop(y) == K raises(GeneratorsError, lambda: Ky.drop(x))
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_dom_eigenvects_algebraic(): # Algebraic eigenvalues A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ) Avects = dom_eigenvects(A) # Extract the dummy to build the expected result: lamda = Avects[1][0][1].gens[0] irreducible = Poly(lamda**2 - 5 * lamda - 2, lamda, domain=QQ) K = FiniteExtension(irreducible) KK = K.from_sympy algebraic_eigenvects = [ (K, irreducible, 1, DomainMatrix([[KK((lamda - 4) / 3), KK(1)]], (1, 2), K)), ] assert Avects == ([], algebraic_eigenvects) # Test converting to Expr: sympy_eigenvects = [ (S(5) / 2 - sqrt(33) / 2, 1, [Matrix([[-sqrt(33) / 6 - S(1) / 2], [1]])]), (S(5) / 2 + sqrt(33) / 2, 1, [Matrix([[-S(1) / 2 + sqrt(33) / 6], [1]])]), ] assert dom_eigenvects_to_sympy([], algebraic_eigenvects, Matrix) == sympy_eigenvects
def test_dom_eigenvects_rootof(): # Algebraic eigenvalues A = DomainMatrix([[0, 0, 0, 0, -1], [1, 0, 0, 0, 1], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0]], (5, 5), QQ) Avects = dom_eigenvects(A) # Extract the dummy to build the expected result: lamda = Avects[1][0][1].gens[0] irreducible = Poly(lamda**5 - lamda + 1, lamda, domain=QQ) K = FiniteExtension(irreducible) KK = K.from_sympy algebraic_eigenvects = [ (K, irreducible, 1, DomainMatrix( [[KK(lamda**4 - 1), KK(lamda**3), KK(lamda**2), KK(lamda), KK(1)]], (1, 5), K)), ] assert Avects == ([], algebraic_eigenvects) # Test converting to Expr (slow): l0, l1, l2, l3, l4 = [CRootOf(lamda**5 - lamda + 1, i) for i in range(5)] sympy_eigenvects = [ (l0, 1, [Matrix([-1 + l0**4, l0**3, l0**2, l0, 1])]), (l1, 1, [Matrix([-1 + l1**4, l1**3, l1**2, l1, 1])]), (l2, 1, [Matrix([-1 + l2**4, l2**3, l2**2, l2, 1])]), (l3, 1, [Matrix([-1 + l3**4, l3**3, l3**2, l3, 1])]), (l4, 1, [Matrix([-1 + l4**4, l4**3, l4**2, l4, 1])]), ] assert dom_eigenvects_to_sympy([], algebraic_eigenvects, Matrix) == sympy_eigenvects
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_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_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 dom_eigenvects(A, l=Dummy('lambda')): charpoly = A.charpoly() rows, cols = A.shape domain = A.domain _, factors = dup_factor_list(charpoly, domain) rational_eigenvects = [] algebraic_eigenvects = [] for base, exp in factors: if len(base) == 2: field = domain eigenval = -base[1] / base[0] EE_items = [ [eigenval if i == j else field.zero for j in range(cols)] for i in range(rows)] EE = DomainMatrix(EE_items, (rows, cols), field) basis = (A - EE).nullspace() rational_eigenvects.append((field, eigenval, exp, basis)) else: minpoly = Poly.from_list(base, l, domain=domain) field = FiniteExtension(minpoly) eigenval = field(l) AA_items = [ [Poly.from_list([item], l, domain=domain).rep for item in row] for row in A.rep] AA_items = [[field(item) for item in row] for row in AA_items] AA = DomainMatrix(AA_items, (rows, cols), field) EE_items = [ [eigenval if i == j else field.zero for j in range(cols)] for i in range(rows)] EE = DomainMatrix(EE_items, (rows, cols), field) basis = (AA - EE).nullspace() algebraic_eigenvects.append((field, minpoly, exp, basis)) return rational_eigenvects, algebraic_eigenvects
def test_Domain_unify_FiniteExtension(): KxZZ = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ)) KxQQ = FiniteExtension(Poly(x**2 - 2, x, domain=QQ)) KxZZy = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y])) KxQQy = FiniteExtension(Poly(x**2 - 2, x, domain=QQ[y])) assert KxZZ.unify(KxZZ) == KxZZ assert KxQQ.unify(KxQQ) == KxQQ assert KxZZy.unify(KxZZy) == KxZZy assert KxQQy.unify(KxQQy) == KxQQy assert KxZZ.unify(ZZ) == KxZZ assert KxZZ.unify(QQ) == KxQQ assert KxQQ.unify(ZZ) == KxQQ assert KxQQ.unify(QQ) == KxQQ assert KxZZ.unify(ZZ[y]) == KxZZy assert KxZZ.unify(QQ[y]) == KxQQy assert KxQQ.unify(ZZ[y]) == KxQQy assert KxQQ.unify(QQ[y]) == KxQQy assert KxZZy.unify(ZZ) == KxZZy assert KxZZy.unify(QQ) == KxQQy assert KxQQy.unify(ZZ) == KxQQy assert KxQQy.unify(QQ) == KxQQy assert KxZZy.unify(ZZ[y]) == KxZZy assert KxZZy.unify(QQ[y]) == KxQQy assert KxQQy.unify(ZZ[y]) == KxQQy assert KxQQy.unify(QQ[y]) == KxQQy K = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y])) assert K.unify(ZZ) == K assert K.unify(ZZ[x]) == K assert K.unify(ZZ[y]) == K assert K.unify(ZZ[x, y]) == K Kz = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ[y, z])) assert K.unify(ZZ[z]) == Kz assert K.unify(ZZ[x, z]) == Kz assert K.unify(ZZ[y, z]) == Kz assert K.unify(ZZ[x, y, z]) == Kz Kx = FiniteExtension(Poly(x**2 - 2, x, domain=ZZ)) Ky = FiniteExtension(Poly(y**2 - 2, y, domain=ZZ)) Kxy = FiniteExtension(Poly(y**2 - 2, y, domain=Kx)) assert Kx.unify(Kx) == Kx assert Ky.unify(Ky) == Ky assert Kx.unify(Ky) == Kxy assert Ky.unify(Kx) == Kxy
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_ExtensionElement(): A = FiniteExtension(Poly(x**2 + 1, x)) assert srepr(A.generator) == \ "ExtElem(DMP([1, 0], ZZ, ring=GlobalPolynomialRing(ZZ, Symbol('x'))), FiniteExtension(Poly(x**2 + 1, x, domain='ZZ')))"
def test_FiniteExtension(): assert srepr(FiniteExtension(Poly(x**2 + 1, x))) == \ "FiniteExtension(Poly(x**2 + 1, x, domain='ZZ'))"
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 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