def test_intersection():
R = QQ.old_poly_ring(x, y, z)
# SCA, example 1.8.11
assert R.ideal(x, y).intersect(R.ideal(y ** 2, z)) == R.ideal(y ** 2, y * z, x * z)
assert R.ideal(x, y).intersect(R.ideal()).is_zero()
R = QQ.old_poly_ring(x, y, z, order="ilex")
assert R.ideal(x, y).intersect(R.ideal(y ** 2 + y ** 2 * z, z + z * x ** 3 * y)) == R.ideal(y ** 2, y * z, x * z)
def test_exceptions():
I = QQ.old_poly_ring(x).ideal(x)
J = QQ.old_poly_ring(y).ideal(1)
raises(ValueError, lambda: I.union(x))
raises(ValueError, lambda: I + J)
raises(ValueError, lambda: I * J)
raises(ValueError, lambda: I.union(J))
assert (I == J) is False
assert I != J
def test_FreeModule():
M1 = FreeModule(QQ[x], 2)
assert M1 == FreeModule(QQ[x], 2)
assert M1 != FreeModule(QQ[y], 2)
assert M1 != FreeModule(QQ[x], 3)
M2 = FreeModule(QQ.poly_ring(x, order="ilex"), 2)
assert [x, 1] in M1
assert [x] not in M1
assert [2, y] not in M1
assert [1/(x + 1), 2] not in M1
e = M1.convert([x, x**2 + 1])
X = QQ[x].convert(x)
assert e == [X, X**2 + 1]
assert e == [x, x**2 + 1]
assert 2*e == [2*x, 2*x**2 + 2]
assert e*2 == [2*x, 2*x**2 + 2]
assert e/2 == [x/2, (x**2 + 1)/2]
assert x*e == [x**2, x**3 + x]
assert e*x == [x**2, x**3 + x]
assert X*e == [x**2, x**3 + x]
assert e*X == [x**2, x**3 + x]
assert [x, 1] in M2
assert [x] not in M2
assert [2, y] not in M2
assert [1/(x + 1), 2] in M2
e = M2.convert([x, x**2 + 1])
X = QQ.poly_ring(x, order="ilex").convert(x)
assert e == [X, X**2 + 1]
assert e == [x, x**2 + 1]
assert 2*e == [2*x, 2*x**2 + 2]
assert e*2 == [2*x, 2*x**2 + 2]
assert e/2 == [x/2, (x**2 + 1)/2]
assert x*e == [x**2, x**3 + x]
assert e*x == [x**2, x**3 + x]
assert e/(1 + x) == [x/(1 + x), (x**2 + 1)/(1 + x)]
assert X*e == [x**2, x**3 + x]
assert e*X == [x**2, x**3 + x]
M3 = FreeModule(QQ[x, y], 2)
assert M3.convert(e) == M3.convert([x, x**2 + 1])
assert not M3.is_submodule(0)
assert not M3.is_zero()
raises(NotImplementedError, lambda: ZZ[x].free_module(2))
raises(NotImplementedError, lambda: FreeModulePolyRing(ZZ, 2))
raises(CoercionFailed, lambda: M1.convert(QQ[x].free_module(3)
.convert([1, 2, 3])))
raises(CoercionFailed, lambda: M3.convert(1))
def test_quotient():
# SCA, example 2.8.6
R = QQ.old_poly_ring(x, y, z)
F = R.free_module(2)
assert F.submodule([x*y, x*z], [y*z, x*y]).module_quotient(
F.submodule([y, z], [z, y])) == QQ.old_poly_ring(x, y, z).ideal(x**2*y**2 - x*y*z**2)
assert F.submodule([x, y]).module_quotient(F.submodule()).is_whole_ring()
M = F.submodule([x**2, x**2], [y**2, y**2])
N = F.submodule([x + y, x + y])
q, rel = M.module_quotient(N, relations=True)
assert q == R.ideal(y**2, x - y)
for i, g in enumerate(q.gens):
assert g*N.gens[0] == sum(c*x for c, x in zip(rel[i], M.gens))
def test_PolynomialRingBase():
assert srepr(ZZ.old_poly_ring(x)) == \
"GlobalPolynomialRing(ZZ, Symbol('x'))"
assert srepr(ZZ[x].old_poly_ring(y)) == \
"GlobalPolynomialRing(ZZ[x], Symbol('y'))"
assert srepr(QQ.frac_field(x).old_poly_ring(y)) == \
"GlobalPolynomialRing(FractionField(FracField((Symbol('x'),), QQ, lex)), Symbol('y'))"
def test_in_terms_of_generators():
R = QQ.old_poly_ring(x, order="ilex")
M = R.free_module(2).submodule([2*x, 0], [1, 2])
assert M.in_terms_of_generators(
[x, x]) == [R.convert(S(1)/4), R.convert(x/2)]
raises(ValueError, lambda: M.in_terms_of_generators([1, 0]))
M = R.free_module(2) / ([x, 0], [1, 1])
SM = M.submodule([1, x])
assert SM.in_terms_of_generators([2, 0]) == [R.convert(-2/(x - 1))]
R = QQ.old_poly_ring(x, y) / [x**2 - y**2]
M = R.free_module(2)
SM = M.submodule([x, 0], [0, y])
assert SM.in_terms_of_generators(
[x**2, x**2]) == [R.convert(x), R.convert(y)]
def test_SubModulePolyRing_nontriv_global():
R = QQ.old_poly_ring(x, y, z)
F = R.free_module(1)
def contains(I, f):
return F.submodule(*[[g] for g in I]).contains([f])
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**3)
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4)
assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y**2)
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4 + y**3 + 2*z*y*x)
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y*z)
assert contains([x, 1 + x + y, 5 - 7*y], 1)
assert contains(
[x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
x**3)
assert not contains(
[x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
x**2 + y**2)
# compare local order
assert not contains([x*(1 + x + y), y*(1 + z)], x)
assert not contains([x*(1 + x + y), y*(1 + z)], x + y)
def test_nontriv_global():
R = QQ.old_poly_ring(x, y, z)
def contains(I, f):
return R.ideal(*I).contains(f)
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x ** 2 + y, x ** 2 + x], x - y)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z], x ** 2)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x ** 3)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x ** 4)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z], x * y ** 2)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x ** 4 + y ** 3 + 2 * z * y * x)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x * y * z)
assert contains([x, 1 + x + y, 5 - 7 * y], 1)
assert contains([x ** 3 + y ** 3, y ** 3 + z ** 3, z ** 3 + x ** 3, x ** 2 * y + x ** 2 * z + y ** 2 * z], x ** 3)
assert not contains(
[x ** 3 + y ** 3, y ** 3 + z ** 3, z ** 3 + x ** 3, x ** 2 * y + x ** 2 * z + y ** 2 * z], x ** 2 + y ** 2
)
# compare local order
assert not contains([x * (1 + x + y), y * (1 + z)], x)
assert not contains([x * (1 + x + y), y * (1 + z)], x + y)
def test_SubModulePolyRing_local():
R = QQ.poly_ring(x, y, order=ilex)
F = R.free_module(3)
Fd = F.submodule([1+x, 0, 0], [1+y, 2+2*y, 0], [1, 2, 3])
M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
assert F == Fd
assert Fd == F
assert F != M
assert M != F
assert Fd != M
assert M != Fd
assert Fd == F.submodule(*F.basis())
assert Fd.is_full_module()
assert not M.is_full_module()
assert not Fd.is_zero()
assert not M.is_zero()
assert Fd.submodule().is_zero()
assert M.contains([x**2 + y**2 + x, 1 + y, 1])
assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
assert M.contains([y**2, 1 - x*y, -x])
assert F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1 + x*y])) == F
raises(ValueError, lambda: M.submodule([1, 0, 0]))
def test_QuotientModule():
R = QQ.old_poly_ring(x)
F = R.free_module(3)
N = F.submodule([1, x, x**2])
M = F/N
assert M != F
assert M != N
assert M == F / [(1, x, x**2)]
assert not M.is_zero()
assert (F / F.basis()).is_zero()
SQ = F.submodule([1, x, x**2], [2, 0, 0]) / N
assert SQ == M.submodule([2, x, x**2])
assert SQ != M.submodule([2, 1, 0])
assert SQ != M
assert M.is_submodule(SQ)
assert not SQ.is_full_module()
raises(ValueError, lambda: N/F)
raises(ValueError, lambda: F.submodule([2, 0, 0]) / N)
raises(ValueError, lambda: R.free_module(2)/F)
raises(CoercionFailed, lambda: F.convert(M.convert([1, x, x**2])))
M1 = F / [[1, 1, 1]]
M2 = M1.submodule([1, 0, 0], [0, 1, 0])
assert M1 == M2
def test_PrettyPoly():
from sympy.polys.domains import QQ
F = QQ.frac_field(x, y)
R = QQ[x, y]
assert sstr(F.convert(x / (x + y))) == sstr(x / (x + y))
assert sstr(R.convert(x + y)) == sstr(x + y)
def test_reduction():
from sympy.polys.distributedmodules import sdm_nf_buchberger_reduced
R = QQ.old_poly_ring(x, y)
I = R.ideal(x**5, y)
e = R.convert(x**3 + y**2)
assert I.reduce_element(e) == e
assert I.reduce_element(e, NF=sdm_nf_buchberger_reduced) == R.convert(x**3)
def test_QuotientModuleElement():
R = QQ.old_poly_ring(x)
F = R.free_module(3)
N = F.submodule([1, x, x**2])
M = F/N
e = M.convert([x**2, 2, 0])
assert M.convert([x + 1, x**2 + x, x**3 + x**2]) == 0
assert e == [x**2, 2, 0] + N == F.convert([x**2, 2, 0]) + N == \
M.convert(F.convert([x**2, 2, 0]))
assert M.convert([x**2 + 1, 2*x + 2, x**2]) == e + [0, x, 0] == \
e + M.convert([0, x, 0]) == e + F.convert([0, x, 0])
assert M.convert([x**2 + 1, 2, x**2]) == e - [0, x, 0] == \
e - M.convert([0, x, 0]) == e - F.convert([0, x, 0])
assert M.convert([0, 2, 0]) == M.convert([x**2, 4, 0]) - e == \
[x**2, 4, 0] - e == F.convert([x**2, 4, 0]) - e
assert M.convert([x**3 + x**2, 2*x + 2, 0]) == (1 + x)*e == \
R.convert(1 + x)*e == e*(1 + x) == e*R.convert(1 + x)
assert -e == [-x**2, -2, 0]
f = [x, x, 0] + N
assert M.convert([1, 1, 0]) == f / x == f / R.convert(x)
M2 = F/[(2, 2*x, 2*x**2), (0, 0, 1)]
G = R.free_module(2)
M3 = G/[[1, x]]
M4 = F.submodule([1, x, x**2], [1, 0, 0]) / N
raises(CoercionFailed, lambda: M.convert(G.convert([1, x])))
raises(CoercionFailed, lambda: M.convert(M3.convert([1, x])))
raises(CoercionFailed, lambda: M.convert(M2.convert([1, x, x])))
assert M2.convert(M.convert([2, x, x**2])) == [2, x, 0]
assert M.convert(M4.convert([2, 0, 0])) == [2, 0, 0]
def test_syzygy():
R = QQ.old_poly_ring(x, y, z)
M = R.free_module(1).submodule([x*y], [y*z], [x*z])
S = R.free_module(3).submodule([0, x, -y], [z, -x, 0])
assert M.syzygy_module() == S
M2 = M / ([x*y*z],)
S2 = R.free_module(3).submodule([z, 0, 0], [0, x, 0], [0, 0, y])
assert M2.syzygy_module() == S2
F = R.free_module(3)
assert F.submodule(*F.basis()).syzygy_module() == F.submodule()
R2 = QQ.old_poly_ring(x, y, z) / [x*y*z]
M3 = R2.free_module(1).submodule([x*y], [y*z], [x*z])
S3 = R2.free_module(3).submodule([z, 0, 0], [0, x, 0], [0, 0, y])
assert M3.syzygy_module() == S3
def test_DomainMatrix_det():
A = DomainMatrix([], (0, 0), ZZ)
assert A.det() == 1
A = DomainMatrix([[1]], (1, 1), ZZ)
assert A.det() == 1
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
assert A.det() == ZZ(-2)
A = DomainMatrix(
[[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)],
[ZZ(1), ZZ(3), ZZ(5)]], (3, 3), ZZ)
assert A.det() == ZZ(-1)
A = DomainMatrix(
[[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)],
[ZZ(1), ZZ(2), ZZ(5)]], (3, 3), ZZ)
assert A.det() == ZZ(0)
Ans = DomainMatrix([[QQ(1), QQ(2)]], (1, 2), QQ)
raises(NonSquareMatrixError, lambda: Ans.det())
A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
assert A.det() == QQ(-2)
def test_module_mul():
R = QQ.old_poly_ring(x)
M = R.free_module(2)
S1 = M.submodule([x, 0], [0, x])
S2 = M.submodule([x**2, 0], [0, x**2])
I = R.ideal(x)
assert I * M == M * I == S1 == x * M == M * x
assert I * S1 == S2 == x * S1
def test_DDM_sub():
A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
B = DDM([[ZZ(3)], [ZZ(4)]], (2, 1), ZZ)
C = DDM([[ZZ(-2)], [ZZ(-2)]], (2, 1), ZZ)
AQ = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
D = DDM([[ZZ(5)]], (1, 1), ZZ)
assert A - B == A.sub(B) == C
raises(TypeError, lambda: A - ZZ(1))
raises(TypeError, lambda: ZZ(1) - A)
raises(DDMShapeError, lambda: A - D)
raises(DDMShapeError, lambda: D - A)
raises(DDMShapeError, lambda: A.sub(D))
raises(DDMShapeError, lambda: D.sub(A))
raises(DDMDomainError, lambda: A - AQ)
raises(DDMDomainError, lambda: AQ - A)
raises(DDMDomainError, lambda: A.sub(AQ))
raises(DDMDomainError, lambda: AQ.sub(A))
def test_in_terms_of_generators():
R = QQ.old_poly_ring(x, order="ilex")
M = R.free_module(2).submodule([2 * x, 0], [1, 2])
assert M.in_terms_of_generators(
[x, x]) == [R.convert(Rational(1, 4)),
R.convert(x / 2)]
raises(ValueError, lambda: M.in_terms_of_generators([1, 0]))
M = R.free_module(2) / ([x, 0], [1, 1])
SM = M.submodule([1, x])
assert SM.in_terms_of_generators([2, 0]) == [R.convert(-2 / (x - 1))]
R = QQ.old_poly_ring(x, y) / [x**2 - y**2]
M = R.free_module(2)
SM = M.submodule([x, 0], [0, y])
assert SM.in_terms_of_generators([x**2,
x**2]) == [R.convert(x),
R.convert(y)]
def test_ddm_idet():
A = []
assert ddm_idet(A, ZZ) == ZZ(1)
A = [[ZZ(2)]]
assert ddm_idet(A, ZZ) == ZZ(2)
A = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
assert ddm_idet(A, ZZ) == ZZ(-2)
A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(3), ZZ(5)]]
assert ddm_idet(A, ZZ) == ZZ(-1)
A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(2), ZZ(5)]]
assert ddm_idet(A, ZZ) == ZZ(0)
A = [[QQ(1, 2), QQ(1, 2)], [QQ(1, 3), QQ(1, 4)]]
assert ddm_idet(A, QQ) == QQ(-1, 24)
def test_module_mul():
R = QQ.old_poly_ring(x)
M = R.free_module(2)
S1 = M.submodule([x, 0], [0, x])
S2 = M.submodule([x**2, 0], [0, x**2])
I = R.ideal(x)
assert I*M == M*I == S1 == x*M == M*x
assert I*S1 == S2 == x*S1
def test_DomainScalar_eq():
A = DomainScalar(QQ(2), QQ)
assert A == A
B = DomainScalar(ZZ(-5), ZZ)
assert A != B
C = DomainScalar(ZZ(2), ZZ)
assert A != C
D = [1]
assert A != D
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_intersection():
R = QQ[x, y, z]
# SCA, example 1.8.11
assert R.ideal(x, y).intersect(R.ideal(y**2,
z)) == R.ideal(y**2, y * z, x * z)
assert R.ideal(x, y).intersect(R.ideal()).is_zero()
R = QQ.poly_ring(x, y, z, order="ilex")
assert R.ideal(x, y).intersect(R.ideal(y**2 + y**2*z, z + z*x**3*y)) == \
R.ideal(y**2, y*z, x*z)
def test_ModulesQuotientRing():
R = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
M1 = R.free_module(2)
assert M1 == R.free_module(2)
assert M1 != QQ.old_poly_ring(x).free_module(2)
assert M1 != R.free_module(3)
assert [x, 1] in M1
assert [x] not in M1
assert [1/(R.convert(x) + 1), 2] in M1
assert [1, 2/(1 + y)] in M1
assert [1, 2/y] not in M1
assert M1.convert([x**2, y]) == [-1, y]
F = R.free_module(3)
Fd = F.submodule([x**2, 0, 0], [1, 2, 0], [1, 2, 3])
M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
assert F == Fd
assert Fd == F
assert F != M
assert M != F
assert Fd != M
assert M != Fd
assert Fd == F.submodule(*F.basis())
assert Fd.is_full_module()
assert not M.is_full_module()
assert not Fd.is_zero()
assert not M.is_zero()
assert Fd.submodule().is_zero()
assert M.contains([x**2 + y**2 + x, -x**2 + y, 1])
assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
assert M.contains([y**2, 1 - x*y, -x])
assert F.submodule([x, 0, 0]) == F.submodule([1, 0, 0])
assert not F.submodule([y, 0, 0]) == F.submodule([1, 0, 0])
assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
assert not M.is_submodule(0)
def test_DDM_matmul():
A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
B = DDM([[ZZ(3), ZZ(4)]], (1, 2), ZZ)
AB = DDM([[ZZ(3), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
BA = DDM([[ZZ(11)]], (1, 1), ZZ)
assert A @ B == A.matmul(B) == AB
assert B @ A == B.matmul(A) == BA
raises(TypeError, lambda: A @ 1)
raises(TypeError, lambda: A @ [[3, 4]])
Bq = DDM([[QQ(3), QQ(4)]], (1, 2), QQ)
raises(DDMDomainError, lambda: A @ Bq)
raises(DDMDomainError, lambda: Bq @ A)
C = DDM([[ZZ(1)]], (1, 1), ZZ)
assert A @ C == A.matmul(C) == A
raises(DDMShapeError, lambda: C @ A)
raises(DDMShapeError, lambda: C.matmul(A))
Z04 = DDM([], (0, 4), ZZ)
Z40 = DDM([[]] * 4, (4, 0), ZZ)
Z50 = DDM([[]] * 5, (5, 0), ZZ)
Z05 = DDM([], (0, 5), ZZ)
Z45 = DDM([[0] * 5] * 4, (4, 5), ZZ)
Z54 = DDM([[0] * 4] * 5, (5, 4), ZZ)
Z00 = DDM([], (0, 0), ZZ)
assert Z04 @ Z45 == Z04.matmul(Z45) == Z05
assert Z45 @ Z50 == Z45.matmul(Z50) == Z40
assert Z00 @ Z04 == Z00.matmul(Z04) == Z04
assert Z50 @ Z00 == Z50.matmul(Z00) == Z50
assert Z00 @ Z00 == Z00.matmul(Z00) == Z00
assert Z50 @ Z04 == Z50.matmul(Z04) == Z54
raises(DDMShapeError, lambda: Z05 @ Z40)
raises(DDMShapeError, lambda: Z05.matmul(Z40))
def test_ModulesQuotientRing():
R = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
M1 = R.free_module(2)
assert M1 == R.free_module(2)
assert M1 != QQ.old_poly_ring(x).free_module(2)
assert M1 != R.free_module(3)
assert [x, 1] in M1
assert [x] not in M1
assert [1 / (R.convert(x) + 1), 2] in M1
assert [1, 2 / (1 + y)] in M1
assert [1, 2 / y] not in M1
assert M1.convert([x**2, y]) == [-1, y]
F = R.free_module(3)
Fd = F.submodule([x**2, 0, 0], [1, 2, 0], [1, 2, 3])
M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
assert F == Fd
assert Fd == F
assert F != M
assert M != F
assert Fd != M
assert M != Fd
assert Fd == F.submodule(*F.basis())
assert Fd.is_full_module()
assert not M.is_full_module()
assert not Fd.is_zero()
assert not M.is_zero()
assert Fd.submodule().is_zero()
assert M.contains([x**2 + y**2 + x, -x**2 + y, 1])
assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
assert M.contains([y**2, 1 - x * y, -x])
assert F.submodule([x, 0, 0]) == F.submodule([1, 0, 0])
assert not F.submodule([y, 0, 0]) == F.submodule([1, 0, 0])
assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
assert not M.is_submodule(0)
def test_DomainMatrix_nullspace():
A = DomainMatrix([[QQ(1), QQ(1)], [QQ(1), QQ(1)]], (2, 2), QQ)
Anull = DomainMatrix([[QQ(-1), QQ(1)]], (1, 2), QQ)
assert A.nullspace() == Anull
Az = DomainMatrix([[ZZ(1), ZZ(1)], [ZZ(1), ZZ(1)]], (2, 2), ZZ)
raises(ValueError, lambda: Az.nullspace())
def test_intersection():
# SCA, example 2.8.5
F = QQ.old_poly_ring(x, y).free_module(2)
M1 = F.submodule([x, y], [y, 1])
M2 = F.submodule([0, y - 1], [x, 1], [y, x])
I = F.submodule([x, y], [y**2 - y, y - 1], [x * y + y, x + 1])
I1, rel1, rel2 = M1.intersect(M2, relations=True)
assert I1 == M2.intersect(M1) == I
for i, g in enumerate(I1.gens):
assert g == sum(c*x for c, x in zip(rel1[i], M1.gens)) \
== sum(d*y for d, y in zip(rel2[i], M2.gens))
assert F.submodule([x, y]).intersect(F.submodule([y, x])).is_zero()
def test_intersection():
# SCA, example 2.8.5
F = QQ.old_poly_ring(x, y).free_module(2)
M1 = F.submodule([x, y], [y, 1])
M2 = F.submodule([0, y - 1], [x, 1], [y, x])
I = F.submodule([x, y], [y**2 - y, y - 1], [x*y + y, x + 1])
I1, rel1, rel2 = M1.intersect(M2, relations=True)
assert I1 == M2.intersect(M1) == I
for i, g in enumerate(I1.gens):
assert g == sum(c*x for c, x in zip(rel1[i], M1.gens)) \
== sum(d*y for d, y in zip(rel2[i], M2.gens))
assert F.submodule([x, y]).intersect(F.submodule([y, x])).is_zero()
def test_nontriv_local():
R = QQ.poly_ring(x, y, z, order=ilex)
def contains(I, f):
return R.ideal(*I).contains(f)
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x+y+z, x*y+x*z+y*z, x*y*z], x**2)
assert contains([x*(1+x+y), y*(1+z)], x)
assert contains([x*(1+x+y), y*(1+z)], x + y)
def test_DomainMatrix_add():
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
B = DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
assert A + A == A.add(A) == B
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
L = [[2, 3], [3, 4]]
raises(TypeError, lambda: A + L)
raises(TypeError, lambda: L + A)
A1 = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
A2 = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
raises(ShapeError, lambda: A1 + A2)
raises(ShapeError, lambda: A2 + A1)
raises(ShapeError, lambda: A1.add(A2))
raises(ShapeError, lambda: A2.add(A1))
Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
raises(ValueError, lambda: Az + Aq)
raises(ValueError, lambda: Aq + Az)
raises(ValueError, lambda: Az.add(Aq))
raises(ValueError, lambda: Aq.add(Az))
def test_SubModulePolyRing_nontriv_local():
R = QQ.poly_ring(x, y, z, order=ilex)
F = R.free_module(1)
def contains(I, f):
return F.submodule(*[[g] for g in I]).contains([f])
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x+y+z, x*y+x*z+y*z, x*y*z], x**2)
assert contains([x*(1+x+y), y*(1+z)], x)
assert contains([x*(1+x+y), y*(1+z)], x + y)
def test_DomainMatrix_sub():
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
B = DomainMatrix([[ZZ(0), ZZ(0)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
assert A - A == A.sub(A) == B
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
L = [[2, 3], [3, 4]]
raises(TypeError, lambda: A - L)
raises(TypeError, lambda: L - A)
A1 = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
A2 = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
raises(ShapeError, lambda: A1 - A2)
raises(ShapeError, lambda: A2 - A1)
raises(ShapeError, lambda: A1.sub(A2))
raises(ShapeError, lambda: A2.sub(A1))
Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
raises(ValueError, lambda: Az - Aq)
raises(ValueError, lambda: Aq - Az)
raises(ValueError, lambda: Az.sub(Aq))
raises(ValueError, lambda: Aq.sub(Az))
def test_nontriv_local():
R = QQ.old_poly_ring(x, y, z, order=ilex)
def contains(I, f):
return R.ideal(*I).contains(f)
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z], x**2)
assert contains([x * (1 + x + y), y * (1 + z)], x)
assert contains([x * (1 + x + y), y * (1 + z)], x + y)
def test_DomainMatrix_unify():
Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
assert Az.unify(Az) == (Az, Az)
assert Az.unify(Aq) == (Aq, Aq)
assert Aq.unify(Az) == (Aq, Aq)
assert Aq.unify(Aq) == (Aq, Aq)
As = DomainMatrix({0: {1: ZZ(1)}, 1:{0:ZZ(2)}}, (2, 2), ZZ)
Ad = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
assert As.unify(As) == (As, As)
assert Ad.unify(Ad) == (Ad, Ad)
Bs, Bd = As.unify(Ad, fmt='dense')
assert Bs.rep == DDM([[0, 1], [2, 0]], (2, 2), ZZ)
assert Bd.rep == DDM([[1, 2],[3, 4]], (2, 2), ZZ)
Bs, Bd = As.unify(Ad, fmt='sparse')
assert Bs.rep == SDM({0: {1: 1}, 1: {0: 2}}, (2, 2), ZZ)
assert Bd.rep == SDM({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
raises(ValueError, lambda: As.unify(Ad, fmt='invalid'))
def test_DomainMatrix_scalarmul():
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
lamda = DomainScalar(QQ(3)/QQ(2), QQ)
assert A * lamda == DomainMatrix([[QQ(3, 2), QQ(3)], [QQ(9, 2), QQ(6)]], (2, 2), QQ)
assert A * 2 == DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
assert A * DomainScalar(ZZ(0), ZZ) == DomainMatrix([[ZZ(0)]*2]*2, (2, 2), ZZ)
assert A * DomainScalar(ZZ(1), ZZ) == A
raises(TypeError, lambda: A * 1.5)
def test_SubModulePolyRing_nontriv_local():
R = QQ.old_poly_ring(x, y, z, order=ilex)
F = R.free_module(1)
def contains(I, f):
return F.submodule(*[[g] for g in I]).contains([f])
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z], x**2)
assert contains([x * (1 + x + y), y * (1 + z)], x)
assert contains([x * (1 + x + y), y * (1 + z)], x + y)
def test_DomainMatrix_from_Matrix():
ddm = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
A = DomainMatrix.from_Matrix(Matrix([[1, 2], [3, 4]]))
assert A.rep == ddm
assert A.shape == (2, 2)
assert A.domain == ZZ
K = QQ.algebraic_field(sqrt(2))
ddm = DDM([[
K.convert(1 + sqrt(2)), K.convert(2 + sqrt(2))
], [K.convert(3 + sqrt(2)), K.convert(4 + sqrt(2))]], (2, 2), K)
A = DomainMatrix.from_Matrix(Matrix([[1 + sqrt(2), 2 + sqrt(2)],
[3 + sqrt(2), 4 + sqrt(2)]]),
extension=True)
assert A.rep == ddm
assert A.shape == (2, 2)
assert A.domain == K
def test_PolyElement():
Ruv, u,v = ring("u,v", ZZ)
Rxyz, x,y,z = ring("x,y,z", Ruv)
assert str(x - x) == "0"
assert str(x - 1) == "x - 1"
assert str(x + 1) == "x + 1"
assert str(x**2) == "x**2"
assert str(x**(-2)) == "x**(-2)"
assert str(x**QQ(1, 2)) == "x**(1/2)"
assert str((u**2 + 3*u*v + 1)*x**2*y + u + 1) == "(u**2 + 3*u*v + 1)*x**2*y + u + 1"
assert str((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x) == "(u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x"
assert str((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1) == "(u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1"
assert str((-u**2 + 3*u*v - 1)*x**2*y - (u + 1)*x - 1) == "-(u**2 - 3*u*v + 1)*x**2*y - (u + 1)*x - 1"
assert str(-(v**2 + v + 1)*x + 3*u*v + 1) == "-(v**2 + v + 1)*x + 3*u*v + 1"
assert str(-(v**2 + v + 1)*x - 3*u*v + 1) == "-(v**2 + v + 1)*x - 3*u*v + 1"
def test_SubModulePolyRing_nontriv_global():
R = QQ.old_poly_ring(x, y, z)
F = R.free_module(1)
def contains(I, f):
return F.submodule(*[[g] for g in I]).contains([f])
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z], x**2)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x**3)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x**4)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z],
x * y**2)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z],
x**4 + y**3 + 2 * z * y * x)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x * y * z)
assert contains([x, 1 + x + y, 5 - 7 * y], 1)
assert contains(
[
x**3 + y**3,
y**3 + z**3,
z**3 + x**3,
x**2 * y + x**2 * z + y**2 * z,
],
x**3,
)
assert not contains(
[
x**3 + y**3,
y**3 + z**3,
z**3 + x**3,
x**2 * y + x**2 * z + y**2 * z,
],
x**2 + y**2,
)
# compare local order
assert not contains([x * (1 + x + y), y * (1 + z)], x)
assert not contains([x * (1 + x + y), y * (1 + z)], x + y)
def test_nontriv_global():
R = QQ.old_poly_ring(x, y, z)
def contains(I, f):
return R.ideal(*I).contains(f)
assert contains([x, y], x)
assert contains([x, y], x + y)
assert not contains([x, y], 1)
assert not contains([x, y], z)
assert contains([x**2 + y, x**2 + x], x - y)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z], x**2)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x**3)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x**4)
assert not contains([x + y + z, x * y + x * z + y * z, x * y * z],
x * y**2)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z],
x**4 + y**3 + 2 * z * y * x)
assert contains([x + y + z, x * y + x * z + y * z, x * y * z], x * y * z)
assert contains([x, 1 + x + y, 5 - 7 * y], 1)
assert contains(
[
x**3 + y**3,
y**3 + z**3,
z**3 + x**3,
x**2 * y + x**2 * z + y**2 * z,
],
x**3,
)
assert not contains(
[
x**3 + y**3,
y**3 + z**3,
z**3 + x**3,
x**2 * y + x**2 * z + y**2 * z,
],
x**2 + y**2,
)
# compare local order
assert not contains([x * (1 + x + y), y * (1 + z)], x)
assert not contains([x * (1 + x + y), y * (1 + z)], x + y)
def test_FreeModuleElement():
M = QQ[x].free_module(3)
e = M.convert([1, x, x**2])
f = [QQ[x].convert(1), QQ[x].convert(x), QQ[x].convert(x**2)]
assert list(e) == f
assert f[0] == e[0]
assert f[1] == e[1]
assert f[2] == e[2]
raises(IndexError, lambda: e[3])
g = M.convert([x, 0, 0])
assert e + g == M.convert([x + 1, x, x**2])
assert f + g == M.convert([x + 1, x, x**2])
assert -e == M.convert([-1, -x, -x**2])
assert e - g == M.convert([1 - x, x, x**2])
assert e != g
assert M.convert([x, x, x]) / QQ[x].convert(x) == [1, 1, 1]
R = QQ.poly_ring(x, order="ilex")
assert R.free_module(1).convert([x]) / R.convert(x) == [1]
def test_FreeModuleElement():
M = QQ[x].free_module(3)
e = M.convert([1, x, x**2])
f = [QQ[x].convert(1), QQ[x].convert(x), QQ[x].convert(x**2)]
assert list(e) == f
assert f[0] == e[0]
assert f[1] == e[1]
assert f[2] == e[2]
raises(IndexError, lambda: e[3])
g = M.convert([x, 0, 0])
assert e + g == M.convert([x + 1, x, x**2])
assert f + g == M.convert([x + 1, x, x**2])
assert -e == M.convert([-1, -x, -x**2])
assert e - g == M.convert([1 - x, x, x**2])
assert e != g
assert M.convert([x, x, x]) / QQ[x].convert(x) == [1, 1, 1]
R = QQ.poly_ring(x, order="ilex")
assert R.free_module(1).convert([x]) / R.convert(x) == [1]
def test_DomainMatrix_from_list_sympy():
# ddm = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
ddm = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
A = DomainMatrix.from_list_sympy(2, 2, [[1, 2], [3, 4]])
assert A.rep == ddm
assert A.shape == (2, 2)
assert A.domain == ZZ
K = QQ.algebraic_field(sqrt(2))
ddm = DDM([[
K.convert(1 + sqrt(2)), K.convert(2 + sqrt(2))
], [K.convert(3 + sqrt(2)), K.convert(4 + sqrt(2))]], (2, 2), K)
ddm = SDM.from_ddm(ddm)
A = DomainMatrix.from_list_sympy(
2,
2, [[1 + sqrt(2), 2 + sqrt(2)], [3 + sqrt(2), 4 + sqrt(2)]],
extension=True)
assert A.rep == ddm
assert A.shape == (2, 2)
assert A.domain == K
def test_ideal_operations():
R = QQ.old_poly_ring(x, y)
I = R.ideal(x)
J = R.ideal(y)
S = R.ideal(x * y)
T = R.ideal(x, y)
assert not (I == J)
assert I == I
assert I.union(J) == T
assert I + J == T
assert I + T == T
assert not I.subset(T)
assert T.subset(I)
assert I.product(J) == S
assert I * J == S
assert x * J == S
assert I * y == S
assert R.convert(x) * J == S
assert I * R.convert(y) == S
assert not I.is_zero()
assert not J.is_whole_ring()
assert R.ideal(x**2 + 1, x).is_whole_ring()
assert R.ideal() == R.ideal(0)
assert R.ideal().is_zero()
assert T.contains(x * y)
assert T.subset([x, y])
assert T.in_terms_of_generators(x) == [R(1), R(0)]
assert T**0 == R.ideal(1)
assert T**1 == T
assert T**2 == R.ideal(x**2, y**2, x * y)
assert I**5 == R.ideal(x**5)
def test_ideal_operations():
R = QQ.old_poly_ring(x, y)
I = R.ideal(x)
J = R.ideal(y)
S = R.ideal(x * y)
T = R.ideal(x, y)
assert not (I == J)
assert I == I
assert I.union(J) == T
assert I + J == T
assert I + T == T
assert not I.subset(T)
assert T.subset(I)
assert I.product(J) == S
assert I * J == S
assert x * J == S
assert I * y == S
assert R.convert(x) * J == S
assert I * R.convert(y) == S
assert not I.is_zero()
assert not J.is_whole_ring()
assert R.ideal(x ** 2 + 1, x).is_whole_ring()
assert R.ideal() == R.ideal(0)
assert R.ideal().is_zero()
assert T.contains(x * y)
assert T.subset([x, y])
assert T.in_terms_of_generators(x) == [R(1), R(0)]
assert T ** 0 == R.ideal(1)
assert T ** 1 == T
assert T ** 2 == R.ideal(x ** 2, y ** 2, x * y)
assert I ** 5 == R.ideal(x ** 5)
def test_DomainMatrix_mul():
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
A2 = DomainMatrix([[ZZ(7), ZZ(10)], [ZZ(15), ZZ(22)]], (2, 2), ZZ)
assert A*A == A.matmul(A) == A2
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
L = [[1, 2], [3, 4]]
raises(TypeError, lambda: A * L)
raises(TypeError, lambda: L * A)
Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
Aprod = DomainMatrix([[QQ(7), QQ(10)], [QQ(15), QQ(22)]], (2, 2), QQ)
assert Az * Aq == Aprod
assert Aq * Az == Aprod
raises(DDMDomainError, lambda: Az.matmul(Aq))
raises(DDMDomainError, lambda: Aq.matmul(Az))
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
AA = DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
x = ZZ(2)
assert A * x == x * A == A.mul(x) == AA
A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
AA = DomainMatrix([[ZZ(0), ZZ(0)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
x = ZZ(0)
assert A * x == x * A == A.mul(x) == AA
As = DomainMatrix({0: {1: ZZ(1)}, 1: {0: ZZ(2)}}, (2, 2), ZZ)
Ad = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
Asd = As * Ad
Ads = Ad * As
assert Asd == DomainMatrix([[3, 4], [2, 4]], (2, 2), ZZ)
assert Asd.rep == DDM([[3, 4], [2, 4]], (2, 2), ZZ)
assert Ads == DomainMatrix([[4, 1], [8, 3]], (2, 2), ZZ)
assert Ads.rep == DDM([[4, 1], [8, 3]], (2, 2), ZZ)
def test_SubModulePolyRing_global():
R = QQ.old_poly_ring(x, y)
F = R.free_module(3)
Fd = F.submodule([1, 0, 0], [1, 2, 0], [1, 2, 3])
M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
assert F == Fd
assert Fd == F
assert F != M
assert M != F
assert Fd != M
assert M != Fd
assert Fd == F.submodule(*F.basis())
assert Fd.is_full_module()
assert not M.is_full_module()
assert not Fd.is_zero()
assert not M.is_zero()
assert Fd.submodule().is_zero()
assert M.contains([x**2 + y**2 + x, 1 + y, 1])
assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
assert M.contains([y**2, 1 - x*y, -x])
assert not F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
assert not M.is_submodule(0)
m = F.convert([x**2 + y**2, 1, 0])
n = M.convert(m)
assert m.module is F
assert n.module is M
raises(ValueError, lambda: M.submodule([1, 0, 0]))
raises(TypeError, lambda: M.union(1))
raises(ValueError, lambda: M.union(R.free_module(1).submodule([x])))
assert F.submodule([x, x, x]) != F.submodule([x, x, x], order="ilex")
def test_SubModulePolyRing_global():
R = QQ.old_poly_ring(x, y)
F = R.free_module(3)
Fd = F.submodule([1, 0, 0], [1, 2, 0], [1, 2, 3])
M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
assert F == Fd
assert Fd == F
assert F != M
assert M != F
assert Fd != M
assert M != Fd
assert Fd == F.submodule(*F.basis())
assert Fd.is_full_module()
assert not M.is_full_module()
assert not Fd.is_zero()
assert not M.is_zero()
assert Fd.submodule().is_zero()
assert M.contains([x**2 + y**2 + x, 1 + y, 1])
assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
assert M.contains([y**2, 1 - x * y, -x])
assert not F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
assert not M.is_submodule(0)
m = F.convert([x**2 + y**2, 1, 0])
n = M.convert(m)
assert m.module is F
assert n.module is M
raises(ValueError, lambda: M.submodule([1, 0, 0]))
raises(TypeError, lambda: M.union(1))
raises(ValueError, lambda: M.union(R.free_module(1).submodule([x])))
assert F.submodule([x, x, x]) != F.submodule([x, x, x], order="ilex")
def test_DomainScalar_sub():
A = DomainScalar(ZZ(1), ZZ)
B = DomainScalar(QQ(2), QQ)
assert A - B == DomainScalar(QQ(-1), QQ)
raises(TypeError, lambda: A - 1.5)
def test_DomainScalar_add():
A = DomainScalar(ZZ(1), ZZ)
B = DomainScalar(QQ(2), QQ)
assert A + B == DomainScalar(QQ(3), QQ)
raises(TypeError, lambda: A + 1.5)
def test_DomainScalar_unify():
A = DomainScalar(ZZ(1), ZZ)
B = DomainScalar(QQ(2), QQ)
A, B = A.unify(B)
assert A.domain == B.domain == QQ
def test_quotient():
# SCA, example 1.8.13
R = QQ.old_poly_ring(x, y, z)
assert R.ideal(x, y).quotient(R.ideal(y ** 2, z)) == R.ideal(x, y)
def test_groebner_extendend():
M = QQ.old_poly_ring(x, y, z).free_module(3).submodule([x + 1, y, 1], [x*y, z, z**2])
G, R = M._groebner_vec(extended=True)
for i, g in enumerate(G):
assert g == sum(c*gen for c, gen in zip(R[i], M.gens))
def test_FractionField():
assert srepr(QQ.frac_field(x)) == \
"FractionField(FracField((Symbol('x'),), QQ, lex))"
assert srepr(QQ.frac_field(x, y, order=grlex)) == \
"FractionField(FracField((Symbol('x'), Symbol('y')), QQ, grlex))"