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