Add files using upload-large-folder tool

pllava/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_basis.py

@@ -0,0 +1,85 @@
+from sympy.abc import x
+from sympy.core import S
+from sympy.core.numbers import AlgebraicNumber
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.domains import QQ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.numberfields.basis import round_two
+from sympy.testing.pytest import raises
+
+
+def test_round_two():
+    # Poly must be irreducible, and over ZZ or QQ:
+    raises(ValueError, lambda: round_two(Poly(x ** 2 - 1)))
+    raises(ValueError, lambda: round_two(Poly(x ** 2 + sqrt(2))))
+
+    # Test on many fields:
+    cases = (
+        # A couple of cyclotomic fields:
+        (cyclotomic_poly(5), DomainMatrix.eye(4, QQ), 125),
+        (cyclotomic_poly(7), DomainMatrix.eye(6, QQ), -16807),
+        # A couple of quadratic fields (one 1 mod 4, one 3 mod 4):
+        (x ** 2 - 5, DM([[1, (1, 2)], [0, (1, 2)]], QQ), 5),
+        (x ** 2 - 7, DM([[1, 0], [0, 1]], QQ), 28),
+        # Dedekind's example of a field with 2 as essential disc divisor:
+        (x ** 3 + x ** 2 - 2 * x + 8, DM([[1, 0, 0], [0, 1, 0], [0, (1, 2), (1, 2)]], QQ).transpose(), -503),
+        # A bunch of cubics with various forms for F -- all of these require
+        # second or third enlargements. (Five of them require a third, while the rest require just a second.)
+        # F = 2^2
+        (x**3 + 3 * x**2 - 4 * x + 4, DM([((1, 2), (1, 4), (1, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), -83),
+        # F = 2^2 * 3
+        (x**3 + 3 * x**2 + 3 * x - 3, DM([((1, 2), 0, (1, 2)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -108),
+        # F = 2^3
+        (x**3 + 5 * x**2 - x + 3, DM([((1, 4), 0, (3, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), -31),
+        # F = 2^2 * 5
+        (x**3 + 5 * x**2 - 5 * x - 5, DM([((1, 2), 0, (1, 2)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), 1300),
+        # F = 3^2
+        (x**3 + 3 * x**2 + 5, DM([((1, 3), (1, 3), (1, 3)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -135),
+        # F = 3^3
+        (x**3 + 6 * x**2 + 3 * x - 1, DM([((1, 3), (1, 3), (1, 3)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), 81),
+        # F = 2^2 * 3^2
+        (x**3 + 6 * x**2 + 4, DM([((1, 3), (2, 3), (1, 3)), (0, 1, 0), (0, 0, (1, 2))], QQ).transpose(), -108),
+        # F = 2^3 * 7
+        (x**3 + 7 * x**2 + 7 * x - 7, DM([((1, 4), 0, (3, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), 49),
+        # F = 2^2 * 13
+        (x**3 + 7 * x**2 - x + 5, DM([((1, 2), 0, (1, 2)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -2028),
+        # F = 2^4
+        (x**3 + 7 * x**2 - 5 * x + 5, DM([((1, 4), 0, (3, 4)), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), -140),
+        # F = 5^2
+        (x**3 + 4 * x**2 - 3 * x + 7, DM([((1, 5), (4, 5), (4, 5)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -175),
+        # F = 7^2
+        (x**3 + 8 * x**2 + 5 * x - 1, DM([((1, 7), (6, 7), (2, 7)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), 49),
+        # F = 2 * 5 * 7
+        (x**3 + 8 * x**2 - 2 * x + 6, DM([(1, 0, 0), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -14700),
+        # F = 2^2 * 3 * 5
+        (x**3 + 6 * x**2 - 3 * x + 8, DM([(1, 0, 0), (0, (1, 4), (1, 4)), (0, 0, 1)], QQ).transpose(), -675),
+        # F = 2 * 3^2 * 7
+        (x**3 + 9 * x**2 + 6 * x - 8, DM([(1, 0, 0), (0, (1, 2), (1, 2)), (0, 0, 1)], QQ).transpose(), 3969),
+        # F = 2^2 * 3^2 * 7
+        (x**3 + 15 * x**2 - 9 * x + 13, DM([((1, 6), (1, 3), (1, 6)), (0, 1, 0), (0, 0, 1)], QQ).transpose(), -5292),
+        # Polynomial need not be monic
+        (5*x**3 + 5*x**2 - 10 * x + 40, DM([[1, 0, 0], [0, 1, 0], [0, (1, 2), (1, 2)]], QQ).transpose(), -503),
+        # Polynomial can have non-integer rational coeffs
+        (QQ(5, 3)*x**3 + QQ(5, 3)*x**2 - QQ(10, 3)*x + QQ(40, 3), DM([[1, 0, 0], [0, 1, 0], [0, (1, 2), (1, 2)]], QQ).transpose(), -503),
+    )
+    for f, B_exp, d_exp in cases:
+        K = QQ.alg_field_from_poly(f)
+        B = K.maximal_order().QQ_matrix
+        d = K.discriminant()
+        assert d == d_exp
+        # The computed basis need not equal the expected one, but their quotient
+        # must be unimodular:
+        assert (B.inv()*B_exp).det()**2 == 1
+
+
+def test_AlgebraicField_integral_basis():
+    alpha = AlgebraicNumber(sqrt(5), alias='alpha')
+    k = QQ.algebraic_field(alpha)
+    B0 = k.integral_basis()
+    B1 = k.integral_basis(fmt='sympy')
+    B2 = k.integral_basis(fmt='alg')
+    assert B0 == [k([1]), k([S.Half, S.Half])]
+    assert B1 == [1, S.Half + alpha/2]
+    assert B2 == [k.ext.field_element([1]),
+                  k.ext.field_element([S.Half, S.Half])]

pllava/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_galoisgroups.py

@@ -0,0 +1,143 @@
+"""Tests for computing Galois groups. """
+
+from sympy.abc import x
+from sympy.combinatorics.galois import (
+    S1TransitiveSubgroups, S2TransitiveSubgroups, S3TransitiveSubgroups,
+    S4TransitiveSubgroups, S5TransitiveSubgroups, S6TransitiveSubgroups,
+)
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.numberfields.galoisgroups import (
+    tschirnhausen_transformation,
+    galois_group,
+    _galois_group_degree_4_root_approx,
+    _galois_group_degree_5_hybrid,
+)
+from sympy.polys.numberfields.subfield import field_isomorphism
+from sympy.polys.polytools import Poly
+from sympy.testing.pytest import raises
+
+
+def test_tschirnhausen_transformation():
+    for T in [
+        Poly(x**2 - 2),
+        Poly(x**2 + x + 1),
+        Poly(x**4 + 1),
+        Poly(x**4 - x**3 + x**2 - x + 1),
+    ]:
+        _, U = tschirnhausen_transformation(T)
+        assert U.degree() == T.degree()
+        assert U.is_monic
+        assert U.is_irreducible
+        K = QQ.alg_field_from_poly(T)
+        L = QQ.alg_field_from_poly(U)
+        assert field_isomorphism(K.ext, L.ext) is not None
+
+
+# Test polys are from:
+# Cohen, H. *A Course in Computational Algebraic Number Theory*.
+test_polys_by_deg = {
+    # Degree 1
+    1: [
+        (x, S1TransitiveSubgroups.S1, True)
+    ],
+    # Degree 2
+    2: [
+        (x**2 + x + 1, S2TransitiveSubgroups.S2, False)
+    ],
+    # Degree 3
+    3: [
+        (x**3 + x**2 - 2*x - 1, S3TransitiveSubgroups.A3, True),
+        (x**3 + 2, S3TransitiveSubgroups.S3, False),
+    ],
+    # Degree 4
+    4: [
+        (x**4 + x**3 + x**2 + x + 1, S4TransitiveSubgroups.C4, False),
+        (x**4 + 1, S4TransitiveSubgroups.V, True),
+        (x**4 - 2, S4TransitiveSubgroups.D4, False),
+        (x**4 + 8*x + 12, S4TransitiveSubgroups.A4, True),
+        (x**4 + x + 1, S4TransitiveSubgroups.S4, False),
+    ],
+    # Degree 5
+    5: [
+        (x**5 + x**4 - 4*x**3 - 3*x**2 + 3*x + 1, S5TransitiveSubgroups.C5, True),
+        (x**5 - 5*x + 12, S5TransitiveSubgroups.D5, True),
+        (x**5 + 2, S5TransitiveSubgroups.M20, False),
+        (x**5 + 20*x + 16, S5TransitiveSubgroups.A5, True),
+        (x**5 - x + 1, S5TransitiveSubgroups.S5, False),
+    ],
+    # Degree 6
+    6: [
+        (x**6 + x**5 + x**4 + x**3 + x**2 + x + 1, S6TransitiveSubgroups.C6, False),
+        (x**6 + 108, S6TransitiveSubgroups.S3, False),
+        (x**6 + 2, S6TransitiveSubgroups.D6, False),
+        (x**6 - 3*x**2 - 1, S6TransitiveSubgroups.A4, True),
+        (x**6 + 3*x**3 + 3, S6TransitiveSubgroups.G18, False),
+        (x**6 - 3*x**2 + 1, S6TransitiveSubgroups.A4xC2, False),
+        (x**6 - 4*x**2 - 1, S6TransitiveSubgroups.S4p, True),
+        (x**6 - 3*x**5 + 6*x**4 - 7*x**3 + 2*x**2 + x - 4, S6TransitiveSubgroups.S4m, False),
+        (x**6 + 2*x**3 - 2, S6TransitiveSubgroups.G36m, False),
+        (x**6 + 2*x**2 + 2, S6TransitiveSubgroups.S4xC2, False),
+        (x**6 + 10*x**5 + 55*x**4 + 140*x**3 + 175*x**2 + 170*x + 25, S6TransitiveSubgroups.PSL2F5, True),
+        (x**6 + 10*x**5 + 55*x**4 + 140*x**3 + 175*x**2 - 3019*x + 25, S6TransitiveSubgroups.PGL2F5, False),
+        (x**6 + 6*x**4 + 2*x**3 + 9*x**2 + 6*x - 4, S6TransitiveSubgroups.G36p, True),
+        (x**6 + 2*x**4 + 2*x**3 + x**2 + 2*x + 2, S6TransitiveSubgroups.G72, False),
+        (x**6 + 24*x - 20, S6TransitiveSubgroups.A6, True),
+        (x**6 + x + 1, S6TransitiveSubgroups.S6, False),
+    ],
+}
+
+
+def test_galois_group():
+    """
+    Try all the test polys.
+    """
+    for deg in range(1, 7):
+        polys = test_polys_by_deg[deg]
+        for T, G, alt in polys:
+            assert galois_group(T, by_name=True) == (G, alt)
+
+
+def test_galois_group_degree_out_of_bounds():
+    raises(ValueError, lambda: galois_group(Poly(0, x)))
+    raises(ValueError, lambda: galois_group(Poly(1, x)))
+    raises(ValueError, lambda: galois_group(Poly(x ** 7 + 1)))
+
+
+def test_galois_group_not_by_name():
+    """
+    Check at least one polynomial of each supported degree, to see that
+    conversion from name to group works.
+    """
+    for deg in range(1, 7):
+        T, G_name, _ = test_polys_by_deg[deg][0]
+        G, _ = galois_group(T)
+        assert G == G_name.get_perm_group()
+
+
+def test_galois_group_not_monic_over_ZZ():
+    """
+    Check that we can work with polys that are not monic over ZZ.
+    """
+    for deg in range(1, 7):
+        T, G, alt = test_polys_by_deg[deg][0]
+        assert galois_group(T/2, by_name=True) == (G, alt)
+
+
+def test__galois_group_degree_4_root_approx():
+    for T, G, alt in test_polys_by_deg[4]:
+        assert _galois_group_degree_4_root_approx(Poly(T)) == (G, alt)
+
+
+def test__galois_group_degree_5_hybrid():
+    for T, G, alt in test_polys_by_deg[5]:
+        assert _galois_group_degree_5_hybrid(Poly(T)) == (G, alt)
+
+
+def test_AlgebraicField_galois_group():
+    k = QQ.alg_field_from_poly(Poly(x**4 + 1))
+    G, _ = k.galois_group(by_name=True)
+    assert G == S4TransitiveSubgroups.V
+
+    k = QQ.alg_field_from_poly(Poly(x**4 - 2))
+    G, _ = k.galois_group(by_name=True)
+    assert G == S4TransitiveSubgroups.D4

pllava/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_minpoly.py

@@ -0,0 +1,474 @@
+"""Tests for minimal polynomials. """
+
+from sympy.core.function import expand
+from sympy.core import (GoldenRatio, TribonacciConstant)
+from sympy.core.numbers import (AlgebraicNumber, I, Rational, oo, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import (cbrt, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.solvers.solveset import nonlinsolve
+from sympy.geometry import Circle, intersection
+from sympy.testing.pytest import raises, slow
+from sympy.sets.sets import FiniteSet
+from sympy.geometry.point import Point2D
+from sympy.polys.numberfields.minpoly import (
+    minimal_polynomial,
+    _choose_factor,
+    _minpoly_op_algebraic_element,
+    _separate_sq,
+    _minpoly_groebner,
+)
+from sympy.polys.partfrac import apart
+from sympy.polys.polyerrors import (
+    NotAlgebraic,
+    GeneratorsError,
+)
+
+from sympy.polys.domains import QQ
+from sympy.polys.rootoftools import rootof
+from sympy.polys.polytools import degree
+
+from sympy.abc import x, y, z
+
+Q = Rational
+
+
+def test_minimal_polynomial():
+    assert minimal_polynomial(-7, x) == x + 7
+    assert minimal_polynomial(-1, x) == x + 1
+    assert minimal_polynomial( 0, x) == x
+    assert minimal_polynomial( 1, x) == x - 1
+    assert minimal_polynomial( 7, x) == x - 7
+
+    assert minimal_polynomial(sqrt(2), x) == x**2 - 2
+    assert minimal_polynomial(sqrt(5), x) == x**2 - 5
+    assert minimal_polynomial(sqrt(6), x) == x**2 - 6
+
+    assert minimal_polynomial(2*sqrt(2), x) == x**2 - 8
+    assert minimal_polynomial(3*sqrt(5), x) == x**2 - 45
+    assert minimal_polynomial(4*sqrt(6), x) == x**2 - 96
+
+    assert minimal_polynomial(2*sqrt(2) + 3, x) == x**2 - 6*x + 1
+    assert minimal_polynomial(3*sqrt(5) + 6, x) == x**2 - 12*x - 9
+    assert minimal_polynomial(4*sqrt(6) + 7, x) == x**2 - 14*x - 47
+
+    assert minimal_polynomial(2*sqrt(2) - 3, x) == x**2 + 6*x + 1
+    assert minimal_polynomial(3*sqrt(5) - 6, x) == x**2 + 12*x - 9
+    assert minimal_polynomial(4*sqrt(6) - 7, x) == x**2 + 14*x - 47
+
+    assert minimal_polynomial(sqrt(1 + sqrt(6)), x) == x**4 - 2*x**2 - 5
+    assert minimal_polynomial(sqrt(I + sqrt(6)), x) == x**8 - 10*x**4 + 49
+
+    assert minimal_polynomial(2*I + sqrt(2 + I), x) == x**4 + 4*x**2 + 8*x + 37
+
+    assert minimal_polynomial(sqrt(2) + sqrt(3), x) == x**4 - 10*x**2 + 1
+    assert minimal_polynomial(
+        sqrt(2) + sqrt(3) + sqrt(6), x) == x**4 - 22*x**2 - 48*x - 23
+
+    a = 1 - 9*sqrt(2) + 7*sqrt(3)
+
+    assert minimal_polynomial(
+        1/a, x) == 392*x**4 - 1232*x**3 + 612*x**2 + 4*x - 1
+    assert minimal_polynomial(
+        1/sqrt(a), x) == 392*x**8 - 1232*x**6 + 612*x**4 + 4*x**2 - 1
+
+    raises(NotAlgebraic, lambda: minimal_polynomial(oo, x))
+    raises(NotAlgebraic, lambda: minimal_polynomial(2**y, x))
+    raises(NotAlgebraic, lambda: minimal_polynomial(sin(1), x))
+
+    assert minimal_polynomial(sqrt(2)).dummy_eq(x**2 - 2)
+    assert minimal_polynomial(sqrt(2), x) == x**2 - 2
+
+    assert minimal_polynomial(sqrt(2), polys=True) == Poly(x**2 - 2)
+    assert minimal_polynomial(sqrt(2), x, polys=True) == Poly(x**2 - 2, domain='QQ')
+    assert minimal_polynomial(sqrt(2), x, polys=True, compose=False) == Poly(x**2 - 2, domain='QQ')
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(3))
+
+    assert minimal_polynomial(a, x) == x**2 - 2
+    assert minimal_polynomial(b, x) == x**2 - 3
+
+    assert minimal_polynomial(a, x, polys=True) == Poly(x**2 - 2, domain='QQ')
+    assert minimal_polynomial(b, x, polys=True) == Poly(x**2 - 3, domain='QQ')
+
+    assert minimal_polynomial(sqrt(a/2 + 17), x) == 2*x**4 - 68*x**2 + 577
+    assert minimal_polynomial(sqrt(b/2 + 17), x) == 4*x**4 - 136*x**2 + 1153
+
+    a, b = sqrt(2)/3 + 7, AlgebraicNumber(sqrt(2)/3 + 7)
+
+    f = 81*x**8 - 2268*x**6 - 4536*x**5 + 22644*x**4 + 63216*x**3 - \
+        31608*x**2 - 189648*x + 141358
+
+    assert minimal_polynomial(sqrt(a) + sqrt(sqrt(a)), x) == f
+    assert minimal_polynomial(sqrt(b) + sqrt(sqrt(b)), x) == f
+
+    assert minimal_polynomial(
+        a**Q(3, 2), x) == 729*x**4 - 506898*x**2 + 84604519
+
+    # issue 5994
+    eq = S('''
+        -1/(800*sqrt(-1/240 + 1/(18000*(-1/17280000 +
+        sqrt(15)*I/28800000)**(1/3)) + 2*(-1/17280000 +
+        sqrt(15)*I/28800000)**(1/3)))''')
+    assert minimal_polynomial(eq, x) == 8000*x**2 - 1
+
+    ex = (sqrt(5)*sqrt(I)/(5*sqrt(1 + 125*I))
+            + 25*sqrt(5)/(I**Q(5,2)*(1 + 125*I)**Q(3,2))
+            + 3125*sqrt(5)/(I**Q(11,2)*(1 + 125*I)**Q(3,2))
+            + 5*I*sqrt(1 - I/125))
+    mp = minimal_polynomial(ex, x)
+    assert mp == 25*x**4 + 5000*x**2 + 250016
+
+    ex = 1 + sqrt(2) + sqrt(3)
+    mp = minimal_polynomial(ex, x)
+    assert mp == x**4 - 4*x**3 - 4*x**2 + 16*x - 8
+
+    ex = 1/(1 + sqrt(2) + sqrt(3))
+    mp = minimal_polynomial(ex, x)
+    assert mp == 8*x**4 - 16*x**3 + 4*x**2 + 4*x - 1
+
+    p = (expand((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3))**Rational(1, 3)
+    mp = minimal_polynomial(p, x)
+    assert mp == x**8 - 8*x**7 - 56*x**6 + 448*x**5 + 480*x**4 - 5056*x**3 + 1984*x**2 + 7424*x - 3008
+    p = expand((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3)
+    mp = minimal_polynomial(p, x)
+    assert mp == x**8 - 512*x**7 - 118208*x**6 + 31131136*x**5 + 647362560*x**4 - 56026611712*x**3 + 116994310144*x**2 + 404854931456*x - 27216576512
+
+    assert minimal_polynomial(S("-sqrt(5)/2 - 1/2 + (-sqrt(5)/2 - 1/2)**2"), x) == x - 1
+    a = 1 + sqrt(2)
+    assert minimal_polynomial((a*sqrt(2) + a)**3, x) == x**2 - 198*x + 1
+
+    p = 1/(1 + sqrt(2) + sqrt(3))
+    assert minimal_polynomial(p, x, compose=False) == 8*x**4 - 16*x**3 + 4*x**2 + 4*x - 1
+
+    p = 2/(1 + sqrt(2) + sqrt(3))
+    assert minimal_polynomial(p, x, compose=False) == x**4 - 4*x**3 + 2*x**2 + 4*x - 2
+
+    assert minimal_polynomial(1 + sqrt(2)*I, x, compose=False) == x**2 - 2*x + 3
+    assert minimal_polynomial(1/(1 + sqrt(2)) + 1, x, compose=False) == x**2 - 2
+    assert minimal_polynomial(sqrt(2)*I + I*(1 + sqrt(2)), x,
+            compose=False) ==  x**4 + 18*x**2 + 49
+
+    # minimal polynomial of I
+    assert minimal_polynomial(I, x, domain=QQ.algebraic_field(I)) == x - I
+    K = QQ.algebraic_field(I*(sqrt(2) + 1))
+    assert minimal_polynomial(I, x, domain=K) == x - I
+    assert minimal_polynomial(I, x, domain=QQ) == x**2 + 1
+    assert minimal_polynomial(I, x, domain='QQ(y)') == x**2 + 1
+
+    #issue 11553
+    assert minimal_polynomial(GoldenRatio, x) == x**2 - x - 1
+    assert minimal_polynomial(TribonacciConstant + 3, x) == x**3 - 10*x**2 + 32*x - 34
+    assert minimal_polynomial(GoldenRatio, x, domain=QQ.algebraic_field(sqrt(5))) == \
+            2*x - sqrt(5) - 1
+    assert minimal_polynomial(TribonacciConstant, x, domain=QQ.algebraic_field(cbrt(19 - 3*sqrt(33)))) == \
+    48*x - 19*(19 - 3*sqrt(33))**Rational(2, 3) - 3*sqrt(33)*(19 - 3*sqrt(33))**Rational(2, 3) \
+    - 16*(19 - 3*sqrt(33))**Rational(1, 3) - 16
+
+    # AlgebraicNumber with an alias.
+    # Wester H24
+    phi = AlgebraicNumber(S.GoldenRatio.expand(func=True), alias='phi')
+    assert minimal_polynomial(phi, x) == x**2 - x - 1
+
+
+def test_minimal_polynomial_issue_19732():
+    # https://github.com/sympy/sympy/issues/19732
+    expr = (-280898097948878450887044002323982963174671632174995451265117559518123750720061943079105185551006003416773064305074191140286225850817291393988597615/(-488144716373031204149459129212782509078221364279079444636386844223983756114492222145074506571622290776245390771587888364089507840000000*sqrt(238368341569)*sqrt(S(11918417078450)/63568729
+    - 24411360*sqrt(238368341569)/63568729) +
+    238326799225996604451373809274348704114327860564921529846705817404208077866956345381951726531296652901169111729944612727047670549086208000000*sqrt(S(11918417078450)/63568729
+        - 24411360*sqrt(238368341569)/63568729)) -
+    180561807339168676696180573852937120123827201075968945871075967679148461189459480842956689723484024031016208588658753107/(-59358007109636562851035004992802812513575019937126272896569856090962677491318275291141463850327474176000000*sqrt(238368341569)*sqrt(S(11918417078450)/63568729
+        - 24411360*sqrt(238368341569)/63568729) +
+        28980348180319251787320809875930301310576055074938369007463004788921613896002936637780993064387310446267596800000*sqrt(S(11918417078450)/63568729
+            - 24411360*sqrt(238368341569)/63568729)))
+    poly = (2151288870990266634727173620565483054187142169311153766675688628985237817262915166497766867289157986631135400926544697981091151416655364879773546003475813114962656742744975460025956167152918469472166170500512008351638710934022160294849059721218824490226159355197136265032810944357335461128949781377875451881300105989490353140886315677977149440000000000000000000000*x**4
+            - 5773274155644072033773937864114266313663195672820501581692669271302387257492905909558846459600429795784309388968498783843631580008547382703258503404023153694528041873101120067477617592651525155101107144042679962433039557235772239171616433004024998230222455940044709064078962397144550855715640331680262171410099614469231080995436488414164502751395405398078353242072696360734131090111239998110773292915337556205692674790561090109440000000000000*x**2
+            + 211295968822207088328287206509522887719741955693091053353263782924470627623790749534705683380138972642560898936171035770539616881000369889020398551821767092685775598633794696371561234818461806577723412581353857653829324364446419444210520602157621008010129702779407422072249192199762604318993590841636967747488049176548615614290254356975376588506729604345612047361483789518445332415765213187893207704958013682516462853001964919444736320672860140355089)
+    assert minimal_polynomial(expr, x) == poly
+
+
+def test_minimal_polynomial_hi_prec():
+    p = 1/sqrt(1 - 9*sqrt(2) + 7*sqrt(3) + Rational(1, 10)**30)
+    mp = minimal_polynomial(p, x)
+    # checked with Wolfram Alpha
+    assert mp.coeff(x**6) == -1232000000000000000000000000001223999999999999999999999999999987999999999999999999999999999996000000000000000000000000000000
+
+
+def test_minimal_polynomial_sq():
+    from sympy.core.add import Add
+    from sympy.core.function import expand_multinomial
+    p = expand_multinomial((1 + 5*sqrt(2) + 2*sqrt(3))**3)
+    mp = minimal_polynomial(p**Rational(1, 3), x)
+    assert mp == x**4 - 4*x**3 - 118*x**2 + 244*x + 1321
+    p = expand_multinomial((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3)
+    mp = minimal_polynomial(p**Rational(1, 3), x)
+    assert mp == x**8 - 8*x**7 - 56*x**6 + 448*x**5 + 480*x**4 - 5056*x**3 + 1984*x**2 + 7424*x - 3008
+    p = Add(*[sqrt(i) for i in range(1, 12)])
+    mp = minimal_polynomial(p, x)
+    assert mp.subs({x: 0}) == -71965773323122507776
+
+
+def test_minpoly_compose():
+    # issue 6868
+    eq = S('''
+        -1/(800*sqrt(-1/240 + 1/(18000*(-1/17280000 +
+        sqrt(15)*I/28800000)**(1/3)) + 2*(-1/17280000 +
+        sqrt(15)*I/28800000)**(1/3)))''')
+    mp = minimal_polynomial(eq + 3, x)
+    assert mp == 8000*x**2 - 48000*x + 71999
+
+    # issue 5888
+    assert minimal_polynomial(exp(I*pi/8), x) == x**8 + 1
+
+    mp = minimal_polynomial(sin(pi/7) + sqrt(2), x)
+    assert mp == 4096*x**12 - 63488*x**10 + 351488*x**8 - 826496*x**6 + \
+        770912*x**4 - 268432*x**2 + 28561
+    mp = minimal_polynomial(cos(pi/7) + sqrt(2), x)
+    assert mp == 64*x**6 - 64*x**5 - 432*x**4 + 304*x**3 + 712*x**2 - \
+            232*x - 239
+    mp = minimal_polynomial(exp(I*pi/7) + sqrt(2), x)
+    assert mp == x**12 - 2*x**11 - 9*x**10 + 16*x**9 + 43*x**8 - 70*x**7 - 97*x**6 + 126*x**5 + 211*x**4 - 212*x**3 - 37*x**2 + 142*x + 127
+
+    mp = minimal_polynomial(sin(pi/7) + sqrt(2), x)
+    assert mp == 4096*x**12 - 63488*x**10 + 351488*x**8 - 826496*x**6 + \
+        770912*x**4 - 268432*x**2 + 28561
+    mp = minimal_polynomial(cos(pi/7) + sqrt(2), x)
+    assert mp == 64*x**6 - 64*x**5 - 432*x**4 + 304*x**3 + 712*x**2 - \
+            232*x - 239
+    mp = minimal_polynomial(exp(I*pi/7) + sqrt(2), x)
+    assert mp == x**12 - 2*x**11 - 9*x**10 + 16*x**9 + 43*x**8 - 70*x**7 - 97*x**6 + 126*x**5 + 211*x**4 - 212*x**3 - 37*x**2 + 142*x + 127
+
+    mp = minimal_polynomial(exp(I*pi*Rational(2, 7)), x)
+    assert mp == x**6 + x**5 + x**4 + x**3 + x**2 + x + 1
+    mp = minimal_polynomial(exp(I*pi*Rational(2, 15)), x)
+    assert mp == x**8 - x**7 + x**5 - x**4 + x**3 - x + 1
+    mp = minimal_polynomial(cos(pi*Rational(2, 7)), x)
+    assert mp == 8*x**3 + 4*x**2 - 4*x - 1
+    mp = minimal_polynomial(sin(pi*Rational(2, 7)), x)
+    ex = (5*cos(pi*Rational(2, 7)) - 7)/(9*cos(pi/7) - 5*cos(pi*Rational(3, 7)))
+    mp = minimal_polynomial(ex, x)
+    assert mp == x**3 + 2*x**2 - x - 1
+    assert minimal_polynomial(-1/(2*cos(pi/7)), x) == x**3 + 2*x**2 - x - 1
+    assert minimal_polynomial(sin(pi*Rational(2, 15)), x) == \
+            256*x**8 - 448*x**6 + 224*x**4 - 32*x**2 + 1
+    assert minimal_polynomial(sin(pi*Rational(5, 14)), x) == 8*x**3 - 4*x**2 - 4*x + 1
+    assert minimal_polynomial(cos(pi/15), x) == 16*x**4 + 8*x**3 - 16*x**2 - 8*x + 1
+
+    ex = rootof(x**3 +x*4 + 1, 0)
+    mp = minimal_polynomial(ex, x)
+    assert mp == x**3 + 4*x + 1
+    mp = minimal_polynomial(ex + 1, x)
+    assert mp == x**3 - 3*x**2 + 7*x - 4
+    assert minimal_polynomial(exp(I*pi/3), x) == x**2 - x + 1
+    assert minimal_polynomial(exp(I*pi/4), x) == x**4 + 1
+    assert minimal_polynomial(exp(I*pi/6), x) == x**4 - x**2 + 1
+    assert minimal_polynomial(exp(I*pi/9), x) == x**6 - x**3 + 1
+    assert minimal_polynomial(exp(I*pi/10), x) == x**8 - x**6 + x**4 - x**2 + 1
+    assert minimal_polynomial(sin(pi/9), x) == 64*x**6 - 96*x**4 + 36*x**2 - 3
+    assert minimal_polynomial(sin(pi/11), x) == 1024*x**10 - 2816*x**8 + \
+            2816*x**6 - 1232*x**4 + 220*x**2 - 11
+    assert minimal_polynomial(sin(pi/21), x) == 4096*x**12 - 11264*x**10 + \
+           11264*x**8 - 4992*x**6 + 960*x**4 - 64*x**2 + 1
+    assert minimal_polynomial(cos(pi/9), x) == 8*x**3 - 6*x - 1
+
+    ex = 2**Rational(1, 3)*exp(2*I*pi/3)
+    assert minimal_polynomial(ex, x) == x**3 - 2
+
+    raises(NotAlgebraic, lambda: minimal_polynomial(cos(pi*sqrt(2)), x))
+    raises(NotAlgebraic, lambda: minimal_polynomial(sin(pi*sqrt(2)), x))
+    raises(NotAlgebraic, lambda: minimal_polynomial(exp(1.618*I*pi), x))
+    raises(NotAlgebraic, lambda: minimal_polynomial(exp(I*pi*sqrt(2)), x))
+
+    # issue 5934
+    ex = 1/(-36000 - 7200*sqrt(5) + (12*sqrt(10)*sqrt(sqrt(5) + 5) +
+        24*sqrt(10)*sqrt(-sqrt(5) + 5))**2) + 1
+    raises(ZeroDivisionError, lambda: minimal_polynomial(ex, x))
+
+    ex = sqrt(1 + 2**Rational(1,3)) + sqrt(1 + 2**Rational(1,4)) + sqrt(2)
+    mp = minimal_polynomial(ex, x)
+    assert degree(mp) == 48 and mp.subs({x:0}) == -16630256576
+
+    ex = tan(pi/5, evaluate=False)
+    mp = minimal_polynomial(ex, x)
+    assert mp == x**4 - 10*x**2 + 5
+    assert mp.subs(x, tan(pi/5)).is_zero
+
+    ex = tan(pi/6, evaluate=False)
+    mp = minimal_polynomial(ex, x)
+    assert mp == 3*x**2 - 1
+    assert mp.subs(x, tan(pi/6)).is_zero
+
+    ex = tan(pi/10, evaluate=False)
+    mp = minimal_polynomial(ex, x)
+    assert mp == 5*x**4 - 10*x**2 + 1
+    assert mp.subs(x, tan(pi/10)).is_zero
+
+    raises(NotAlgebraic, lambda: minimal_polynomial(tan(pi*sqrt(2)), x))
+
+
+def test_minpoly_issue_7113():
+    # see discussion in https://github.com/sympy/sympy/pull/2234
+    from sympy.simplify.simplify import nsimplify
+    r = nsimplify(pi, tolerance=0.000000001)
+    mp = minimal_polynomial(r, x)
+    assert mp == 1768292677839237920489538677417507171630859375*x**109 - \
+    2734577732179183863586489182929671773182898498218854181690460140337930774573792597743853652058046464
+
+
+def test_minpoly_issue_23677():
+    r1 = CRootOf(4000000*x**3 - 239960000*x**2 + 4782399900*x - 31663998001, 0)
+    r2 = CRootOf(4000000*x**3 - 239960000*x**2 + 4782399900*x - 31663998001, 1)
+    num = (7680000000000000000*r1**4*r2**4 - 614323200000000000000*r1**4*r2**3
+            + 18458112576000000000000*r1**4*r2**2 - 246896663036160000000000*r1**4*r2
+            + 1240473830323209600000000*r1**4 - 614323200000000000000*r1**3*r2**4
+            - 1476464424954240000000000*r1**3*r2**2 - 99225501687553535904000000*r1**3
+            + 18458112576000000000000*r1**2*r2**4 - 1476464424954240000000000*r1**2*r2**3
+            - 593391458458356671712000000*r1**2*r2 + 2981354896834339226880720000*r1**2
+            - 246896663036160000000000*r1*r2**4 - 593391458458356671712000000*r1*r2**2
+            - 39878756418031796275267195200*r1 + 1240473830323209600000000*r2**4
+            - 99225501687553535904000000*r2**3 + 2981354896834339226880720000*r2**2 -
+            39878756418031796275267195200*r2 + 200361370275616536577343808012)
+    mp = (x**3 + 59426520028417434406408556687919*x**2 +
+        1161475464966574421163316896737773190861975156439163671112508400*x +
+        7467465541178623874454517208254940823818304424383315270991298807299003671748074773558707779600)
+    assert minimal_polynomial(num, x) == mp
+
+
+def test_minpoly_issue_7574():
+    ex = -(-1)**Rational(1, 3) + (-1)**Rational(2,3)
+    assert minimal_polynomial(ex, x) == x + 1
+
+
+def test_choose_factor():
+    # Test that this does not enter an infinite loop:
+    bad_factors = [Poly(x-2, x), Poly(x+2, x)]
+    raises(NotImplementedError, lambda: _choose_factor(bad_factors, x, sqrt(3)))
+
+
+def test_minpoly_fraction_field():
+    assert minimal_polynomial(1/x, y) == -x*y + 1
+    assert minimal_polynomial(1 / (x + 1), y) == (x + 1)*y - 1
+
+    assert minimal_polynomial(sqrt(x), y) == y**2 - x
+    assert minimal_polynomial(sqrt(x + 1), y) == y**2 - x - 1
+    assert minimal_polynomial(sqrt(x) / x, y) == x*y**2 - 1
+    assert minimal_polynomial(sqrt(2) * sqrt(x), y) == y**2 - 2 * x
+    assert minimal_polynomial(sqrt(2) + sqrt(x), y) == \
+        y**4 + (-2*x - 4)*y**2 + x**2 - 4*x + 4
+
+    assert minimal_polynomial(x**Rational(1,3), y) == y**3 - x
+    assert minimal_polynomial(x**Rational(1,3) + sqrt(x), y) == \
+        y**6 - 3*x*y**4 - 2*x*y**3 + 3*x**2*y**2 - 6*x**2*y - x**3 + x**2
+
+    assert minimal_polynomial(sqrt(x) / z, y) == z**2*y**2 - x
+    assert minimal_polynomial(sqrt(x) / (z + 1), y) == (z**2 + 2*z + 1)*y**2 - x
+
+    assert minimal_polynomial(1/x, y, polys=True) == Poly(-x*y + 1, y, domain='ZZ(x)')
+    assert minimal_polynomial(1 / (x + 1), y, polys=True) == \
+        Poly((x + 1)*y - 1, y, domain='ZZ(x)')
+    assert minimal_polynomial(sqrt(x), y, polys=True) == Poly(y**2 - x, y, domain='ZZ(x)')
+    assert minimal_polynomial(sqrt(x) / z, y, polys=True) == \
+        Poly(z**2*y**2 - x, y, domain='ZZ(x, z)')
+
+    # this is (sqrt(1 + x**3)/x).integrate(x).diff(x) - sqrt(1 + x**3)/x
+    a = sqrt(x)/sqrt(1 + x**(-3)) - sqrt(x**3 + 1)/x + 1/(x**Rational(5, 2)* \
+        (1 + x**(-3))**Rational(3, 2)) + 1/(x**Rational(11, 2)*(1 + x**(-3))**Rational(3, 2))
+
+    assert minimal_polynomial(a, y) == y
+
+    raises(NotAlgebraic, lambda: minimal_polynomial(exp(x), y))
+    raises(GeneratorsError, lambda: minimal_polynomial(sqrt(x), x))
+    raises(GeneratorsError, lambda: minimal_polynomial(sqrt(x) - y, x))
+    raises(NotImplementedError, lambda: minimal_polynomial(sqrt(x), y, compose=False))
+
+@slow
+def test_minpoly_fraction_field_slow():
+    assert minimal_polynomial(minimal_polynomial(sqrt(x**Rational(1,5) - 1),
+        y).subs(y, sqrt(x**Rational(1,5) - 1)), z) == z
+
+def test_minpoly_domain():
+    assert minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2))) == \
+        x - sqrt(2)
+    assert minimal_polynomial(sqrt(8), x, domain=QQ.algebraic_field(sqrt(2))) == \
+        x - 2*sqrt(2)
+    assert minimal_polynomial(sqrt(Rational(3,2)), x,
+        domain=QQ.algebraic_field(sqrt(2))) == 2*x**2 - 3
+
+    raises(NotAlgebraic, lambda: minimal_polynomial(y, x, domain=QQ))
+
+
+def test_issue_14831():
+    a = -2*sqrt(2)*sqrt(12*sqrt(2) + 17)
+    assert minimal_polynomial(a, x) == x**2 + 16*x - 8
+    e = (-3*sqrt(12*sqrt(2) + 17) + 12*sqrt(2) +
+         17 - 2*sqrt(2)*sqrt(12*sqrt(2) + 17))
+    assert minimal_polynomial(e, x) == x
+
+
+def test_issue_18248():
+    assert nonlinsolve([x*y**3-sqrt(2)/3, x*y**6-4/(9*(sqrt(3)))],x,y) == \
+            FiniteSet((sqrt(3)/2, sqrt(6)/3), (sqrt(3)/2, -sqrt(6)/6 - sqrt(2)*I/2),
+            (sqrt(3)/2, -sqrt(6)/6 + sqrt(2)*I/2))
+
+
+def test_issue_13230():
+    c1 = Circle(Point2D(3, sqrt(5)), 5)
+    c2 = Circle(Point2D(4, sqrt(7)), 6)
+    assert intersection(c1, c2) == [Point2D(-1 + (-sqrt(7) + sqrt(5))*(-2*sqrt(7)/29
+    + 9*sqrt(5)/29 + sqrt(196*sqrt(35) + 1941)/29), -2*sqrt(7)/29 + 9*sqrt(5)/29
+    + sqrt(196*sqrt(35) + 1941)/29), Point2D(-1 + (-sqrt(7) + sqrt(5))*(-sqrt(196*sqrt(35)
+    + 1941)/29 - 2*sqrt(7)/29 + 9*sqrt(5)/29), -sqrt(196*sqrt(35) + 1941)/29 - 2*sqrt(7)/29 + 9*sqrt(5)/29)]
+
+def test_issue_19760():
+    e = 1/(sqrt(1 + sqrt(2)) - sqrt(2)*sqrt(1 + sqrt(2))) + 1
+    mp_expected = x**4 - 4*x**3 + 4*x**2 - 2
+
+    for comp in (True, False):
+        mp = Poly(minimal_polynomial(e, compose=comp))
+        assert mp(x) == mp_expected, "minimal_polynomial(e, compose=%s) = %s; %s expected" % (comp, mp(x), mp_expected)
+
+
+def test_issue_20163():
+    assert apart(1/(x**6+1), extension=[sqrt(3), I]) == \
+        (sqrt(3) + I)/(2*x + sqrt(3) + I)/6 + \
+        (sqrt(3) - I)/(2*x + sqrt(3) - I)/6 - \
+        (sqrt(3) - I)/(2*x - sqrt(3) + I)/6 - \
+        (sqrt(3) + I)/(2*x - sqrt(3) - I)/6 + \
+        I/(x + I)/6 - I/(x - I)/6
+
+
+def test_issue_22559():
+    alpha = AlgebraicNumber(sqrt(2))
+    assert minimal_polynomial(alpha**3, x) == x**2 - 8
+
+
+def test_issue_22561():
+    a = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1) / 2, 0, S(-9) / 2, 0], gen=x)
+    assert a.as_expr() == sqrt(2)
+    assert minimal_polynomial(a, x) == x**2 - 2
+    assert minimal_polynomial(a**3, x) == x**2 - 8
+
+
+def test_separate_sq_not_impl():
+    raises(NotImplementedError, lambda: _separate_sq(x**(S(1)/3) + x))
+
+
+def test_minpoly_op_algebraic_element_not_impl():
+    raises(NotImplementedError,
+           lambda: _minpoly_op_algebraic_element(Pow, sqrt(2), sqrt(3), x, QQ))
+
+
+def test_minpoly_groebner():
+    assert _minpoly_groebner(S(2)/3, x, Poly) == 3*x - 2
+    assert _minpoly_groebner(
+        (sqrt(2) + 3)*(sqrt(2) + 1), x, Poly) == x**2 - 10*x - 7
+    assert _minpoly_groebner((sqrt(2) + 3)**(S(1)/3)*(sqrt(2) + 1)**(S(1)/3),
+                             x, Poly) == x**6 - 10*x**3 - 7
+    assert _minpoly_groebner((sqrt(2) + 3)**(-S(1)/3)*(sqrt(2) + 1)**(S(1)/3),
+                             x, Poly) == 7*x**6 - 2*x**3 - 1
+    raises(NotAlgebraic, lambda: _minpoly_groebner(pi**2, x, Poly))

pllava/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_numbers.py

@@ -0,0 +1,202 @@
+"""Tests on algebraic numbers. """
+
+from sympy.core.containers import Tuple
+from sympy.core.numbers import (AlgebraicNumber, I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.polytools import Poly
+from sympy.polys.numberfields.subfield import to_number_field
+from sympy.polys.polyclasses import DMP
+from sympy.polys.domains import QQ
+from sympy.polys.rootoftools import CRootOf
+from sympy.abc import x, y
+
+
+def test_AlgebraicNumber():
+    minpoly, root = x**2 - 2, sqrt(2)
+
+    a = AlgebraicNumber(root, gen=x)
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert a.coeffs() == [S.One, S.Zero]
+    assert a.native_coeffs() == [QQ(1), QQ(0)]
+
+    a = AlgebraicNumber(root, gen=x, alias='y')
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias == Symbol('y')
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is True
+
+    a = AlgebraicNumber(root, gen=x, alias=Symbol('y'))
+
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+    assert a.root == root
+    assert a.alias == Symbol('y')
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is True
+
+    assert AlgebraicNumber(sqrt(2), []).rep == DMP([], QQ)
+    assert AlgebraicNumber(sqrt(2), ()).rep == DMP([], QQ)
+    assert AlgebraicNumber(sqrt(2), (0, 0)).rep == DMP([], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [8]).rep == DMP([QQ(8)], QQ)
+    assert AlgebraicNumber(sqrt(2), [Rational(8, 3)]).rep == DMP([QQ(8, 3)], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [7, 3]).rep == DMP([QQ(7), QQ(3)], QQ)
+    assert AlgebraicNumber(
+        sqrt(2), [Rational(7, 9), Rational(3, 2)]).rep == DMP([QQ(7, 9), QQ(3, 2)], QQ)
+
+    assert AlgebraicNumber(sqrt(2), [1, 2, 3]).rep == DMP([QQ(2), QQ(5)], QQ)
+
+    a = AlgebraicNumber(AlgebraicNumber(root, gen=x), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert a.coeffs() == [S.One, S(2)]
+    assert a.native_coeffs() == [QQ(1), QQ(2)]
+
+    a = AlgebraicNumber((minpoly, root), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    a = AlgebraicNumber((Poly(minpoly), root), [1, 2])
+
+    assert a.rep == DMP([QQ(1), QQ(2)], QQ)
+    assert a.root == root
+    assert a.alias is None
+    assert a.minpoly == minpoly
+    assert a.is_number
+
+    assert a.is_aliased is False
+
+    assert AlgebraicNumber( sqrt(3)).rep == DMP([ QQ(1), QQ(0)], QQ)
+    assert AlgebraicNumber(-sqrt(3)).rep == DMP([ QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(2))
+
+    assert a == b
+
+    c = AlgebraicNumber(sqrt(2), gen=x)
+
+    assert a == b
+    assert a == c
+
+    a = AlgebraicNumber(sqrt(2), [1, 2])
+    b = AlgebraicNumber(sqrt(2), [1, 3])
+
+    assert a != b and a != sqrt(2) + 3
+
+    assert (a == x) is False and (a != x) is True
+
+    a = AlgebraicNumber(sqrt(2), [1, 0])
+    b = AlgebraicNumber(sqrt(2), [1, 0], alias=y)
+
+    assert a.as_poly(x) == Poly(x, domain='QQ')
+    assert b.as_poly() == Poly(y, domain='QQ')
+
+    assert a.as_expr() == sqrt(2)
+    assert a.as_expr(x) == x
+    assert b.as_expr() == sqrt(2)
+    assert b.as_expr(x) == x
+
+    a = AlgebraicNumber(sqrt(2), [2, 3])
+    b = AlgebraicNumber(sqrt(2), [2, 3], alias=y)
+
+    p = a.as_poly()
+
+    assert p == Poly(2*p.gen + 3)
+
+    assert a.as_poly(x) == Poly(2*x + 3, domain='QQ')
+    assert b.as_poly() == Poly(2*y + 3, domain='QQ')
+
+    assert a.as_expr() == 2*sqrt(2) + 3
+    assert a.as_expr(x) == 2*x + 3
+    assert b.as_expr() == 2*sqrt(2) + 3
+    assert b.as_expr(x) == 2*x + 3
+
+    a = AlgebraicNumber(sqrt(2))
+    b = to_number_field(sqrt(2))
+    assert a.args == b.args == (sqrt(2), Tuple(1, 0))
+    b = AlgebraicNumber(sqrt(2), alias='alpha')
+    assert b.args == (sqrt(2), Tuple(1, 0), Symbol('alpha'))
+
+    a = AlgebraicNumber(sqrt(2), [1, 2, 3])
+    assert a.args == (sqrt(2), Tuple(1, 2, 3))
+
+    a = AlgebraicNumber(sqrt(2), [1, 2], "alpha")
+    b = AlgebraicNumber(a)
+    c = AlgebraicNumber(a, alias="gamma")
+    assert a == b
+    assert c.alias.name == "gamma"
+
+    a = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1)/2, 0, S(-9)/2, 0])
+    b = AlgebraicNumber(a, [1, 0, 0])
+    assert b.root == a.root
+    assert a.to_root() == sqrt(2)
+    assert b.to_root() == 2
+
+    a = AlgebraicNumber(2)
+    assert a.is_primitive_element is True
+
+
+def test_to_algebraic_integer():
+    a = AlgebraicNumber(sqrt(3), gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 3
+    assert a.root == sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(2*sqrt(3), gen=x).to_algebraic_integer()
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(3)/2, gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(1), QQ(0)], QQ)
+
+    a = AlgebraicNumber(sqrt(3)/2, [Rational(7, 19), 3], gen=x).to_algebraic_integer()
+
+    assert a.minpoly == x**2 - 12
+    assert a.root == 2*sqrt(3)
+    assert a.rep == DMP([QQ(7, 19), QQ(3)], QQ)
+
+
+def test_AlgebraicNumber_to_root():
+    assert AlgebraicNumber(sqrt(2)).to_root() == sqrt(2)
+
+    zeta5_squared = AlgebraicNumber(CRootOf(x**5 - 1, 4), coeffs=[1, 0, 0])
+    assert zeta5_squared.to_root() == CRootOf(x**4 + x**3 + x**2 + x + 1, 1)
+
+    zeta3_squared = AlgebraicNumber(CRootOf(x**3 - 1, 2), coeffs=[1, 0, 0])
+    assert zeta3_squared.to_root() == -S(1)/2 - sqrt(3)*I/2
+    assert zeta3_squared.to_root(radicals=False) == CRootOf(x**2 + x + 1, 0)

pllava/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_primes.py

@@ -0,0 +1,296 @@
+from math import prod
+
+from sympy import QQ, ZZ
+from sympy.abc import x, theta
+from sympy.ntheory import factorint
+from sympy.ntheory.residue_ntheory import n_order
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.matrices import DomainMatrix
+from sympy.polys.numberfields.basis import round_two
+from sympy.polys.numberfields.exceptions import StructureError
+from sympy.polys.numberfields.modules import PowerBasis, to_col
+from sympy.polys.numberfields.primes import (
+    prime_decomp, _two_elt_rep,
+    _check_formal_conditions_for_maximal_order,
+)
+from sympy.testing.pytest import raises
+
+
+def test_check_formal_conditions_for_maximal_order():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = A.submodule_from_matrix(DomainMatrix.eye(4, ZZ)[:, :-1])
+    # Is a direct submodule of a power basis, but lacks 1 as first generator:
+    raises(StructureError, lambda: _check_formal_conditions_for_maximal_order(B))
+    # Is not a direct submodule of a power basis:
+    raises(StructureError, lambda: _check_formal_conditions_for_maximal_order(C))
+    # Is direct submod of pow basis, and starts with 1, but not sq/max rank/HNF:
+    raises(StructureError, lambda: _check_formal_conditions_for_maximal_order(D))
+
+
+def test_two_elt_rep():
+    ell = 7
+    T = Poly(cyclotomic_poly(ell))
+    ZK, dK = round_two(T)
+    for p in [29, 13, 11, 5]:
+        P = prime_decomp(p, T)
+        for Pi in P:
+            # We have Pi in two-element representation, and, because we are
+            # looking at a cyclotomic field, this was computed by the "easy"
+            # method that just factors T mod p. We will now convert this to
+            # a set of Z-generators, then convert that back into a two-element
+            # rep. The latter need not be identical to the two-elt rep we
+            # already have, but it must have the same HNF.
+            H = p*ZK + Pi.alpha*ZK
+            gens = H.basis_element_pullbacks()
+            # Note: we could supply f = Pi.f, but prefer to test behavior without it.
+            b = _two_elt_rep(gens, ZK, p)
+            if b != Pi.alpha:
+                H2 = p*ZK + b*ZK
+                assert H2 == H
+
+
+def test_valuation_at_prime_ideal():
+    p = 7
+    T = Poly(cyclotomic_poly(p))
+    ZK, dK = round_two(T)
+    P = prime_decomp(p, T, dK=dK, ZK=ZK)
+    assert len(P) == 1
+    P0 = P[0]
+    v = P0.valuation(p*ZK)
+    assert v == P0.e
+    # Test easy 0 case:
+    assert P0.valuation(5*ZK) == 0
+
+
+def test_decomp_1():
+    # All prime decompositions in cyclotomic fields are in the "easy case,"
+    # since the index is unity.
+    # Here we check the ramified prime.
+    T = Poly(cyclotomic_poly(7))
+    raises(ValueError, lambda: prime_decomp(7))
+    P = prime_decomp(7, T)
+    assert len(P) == 1
+    P0 = P[0]
+    assert P0.e == 6
+    assert P0.f == 1
+    # Test powers:
+    assert P0**0 == P0.ZK
+    assert P0**1 == P0
+    assert P0**6 == 7 * P0.ZK
+
+
+def test_decomp_2():
+    # More easy cyclotomic cases, but here we check unramified primes.
+    ell = 7
+    T = Poly(cyclotomic_poly(ell))
+    for p in [29, 13, 11, 5]:
+        f_exp = n_order(p, ell)
+        g_exp = (ell - 1) // f_exp
+        P = prime_decomp(p, T)
+        assert len(P) == g_exp
+        for Pi in P:
+            assert Pi.e == 1
+            assert Pi.f == f_exp
+
+
+def test_decomp_3():
+    T = Poly(x ** 2 - 35)
+    rad = {}
+    ZK, dK = round_two(T, radicals=rad)
+    # 35 is 3 mod 4, so field disc is 4*5*7, and theory says each of the
+    # rational primes 2, 5, 7 should be the square of a prime ideal.
+    for p in [2, 5, 7]:
+        P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+        assert len(P) == 1
+        assert P[0].e == 2
+        assert P[0]**2 == p*ZK
+
+
+def test_decomp_4():
+    T = Poly(x ** 2 - 21)
+    rad = {}
+    ZK, dK = round_two(T, radicals=rad)
+    # 21 is 1 mod 4, so field disc is 3*7, and theory says the
+    # rational primes 3, 7 should be the square of a prime ideal.
+    for p in [3, 7]:
+        P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+        assert len(P) == 1
+        assert P[0].e == 2
+        assert P[0]**2 == p*ZK
+
+
+def test_decomp_5():
+    # Here is our first test of the "hard case" of prime decomposition.
+    # We work in a quadratic extension Q(sqrt(d)) where d is 1 mod 4, and
+    # we consider the factorization of the rational prime 2, which divides
+    # the index.
+    # Theory says the form of p's factorization depends on the residue of
+    # d mod 8, so we consider both cases, d = 1 mod 8 and d = 5 mod 8.
+    for d in [-7, -3]:
+        T = Poly(x ** 2 - d)
+        rad = {}
+        ZK, dK = round_two(T, radicals=rad)
+        p = 2
+        P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+        if d % 8 == 1:
+            assert len(P) == 2
+            assert all(P[i].e == 1 and P[i].f == 1 for i in range(2))
+            assert prod(Pi**Pi.e for Pi in P) == p * ZK
+        else:
+            assert d % 8 == 5
+            assert len(P) == 1
+            assert P[0].e == 1
+            assert P[0].f == 2
+            assert P[0].as_submodule() == p * ZK
+
+
+def test_decomp_6():
+    # Another case where 2 divides the index. This is Dedekind's example of
+    # an essential discriminant divisor. (See Cohen, Exercise 6.10.)
+    T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    rad = {}
+    ZK, dK = round_two(T, radicals=rad)
+    p = 2
+    P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=rad.get(p))
+    assert len(P) == 3
+    assert all(Pi.e == Pi.f == 1 for Pi in P)
+    assert prod(Pi**Pi.e for Pi in P) == p*ZK
+
+
+def test_decomp_7():
+    # Try working through an AlgebraicField
+    T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    K = QQ.alg_field_from_poly(T)
+    p = 2
+    P = K.primes_above(p)
+    ZK = K.maximal_order()
+    assert len(P) == 3
+    assert all(Pi.e == Pi.f == 1 for Pi in P)
+    assert prod(Pi**Pi.e for Pi in P) == p*ZK
+
+
+def test_decomp_8():
+    # This time we consider various cubics, and try factoring all primes
+    # dividing the index.
+    cases = (
+        x ** 3 + 3 * x ** 2 - 4 * x + 4,
+        x ** 3 + 3 * x ** 2 + 3 * x - 3,
+        x ** 3 + 5 * x ** 2 - x + 3,
+        x ** 3 + 5 * x ** 2 - 5 * x - 5,
+        x ** 3 + 3 * x ** 2 + 5,
+        x ** 3 + 6 * x ** 2 + 3 * x - 1,
+        x ** 3 + 6 * x ** 2 + 4,
+        x ** 3 + 7 * x ** 2 + 7 * x - 7,
+        x ** 3 + 7 * x ** 2 - x + 5,
+        x ** 3 + 7 * x ** 2 - 5 * x + 5,
+        x ** 3 + 4 * x ** 2 - 3 * x + 7,
+        x ** 3 + 8 * x ** 2 + 5 * x - 1,
+        x ** 3 + 8 * x ** 2 - 2 * x + 6,
+        x ** 3 + 6 * x ** 2 - 3 * x + 8,
+        x ** 3 + 9 * x ** 2 + 6 * x - 8,
+        x ** 3 + 15 * x ** 2 - 9 * x + 13,
+    )
+    def display(T, p, radical, P, I, J):
+        """Useful for inspection, when running test manually."""
+        print('=' * 20)
+        print(T, p, radical)
+        for Pi in P:
+            print(f'  ({Pi!r})')
+        print("I: ", I)
+        print("J: ", J)
+        print(f'Equal: {I == J}')
+    inspect = False
+    for g in cases:
+        T = Poly(g)
+        rad = {}
+        ZK, dK = round_two(T, radicals=rad)
+        dT = T.discriminant()
+        f_squared = dT // dK
+        F = factorint(f_squared)
+        for p in F:
+            radical = rad.get(p)
+            P = prime_decomp(p, T, dK=dK, ZK=ZK, radical=radical)
+            I = prod(Pi**Pi.e for Pi in P)
+            J = p * ZK
+            if inspect:
+                display(T, p, radical, P, I, J)
+            assert I == J
+
+
+def test_PrimeIdeal_eq():
+    # `==` should fail on objects of different types, so even a completely
+    # inert PrimeIdeal should test unequal to the rational prime it divides.
+    T = Poly(cyclotomic_poly(7))
+    P0 = prime_decomp(5, T)[0]
+    assert P0.f == 6
+    assert P0.as_submodule() == 5 * P0.ZK
+    assert P0 != 5
+
+
+def test_PrimeIdeal_add():
+    T = Poly(cyclotomic_poly(7))
+    P0 = prime_decomp(7, T)[0]
+    # Adding ideals computes their GCD, so adding the ramified prime dividing
+    # 7 to 7 itself should reproduce this prime (as a submodule).
+    assert P0 + 7 * P0.ZK == P0.as_submodule()
+
+
+def test_str():
+    # Without alias:
+    k = QQ.alg_field_from_poly(Poly(x**2 + 7))
+    frp = k.primes_above(2)[0]
+    assert str(frp) == '(2, 3*_x/2 + 1/2)'
+
+    frp = k.primes_above(3)[0]
+    assert str(frp) == '(3)'
+
+    # With alias:
+    k = QQ.alg_field_from_poly(Poly(x ** 2 + 7), alias='alpha')
+    frp = k.primes_above(2)[0]
+    assert str(frp) == '(2, 3*alpha/2 + 1/2)'
+
+    frp = k.primes_above(3)[0]
+    assert str(frp) == '(3)'
+
+
+def test_repr():
+    T = Poly(x**2 + 7)
+    ZK, dK = round_two(T)
+    P = prime_decomp(2, T, dK=dK, ZK=ZK)
+    assert repr(P[0]) == '[ (2, (3*x + 1)/2) e=1, f=1 ]'
+    assert P[0].repr(field_gen=theta) == '[ (2, (3*theta + 1)/2) e=1, f=1 ]'
+    assert P[0].repr(field_gen=theta, just_gens=True) == '(2, (3*theta + 1)/2)'
+
+
+def test_PrimeIdeal_reduce():
+    k = QQ.alg_field_from_poly(Poly(x ** 3 + x ** 2 - 2 * x + 8))
+    Zk = k.maximal_order()
+    P = k.primes_above(2)
+    frp = P[2]
+
+    # reduce_element
+    a = Zk.parent(to_col([23, 20, 11]), denom=6)
+    a_bar_expected = Zk.parent(to_col([11, 5, 2]), denom=6)
+    a_bar = frp.reduce_element(a)
+    assert a_bar == a_bar_expected
+
+    # reduce_ANP
+    a = k([QQ(11, 6), QQ(20, 6), QQ(23, 6)])
+    a_bar_expected = k([QQ(2, 6), QQ(5, 6), QQ(11, 6)])
+    a_bar = frp.reduce_ANP(a)
+    assert a_bar == a_bar_expected
+
+    # reduce_alg_num
+    a = k.to_alg_num(a)
+    a_bar_expected = k.to_alg_num(a_bar_expected)
+    a_bar = frp.reduce_alg_num(a)
+    assert a_bar == a_bar_expected
+
+
+def test_issue_23402():
+    k = QQ.alg_field_from_poly(Poly(x ** 3 + x ** 2 - 2 * x + 8))
+    P = k.primes_above(3)
+    assert P[0].alpha.equiv(0)

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_appellseqs.py

@@ -0,0 +1,91 @@
+"""Tests for efficient functions for generating Appell sequences."""
+from sympy.core.numbers import Rational as Q
+from sympy.polys.polytools import Poly
+from sympy.testing.pytest import raises
+from sympy.polys.appellseqs import (bernoulli_poly, bernoulli_c_poly,
+    euler_poly, genocchi_poly, andre_poly)
+from sympy.abc import x
+
+def test_bernoulli_poly():
+    raises(ValueError, lambda: bernoulli_poly(-1, x))
+    assert bernoulli_poly(1, x, polys=True) == Poly(x - Q(1,2))
+
+    assert bernoulli_poly(0, x) == 1
+    assert bernoulli_poly(1, x) == x - Q(1,2)
+    assert bernoulli_poly(2, x) == x**2 - x + Q(1,6)
+    assert bernoulli_poly(3, x) == x**3 - Q(3,2)*x**2 + Q(1,2)*x
+    assert bernoulli_poly(4, x) == x**4 - 2*x**3 + x**2 - Q(1,30)
+    assert bernoulli_poly(5, x) == x**5 - Q(5,2)*x**4 + Q(5,3)*x**3 - Q(1,6)*x
+    assert bernoulli_poly(6, x) == x**6 - 3*x**5 + Q(5,2)*x**4 - Q(1,2)*x**2 + Q(1,42)
+
+    assert bernoulli_poly(1).dummy_eq(x - Q(1,2))
+    assert bernoulli_poly(1, polys=True) == Poly(x - Q(1,2))
+
+def test_bernoulli_c_poly():
+    raises(ValueError, lambda: bernoulli_c_poly(-1, x))
+    assert bernoulli_c_poly(1, x, polys=True) == Poly(x, domain='QQ')
+
+    assert bernoulli_c_poly(0, x) == 1
+    assert bernoulli_c_poly(1, x) == x
+    assert bernoulli_c_poly(2, x) == x**2 - Q(1,3)
+    assert bernoulli_c_poly(3, x) == x**3 - x
+    assert bernoulli_c_poly(4, x) == x**4 - 2*x**2 + Q(7,15)
+    assert bernoulli_c_poly(5, x) == x**5 - Q(10,3)*x**3 + Q(7,3)*x
+    assert bernoulli_c_poly(6, x) == x**6 - 5*x**4 + 7*x**2 - Q(31,21)
+
+    assert bernoulli_c_poly(1).dummy_eq(x)
+    assert bernoulli_c_poly(1, polys=True) == Poly(x, domain='QQ')
+
+    assert 2**8 * bernoulli_poly(8, (x+1)/2).expand() == bernoulli_c_poly(8, x)
+    assert 2**9 * bernoulli_poly(9, (x+1)/2).expand() == bernoulli_c_poly(9, x)
+
+def test_genocchi_poly():
+    raises(ValueError, lambda: genocchi_poly(-1, x))
+    assert genocchi_poly(2, x, polys=True) == Poly(-2*x + 1)
+
+    assert genocchi_poly(0, x) == 0
+    assert genocchi_poly(1, x) == -1
+    assert genocchi_poly(2, x) == 1 - 2*x
+    assert genocchi_poly(3, x) == 3*x - 3*x**2
+    assert genocchi_poly(4, x) == -1 + 6*x**2 - 4*x**3
+    assert genocchi_poly(5, x) == -5*x + 10*x**3 - 5*x**4
+    assert genocchi_poly(6, x) == 3 - 15*x**2 + 15*x**4 - 6*x**5
+
+    assert genocchi_poly(2).dummy_eq(-2*x + 1)
+    assert genocchi_poly(2, polys=True) == Poly(-2*x + 1)
+
+    assert 2 * (bernoulli_poly(8, x) - bernoulli_c_poly(8, x)) == genocchi_poly(8, x)
+    assert 2 * (bernoulli_poly(9, x) - bernoulli_c_poly(9, x)) == genocchi_poly(9, x)
+
+def test_euler_poly():
+    raises(ValueError, lambda: euler_poly(-1, x))
+    assert euler_poly(1, x, polys=True) == Poly(x - Q(1,2))
+
+    assert euler_poly(0, x) == 1
+    assert euler_poly(1, x) == x - Q(1,2)
+    assert euler_poly(2, x) == x**2 - x
+    assert euler_poly(3, x) == x**3 - Q(3,2)*x**2 + Q(1,4)
+    assert euler_poly(4, x) == x**4 - 2*x**3 + x
+    assert euler_poly(5, x) == x**5 - Q(5,2)*x**4 + Q(5,2)*x**2 - Q(1,2)
+    assert euler_poly(6, x) == x**6 - 3*x**5 + 5*x**3 - 3*x
+
+    assert euler_poly(1).dummy_eq(x - Q(1,2))
+    assert euler_poly(1, polys=True) == Poly(x - Q(1,2))
+
+    assert genocchi_poly(9, x) == euler_poly(8, x) * -9
+    assert genocchi_poly(10, x) == euler_poly(9, x) * -10
+
+def test_andre_poly():
+    raises(ValueError, lambda: andre_poly(-1, x))
+    assert andre_poly(1, x, polys=True) == Poly(x)
+
+    assert andre_poly(0, x) == 1
+    assert andre_poly(1, x) == x
+    assert andre_poly(2, x) == x**2 - 1
+    assert andre_poly(3, x) == x**3 - 3*x
+    assert andre_poly(4, x) == x**4 - 6*x**2 + 5
+    assert andre_poly(5, x) == x**5 - 10*x**3 + 25*x
+    assert andre_poly(6, x) == x**6 - 15*x**4 + 75*x**2 - 61
+
+    assert andre_poly(1).dummy_eq(x)
+    assert andre_poly(1, polys=True) == Poly(x)

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_constructor.py

@@ -0,0 +1,208 @@
+"""Tests for tools for constructing domains for expressions. """
+
+from sympy.polys.constructor import construct_domain
+from sympy.polys.domains import ZZ, QQ, ZZ_I, QQ_I, RR, CC, EX
+from sympy.polys.domains.realfield import RealField
+from sympy.polys.domains.complexfield import ComplexField
+
+from sympy.core import (Catalan, GoldenRatio)
+from sympy.core.numbers import (E, Float, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.abc import x, y
+
+
+def test_construct_domain():
+
+    assert construct_domain([1, 2, 3]) == (ZZ, [ZZ(1), ZZ(2), ZZ(3)])
+    assert construct_domain([1, 2, 3], field=True) == (QQ, [QQ(1), QQ(2), QQ(3)])
+
+    assert construct_domain([S.One, S(2), S(3)]) == (ZZ, [ZZ(1), ZZ(2), ZZ(3)])
+    assert construct_domain([S.One, S(2), S(3)], field=True) == (QQ, [QQ(1), QQ(2), QQ(3)])
+
+    assert construct_domain([S.Half, S(2)]) == (QQ, [QQ(1, 2), QQ(2)])
+    result = construct_domain([3.14, 1, S.Half])
+    assert isinstance(result[0], RealField)
+    assert result[1] == [RR(3.14), RR(1.0), RR(0.5)]
+
+    result = construct_domain([3.14, I, S.Half])
+    assert isinstance(result[0], ComplexField)
+    assert result[1] == [CC(3.14), CC(1.0j), CC(0.5)]
+
+    assert construct_domain([1.0+I]) == (CC, [CC(1.0, 1.0)])
+    assert construct_domain([2.0+3.0*I]) == (CC, [CC(2.0, 3.0)])
+
+    assert construct_domain([1, I]) == (ZZ_I, [ZZ_I(1, 0), ZZ_I(0, 1)])
+    assert construct_domain([1, I/2]) == (QQ_I, [QQ_I(1, 0), QQ_I(0, S.Half)])
+
+    assert construct_domain([3.14, sqrt(2)], extension=None) == (EX, [EX(3.14), EX(sqrt(2))])
+    assert construct_domain([3.14, sqrt(2)], extension=True) == (EX, [EX(3.14), EX(sqrt(2))])
+
+    assert construct_domain([1, sqrt(2)], extension=None) == (EX, [EX(1), EX(sqrt(2))])
+
+    assert construct_domain([x, sqrt(x)]) == (EX, [EX(x), EX(sqrt(x))])
+    assert construct_domain([x, sqrt(x), sqrt(y)]) == (EX, [EX(x), EX(sqrt(x)), EX(sqrt(y))])
+
+    alg = QQ.algebraic_field(sqrt(2))
+
+    assert construct_domain([7, S.Half, sqrt(2)], extension=True) == \
+        (alg, [alg.convert(7), alg.convert(S.Half), alg.convert(sqrt(2))])
+
+    alg = QQ.algebraic_field(sqrt(2) + sqrt(3))
+
+    assert construct_domain([7, sqrt(2), sqrt(3)], extension=True) == \
+        (alg, [alg.convert(7), alg.convert(sqrt(2)), alg.convert(sqrt(3))])
+
+    dom = ZZ[x]
+
+    assert construct_domain([2*x, 3]) == \
+        (dom, [dom.convert(2*x), dom.convert(3)])
+
+    dom = ZZ[x, y]
+
+    assert construct_domain([2*x, 3*y]) == \
+        (dom, [dom.convert(2*x), dom.convert(3*y)])
+
+    dom = QQ[x]
+
+    assert construct_domain([x/2, 3]) == \
+        (dom, [dom.convert(x/2), dom.convert(3)])
+
+    dom = QQ[x, y]
+
+    assert construct_domain([x/2, 3*y]) == \
+        (dom, [dom.convert(x/2), dom.convert(3*y)])
+
+    dom = ZZ_I[x]
+
+    assert construct_domain([2*x, I]) == \
+        (dom, [dom.convert(2*x), dom.convert(I)])
+
+    dom = ZZ_I[x, y]
+
+    assert construct_domain([2*x, I*y]) == \
+        (dom, [dom.convert(2*x), dom.convert(I*y)])
+
+    dom = QQ_I[x]
+
+    assert construct_domain([x/2, I]) == \
+        (dom, [dom.convert(x/2), dom.convert(I)])
+
+    dom = QQ_I[x, y]
+
+    assert construct_domain([x/2, I*y]) == \
+        (dom, [dom.convert(x/2), dom.convert(I*y)])
+
+    dom = RR[x]
+
+    assert construct_domain([x/2, 3.5]) == \
+        (dom, [dom.convert(x/2), dom.convert(3.5)])
+
+    dom = RR[x, y]
+
+    assert construct_domain([x/2, 3.5*y]) == \
+        (dom, [dom.convert(x/2), dom.convert(3.5*y)])
+
+    dom = CC[x]
+
+    assert construct_domain([I*x/2, 3.5]) == \
+        (dom, [dom.convert(I*x/2), dom.convert(3.5)])
+
+    dom = CC[x, y]
+
+    assert construct_domain([I*x/2, 3.5*y]) == \
+        (dom, [dom.convert(I*x/2), dom.convert(3.5*y)])
+
+    dom = CC[x]
+
+    assert construct_domain([x/2, I*3.5]) == \
+        (dom, [dom.convert(x/2), dom.convert(I*3.5)])
+
+    dom = CC[x, y]
+
+    assert construct_domain([x/2, I*3.5*y]) == \
+        (dom, [dom.convert(x/2), dom.convert(I*3.5*y)])
+
+    dom = ZZ.frac_field(x)
+
+    assert construct_domain([2/x, 3]) == \
+        (dom, [dom.convert(2/x), dom.convert(3)])
+
+    dom = ZZ.frac_field(x, y)
+
+    assert construct_domain([2/x, 3*y]) == \
+        (dom, [dom.convert(2/x), dom.convert(3*y)])
+
+    dom = RR.frac_field(x)
+
+    assert construct_domain([2/x, 3.5]) == \
+        (dom, [dom.convert(2/x), dom.convert(3.5)])
+
+    dom = RR.frac_field(x, y)
+
+    assert construct_domain([2/x, 3.5*y]) == \
+        (dom, [dom.convert(2/x), dom.convert(3.5*y)])
+
+    dom = RealField(prec=336)[x]
+
+    assert construct_domain([pi.evalf(100)*x]) == \
+        (dom, [dom.convert(pi.evalf(100)*x)])
+
+    assert construct_domain(2) == (ZZ, ZZ(2))
+    assert construct_domain(S(2)/3) == (QQ, QQ(2, 3))
+    assert construct_domain(Rational(2, 3)) == (QQ, QQ(2, 3))
+
+    assert construct_domain({}) == (ZZ, {})
+
+
+def test_complex_exponential():
+    w = exp(-I*2*pi/3, evaluate=False)
+    alg = QQ.algebraic_field(w)
+    assert construct_domain([w**2, w, 1], extension=True) == (
+        alg,
+        [alg.convert(w**2),
+         alg.convert(w),
+         alg.convert(1)]
+    )
+
+
+def test_composite_option():
+    assert construct_domain({(1,): sin(y)}, composite=False) == \
+        (EX, {(1,): EX(sin(y))})
+
+    assert construct_domain({(1,): y}, composite=False) == \
+        (EX, {(1,): EX(y)})
+
+    assert construct_domain({(1, 1): 1}, composite=False) == \
+        (ZZ, {(1, 1): 1})
+
+    assert construct_domain({(1, 0): y}, composite=False) == \
+        (EX, {(1, 0): EX(y)})
+
+
+def test_precision():
+    f1 = Float("1.01")
+    f2 = Float("1.0000000000000000000001")
+    for u in [1, 1e-2, 1e-6, 1e-13, 1e-14, 1e-16, 1e-20, 1e-100, 1e-300,
+            f1, f2]:
+        result = construct_domain([u])
+        v = float(result[1][0])
+        assert abs(u - v) / u < 1e-14  # Test relative accuracy
+
+    result = construct_domain([f1])
+    y = result[1][0]
+    assert y-1 > 1e-50
+
+    result = construct_domain([f2])
+    y = result[1][0]
+    assert y-1 > 1e-50
+
+
+def test_issue_11538():
+    for n in [E, pi, Catalan]:
+        assert construct_domain(n)[0] == ZZ[n]
+        assert construct_domain(x + n)[0] == ZZ[x, n]
+    assert construct_domain(GoldenRatio)[0] == EX
+    assert construct_domain(x + GoldenRatio)[0] == EX

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_densearith.py

@@ -0,0 +1,997 @@
+"""Tests for dense recursive polynomials' arithmetics. """
+
+from sympy.external.gmpy import GROUND_TYPES
+
+from sympy.polys.densebasic import (
+    dup_normal, dmp_normal,
+)
+
+from sympy.polys.densearith import (
+    dup_add_term, dmp_add_term,
+    dup_sub_term, dmp_sub_term,
+    dup_mul_term, dmp_mul_term,
+    dup_add_ground, dmp_add_ground,
+    dup_sub_ground, dmp_sub_ground,
+    dup_mul_ground, dmp_mul_ground,
+    dup_quo_ground, dmp_quo_ground,
+    dup_exquo_ground, dmp_exquo_ground,
+    dup_lshift, dup_rshift,
+    dup_abs, dmp_abs,
+    dup_neg, dmp_neg,
+    dup_add, dmp_add,
+    dup_sub, dmp_sub,
+    dup_mul, dmp_mul,
+    dup_sqr, dmp_sqr,
+    dup_pow, dmp_pow,
+    dup_add_mul, dmp_add_mul,
+    dup_sub_mul, dmp_sub_mul,
+    dup_pdiv, dup_prem, dup_pquo, dup_pexquo,
+    dmp_pdiv, dmp_prem, dmp_pquo, dmp_pexquo,
+    dup_rr_div, dmp_rr_div,
+    dup_ff_div, dmp_ff_div,
+    dup_div, dup_rem, dup_quo, dup_exquo,
+    dmp_div, dmp_rem, dmp_quo, dmp_exquo,
+    dup_max_norm, dmp_max_norm,
+    dup_l1_norm, dmp_l1_norm,
+    dup_l2_norm_squared, dmp_l2_norm_squared,
+    dup_expand, dmp_expand,
+)
+
+from sympy.polys.polyerrors import (
+    ExactQuotientFailed,
+)
+
+from sympy.polys.specialpolys import f_polys
+from sympy.polys.domains import FF, ZZ, QQ
+
+from sympy.testing.pytest import raises
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = [ f.to_dense() for f in f_polys() ]
+F_0 = dmp_mul_ground(dmp_normal(f_0, 2, QQ), QQ(1, 7), 2, QQ)
+
+def test_dup_add_term():
+    f = dup_normal([], ZZ)
+
+    assert dup_add_term(f, ZZ(0), 0, ZZ) == dup_normal([], ZZ)
+
+    assert dup_add_term(f, ZZ(1), 0, ZZ) == dup_normal([1], ZZ)
+    assert dup_add_term(f, ZZ(1), 1, ZZ) == dup_normal([1, 0], ZZ)
+    assert dup_add_term(f, ZZ(1), 2, ZZ) == dup_normal([1, 0, 0], ZZ)
+
+    f = dup_normal([1, 1, 1], ZZ)
+
+    assert dup_add_term(f, ZZ(1), 0, ZZ) == dup_normal([1, 1, 2], ZZ)
+    assert dup_add_term(f, ZZ(1), 1, ZZ) == dup_normal([1, 2, 1], ZZ)
+    assert dup_add_term(f, ZZ(1), 2, ZZ) == dup_normal([2, 1, 1], ZZ)
+
+    assert dup_add_term(f, ZZ(1), 3, ZZ) == dup_normal([1, 1, 1, 1], ZZ)
+    assert dup_add_term(f, ZZ(1), 4, ZZ) == dup_normal([1, 0, 1, 1, 1], ZZ)
+    assert dup_add_term(f, ZZ(1), 5, ZZ) == dup_normal([1, 0, 0, 1, 1, 1], ZZ)
+    assert dup_add_term(
+        f, ZZ(1), 6, ZZ) == dup_normal([1, 0, 0, 0, 1, 1, 1], ZZ)
+
+    assert dup_add_term(f, ZZ(-1), 2, ZZ) == dup_normal([1, 1], ZZ)
+
+
+def test_dmp_add_term():
+    assert dmp_add_term([ZZ(1), ZZ(1), ZZ(1)], ZZ(1), 2, 0, ZZ) == \
+        dup_add_term([ZZ(1), ZZ(1), ZZ(1)], ZZ(1), 2, ZZ)
+    assert dmp_add_term(f_0, [[]], 3, 2, ZZ) == f_0
+    assert dmp_add_term(F_0, [[]], 3, 2, QQ) == F_0
+
+
+def test_dup_sub_term():
+    f = dup_normal([], ZZ)
+
+    assert dup_sub_term(f, ZZ(0), 0, ZZ) == dup_normal([], ZZ)
+
+    assert dup_sub_term(f, ZZ(1), 0, ZZ) == dup_normal([-1], ZZ)
+    assert dup_sub_term(f, ZZ(1), 1, ZZ) == dup_normal([-1, 0], ZZ)
+    assert dup_sub_term(f, ZZ(1), 2, ZZ) == dup_normal([-1, 0, 0], ZZ)
+
+    f = dup_normal([1, 1, 1], ZZ)
+
+    assert dup_sub_term(f, ZZ(2), 0, ZZ) == dup_normal([ 1, 1, -1], ZZ)
+    assert dup_sub_term(f, ZZ(2), 1, ZZ) == dup_normal([ 1, -1, 1], ZZ)
+    assert dup_sub_term(f, ZZ(2), 2, ZZ) == dup_normal([-1, 1, 1], ZZ)
+
+    assert dup_sub_term(f, ZZ(1), 3, ZZ) == dup_normal([-1, 1, 1, 1], ZZ)
+    assert dup_sub_term(f, ZZ(1), 4, ZZ) == dup_normal([-1, 0, 1, 1, 1], ZZ)
+    assert dup_sub_term(f, ZZ(1), 5, ZZ) == dup_normal([-1, 0, 0, 1, 1, 1], ZZ)
+    assert dup_sub_term(
+        f, ZZ(1), 6, ZZ) == dup_normal([-1, 0, 0, 0, 1, 1, 1], ZZ)
+
+    assert dup_sub_term(f, ZZ(1), 2, ZZ) == dup_normal([1, 1], ZZ)
+
+
+def test_dmp_sub_term():
+    assert dmp_sub_term([ZZ(1), ZZ(1), ZZ(1)], ZZ(1), 2, 0, ZZ) == \
+        dup_sub_term([ZZ(1), ZZ(1), ZZ(1)], ZZ(1), 2, ZZ)
+    assert dmp_sub_term(f_0, [[]], 3, 2, ZZ) == f_0
+    assert dmp_sub_term(F_0, [[]], 3, 2, QQ) == F_0
+
+
+def test_dup_mul_term():
+    f = dup_normal([], ZZ)
+
+    assert dup_mul_term(f, ZZ(2), 3, ZZ) == dup_normal([], ZZ)
+
+    f = dup_normal([1, 1], ZZ)
+
+    assert dup_mul_term(f, ZZ(0), 3, ZZ) == dup_normal([], ZZ)
+
+    f = dup_normal([1, 2, 3], ZZ)
+
+    assert dup_mul_term(f, ZZ(2), 0, ZZ) == dup_normal([2, 4, 6], ZZ)
+    assert dup_mul_term(f, ZZ(2), 1, ZZ) == dup_normal([2, 4, 6, 0], ZZ)
+    assert dup_mul_term(f, ZZ(2), 2, ZZ) == dup_normal([2, 4, 6, 0, 0], ZZ)
+    assert dup_mul_term(f, ZZ(2), 3, ZZ) == dup_normal([2, 4, 6, 0, 0, 0], ZZ)
+
+
+def test_dmp_mul_term():
+    assert dmp_mul_term([ZZ(1), ZZ(2), ZZ(3)], ZZ(2), 1, 0, ZZ) == \
+        dup_mul_term([ZZ(1), ZZ(2), ZZ(3)], ZZ(2), 1, ZZ)
+
+    assert dmp_mul_term([[]], [ZZ(2)], 3, 1, ZZ) == [[]]
+    assert dmp_mul_term([[ZZ(1)]], [], 3, 1, ZZ) == [[]]
+
+    assert dmp_mul_term([[ZZ(1), ZZ(2)], [ZZ(3)]], [ZZ(2)], 2, 1, ZZ) == \
+        [[ZZ(2), ZZ(4)], [ZZ(6)], [], []]
+
+    assert dmp_mul_term([[]], [QQ(2, 3)], 3, 1, QQ) == [[]]
+    assert dmp_mul_term([[QQ(1, 2)]], [], 3, 1, QQ) == [[]]
+
+    assert dmp_mul_term([[QQ(1, 5), QQ(2, 5)], [QQ(3, 5)]], [QQ(2, 3)], 2, 1, QQ) == \
+        [[QQ(2, 15), QQ(4, 15)], [QQ(6, 15)], [], []]
+
+
+def test_dup_add_ground():
+    f = ZZ.map([1, 2, 3, 4])
+    g = ZZ.map([1, 2, 3, 8])
+
+    assert dup_add_ground(f, ZZ(4), ZZ) == g
+
+
+def test_dmp_add_ground():
+    f = ZZ.map([[1], [2], [3], [4]])
+    g = ZZ.map([[1], [2], [3], [8]])
+
+    assert dmp_add_ground(f, ZZ(4), 1, ZZ) == g
+
+
+def test_dup_sub_ground():
+    f = ZZ.map([1, 2, 3, 4])
+    g = ZZ.map([1, 2, 3, 0])
+
+    assert dup_sub_ground(f, ZZ(4), ZZ) == g
+
+
+def test_dmp_sub_ground():
+    f = ZZ.map([[1], [2], [3], [4]])
+    g = ZZ.map([[1], [2], [3], []])
+
+    assert dmp_sub_ground(f, ZZ(4), 1, ZZ) == g
+
+
+def test_dup_mul_ground():
+    f = dup_normal([], ZZ)
+
+    assert dup_mul_ground(f, ZZ(2), ZZ) == dup_normal([], ZZ)
+
+    f = dup_normal([1, 2, 3], ZZ)
+
+    assert dup_mul_ground(f, ZZ(0), ZZ) == dup_normal([], ZZ)
+    assert dup_mul_ground(f, ZZ(2), ZZ) == dup_normal([2, 4, 6], ZZ)
+
+
+def test_dmp_mul_ground():
+    assert dmp_mul_ground(f_0, ZZ(2), 2, ZZ) == [
+        [[ZZ(2), ZZ(4), ZZ(6)], [ZZ(4)]],
+        [[ZZ(6)]],
+        [[ZZ(8), ZZ(10), ZZ(12)], [ZZ(2), ZZ(4), ZZ(2)], [ZZ(2)]]
+    ]
+
+    assert dmp_mul_ground(F_0, QQ(1, 2), 2, QQ) == [
+        [[QQ(1, 14), QQ(2, 14), QQ(3, 14)], [QQ(2, 14)]],
+        [[QQ(3, 14)]],
+        [[QQ(4, 14), QQ(5, 14), QQ(6, 14)], [QQ(1, 14), QQ(2, 14),
+             QQ(1, 14)], [QQ(1, 14)]]
+    ]
+
+
+def test_dup_quo_ground():
+    raises(ZeroDivisionError, lambda: dup_quo_ground(dup_normal([1, 2,
+           3], ZZ), ZZ(0), ZZ))
+
+    f = dup_normal([], ZZ)
+
+    assert dup_quo_ground(f, ZZ(3), ZZ) == dup_normal([], ZZ)
+
+    f = dup_normal([6, 2, 8], ZZ)
+
+    assert dup_quo_ground(f, ZZ(1), ZZ) == f
+    assert dup_quo_ground(f, ZZ(2), ZZ) == dup_normal([3, 1, 4], ZZ)
+
+    assert dup_quo_ground(f, ZZ(3), ZZ) == dup_normal([2, 0, 2], ZZ)
+
+    f = dup_normal([6, 2, 8], QQ)
+
+    assert dup_quo_ground(f, QQ(1), QQ) == f
+    assert dup_quo_ground(f, QQ(2), QQ) == [QQ(3), QQ(1), QQ(4)]
+    assert dup_quo_ground(f, QQ(7), QQ) == [QQ(6, 7), QQ(2, 7), QQ(8, 7)]
+
+
+def test_dup_exquo_ground():
+    raises(ZeroDivisionError, lambda: dup_exquo_ground(dup_normal([1,
+           2, 3], ZZ), ZZ(0), ZZ))
+    raises(ExactQuotientFailed, lambda: dup_exquo_ground(dup_normal([1,
+           2, 3], ZZ), ZZ(3), ZZ))
+
+    f = dup_normal([], ZZ)
+
+    assert dup_exquo_ground(f, ZZ(3), ZZ) == dup_normal([], ZZ)
+
+    f = dup_normal([6, 2, 8], ZZ)
+
+    assert dup_exquo_ground(f, ZZ(1), ZZ) == f
+    assert dup_exquo_ground(f, ZZ(2), ZZ) == dup_normal([3, 1, 4], ZZ)
+
+    f = dup_normal([6, 2, 8], QQ)
+
+    assert dup_exquo_ground(f, QQ(1), QQ) == f
+    assert dup_exquo_ground(f, QQ(2), QQ) == [QQ(3), QQ(1), QQ(4)]
+    assert dup_exquo_ground(f, QQ(7), QQ) == [QQ(6, 7), QQ(2, 7), QQ(8, 7)]
+
+
+def test_dmp_quo_ground():
+    f = dmp_normal([[6], [2], [8]], 1, ZZ)
+
+    assert dmp_quo_ground(f, ZZ(1), 1, ZZ) == f
+    assert dmp_quo_ground(
+        f, ZZ(2), 1, ZZ) == dmp_normal([[3], [1], [4]], 1, ZZ)
+
+    assert dmp_normal(dmp_quo_ground(
+        f, ZZ(3), 1, ZZ), 1, ZZ) == dmp_normal([[2], [], [2]], 1, ZZ)
+
+
+def test_dmp_exquo_ground():
+    f = dmp_normal([[6], [2], [8]], 1, ZZ)
+
+    assert dmp_exquo_ground(f, ZZ(1), 1, ZZ) == f
+    assert dmp_exquo_ground(
+        f, ZZ(2), 1, ZZ) == dmp_normal([[3], [1], [4]], 1, ZZ)
+
+
+def test_dup_lshift():
+    assert dup_lshift([], 3, ZZ) == []
+    assert dup_lshift([1], 3, ZZ) == [1, 0, 0, 0]
+
+
+def test_dup_rshift():
+    assert dup_rshift([], 3, ZZ) == []
+    assert dup_rshift([1, 0, 0, 0], 3, ZZ) == [1]
+
+
+def test_dup_abs():
+    assert dup_abs([], ZZ) == []
+    assert dup_abs([ZZ( 1)], ZZ) == [ZZ(1)]
+    assert dup_abs([ZZ(-7)], ZZ) == [ZZ(7)]
+    assert dup_abs([ZZ(-1), ZZ(2), ZZ(3)], ZZ) == [ZZ(1), ZZ(2), ZZ(3)]
+
+    assert dup_abs([], QQ) == []
+    assert dup_abs([QQ( 1, 2)], QQ) == [QQ(1, 2)]
+    assert dup_abs([QQ(-7, 3)], QQ) == [QQ(7, 3)]
+    assert dup_abs(
+        [QQ(-1, 7), QQ(2, 7), QQ(3, 7)], QQ) == [QQ(1, 7), QQ(2, 7), QQ(3, 7)]
+
+
+def test_dmp_abs():
+    assert dmp_abs([ZZ(-1)], 0, ZZ) == [ZZ(1)]
+    assert dmp_abs([QQ(-1, 2)], 0, QQ) == [QQ(1, 2)]
+
+    assert dmp_abs([[[]]], 2, ZZ) == [[[]]]
+    assert dmp_abs([[[ZZ(1)]]], 2, ZZ) == [[[ZZ(1)]]]
+    assert dmp_abs([[[ZZ(-7)]]], 2, ZZ) == [[[ZZ(7)]]]
+
+    assert dmp_abs([[[]]], 2, QQ) == [[[]]]
+    assert dmp_abs([[[QQ(1, 2)]]], 2, QQ) == [[[QQ(1, 2)]]]
+    assert dmp_abs([[[QQ(-7, 9)]]], 2, QQ) == [[[QQ(7, 9)]]]
+
+
+def test_dup_neg():
+    assert dup_neg([], ZZ) == []
+    assert dup_neg([ZZ(1)], ZZ) == [ZZ(-1)]
+    assert dup_neg([ZZ(-7)], ZZ) == [ZZ(7)]
+    assert dup_neg([ZZ(-1), ZZ(2), ZZ(3)], ZZ) == [ZZ(1), ZZ(-2), ZZ(-3)]
+
+    assert dup_neg([], QQ) == []
+    assert dup_neg([QQ(1, 2)], QQ) == [QQ(-1, 2)]
+    assert dup_neg([QQ(-7, 9)], QQ) == [QQ(7, 9)]
+    assert dup_neg([QQ(
+        -1, 7), QQ(2, 7), QQ(3, 7)], QQ) == [QQ(1, 7), QQ(-2, 7), QQ(-3, 7)]
+
+
+def test_dmp_neg():
+    assert dmp_neg([ZZ(-1)], 0, ZZ) == [ZZ(1)]
+    assert dmp_neg([QQ(-1, 2)], 0, QQ) == [QQ(1, 2)]
+
+    assert dmp_neg([[[]]], 2, ZZ) == [[[]]]
+    assert dmp_neg([[[ZZ(1)]]], 2, ZZ) == [[[ZZ(-1)]]]
+    assert dmp_neg([[[ZZ(-7)]]], 2, ZZ) == [[[ZZ(7)]]]
+
+    assert dmp_neg([[[]]], 2, QQ) == [[[]]]
+    assert dmp_neg([[[QQ(1, 9)]]], 2, QQ) == [[[QQ(-1, 9)]]]
+    assert dmp_neg([[[QQ(-7, 9)]]], 2, QQ) == [[[QQ(7, 9)]]]
+
+
+def test_dup_add():
+    assert dup_add([], [], ZZ) == []
+    assert dup_add([ZZ(1)], [], ZZ) == [ZZ(1)]
+    assert dup_add([], [ZZ(1)], ZZ) == [ZZ(1)]
+    assert dup_add([ZZ(1)], [ZZ(1)], ZZ) == [ZZ(2)]
+    assert dup_add([ZZ(1)], [ZZ(2)], ZZ) == [ZZ(3)]
+
+    assert dup_add([ZZ(1), ZZ(2)], [ZZ(1)], ZZ) == [ZZ(1), ZZ(3)]
+    assert dup_add([ZZ(1)], [ZZ(1), ZZ(2)], ZZ) == [ZZ(1), ZZ(3)]
+
+    assert dup_add([ZZ(1), ZZ(
+        2), ZZ(3)], [ZZ(8), ZZ(9), ZZ(10)], ZZ) == [ZZ(9), ZZ(11), ZZ(13)]
+
+    assert dup_add([], [], QQ) == []
+    assert dup_add([QQ(1, 2)], [], QQ) == [QQ(1, 2)]
+    assert dup_add([], [QQ(1, 2)], QQ) == [QQ(1, 2)]
+    assert dup_add([QQ(1, 4)], [QQ(1, 4)], QQ) == [QQ(1, 2)]
+    assert dup_add([QQ(1, 4)], [QQ(1, 2)], QQ) == [QQ(3, 4)]
+
+    assert dup_add([QQ(1, 2), QQ(2, 3)], [QQ(1)], QQ) == [QQ(1, 2), QQ(5, 3)]
+    assert dup_add([QQ(1)], [QQ(1, 2), QQ(2, 3)], QQ) == [QQ(1, 2), QQ(5, 3)]
+
+    assert dup_add([QQ(1, 7), QQ(2, 7), QQ(3, 7)], [QQ(
+        8, 7), QQ(9, 7), QQ(10, 7)], QQ) == [QQ(9, 7), QQ(11, 7), QQ(13, 7)]
+
+
+def test_dmp_add():
+    assert dmp_add([ZZ(1), ZZ(2)], [ZZ(1)], 0, ZZ) == \
+        dup_add([ZZ(1), ZZ(2)], [ZZ(1)], ZZ)
+    assert dmp_add([QQ(1, 2), QQ(2, 3)], [QQ(1)], 0, QQ) == \
+        dup_add([QQ(1, 2), QQ(2, 3)], [QQ(1)], QQ)
+
+    assert dmp_add([[[]]], [[[]]], 2, ZZ) == [[[]]]
+    assert dmp_add([[[ZZ(1)]]], [[[]]], 2, ZZ) == [[[ZZ(1)]]]
+    assert dmp_add([[[]]], [[[ZZ(1)]]], 2, ZZ) == [[[ZZ(1)]]]
+    assert dmp_add([[[ZZ(2)]]], [[[ZZ(1)]]], 2, ZZ) == [[[ZZ(3)]]]
+    assert dmp_add([[[ZZ(1)]]], [[[ZZ(2)]]], 2, ZZ) == [[[ZZ(3)]]]
+
+    assert dmp_add([[[]]], [[[]]], 2, QQ) == [[[]]]
+    assert dmp_add([[[QQ(1, 2)]]], [[[]]], 2, QQ) == [[[QQ(1, 2)]]]
+    assert dmp_add([[[]]], [[[QQ(1, 2)]]], 2, QQ) == [[[QQ(1, 2)]]]
+    assert dmp_add([[[QQ(2, 7)]]], [[[QQ(1, 7)]]], 2, QQ) == [[[QQ(3, 7)]]]
+    assert dmp_add([[[QQ(1, 7)]]], [[[QQ(2, 7)]]], 2, QQ) == [[[QQ(3, 7)]]]
+
+
+def test_dup_sub():
+    assert dup_sub([], [], ZZ) == []
+    assert dup_sub([ZZ(1)], [], ZZ) == [ZZ(1)]
+    assert dup_sub([], [ZZ(1)], ZZ) == [ZZ(-1)]
+    assert dup_sub([ZZ(1)], [ZZ(1)], ZZ) == []
+    assert dup_sub([ZZ(1)], [ZZ(2)], ZZ) == [ZZ(-1)]
+
+    assert dup_sub([ZZ(1), ZZ(2)], [ZZ(1)], ZZ) == [ZZ(1), ZZ(1)]
+    assert dup_sub([ZZ(1)], [ZZ(1), ZZ(2)], ZZ) == [ZZ(-1), ZZ(-1)]
+
+    assert dup_sub([ZZ(3), ZZ(
+        2), ZZ(1)], [ZZ(8), ZZ(9), ZZ(10)], ZZ) == [ZZ(-5), ZZ(-7), ZZ(-9)]
+
+    assert dup_sub([], [], QQ) == []
+    assert dup_sub([QQ(1, 2)], [], QQ) == [QQ(1, 2)]
+    assert dup_sub([], [QQ(1, 2)], QQ) == [QQ(-1, 2)]
+    assert dup_sub([QQ(1, 3)], [QQ(1, 3)], QQ) == []
+    assert dup_sub([QQ(1, 3)], [QQ(2, 3)], QQ) == [QQ(-1, 3)]
+
+    assert dup_sub([QQ(1, 7), QQ(2, 7)], [QQ(1)], QQ) == [QQ(1, 7), QQ(-5, 7)]
+    assert dup_sub([QQ(1)], [QQ(1, 7), QQ(2, 7)], QQ) == [QQ(-1, 7), QQ(5, 7)]
+
+    assert dup_sub([QQ(3, 7), QQ(2, 7), QQ(1, 7)], [QQ(
+        8, 7), QQ(9, 7), QQ(10, 7)], QQ) == [QQ(-5, 7), QQ(-7, 7), QQ(-9, 7)]
+
+
+def test_dmp_sub():
+    assert dmp_sub([ZZ(1), ZZ(2)], [ZZ(1)], 0, ZZ) == \
+        dup_sub([ZZ(1), ZZ(2)], [ZZ(1)], ZZ)
+    assert dmp_sub([QQ(1, 2), QQ(2, 3)], [QQ(1)], 0, QQ) == \
+        dup_sub([QQ(1, 2), QQ(2, 3)], [QQ(1)], QQ)
+
+    assert dmp_sub([[[]]], [[[]]], 2, ZZ) == [[[]]]
+    assert dmp_sub([[[ZZ(1)]]], [[[]]], 2, ZZ) == [[[ZZ(1)]]]
+    assert dmp_sub([[[]]], [[[ZZ(1)]]], 2, ZZ) == [[[ZZ(-1)]]]
+    assert dmp_sub([[[ZZ(2)]]], [[[ZZ(1)]]], 2, ZZ) == [[[ZZ(1)]]]
+    assert dmp_sub([[[ZZ(1)]]], [[[ZZ(2)]]], 2, ZZ) == [[[ZZ(-1)]]]
+
+    assert dmp_sub([[[]]], [[[]]], 2, QQ) == [[[]]]
+    assert dmp_sub([[[QQ(1, 2)]]], [[[]]], 2, QQ) == [[[QQ(1, 2)]]]
+    assert dmp_sub([[[]]], [[[QQ(1, 2)]]], 2, QQ) == [[[QQ(-1, 2)]]]
+    assert dmp_sub([[[QQ(2, 7)]]], [[[QQ(1, 7)]]], 2, QQ) == [[[QQ(1, 7)]]]
+    assert dmp_sub([[[QQ(1, 7)]]], [[[QQ(2, 7)]]], 2, QQ) == [[[QQ(-1, 7)]]]
+
+
+def test_dup_add_mul():
+    assert dup_add_mul([ZZ(1), ZZ(2), ZZ(3)], [ZZ(3), ZZ(2), ZZ(1)],
+               [ZZ(1), ZZ(2)], ZZ) == [ZZ(3), ZZ(9), ZZ(7), ZZ(5)]
+    assert dmp_add_mul([[ZZ(1), ZZ(2)], [ZZ(3)]], [[ZZ(3)], [ZZ(2), ZZ(1)]],
+               [[ZZ(1)], [ZZ(2)]], 1, ZZ) == [[ZZ(3)], [ZZ(3), ZZ(9)], [ZZ(4), ZZ(5)]]
+
+
+def test_dup_sub_mul():
+    assert dup_sub_mul([ZZ(1), ZZ(2), ZZ(3)], [ZZ(3), ZZ(2), ZZ(1)],
+               [ZZ(1), ZZ(2)], ZZ) == [ZZ(-3), ZZ(-7), ZZ(-3), ZZ(1)]
+    assert dmp_sub_mul([[ZZ(1), ZZ(2)], [ZZ(3)]], [[ZZ(3)], [ZZ(2), ZZ(1)]],
+               [[ZZ(1)], [ZZ(2)]], 1, ZZ) == [[ZZ(-3)], [ZZ(-1), ZZ(-5)], [ZZ(-4), ZZ(1)]]
+
+
+def test_dup_mul():
+    assert dup_mul([], [], ZZ) == []
+    assert dup_mul([], [ZZ(1)], ZZ) == []
+    assert dup_mul([ZZ(1)], [], ZZ) == []
+    assert dup_mul([ZZ(1)], [ZZ(1)], ZZ) == [ZZ(1)]
+    assert dup_mul([ZZ(5)], [ZZ(7)], ZZ) == [ZZ(35)]
+
+    assert dup_mul([], [], QQ) == []
+    assert dup_mul([], [QQ(1, 2)], QQ) == []
+    assert dup_mul([QQ(1, 2)], [], QQ) == []
+    assert dup_mul([QQ(1, 2)], [QQ(4, 7)], QQ) == [QQ(2, 7)]
+    assert dup_mul([QQ(5, 7)], [QQ(3, 7)], QQ) == [QQ(15, 49)]
+
+    f = dup_normal([3, 0, 0, 6, 1, 2], ZZ)
+    g = dup_normal([4, 0, 1, 0], ZZ)
+    h = dup_normal([12, 0, 3, 24, 4, 14, 1, 2, 0], ZZ)
+
+    assert dup_mul(f, g, ZZ) == h
+    assert dup_mul(g, f, ZZ) == h
+
+    f = dup_normal([2, 0, 0, 1, 7], ZZ)
+    h = dup_normal([4, 0, 0, 4, 28, 0, 1, 14, 49], ZZ)
+
+    assert dup_mul(f, f, ZZ) == h
+
+    K = FF(6)
+
+    assert dup_mul([K(2), K(1)], [K(3), K(4)], K) == [K(5), K(4)]
+
+    p1 = dup_normal([79, -1, 78, -94, -10, 11, 32, -19, 78, 2, -89, 30, 73, 42,
+        85, 77, 83, -30, -34, -2, 95, -81, 37, -49, -46, -58, -16, 37, 35, -11,
+        -57, -15, -31, 67, -20, 27, 76, 2, 70, 67, -65, 65, -26, -93, -44, -12,
+        -92, 57, -90, -57, -11, -67, -98, -69, 97, -41, 89, 33, 89, -50, 81,
+        -31, 60, -27, 43, 29, -77, 44, 21, -91, 32, -57, 33, 3, 53, -51, -38,
+        -99, -84, 23, -50, 66, -100, 1, -75, -25, 27, -60, 98, -51, -87, 6, 8,
+        78, -28, -95, -88, 12, -35, 26, -9, 16, -92, 55, -7, -86, 68, -39, -46,
+        84, 94, 45, 60, 92, 68, -75, -74, -19, 8, 75, 78, 91, 57, 34, 14, -3,
+        -49, 65, 78, -18, 6, -29, -80, -98, 17, 13, 58, 21, 20, 9, 37, 7, -30,
+        -53, -20, 34, 67, -42, 89, -22, 73, 43, -6, 5, 51, -8, -15, -52, -22,
+        -58, -72, -3, 43, -92, 82, 83, -2, -13, -23, -60, 16, -94, -8, -28,
+        -95, -72, 63, -90, 76, 6, -43, -100, -59, 76, 3, 3, 46, -85, 75, 62,
+        -71, -76, 88, 97, -72, -1, 30, -64, 72, -48, 14, -78, 58, 63, -91, 24,
+        -87, -27, -80, -100, -44, 98, 70, 100, -29, -38, 11, 77, 100, 52, 86,
+        65, -5, -42, -81, -38, -42, 43, -2, -70, -63, -52], ZZ)
+    p2 = dup_normal([65, -19, -47, 1, 90, 81, -15, -34, 25, -75, 9, -83, 50, -5,
+        -44, 31, 1, 70, -7, 78, 74, 80, 85, 65, 21, 41, 66, 19, -40, 63, -21,
+        -27, 32, 69, 83, 34, -35, 14, 81, 57, -75, 32, -67, -89, -100, -61, 46,
+        84, -78, -29, -50, -94, -24, -32, -68, -16, 100, -7, -72, -89, 35, 82,
+        58, 81, -92, 62, 5, -47, -39, -58, -72, -13, 84, 44, 55, -25, 48, -54,
+        -31, -56, -11, -50, -84, 10, 67, 17, 13, -14, 61, 76, -64, -44, -40,
+        -96, 11, -11, -94, 2, 6, 27, -6, 68, -54, 66, -74, -14, -1, -24, -73,
+        96, 89, -11, -89, 56, -53, 72, -43, 96, 25, 63, -31, 29, 68, 83, 91,
+        -93, -19, -38, -40, 40, -12, -19, -79, 44, 100, -66, -29, -77, 62, 39,
+        -8, 11, -97, 14, 87, 64, 21, -18, 13, 15, -59, -75, -99, -88, 57, 54,
+        56, -67, 6, -63, -59, -14, 28, 87, -20, -39, 84, -91, -2, 49, -75, 11,
+        -24, -95, 36, 66, 5, 25, -72, -40, 86, 90, 37, -33, 57, -35, 29, -18,
+        4, -79, 64, -17, -27, 21, 29, -5, -44, -87, -24, 52, 78, 11, -23, -53,
+        36, 42, 21, -68, 94, -91, -51, -21, 51, -76, 72, 31, 24, -48, -80, -9,
+        37, -47, -6, -8, -63, -91, 79, -79, -100, 38, -20, 38, 100, 83, -90,
+        87, 63, -36, 82, -19, 18, -98, -38, 26, 98, -70, 79, 92, 12, 12, 70,
+        74, 36, 48, -13, 31, 31, -47, -71, -12, -64, 36, -42, 32, -86, 60, 83,
+        70, 55, 0, 1, 29, -35, 8, -82, 8, -73, -46, -50, 43, 48, -5, -86, -72,
+        44, -90, 19, 19, 5, -20, 97, -13, -66, -5, 5, -69, 64, -30, 41, 51, 36,
+        13, -99, -61, 94, -12, 74, 98, 68, 24, 46, -97, -87, -6, -27, 82, 62,
+        -11, -77, 86, 66, -47, -49, -50, 13, 18, 89, -89, 46, -80, 13, 98, -35,
+        -36, -25, 12, 20, 26, -52, 79, 27, 79, 100, 8, 62, -58, -28, 37], ZZ)
+    res = dup_normal([5135, -1566, 1376, -7466, 4579, 11710, 8001, -7183,
+        -3737, -7439, 345, -10084, 24522, -1201, 1070, -10245, 9582, 9264,
+        1903, 23312, 18953, 10037, -15268, -5450, 6442, -6243, -3777, 5110,
+        10936, -16649, -6022, 16255, 31300, 24818, 31922, 32760, 7854, 27080,
+        15766, 29596, 7139, 31945, -19810, 465, -38026, -3971, 9641, 465,
+        -19375, 5524, -30112, -11960, -12813, 13535, 30670, 5925, -43725,
+        -14089, 11503, -22782, 6371, 43881, 37465, -33529, -33590, -39798,
+        -37854, -18466, -7908, -35825, -26020, -36923, -11332, -5699, 25166,
+        -3147, 19885, 12962, -20659, -1642, 27723, -56331, -24580, -11010,
+        -20206, 20087, -23772, -16038, 38580, 20901, -50731, 32037, -4299,
+        26508, 18038, -28357, 31846, -7405, -20172, -15894, 2096, 25110,
+        -45786, 45918, -55333, -31928, -49428, -29824, -58796, -24609, -15408,
+        69, -35415, -18439, 10123, -20360, -65949, 33356, -20333, 26476,
+        -32073, 33621, 930, 28803, -42791, 44716, 38164, 12302, -1739, 11421,
+        73385, -7613, 14297, 38155, -414, 77587, 24338, -21415, 29367, 42639,
+        13901, -288, 51027, -11827, 91260, 43407, 88521, -15186, 70572, -12049,
+        5090, -12208, -56374, 15520, -623, -7742, 50825, 11199, -14894, 40892,
+        59591, -31356, -28696, -57842, -87751, -33744, -28436, -28945, -40287,
+        37957, -35638, 33401, -61534, 14870, 40292, 70366, -10803, 102290,
+        -71719, -85251, 7902, -22409, 75009, 99927, 35298, -1175, -762, -34744,
+        -10587, -47574, -62629, -19581, -43659, -54369, -32250, -39545, 15225,
+        -24454, 11241, -67308, -30148, 39929, 37639, 14383, -73475, -77636,
+        -81048, -35992, 41601, -90143, 76937, -8112, 56588, 9124, -40094,
+        -32340, 13253, 10898, -51639, 36390, 12086, -1885, 100714, -28561,
+        -23784, -18735, 18916, 16286, 10742, -87360, -13697, 10689, -19477,
+        -29770, 5060, 20189, -8297, 112407, 47071, 47743, 45519, -4109, 17468,
+        -68831, 78325, -6481, -21641, -19459, 30919, 96115, 8607, 53341, 32105,
+        -16211, 23538, 57259, -76272, -40583, 62093, 38511, -34255, -40665,
+        -40604, -37606, -15274, 33156, -13885, 103636, 118678, -14101, -92682,
+        -100791, 2634, 63791, 98266, 19286, -34590, -21067, -71130, 25380,
+        -40839, -27614, -26060, 52358, -15537, 27138, -6749, 36269, -33306,
+        13207, -91084, -5540, -57116, 69548, 44169, -57742, -41234, -103327,
+        -62904, -8566, 41149, -12866, 71188, 23980, 1838, 58230, 73950, 5594,
+        43113, -8159, -15925, 6911, 85598, -75016, -16214, -62726, -39016,
+        8618, -63882, -4299, 23182, 49959, 49342, -3238, -24913, -37138, 78361,
+        32451, 6337, -11438, -36241, -37737, 8169, -3077, -24829, 57953, 53016,
+        -31511, -91168, 12599, -41849, 41576, 55275, -62539, 47814, -62319,
+        12300, -32076, -55137, -84881, -27546, 4312, -3433, -54382, 113288,
+        -30157, 74469, 18219, 79880, -2124, 98911, 17655, -33499, -32861,
+        47242, -37393, 99765, 14831, -44483, 10800, -31617, -52710, 37406,
+        22105, 29704, -20050, 13778, 43683, 36628, 8494, 60964, -22644, 31550,
+        -17693, 33805, -124879, -12302, 19343, 20400, -30937, -21574, -34037,
+        -33380, 56539, -24993, -75513, -1527, 53563, 65407, -101, 53577, 37991,
+        18717, -23795, -8090, -47987, -94717, 41967, 5170, -14815, -94311,
+        17896, -17734, -57718, -774, -38410, 24830, 29682, 76480, 58802,
+        -46416, -20348, -61353, -68225, -68306, 23822, -31598, 42972, 36327,
+        28968, -65638, -21638, 24354, -8356, 26777, 52982, -11783, -44051,
+        -26467, -44721, -28435, -53265, -25574, -2669, 44155, 22946, -18454,
+        -30718, -11252, 58420, 8711, 67447, 4425, 41749, 67543, 43162, 11793,
+        -41907, 20477, -13080, 6559, -6104, -13244, 42853, 42935, 29793, 36730,
+        -28087, 28657, 17946, 7503, 7204, 21491, -27450, -24241, -98156,
+        -18082, -42613, -24928, 10775, -14842, -44127, 55910, 14777, 31151, -2194,
+        39206, -2100, -4211, 11827, -8918, -19471, 72567, 36447, -65590, -34861,
+        -17147, -45303, 9025, -7333, -35473, 11101, 11638, 3441, 6626, -41800,
+        9416, 13679, 33508, 40502, -60542, 16358, 8392, -43242, -35864, -34127,
+        -48721, 35878, 30598, 28630, 20279, -19983, -14638, -24455, -1851, -11344,
+        45150, 42051, 26034, -28889, -32382, -3527, -14532, 22564, -22346, 477,
+        11706, 28338, -25972, -9185, -22867, -12522, 32120, -4424, 11339, -33913,
+        -7184, 5101, -23552, -17115, -31401, -6104, 21906, 25708, 8406, 6317,
+        -7525, 5014, 20750, 20179, 22724, 11692, 13297, 2493, -253, -16841, -17339,
+        -6753, -4808, 2976, -10881, -10228, -13816, -12686, 1385, 2316, 2190, -875,
+        -1924], ZZ)
+
+    assert dup_mul(p1, p2, ZZ) == res
+
+    p1 = dup_normal([83, -61, -86, -24, 12, 43, -88, -9, 42, 55, -66, 74, 95,
+        -25, -12, 68, -99, 4, 45, 6, -15, -19, 78, 65, -55, 47, -13, 17, 86,
+        81, -58, -27, 50, -40, -24, 39, -41, -92, 75, 90, -1, 40, -15, -27,
+        -35, 68, 70, -64, -40, 78, -88, -58, -39, 69, 46, 12, 28, -94, -37,
+        -50, -80, -96, -61, 25, 1, 71, 4, 12, 48, 4, 34, -47, -75, 5, 48, 82,
+        88, 23, 98, 35, 17, -10, 48, -61, -95, 47, 65, -19, -66, -57, -6, -51,
+        -42, -89, 66, -13, 18, 37, 90, -23, 72, 96, -53, 0, 40, -73, -52, -68,
+        32, -25, -53, 79, -52, 18, 44, 73, -81, 31, -90, 70, 3, 36, 48, 76,
+        -24, -44, 23, 98, -4, 73, 69, 88, -70, 14, -68, 94, -78, -15, -64, -97,
+        -70, -35, 65, 88, 49, -53, -7, 12, -45, -7, 59, -94, 99, -2, 67, -60,
+        -71, 29, -62, -77, 1, 51, 17, 80, -20, -47, -19, 24, -9, 39, -23, 21,
+        -84, 10, 84, 56, -17, -21, -66, 85, 70, 46, -51, -22, -95, 78, -60,
+        -96, -97, -45, 72, 35, 30, -61, -92, -93, -60, -61, 4, -4, -81, -73,
+        46, 53, -11, 26, 94, 45, 14, -78, 55, 84, -68, 98, 60, 23, 100, -63,
+        68, 96, -16, 3, 56, 21, -58, 62, -67, 66, 85, 41, -79, -22, 97, -67,
+        82, 82, -96, -20, -7, 48, -67, 48, -9, -39, 78], ZZ)
+    p2 = dup_normal([52, 88, 76, 66, 9, -64, 46, -20, -28, 69, 60, 96, -36,
+        -92, -30, -11, -35, 35, 55, 63, -92, -7, 25, -58, 74, 55, -6, 4, 47,
+        -92, -65, 67, -45, 74, -76, 59, -6, 69, 39, 24, -71, -7, 39, -45, 60,
+        -68, 98, 97, -79, 17, 4, 94, -64, 68, -100, -96, -2, 3, 22, 96, 54,
+        -77, -86, 67, 6, 57, 37, 40, 89, -78, 64, -94, -45, -92, 57, 87, -26,
+        36, 19, 97, 25, 77, -87, 24, 43, -5, 35, 57, 83, 71, 35, 63, 61, 96,
+        -22, 8, -1, 96, 43, 45, 94, -93, 36, 71, -41, -99, 85, -48, 59, 52,
+        -17, 5, 87, -16, -68, -54, 76, -18, 100, 91, -42, -70, -66, -88, -12,
+        1, 95, -82, 52, 43, -29, 3, 12, 72, -99, -43, -32, -93, -51, 16, -20,
+        -12, -11, 5, 33, -38, 93, -5, -74, 25, 74, -58, 93, 59, -63, -86, 63,
+        -20, -4, -74, -73, -95, 29, -28, 93, -91, -2, -38, -62, 77, -58, -85,
+        -28, 95, 38, 19, -69, 86, 94, 25, -2, -4, 47, 34, -59, 35, -48, 29,
+        -63, -53, 34, 29, 66, 73, 6, 92, -84, 89, 15, 81, 93, 97, 51, -72, -78,
+        25, 60, 90, -45, 39, 67, -84, -62, 57, 26, -32, -56, -14, -83, 76, 5,
+        -2, 99, -100, 28, 46, 94, -7, 53, -25, 16, -23, -36, 89, -78, -63, 31,
+        1, 84, -99, -52, 76, 48, 90, -76, 44, -19, 54, -36, -9, -73, -100, -69,
+        31, 42, 25, -39, 76, -26, -8, -14, 51, 3, 37, 45, 2, -54, 13, -34, -92,
+        17, -25, -65, 53, -63, 30, 4, -70, -67, 90, 52, 51, 18, -3, 31, -45,
+        -9, 59, 63, -87, 22, -32, 29, -38, 21, 36, -82, 27, -11], ZZ)
+    res = dup_normal([4316, 4132, -3532, -7974, -11303, -10069, 5484, -3330,
+        -5874, 7734, 4673, 11327, -9884, -8031, 17343, 21035, -10570, -9285,
+        15893, 3780, -14083, 8819, 17592, 10159, 7174, -11587, 8598, -16479,
+        3602, 25596, 9781, 12163, 150, 18749, -21782, -12307, 27578, -2757,
+        -12573, 12565, 6345, -18956, 19503, -15617, 1443, -16778, 36851, 23588,
+        -28474, 5749, 40695, -7521, -53669, -2497, -18530, 6770, 57038, 3926,
+        -6927, -15399, 1848, -64649, -27728, 3644, 49608, 15187, -8902, -9480,
+        -7398, -40425, 4824, 23767, -7594, -6905, 33089, 18786, 12192, 24670,
+        31114, 35334, -4501, -14676, 7107, -59018, -21352, 20777, 19661, 20653,
+        33754, -885, -43758, 6269, 51897, -28719, -97488, -9527, 13746, 11644,
+        17644, -21720, 23782, -10481, 47867, 20752, 33810, -1875, 39918, -7710,
+        -40840, 19808, -47075, 23066, 46616, 25201, 9287, 35436, -1602, 9645,
+        -11978, 13273, 15544, 33465, 20063, 44539, 11687, 27314, -6538, -37467,
+        14031, 32970, -27086, 41323, 29551, 65910, -39027, -37800, -22232,
+        8212, 46316, -28981, -55282, 50417, -44929, -44062, 73879, 37573,
+        -2596, -10877, -21893, -133218, -33707, -25753, -9531, 17530, 61126,
+        2748, -56235, 43874, -10872, -90459, -30387, 115267, -7264, -44452,
+        122626, 14839, -599, 10337, 57166, -67467, -54957, 63669, 1202, 18488,
+        52594, 7205, -97822, 612, 78069, -5403, -63562, 47236, 36873, -154827,
+        -26188, 82427, -39521, 5628, 7416, 5276, -53095, 47050, 26121, -42207,
+        79021, -13035, 2499, -66943, 29040, -72355, -23480, 23416, -12885,
+        -44225, -42688, -4224, 19858, 55299, 15735, 11465, 101876, -39169,
+        51786, 14723, 43280, -68697, 16410, 92295, 56767, 7183, 111850, 4550,
+        115451, -38443, -19642, -35058, 10230, 93829, 8925, 63047, 3146, 29250,
+        8530, 5255, -98117, -115517, -76817, -8724, 41044, 1312, -35974, 79333,
+        -28567, 7547, -10580, -24559, -16238, 10794, -3867, 24848, 57770,
+        -51536, -35040, 71033, 29853, 62029, -7125, -125585, -32169, -47907,
+        156811, -65176, -58006, -15757, -57861, 11963, 30225, -41901, -41681,
+        31310, 27982, 18613, 61760, 60746, -59096, 33499, 30097, -17997, 24032,
+        56442, -83042, 23747, -20931, -21978, -158752, -9883, -73598, -7987,
+        -7333, -125403, -116329, 30585, 53281, 51018, -29193, 88575, 8264,
+        -40147, -16289, 113088, 12810, -6508, 101552, -13037, 34440, -41840,
+        101643, 24263, 80532, 61748, 65574, 6423, -20672, 6591, -10834, -71716,
+        86919, -92626, 39161, 28490, 81319, 46676, 106720, 43530, 26998, 57456,
+        -8862, 60989, 13982, 3119, -2224, 14743, 55415, -49093, -29303, 28999,
+        1789, 55953, -84043, -7780, -65013, 57129, -47251, 61484, 61994,
+        -78361, -82778, 22487, -26894, 9756, -74637, -15519, -4360, 30115,
+        42433, 35475, 15286, 69768, 21509, -20214, 78675, -21163, 13596, 11443,
+        -10698, -53621, -53867, -24155, 64500, -42784, -33077, -16500, 873,
+        -52788, 14546, -38011, 36974, -39849, -34029, -94311, 83068, -50437,
+        -26169, -46746, 59185, 42259, -101379, -12943, 30089, -59086, 36271,
+        22723, -30253, -52472, -70826, -23289, 3331, -31687, 14183, -857,
+        -28627, 35246, -51284, 5636, -6933, 66539, 36654, 50927, 24783, 3457,
+        33276, 45281, 45650, -4938, -9968, -22590, 47995, 69229, 5214, -58365,
+        -17907, -14651, 18668, 18009, 12649, -11851, -13387, 20339, 52472,
+        -1087, -21458, -68647, 52295, 15849, 40608, 15323, 25164, -29368,
+        10352, -7055, 7159, 21695, -5373, -54849, 101103, -24963, -10511,
+        33227, 7659, 41042, -69588, 26718, -20515, 6441, 38135, -63, 24088,
+        -35364, -12785, -18709, 47843, 48533, -48575, 17251, -19394, 32878,
+        -9010, -9050, 504, -12407, 28076, -3429, 25324, -4210, -26119, 752,
+        -29203, 28251, -11324, -32140, -3366, -25135, 18702, -31588, -7047,
+        -24267, 49987, -14975, -33169, 37744, -7720, -9035, 16964, -2807, -421,
+        14114, -17097, -13662, 40628, -12139, -9427, 5369, 17551, -13232, -16211,
+        9804, -7422, 2677, 28635, -8280, -4906, 2908, -22558, 5604, 12459, 8756,
+        -3980, -4745, -18525, 7913, 5970, -16457, 20230, -6247, -13812, 2505,
+        11899, 1409, -15094, 22540, -18863, 137, 11123, -4516, 2290, -8594, 12150,
+        -10380, 3005, 5235, -7350, 2535, -858], ZZ)
+
+    assert dup_mul(p1, p2, ZZ) == res
+
+
+def test_dmp_mul():
+    assert dmp_mul([ZZ(5)], [ZZ(7)], 0, ZZ) == \
+        dup_mul([ZZ(5)], [ZZ(7)], ZZ)
+    assert dmp_mul([QQ(5, 7)], [QQ(3, 7)], 0, QQ) == \
+        dup_mul([QQ(5, 7)], [QQ(3, 7)], QQ)
+
+    assert dmp_mul([[[]]], [[[]]], 2, ZZ) == [[[]]]
+    assert dmp_mul([[[ZZ(1)]]], [[[]]], 2, ZZ) == [[[]]]
+    assert dmp_mul([[[]]], [[[ZZ(1)]]], 2, ZZ) == [[[]]]
+    assert dmp_mul([[[ZZ(2)]]], [[[ZZ(1)]]], 2, ZZ) == [[[ZZ(2)]]]
+    assert dmp_mul([[[ZZ(1)]]], [[[ZZ(2)]]], 2, ZZ) == [[[ZZ(2)]]]
+
+    assert dmp_mul([[[]]], [[[]]], 2, QQ) == [[[]]]
+    assert dmp_mul([[[QQ(1, 2)]]], [[[]]], 2, QQ) == [[[]]]
+    assert dmp_mul([[[]]], [[[QQ(1, 2)]]], 2, QQ) == [[[]]]
+    assert dmp_mul([[[QQ(2, 7)]]], [[[QQ(1, 3)]]], 2, QQ) == [[[QQ(2, 21)]]]
+    assert dmp_mul([[[QQ(1, 7)]]], [[[QQ(2, 3)]]], 2, QQ) == [[[QQ(2, 21)]]]
+
+    K = FF(6)
+
+    assert dmp_mul(
+        [[K(2)], [K(1)]], [[K(3)], [K(4)]], 1, K) == [[K(5)], [K(4)]]
+
+
+def test_dup_sqr():
+    assert dup_sqr([], ZZ) == []
+    assert dup_sqr([ZZ(2)], ZZ) == [ZZ(4)]
+    assert dup_sqr([ZZ(1), ZZ(2)], ZZ) == [ZZ(1), ZZ(4), ZZ(4)]
+
+    assert dup_sqr([], QQ) == []
+    assert dup_sqr([QQ(2, 3)], QQ) == [QQ(4, 9)]
+    assert dup_sqr([QQ(1, 3), QQ(2, 3)], QQ) == [QQ(1, 9), QQ(4, 9), QQ(4, 9)]
+
+    f = dup_normal([2, 0, 0, 1, 7], ZZ)
+
+    assert dup_sqr(f, ZZ) == dup_normal([4, 0, 0, 4, 28, 0, 1, 14, 49], ZZ)
+
+    K = FF(9)
+
+    assert dup_sqr([K(3), K(4)], K) == [K(6), K(7)]
+
+
+def test_dmp_sqr():
+    assert dmp_sqr([ZZ(1), ZZ(2)], 0, ZZ) == \
+        dup_sqr([ZZ(1), ZZ(2)], ZZ)
+
+    assert dmp_sqr([[[]]], 2, ZZ) == [[[]]]
+    assert dmp_sqr([[[ZZ(2)]]], 2, ZZ) == [[[ZZ(4)]]]
+
+    assert dmp_sqr([[[]]], 2, QQ) == [[[]]]
+    assert dmp_sqr([[[QQ(2, 3)]]], 2, QQ) == [[[QQ(4, 9)]]]
+
+    K = FF(9)
+
+    assert dmp_sqr([[K(3)], [K(4)]], 1, K) == [[K(6)], [K(7)]]
+
+
+def test_dup_pow():
+    assert dup_pow([], 0, ZZ) == [ZZ(1)]
+    assert dup_pow([], 0, QQ) == [QQ(1)]
+
+    assert dup_pow([], 1, ZZ) == []
+    assert dup_pow([], 7, ZZ) == []
+
+    assert dup_pow([ZZ(1)], 0, ZZ) == [ZZ(1)]
+    assert dup_pow([ZZ(1)], 1, ZZ) == [ZZ(1)]
+    assert dup_pow([ZZ(1)], 7, ZZ) == [ZZ(1)]
+
+    assert dup_pow([ZZ(3)], 0, ZZ) == [ZZ(1)]
+    assert dup_pow([ZZ(3)], 1, ZZ) == [ZZ(3)]
+    assert dup_pow([ZZ(3)], 7, ZZ) == [ZZ(2187)]
+
+    assert dup_pow([QQ(1, 1)], 0, QQ) == [QQ(1, 1)]
+    assert dup_pow([QQ(1, 1)], 1, QQ) == [QQ(1, 1)]
+    assert dup_pow([QQ(1, 1)], 7, QQ) == [QQ(1, 1)]
+
+    assert dup_pow([QQ(3, 7)], 0, QQ) == [QQ(1, 1)]
+    assert dup_pow([QQ(3, 7)], 1, QQ) == [QQ(3, 7)]
+    assert dup_pow([QQ(3, 7)], 7, QQ) == [QQ(2187, 823543)]
+
+    f = dup_normal([2, 0, 0, 1, 7], ZZ)
+
+    assert dup_pow(f, 0, ZZ) == dup_normal([1], ZZ)
+    assert dup_pow(f, 1, ZZ) == dup_normal([2, 0, 0, 1, 7], ZZ)
+    assert dup_pow(f, 2, ZZ) == dup_normal([4, 0, 0, 4, 28, 0, 1, 14, 49], ZZ)
+    assert dup_pow(f, 3, ZZ) == dup_normal(
+        [8, 0, 0, 12, 84, 0, 6, 84, 294, 1, 21, 147, 343], ZZ)
+
+
+def test_dmp_pow():
+    assert dmp_pow([[]], 0, 1, ZZ) == [[ZZ(1)]]
+    assert dmp_pow([[]], 0, 1, QQ) == [[QQ(1)]]
+
+    assert dmp_pow([[]], 1, 1, ZZ) == [[]]
+    assert dmp_pow([[]], 7, 1, ZZ) == [[]]
+
+    assert dmp_pow([[ZZ(1)]], 0, 1, ZZ) == [[ZZ(1)]]
+    assert dmp_pow([[ZZ(1)]], 1, 1, ZZ) == [[ZZ(1)]]
+    assert dmp_pow([[ZZ(1)]], 7, 1, ZZ) == [[ZZ(1)]]
+
+    assert dmp_pow([[QQ(3, 7)]], 0, 1, QQ) == [[QQ(1, 1)]]
+    assert dmp_pow([[QQ(3, 7)]], 1, 1, QQ) == [[QQ(3, 7)]]
+    assert dmp_pow([[QQ(3, 7)]], 7, 1, QQ) == [[QQ(2187, 823543)]]
+
+    f = dup_normal([2, 0, 0, 1, 7], ZZ)
+
+    assert dmp_pow(f, 2, 0, ZZ) == dup_pow(f, 2, ZZ)
+
+
+def test_dup_pdiv():
+    f = dup_normal([3, 1, 1, 5], ZZ)
+    g = dup_normal([5, -3, 1], ZZ)
+
+    q = dup_normal([15, 14], ZZ)
+    r = dup_normal([52, 111], ZZ)
+
+    assert dup_pdiv(f, g, ZZ) == (q, r)
+    assert dup_pquo(f, g, ZZ) == q
+    assert dup_prem(f, g, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dup_pexquo(f, g, ZZ))
+
+    f = dup_normal([3, 1, 1, 5], QQ)
+    g = dup_normal([5, -3, 1], QQ)
+
+    q = dup_normal([15, 14], QQ)
+    r = dup_normal([52, 111], QQ)
+
+    assert dup_pdiv(f, g, QQ) == (q, r)
+    assert dup_pquo(f, g, QQ) == q
+    assert dup_prem(f, g, QQ) == r
+
+    raises(ExactQuotientFailed, lambda: dup_pexquo(f, g, QQ))
+
+
+def test_dmp_pdiv():
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, ZZ)
+    g = dmp_normal([[1], [-1, 0]], 1, ZZ)
+
+    q = dmp_normal([[1], [1, 0]], 1, ZZ)
+    r = dmp_normal([[2, 0, 0]], 1, ZZ)
+
+    assert dmp_pdiv(f, g, 1, ZZ) == (q, r)
+    assert dmp_pquo(f, g, 1, ZZ) == q
+    assert dmp_prem(f, g, 1, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dmp_pexquo(f, g, 1, ZZ))
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, ZZ)
+    g = dmp_normal([[2], [-2, 0]], 1, ZZ)
+
+    q = dmp_normal([[2], [2, 0]], 1, ZZ)
+    r = dmp_normal([[8, 0, 0]], 1, ZZ)
+
+    assert dmp_pdiv(f, g, 1, ZZ) == (q, r)
+    assert dmp_pquo(f, g, 1, ZZ) == q
+    assert dmp_prem(f, g, 1, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dmp_pexquo(f, g, 1, ZZ))
+
+
+def test_dup_rr_div():
+    raises(ZeroDivisionError, lambda: dup_rr_div([1, 2, 3], [], ZZ))
+
+    f = dup_normal([3, 1, 1, 5], ZZ)
+    g = dup_normal([5, -3, 1], ZZ)
+
+    q, r = [], f
+
+    assert dup_rr_div(f, g, ZZ) == (q, r)
+
+
+def test_dmp_rr_div():
+    raises(ZeroDivisionError, lambda: dmp_rr_div([[1, 2], [3]], [[]], 1, ZZ))
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, ZZ)
+    g = dmp_normal([[1], [-1, 0]], 1, ZZ)
+
+    q = dmp_normal([[1], [1, 0]], 1, ZZ)
+    r = dmp_normal([[2, 0, 0]], 1, ZZ)
+
+    assert dmp_rr_div(f, g, 1, ZZ) == (q, r)
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, ZZ)
+    g = dmp_normal([[-1], [1, 0]], 1, ZZ)
+
+    q = dmp_normal([[-1], [-1, 0]], 1, ZZ)
+    r = dmp_normal([[2, 0, 0]], 1, ZZ)
+
+    assert dmp_rr_div(f, g, 1, ZZ) == (q, r)
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, ZZ)
+    g = dmp_normal([[2], [-2, 0]], 1, ZZ)
+
+    q, r = [[]], f
+
+    assert dmp_rr_div(f, g, 1, ZZ) == (q, r)
+
+
+def test_dup_ff_div():
+    raises(ZeroDivisionError, lambda: dup_ff_div([1, 2, 3], [], QQ))
+
+    f = dup_normal([3, 1, 1, 5], QQ)
+    g = dup_normal([5, -3, 1], QQ)
+
+    q = [QQ(3, 5), QQ(14, 25)]
+    r = [QQ(52, 25), QQ(111, 25)]
+
+    assert dup_ff_div(f, g, QQ) == (q, r)
+
+def test_dup_ff_div_gmpy2():
+    if GROUND_TYPES != 'gmpy2':
+        return
+
+    from gmpy2 import mpq
+    from sympy.polys.domains import GMPYRationalField
+    K = GMPYRationalField()
+
+    f = [mpq(1,3), mpq(3,2)]
+    g = [mpq(2,1)]
+    assert dmp_ff_div(f, g, 0, K) == ([mpq(1,6), mpq(3,4)], [])
+
+    f = [mpq(1,2), mpq(1,3), mpq(1,4), mpq(1,5)]
+    g = [mpq(-1,1), mpq(1,1), mpq(-1,1)]
+    assert dmp_ff_div(f, g, 0, K) == ([mpq(-1,2), mpq(-5,6)], [mpq(7,12), mpq(-19,30)])
+
+def test_dmp_ff_div():
+    raises(ZeroDivisionError, lambda: dmp_ff_div([[1, 2], [3]], [[]], 1, QQ))
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, QQ)
+    g = dmp_normal([[1], [-1, 0]], 1, QQ)
+
+    q = [[QQ(1, 1)], [QQ(1, 1), QQ(0, 1)]]
+    r = [[QQ(2, 1), QQ(0, 1), QQ(0, 1)]]
+
+    assert dmp_ff_div(f, g, 1, QQ) == (q, r)
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, QQ)
+    g = dmp_normal([[-1], [1, 0]], 1, QQ)
+
+    q = [[QQ(-1, 1)], [QQ(-1, 1), QQ(0, 1)]]
+    r = [[QQ(2, 1), QQ(0, 1), QQ(0, 1)]]
+
+    assert dmp_ff_div(f, g, 1, QQ) == (q, r)
+
+    f = dmp_normal([[1], [], [1, 0, 0]], 1, QQ)
+    g = dmp_normal([[2], [-2, 0]], 1, QQ)
+
+    q = [[QQ(1, 2)], [QQ(1, 2), QQ(0, 1)]]
+    r = [[QQ(2, 1), QQ(0, 1), QQ(0, 1)]]
+
+    assert dmp_ff_div(f, g, 1, QQ) == (q, r)
+
+
+def test_dup_div():
+    f, g, q, r = [5, 4, 3, 2, 1], [1, 2, 3], [5, -6, 0], [20, 1]
+
+    assert dup_div(f, g, ZZ) == (q, r)
+    assert dup_quo(f, g, ZZ) == q
+    assert dup_rem(f, g, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dup_exquo(f, g, ZZ))
+
+    f, g, q, r = [5, 4, 3, 2, 1, 0], [1, 2, 0, 0, 9], [5, -6], [15, 2, -44, 54]
+
+    assert dup_div(f, g, ZZ) == (q, r)
+    assert dup_quo(f, g, ZZ) == q
+    assert dup_rem(f, g, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dup_exquo(f, g, ZZ))
+
+
+def test_dmp_div():
+    f, g, q, r = [5, 4, 3, 2, 1], [1, 2, 3], [5, -6, 0], [20, 1]
+
+    assert dmp_div(f, g, 0, ZZ) == (q, r)
+    assert dmp_quo(f, g, 0, ZZ) == q
+    assert dmp_rem(f, g, 0, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dmp_exquo(f, g, 0, ZZ))
+
+    f, g, q, r = [[[1]]], [[[2]], [1]], [[[]]], [[[1]]]
+
+    assert dmp_div(f, g, 2, ZZ) == (q, r)
+    assert dmp_quo(f, g, 2, ZZ) == q
+    assert dmp_rem(f, g, 2, ZZ) == r
+
+    raises(ExactQuotientFailed, lambda: dmp_exquo(f, g, 2, ZZ))
+
+
+def test_dup_max_norm():
+    assert dup_max_norm([], ZZ) == 0
+    assert dup_max_norm([1], ZZ) == 1
+
+    assert dup_max_norm([1, 4, 2, 3], ZZ) == 4
+
+
+def test_dmp_max_norm():
+    assert dmp_max_norm([[[]]], 2, ZZ) == 0
+    assert dmp_max_norm([[[1]]], 2, ZZ) == 1
+
+    assert dmp_max_norm(f_0, 2, ZZ) == 6
+
+
+def test_dup_l1_norm():
+    assert dup_l1_norm([], ZZ) == 0
+    assert dup_l1_norm([1], ZZ) == 1
+    assert dup_l1_norm([1, 4, 2, 3], ZZ) == 10
+
+
+def test_dmp_l1_norm():
+    assert dmp_l1_norm([[[]]], 2, ZZ) == 0
+    assert dmp_l1_norm([[[1]]], 2, ZZ) == 1
+
+    assert dmp_l1_norm(f_0, 2, ZZ) == 31
+
+
+def test_dup_l2_norm_squared():
+    assert dup_l2_norm_squared([], ZZ) == 0
+    assert dup_l2_norm_squared([1], ZZ) == 1
+    assert dup_l2_norm_squared([1, 4, 2, 3], ZZ) == 30
+
+
+def test_dmp_l2_norm_squared():
+    assert dmp_l2_norm_squared([[[]]], 2, ZZ) == 0
+    assert dmp_l2_norm_squared([[[1]]], 2, ZZ) == 1
+    assert dmp_l2_norm_squared(f_0, 2, ZZ) == 111
+
+
+def test_dup_expand():
+    assert dup_expand((), ZZ) == [1]
+    assert dup_expand(([1, 2, 3], [1, 2], [7, 5, 4, 3]), ZZ) == \
+        dup_mul([1, 2, 3], dup_mul([1, 2], [7, 5, 4, 3], ZZ), ZZ)
+
+
+def test_dmp_expand():
+    assert dmp_expand((), 1, ZZ) == [[1]]
+    assert dmp_expand(([[1], [2], [3]], [[1], [2]], [[7], [5], [4], [3]]), 1, ZZ) == \
+        dmp_mul([[1], [2], [3]], dmp_mul([[1], [2]], [[7], [5], [
+                4], [3]], 1, ZZ), 1, ZZ)

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_densebasic.py

@@ -0,0 +1,730 @@
+"""Tests for dense recursive polynomials' basic tools. """
+
+from sympy.polys.densebasic import (
+    ninf,
+    dup_LC, dmp_LC,
+    dup_TC, dmp_TC,
+    dmp_ground_LC, dmp_ground_TC,
+    dmp_true_LT,
+    dup_degree, dmp_degree,
+    dmp_degree_in, dmp_degree_list,
+    dup_strip, dmp_strip,
+    dmp_validate,
+    dup_reverse,
+    dup_copy, dmp_copy,
+    dup_normal, dmp_normal,
+    dup_convert, dmp_convert,
+    dup_from_sympy, dmp_from_sympy,
+    dup_nth, dmp_nth, dmp_ground_nth,
+    dmp_zero_p, dmp_zero,
+    dmp_one_p, dmp_one,
+    dmp_ground_p, dmp_ground,
+    dmp_negative_p, dmp_positive_p,
+    dmp_zeros, dmp_grounds,
+    dup_from_dict, dup_from_raw_dict,
+    dup_to_dict, dup_to_raw_dict,
+    dmp_from_dict, dmp_to_dict,
+    dmp_swap, dmp_permute,
+    dmp_nest, dmp_raise,
+    dup_deflate, dmp_deflate,
+    dup_multi_deflate, dmp_multi_deflate,
+    dup_inflate, dmp_inflate,
+    dmp_exclude, dmp_include,
+    dmp_inject, dmp_eject,
+    dup_terms_gcd, dmp_terms_gcd,
+    dmp_list_terms, dmp_apply_pairs,
+    dup_slice,
+    dup_random,
+)
+
+from sympy.polys.specialpolys import f_polys
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.rings import ring
+
+from sympy.core.singleton import S
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import oo
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = [ f.to_dense() for f in f_polys() ]
+
+def test_dup_LC():
+    assert dup_LC([], ZZ) == 0
+    assert dup_LC([2, 3, 4, 5], ZZ) == 2
+
+
+def test_dup_TC():
+    assert dup_TC([], ZZ) == 0
+    assert dup_TC([2, 3, 4, 5], ZZ) == 5
+
+
+def test_dmp_LC():
+    assert dmp_LC([[]], ZZ) == []
+    assert dmp_LC([[2, 3, 4], [5]], ZZ) == [2, 3, 4]
+    assert dmp_LC([[[]]], ZZ) == [[]]
+    assert dmp_LC([[[2], [3, 4]], [[5]]], ZZ) == [[2], [3, 4]]
+
+
+def test_dmp_TC():
+    assert dmp_TC([[]], ZZ) == []
+    assert dmp_TC([[2, 3, 4], [5]], ZZ) == [5]
+    assert dmp_TC([[[]]], ZZ) == [[]]
+    assert dmp_TC([[[2], [3, 4]], [[5]]], ZZ) == [[5]]
+
+
+def test_dmp_ground_LC():
+    assert dmp_ground_LC([[]], 1, ZZ) == 0
+    assert dmp_ground_LC([[2, 3, 4], [5]], 1, ZZ) == 2
+    assert dmp_ground_LC([[[]]], 2, ZZ) == 0
+    assert dmp_ground_LC([[[2], [3, 4]], [[5]]], 2, ZZ) == 2
+
+
+def test_dmp_ground_TC():
+    assert dmp_ground_TC([[]], 1, ZZ) == 0
+    assert dmp_ground_TC([[2, 3, 4], [5]], 1, ZZ) == 5
+    assert dmp_ground_TC([[[]]], 2, ZZ) == 0
+    assert dmp_ground_TC([[[2], [3, 4]], [[5]]], 2, ZZ) == 5
+
+
+def test_dmp_true_LT():
+    assert dmp_true_LT([[]], 1, ZZ) == ((0, 0), 0)
+    assert dmp_true_LT([[7]], 1, ZZ) == ((0, 0), 7)
+
+    assert dmp_true_LT([[1, 0]], 1, ZZ) == ((0, 1), 1)
+    assert dmp_true_LT([[1], []], 1, ZZ) == ((1, 0), 1)
+    assert dmp_true_LT([[1, 0], []], 1, ZZ) == ((1, 1), 1)
+
+
+def test_dup_degree():
+    assert ninf == float('-inf')
+    assert dup_degree([]) is ninf
+    assert dup_degree([1]) == 0
+    assert dup_degree([1, 0]) == 1
+    assert dup_degree([1, 0, 0, 0, 1]) == 4
+
+
+def test_dmp_degree():
+    assert dmp_degree([[]], 1) is ninf
+    assert dmp_degree([[[]]], 2) is ninf
+
+    assert dmp_degree([[1]], 1) == 0
+    assert dmp_degree([[2], [1]], 1) == 1
+
+
+def test_dmp_degree_in():
+    assert dmp_degree_in([[[]]], 0, 2) is ninf
+    assert dmp_degree_in([[[]]], 1, 2) is ninf
+    assert dmp_degree_in([[[]]], 2, 2) is ninf
+
+    assert dmp_degree_in([[[1]]], 0, 2) == 0
+    assert dmp_degree_in([[[1]]], 1, 2) == 0
+    assert dmp_degree_in([[[1]]], 2, 2) == 0
+
+    assert dmp_degree_in(f_4, 0, 2) == 9
+    assert dmp_degree_in(f_4, 1, 2) == 12
+    assert dmp_degree_in(f_4, 2, 2) == 8
+
+    assert dmp_degree_in(f_6, 0, 2) == 4
+    assert dmp_degree_in(f_6, 1, 2) == 4
+    assert dmp_degree_in(f_6, 2, 2) == 6
+    assert dmp_degree_in(f_6, 3, 3) == 3
+
+    raises(IndexError, lambda: dmp_degree_in([[1]], -5, 1))
+
+
+def test_dmp_degree_list():
+    assert dmp_degree_list([[[[ ]]]], 3) == (-oo, -oo, -oo, -oo)
+    assert dmp_degree_list([[[[1]]]], 3) == ( 0, 0, 0, 0)
+
+    assert dmp_degree_list(f_0, 2) == (2, 2, 2)
+    assert dmp_degree_list(f_1, 2) == (3, 3, 3)
+    assert dmp_degree_list(f_2, 2) == (5, 3, 3)
+    assert dmp_degree_list(f_3, 2) == (5, 4, 7)
+    assert dmp_degree_list(f_4, 2) == (9, 12, 8)
+    assert dmp_degree_list(f_5, 2) == (3, 3, 3)
+    assert dmp_degree_list(f_6, 3) == (4, 4, 6, 3)
+
+
+def test_dup_strip():
+    assert dup_strip([]) == []
+    assert dup_strip([0]) == []
+    assert dup_strip([0, 0, 0]) == []
+
+    assert dup_strip([1]) == [1]
+    assert dup_strip([0, 1]) == [1]
+    assert dup_strip([0, 0, 0, 1]) == [1]
+
+    assert dup_strip([1, 2, 0]) == [1, 2, 0]
+    assert dup_strip([0, 1, 2, 0]) == [1, 2, 0]
+    assert dup_strip([0, 0, 0, 1, 2, 0]) == [1, 2, 0]
+
+
+def test_dmp_strip():
+    assert dmp_strip([0, 1, 0], 0) == [1, 0]
+
+    assert dmp_strip([[]], 1) == [[]]
+    assert dmp_strip([[], []], 1) == [[]]
+    assert dmp_strip([[], [], []], 1) == [[]]
+
+    assert dmp_strip([[[]]], 2) == [[[]]]
+    assert dmp_strip([[[]], [[]]], 2) == [[[]]]
+    assert dmp_strip([[[]], [[]], [[]]], 2) == [[[]]]
+
+    assert dmp_strip([[[1]]], 2) == [[[1]]]
+    assert dmp_strip([[[]], [[1]]], 2) == [[[1]]]
+    assert dmp_strip([[[]], [[1]], [[]]], 2) == [[[1]], [[]]]
+
+
+def test_dmp_validate():
+    assert dmp_validate([]) == ([], 0)
+    assert dmp_validate([0, 0, 0, 1, 0]) == ([1, 0], 0)
+
+    assert dmp_validate([[[]]]) == ([[[]]], 2)
+    assert dmp_validate([[0], [], [0], [1], [0]]) == ([[1], []], 1)
+
+    raises(ValueError, lambda: dmp_validate([[0], 0, [0], [1], [0]]))
+
+
+def test_dup_reverse():
+    assert dup_reverse([1, 2, 0, 3]) == [3, 0, 2, 1]
+    assert dup_reverse([1, 2, 3, 0]) == [3, 2, 1]
+
+
+def test_dup_copy():
+    f = [ZZ(1), ZZ(0), ZZ(2)]
+    g = dup_copy(f)
+
+    g[0], g[2] = ZZ(7), ZZ(0)
+
+    assert f != g
+
+
+def test_dmp_copy():
+    f = [[ZZ(1)], [ZZ(2), ZZ(0)]]
+    g = dmp_copy(f, 1)
+
+    g[0][0], g[1][1] = ZZ(7), ZZ(1)
+
+    assert f != g
+
+
+def test_dup_normal():
+    assert dup_normal([0, 0, 2, 1, 0, 11, 0], ZZ) == \
+        [ZZ(2), ZZ(1), ZZ(0), ZZ(11), ZZ(0)]
+
+
+def test_dmp_normal():
+    assert dmp_normal([[0], [], [0, 2, 1], [0], [11], []], 1, ZZ) == \
+        [[ZZ(2), ZZ(1)], [], [ZZ(11)], []]
+
+
+def test_dup_convert():
+    K0, K1 = ZZ['x'], ZZ
+
+    f = [K0(1), K0(2), K0(0), K0(3)]
+
+    assert dup_convert(f, K0, K1) == \
+        [ZZ(1), ZZ(2), ZZ(0), ZZ(3)]
+
+
+def test_dmp_convert():
+    K0, K1 = ZZ['x'], ZZ
+
+    f = [[K0(1)], [K0(2)], [], [K0(3)]]
+
+    assert dmp_convert(f, 1, K0, K1) == \
+        [[ZZ(1)], [ZZ(2)], [], [ZZ(3)]]
+
+
+def test_dup_from_sympy():
+    assert dup_from_sympy([S.One, S(2)], ZZ) == \
+        [ZZ(1), ZZ(2)]
+    assert dup_from_sympy([S.Half, S(3)], QQ) == \
+        [QQ(1, 2), QQ(3, 1)]
+
+
+def test_dmp_from_sympy():
+    assert dmp_from_sympy([[S.One, S(2)], [S.Zero]], 1, ZZ) == \
+        [[ZZ(1), ZZ(2)], []]
+    assert dmp_from_sympy([[S.Half, S(2)]], 1, QQ) == \
+        [[QQ(1, 2), QQ(2, 1)]]
+
+
+def test_dup_nth():
+    assert dup_nth([1, 2, 3], 0, ZZ) == 3
+    assert dup_nth([1, 2, 3], 1, ZZ) == 2
+    assert dup_nth([1, 2, 3], 2, ZZ) == 1
+
+    assert dup_nth([1, 2, 3], 9, ZZ) == 0
+
+    raises(IndexError, lambda: dup_nth([3, 4, 5], -1, ZZ))
+
+
+def test_dmp_nth():
+    assert dmp_nth([[1], [2], [3]], 0, 1, ZZ) == [3]
+    assert dmp_nth([[1], [2], [3]], 1, 1, ZZ) == [2]
+    assert dmp_nth([[1], [2], [3]], 2, 1, ZZ) == [1]
+
+    assert dmp_nth([[1], [2], [3]], 9, 1, ZZ) == []
+
+    raises(IndexError, lambda: dmp_nth([[3], [4], [5]], -1, 1, ZZ))
+
+
+def test_dmp_ground_nth():
+    assert dmp_ground_nth([[]], (0, 0), 1, ZZ) == 0
+    assert dmp_ground_nth([[1], [2], [3]], (0, 0), 1, ZZ) == 3
+    assert dmp_ground_nth([[1], [2], [3]], (1, 0), 1, ZZ) == 2
+    assert dmp_ground_nth([[1], [2], [3]], (2, 0), 1, ZZ) == 1
+
+    assert dmp_ground_nth([[1], [2], [3]], (2, 1), 1, ZZ) == 0
+    assert dmp_ground_nth([[1], [2], [3]], (3, 0), 1, ZZ) == 0
+
+    raises(IndexError, lambda: dmp_ground_nth([[3], [4], [5]], (2, -1), 1, ZZ))
+
+
+def test_dmp_zero_p():
+    assert dmp_zero_p([], 0) is True
+    assert dmp_zero_p([[]], 1) is True
+
+    assert dmp_zero_p([[[]]], 2) is True
+    assert dmp_zero_p([[[1]]], 2) is False
+
+
+def test_dmp_zero():
+    assert dmp_zero(0) == []
+    assert dmp_zero(2) == [[[]]]
+
+
+def test_dmp_one_p():
+    assert dmp_one_p([1], 0, ZZ) is True
+    assert dmp_one_p([[1]], 1, ZZ) is True
+    assert dmp_one_p([[[1]]], 2, ZZ) is True
+    assert dmp_one_p([[[12]]], 2, ZZ) is False
+
+
+def test_dmp_one():
+    assert dmp_one(0, ZZ) == [ZZ(1)]
+    assert dmp_one(2, ZZ) == [[[ZZ(1)]]]
+
+
+def test_dmp_ground_p():
+    assert dmp_ground_p([], 0, 0) is True
+    assert dmp_ground_p([[]], 0, 1) is True
+    assert dmp_ground_p([[]], 1, 1) is False
+
+    assert dmp_ground_p([[ZZ(1)]], 1, 1) is True
+    assert dmp_ground_p([[[ZZ(2)]]], 2, 2) is True
+
+    assert dmp_ground_p([[[ZZ(2)]]], 3, 2) is False
+    assert dmp_ground_p([[[ZZ(3)], []]], 3, 2) is False
+
+    assert dmp_ground_p([], None, 0) is True
+    assert dmp_ground_p([[]], None, 1) is True
+
+    assert dmp_ground_p([ZZ(1)], None, 0) is True
+    assert dmp_ground_p([[[ZZ(1)]]], None, 2) is True
+
+    assert dmp_ground_p([[[ZZ(3)], []]], None, 2) is False
+
+
+def test_dmp_ground():
+    assert dmp_ground(ZZ(0), 2) == [[[]]]
+
+    assert dmp_ground(ZZ(7), -1) == ZZ(7)
+    assert dmp_ground(ZZ(7), 0) == [ZZ(7)]
+    assert dmp_ground(ZZ(7), 2) == [[[ZZ(7)]]]
+
+
+def test_dmp_zeros():
+    assert dmp_zeros(4, 0, ZZ) == [[], [], [], []]
+
+    assert dmp_zeros(0, 2, ZZ) == []
+    assert dmp_zeros(1, 2, ZZ) == [[[[]]]]
+    assert dmp_zeros(2, 2, ZZ) == [[[[]]], [[[]]]]
+    assert dmp_zeros(3, 2, ZZ) == [[[[]]], [[[]]], [[[]]]]
+
+    assert dmp_zeros(3, -1, ZZ) == [0, 0, 0]
+
+
+def test_dmp_grounds():
+    assert dmp_grounds(ZZ(7), 0, 2) == []
+
+    assert dmp_grounds(ZZ(7), 1, 2) == [[[[7]]]]
+    assert dmp_grounds(ZZ(7), 2, 2) == [[[[7]]], [[[7]]]]
+    assert dmp_grounds(ZZ(7), 3, 2) == [[[[7]]], [[[7]]], [[[7]]]]
+
+    assert dmp_grounds(ZZ(7), 3, -1) == [7, 7, 7]
+
+
+def test_dmp_negative_p():
+    assert dmp_negative_p([[[]]], 2, ZZ) is False
+    assert dmp_negative_p([[[1], [2]]], 2, ZZ) is False
+    assert dmp_negative_p([[[-1], [2]]], 2, ZZ) is True
+
+
+def test_dmp_positive_p():
+    assert dmp_positive_p([[[]]], 2, ZZ) is False
+    assert dmp_positive_p([[[1], [2]]], 2, ZZ) is True
+    assert dmp_positive_p([[[-1], [2]]], 2, ZZ) is False
+
+
+def test_dup_from_to_dict():
+    assert dup_from_raw_dict({}, ZZ) == []
+    assert dup_from_dict({}, ZZ) == []
+
+    assert dup_to_raw_dict([]) == {}
+    assert dup_to_dict([]) == {}
+
+    assert dup_to_raw_dict([], ZZ, zero=True) == {0: ZZ(0)}
+    assert dup_to_dict([], ZZ, zero=True) == {(0,): ZZ(0)}
+
+    f = [3, 0, 0, 2, 0, 0, 0, 0, 8]
+    g = {8: 3, 5: 2, 0: 8}
+    h = {(8,): 3, (5,): 2, (0,): 8}
+
+    assert dup_from_raw_dict(g, ZZ) == f
+    assert dup_from_dict(h, ZZ) == f
+
+    assert dup_to_raw_dict(f) == g
+    assert dup_to_dict(f) == h
+
+    R, x,y = ring("x,y", ZZ)
+    K = R.to_domain()
+
+    f = [R(3), R(0), R(2), R(0), R(0), R(8)]
+    g = {5: R(3), 3: R(2), 0: R(8)}
+    h = {(5,): R(3), (3,): R(2), (0,): R(8)}
+
+    assert dup_from_raw_dict(g, K) == f
+    assert dup_from_dict(h, K) == f
+
+    assert dup_to_raw_dict(f) == g
+    assert dup_to_dict(f) == h
+
+
+def test_dmp_from_to_dict():
+    assert dmp_from_dict({}, 1, ZZ) == [[]]
+    assert dmp_to_dict([[]], 1) == {}
+
+    assert dmp_to_dict([], 0, ZZ, zero=True) == {(0,): ZZ(0)}
+    assert dmp_to_dict([[]], 1, ZZ, zero=True) == {(0, 0): ZZ(0)}
+
+    f = [[3], [], [], [2], [], [], [], [], [8]]
+    g = {(8, 0): 3, (5, 0): 2, (0, 0): 8}
+
+    assert dmp_from_dict(g, 1, ZZ) == f
+    assert dmp_to_dict(f, 1) == g
+
+
+def test_dmp_swap():
+    f = dmp_normal([[1, 0, 0], [], [1, 0], [], [1]], 1, ZZ)
+    g = dmp_normal([[1, 0, 0, 0, 0], [1, 0, 0], [1]], 1, ZZ)
+
+    assert dmp_swap(f, 1, 1, 1, ZZ) == f
+
+    assert dmp_swap(f, 0, 1, 1, ZZ) == g
+    assert dmp_swap(g, 0, 1, 1, ZZ) == f
+
+    raises(IndexError, lambda: dmp_swap(f, -1, -7, 1, ZZ))
+
+
+def test_dmp_permute():
+    f = dmp_normal([[1, 0, 0], [], [1, 0], [], [1]], 1, ZZ)
+    g = dmp_normal([[1, 0, 0, 0, 0], [1, 0, 0], [1]], 1, ZZ)
+
+    assert dmp_permute(f, [0, 1], 1, ZZ) == f
+    assert dmp_permute(g, [0, 1], 1, ZZ) == g
+
+    assert dmp_permute(f, [1, 0], 1, ZZ) == g
+    assert dmp_permute(g, [1, 0], 1, ZZ) == f
+
+
+def test_dmp_nest():
+    assert dmp_nest(ZZ(1), 2, ZZ) == [[[1]]]
+
+    assert dmp_nest([[1]], 0, ZZ) == [[1]]
+    assert dmp_nest([[1]], 1, ZZ) == [[[1]]]
+    assert dmp_nest([[1]], 2, ZZ) == [[[[1]]]]
+
+
+def test_dmp_raise():
+    assert dmp_raise([], 2, 0, ZZ) == [[[]]]
+    assert dmp_raise([[1]], 0, 1, ZZ) == [[1]]
+
+    assert dmp_raise([[1, 2, 3], [], [2, 3]], 2, 1, ZZ) == \
+        [[[[1]], [[2]], [[3]]], [[[]]], [[[2]], [[3]]]]
+
+
+def test_dup_deflate():
+    assert dup_deflate([], ZZ) == (1, [])
+    assert dup_deflate([2], ZZ) == (1, [2])
+    assert dup_deflate([1, 2, 3], ZZ) == (1, [1, 2, 3])
+    assert dup_deflate([1, 0, 2, 0, 3], ZZ) == (2, [1, 2, 3])
+
+    assert dup_deflate(dup_from_raw_dict({7: 1, 1: 1}, ZZ), ZZ) == \
+        (1, [1, 0, 0, 0, 0, 0, 1, 0])
+    assert dup_deflate(dup_from_raw_dict({7: 1, 0: 1}, ZZ), ZZ) == \
+        (7, [1, 1])
+    assert dup_deflate(dup_from_raw_dict({7: 1, 3: 1}, ZZ), ZZ) == \
+        (1, [1, 0, 0, 0, 1, 0, 0, 0])
+
+    assert dup_deflate(dup_from_raw_dict({7: 1, 4: 1}, ZZ), ZZ) == \
+        (1, [1, 0, 0, 1, 0, 0, 0, 0])
+    assert dup_deflate(dup_from_raw_dict({8: 1, 4: 1}, ZZ), ZZ) == \
+        (4, [1, 1, 0])
+
+    assert dup_deflate(dup_from_raw_dict({8: 1}, ZZ), ZZ) == \
+        (8, [1, 0])
+    assert dup_deflate(dup_from_raw_dict({7: 1}, ZZ), ZZ) == \
+        (7, [1, 0])
+    assert dup_deflate(dup_from_raw_dict({1: 1}, ZZ), ZZ) == \
+        (1, [1, 0])
+
+
+def test_dmp_deflate():
+    assert dmp_deflate([[]], 1, ZZ) == ((1, 1), [[]])
+    assert dmp_deflate([[2]], 1, ZZ) == ((1, 1), [[2]])
+
+    f = [[1, 0, 0], [], [1, 0], [], [1]]
+
+    assert dmp_deflate(f, 1, ZZ) == ((2, 1), [[1, 0, 0], [1, 0], [1]])
+
+
+def test_dup_multi_deflate():
+    assert dup_multi_deflate(([2],), ZZ) == (1, ([2],))
+    assert dup_multi_deflate(([], []), ZZ) == (1, ([], []))
+
+    assert dup_multi_deflate(([1, 2, 3],), ZZ) == (1, ([1, 2, 3],))
+    assert dup_multi_deflate(([1, 0, 2, 0, 3],), ZZ) == (2, ([1, 2, 3],))
+
+    assert dup_multi_deflate(([1, 0, 2, 0, 3], [2, 0, 0]), ZZ) == \
+        (2, ([1, 2, 3], [2, 0]))
+    assert dup_multi_deflate(([1, 0, 2, 0, 3], [2, 1, 0]), ZZ) == \
+        (1, ([1, 0, 2, 0, 3], [2, 1, 0]))
+
+
+def test_dmp_multi_deflate():
+    assert dmp_multi_deflate(([[]],), 1, ZZ) == \
+        ((1, 1), ([[]],))
+    assert dmp_multi_deflate(([[]], [[]]), 1, ZZ) == \
+        ((1, 1), ([[]], [[]]))
+
+    assert dmp_multi_deflate(([[1]], [[]]), 1, ZZ) == \
+        ((1, 1), ([[1]], [[]]))
+    assert dmp_multi_deflate(([[1]], [[2]]), 1, ZZ) == \
+        ((1, 1), ([[1]], [[2]]))
+    assert dmp_multi_deflate(([[1]], [[2, 0]]), 1, ZZ) == \
+        ((1, 1), ([[1]], [[2, 0]]))
+
+    assert dmp_multi_deflate(([[2, 0]], [[2, 0]]), 1, ZZ) == \
+        ((1, 1), ([[2, 0]], [[2, 0]]))
+
+    assert dmp_multi_deflate(
+        ([[2]], [[2, 0, 0]]), 1, ZZ) == ((1, 2), ([[2]], [[2, 0]]))
+    assert dmp_multi_deflate(
+        ([[2, 0, 0]], [[2, 0, 0]]), 1, ZZ) == ((1, 2), ([[2, 0]], [[2, 0]]))
+
+    assert dmp_multi_deflate(([2, 0, 0], [1, 0, 4, 0, 1]), 0, ZZ) == \
+        ((2,), ([2, 0], [1, 4, 1]))
+
+    f = [[1, 0, 0], [], [1, 0], [], [1]]
+    g = [[1, 0, 1, 0], [], [1]]
+
+    assert dmp_multi_deflate((f,), 1, ZZ) == \
+        ((2, 1), ([[1, 0, 0], [1, 0], [1]],))
+
+    assert dmp_multi_deflate((f, g), 1, ZZ) == \
+        ((2, 1), ([[1, 0, 0], [1, 0], [1]],
+                  [[1, 0, 1, 0], [1]]))
+
+
+def test_dup_inflate():
+    assert dup_inflate([], 17, ZZ) == []
+
+    assert dup_inflate([1, 2, 3], 1, ZZ) == [1, 2, 3]
+    assert dup_inflate([1, 2, 3], 2, ZZ) == [1, 0, 2, 0, 3]
+    assert dup_inflate([1, 2, 3], 3, ZZ) == [1, 0, 0, 2, 0, 0, 3]
+    assert dup_inflate([1, 2, 3], 4, ZZ) == [1, 0, 0, 0, 2, 0, 0, 0, 3]
+
+    raises(IndexError, lambda: dup_inflate([1, 2, 3], 0, ZZ))
+
+
+def test_dmp_inflate():
+    assert dmp_inflate([1], (3,), 0, ZZ) == [1]
+
+    assert dmp_inflate([[]], (3, 7), 1, ZZ) == [[]]
+    assert dmp_inflate([[2]], (1, 2), 1, ZZ) == [[2]]
+
+    assert dmp_inflate([[2, 0]], (1, 1), 1, ZZ) == [[2, 0]]
+    assert dmp_inflate([[2, 0]], (1, 2), 1, ZZ) == [[2, 0, 0]]
+    assert dmp_inflate([[2, 0]], (1, 3), 1, ZZ) == [[2, 0, 0, 0]]
+
+    assert dmp_inflate([[1, 0, 0], [1], [1, 0]], (2, 1), 1, ZZ) == \
+        [[1, 0, 0], [], [1], [], [1, 0]]
+
+    raises(IndexError, lambda: dmp_inflate([[]], (-3, 7), 1, ZZ))
+
+
+def test_dmp_exclude():
+    assert dmp_exclude([[[]]], 2, ZZ) == ([], [[[]]], 2)
+    assert dmp_exclude([[[7]]], 2, ZZ) == ([], [[[7]]], 2)
+
+    assert dmp_exclude([1, 2, 3], 0, ZZ) == ([], [1, 2, 3], 0)
+    assert dmp_exclude([[1], [2, 3]], 1, ZZ) == ([], [[1], [2, 3]], 1)
+
+    assert dmp_exclude([[1, 2, 3]], 1, ZZ) == ([0], [1, 2, 3], 0)
+    assert dmp_exclude([[1], [2], [3]], 1, ZZ) == ([1], [1, 2, 3], 0)
+
+    assert dmp_exclude([[[1, 2, 3]]], 2, ZZ) == ([0, 1], [1, 2, 3], 0)
+    assert dmp_exclude([[[1]], [[2]], [[3]]], 2, ZZ) == ([1, 2], [1, 2, 3], 0)
+
+
+def test_dmp_include():
+    assert dmp_include([1, 2, 3], [], 0, ZZ) == [1, 2, 3]
+
+    assert dmp_include([1, 2, 3], [0], 0, ZZ) == [[1, 2, 3]]
+    assert dmp_include([1, 2, 3], [1], 0, ZZ) == [[1], [2], [3]]
+
+    assert dmp_include([1, 2, 3], [0, 1], 0, ZZ) == [[[1, 2, 3]]]
+    assert dmp_include([1, 2, 3], [1, 2], 0, ZZ) == [[[1]], [[2]], [[3]]]
+
+
+def test_dmp_inject():
+    R, x,y = ring("x,y", ZZ)
+    K = R.to_domain()
+
+    assert dmp_inject([], 0, K) == ([[[]]], 2)
+    assert dmp_inject([[]], 1, K) == ([[[[]]]], 3)
+
+    assert dmp_inject([R(1)], 0, K) == ([[[1]]], 2)
+    assert dmp_inject([[R(1)]], 1, K) == ([[[[1]]]], 3)
+
+    assert dmp_inject([R(1), 2*x + 3*y + 4], 0, K) == ([[[1]], [[2], [3, 4]]], 2)
+
+    f = [3*x**2 + 7*x*y + 5*y**2, 2*x, R(0), x*y**2 + 11]
+    g = [[[3], [7, 0], [5, 0, 0]], [[2], []], [[]], [[1, 0, 0], [11]]]
+
+    assert dmp_inject(f, 0, K) == (g, 2)
+
+
+def test_dmp_eject():
+    R, x,y = ring("x,y", ZZ)
+    K = R.to_domain()
+
+    assert dmp_eject([[[]]], 2, K) == []
+    assert dmp_eject([[[[]]]], 3, K) == [[]]
+
+    assert dmp_eject([[[1]]], 2, K) == [R(1)]
+    assert dmp_eject([[[[1]]]], 3, K) == [[R(1)]]
+
+    assert dmp_eject([[[1]], [[2], [3, 4]]], 2, K) == [R(1), 2*x + 3*y + 4]
+
+    f = [3*x**2 + 7*x*y + 5*y**2, 2*x, R(0), x*y**2 + 11]
+    g = [[[3], [7, 0], [5, 0, 0]], [[2], []], [[]], [[1, 0, 0], [11]]]
+
+    assert dmp_eject(g, 2, K) == f
+
+
+def test_dup_terms_gcd():
+    assert dup_terms_gcd([], ZZ) == (0, [])
+    assert dup_terms_gcd([1, 0, 1], ZZ) == (0, [1, 0, 1])
+    assert dup_terms_gcd([1, 0, 1, 0], ZZ) == (1, [1, 0, 1])
+
+
+def test_dmp_terms_gcd():
+    assert dmp_terms_gcd([[]], 1, ZZ) == ((0, 0), [[]])
+
+    assert dmp_terms_gcd([1, 0, 1, 0], 0, ZZ) == ((1,), [1, 0, 1])
+    assert dmp_terms_gcd([[1], [], [1], []], 1, ZZ) == ((1, 0), [[1], [], [1]])
+
+    assert dmp_terms_gcd(
+        [[1, 0], [], [1]], 1, ZZ) == ((0, 0), [[1, 0], [], [1]])
+    assert dmp_terms_gcd(
+        [[1, 0], [1, 0, 0], [], []], 1, ZZ) == ((2, 1), [[1], [1, 0]])
+
+
+def test_dmp_list_terms():
+    assert dmp_list_terms([[[]]], 2, ZZ) == [((0, 0, 0), 0)]
+    assert dmp_list_terms([[[1]]], 2, ZZ) == [((0, 0, 0), 1)]
+
+    assert dmp_list_terms([1, 2, 4, 3, 5], 0, ZZ) == \
+        [((4,), 1), ((3,), 2), ((2,), 4), ((1,), 3), ((0,), 5)]
+
+    assert dmp_list_terms([[1], [2, 4], [3, 5, 0]], 1, ZZ) == \
+        [((2, 0), 1), ((1, 1), 2), ((1, 0), 4), ((0, 2), 3), ((0, 1), 5)]
+
+    f = [[2, 0, 0, 0], [1, 0, 0], []]
+
+    assert dmp_list_terms(f, 1, ZZ, order='lex') == [((2, 3), 2), ((1, 2), 1)]
+    assert dmp_list_terms(
+        f, 1, ZZ, order='grlex') == [((2, 3), 2), ((1, 2), 1)]
+
+    f = [[2, 0, 0, 0], [1, 0, 0, 0, 0, 0], []]
+
+    assert dmp_list_terms(f, 1, ZZ, order='lex') == [((2, 3), 2), ((1, 5), 1)]
+    assert dmp_list_terms(
+        f, 1, ZZ, order='grlex') == [((1, 5), 1), ((2, 3), 2)]
+
+
+def test_dmp_apply_pairs():
+    h = lambda a, b: a*b
+
+    assert dmp_apply_pairs([1, 2, 3], [4, 5, 6], h, [], 0, ZZ) == [4, 10, 18]
+
+    assert dmp_apply_pairs([2, 3], [4, 5, 6], h, [], 0, ZZ) == [10, 18]
+    assert dmp_apply_pairs([1, 2, 3], [5, 6], h, [], 0, ZZ) == [10, 18]
+
+    assert dmp_apply_pairs(
+        [[1, 2], [3]], [[4, 5], [6]], h, [], 1, ZZ) == [[4, 10], [18]]
+
+    assert dmp_apply_pairs(
+        [[1, 2], [3]], [[4], [5, 6]], h, [], 1, ZZ) == [[8], [18]]
+    assert dmp_apply_pairs(
+        [[1], [2, 3]], [[4, 5], [6]], h, [], 1, ZZ) == [[5], [18]]
+
+
+def test_dup_slice():
+    f = [1, 2, 3, 4]
+
+    assert dup_slice(f, 0, 0, ZZ) == []
+    assert dup_slice(f, 0, 1, ZZ) == [4]
+    assert dup_slice(f, 0, 2, ZZ) == [3, 4]
+    assert dup_slice(f, 0, 3, ZZ) == [2, 3, 4]
+    assert dup_slice(f, 0, 4, ZZ) == [1, 2, 3, 4]
+
+    assert dup_slice(f, 0, 4, ZZ) == f
+    assert dup_slice(f, 0, 9, ZZ) == f
+
+    assert dup_slice(f, 1, 0, ZZ) == []
+    assert dup_slice(f, 1, 1, ZZ) == []
+    assert dup_slice(f, 1, 2, ZZ) == [3, 0]
+    assert dup_slice(f, 1, 3, ZZ) == [2, 3, 0]
+    assert dup_slice(f, 1, 4, ZZ) == [1, 2, 3, 0]
+
+    assert dup_slice([1, 2], 0, 3, ZZ) == [1, 2]
+
+    g = [1, 0, 0, 2]
+
+    assert dup_slice(g, 0, 3, ZZ) == [2]
+
+
+def test_dup_random():
+    f = dup_random(0, -10, 10, ZZ)
+
+    assert dup_degree(f) == 0
+    assert all(-10 <= c <= 10 for c in f)
+
+    f = dup_random(1, -20, 20, ZZ)
+
+    assert dup_degree(f) == 1
+    assert all(-20 <= c <= 20 for c in f)
+
+    f = dup_random(2, -30, 30, ZZ)
+
+    assert dup_degree(f) == 2
+    assert all(-30 <= c <= 30 for c in f)
+
+    f = dup_random(3, -40, 40, ZZ)
+
+    assert dup_degree(f) == 3
+    assert all(-40 <= c <= 40 for c in f)

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_densetools.py

@@ -0,0 +1,715 @@
+"""Tests for dense recursive polynomials' tools. """
+
+from sympy.polys.densebasic import (
+    dup_normal, dmp_normal,
+    dup_from_raw_dict,
+    dmp_convert, dmp_swap,
+)
+
+from sympy.polys.densearith import dmp_mul_ground
+
+from sympy.polys.densetools import (
+    dup_clear_denoms, dmp_clear_denoms,
+    dup_integrate, dmp_integrate, dmp_integrate_in,
+    dup_diff, dmp_diff, dmp_diff_in,
+    dup_eval, dmp_eval, dmp_eval_in,
+    dmp_eval_tail, dmp_diff_eval_in,
+    dup_trunc, dmp_trunc, dmp_ground_trunc,
+    dup_monic, dmp_ground_monic,
+    dup_content, dmp_ground_content,
+    dup_primitive, dmp_ground_primitive,
+    dup_extract, dmp_ground_extract,
+    dup_real_imag,
+    dup_mirror, dup_scale, dup_shift, dmp_shift,
+    dup_transform,
+    dup_compose, dmp_compose,
+    dup_decompose,
+    dmp_lift,
+    dup_sign_variations,
+    dup_revert, dmp_revert,
+)
+from sympy.polys.polyclasses import ANP
+
+from sympy.polys.polyerrors import (
+    MultivariatePolynomialError,
+    ExactQuotientFailed,
+    NotReversible,
+    DomainError,
+)
+
+from sympy.polys.specialpolys import f_polys
+
+from sympy.polys.domains import FF, ZZ, QQ, ZZ_I, QQ_I, EX, RR
+from sympy.polys.rings import ring
+
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.functions.elementary.trigonometric import sin
+
+from sympy.abc import x
+from sympy.testing.pytest import raises
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = [ f.to_dense() for f in f_polys() ]
+
+def test_dup_integrate():
+    assert dup_integrate([], 1, QQ) == []
+    assert dup_integrate([], 2, QQ) == []
+
+    assert dup_integrate([QQ(1)], 1, QQ) == [QQ(1), QQ(0)]
+    assert dup_integrate([QQ(1)], 2, QQ) == [QQ(1, 2), QQ(0), QQ(0)]
+
+    assert dup_integrate([QQ(1), QQ(2), QQ(3)], 0, QQ) == \
+        [QQ(1), QQ(2), QQ(3)]
+    assert dup_integrate([QQ(1), QQ(2), QQ(3)], 1, QQ) == \
+        [QQ(1, 3), QQ(1), QQ(3), QQ(0)]
+    assert dup_integrate([QQ(1), QQ(2), QQ(3)], 2, QQ) == \
+        [QQ(1, 12), QQ(1, 3), QQ(3, 2), QQ(0), QQ(0)]
+    assert dup_integrate([QQ(1), QQ(2), QQ(3)], 3, QQ) == \
+        [QQ(1, 60), QQ(1, 12), QQ(1, 2), QQ(0), QQ(0), QQ(0)]
+
+    assert dup_integrate(dup_from_raw_dict({29: QQ(17)}, QQ), 3, QQ) == \
+        dup_from_raw_dict({32: QQ(17, 29760)}, QQ)
+
+    assert dup_integrate(dup_from_raw_dict({29: QQ(17), 5: QQ(1, 2)}, QQ), 3, QQ) == \
+        dup_from_raw_dict({32: QQ(17, 29760), 8: QQ(1, 672)}, QQ)
+
+
+def test_dmp_integrate():
+    assert dmp_integrate([QQ(1)], 2, 0, QQ) == [QQ(1, 2), QQ(0), QQ(0)]
+
+    assert dmp_integrate([[[]]], 1, 2, QQ) == [[[]]]
+    assert dmp_integrate([[[]]], 2, 2, QQ) == [[[]]]
+
+    assert dmp_integrate([[[QQ(1)]]], 1, 2, QQ) == [[[QQ(1)]], [[]]]
+    assert dmp_integrate([[[QQ(1)]]], 2, 2, QQ) == [[[QQ(1, 2)]], [[]], [[]]]
+
+    assert dmp_integrate([[QQ(1)], [QQ(2)], [QQ(3)]], 0, 1, QQ) == \
+        [[QQ(1)], [QQ(2)], [QQ(3)]]
+    assert dmp_integrate([[QQ(1)], [QQ(2)], [QQ(3)]], 1, 1, QQ) == \
+        [[QQ(1, 3)], [QQ(1)], [QQ(3)], []]
+    assert dmp_integrate([[QQ(1)], [QQ(2)], [QQ(3)]], 2, 1, QQ) == \
+        [[QQ(1, 12)], [QQ(1, 3)], [QQ(3, 2)], [], []]
+    assert dmp_integrate([[QQ(1)], [QQ(2)], [QQ(3)]], 3, 1, QQ) == \
+        [[QQ(1, 60)], [QQ(1, 12)], [QQ(1, 2)], [], [], []]
+
+
+def test_dmp_integrate_in():
+    f = dmp_convert(f_6, 3, ZZ, QQ)
+
+    assert dmp_integrate_in(f, 2, 1, 3, QQ) == \
+        dmp_swap(
+            dmp_integrate(dmp_swap(f, 0, 1, 3, QQ), 2, 3, QQ), 0, 1, 3, QQ)
+    assert dmp_integrate_in(f, 3, 1, 3, QQ) == \
+        dmp_swap(
+            dmp_integrate(dmp_swap(f, 0, 1, 3, QQ), 3, 3, QQ), 0, 1, 3, QQ)
+    assert dmp_integrate_in(f, 2, 2, 3, QQ) == \
+        dmp_swap(
+            dmp_integrate(dmp_swap(f, 0, 2, 3, QQ), 2, 3, QQ), 0, 2, 3, QQ)
+    assert dmp_integrate_in(f, 3, 2, 3, QQ) == \
+        dmp_swap(
+            dmp_integrate(dmp_swap(f, 0, 2, 3, QQ), 3, 3, QQ), 0, 2, 3, QQ)
+
+    raises(IndexError, lambda: dmp_integrate_in(f, 1, -1, 3, QQ))
+    raises(IndexError, lambda: dmp_integrate_in(f, 1, 4, 3, QQ))
+
+
+def test_dup_diff():
+    assert dup_diff([], 1, ZZ) == []
+    assert dup_diff([7], 1, ZZ) == []
+    assert dup_diff([2, 7], 1, ZZ) == [2]
+    assert dup_diff([1, 2, 1], 1, ZZ) == [2, 2]
+    assert dup_diff([1, 2, 3, 4], 1, ZZ) == [3, 4, 3]
+    assert dup_diff([1, -1, 0, 0, 2], 1, ZZ) == [4, -3, 0, 0]
+
+    f = dup_normal([17, 34, 56, -345, 23, 76, 0, 0, 12, 3, 7], ZZ)
+
+    assert dup_diff(f, 0, ZZ) == f
+    assert dup_diff(f, 1, ZZ) == [170, 306, 448, -2415, 138, 380, 0, 0, 24, 3]
+    assert dup_diff(f, 2, ZZ) == dup_diff(dup_diff(f, 1, ZZ), 1, ZZ)
+    assert dup_diff(
+        f, 3, ZZ) == dup_diff(dup_diff(dup_diff(f, 1, ZZ), 1, ZZ), 1, ZZ)
+
+    K = FF(3)
+    f = dup_normal([17, 34, 56, -345, 23, 76, 0, 0, 12, 3, 7], K)
+
+    assert dup_diff(f, 1, K) == dup_normal([2, 0, 1, 0, 0, 2, 0, 0, 0, 0], K)
+    assert dup_diff(f, 2, K) == dup_normal([1, 0, 0, 2, 0, 0, 0], K)
+    assert dup_diff(f, 3, K) == dup_normal([], K)
+
+    assert dup_diff(f, 0, K) == f
+    assert dup_diff(f, 2, K) == dup_diff(dup_diff(f, 1, K), 1, K)
+    assert dup_diff(
+        f, 3, K) == dup_diff(dup_diff(dup_diff(f, 1, K), 1, K), 1, K)
+
+
+def test_dmp_diff():
+    assert dmp_diff([], 1, 0, ZZ) == []
+    assert dmp_diff([[]], 1, 1, ZZ) == [[]]
+    assert dmp_diff([[[]]], 1, 2, ZZ) == [[[]]]
+
+    assert dmp_diff([[[1], [2]]], 1, 2, ZZ) == [[[]]]
+
+    assert dmp_diff([[[1]], [[]]], 1, 2, ZZ) == [[[1]]]
+    assert dmp_diff([[[3]], [[1]], [[]]], 1, 2, ZZ) == [[[6]], [[1]]]
+
+    assert dmp_diff([1, -1, 0, 0, 2], 1, 0, ZZ) == \
+        dup_diff([1, -1, 0, 0, 2], 1, ZZ)
+
+    assert dmp_diff(f_6, 0, 3, ZZ) == f_6
+    assert dmp_diff(f_6, 1, 3, ZZ) == [[[[8460]], [[]]],
+                       [[[135, 0, 0], [], [], [-135, 0, 0]]],
+                       [[[]]],
+                       [[[-423]], [[-47]], [[]], [[141], [], [94, 0], []], [[]]]]
+    assert dmp_diff(
+        f_6, 2, 3, ZZ) == dmp_diff(dmp_diff(f_6, 1, 3, ZZ), 1, 3, ZZ)
+    assert dmp_diff(f_6, 3, 3, ZZ) == dmp_diff(
+        dmp_diff(dmp_diff(f_6, 1, 3, ZZ), 1, 3, ZZ), 1, 3, ZZ)
+
+    K = FF(23)
+    F_6 = dmp_normal(f_6, 3, K)
+
+    assert dmp_diff(F_6, 0, 3, K) == F_6
+    assert dmp_diff(F_6, 1, 3, K) == dmp_diff(F_6, 1, 3, K)
+    assert dmp_diff(F_6, 2, 3, K) == dmp_diff(dmp_diff(F_6, 1, 3, K), 1, 3, K)
+    assert dmp_diff(F_6, 3, 3, K) == dmp_diff(
+        dmp_diff(dmp_diff(F_6, 1, 3, K), 1, 3, K), 1, 3, K)
+
+
+def test_dmp_diff_in():
+    assert dmp_diff_in(f_6, 2, 1, 3, ZZ) == \
+        dmp_swap(dmp_diff(dmp_swap(f_6, 0, 1, 3, ZZ), 2, 3, ZZ), 0, 1, 3, ZZ)
+    assert dmp_diff_in(f_6, 3, 1, 3, ZZ) == \
+        dmp_swap(dmp_diff(dmp_swap(f_6, 0, 1, 3, ZZ), 3, 3, ZZ), 0, 1, 3, ZZ)
+    assert dmp_diff_in(f_6, 2, 2, 3, ZZ) == \
+        dmp_swap(dmp_diff(dmp_swap(f_6, 0, 2, 3, ZZ), 2, 3, ZZ), 0, 2, 3, ZZ)
+    assert dmp_diff_in(f_6, 3, 2, 3, ZZ) == \
+        dmp_swap(dmp_diff(dmp_swap(f_6, 0, 2, 3, ZZ), 3, 3, ZZ), 0, 2, 3, ZZ)
+
+    raises(IndexError, lambda: dmp_diff_in(f_6, 1, -1, 3, ZZ))
+    raises(IndexError, lambda: dmp_diff_in(f_6, 1, 4, 3, ZZ))
+
+def test_dup_eval():
+    assert dup_eval([], 7, ZZ) == 0
+    assert dup_eval([1, 2], 0, ZZ) == 2
+    assert dup_eval([1, 2, 3], 7, ZZ) == 66
+
+
+def test_dmp_eval():
+    assert dmp_eval([], 3, 0, ZZ) == 0
+
+    assert dmp_eval([[]], 3, 1, ZZ) == []
+    assert dmp_eval([[[]]], 3, 2, ZZ) == [[]]
+
+    assert dmp_eval([[1, 2]], 0, 1, ZZ) == [1, 2]
+
+    assert dmp_eval([[[1]]], 3, 2, ZZ) == [[1]]
+    assert dmp_eval([[[1, 2]]], 3, 2, ZZ) == [[1, 2]]
+
+    assert dmp_eval([[3, 2], [1, 2]], 3, 1, ZZ) == [10, 8]
+    assert dmp_eval([[[3, 2]], [[1, 2]]], 3, 2, ZZ) == [[10, 8]]
+
+
+def test_dmp_eval_in():
+    assert dmp_eval_in(
+        f_6, -2, 1, 3, ZZ) == dmp_eval(dmp_swap(f_6, 0, 1, 3, ZZ), -2, 3, ZZ)
+    assert dmp_eval_in(
+        f_6, 7, 1, 3, ZZ) == dmp_eval(dmp_swap(f_6, 0, 1, 3, ZZ), 7, 3, ZZ)
+    assert dmp_eval_in(f_6, -2, 2, 3, ZZ) == dmp_swap(
+        dmp_eval(dmp_swap(f_6, 0, 2, 3, ZZ), -2, 3, ZZ), 0, 1, 2, ZZ)
+    assert dmp_eval_in(f_6, 7, 2, 3, ZZ) == dmp_swap(
+        dmp_eval(dmp_swap(f_6, 0, 2, 3, ZZ), 7, 3, ZZ), 0, 1, 2, ZZ)
+
+    f = [[[int(45)]], [[]], [[]], [[int(-9)], [-1], [], [int(3), int(0), int(10), int(0)]]]
+
+    assert dmp_eval_in(f, -2, 2, 2, ZZ) == \
+        [[45], [], [], [-9, -1, 0, -44]]
+
+    raises(IndexError, lambda: dmp_eval_in(f_6, ZZ(1), -1, 3, ZZ))
+    raises(IndexError, lambda: dmp_eval_in(f_6, ZZ(1), 4, 3, ZZ))
+
+
+def test_dmp_eval_tail():
+    assert dmp_eval_tail([[]], [1], 1, ZZ) == []
+    assert dmp_eval_tail([[[]]], [1], 2, ZZ) == [[]]
+    assert dmp_eval_tail([[[]]], [1, 2], 2, ZZ) == []
+
+    assert dmp_eval_tail(f_0, [], 2, ZZ) == f_0
+
+    assert dmp_eval_tail(f_0, [1, -17, 8], 2, ZZ) == 84496
+    assert dmp_eval_tail(f_0, [-17, 8], 2, ZZ) == [-1409, 3, 85902]
+    assert dmp_eval_tail(f_0, [8], 2, ZZ) == [[83, 2], [3], [302, 81, 1]]
+
+    assert dmp_eval_tail(f_1, [-17, 8], 2, ZZ) == [-136, 15699, 9166, -27144]
+
+    assert dmp_eval_tail(
+        f_2, [-12, 3], 2, ZZ) == [-1377, 0, -702, -1224, 0, -624]
+    assert dmp_eval_tail(
+        f_3, [-12, 3], 2, ZZ) == [144, 82, -5181, -28872, -14868, -540]
+
+    assert dmp_eval_tail(
+        f_4, [25, -1], 2, ZZ) == [152587890625, 9765625, -59605407714843750,
+        -3839159765625, -1562475, 9536712644531250, 610349546750, -4, 24414375000, 1562520]
+    assert dmp_eval_tail(f_5, [25, -1], 2, ZZ) == [-1, -78, -2028, -17576]
+
+    assert dmp_eval_tail(f_6, [0, 2, 4], 3, ZZ) == [5040, 0, 0, 4480]
+
+
+def test_dmp_diff_eval_in():
+    assert dmp_diff_eval_in(f_6, 2, 7, 1, 3, ZZ) == \
+        dmp_eval(dmp_diff(dmp_swap(f_6, 0, 1, 3, ZZ), 2, 3, ZZ), 7, 3, ZZ)
+
+    assert dmp_diff_eval_in(f_6, 2, 7, 0, 3, ZZ) == \
+        dmp_eval(dmp_diff(f_6, 2, 3, ZZ), 7, 3, ZZ)
+
+    raises(IndexError, lambda: dmp_diff_eval_in(f_6, 1, ZZ(1), 4, 3, ZZ))
+
+
+def test_dup_revert():
+    f = [-QQ(1, 720), QQ(0), QQ(1, 24), QQ(0), -QQ(1, 2), QQ(0), QQ(1)]
+    g = [QQ(61, 720), QQ(0), QQ(5, 24), QQ(0), QQ(1, 2), QQ(0), QQ(1)]
+
+    assert dup_revert(f, 8, QQ) == g
+
+    raises(NotReversible, lambda: dup_revert([QQ(1), QQ(0)], 3, QQ))
+
+
+def test_dmp_revert():
+    f = [-QQ(1, 720), QQ(0), QQ(1, 24), QQ(0), -QQ(1, 2), QQ(0), QQ(1)]
+    g = [QQ(61, 720), QQ(0), QQ(5, 24), QQ(0), QQ(1, 2), QQ(0), QQ(1)]
+
+    assert dmp_revert(f, 8, 0, QQ) == g
+
+    raises(MultivariatePolynomialError, lambda: dmp_revert([[1]], 2, 1, QQ))
+
+
+def test_dup_trunc():
+    assert dup_trunc([1, 2, 3, 4, 5, 6], ZZ(3), ZZ) == [1, -1, 0, 1, -1, 0]
+    assert dup_trunc([6, 5, 4, 3, 2, 1], ZZ(3), ZZ) == [-1, 1, 0, -1, 1]
+
+    R = ZZ_I
+    assert dup_trunc([R(3), R(4), R(5)], R(3), R) == [R(1), R(-1)]
+
+    K = FF(5)
+    assert dup_trunc([K(3), K(4), K(5)], K(3), K) == [K(1), K(0)]
+
+
+def test_dmp_trunc():
+    assert dmp_trunc([[]], [1, 2], 2, ZZ) == [[]]
+    assert dmp_trunc([[1, 2], [1, 4, 1], [1]], [1, 2], 1, ZZ) == [[-3], [1]]
+
+
+def test_dmp_ground_trunc():
+    assert dmp_ground_trunc(f_0, ZZ(3), 2, ZZ) == \
+        dmp_normal(
+            [[[1, -1, 0], [-1]], [[]], [[1, -1, 0], [1, -1, 1], [1]]], 2, ZZ)
+
+
+def test_dup_monic():
+    assert dup_monic([3, 6, 9], ZZ) == [1, 2, 3]
+
+    raises(ExactQuotientFailed, lambda: dup_monic([3, 4, 5], ZZ))
+
+    assert dup_monic([], QQ) == []
+    assert dup_monic([QQ(1)], QQ) == [QQ(1)]
+    assert dup_monic([QQ(7), QQ(1), QQ(21)], QQ) == [QQ(1), QQ(1, 7), QQ(3)]
+
+
+def test_dmp_ground_monic():
+    assert dmp_ground_monic([3, 6, 9], 0, ZZ) == [1, 2, 3]
+
+    assert dmp_ground_monic([[3], [6], [9]], 1, ZZ) == [[1], [2], [3]]
+
+    raises(
+        ExactQuotientFailed, lambda: dmp_ground_monic([[3], [4], [5]], 1, ZZ))
+
+    assert dmp_ground_monic([[]], 1, QQ) == [[]]
+    assert dmp_ground_monic([[QQ(1)]], 1, QQ) == [[QQ(1)]]
+    assert dmp_ground_monic(
+        [[QQ(7)], [QQ(1)], [QQ(21)]], 1, QQ) == [[QQ(1)], [QQ(1, 7)], [QQ(3)]]
+
+
+def test_dup_content():
+    assert dup_content([], ZZ) == ZZ(0)
+    assert dup_content([1], ZZ) == ZZ(1)
+    assert dup_content([-1], ZZ) == ZZ(1)
+    assert dup_content([1, 1], ZZ) == ZZ(1)
+    assert dup_content([2, 2], ZZ) == ZZ(2)
+    assert dup_content([1, 2, 1], ZZ) == ZZ(1)
+    assert dup_content([2, 4, 2], ZZ) == ZZ(2)
+
+    assert dup_content([QQ(2, 3), QQ(4, 9)], QQ) == QQ(2, 9)
+    assert dup_content([QQ(2, 3), QQ(4, 5)], QQ) == QQ(2, 15)
+
+
+def test_dmp_ground_content():
+    assert dmp_ground_content([[]], 1, ZZ) == ZZ(0)
+    assert dmp_ground_content([[]], 1, QQ) == QQ(0)
+    assert dmp_ground_content([[1]], 1, ZZ) == ZZ(1)
+    assert dmp_ground_content([[-1]], 1, ZZ) == ZZ(1)
+    assert dmp_ground_content([[1], [1]], 1, ZZ) == ZZ(1)
+    assert dmp_ground_content([[2], [2]], 1, ZZ) == ZZ(2)
+    assert dmp_ground_content([[1], [2], [1]], 1, ZZ) == ZZ(1)
+    assert dmp_ground_content([[2], [4], [2]], 1, ZZ) == ZZ(2)
+
+    assert dmp_ground_content([[QQ(2, 3)], [QQ(4, 9)]], 1, QQ) == QQ(2, 9)
+    assert dmp_ground_content([[QQ(2, 3)], [QQ(4, 5)]], 1, QQ) == QQ(2, 15)
+
+    assert dmp_ground_content(f_0, 2, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_0, ZZ(2), 2, ZZ), 2, ZZ) == ZZ(2)
+
+    assert dmp_ground_content(f_1, 2, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_1, ZZ(3), 2, ZZ), 2, ZZ) == ZZ(3)
+
+    assert dmp_ground_content(f_2, 2, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_2, ZZ(4), 2, ZZ), 2, ZZ) == ZZ(4)
+
+    assert dmp_ground_content(f_3, 2, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_3, ZZ(5), 2, ZZ), 2, ZZ) == ZZ(5)
+
+    assert dmp_ground_content(f_4, 2, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_4, ZZ(6), 2, ZZ), 2, ZZ) == ZZ(6)
+
+    assert dmp_ground_content(f_5, 2, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_5, ZZ(7), 2, ZZ), 2, ZZ) == ZZ(7)
+
+    assert dmp_ground_content(f_6, 3, ZZ) == ZZ(1)
+    assert dmp_ground_content(
+        dmp_mul_ground(f_6, ZZ(8), 3, ZZ), 3, ZZ) == ZZ(8)
+
+
+def test_dup_primitive():
+    assert dup_primitive([], ZZ) == (ZZ(0), [])
+    assert dup_primitive([ZZ(1)], ZZ) == (ZZ(1), [ZZ(1)])
+    assert dup_primitive([ZZ(1), ZZ(1)], ZZ) == (ZZ(1), [ZZ(1), ZZ(1)])
+    assert dup_primitive([ZZ(2), ZZ(2)], ZZ) == (ZZ(2), [ZZ(1), ZZ(1)])
+    assert dup_primitive(
+        [ZZ(1), ZZ(2), ZZ(1)], ZZ) == (ZZ(1), [ZZ(1), ZZ(2), ZZ(1)])
+    assert dup_primitive(
+        [ZZ(2), ZZ(4), ZZ(2)], ZZ) == (ZZ(2), [ZZ(1), ZZ(2), ZZ(1)])
+
+    assert dup_primitive([], QQ) == (QQ(0), [])
+    assert dup_primitive([QQ(1)], QQ) == (QQ(1), [QQ(1)])
+    assert dup_primitive([QQ(1), QQ(1)], QQ) == (QQ(1), [QQ(1), QQ(1)])
+    assert dup_primitive([QQ(2), QQ(2)], QQ) == (QQ(2), [QQ(1), QQ(1)])
+    assert dup_primitive(
+        [QQ(1), QQ(2), QQ(1)], QQ) == (QQ(1), [QQ(1), QQ(2), QQ(1)])
+    assert dup_primitive(
+        [QQ(2), QQ(4), QQ(2)], QQ) == (QQ(2), [QQ(1), QQ(2), QQ(1)])
+
+    assert dup_primitive(
+        [QQ(2, 3), QQ(4, 9)], QQ) == (QQ(2, 9), [QQ(3), QQ(2)])
+    assert dup_primitive(
+        [QQ(2, 3), QQ(4, 5)], QQ) == (QQ(2, 15), [QQ(5), QQ(6)])
+
+
+def test_dmp_ground_primitive():
+    assert dmp_ground_primitive([ZZ(1)], 0, ZZ) == (ZZ(1), [ZZ(1)])
+
+    assert dmp_ground_primitive([[]], 1, ZZ) == (ZZ(0), [[]])
+
+    assert dmp_ground_primitive(f_0, 2, ZZ) == (ZZ(1), f_0)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_0, ZZ(2), 2, ZZ), 2, ZZ) == (ZZ(2), f_0)
+
+    assert dmp_ground_primitive(f_1, 2, ZZ) == (ZZ(1), f_1)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_1, ZZ(3), 2, ZZ), 2, ZZ) == (ZZ(3), f_1)
+
+    assert dmp_ground_primitive(f_2, 2, ZZ) == (ZZ(1), f_2)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_2, ZZ(4), 2, ZZ), 2, ZZ) == (ZZ(4), f_2)
+
+    assert dmp_ground_primitive(f_3, 2, ZZ) == (ZZ(1), f_3)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_3, ZZ(5), 2, ZZ), 2, ZZ) == (ZZ(5), f_3)
+
+    assert dmp_ground_primitive(f_4, 2, ZZ) == (ZZ(1), f_4)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_4, ZZ(6), 2, ZZ), 2, ZZ) == (ZZ(6), f_4)
+
+    assert dmp_ground_primitive(f_5, 2, ZZ) == (ZZ(1), f_5)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_5, ZZ(7), 2, ZZ), 2, ZZ) == (ZZ(7), f_5)
+
+    assert dmp_ground_primitive(f_6, 3, ZZ) == (ZZ(1), f_6)
+    assert dmp_ground_primitive(
+        dmp_mul_ground(f_6, ZZ(8), 3, ZZ), 3, ZZ) == (ZZ(8), f_6)
+
+    assert dmp_ground_primitive([[ZZ(2)]], 1, ZZ) == (ZZ(2), [[ZZ(1)]])
+    assert dmp_ground_primitive([[QQ(2)]], 1, QQ) == (QQ(2), [[QQ(1)]])
+
+    assert dmp_ground_primitive(
+        [[QQ(2, 3)], [QQ(4, 9)]], 1, QQ) == (QQ(2, 9), [[QQ(3)], [QQ(2)]])
+    assert dmp_ground_primitive(
+        [[QQ(2, 3)], [QQ(4, 5)]], 1, QQ) == (QQ(2, 15), [[QQ(5)], [QQ(6)]])
+
+
+def test_dup_extract():
+    f = dup_normal([2930944, 0, 2198208, 0, 549552, 0, 45796], ZZ)
+    g = dup_normal([17585664, 0, 8792832, 0, 1099104, 0], ZZ)
+
+    F = dup_normal([64, 0, 48, 0, 12, 0, 1], ZZ)
+    G = dup_normal([384, 0, 192, 0, 24, 0], ZZ)
+
+    assert dup_extract(f, g, ZZ) == (45796, F, G)
+
+
+def test_dmp_ground_extract():
+    f = dmp_normal(
+        [[2930944], [], [2198208], [], [549552], [], [45796]], 1, ZZ)
+    g = dmp_normal([[17585664], [], [8792832], [], [1099104], []], 1, ZZ)
+
+    F = dmp_normal([[64], [], [48], [], [12], [], [1]], 1, ZZ)
+    G = dmp_normal([[384], [], [192], [], [24], []], 1, ZZ)
+
+    assert dmp_ground_extract(f, g, 1, ZZ) == (45796, F, G)
+
+
+def test_dup_real_imag():
+    assert dup_real_imag([], ZZ) == ([[]], [[]])
+    assert dup_real_imag([1], ZZ) == ([[1]], [[]])
+
+    assert dup_real_imag([1, 1], ZZ) == ([[1], [1]], [[1, 0]])
+    assert dup_real_imag([1, 2], ZZ) == ([[1], [2]], [[1, 0]])
+
+    assert dup_real_imag(
+        [1, 2, 3], ZZ) == ([[1], [2], [-1, 0, 3]], [[2, 0], [2, 0]])
+
+    assert dup_real_imag([ZZ(1), ZZ(0), ZZ(1), ZZ(3)], ZZ) == (
+        [[ZZ(1)], [], [ZZ(-3), ZZ(0), ZZ(1)], [ZZ(3)]],
+        [[ZZ(3), ZZ(0)], [], [ZZ(-1), ZZ(0), ZZ(1), ZZ(0)]]
+    )
+
+    raises(DomainError, lambda: dup_real_imag([EX(1), EX(2)], EX))
+
+
+
+def test_dup_mirror():
+    assert dup_mirror([], ZZ) == []
+    assert dup_mirror([1], ZZ) == [1]
+
+    assert dup_mirror([1, 2, 3, 4, 5], ZZ) == [1, -2, 3, -4, 5]
+    assert dup_mirror([1, 2, 3, 4, 5, 6], ZZ) == [-1, 2, -3, 4, -5, 6]
+
+
+def test_dup_scale():
+    assert dup_scale([], -1, ZZ) == []
+    assert dup_scale([1], -1, ZZ) == [1]
+
+    assert dup_scale([1, 2, 3, 4, 5], -1, ZZ) == [1, -2, 3, -4, 5]
+    assert dup_scale([1, 2, 3, 4, 5], -7, ZZ) == [2401, -686, 147, -28, 5]
+
+
+def test_dup_shift():
+    assert dup_shift([], 1, ZZ) == []
+    assert dup_shift([1], 1, ZZ) == [1]
+
+    assert dup_shift([1, 2, 3, 4, 5], 1, ZZ) == [1, 6, 15, 20, 15]
+    assert dup_shift([1, 2, 3, 4, 5], 7, ZZ) == [1, 30, 339, 1712, 3267]
+
+
+def test_dmp_shift():
+    assert dmp_shift([ZZ(1), ZZ(2)], [ZZ(1)], 0, ZZ) == [ZZ(1), ZZ(3)]
+
+    assert dmp_shift([[]], [ZZ(1), ZZ(2)], 1, ZZ) == [[]]
+
+    xy = [[ZZ(1), ZZ(0)], []]               # x*y
+    x1y2 = [[ZZ(1), ZZ(2)], [ZZ(1), ZZ(2)]] # (x+1)*(y+2)
+    assert dmp_shift(xy, [ZZ(1), ZZ(2)], 1, ZZ) == x1y2
+
+
+def test_dup_transform():
+    assert dup_transform([], [], [1, 1], ZZ) == []
+    assert dup_transform([], [1], [1, 1], ZZ) == []
+    assert dup_transform([], [1, 2], [1, 1], ZZ) == []
+
+    assert dup_transform([6, -5, 4, -3, 17], [1, -3, 4], [2, -3], ZZ) == \
+        [6, -82, 541, -2205, 6277, -12723, 17191, -13603, 4773]
+
+
+def test_dup_compose():
+    assert dup_compose([], [], ZZ) == []
+    assert dup_compose([], [1], ZZ) == []
+    assert dup_compose([], [1, 2], ZZ) == []
+
+    assert dup_compose([1], [], ZZ) == [1]
+
+    assert dup_compose([1, 2, 0], [], ZZ) == []
+    assert dup_compose([1, 2, 1], [], ZZ) == [1]
+
+    assert dup_compose([1, 2, 1], [1], ZZ) == [4]
+    assert dup_compose([1, 2, 1], [7], ZZ) == [64]
+
+    assert dup_compose([1, 2, 1], [1, -1], ZZ) == [1, 0, 0]
+    assert dup_compose([1, 2, 1], [1, 1], ZZ) == [1, 4, 4]
+    assert dup_compose([1, 2, 1], [1, 2, 1], ZZ) == [1, 4, 8, 8, 4]
+
+
+def test_dmp_compose():
+    assert dmp_compose([1, 2, 1], [1, 2, 1], 0, ZZ) == [1, 4, 8, 8, 4]
+
+    assert dmp_compose([[[]]], [[[]]], 2, ZZ) == [[[]]]
+    assert dmp_compose([[[]]], [[[1]]], 2, ZZ) == [[[]]]
+    assert dmp_compose([[[]]], [[[1]], [[2]]], 2, ZZ) == [[[]]]
+
+    assert dmp_compose([[[1]]], [], 2, ZZ) == [[[1]]]
+
+    assert dmp_compose([[1], [2], [ ]], [[]], 1, ZZ) == [[]]
+    assert dmp_compose([[1], [2], [1]], [[]], 1, ZZ) == [[1]]
+
+    assert dmp_compose([[1], [2], [1]], [[1]], 1, ZZ) == [[4]]
+    assert dmp_compose([[1], [2], [1]], [[7]], 1, ZZ) == [[64]]
+
+    assert dmp_compose([[1], [2], [1]], [[1], [-1]], 1, ZZ) == [[1], [ ], [ ]]
+    assert dmp_compose([[1], [2], [1]], [[1], [ 1]], 1, ZZ) == [[1], [4], [4]]
+
+    assert dmp_compose(
+        [[1], [2], [1]], [[1], [2], [1]], 1, ZZ) == [[1], [4], [8], [8], [4]]
+
+
+def test_dup_decompose():
+    assert dup_decompose([1], ZZ) == [[1]]
+
+    assert dup_decompose([1, 0], ZZ) == [[1, 0]]
+    assert dup_decompose([1, 0, 0, 0], ZZ) == [[1, 0, 0, 0]]
+
+    assert dup_decompose([1, 0, 0, 0, 0], ZZ) == [[1, 0, 0], [1, 0, 0]]
+    assert dup_decompose(
+        [1, 0, 0, 0, 0, 0, 0], ZZ) == [[1, 0, 0, 0], [1, 0, 0]]
+
+    assert dup_decompose([7, 0, 0, 0, 1], ZZ) == [[7, 0, 1], [1, 0, 0]]
+    assert dup_decompose([4, 0, 3, 0, 2], ZZ) == [[4, 3, 2], [1, 0, 0]]
+
+    f = [1, 0, 20, 0, 150, 0, 500, 0, 625, -2, 0, -10, 9]
+
+    assert dup_decompose(f, ZZ) == [[1, 0, 0, -2, 9], [1, 0, 5, 0]]
+
+    f = [2, 0, 40, 0, 300, 0, 1000, 0, 1250, -4, 0, -20, 18]
+
+    assert dup_decompose(f, ZZ) == [[2, 0, 0, -4, 18], [1, 0, 5, 0]]
+
+    f = [1, 0, 20, -8, 150, -120, 524, -600, 865, -1034, 600, -170, 29]
+
+    assert dup_decompose(f, ZZ) == [[1, -8, 24, -34, 29], [1, 0, 5, 0]]
+
+    R, t = ring("t", ZZ)
+    f = [6*t**2 - 42,
+         48*t**2 + 96,
+         144*t**2 + 648*t + 288,
+         624*t**2 + 864*t + 384,
+         108*t**3 + 312*t**2 + 432*t + 192]
+
+    assert dup_decompose(f, R.to_domain()) == [f]
+
+
+def test_dmp_lift():
+    q = [QQ(1, 1), QQ(0, 1), QQ(1, 1)]
+
+    f_a = [ANP([QQ(1, 1)], q, QQ), ANP([], q, QQ), ANP([], q, QQ),
+         ANP([QQ(1, 1), QQ(0, 1)], q, QQ), ANP([QQ(17, 1), QQ(0, 1)], q, QQ)]
+
+    f_lift = [QQ(1), QQ(0), QQ(0), QQ(0), QQ(0), QQ(0), QQ(2), QQ(0), QQ(578),
+              QQ(0), QQ(0), QQ(0), QQ(1), QQ(0), QQ(-578), QQ(0), QQ(83521)]
+
+    assert dmp_lift(f_a, 0, QQ.algebraic_field(I)) == f_lift
+
+    f_g = [QQ_I(1), QQ_I(0), QQ_I(0), QQ_I(0, 1), QQ_I(0, 17)]
+
+    assert dmp_lift(f_g, 0, QQ_I) == f_lift
+
+    raises(DomainError, lambda: dmp_lift([EX(1), EX(2)], 0, EX))
+
+
+def test_dup_sign_variations():
+    assert dup_sign_variations([], ZZ) == 0
+    assert dup_sign_variations([1, 0], ZZ) == 0
+    assert dup_sign_variations([1, 0, 2], ZZ) == 0
+    assert dup_sign_variations([1, 0, 3, 0], ZZ) == 0
+    assert dup_sign_variations([1, 0, 4, 0, 5], ZZ) == 0
+
+    assert dup_sign_variations([-1, 0, 2], ZZ) == 1
+    assert dup_sign_variations([-1, 0, 3, 0], ZZ) == 1
+    assert dup_sign_variations([-1, 0, 4, 0, 5], ZZ) == 1
+
+    assert dup_sign_variations([-1, -4, -5], ZZ) == 0
+    assert dup_sign_variations([ 1, -4, -5], ZZ) == 1
+    assert dup_sign_variations([ 1, 4, -5], ZZ) == 1
+    assert dup_sign_variations([ 1, -4, 5], ZZ) == 2
+    assert dup_sign_variations([-1, 4, -5], ZZ) == 2
+    assert dup_sign_variations([-1, 4, 5], ZZ) == 1
+    assert dup_sign_variations([-1, -4, 5], ZZ) == 1
+    assert dup_sign_variations([ 1, 4, 5], ZZ) == 0
+
+    assert dup_sign_variations([-1, 0, -4, 0, -5], ZZ) == 0
+    assert dup_sign_variations([ 1, 0, -4, 0, -5], ZZ) == 1
+    assert dup_sign_variations([ 1, 0, 4, 0, -5], ZZ) == 1
+    assert dup_sign_variations([ 1, 0, -4, 0, 5], ZZ) == 2
+    assert dup_sign_variations([-1, 0, 4, 0, -5], ZZ) == 2
+    assert dup_sign_variations([-1, 0, 4, 0, 5], ZZ) == 1
+    assert dup_sign_variations([-1, 0, -4, 0, 5], ZZ) == 1
+    assert dup_sign_variations([ 1, 0, 4, 0, 5], ZZ) == 0
+
+
+def test_dup_clear_denoms():
+    assert dup_clear_denoms([], QQ, ZZ) == (ZZ(1), [])
+
+    assert dup_clear_denoms([QQ(1)], QQ, ZZ) == (ZZ(1), [QQ(1)])
+    assert dup_clear_denoms([QQ(7)], QQ, ZZ) == (ZZ(1), [QQ(7)])
+
+    assert dup_clear_denoms([QQ(7, 3)], QQ) == (ZZ(3), [QQ(7)])
+    assert dup_clear_denoms([QQ(7, 3)], QQ, ZZ) == (ZZ(3), [QQ(7)])
+
+    assert dup_clear_denoms(
+        [QQ(3), QQ(1), QQ(0)], QQ, ZZ) == (ZZ(1), [QQ(3), QQ(1), QQ(0)])
+    assert dup_clear_denoms(
+        [QQ(1), QQ(1, 2), QQ(0)], QQ, ZZ) == (ZZ(2), [QQ(2), QQ(1), QQ(0)])
+
+    assert dup_clear_denoms([QQ(3), QQ(
+        1), QQ(0)], QQ, ZZ, convert=True) == (ZZ(1), [ZZ(3), ZZ(1), ZZ(0)])
+    assert dup_clear_denoms([QQ(1), QQ(
+        1, 2), QQ(0)], QQ, ZZ, convert=True) == (ZZ(2), [ZZ(2), ZZ(1), ZZ(0)])
+
+    assert dup_clear_denoms(
+        [EX(S(3)/2), EX(S(9)/4)], EX) == (EX(4), [EX(6), EX(9)])
+
+    assert dup_clear_denoms([EX(7)], EX) == (EX(1), [EX(7)])
+    assert dup_clear_denoms([EX(sin(x)/x), EX(0)], EX) == (EX(x), [EX(sin(x)), EX(0)])
+
+    F = RR.frac_field(x)
+    result = dup_clear_denoms([F(8.48717/(8.0089*x + 2.83)), F(0.0)], F)
+    assert str(result) == "(x + 0.353356890459364, [1.05971731448763, 0.0])"
+
+def test_dmp_clear_denoms():
+    assert dmp_clear_denoms([[]], 1, QQ, ZZ) == (ZZ(1), [[]])
+
+    assert dmp_clear_denoms([[QQ(1)]], 1, QQ, ZZ) == (ZZ(1), [[QQ(1)]])
+    assert dmp_clear_denoms([[QQ(7)]], 1, QQ, ZZ) == (ZZ(1), [[QQ(7)]])
+
+    assert dmp_clear_denoms([[QQ(7, 3)]], 1, QQ) == (ZZ(3), [[QQ(7)]])
+    assert dmp_clear_denoms([[QQ(7, 3)]], 1, QQ, ZZ) == (ZZ(3), [[QQ(7)]])
+
+    assert dmp_clear_denoms(
+        [[QQ(3)], [QQ(1)], []], 1, QQ, ZZ) == (ZZ(1), [[QQ(3)], [QQ(1)], []])
+    assert dmp_clear_denoms([[QQ(
+        1)], [QQ(1, 2)], []], 1, QQ, ZZ) == (ZZ(2), [[QQ(2)], [QQ(1)], []])
+
+    assert dmp_clear_denoms([QQ(3), QQ(
+        1), QQ(0)], 0, QQ, ZZ, convert=True) == (ZZ(1), [ZZ(3), ZZ(1), ZZ(0)])
+    assert dmp_clear_denoms([QQ(1), QQ(1, 2), QQ(
+        0)], 0, QQ, ZZ, convert=True) == (ZZ(2), [ZZ(2), ZZ(1), ZZ(0)])
+
+    assert dmp_clear_denoms([[QQ(3)], [QQ(
+        1)], []], 1, QQ, ZZ, convert=True) == (ZZ(1), [[QQ(3)], [QQ(1)], []])
+    assert dmp_clear_denoms([[QQ(1)], [QQ(1, 2)], []], 1, QQ, ZZ,
+                            convert=True) == (ZZ(2), [[QQ(2)], [QQ(1)], []])
+
+    assert dmp_clear_denoms(
+        [[EX(S(3)/2)], [EX(S(9)/4)]], 1, EX) == (EX(4), [[EX(6)], [EX(9)]])
+    assert dmp_clear_denoms([[EX(7)]], 1, EX) == (EX(1), [[EX(7)]])
+    assert dmp_clear_denoms([[EX(sin(x)/x), EX(0)]], 1, EX) == (EX(x), [[EX(sin(x)), EX(0)]])

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_dispersion.py

@@ -0,0 +1,95 @@
+from sympy.core import Symbol, S, oo
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys import poly
+from sympy.polys.dispersion import dispersion, dispersionset
+
+
+def test_dispersion():
+    x = Symbol("x")
+    a = Symbol("a")
+
+    fp = poly(S.Zero, x)
+    assert sorted(dispersionset(fp)) == [0]
+
+    fp = poly(S(2), x)
+    assert sorted(dispersionset(fp)) == [0]
+
+    fp = poly(x + 1, x)
+    assert sorted(dispersionset(fp)) == [0]
+    assert dispersion(fp) == 0
+
+    fp = poly((x + 1)*(x + 2), x)
+    assert sorted(dispersionset(fp)) == [0, 1]
+    assert dispersion(fp) == 1
+
+    fp = poly(x*(x + 3), x)
+    assert sorted(dispersionset(fp)) == [0, 3]
+    assert dispersion(fp) == 3
+
+    fp = poly((x - 3)*(x + 3), x)
+    assert sorted(dispersionset(fp)) == [0, 6]
+    assert dispersion(fp) == 6
+
+    fp = poly(x**4 - 3*x**2 + 1, x)
+    gp = fp.shift(-3)
+    assert sorted(dispersionset(fp, gp)) == [2, 3, 4]
+    assert dispersion(fp, gp) == 4
+    assert sorted(dispersionset(gp, fp)) == []
+    assert dispersion(gp, fp) is -oo
+
+    fp = poly(x*(3*x**2+a)*(x-2536)*(x**3+a), x)
+    gp = fp.as_expr().subs(x, x-345).as_poly(x)
+    assert sorted(dispersionset(fp, gp)) == [345, 2881]
+    assert sorted(dispersionset(gp, fp)) == [2191]
+
+    gp = poly((x-2)**2*(x-3)**3*(x-5)**3, x)
+    assert sorted(dispersionset(gp)) == [0, 1, 2, 3]
+    assert sorted(dispersionset(gp, (gp+4)**2)) == [1, 2]
+
+    fp = poly(x*(x+2)*(x-1), x)
+    assert sorted(dispersionset(fp)) == [0, 1, 2, 3]
+
+    fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')
+    gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')
+    assert sorted(dispersionset(fp, gp)) == [2]
+    assert sorted(dispersionset(gp, fp)) == [1, 4]
+
+    # There are some difficulties if we compute over Z[a]
+    # and alpha happenes to lie in Z[a] instead of simply Z.
+    # Hence we can not decide if alpha is indeed integral
+    # in general.
+
+    fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)
+    assert sorted(dispersionset(fp)) == [0, 1]
+
+    # For any specific value of a, the dispersion is 3*a
+    # but the algorithm can not find this in general.
+    # This is the point where the resultant based Ansatz
+    # is superior to the current one.
+    fp = poly(a**2*x**3 + (a**3 + a**2 + a + 1)*x, x)
+    gp = fp.as_expr().subs(x, x - 3*a).as_poly(x)
+    assert sorted(dispersionset(fp, gp)) == []
+
+    fpa = fp.as_expr().subs(a, 2).as_poly(x)
+    gpa = gp.as_expr().subs(a, 2).as_poly(x)
+    assert sorted(dispersionset(fpa, gpa)) == [6]
+
+    # Work with Expr instead of Poly
+    f = (x + 1)*(x + 2)
+    assert sorted(dispersionset(f)) == [0, 1]
+    assert dispersion(f) == 1
+
+    f = x**4 - 3*x**2 + 1
+    g = x**4 - 12*x**3 + 51*x**2 - 90*x + 55
+    assert sorted(dispersionset(f, g)) == [2, 3, 4]
+    assert dispersion(f, g) == 4
+
+    # Work with Expr and specify a generator
+    f = (x + 1)*(x + 2)
+    assert sorted(dispersionset(f, None, x)) == [0, 1]
+    assert dispersion(f, None, x) == 1
+
+    f = x**4 - 3*x**2 + 1
+    g = x**4 - 12*x**3 + 51*x**2 - 90*x + 55
+    assert sorted(dispersionset(f, g, x)) == [2, 3, 4]
+    assert dispersion(f, g, x) == 4

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_distributedmodules.py

@@ -0,0 +1,208 @@
+"""Tests for sparse distributed modules. """
+
+from sympy.polys.distributedmodules import (
+    sdm_monomial_mul, sdm_monomial_deg, sdm_monomial_divides,
+    sdm_add, sdm_LM, sdm_LT, sdm_mul_term, sdm_zero, sdm_deg,
+    sdm_LC, sdm_from_dict,
+    sdm_spoly, sdm_ecart, sdm_nf_mora, sdm_groebner,
+    sdm_from_vector, sdm_to_vector, sdm_monomial_lcm
+)
+
+from sympy.polys.orderings import lex, grlex, InverseOrder
+from sympy.polys.domains import QQ
+
+from sympy.abc import x, y, z
+
+
+def test_sdm_monomial_mul():
+    assert sdm_monomial_mul((1, 1, 0), (1, 3)) == (1, 2, 3)
+
+
+def test_sdm_monomial_deg():
+    assert sdm_monomial_deg((5, 2, 1)) == 3
+
+
+def test_sdm_monomial_lcm():
+    assert sdm_monomial_lcm((1, 2, 3), (1, 5, 0)) == (1, 5, 3)
+
+
+def test_sdm_monomial_divides():
+    assert sdm_monomial_divides((1, 0, 0), (1, 0, 0)) is True
+    assert sdm_monomial_divides((1, 0, 0), (1, 2, 1)) is True
+    assert sdm_monomial_divides((5, 1, 1), (5, 2, 1)) is True
+
+    assert sdm_monomial_divides((1, 0, 0), (2, 0, 0)) is False
+    assert sdm_monomial_divides((1, 1, 0), (1, 0, 0)) is False
+    assert sdm_monomial_divides((5, 1, 2), (5, 0, 1)) is False
+
+
+def test_sdm_LC():
+    assert sdm_LC([((1, 2, 3), QQ(5))], QQ) == QQ(5)
+
+
+def test_sdm_from_dict():
+    dic = {(1, 2, 1, 1): QQ(1), (1, 1, 2, 1): QQ(1), (1, 0, 2, 1): QQ(1),
+           (1, 0, 0, 3): QQ(1), (1, 1, 1, 0): QQ(1)}
+    assert sdm_from_dict(dic, grlex) == \
+        [((1, 2, 1, 1), QQ(1)), ((1, 1, 2, 1), QQ(1)),
+         ((1, 0, 2, 1), QQ(1)), ((1, 0, 0, 3), QQ(1)), ((1, 1, 1, 0), QQ(1))]
+
+# TODO test to_dict?
+
+
+def test_sdm_add():
+    assert sdm_add([((1, 1, 1), QQ(1))], [((2, 0, 0), QQ(1))], lex, QQ) == \
+        [((2, 0, 0), QQ(1)), ((1, 1, 1), QQ(1))]
+    assert sdm_add([((1, 1, 1), QQ(1))], [((1, 1, 1), QQ(-1))], lex, QQ) == []
+    assert sdm_add([((1, 0, 0), QQ(1))], [((1, 0, 0), QQ(2))], lex, QQ) == \
+        [((1, 0, 0), QQ(3))]
+    assert sdm_add([((1, 0, 1), QQ(1))], [((1, 1, 0), QQ(1))], lex, QQ) == \
+        [((1, 1, 0), QQ(1)), ((1, 0, 1), QQ(1))]
+
+
+def test_sdm_LM():
+    dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(1), (4, 0, 1): QQ(1)}
+    assert sdm_LM(sdm_from_dict(dic, lex)) == (4, 0, 1)
+
+
+def test_sdm_LT():
+    dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(2), (4, 0, 1): QQ(3)}
+    assert sdm_LT(sdm_from_dict(dic, lex)) == ((4, 0, 1), QQ(3))
+
+
+def test_sdm_mul_term():
+    assert sdm_mul_term([((1, 0, 0), QQ(1))], ((0, 0), QQ(0)), lex, QQ) == []
+    assert sdm_mul_term([], ((1, 0), QQ(1)), lex, QQ) == []
+    assert sdm_mul_term([((1, 0, 0), QQ(1))], ((1, 0), QQ(1)), lex, QQ) == \
+        [((1, 1, 0), QQ(1))]
+    f = [((2, 0, 1), QQ(4)), ((1, 1, 0), QQ(3))]
+    assert sdm_mul_term(f, ((1, 1), QQ(2)), lex, QQ) == \
+        [((2, 1, 2), QQ(8)), ((1, 2, 1), QQ(6))]
+
+
+def test_sdm_zero():
+    assert sdm_zero() == []
+
+
+def test_sdm_deg():
+    assert sdm_deg([((1, 2, 3), 1), ((10, 0, 1), 1), ((2, 3, 4), 4)]) == 7
+
+
+def test_sdm_spoly():
+    f = [((2, 1, 1), QQ(1)), ((1, 0, 1), QQ(1))]
+    g = [((2, 3, 0), QQ(1))]
+    h = [((1, 2, 3), QQ(1))]
+    assert sdm_spoly(f, h, lex, QQ) == []
+    assert sdm_spoly(f, g, lex, QQ) == [((1, 2, 1), QQ(1))]
+
+
+def test_sdm_ecart():
+    assert sdm_ecart([((1, 2, 3), 1), ((1, 0, 1), 1)]) == 0
+    assert sdm_ecart([((2, 2, 1), 1), ((1, 5, 1), 1)]) == 3
+
+
+def test_sdm_nf_mora():
+    f = sdm_from_dict({(1, 2, 1, 1): QQ(1), (1, 1, 2, 1): QQ(1),
+                (1, 0, 2, 1): QQ(1), (1, 0, 0, 3): QQ(1), (1, 1, 1, 0): QQ(1)},
+        grlex)
+    f1 = sdm_from_dict({(1, 1, 1, 0): QQ(1), (1, 0, 2, 0): QQ(1),
+                        (1, 0, 0, 0): QQ(-1)}, grlex)
+    f2 = sdm_from_dict({(1, 1, 1, 0): QQ(1)}, grlex)
+    (id0, id1, id2) = [sdm_from_dict({(i, 0, 0, 0): QQ(1)}, grlex)
+                       for i in range(3)]
+
+    assert sdm_nf_mora(f, [f1, f2], grlex, QQ, phantom=(id0, [id1, id2])) == \
+        ([((1, 0, 2, 1), QQ(1)), ((1, 0, 0, 3), QQ(1)), ((1, 1, 1, 0), QQ(1)),
+          ((1, 1, 0, 1), QQ(1))],
+         [((1, 1, 0, 1), QQ(-1)), ((0, 0, 0, 0), QQ(1))])
+    assert sdm_nf_mora(f, [f2, f1], grlex, QQ, phantom=(id0, [id2, id1])) == \
+        ([((1, 0, 2, 1), QQ(1)), ((1, 0, 0, 3), QQ(1)), ((1, 1, 1, 0), QQ(1))],
+         [((2, 1, 0, 1), QQ(-1)), ((2, 0, 1, 1), QQ(-1)), ((0, 0, 0, 0), QQ(1))])
+
+    f = sdm_from_vector([x*z, y**2 + y*z - z, y], lex, QQ, gens=[x, y, z])
+    f1 = sdm_from_vector([x, y, 1], lex, QQ, gens=[x, y, z])
+    f2 = sdm_from_vector([x*y, z, z**2], lex, QQ, gens=[x, y, z])
+    assert sdm_nf_mora(f, [f1, f2], lex, QQ) == \
+        sdm_nf_mora(f, [f2, f1], lex, QQ) == \
+        [((1, 0, 1, 1), QQ(1)), ((1, 0, 0, 1), QQ(-1)), ((0, 1, 1, 0), QQ(-1)),
+         ((0, 1, 0, 1), QQ(1))]
+
+
+def test_conversion():
+    f = [x**2 + y**2, 2*z]
+    g = [((1, 0, 0, 1), QQ(2)), ((0, 2, 0, 0), QQ(1)), ((0, 0, 2, 0), QQ(1))]
+    assert sdm_to_vector(g, [x, y, z], QQ) == f
+    assert sdm_from_vector(f, lex, QQ) == g
+    assert sdm_from_vector(
+        [x, 1], lex, QQ) == [((1, 0), QQ(1)), ((0, 1), QQ(1))]
+    assert sdm_to_vector([((1, 1, 0, 0), 1)], [x, y, z], QQ, n=3) == [0, x, 0]
+    assert sdm_from_vector([0, 0], lex, QQ, gens=[x, y]) == sdm_zero()
+
+
+def test_nontrivial():
+    gens = [x, y, z]
+
+    def contains(I, f):
+        S = [sdm_from_vector([g], lex, QQ, gens=gens) for g in I]
+        G = sdm_groebner(S, sdm_nf_mora, lex, QQ)
+        return sdm_nf_mora(sdm_from_vector([f], lex, QQ, gens=gens),
+                           G, lex, QQ) == sdm_zero()
+
+    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_local():
+    igrlex = InverseOrder(grlex)
+    gens = [x, y, z]
+
+    def contains(I, f):
+        S = [sdm_from_vector([g], igrlex, QQ, gens=gens) for g in I]
+        G = sdm_groebner(S, sdm_nf_mora, igrlex, QQ)
+        return sdm_nf_mora(sdm_from_vector([f], lex, QQ, gens=gens),
+                           G, lex, QQ) == sdm_zero()
+    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_uncovered_line():
+    gens = [x, y]
+    f1 = sdm_zero()
+    f2 = sdm_from_vector([x, 0], lex, QQ, gens=gens)
+    f3 = sdm_from_vector([0, y], lex, QQ, gens=gens)
+
+    assert sdm_spoly(f1, f2, lex, QQ) == sdm_zero()
+    assert sdm_spoly(f3, f2, lex, QQ) == sdm_zero()
+
+
+def test_chain_criterion():
+    gens = [x]
+    f1 = sdm_from_vector([1, x], grlex, QQ, gens=gens)
+    f2 = sdm_from_vector([0, x - 2], grlex, QQ, gens=gens)
+    assert len(sdm_groebner([f1, f2], sdm_nf_mora, grlex, QQ)) == 2

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_euclidtools.py

@@ -0,0 +1,712 @@
+"""Tests for Euclidean algorithms, GCDs, LCMs and polynomial remainder sequences. """
+
+from sympy.polys.rings import ring
+from sympy.polys.domains import ZZ, QQ, RR
+
+from sympy.polys.specialpolys import (
+    f_polys,
+    dmp_fateman_poly_F_1,
+    dmp_fateman_poly_F_2,
+    dmp_fateman_poly_F_3)
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = f_polys()
+
+def test_dup_gcdex():
+    R, x = ring("x", QQ)
+
+    f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
+    g = x**3 + x**2 - 4*x - 4
+
+    s = -QQ(1,5)*x + QQ(3,5)
+    t = QQ(1,5)*x**2 - QQ(6,5)*x + 2
+    h = x + 1
+
+    assert R.dup_half_gcdex(f, g) == (s, h)
+    assert R.dup_gcdex(f, g) == (s, t, h)
+
+    f = x**4 + 4*x**3 - x + 1
+    g = x**3 - x + 1
+
+    s, t, h = R.dup_gcdex(f, g)
+    S, T, H = R.dup_gcdex(g, f)
+
+    assert R.dup_add(R.dup_mul(s, f),
+                     R.dup_mul(t, g)) == h
+    assert R.dup_add(R.dup_mul(S, g),
+                     R.dup_mul(T, f)) == H
+
+    f = 2*x
+    g = x**2 - 16
+
+    s = QQ(1,32)*x
+    t = -QQ(1,16)
+    h = 1
+
+    assert R.dup_half_gcdex(f, g) == (s, h)
+    assert R.dup_gcdex(f, g) == (s, t, h)
+
+
+def test_dup_invert():
+    R, x = ring("x", QQ)
+    assert R.dup_invert(2*x, x**2 - 16) == QQ(1,32)*x
+
+
+def test_dup_euclidean_prs():
+    R, x = ring("x", QQ)
+
+    f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    assert R.dup_euclidean_prs(f, g) == [
+        f,
+        g,
+        -QQ(5,9)*x**4 + QQ(1,9)*x**2 - QQ(1,3),
+        -QQ(117,25)*x**2 - 9*x + QQ(441,25),
+        QQ(233150,19773)*x - QQ(102500,6591),
+        -QQ(1288744821,543589225)]
+
+
+def test_dup_primitive_prs():
+    R, x = ring("x", ZZ)
+
+    f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    assert R.dup_primitive_prs(f, g) == [
+        f,
+        g,
+        -5*x**4 + x**2 - 3,
+        13*x**2 + 25*x - 49,
+        4663*x - 6150,
+        1]
+
+
+def test_dup_subresultants():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_resultant(0, 0) == 0
+
+    assert R.dup_resultant(1, 0) == 0
+    assert R.dup_resultant(0, 1) == 0
+
+    f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    a = 15*x**4 - 3*x**2 + 9
+    b = 65*x**2 + 125*x - 245
+    c = 9326*x - 12300
+    d = 260708
+
+    assert R.dup_subresultants(f, g) == [f, g, a, b, c, d]
+    assert R.dup_resultant(f, g) == R.dup_LC(d)
+
+    f = x**2 - 2*x + 1
+    g = x**2 - 1
+
+    a = 2*x - 2
+
+    assert R.dup_subresultants(f, g) == [f, g, a]
+    assert R.dup_resultant(f, g) == 0
+
+    f = x**2 + 1
+    g = x**2 - 1
+
+    a = -2
+
+    assert R.dup_subresultants(f, g) == [f, g, a]
+    assert R.dup_resultant(f, g) == 4
+
+    f = x**2 - 1
+    g = x**3 - x**2 + 2
+
+    assert R.dup_resultant(f, g) == 0
+
+    f = 3*x**3 - x
+    g = 5*x**2 + 1
+
+    assert R.dup_resultant(f, g) == 64
+
+    f = x**2 - 2*x + 7
+    g = x**3 - x + 5
+
+    assert R.dup_resultant(f, g) == 265
+
+    f = x**3 - 6*x**2 + 11*x - 6
+    g = x**3 - 15*x**2 + 74*x - 120
+
+    assert R.dup_resultant(f, g) == -8640
+
+    f = x**3 - 6*x**2 + 11*x - 6
+    g = x**3 - 10*x**2 + 29*x - 20
+
+    assert R.dup_resultant(f, g) == 0
+
+    f = x**3 - 1
+    g = x**3 + 2*x**2 + 2*x - 1
+
+    assert R.dup_resultant(f, g) == 16
+
+    f = x**8 - 2
+    g = x - 1
+
+    assert R.dup_resultant(f, g) == -1
+
+
+def test_dmp_subresultants():
+    R, x, y = ring("x,y", ZZ)
+
+    assert R.dmp_resultant(0, 0) == 0
+    assert R.dmp_prs_resultant(0, 0)[0] == 0
+    assert R.dmp_zz_collins_resultant(0, 0) == 0
+    assert R.dmp_qq_collins_resultant(0, 0) == 0
+
+    assert R.dmp_resultant(1, 0) == 0
+    assert R.dmp_resultant(1, 0) == 0
+    assert R.dmp_resultant(1, 0) == 0
+
+    assert R.dmp_resultant(0, 1) == 0
+    assert R.dmp_prs_resultant(0, 1)[0] == 0
+    assert R.dmp_zz_collins_resultant(0, 1) == 0
+    assert R.dmp_qq_collins_resultant(0, 1) == 0
+
+    f = 3*x**2*y - y**3 - 4
+    g = x**2 + x*y**3 - 9
+
+    a = 3*x*y**4 + y**3 - 27*y + 4
+    b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16
+
+    r = R.dmp_LC(b)
+
+    assert R.dmp_subresultants(f, g) == [f, g, a, b]
+
+    assert R.dmp_resultant(f, g) == r
+    assert R.dmp_prs_resultant(f, g)[0] == r
+    assert R.dmp_zz_collins_resultant(f, g) == r
+    assert R.dmp_qq_collins_resultant(f, g) == r
+
+    f = -x**3 + 5
+    g = 3*x**2*y + x**2
+
+    a = 45*y**2 + 30*y + 5
+    b = 675*y**3 + 675*y**2 + 225*y + 25
+
+    r = R.dmp_LC(b)
+
+    assert R.dmp_subresultants(f, g) == [f, g, a]
+    assert R.dmp_resultant(f, g) == r
+    assert R.dmp_prs_resultant(f, g)[0] == r
+    assert R.dmp_zz_collins_resultant(f, g) == r
+    assert R.dmp_qq_collins_resultant(f, g) == r
+
+    R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
+
+    f = 6*x**2 - 3*x*y - 2*x*z + y*z
+    g = x**2 - x*u - x*v + u*v
+
+    r = y**2*z**2 - 3*y**2*z*u - 3*y**2*z*v + 9*y**2*u*v - 2*y*z**2*u \
+      - 2*y*z**2*v + 6*y*z*u**2 + 12*y*z*u*v + 6*y*z*v**2 - 18*y*u**2*v \
+      - 18*y*u*v**2 + 4*z**2*u*v - 12*z*u**2*v - 12*z*u*v**2 + 36*u**2*v**2
+
+    assert R.dmp_zz_collins_resultant(f, g) == r.drop(x)
+
+    R, x, y, z, u, v = ring("x,y,z,u,v", QQ)
+
+    f = x**2 - QQ(1,2)*x*y - QQ(1,3)*x*z + QQ(1,6)*y*z
+    g = x**2 - x*u - x*v + u*v
+
+    r = QQ(1,36)*y**2*z**2 - QQ(1,12)*y**2*z*u - QQ(1,12)*y**2*z*v + QQ(1,4)*y**2*u*v \
+      - QQ(1,18)*y*z**2*u - QQ(1,18)*y*z**2*v + QQ(1,6)*y*z*u**2 + QQ(1,3)*y*z*u*v \
+      + QQ(1,6)*y*z*v**2 - QQ(1,2)*y*u**2*v - QQ(1,2)*y*u*v**2 + QQ(1,9)*z**2*u*v \
+      - QQ(1,3)*z*u**2*v - QQ(1,3)*z*u*v**2 + u**2*v**2
+
+    assert R.dmp_qq_collins_resultant(f, g) == r.drop(x)
+
+    Rt, t = ring("t", ZZ)
+    Rx, x = ring("x", Rt)
+
+    f = x**6 - 5*x**4 + 5*x**2 + 4
+    g = -6*t*x**5 + x**4 + 20*t*x**3 - 3*x**2 - 10*t*x + 6
+
+    assert Rx.dup_resultant(f, g) == 2930944*t**6 + 2198208*t**4 + 549552*t**2 + 45796
+
+
+def test_dup_discriminant():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_discriminant(0) == 0
+    assert R.dup_discriminant(x) == 1
+
+    assert R.dup_discriminant(x**3 + 3*x**2 + 9*x - 13) == -11664
+    assert R.dup_discriminant(5*x**5 + x**3 + 2) == 31252160
+    assert R.dup_discriminant(x**4 + 2*x**3 + 6*x**2 - 22*x + 13) == 0
+    assert R.dup_discriminant(12*x**7 + 15*x**4 + 30*x**3 + x**2 + 1) == -220289699947514112
+
+
+def test_dmp_discriminant():
+    R, x = ring("x", ZZ)
+
+    assert R.dmp_discriminant(0) == 0
+
+    R, x, y = ring("x,y", ZZ)
+
+    assert R.dmp_discriminant(0) == 0
+    assert R.dmp_discriminant(y) == 0
+
+    assert R.dmp_discriminant(x**3 + 3*x**2 + 9*x - 13) == -11664
+    assert R.dmp_discriminant(5*x**5 + x**3 + 2) == 31252160
+    assert R.dmp_discriminant(x**4 + 2*x**3 + 6*x**2 - 22*x + 13) == 0
+    assert R.dmp_discriminant(12*x**7 + 15*x**4 + 30*x**3 + x**2 + 1) == -220289699947514112
+
+    assert R.dmp_discriminant(x**2*y + 2*y) == (-8*y**2).drop(x)
+    assert R.dmp_discriminant(x*y**2 + 2*x) == 1
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    assert R.dmp_discriminant(x*y + z) == 1
+
+    R, x, y, z, u = ring("x,y,z,u", ZZ)
+    assert R.dmp_discriminant(x**2*y + x*z + u) == (-4*y*u + z**2).drop(x)
+
+    R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
+    assert R.dmp_discriminant(x**3*y + x**2*z + x*u + v) == \
+        (-27*y**2*v**2 + 18*y*z*u*v - 4*y*u**3 - 4*z**3*v + z**2*u**2).drop(x)
+
+
+def test_dup_gcd():
+    R, x = ring("x", ZZ)
+
+    f, g = 0, 0
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (0, 0, 0)
+
+    f, g = 2, 0
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, 0)
+
+    f, g = -2, 0
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, -1, 0)
+
+    f, g = 0, -2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 0, -1)
+
+    f, g = 0, 2*x + 4
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2*x + 4, 0, 1)
+
+    f, g = 2*x + 4, 0
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2*x + 4, 1, 0)
+
+    f, g = 2, 2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, 1)
+
+    f, g = -2, 2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, -1, 1)
+
+    f, g = 2, -2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, -1)
+
+    f, g = -2, -2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, -1, -1)
+
+    f, g = x**2 + 2*x + 1, 1
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (1, x**2 + 2*x + 1, 1)
+
+    f, g = x**2 + 2*x + 1, 2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (1, x**2 + 2*x + 1, 2)
+
+    f, g = 2*x**2 + 4*x + 2, 2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, x**2 + 2*x + 1, 1)
+
+    f, g = 2, 2*x**2 + 4*x + 2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (2, 1, x**2 + 2*x + 1)
+
+    f, g = 2*x**2 + 4*x + 2, x + 1
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (x + 1, 2*x + 2, 1)
+
+    f, g = x + 1, 2*x**2 + 4*x + 2
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (x + 1, 1, 2*x + 2)
+
+    f, g = x - 31, x
+    assert R.dup_zz_heu_gcd(f, g) == R.dup_rr_prs_gcd(f, g) == (1, f, g)
+
+    f = x**4 + 8*x**3 + 21*x**2 + 22*x + 8
+    g = x**3 + 6*x**2 + 11*x + 6
+
+    h = x**2 + 3*x + 2
+
+    cff = x**2 + 5*x + 4
+    cfg = x + 3
+
+    assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
+    assert R.dup_rr_prs_gcd(f, g) == (h, cff, cfg)
+
+    f = x**4 - 4
+    g = x**4 + 4*x**2 + 4
+
+    h = x**2 + 2
+
+    cff = x**2 - 2
+    cfg = x**2 + 2
+
+    assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
+    assert R.dup_rr_prs_gcd(f, g) == (h, cff, cfg)
+
+    f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    h = 1
+
+    cff = f
+    cfg = g
+
+    assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
+    assert R.dup_rr_prs_gcd(f, g) == (h, cff, cfg)
+
+    R, x = ring("x", QQ)
+
+    f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    h = 1
+
+    cff = f
+    cfg = g
+
+    assert R.dup_qq_heu_gcd(f, g) == (h, cff, cfg)
+    assert R.dup_ff_prs_gcd(f, g) == (h, cff, cfg)
+
+    R, x = ring("x", ZZ)
+
+    f = - 352518131239247345597970242177235495263669787845475025293906825864749649589178600387510272*x**49 \
+        + 46818041807522713962450042363465092040687472354933295397472942006618953623327997952*x**42 \
+        + 378182690892293941192071663536490788434899030680411695933646320291525827756032*x**35 \
+        + 112806468807371824947796775491032386836656074179286744191026149539708928*x**28 \
+        - 12278371209708240950316872681744825481125965781519138077173235712*x**21 \
+        + 289127344604779611146960547954288113529690984687482920704*x**14 \
+        + 19007977035740498977629742919480623972236450681*x**7 \
+        + 311973482284542371301330321821976049
+
+    g =   365431878023781158602430064717380211405897160759702125019136*x**21 \
+        + 197599133478719444145775798221171663643171734081650688*x**14 \
+        - 9504116979659010018253915765478924103928886144*x**7 \
+        - 311973482284542371301330321821976049
+
+    assert R.dup_zz_heu_gcd(f, R.dup_diff(f, 1))[0] == g
+    assert R.dup_rr_prs_gcd(f, R.dup_diff(f, 1))[0] == g
+
+    R, x = ring("x", QQ)
+
+    f = QQ(1,2)*x**2 + x + QQ(1,2)
+    g = QQ(1,2)*x + QQ(1,2)
+
+    h = x + 1
+
+    assert R.dup_qq_heu_gcd(f, g) == (h, g, QQ(1,2))
+    assert R.dup_ff_prs_gcd(f, g) == (h, g, QQ(1,2))
+
+    R, x = ring("x", ZZ)
+
+    f = 1317378933230047068160*x + 2945748836994210856960
+    g = 120352542776360960*x + 269116466014453760
+
+    h = 120352542776360960*x + 269116466014453760
+    cff = 10946
+    cfg = 1
+
+    assert R.dup_zz_heu_gcd(f, g) == (h, cff, cfg)
+
+
+def test_dmp_gcd():
+    R, x, y = ring("x,y", ZZ)
+
+    f, g = 0, 0
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (0, 0, 0)
+
+    f, g = 2, 0
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, 0)
+
+    f, g = -2, 0
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, -1, 0)
+
+    f, g = 0, -2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 0, -1)
+
+    f, g = 0, 2*x + 4
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2*x + 4, 0, 1)
+
+    f, g = 2*x + 4, 0
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2*x + 4, 1, 0)
+
+    f, g = 2, 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, 1)
+
+    f, g = -2, 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, -1, 1)
+
+    f, g = 2, -2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, -1)
+
+    f, g = -2, -2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, -1, -1)
+
+    f, g = x**2 + 2*x + 1, 1
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (1, x**2 + 2*x + 1, 1)
+
+    f, g = x**2 + 2*x + 1, 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (1, x**2 + 2*x + 1, 2)
+
+    f, g = 2*x**2 + 4*x + 2, 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, x**2 + 2*x + 1, 1)
+
+    f, g = 2, 2*x**2 + 4*x + 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (2, 1, x**2 + 2*x + 1)
+
+    f, g = 2*x**2 + 4*x + 2, x + 1
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (x + 1, 2*x + 2, 1)
+
+    f, g = x + 1, 2*x**2 + 4*x + 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (x + 1, 1, 2*x + 2)
+
+    R, x, y, z, u = ring("x,y,z,u", ZZ)
+
+    f, g = u**2 + 2*u + 1, 2*u + 2
+    assert R.dmp_zz_heu_gcd(f, g) == R.dmp_rr_prs_gcd(f, g) == (u + 1, u + 1, 2)
+
+    f, g = z**2*u**2 + 2*z**2*u + z**2 + z*u + z, u**2 + 2*u + 1
+    h, cff, cfg = u + 1, z**2*u + z**2 + z, u + 1
+
+    assert R.dmp_zz_heu_gcd(f, g) == (h, cff, cfg)
+    assert R.dmp_rr_prs_gcd(f, g) == (h, cff, cfg)
+
+    assert R.dmp_zz_heu_gcd(g, f) == (h, cfg, cff)
+    assert R.dmp_rr_prs_gcd(g, f) == (h, cfg, cff)
+
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(2, ZZ))
+    H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    H, cff, cfg = R.dmp_rr_prs_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(4, ZZ))
+    H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    R, x, y, z, u, v, a, b = ring("x,y,z,u,v,a,b", ZZ)
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(6, ZZ))
+    H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    R, x, y, z, u, v, a, b, c, d = ring("x,y,z,u,v,a,b,c,d", ZZ)
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_1(8, ZZ))
+    H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_2(2, ZZ))
+    H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    H, cff, cfg = R.dmp_rr_prs_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_3(2, ZZ))
+    H, cff, cfg = R.dmp_zz_heu_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    H, cff, cfg = R.dmp_rr_prs_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
+
+    f, g, h = map(R.from_dense, dmp_fateman_poly_F_3(4, ZZ))
+    H, cff, cfg = R.dmp_inner_gcd(f, g)
+
+    assert H == h and R.dmp_mul(H, cff) == f \
+                  and R.dmp_mul(H, cfg) == g
+
+    R, x, y = ring("x,y", QQ)
+
+    f = QQ(1,2)*x**2 + x + QQ(1,2)
+    g = QQ(1,2)*x + QQ(1,2)
+
+    h = x + 1
+
+    assert R.dmp_qq_heu_gcd(f, g) == (h, g, QQ(1,2))
+    assert R.dmp_ff_prs_gcd(f, g) == (h, g, QQ(1,2))
+
+    R, x, y = ring("x,y", RR)
+
+    f = 2.1*x*y**2 - 2.2*x*y + 2.1*x
+    g = 1.0*x**3
+
+    assert R.dmp_ff_prs_gcd(f, g) == \
+        (1.0*x, 2.1*y**2 - 2.2*y + 2.1, 1.0*x**2)
+
+
+def test_dup_lcm():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_lcm(2, 6) == 6
+
+    assert R.dup_lcm(2*x**3, 6*x) == 6*x**3
+    assert R.dup_lcm(2*x**3, 3*x) == 6*x**3
+
+    assert R.dup_lcm(x**2 + x, x) == x**2 + x
+    assert R.dup_lcm(x**2 + x, 2*x) == 2*x**2 + 2*x
+    assert R.dup_lcm(x**2 + 2*x, x) == x**2 + 2*x
+    assert R.dup_lcm(2*x**2 + x, x) == 2*x**2 + x
+    assert R.dup_lcm(2*x**2 + x, 2*x) == 4*x**2 + 2*x
+
+
+def test_dmp_lcm():
+    R, x, y = ring("x,y", ZZ)
+
+    assert R.dmp_lcm(2, 6) == 6
+    assert R.dmp_lcm(x, y) == x*y
+
+    assert R.dmp_lcm(2*x**3, 6*x*y**2) == 6*x**3*y**2
+    assert R.dmp_lcm(2*x**3, 3*x*y**2) == 6*x**3*y**2
+
+    assert R.dmp_lcm(x**2*y, x*y**2) == x**2*y**2
+
+    f = 2*x*y**5 - 3*x*y**4 - 2*x*y**3 + 3*x*y**2
+    g = y**5 - 2*y**3 + y
+    h = 2*x*y**7 - 3*x*y**6 - 4*x*y**5 + 6*x*y**4 + 2*x*y**3 - 3*x*y**2
+
+    assert R.dmp_lcm(f, g) == h
+
+    f = x**3 - 3*x**2*y - 9*x*y**2 - 5*y**3
+    g = x**4 + 6*x**3*y + 12*x**2*y**2 + 10*x*y**3 + 3*y**4
+    h = x**5 + x**4*y - 18*x**3*y**2 - 50*x**2*y**3 - 47*x*y**4 - 15*y**5
+
+    assert R.dmp_lcm(f, g) == h
+
+
+def test_dmp_content():
+    R, x,y = ring("x,y", ZZ)
+
+    assert R.dmp_content(-2) == 2
+
+    f, g, F = 3*y**2 + 2*y + 1, 1, 0
+
+    for i in range(0, 5):
+        g *= f
+        F += x**i*g
+
+    assert R.dmp_content(F) == f.drop(x)
+
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R.dmp_content(f_4) == 1
+    assert R.dmp_content(f_5) == 1
+
+    R, x,y,z,t = ring("x,y,z,t", ZZ)
+    assert R.dmp_content(f_6) == 1
+
+
+def test_dmp_primitive():
+    R, x,y = ring("x,y", ZZ)
+
+    assert R.dmp_primitive(0) == (0, 0)
+    assert R.dmp_primitive(1) == (1, 1)
+
+    f, g, F = 3*y**2 + 2*y + 1, 1, 0
+
+    for i in range(0, 5):
+        g *= f
+        F += x**i*g
+
+    assert R.dmp_primitive(F) == (f.drop(x), F / f)
+
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    cont, f = R.dmp_primitive(f_4)
+    assert cont == 1 and f == f_4
+    cont, f = R.dmp_primitive(f_5)
+    assert cont == 1 and f == f_5
+
+    R, x,y,z,t = ring("x,y,z,t", ZZ)
+
+    cont, f = R.dmp_primitive(f_6)
+    assert cont == 1 and f == f_6
+
+
+def test_dup_cancel():
+    R, x = ring("x", ZZ)
+
+    f = 2*x**2 - 2
+    g = x**2 - 2*x + 1
+
+    p = 2*x + 2
+    q = x - 1
+
+    assert R.dup_cancel(f, g) == (p, q)
+    assert R.dup_cancel(f, g, include=False) == (1, 1, p, q)
+
+    f = -x - 2
+    g = 3*x - 4
+
+    F = x + 2
+    G = -3*x + 4
+
+    assert R.dup_cancel(f, g) == (f, g)
+    assert R.dup_cancel(F, G) == (f, g)
+
+    assert R.dup_cancel(0, 0) == (0, 0)
+    assert R.dup_cancel(0, 0, include=False) == (1, 1, 0, 0)
+
+    assert R.dup_cancel(x, 0) == (1, 0)
+    assert R.dup_cancel(x, 0, include=False) == (1, 1, 1, 0)
+
+    assert R.dup_cancel(0, x) == (0, 1)
+    assert R.dup_cancel(0, x, include=False) == (1, 1, 0, 1)
+
+    f = 0
+    g = x
+    one = 1
+
+    assert R.dup_cancel(f, g, include=True) == (f, one)
+
+
+def test_dmp_cancel():
+    R, x, y = ring("x,y", ZZ)
+
+    f = 2*x**2 - 2
+    g = x**2 - 2*x + 1
+
+    p = 2*x + 2
+    q = x - 1
+
+    assert R.dmp_cancel(f, g) == (p, q)
+    assert R.dmp_cancel(f, g, include=False) == (1, 1, p, q)
+
+    assert R.dmp_cancel(0, 0) == (0, 0)
+    assert R.dmp_cancel(0, 0, include=False) == (1, 1, 0, 0)
+
+    assert R.dmp_cancel(y, 0) == (1, 0)
+    assert R.dmp_cancel(y, 0, include=False) == (1, 1, 1, 0)
+
+    assert R.dmp_cancel(0, y) == (0, 1)
+    assert R.dmp_cancel(0, y, include=False) == (1, 1, 0, 1)

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_factortools.py

@@ -0,0 +1,784 @@
+"""Tools for polynomial factorization routines in characteristic zero. """
+
+from sympy.polys.rings import ring, xring
+from sympy.polys.domains import FF, ZZ, QQ, ZZ_I, QQ_I, RR, EX
+
+from sympy.polys import polyconfig as config
+from sympy.polys.polyerrors import DomainError
+from sympy.polys.polyclasses import ANP
+from sympy.polys.specialpolys import f_polys, w_polys
+
+from sympy.core.numbers import I
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.ntheory.generate import nextprime
+from sympy.testing.pytest import raises, XFAIL
+
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = f_polys()
+w_1, w_2 = w_polys()
+
+def test_dup_trial_division():
+    R, x = ring("x", ZZ)
+    assert R.dup_trial_division(x**5 + 8*x**4 + 25*x**3 + 38*x**2 + 28*x + 8, (x + 1, x + 2)) == [(x + 1, 2), (x + 2, 3)]
+
+
+def test_dmp_trial_division():
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_trial_division(x**5 + 8*x**4 + 25*x**3 + 38*x**2 + 28*x + 8, (x + 1, x + 2)) == [(x + 1, 2), (x + 2, 3)]
+
+
+def test_dup_zz_mignotte_bound():
+    R, x = ring("x", ZZ)
+    assert R.dup_zz_mignotte_bound(2*x**2 + 3*x + 4) == 6
+    assert R.dup_zz_mignotte_bound(x**3 + 14*x**2 + 56*x + 64) == 152
+
+
+def test_dmp_zz_mignotte_bound():
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_zz_mignotte_bound(2*x**2 + 3*x + 4) == 32
+
+
+def test_dup_zz_hensel_step():
+    R, x = ring("x", ZZ)
+
+    f = x**4 - 1
+    g = x**3 + 2*x**2 - x - 2
+    h = x - 2
+    s = -2
+    t = 2*x**2 - 2*x - 1
+
+    G, H, S, T = R.dup_zz_hensel_step(5, f, g, h, s, t)
+
+    assert G == x**3 + 7*x**2 - x - 7
+    assert H == x - 7
+    assert S == 8
+    assert T == -8*x**2 - 12*x - 1
+
+
+def test_dup_zz_hensel_lift():
+    R, x = ring("x", ZZ)
+
+    f = x**4 - 1
+    F = [x - 1, x - 2, x + 2, x + 1]
+
+    assert R.dup_zz_hensel_lift(ZZ(5), f, F, 4) == \
+        [x - 1, x - 182, x + 182, x + 1]
+
+
+def test_dup_zz_irreducible_p():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 7) is None
+    assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 4) is None
+
+    assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 10) is True
+    assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 14) is True
+
+
+def test_dup_cyclotomic_p():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_cyclotomic_p(x - 1) is True
+    assert R.dup_cyclotomic_p(x + 1) is True
+    assert R.dup_cyclotomic_p(x**2 + x + 1) is True
+    assert R.dup_cyclotomic_p(x**2 + 1) is True
+    assert R.dup_cyclotomic_p(x**4 + x**3 + x**2 + x + 1) is True
+    assert R.dup_cyclotomic_p(x**2 - x + 1) is True
+    assert R.dup_cyclotomic_p(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1) is True
+    assert R.dup_cyclotomic_p(x**4 + 1) is True
+    assert R.dup_cyclotomic_p(x**6 + x**3 + 1) is True
+
+    assert R.dup_cyclotomic_p(0) is False
+    assert R.dup_cyclotomic_p(1) is False
+    assert R.dup_cyclotomic_p(x) is False
+    assert R.dup_cyclotomic_p(x + 2) is False
+    assert R.dup_cyclotomic_p(3*x + 1) is False
+    assert R.dup_cyclotomic_p(x**2 - 1) is False
+
+    f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1
+    assert R.dup_cyclotomic_p(f) is False
+
+    g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1
+    assert R.dup_cyclotomic_p(g) is True
+
+    R, x = ring("x", QQ)
+    assert R.dup_cyclotomic_p(x**2 + x + 1) is True
+    assert R.dup_cyclotomic_p(QQ(1,2)*x**2 + x + 1) is False
+
+    R, x = ring("x", ZZ["y"])
+    assert R.dup_cyclotomic_p(x**2 + x + 1) is False
+
+
+def test_dup_zz_cyclotomic_poly():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_zz_cyclotomic_poly(1) == x - 1
+    assert R.dup_zz_cyclotomic_poly(2) == x + 1
+    assert R.dup_zz_cyclotomic_poly(3) == x**2 + x + 1
+    assert R.dup_zz_cyclotomic_poly(4) == x**2 + 1
+    assert R.dup_zz_cyclotomic_poly(5) == x**4 + x**3 + x**2 + x + 1
+    assert R.dup_zz_cyclotomic_poly(6) == x**2 - x + 1
+    assert R.dup_zz_cyclotomic_poly(7) == x**6 + x**5 + x**4 + x**3 + x**2 + x + 1
+    assert R.dup_zz_cyclotomic_poly(8) == x**4 + 1
+    assert R.dup_zz_cyclotomic_poly(9) == x**6 + x**3 + 1
+
+
+def test_dup_zz_cyclotomic_factor():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_zz_cyclotomic_factor(0) is None
+    assert R.dup_zz_cyclotomic_factor(1) is None
+
+    assert R.dup_zz_cyclotomic_factor(2*x**10 - 1) is None
+    assert R.dup_zz_cyclotomic_factor(x**10 - 3) is None
+    assert R.dup_zz_cyclotomic_factor(x**10 + x**5 - 1) is None
+
+    assert R.dup_zz_cyclotomic_factor(x + 1) == [x + 1]
+    assert R.dup_zz_cyclotomic_factor(x - 1) == [x - 1]
+
+    assert R.dup_zz_cyclotomic_factor(x**2 + 1) == [x**2 + 1]
+    assert R.dup_zz_cyclotomic_factor(x**2 - 1) == [x - 1, x + 1]
+
+    assert R.dup_zz_cyclotomic_factor(x**27 + 1) == \
+        [x + 1, x**2 - x + 1, x**6 - x**3 + 1, x**18 - x**9 + 1]
+    assert R.dup_zz_cyclotomic_factor(x**27 - 1) == \
+        [x - 1, x**2 + x + 1, x**6 + x**3 + 1, x**18 + x**9 + 1]
+
+
+def test_dup_zz_factor():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_zz_factor(0) == (0, [])
+    assert R.dup_zz_factor(7) == (7, [])
+    assert R.dup_zz_factor(-7) == (-7, [])
+
+    assert R.dup_zz_factor_sqf(0) == (0, [])
+    assert R.dup_zz_factor_sqf(7) == (7, [])
+    assert R.dup_zz_factor_sqf(-7) == (-7, [])
+
+    assert R.dup_zz_factor(2*x + 4) == (2, [(x + 2, 1)])
+    assert R.dup_zz_factor_sqf(2*x + 4) == (2, [x + 2])
+
+    f = x**4 + x + 1
+
+    for i in range(0, 20):
+        assert R.dup_zz_factor(f) == (1, [(f, 1)])
+
+    assert R.dup_zz_factor(x**2 + 2*x + 2) == \
+        (1, [(x**2 + 2*x + 2, 1)])
+
+    assert R.dup_zz_factor(18*x**2 + 12*x + 2) == \
+        (2, [(3*x + 1, 2)])
+
+    assert R.dup_zz_factor(-9*x**2 + 1) == \
+        (-1, [(3*x - 1, 1),
+              (3*x + 1, 1)])
+
+    assert R.dup_zz_factor_sqf(-9*x**2 + 1) == \
+        (-1, [3*x - 1,
+              3*x + 1])
+
+    # The order of the factors will be different when the ground types are
+    # flint. At the higher level dup_factor_list will sort the factors.
+    c, factors = R.dup_zz_factor(x**3 - 6*x**2 + 11*x - 6)
+    assert c == 1
+    assert set(factors) == {(x - 3, 1), (x - 2, 1), (x - 1, 1)}
+
+    assert R.dup_zz_factor_sqf(x**3 - 6*x**2 + 11*x - 6) == \
+        (1, [x - 3,
+             x - 2,
+             x - 1])
+
+    assert R.dup_zz_factor(3*x**3 + 10*x**2 + 13*x + 10) == \
+        (1, [(x + 2, 1),
+             (3*x**2 + 4*x + 5, 1)])
+
+    assert R.dup_zz_factor_sqf(3*x**3 + 10*x**2 + 13*x + 10) == \
+        (1, [x + 2,
+             3*x**2 + 4*x + 5])
+
+    c, factors = R.dup_zz_factor(-x**6 + x**2)
+    assert c == -1
+    assert set(factors) == {(x, 2), (x - 1, 1), (x + 1, 1), (x**2 + 1, 1)}
+
+    f = 1080*x**8 + 5184*x**7 + 2099*x**6 + 744*x**5 + 2736*x**4 - 648*x**3 + 129*x**2 - 324
+
+    assert R.dup_zz_factor(f) == \
+        (1, [(5*x**4 + 24*x**3 + 9*x**2 + 12, 1),
+             (216*x**4 + 31*x**2 - 27, 1)])
+
+    f = -29802322387695312500000000000000000000*x**25 \
+      + 2980232238769531250000000000000000*x**20 \
+      + 1743435859680175781250000000000*x**15 \
+      + 114142894744873046875000000*x**10 \
+      - 210106372833251953125*x**5 \
+      + 95367431640625
+
+    c, factors = R.dup_zz_factor(f)
+    assert c == -95367431640625
+    assert set(factors) == {
+        (5*x - 1, 1),
+        (100*x**2 + 10*x - 1, 2),
+        (625*x**4 + 125*x**3 + 25*x**2 + 5*x + 1, 1),
+        (10000*x**4 - 3000*x**3 + 400*x**2 - 20*x + 1, 2),
+        (10000*x**4 + 2000*x**3 + 400*x**2 + 30*x + 1, 2),
+    }
+
+    f = x**10 - 1
+
+    config.setup('USE_CYCLOTOMIC_FACTOR', True)
+    c0, F_0 = R.dup_zz_factor(f)
+
+    config.setup('USE_CYCLOTOMIC_FACTOR', False)
+    c1, F_1 = R.dup_zz_factor(f)
+
+    assert c0 == c1 == 1
+    assert set(F_0) == set(F_1) == {
+        (x - 1, 1),
+        (x + 1, 1),
+        (x**4 - x**3 + x**2 - x + 1, 1),
+        (x**4 + x**3 + x**2 + x + 1, 1),
+    }
+
+    config.setup('USE_CYCLOTOMIC_FACTOR')
+
+    f = x**10 + 1
+
+    config.setup('USE_CYCLOTOMIC_FACTOR', True)
+    F_0 = R.dup_zz_factor(f)
+
+    config.setup('USE_CYCLOTOMIC_FACTOR', False)
+    F_1 = R.dup_zz_factor(f)
+
+    assert F_0 == F_1 == \
+        (1, [(x**2 + 1, 1),
+             (x**8 - x**6 + x**4 - x**2 + 1, 1)])
+
+    config.setup('USE_CYCLOTOMIC_FACTOR')
+
+def test_dmp_zz_wang():
+    R, x,y,z = ring("x,y,z", ZZ)
+    UV, _x = ring("x", ZZ)
+
+    p = ZZ(nextprime(R.dmp_zz_mignotte_bound(w_1)))
+    assert p == 6291469
+
+    t_1, k_1, e_1 = y, 1, ZZ(-14)
+    t_2, k_2, e_2 = z, 2, ZZ(3)
+    t_3, k_3, e_3 = y + z, 2, ZZ(-11)
+    t_4, k_4, e_4 = y - z, 1, ZZ(-17)
+
+    T = [t_1, t_2, t_3, t_4]
+    K = [k_1, k_2, k_3, k_4]
+    E = [e_1, e_2, e_3, e_4]
+
+    T = zip([ t.drop(x) for t in T ], K)
+
+    A = [ZZ(-14), ZZ(3)]
+
+    S = R.dmp_eval_tail(w_1, A)
+    cs, s = UV.dup_primitive(S)
+
+    assert cs == 1 and s == S == \
+        1036728*_x**6 + 915552*_x**5 + 55748*_x**4 + 105621*_x**3 - 17304*_x**2 - 26841*_x - 644
+
+    assert R.dmp_zz_wang_non_divisors(E, cs, ZZ(4)) == [7, 3, 11, 17]
+    assert UV.dup_sqf_p(s) and UV.dup_degree(s) == R.dmp_degree(w_1)
+
+    _, H = UV.dup_zz_factor_sqf(s)
+
+    h_1 = 44*_x**2 + 42*_x + 1
+    h_2 = 126*_x**2 - 9*_x + 28
+    h_3 = 187*_x**2 - 23
+
+    assert H == [h_1, h_2, h_3]
+
+    LC = [ lc.drop(x) for lc in [-4*y - 4*z, -y*z**2, y**2 - z**2] ]
+
+    assert R.dmp_zz_wang_lead_coeffs(w_1, T, cs, E, H, A) == (w_1, H, LC)
+
+    factors = R.dmp_zz_wang_hensel_lifting(w_1, H, LC, A, p)
+    assert R.dmp_expand(factors) == w_1
+
+
+@XFAIL
+def test_dmp_zz_wang_fail():
+    R, x,y,z = ring("x,y,z", ZZ)
+    UV, _x = ring("x", ZZ)
+
+    p = ZZ(nextprime(R.dmp_zz_mignotte_bound(w_1)))
+    assert p == 6291469
+
+    H_1 = [44*x**2 + 42*x + 1, 126*x**2 - 9*x + 28, 187*x**2 - 23]
+    H_2 = [-4*x**2*y - 12*x**2 - 3*x*y + 1, -9*x**2*y - 9*x - 2*y, x**2*y**2 - 9*x**2 + y - 9]
+    H_3 = [-4*x**2*y - 12*x**2 - 3*x*y + 1, -9*x**2*y - 9*x - 2*y, x**2*y**2 - 9*x**2 + y - 9]
+
+    c_1 = -70686*x**5 - 5863*x**4 - 17826*x**3 + 2009*x**2 + 5031*x + 74
+    c_2 = 9*x**5*y**4 + 12*x**5*y**3 - 45*x**5*y**2 - 108*x**5*y - 324*x**5 + 18*x**4*y**3 - 216*x**4*y**2 - 810*x**4*y + 2*x**3*y**4 + 9*x**3*y**3 - 252*x**3*y**2 - 288*x**3*y - 945*x**3 - 30*x**2*y**2 - 414*x**2*y + 2*x*y**3 - 54*x*y**2 - 3*x*y + 81*x + 12*y
+    c_3 = -36*x**4*y**2 - 108*x**4*y - 27*x**3*y**2 - 36*x**3*y - 108*x**3 - 8*x**2*y**2 - 42*x**2*y - 6*x*y**2 + 9*x + 2*y
+
+    assert R.dmp_zz_diophantine(H_1, c_1, [], 5, p) == [-3*x, -2, 1]
+    assert R.dmp_zz_diophantine(H_2, c_2, [ZZ(-14)], 5, p) == [-x*y, -3*x, -6]
+    assert R.dmp_zz_diophantine(H_3, c_3, [ZZ(-14)], 5, p) == [0, 0, -1]
+
+
+def test_issue_6355():
+    # This tests a bug in the Wang algorithm that occurred only with a very
+    # specific set of random numbers.
+    random_sequence = [-1, -1, 0, 0, 0, 0, -1, -1, 0, -1, 3, -1, 3, 3, 3, 3, -1, 3]
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    f = 2*x**2 + y*z - y - z**2 + z
+
+    assert R.dmp_zz_wang(f, seed=random_sequence) == [f]
+
+
+def test_dmp_zz_factor():
+    R, x = ring("x", ZZ)
+    assert R.dmp_zz_factor(0) == (0, [])
+    assert R.dmp_zz_factor(7) == (7, [])
+    assert R.dmp_zz_factor(-7) == (-7, [])
+
+    assert R.dmp_zz_factor(x**2 - 9) == (1, [(x - 3, 1), (x + 3, 1)])
+
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_zz_factor(0) == (0, [])
+    assert R.dmp_zz_factor(7) == (7, [])
+    assert R.dmp_zz_factor(-7) == (-7, [])
+
+    assert R.dmp_zz_factor(x) == (1, [(x, 1)])
+    assert R.dmp_zz_factor(4*x) == (4, [(x, 1)])
+    assert R.dmp_zz_factor(4*x + 2) == (2, [(2*x + 1, 1)])
+    assert R.dmp_zz_factor(x*y + 1) == (1, [(x*y + 1, 1)])
+    assert R.dmp_zz_factor(y**2 + 1) == (1, [(y**2 + 1, 1)])
+    assert R.dmp_zz_factor(y**2 - 1) == (1, [(y - 1, 1), (y + 1, 1)])
+
+    assert R.dmp_zz_factor(x**2*y**2 + 6*x**2*y + 9*x**2 - 1) == (1, [(x*y + 3*x - 1, 1), (x*y + 3*x + 1, 1)])
+    assert R.dmp_zz_factor(x**2*y**2 - 9) == (1, [(x*y - 3, 1), (x*y + 3, 1)])
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    assert R.dmp_zz_factor(x**2*y**2*z**2 - 9) == \
+        (1, [(x*y*z - 3, 1),
+             (x*y*z + 3, 1)])
+
+    R, x, y, z, u = ring("x,y,z,u", ZZ)
+    assert R.dmp_zz_factor(x**2*y**2*z**2*u**2 - 9) == \
+        (1, [(x*y*z*u - 3, 1),
+             (x*y*z*u + 3, 1)])
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    assert R.dmp_zz_factor(f_1) == \
+        (1, [(x + y*z + 20, 1),
+             (x*y + z + 10, 1),
+             (x*z + y + 30, 1)])
+
+    assert R.dmp_zz_factor(f_2) == \
+        (1, [(x**2*y**2 + x**2*z**2 + y + 90, 1),
+             (x**3*y + x**3*z + z - 11, 1)])
+
+    assert R.dmp_zz_factor(f_3) == \
+        (1, [(x**2*y**2 + x*z**4 + x + z, 1),
+             (x**3 + x*y*z + y**2 + y*z**3, 1)])
+
+    assert R.dmp_zz_factor(f_4) == \
+        (-1, [(x*y**3 + z**2, 1),
+              (x**2*z + y**4*z**2 + 5, 1),
+              (x**3*y - z**2 - 3, 1),
+              (x**3*y**4 + z**2, 1)])
+
+    assert R.dmp_zz_factor(f_5) == \
+        (-1, [(x + y - z, 3)])
+
+    R, x, y, z, t = ring("x,y,z,t", ZZ)
+    assert R.dmp_zz_factor(f_6) == \
+        (1, [(47*x*y + z**3*t**2 - t**2, 1),
+             (45*x**3 - 9*y**3 - y**2 + 3*z**3 + 2*z*t, 1)])
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    assert R.dmp_zz_factor(w_1) == \
+        (1, [(x**2*y**2 - x**2*z**2 + y - z**2, 1),
+             (x**2*y*z**2 + 3*x*z + 2*y, 1),
+             (4*x**2*y + 4*x**2*z + x*y*z - 1, 1)])
+
+    R, x, y = ring("x,y", ZZ)
+    f = -12*x**16*y + 240*x**12*y**3 - 768*x**10*y**4 + 1080*x**8*y**5 - 768*x**6*y**6 + 240*x**4*y**7 - 12*y**9
+
+    assert R.dmp_zz_factor(f) == \
+        (-12, [(y, 1),
+               (x**2 - y, 6),
+               (x**4 + 6*x**2*y + y**2, 1)])
+
+
+def test_dup_qq_i_factor():
+    R, x = ring("x", QQ_I)
+    i = QQ_I(0, 1)
+
+    assert R.dup_qq_i_factor(x**2 - 2) == (QQ_I(1, 0), [(x**2 - 2, 1)])
+
+    assert R.dup_qq_i_factor(x**2 - 1) == (QQ_I(1, 0), [(x - 1, 1), (x + 1, 1)])
+
+    assert R.dup_qq_i_factor(x**2 + 1) == (QQ_I(1, 0), [(x - i, 1), (x + i, 1)])
+
+    assert R.dup_qq_i_factor(x**2/4 + 1) == \
+            (QQ_I(QQ(1, 4), 0), [(x - 2*i, 1), (x + 2*i, 1)])
+
+    assert R.dup_qq_i_factor(x**2 + 4) == \
+            (QQ_I(1, 0), [(x - 2*i, 1), (x + 2*i, 1)])
+
+    assert R.dup_qq_i_factor(x**2 + 2*x + 1) == \
+            (QQ_I(1, 0), [(x + 1, 2)])
+
+    assert R.dup_qq_i_factor(x**2 + 2*i*x - 1) == \
+            (QQ_I(1, 0), [(x + i, 2)])
+
+    f = 8192*x**2 + x*(22656 + 175232*i) - 921416 + 242313*i
+
+    assert R.dup_qq_i_factor(f) == \
+            (QQ_I(8192, 0), [(x + QQ_I(QQ(177, 128), QQ(1369, 128)), 2)])
+
+
+def test_dmp_qq_i_factor():
+    R, x, y = ring("x, y", QQ_I)
+    i = QQ_I(0, 1)
+
+    assert R.dmp_qq_i_factor(x**2 + 2*y**2) == \
+            (QQ_I(1, 0), [(x**2 + 2*y**2, 1)])
+
+    assert R.dmp_qq_i_factor(x**2 + y**2) == \
+            (QQ_I(1, 0), [(x - i*y, 1), (x + i*y, 1)])
+
+    assert R.dmp_qq_i_factor(x**2 + y**2/4) == \
+            (QQ_I(1, 0), [(x - i*y/2, 1), (x + i*y/2, 1)])
+
+    assert R.dmp_qq_i_factor(4*x**2 + y**2) == \
+            (QQ_I(4, 0), [(x - i*y/2, 1), (x + i*y/2, 1)])
+
+
+def test_dup_zz_i_factor():
+    R, x = ring("x", ZZ_I)
+    i = ZZ_I(0, 1)
+
+    assert R.dup_zz_i_factor(x**2 - 2) == (ZZ_I(1, 0), [(x**2 - 2, 1)])
+
+    assert R.dup_zz_i_factor(x**2 - 1) == (ZZ_I(1, 0), [(x - 1, 1), (x + 1, 1)])
+
+    assert R.dup_zz_i_factor(x**2 + 1) == (ZZ_I(1, 0), [(x - i, 1), (x + i, 1)])
+
+    assert R.dup_zz_i_factor(x**2 + 4) == \
+            (ZZ_I(1, 0), [(x - 2*i, 1), (x + 2*i, 1)])
+
+    assert R.dup_zz_i_factor(x**2 + 2*x + 1) == \
+            (ZZ_I(1, 0), [(x + 1, 2)])
+
+    assert R.dup_zz_i_factor(x**2 + 2*i*x - 1) == \
+            (ZZ_I(1, 0), [(x + i, 2)])
+
+    f = 8192*x**2 + x*(22656 + 175232*i) - 921416 + 242313*i
+
+    assert R.dup_zz_i_factor(f) == \
+            (ZZ_I(0, 1), [((64 - 64*i)*x + (773 + 596*i), 2)])
+
+
+def test_dmp_zz_i_factor():
+    R, x, y = ring("x, y", ZZ_I)
+    i = ZZ_I(0, 1)
+
+    assert R.dmp_zz_i_factor(x**2 + 2*y**2) == \
+            (ZZ_I(1, 0), [(x**2 + 2*y**2, 1)])
+
+    assert R.dmp_zz_i_factor(x**2 + y**2) == \
+            (ZZ_I(1, 0), [(x - i*y, 1), (x + i*y, 1)])
+
+    assert R.dmp_zz_i_factor(4*x**2 + y**2) == \
+            (ZZ_I(1, 0), [(2*x - i*y, 1), (2*x + i*y, 1)])
+
+
+def test_dup_ext_factor():
+    R, x = ring("x", QQ.algebraic_field(I))
+    def anp(element):
+        return ANP(element, [QQ(1), QQ(0), QQ(1)], QQ)
+
+    assert R.dup_ext_factor(0) == (anp([]), [])
+
+    f = anp([QQ(1)])*x + anp([QQ(1)])
+
+    assert R.dup_ext_factor(f) == (anp([QQ(1)]), [(f, 1)])
+
+    g = anp([QQ(2)])*x + anp([QQ(2)])
+
+    assert R.dup_ext_factor(g) == (anp([QQ(2)]), [(f, 1)])
+
+    f = anp([QQ(7)])*x**4 + anp([QQ(1, 1)])
+    g = anp([QQ(1)])*x**4 + anp([QQ(1, 7)])
+
+    assert R.dup_ext_factor(f) == (anp([QQ(7)]), [(g, 1)])
+
+    f = anp([QQ(1)])*x**4 + anp([QQ(1)])
+
+    assert R.dup_ext_factor(f) == \
+        (anp([QQ(1, 1)]), [(anp([QQ(1)])*x**2 + anp([QQ(-1), QQ(0)]), 1),
+                           (anp([QQ(1)])*x**2 + anp([QQ( 1), QQ(0)]), 1)])
+
+    f = anp([QQ(4, 1)])*x**2 + anp([QQ(9, 1)])
+
+    assert R.dup_ext_factor(f) == \
+        (anp([QQ(4, 1)]), [(anp([QQ(1, 1)])*x + anp([-QQ(3, 2), QQ(0, 1)]), 1),
+                           (anp([QQ(1, 1)])*x + anp([ QQ(3, 2), QQ(0, 1)]), 1)])
+
+    f = anp([QQ(4, 1)])*x**4 + anp([QQ(8, 1)])*x**3 + anp([QQ(77, 1)])*x**2 + anp([QQ(18, 1)])*x + anp([QQ(153, 1)])
+
+    assert R.dup_ext_factor(f) == \
+        (anp([QQ(4, 1)]), [(anp([QQ(1, 1)])*x + anp([-QQ(4, 1), QQ(1, 1)]), 1),
+                           (anp([QQ(1, 1)])*x + anp([-QQ(3, 2), QQ(0, 1)]), 1),
+                           (anp([QQ(1, 1)])*x + anp([ QQ(3, 2), QQ(0, 1)]), 1),
+                           (anp([QQ(1, 1)])*x + anp([ QQ(4, 1), QQ(1, 1)]), 1)])
+
+    R, x = ring("x", QQ.algebraic_field(sqrt(2)))
+    def anp(element):
+        return ANP(element, [QQ(1), QQ(0), QQ(-2)], QQ)
+
+    f = anp([QQ(1)])*x**4 + anp([QQ(1, 1)])
+
+    assert R.dup_ext_factor(f) == \
+        (anp([QQ(1)]), [(anp([QQ(1)])*x**2 + anp([QQ(-1), QQ(0)])*x + anp([QQ(1)]), 1),
+                        (anp([QQ(1)])*x**2 + anp([QQ( 1), QQ(0)])*x + anp([QQ(1)]), 1)])
+
+    f = anp([QQ(1, 1)])*x**2 + anp([QQ(2), QQ(0)])*x + anp([QQ(2, 1)])
+
+    assert R.dup_ext_factor(f) == \
+        (anp([QQ(1, 1)]), [(anp([1])*x + anp([1, 0]), 2)])
+
+    assert R.dup_ext_factor(f**3) == \
+        (anp([QQ(1, 1)]), [(anp([1])*x + anp([1, 0]), 6)])
+
+    f *= anp([QQ(2, 1)])
+
+    assert R.dup_ext_factor(f) == \
+        (anp([QQ(2, 1)]), [(anp([1])*x + anp([1, 0]), 2)])
+
+    assert R.dup_ext_factor(f**3) == \
+        (anp([QQ(8, 1)]), [(anp([1])*x + anp([1, 0]), 6)])
+
+
+def test_dmp_ext_factor():
+    K = QQ.algebraic_field(sqrt(2))
+    R, x,y = ring("x,y", K)
+    sqrt2 = K.unit
+
+    def anp(x):
+        return ANP(x, [QQ(1), QQ(0), QQ(-2)], QQ)
+
+    assert R.dmp_ext_factor(0) == (anp([]), [])
+
+    f = anp([QQ(1)])*x + anp([QQ(1)])
+
+    assert R.dmp_ext_factor(f) == (anp([QQ(1)]), [(f, 1)])
+
+    g = anp([QQ(2)])*x + anp([QQ(2)])
+
+    assert R.dmp_ext_factor(g) == (anp([QQ(2)]), [(f, 1)])
+
+    f = anp([QQ(1)])*x**2 + anp([QQ(-2)])*y**2
+
+    assert R.dmp_ext_factor(f) == \
+        (anp([QQ(1)]), [(anp([QQ(1)])*x + anp([QQ(-1), QQ(0)])*y, 1),
+                        (anp([QQ(1)])*x + anp([QQ( 1), QQ(0)])*y, 1)])
+
+    f = anp([QQ(2)])*x**2 + anp([QQ(-4)])*y**2
+
+    assert R.dmp_ext_factor(f) == \
+        (anp([QQ(2)]), [(anp([QQ(1)])*x + anp([QQ(-1), QQ(0)])*y, 1),
+                        (anp([QQ(1)])*x + anp([QQ( 1), QQ(0)])*y, 1)])
+
+    f1 = y + 1
+    f2 = y + sqrt2
+    f3 = x**2 + x + 2 + 3*sqrt2
+    f = f1**2 * f2**2 * f3**2
+    assert R.dmp_ext_factor(f) == (K.one, [(f1, 2), (f2, 2), (f3, 2)])
+
+
+def test_dup_factor_list():
+    R, x = ring("x", ZZ)
+    assert R.dup_factor_list(0) == (0, [])
+    assert R.dup_factor_list(7) == (7, [])
+
+    R, x = ring("x", QQ)
+    assert R.dup_factor_list(0) == (0, [])
+    assert R.dup_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
+
+    R, x = ring("x", ZZ['t'])
+    assert R.dup_factor_list(0) == (0, [])
+    assert R.dup_factor_list(7) == (7, [])
+
+    R, x = ring("x", QQ['t'])
+    assert R.dup_factor_list(0) == (0, [])
+    assert R.dup_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
+
+    R, x = ring("x", ZZ)
+    assert R.dup_factor_list_include(0) == [(0, 1)]
+    assert R.dup_factor_list_include(7) == [(7, 1)]
+
+    assert R.dup_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)])
+    assert R.dup_factor_list_include(x**2 + 2*x + 1) == [(x + 1, 2)]
+    # issue 8037
+    assert R.dup_factor_list(6*x**2 - 5*x - 6) == (1, [(2*x - 3, 1), (3*x + 2, 1)])
+
+    R, x = ring("x", QQ)
+    assert R.dup_factor_list(QQ(1,2)*x**2 + x + QQ(1,2)) == (QQ(1, 2), [(x + 1, 2)])
+
+    R, x = ring("x", FF(2))
+    assert R.dup_factor_list(x**2 + 1) == (1, [(x + 1, 2)])
+
+    R, x = ring("x", RR)
+    assert R.dup_factor_list(1.0*x**2 + 2.0*x + 1.0) == (1.0, [(1.0*x + 1.0, 2)])
+    assert R.dup_factor_list(2.0*x**2 + 4.0*x + 2.0) == (2.0, [(1.0*x + 1.0, 2)])
+
+    f = 6.7225336055071*x**2 - 10.6463972754741*x - 0.33469524022264
+    coeff, factors = R.dup_factor_list(f)
+    assert coeff == RR(10.6463972754741)
+    assert len(factors) == 1
+    assert factors[0][0].max_norm() == RR(1.0)
+    assert factors[0][1] == 1
+
+    Rt, t = ring("t", ZZ)
+    R, x = ring("x", Rt)
+
+    f = 4*t*x**2 + 4*t**2*x
+
+    assert R.dup_factor_list(f) == \
+        (4*t, [(x, 1),
+             (x + t, 1)])
+
+    Rt, t = ring("t", QQ)
+    R, x = ring("x", Rt)
+
+    f = QQ(1, 2)*t*x**2 + QQ(1, 2)*t**2*x
+
+    assert R.dup_factor_list(f) == \
+        (QQ(1, 2)*t, [(x, 1),
+                    (x + t, 1)])
+
+    R, x = ring("x", QQ.algebraic_field(I))
+    def anp(element):
+        return ANP(element, [QQ(1), QQ(0), QQ(1)], QQ)
+
+    f = anp([QQ(1, 1)])*x**4 + anp([QQ(2, 1)])*x**2
+
+    assert R.dup_factor_list(f) == \
+        (anp([QQ(1, 1)]), [(anp([QQ(1, 1)])*x, 2),
+                           (anp([QQ(1, 1)])*x**2 + anp([])*x + anp([QQ(2, 1)]), 1)])
+
+    R, x = ring("x", EX)
+    raises(DomainError, lambda: R.dup_factor_list(EX(sin(1))))
+
+
+def test_dmp_factor_list():
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_factor_list(0) == (ZZ(0), [])
+    assert R.dmp_factor_list(7) == (7, [])
+
+    R, x, y = ring("x,y", QQ)
+    assert R.dmp_factor_list(0) == (QQ(0), [])
+    assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
+
+    Rt, t = ring("t", ZZ)
+    R, x, y = ring("x,y", Rt)
+    assert R.dmp_factor_list(0) == (0, [])
+    assert R.dmp_factor_list(7) == (ZZ(7), [])
+
+    Rt, t = ring("t", QQ)
+    R, x, y = ring("x,y", Rt)
+    assert R.dmp_factor_list(0) == (0, [])
+    assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
+
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_factor_list_include(0) == [(0, 1)]
+    assert R.dmp_factor_list_include(7) == [(7, 1)]
+
+    R, X = xring("x:200", ZZ)
+
+    f, g = X[0]**2 + 2*X[0] + 1, X[0] + 1
+    assert R.dmp_factor_list(f) == (1, [(g, 2)])
+
+    f, g = X[-1]**2 + 2*X[-1] + 1, X[-1] + 1
+    assert R.dmp_factor_list(f) == (1, [(g, 2)])
+
+    R, x = ring("x", ZZ)
+    assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)])
+    R, x = ring("x", QQ)
+    assert R.dmp_factor_list(QQ(1,2)*x**2 + x + QQ(1,2)) == (QQ(1,2), [(x + 1, 2)])
+
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)])
+    R, x, y = ring("x,y", QQ)
+    assert R.dmp_factor_list(QQ(1,2)*x**2 + x + QQ(1,2)) == (QQ(1,2), [(x + 1, 2)])
+
+    R, x, y = ring("x,y", ZZ)
+    f = 4*x**2*y + 4*x*y**2
+
+    assert R.dmp_factor_list(f) == \
+        (4, [(y, 1),
+             (x, 1),
+             (x + y, 1)])
+
+    assert R.dmp_factor_list_include(f) == \
+        [(4*y, 1),
+         (x, 1),
+         (x + y, 1)]
+
+    R, x, y = ring("x,y", QQ)
+    f = QQ(1,2)*x**2*y + QQ(1,2)*x*y**2
+
+    assert R.dmp_factor_list(f) == \
+        (QQ(1,2), [(y, 1),
+                   (x, 1),
+                   (x + y, 1)])
+
+    R, x, y = ring("x,y", RR)
+    f = 2.0*x**2 - 8.0*y**2
+
+    assert R.dmp_factor_list(f) == \
+        (RR(8.0), [(0.5*x - y, 1),
+                   (0.5*x + y, 1)])
+
+    f = 6.7225336055071*x**2*y**2 - 10.6463972754741*x*y - 0.33469524022264
+    coeff, factors = R.dmp_factor_list(f)
+    assert coeff == RR(10.6463972754741)
+    assert len(factors) == 1
+    assert factors[0][0].max_norm() == RR(1.0)
+    assert factors[0][1] == 1
+
+    Rt, t = ring("t", ZZ)
+    R, x, y = ring("x,y", Rt)
+    f = 4*t*x**2 + 4*t**2*x
+
+    assert R.dmp_factor_list(f) == \
+        (4*t, [(x, 1),
+             (x + t, 1)])
+
+    Rt, t = ring("t", QQ)
+    R, x, y = ring("x,y", Rt)
+    f = QQ(1, 2)*t*x**2 + QQ(1, 2)*t**2*x
+
+    assert R.dmp_factor_list(f) == \
+        (QQ(1, 2)*t, [(x, 1),
+                    (x + t, 1)])
+
+    R, x, y = ring("x,y", FF(2))
+    raises(NotImplementedError, lambda: R.dmp_factor_list(x**2 + y**2))
+
+    R, x, y = ring("x,y", EX)
+    raises(DomainError, lambda: R.dmp_factor_list(EX(sin(1))))
+
+
+def test_dup_irreducible_p():
+    R, x = ring("x", ZZ)
+    assert R.dup_irreducible_p(x**2 + x + 1) is True
+    assert R.dup_irreducible_p(x**2 + 2*x + 1) is False
+
+
+def test_dmp_irreducible_p():
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_irreducible_p(x**2 + x + 1) is True
+    assert R.dmp_irreducible_p(x**2 + 2*x + 1) is False

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_fields.py

@@ -0,0 +1,362 @@
+"""Test sparse rational functions. """
+
+from sympy.polys.fields import field, sfield, FracField, FracElement
+from sympy.polys.rings import ring
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.orderings import lex
+
+from sympy.testing.pytest import raises, XFAIL
+from sympy.core import symbols, E
+from sympy.core.numbers import Rational
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+
+def test_FracField___init__():
+    F1 = FracField("x,y", ZZ, lex)
+    F2 = FracField("x,y", ZZ, lex)
+    F3 = FracField("x,y,z", ZZ, lex)
+
+    assert F1.x == F1.gens[0]
+    assert F1.y == F1.gens[1]
+    assert F1.x == F2.x
+    assert F1.y == F2.y
+    assert F1.x != F3.x
+    assert F1.y != F3.y
+
+def test_FracField___hash__():
+    F, x, y, z = field("x,y,z", QQ)
+    assert hash(F)
+
+def test_FracField___eq__():
+    assert field("x,y,z", QQ)[0] == field("x,y,z", QQ)[0]
+    assert field("x,y,z", QQ)[0] is field("x,y,z", QQ)[0]
+
+    assert field("x,y,z", QQ)[0] != field("x,y,z", ZZ)[0]
+    assert field("x,y,z", QQ)[0] is not field("x,y,z", ZZ)[0]
+
+    assert field("x,y,z", ZZ)[0] != field("x,y,z", QQ)[0]
+    assert field("x,y,z", ZZ)[0] is not field("x,y,z", QQ)[0]
+
+    assert field("x,y,z", QQ)[0] != field("x,y", QQ)[0]
+    assert field("x,y,z", QQ)[0] is not field("x,y", QQ)[0]
+
+    assert field("x,y", QQ)[0] != field("x,y,z", QQ)[0]
+    assert field("x,y", QQ)[0] is not field("x,y,z", QQ)[0]
+
+def test_sfield():
+    x = symbols("x")
+
+    F = FracField((E, exp(exp(x)), exp(x)), ZZ, lex)
+    e, exex, ex = F.gens
+    assert sfield(exp(x)*exp(exp(x) + 1 + log(exp(x) + 3)/2)**2/(exp(x) + 3)) \
+        == (F, e**2*exex**2*ex)
+
+    F = FracField((x, exp(1/x), log(x), x**QQ(1, 3)), ZZ, lex)
+    _, ex, lg, x3 = F.gens
+    assert sfield(((x-3)*log(x)+4*x**2)*exp(1/x+log(x)/3)/x**2) == \
+        (F, (4*F.x**2*ex + F.x*ex*lg - 3*ex*lg)/x3**5)
+
+    F = FracField((x, log(x), sqrt(x + log(x))), ZZ, lex)
+    _, lg, srt = F.gens
+    assert sfield((x + 1) / (x * (x + log(x))**QQ(3, 2)) - 1/(x * log(x)**2)) \
+        == (F, (F.x*lg**2 - F.x*srt + lg**2 - lg*srt)/
+            (F.x**2*lg**2*srt + F.x*lg**3*srt))
+
+def test_FracElement___hash__():
+    F, x, y, z = field("x,y,z", QQ)
+    assert hash(x*y/z)
+
+def test_FracElement_copy():
+    F, x, y, z = field("x,y,z", ZZ)
+
+    f = x*y/3*z
+    g = f.copy()
+
+    assert f == g
+    g.numer[(1, 1, 1)] = 7
+    assert f != g
+
+def test_FracElement_as_expr():
+    F, x, y, z = field("x,y,z", ZZ)
+    f = (3*x**2*y - x*y*z)/(7*z**3 + 1)
+
+    X, Y, Z = F.symbols
+    g = (3*X**2*Y - X*Y*Z)/(7*Z**3 + 1)
+
+    assert f != g
+    assert f.as_expr() == g
+
+    X, Y, Z = symbols("x,y,z")
+    g = (3*X**2*Y - X*Y*Z)/(7*Z**3 + 1)
+
+    assert f != g
+    assert f.as_expr(X, Y, Z) == g
+
+    raises(ValueError, lambda: f.as_expr(X))
+
+def test_FracElement_from_expr():
+    x, y, z = symbols("x,y,z")
+    F, X, Y, Z = field((x, y, z), ZZ)
+
+    f = F.from_expr(1)
+    assert f == 1 and isinstance(f, F.dtype)
+
+    f = F.from_expr(Rational(3, 7))
+    assert f == F(3)/7 and isinstance(f, F.dtype)
+
+    f = F.from_expr(x)
+    assert f == X and isinstance(f, F.dtype)
+
+    f = F.from_expr(Rational(3,7)*x)
+    assert f == X*Rational(3, 7) and isinstance(f, F.dtype)
+
+    f = F.from_expr(1/x)
+    assert f == 1/X and isinstance(f, F.dtype)
+
+    f = F.from_expr(x*y*z)
+    assert f == X*Y*Z and isinstance(f, F.dtype)
+
+    f = F.from_expr(x*y/z)
+    assert f == X*Y/Z and isinstance(f, F.dtype)
+
+    f = F.from_expr(x*y*z + x*y + x)
+    assert f == X*Y*Z + X*Y + X and isinstance(f, F.dtype)
+
+    f = F.from_expr((x*y*z + x*y + x)/(x*y + 7))
+    assert f == (X*Y*Z + X*Y + X)/(X*Y + 7) and isinstance(f, F.dtype)
+
+    f = F.from_expr(x**3*y*z + x**2*y**7 + 1)
+    assert f == X**3*Y*Z + X**2*Y**7 + 1 and isinstance(f, F.dtype)
+
+    raises(ValueError, lambda: F.from_expr(2**x))
+    raises(ValueError, lambda: F.from_expr(7*x + sqrt(2)))
+
+    assert isinstance(ZZ[2**x].get_field().convert(2**(-x)),
+        FracElement)
+    assert isinstance(ZZ[x**2].get_field().convert(x**(-6)),
+        FracElement)
+    assert isinstance(ZZ[exp(Rational(1, 3))].get_field().convert(E),
+        FracElement)
+
+
+def test_FracField_nested():
+    a, b, x = symbols('a b x')
+    F1 = ZZ.frac_field(a, b)
+    F2 = F1.frac_field(x)
+    frac = F2(a + b)
+    assert frac.numer == F1.poly_ring(x)(a + b)
+    assert frac.numer.coeffs() == [F1(a + b)]
+    assert frac.denom == F1.poly_ring(x)(1)
+
+    F3 = ZZ.poly_ring(a, b)
+    F4 = F3.frac_field(x)
+    frac = F4(a + b)
+    assert frac.numer == F3.poly_ring(x)(a + b)
+    assert frac.numer.coeffs() == [F3(a + b)]
+    assert frac.denom == F3.poly_ring(x)(1)
+
+    frac = F2(F3(a + b))
+    assert frac.numer == F1.poly_ring(x)(a + b)
+    assert frac.numer.coeffs() == [F1(a + b)]
+    assert frac.denom == F1.poly_ring(x)(1)
+
+    frac = F4(F1(a + b))
+    assert frac.numer == F3.poly_ring(x)(a + b)
+    assert frac.numer.coeffs() == [F3(a + b)]
+    assert frac.denom == F3.poly_ring(x)(1)
+
+
+def test_FracElement__lt_le_gt_ge__():
+    F, x, y = field("x,y", ZZ)
+
+    assert F(1) < 1/x < 1/x**2 < 1/x**3
+    assert F(1) <= 1/x <= 1/x**2 <= 1/x**3
+
+    assert -7/x < 1/x < 3/x < y/x < 1/x**2
+    assert -7/x <= 1/x <= 3/x <= y/x <= 1/x**2
+
+    assert 1/x**3 > 1/x**2 > 1/x > F(1)
+    assert 1/x**3 >= 1/x**2 >= 1/x >= F(1)
+
+    assert 1/x**2 > y/x > 3/x > 1/x > -7/x
+    assert 1/x**2 >= y/x >= 3/x >= 1/x >= -7/x
+
+def test_FracElement___neg__():
+    F, x,y = field("x,y", QQ)
+
+    f = (7*x - 9)/y
+    g = (-7*x + 9)/y
+
+    assert -f == g
+    assert -g == f
+
+def test_FracElement___add__():
+    F, x,y = field("x,y", QQ)
+
+    f, g = 1/x, 1/y
+    assert f + g == g + f == (x + y)/(x*y)
+
+    assert x + F.ring.gens[0] == F.ring.gens[0] + x == 2*x
+
+    F, x,y = field("x,y", ZZ)
+    assert x + 3 == 3 + x
+    assert x + QQ(3,7) == QQ(3,7) + x == (7*x + 3)/7
+
+    Fuv, u,v = field("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Fuv)
+
+    f = (u*v + x)/(y + u*v)
+    assert dict(f.numer) == {(1, 0, 0, 0): 1, (0, 0, 0, 0): u*v}
+    assert dict(f.denom) == {(0, 1, 0, 0): 1, (0, 0, 0, 0): u*v}
+
+    Ruv, u,v = ring("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Ruv)
+
+    f = (u*v + x)/(y + u*v)
+    assert dict(f.numer) == {(1, 0, 0, 0): 1, (0, 0, 0, 0): u*v}
+    assert dict(f.denom) == {(0, 1, 0, 0): 1, (0, 0, 0, 0): u*v}
+
+def test_FracElement___sub__():
+    F, x,y = field("x,y", QQ)
+
+    f, g = 1/x, 1/y
+    assert f - g == (-x + y)/(x*y)
+
+    assert x - F.ring.gens[0] == F.ring.gens[0] - x == 0
+
+    F, x,y = field("x,y", ZZ)
+    assert x - 3 == -(3 - x)
+    assert x - QQ(3,7) == -(QQ(3,7) - x) == (7*x - 3)/7
+
+    Fuv, u,v = field("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Fuv)
+
+    f = (u*v - x)/(y - u*v)
+    assert dict(f.numer) == {(1, 0, 0, 0):-1, (0, 0, 0, 0): u*v}
+    assert dict(f.denom) == {(0, 1, 0, 0): 1, (0, 0, 0, 0):-u*v}
+
+    Ruv, u,v = ring("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Ruv)
+
+    f = (u*v - x)/(y - u*v)
+    assert dict(f.numer) == {(1, 0, 0, 0):-1, (0, 0, 0, 0): u*v}
+    assert dict(f.denom) == {(0, 1, 0, 0): 1, (0, 0, 0, 0):-u*v}
+
+def test_FracElement___mul__():
+    F, x,y = field("x,y", QQ)
+
+    f, g = 1/x, 1/y
+    assert f*g == g*f == 1/(x*y)
+
+    assert x*F.ring.gens[0] == F.ring.gens[0]*x == x**2
+
+    F, x,y = field("x,y", ZZ)
+    assert x*3 == 3*x
+    assert x*QQ(3,7) == QQ(3,7)*x == x*Rational(3, 7)
+
+    Fuv, u,v = field("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Fuv)
+
+    f = ((u + 1)*x*y + 1)/((v - 1)*z - t*u*v - 1)
+    assert dict(f.numer) == {(1, 1, 0, 0): u + 1, (0, 0, 0, 0): 1}
+    assert dict(f.denom) == {(0, 0, 1, 0): v - 1, (0, 0, 0, 1): -u*v, (0, 0, 0, 0): -1}
+
+    Ruv, u,v = ring("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Ruv)
+
+    f = ((u + 1)*x*y + 1)/((v - 1)*z - t*u*v - 1)
+    assert dict(f.numer) == {(1, 1, 0, 0): u + 1, (0, 0, 0, 0): 1}
+    assert dict(f.denom) == {(0, 0, 1, 0): v - 1, (0, 0, 0, 1): -u*v, (0, 0, 0, 0): -1}
+
+def test_FracElement___truediv__():
+    F, x,y = field("x,y", QQ)
+
+    f, g = 1/x, 1/y
+    assert f/g == y/x
+
+    assert x/F.ring.gens[0] == F.ring.gens[0]/x == 1
+
+    F, x,y = field("x,y", ZZ)
+    assert x*3 == 3*x
+    assert x/QQ(3,7) == (QQ(3,7)/x)**-1 == x*Rational(7, 3)
+
+    raises(ZeroDivisionError, lambda: x/0)
+    raises(ZeroDivisionError, lambda: 1/(x - x))
+    raises(ZeroDivisionError, lambda: x/(x - x))
+
+    Fuv, u,v = field("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Fuv)
+
+    f = (u*v)/(x*y)
+    assert dict(f.numer) == {(0, 0, 0, 0): u*v}
+    assert dict(f.denom) == {(1, 1, 0, 0): 1}
+
+    g = (x*y)/(u*v)
+    assert dict(g.numer) == {(1, 1, 0, 0): 1}
+    assert dict(g.denom) == {(0, 0, 0, 0): u*v}
+
+    Ruv, u,v = ring("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Ruv)
+
+    f = (u*v)/(x*y)
+    assert dict(f.numer) == {(0, 0, 0, 0): u*v}
+    assert dict(f.denom) == {(1, 1, 0, 0): 1}
+
+    g = (x*y)/(u*v)
+    assert dict(g.numer) == {(1, 1, 0, 0): 1}
+    assert dict(g.denom) == {(0, 0, 0, 0): u*v}
+
+def test_FracElement___pow__():
+    F, x,y = field("x,y", QQ)
+
+    f, g = 1/x, 1/y
+
+    assert f**3 == 1/x**3
+    assert g**3 == 1/y**3
+
+    assert (f*g)**3 == 1/(x**3*y**3)
+    assert (f*g)**-3 == (x*y)**3
+
+    raises(ZeroDivisionError, lambda: (x - x)**-3)
+
+def test_FracElement_diff():
+    F, x,y,z = field("x,y,z", ZZ)
+
+    assert ((x**2 + y)/(z + 1)).diff(x) == 2*x/(z + 1)
+
+@XFAIL
+def test_FracElement___call__():
+    F, x,y,z = field("x,y,z", ZZ)
+    f = (x**2 + 3*y)/z
+
+    r = f(1, 1, 1)
+    assert r == 4 and not isinstance(r, FracElement)
+    raises(ZeroDivisionError, lambda: f(1, 1, 0))
+
+def test_FracElement_evaluate():
+    F, x,y,z = field("x,y,z", ZZ)
+    Fyz = field("y,z", ZZ)[0]
+    f = (x**2 + 3*y)/z
+
+    assert f.evaluate(x, 0) == 3*Fyz.y/Fyz.z
+    raises(ZeroDivisionError, lambda: f.evaluate(z, 0))
+
+def test_FracElement_subs():
+    F, x,y,z = field("x,y,z", ZZ)
+    f = (x**2 + 3*y)/z
+
+    assert f.subs(x, 0) == 3*y/z
+    raises(ZeroDivisionError, lambda: f.subs(z, 0))
+
+def test_FracElement_compose():
+    pass
+
+def test_FracField_index():
+    a = symbols("a")
+    F, x, y, z = field('x y z', QQ)
+    assert F.index(x) == 0
+    assert F.index(y) == 1
+
+    raises(ValueError, lambda: F.index(1))
+    raises(ValueError, lambda: F.index(a))
+    pass

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_galoistools.py

@@ -0,0 +1,875 @@
+from sympy.polys.galoistools import (
+    gf_crt, gf_crt1, gf_crt2, gf_int,
+    gf_degree, gf_strip, gf_trunc, gf_normal,
+    gf_from_dict, gf_to_dict,
+    gf_from_int_poly, gf_to_int_poly,
+    gf_neg, gf_add_ground, gf_sub_ground, gf_mul_ground,
+    gf_add, gf_sub, gf_add_mul, gf_sub_mul, gf_mul, gf_sqr,
+    gf_div, gf_rem, gf_quo, gf_exquo,
+    gf_lshift, gf_rshift, gf_expand,
+    gf_pow, gf_pow_mod,
+    gf_gcdex, gf_gcd, gf_lcm, gf_cofactors,
+    gf_LC, gf_TC, gf_monic,
+    gf_eval, gf_multi_eval,
+    gf_compose, gf_compose_mod,
+    gf_trace_map,
+    gf_diff,
+    gf_irreducible, gf_irreducible_p,
+    gf_irred_p_ben_or, gf_irred_p_rabin,
+    gf_sqf_list, gf_sqf_part, gf_sqf_p,
+    gf_Qmatrix, gf_Qbasis,
+    gf_ddf_zassenhaus, gf_ddf_shoup,
+    gf_edf_zassenhaus, gf_edf_shoup,
+    gf_berlekamp,
+    gf_factor_sqf, gf_factor,
+    gf_value, linear_congruence, _csolve_prime_las_vegas,
+    csolve_prime, gf_csolve, gf_frobenius_map, gf_frobenius_monomial_base
+)
+
+from sympy.polys.polyerrors import (
+    ExactQuotientFailed,
+)
+
+from sympy.polys import polyconfig as config
+
+from sympy.polys.domains import ZZ
+from sympy.core.numbers import pi
+from sympy.ntheory.generate import nextprime
+from sympy.testing.pytest import raises
+
+
+def test_gf_crt():
+    U = [49, 76, 65]
+    M = [99, 97, 95]
+
+    p = 912285
+    u = 639985
+
+    assert gf_crt(U, M, ZZ) == u
+
+    E = [9215, 9405, 9603]
+    S = [62, 24, 12]
+
+    assert gf_crt1(M, ZZ) == (p, E, S)
+    assert gf_crt2(U, M, p, E, S, ZZ) == u
+
+
+def test_gf_int():
+    assert gf_int(0, 5) == 0
+    assert gf_int(1, 5) == 1
+    assert gf_int(2, 5) == 2
+    assert gf_int(3, 5) == -2
+    assert gf_int(4, 5) == -1
+    assert gf_int(5, 5) == 0
+
+
+def test_gf_degree():
+    assert gf_degree([]) == -1
+    assert gf_degree([1]) == 0
+    assert gf_degree([1, 0]) == 1
+    assert gf_degree([1, 0, 0, 0, 1]) == 4
+
+
+def test_gf_strip():
+    assert gf_strip([]) == []
+    assert gf_strip([0]) == []
+    assert gf_strip([0, 0, 0]) == []
+
+    assert gf_strip([1]) == [1]
+    assert gf_strip([0, 1]) == [1]
+    assert gf_strip([0, 0, 0, 1]) == [1]
+
+    assert gf_strip([1, 2, 0]) == [1, 2, 0]
+    assert gf_strip([0, 1, 2, 0]) == [1, 2, 0]
+    assert gf_strip([0, 0, 0, 1, 2, 0]) == [1, 2, 0]
+
+
+def test_gf_trunc():
+    assert gf_trunc([], 11) == []
+    assert gf_trunc([1], 11) == [1]
+    assert gf_trunc([22], 11) == []
+    assert gf_trunc([12], 11) == [1]
+
+    assert gf_trunc([11, 22, 17, 1, 0], 11) == [6, 1, 0]
+    assert gf_trunc([12, 23, 17, 1, 0], 11) == [1, 1, 6, 1, 0]
+
+
+def test_gf_normal():
+    assert gf_normal([11, 22, 17, 1, 0], 11, ZZ) == [6, 1, 0]
+
+
+def test_gf_from_to_dict():
+    f = {11: 12, 6: 2, 0: 25}
+    F = {11: 1, 6: 2, 0: 3}
+    g = [1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 3]
+
+    assert gf_from_dict(f, 11, ZZ) == g
+    assert gf_to_dict(g, 11) == F
+
+    f = {11: -5, 4: 0, 3: 1, 0: 12}
+    F = {11: -5, 3: 1, 0: 1}
+    g = [6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1]
+
+    assert gf_from_dict(f, 11, ZZ) == g
+    assert gf_to_dict(g, 11) == F
+
+    assert gf_to_dict([10], 11, symmetric=True) == {0: -1}
+    assert gf_to_dict([10], 11, symmetric=False) == {0: 10}
+
+
+def test_gf_from_to_int_poly():
+    assert gf_from_int_poly([1, 0, 7, 2, 20], 5) == [1, 0, 2, 2, 0]
+    assert gf_to_int_poly([1, 0, 4, 2, 3], 5) == [1, 0, -1, 2, -2]
+
+    assert gf_to_int_poly([10], 11, symmetric=True) == [-1]
+    assert gf_to_int_poly([10], 11, symmetric=False) == [10]
+
+
+def test_gf_LC():
+    assert gf_LC([], ZZ) == 0
+    assert gf_LC([1], ZZ) == 1
+    assert gf_LC([1, 2], ZZ) == 1
+
+
+def test_gf_TC():
+    assert gf_TC([], ZZ) == 0
+    assert gf_TC([1], ZZ) == 1
+    assert gf_TC([1, 2], ZZ) == 2
+
+
+def test_gf_monic():
+    assert gf_monic(ZZ.map([]), 11, ZZ) == (0, [])
+
+    assert gf_monic(ZZ.map([1]), 11, ZZ) == (1, [1])
+    assert gf_monic(ZZ.map([2]), 11, ZZ) == (2, [1])
+
+    assert gf_monic(ZZ.map([1, 2, 3, 4]), 11, ZZ) == (1, [1, 2, 3, 4])
+    assert gf_monic(ZZ.map([2, 3, 4, 5]), 11, ZZ) == (2, [1, 7, 2, 8])
+
+
+def test_gf_arith():
+    assert gf_neg([], 11, ZZ) == []
+    assert gf_neg([1], 11, ZZ) == [10]
+    assert gf_neg([1, 2, 3], 11, ZZ) == [10, 9, 8]
+
+    assert gf_add_ground([], 0, 11, ZZ) == []
+    assert gf_sub_ground([], 0, 11, ZZ) == []
+
+    assert gf_add_ground([], 3, 11, ZZ) == [3]
+    assert gf_sub_ground([], 3, 11, ZZ) == [8]
+
+    assert gf_add_ground([1], 3, 11, ZZ) == [4]
+    assert gf_sub_ground([1], 3, 11, ZZ) == [9]
+
+    assert gf_add_ground([8], 3, 11, ZZ) == []
+    assert gf_sub_ground([3], 3, 11, ZZ) == []
+
+    assert gf_add_ground([1, 2, 3], 3, 11, ZZ) == [1, 2, 6]
+    assert gf_sub_ground([1, 2, 3], 3, 11, ZZ) == [1, 2, 0]
+
+    assert gf_mul_ground([], 0, 11, ZZ) == []
+    assert gf_mul_ground([], 1, 11, ZZ) == []
+
+    assert gf_mul_ground([1], 0, 11, ZZ) == []
+    assert gf_mul_ground([1], 1, 11, ZZ) == [1]
+
+    assert gf_mul_ground([1, 2, 3], 0, 11, ZZ) == []
+    assert gf_mul_ground([1, 2, 3], 1, 11, ZZ) == [1, 2, 3]
+    assert gf_mul_ground([1, 2, 3], 7, 11, ZZ) == [7, 3, 10]
+
+    assert gf_add([], [], 11, ZZ) == []
+    assert gf_add([1], [], 11, ZZ) == [1]
+    assert gf_add([], [1], 11, ZZ) == [1]
+    assert gf_add([1], [1], 11, ZZ) == [2]
+    assert gf_add([1], [2], 11, ZZ) == [3]
+
+    assert gf_add([1, 2], [1], 11, ZZ) == [1, 3]
+    assert gf_add([1], [1, 2], 11, ZZ) == [1, 3]
+
+    assert gf_add([1, 2, 3], [8, 9, 10], 11, ZZ) == [9, 0, 2]
+
+    assert gf_sub([], [], 11, ZZ) == []
+    assert gf_sub([1], [], 11, ZZ) == [1]
+    assert gf_sub([], [1], 11, ZZ) == [10]
+    assert gf_sub([1], [1], 11, ZZ) == []
+    assert gf_sub([1], [2], 11, ZZ) == [10]
+
+    assert gf_sub([1, 2], [1], 11, ZZ) == [1, 1]
+    assert gf_sub([1], [1, 2], 11, ZZ) == [10, 10]
+
+    assert gf_sub([3, 2, 1], [8, 9, 10], 11, ZZ) == [6, 4, 2]
+
+    assert gf_add_mul(
+        [1, 5, 6], [7, 3], [8, 0, 6, 1], 11, ZZ) == [1, 2, 10, 8, 9]
+    assert gf_sub_mul(
+        [1, 5, 6], [7, 3], [8, 0, 6, 1], 11, ZZ) == [10, 9, 3, 2, 3]
+
+    assert gf_mul([], [], 11, ZZ) == []
+    assert gf_mul([], [1], 11, ZZ) == []
+    assert gf_mul([1], [], 11, ZZ) == []
+    assert gf_mul([1], [1], 11, ZZ) == [1]
+    assert gf_mul([5], [7], 11, ZZ) == [2]
+
+    assert gf_mul([3, 0, 0, 6, 1, 2], [4, 0, 1, 0], 11, ZZ) == [1, 0,
+                  3, 2, 4, 3, 1, 2, 0]
+    assert gf_mul([4, 0, 1, 0], [3, 0, 0, 6, 1, 2], 11, ZZ) == [1, 0,
+                  3, 2, 4, 3, 1, 2, 0]
+
+    assert gf_mul([2, 0, 0, 1, 7], [2, 0, 0, 1, 7], 11, ZZ) == [4, 0,
+                  0, 4, 6, 0, 1, 3, 5]
+
+    assert gf_sqr([], 11, ZZ) == []
+    assert gf_sqr([2], 11, ZZ) == [4]
+    assert gf_sqr([1, 2], 11, ZZ) == [1, 4, 4]
+
+    assert gf_sqr([2, 0, 0, 1, 7], 11, ZZ) == [4, 0, 0, 4, 6, 0, 1, 3, 5]
+
+
+def test_gf_division():
+    raises(ZeroDivisionError, lambda: gf_div([1, 2, 3], [], 11, ZZ))
+    raises(ZeroDivisionError, lambda: gf_rem([1, 2, 3], [], 11, ZZ))
+    raises(ZeroDivisionError, lambda: gf_quo([1, 2, 3], [], 11, ZZ))
+    raises(ZeroDivisionError, lambda: gf_quo([1, 2, 3], [], 11, ZZ))
+
+    assert gf_div([1], [1, 2, 3], 7, ZZ) == ([], [1])
+    assert gf_rem([1], [1, 2, 3], 7, ZZ) == [1]
+    assert gf_quo([1], [1, 2, 3], 7, ZZ) == []
+
+    f = ZZ.map([5, 4, 3, 2, 1, 0])
+    g = ZZ.map([1, 2, 3])
+    q = [5, 1, 0, 6]
+    r = [3, 3]
+
+    assert gf_div(f, g, 7, ZZ) == (q, r)
+    assert gf_rem(f, g, 7, ZZ) == r
+    assert gf_quo(f, g, 7, ZZ) == q
+
+    raises(ExactQuotientFailed, lambda: gf_exquo(f, g, 7, ZZ))
+
+    f = ZZ.map([5, 4, 3, 2, 1, 0])
+    g = ZZ.map([1, 2, 3, 0])
+    q = [5, 1, 0]
+    r = [6, 1, 0]
+
+    assert gf_div(f, g, 7, ZZ) == (q, r)
+    assert gf_rem(f, g, 7, ZZ) == r
+    assert gf_quo(f, g, 7, ZZ) == q
+
+    raises(ExactQuotientFailed, lambda: gf_exquo(f, g, 7, ZZ))
+
+    assert gf_quo(ZZ.map([1, 2, 1]), ZZ.map([1, 1]), 11, ZZ) == [1, 1]
+
+
+def test_gf_shift():
+    f = [1, 2, 3, 4, 5]
+
+    assert gf_lshift([], 5, ZZ) == []
+    assert gf_rshift([], 5, ZZ) == ([], [])
+
+    assert gf_lshift(f, 1, ZZ) == [1, 2, 3, 4, 5, 0]
+    assert gf_lshift(f, 2, ZZ) == [1, 2, 3, 4, 5, 0, 0]
+
+    assert gf_rshift(f, 0, ZZ) == (f, [])
+    assert gf_rshift(f, 1, ZZ) == ([1, 2, 3, 4], [5])
+    assert gf_rshift(f, 3, ZZ) == ([1, 2], [3, 4, 5])
+    assert gf_rshift(f, 5, ZZ) == ([], f)
+
+
+def test_gf_expand():
+    F = [([1, 1], 2), ([1, 2], 3)]
+
+    assert gf_expand(F, 11, ZZ) == [1, 8, 3, 5, 6, 8]
+    assert gf_expand((4, F), 11, ZZ) == [4, 10, 1, 9, 2, 10]
+
+
+def test_gf_powering():
+    assert gf_pow([1, 0, 0, 1, 8], 0, 11, ZZ) == [1]
+    assert gf_pow([1, 0, 0, 1, 8], 1, 11, ZZ) == [1, 0, 0, 1, 8]
+    assert gf_pow([1, 0, 0, 1, 8], 2, 11, ZZ) == [1, 0, 0, 2, 5, 0, 1, 5, 9]
+
+    assert gf_pow([1, 0, 0, 1, 8], 5, 11, ZZ) == \
+        [1, 0, 0, 5, 7, 0, 10, 6, 2, 10, 9, 6, 10, 6, 6, 0, 5, 2, 5, 9, 10]
+
+    assert gf_pow([1, 0, 0, 1, 8], 8, 11, ZZ) == \
+        [1, 0, 0, 8, 9, 0, 6, 8, 10, 1, 2, 5, 10, 7, 7, 9, 1, 2, 0, 0, 6, 2,
+         5, 2, 5, 7, 7, 9, 10, 10, 7, 5, 5]
+
+    assert gf_pow([1, 0, 0, 1, 8], 45, 11, ZZ) == \
+        [ 1, 0, 0,  1,  8, 0, 0, 0, 0, 0, 0,  0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,  4, 0, 0,  4, 10, 0, 0, 0, 0, 0, 0,
+         10, 0, 0, 10,  3, 0, 0, 0, 0, 0, 0,  0, 0, 0,  0,  0, 0, 0, 0, 0, 0, 0,
+          6, 0, 0,  6,  4, 0, 0, 0, 0, 0, 0,  8, 0, 0,  8,  9, 0, 0, 0, 0, 0, 0,
+         10, 0, 0, 10,  3, 0, 0, 0, 0, 0, 0,  4, 0, 0,  4, 10, 0, 0, 0, 0, 0, 0,
+          8, 0, 0,  8,  9, 0, 0, 0, 0, 0, 0,  9, 0, 0,  9,  6, 0, 0, 0, 0, 0, 0,
+          3, 0, 0,  3,  2, 0, 0, 0, 0, 0, 0, 10, 0, 0, 10,  3, 0, 0, 0, 0, 0, 0,
+         10, 0, 0, 10,  3, 0, 0, 0, 0, 0, 0,  2, 0, 0,  2,  5, 0, 0, 0, 0, 0, 0,
+          4, 0, 0,  4, 10]
+
+    assert gf_pow_mod(ZZ.map([1, 0, 0, 1, 8]), 0, ZZ.map([2, 0, 7]), 11, ZZ) == [1]
+    assert gf_pow_mod(ZZ.map([1, 0, 0, 1, 8]), 1, ZZ.map([2, 0, 7]), 11, ZZ) == [1, 1]
+    assert gf_pow_mod(ZZ.map([1, 0, 0, 1, 8]), 2, ZZ.map([2, 0, 7]), 11, ZZ) == [2, 3]
+    assert gf_pow_mod(ZZ.map([1, 0, 0, 1, 8]), 5, ZZ.map([2, 0, 7]), 11, ZZ) == [7, 8]
+    assert gf_pow_mod(ZZ.map([1, 0, 0, 1, 8]), 8, ZZ.map([2, 0, 7]), 11, ZZ) == [1, 5]
+    assert gf_pow_mod(ZZ.map([1, 0, 0, 1, 8]), 45, ZZ.map([2, 0, 7]), 11, ZZ) == [5, 4]
+
+
+def test_gf_gcdex():
+    assert gf_gcdex(ZZ.map([]), ZZ.map([]), 11, ZZ) == ([1], [], [])
+    assert gf_gcdex(ZZ.map([2]), ZZ.map([]), 11, ZZ) == ([6], [], [1])
+    assert gf_gcdex(ZZ.map([]), ZZ.map([2]), 11, ZZ) == ([], [6], [1])
+    assert gf_gcdex(ZZ.map([2]), ZZ.map([2]), 11, ZZ) == ([], [6], [1])
+
+    assert gf_gcdex(ZZ.map([]), ZZ.map([3, 0]), 11, ZZ) == ([], [4], [1, 0])
+    assert gf_gcdex(ZZ.map([3, 0]), ZZ.map([]), 11, ZZ) == ([4], [], [1, 0])
+
+    assert gf_gcdex(ZZ.map([3, 0]), ZZ.map([3, 0]), 11, ZZ) == ([], [4], [1, 0])
+
+    assert gf_gcdex(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ) == ([5, 6], [6], [1, 7])
+
+
+def test_gf_gcd():
+    assert gf_gcd(ZZ.map([]), ZZ.map([]), 11, ZZ) == []
+    assert gf_gcd(ZZ.map([2]), ZZ.map([]), 11, ZZ) == [1]
+    assert gf_gcd(ZZ.map([]), ZZ.map([2]), 11, ZZ) == [1]
+    assert gf_gcd(ZZ.map([2]), ZZ.map([2]), 11, ZZ) == [1]
+
+    assert gf_gcd(ZZ.map([]), ZZ.map([1, 0]), 11, ZZ) == [1, 0]
+    assert gf_gcd(ZZ.map([1, 0]), ZZ.map([]), 11, ZZ) == [1, 0]
+
+    assert gf_gcd(ZZ.map([3, 0]), ZZ.map([3, 0]), 11, ZZ) == [1, 0]
+    assert gf_gcd(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ) == [1, 7]
+
+
+def test_gf_lcm():
+    assert gf_lcm(ZZ.map([]), ZZ.map([]), 11, ZZ) == []
+    assert gf_lcm(ZZ.map([2]), ZZ.map([]), 11, ZZ) == []
+    assert gf_lcm(ZZ.map([]), ZZ.map([2]), 11, ZZ) == []
+    assert gf_lcm(ZZ.map([2]), ZZ.map([2]), 11, ZZ) == [1]
+
+    assert gf_lcm(ZZ.map([]), ZZ.map([1, 0]), 11, ZZ) == []
+    assert gf_lcm(ZZ.map([1, 0]), ZZ.map([]), 11, ZZ) == []
+
+    assert gf_lcm(ZZ.map([3, 0]), ZZ.map([3, 0]), 11, ZZ) == [1, 0]
+    assert gf_lcm(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ) == [1, 8, 8, 8, 7]
+
+
+def test_gf_cofactors():
+    assert gf_cofactors(ZZ.map([]), ZZ.map([]), 11, ZZ) == ([], [], [])
+    assert gf_cofactors(ZZ.map([2]), ZZ.map([]), 11, ZZ) == ([1], [2], [])
+    assert gf_cofactors(ZZ.map([]), ZZ.map([2]), 11, ZZ) == ([1], [], [2])
+    assert gf_cofactors(ZZ.map([2]), ZZ.map([2]), 11, ZZ) == ([1], [2], [2])
+
+    assert gf_cofactors(ZZ.map([]), ZZ.map([1, 0]), 11, ZZ) == ([1, 0], [], [1])
+    assert gf_cofactors(ZZ.map([1, 0]), ZZ.map([]), 11, ZZ) == ([1, 0], [1], [])
+
+    assert gf_cofactors(ZZ.map([3, 0]), ZZ.map([3, 0]), 11, ZZ) == (
+        [1, 0], [3], [3])
+    assert gf_cofactors(ZZ.map([1, 8, 7]), ZZ.map([1, 7, 1, 7]), 11, ZZ) == (
+        ([1, 7], [1, 1], [1, 0, 1]))
+
+
+def test_gf_diff():
+    assert gf_diff([], 11, ZZ) == []
+    assert gf_diff([7], 11, ZZ) == []
+
+    assert gf_diff([7, 3], 11, ZZ) == [7]
+    assert gf_diff([7, 3, 1], 11, ZZ) == [3, 3]
+
+    assert gf_diff([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 11, ZZ) == []
+
+
+def test_gf_eval():
+    assert gf_eval([], 4, 11, ZZ) == 0
+    assert gf_eval([], 27, 11, ZZ) == 0
+    assert gf_eval([7], 4, 11, ZZ) == 7
+    assert gf_eval([7], 27, 11, ZZ) == 7
+
+    assert gf_eval([1, 0, 3, 2, 4, 3, 1, 2, 0], 0, 11, ZZ) == 0
+    assert gf_eval([1, 0, 3, 2, 4, 3, 1, 2, 0], 4, 11, ZZ) == 9
+    assert gf_eval([1, 0, 3, 2, 4, 3, 1, 2, 0], 27, 11, ZZ) == 5
+
+    assert gf_eval([4, 0, 0, 4, 6, 0, 1, 3, 5], 0, 11, ZZ) == 5
+    assert gf_eval([4, 0, 0, 4, 6, 0, 1, 3, 5], 4, 11, ZZ) == 3
+    assert gf_eval([4, 0, 0, 4, 6, 0, 1, 3, 5], 27, 11, ZZ) == 9
+
+    assert gf_multi_eval([3, 2, 1], [0, 1, 2, 3], 11, ZZ) == [1, 6, 6, 1]
+
+
+def test_gf_compose():
+    assert gf_compose([], [1, 0], 11, ZZ) == []
+    assert gf_compose_mod([], [1, 0], [1, 0], 11, ZZ) == []
+
+    assert gf_compose([1], [], 11, ZZ) == [1]
+    assert gf_compose([1, 0], [], 11, ZZ) == []
+    assert gf_compose([1, 0], [1, 0], 11, ZZ) == [1, 0]
+
+    f = ZZ.map([1, 1, 4, 9, 1])
+    g = ZZ.map([1, 1, 1])
+    h = ZZ.map([1, 0, 0, 2])
+
+    assert gf_compose(g, h, 11, ZZ) == [1, 0, 0, 5, 0, 0, 7]
+    assert gf_compose_mod(g, h, f, 11, ZZ) == [3, 9, 6, 10]
+
+
+def test_gf_trace_map():
+    f = ZZ.map([1, 1, 4, 9, 1])
+    a = [1, 1, 1]
+    c = ZZ.map([1, 0])
+    b = gf_pow_mod(c, 11, f, 11, ZZ)
+
+    assert gf_trace_map(a, b, c, 0, f, 11, ZZ) == \
+        ([1, 1, 1], [1, 1, 1])
+    assert gf_trace_map(a, b, c, 1, f, 11, ZZ) == \
+        ([5, 2, 10, 3], [5, 3, 0, 4])
+    assert gf_trace_map(a, b, c, 2, f, 11, ZZ) == \
+        ([5, 9, 5, 3], [10, 1, 5, 7])
+    assert gf_trace_map(a, b, c, 3, f, 11, ZZ) == \
+        ([1, 10, 6, 0], [7])
+    assert gf_trace_map(a, b, c, 4, f, 11, ZZ) == \
+        ([1, 1, 1], [1, 1, 8])
+    assert gf_trace_map(a, b, c, 5, f, 11, ZZ) == \
+        ([5, 2, 10, 3], [5, 3, 0, 0])
+    assert gf_trace_map(a, b, c, 11, f, 11, ZZ) == \
+        ([1, 10, 6, 0], [10])
+
+
+def test_gf_irreducible():
+    assert gf_irreducible_p(gf_irreducible(1, 11, ZZ), 11, ZZ) is True
+    assert gf_irreducible_p(gf_irreducible(2, 11, ZZ), 11, ZZ) is True
+    assert gf_irreducible_p(gf_irreducible(3, 11, ZZ), 11, ZZ) is True
+    assert gf_irreducible_p(gf_irreducible(4, 11, ZZ), 11, ZZ) is True
+    assert gf_irreducible_p(gf_irreducible(5, 11, ZZ), 11, ZZ) is True
+    assert gf_irreducible_p(gf_irreducible(6, 11, ZZ), 11, ZZ) is True
+    assert gf_irreducible_p(gf_irreducible(7, 11, ZZ), 11, ZZ) is True
+
+
+def test_gf_irreducible_p():
+    assert gf_irred_p_ben_or(ZZ.map([7]), 11, ZZ) is True
+    assert gf_irred_p_ben_or(ZZ.map([7, 3]), 11, ZZ) is True
+    assert gf_irred_p_ben_or(ZZ.map([7, 3, 1]), 11, ZZ) is False
+
+    assert gf_irred_p_rabin(ZZ.map([7]), 11, ZZ) is True
+    assert gf_irred_p_rabin(ZZ.map([7, 3]), 11, ZZ) is True
+    assert gf_irred_p_rabin(ZZ.map([7, 3, 1]), 11, ZZ) is False
+
+    config.setup('GF_IRRED_METHOD', 'ben-or')
+
+    assert gf_irreducible_p(ZZ.map([7]), 11, ZZ) is True
+    assert gf_irreducible_p(ZZ.map([7, 3]), 11, ZZ) is True
+    assert gf_irreducible_p(ZZ.map([7, 3, 1]), 11, ZZ) is False
+
+    config.setup('GF_IRRED_METHOD', 'rabin')
+
+    assert gf_irreducible_p(ZZ.map([7]), 11, ZZ) is True
+    assert gf_irreducible_p(ZZ.map([7, 3]), 11, ZZ) is True
+    assert gf_irreducible_p(ZZ.map([7, 3, 1]), 11, ZZ) is False
+
+    config.setup('GF_IRRED_METHOD', 'other')
+    raises(KeyError, lambda: gf_irreducible_p([7], 11, ZZ))
+    config.setup('GF_IRRED_METHOD')
+
+    f = ZZ.map([1, 9, 9, 13, 16, 15, 6, 7, 7, 7, 10])
+    g = ZZ.map([1, 7, 16, 7, 15, 13, 13, 11, 16, 10, 9])
+
+    h = gf_mul(f, g, 17, ZZ)
+
+    assert gf_irred_p_ben_or(f, 17, ZZ) is True
+    assert gf_irred_p_ben_or(g, 17, ZZ) is True
+
+    assert gf_irred_p_ben_or(h, 17, ZZ) is False
+
+    assert gf_irred_p_rabin(f, 17, ZZ) is True
+    assert gf_irred_p_rabin(g, 17, ZZ) is True
+
+    assert gf_irred_p_rabin(h, 17, ZZ) is False
+
+
+def test_gf_squarefree():
+    assert gf_sqf_list([], 11, ZZ) == (0, [])
+    assert gf_sqf_list([1], 11, ZZ) == (1, [])
+    assert gf_sqf_list([1, 1], 11, ZZ) == (1, [([1, 1], 1)])
+
+    assert gf_sqf_p([], 11, ZZ) is True
+    assert gf_sqf_p([1], 11, ZZ) is True
+    assert gf_sqf_p([1, 1], 11, ZZ) is True
+
+    f = gf_from_dict({11: 1, 0: 1}, 11, ZZ)
+
+    assert gf_sqf_p(f, 11, ZZ) is False
+
+    assert gf_sqf_list(f, 11, ZZ) == \
+        (1, [([1, 1], 11)])
+
+    f = [1, 5, 8, 4]
+
+    assert gf_sqf_p(f, 11, ZZ) is False
+
+    assert gf_sqf_list(f, 11, ZZ) == \
+        (1, [([1, 1], 1),
+             ([1, 2], 2)])
+
+    assert gf_sqf_part(f, 11, ZZ) == [1, 3, 2]
+
+    f = [1, 0, 0, 2, 0, 0, 2, 0, 0, 1, 0]
+
+    assert gf_sqf_list(f, 3, ZZ) == \
+        (1, [([1, 0], 1),
+             ([1, 1], 3),
+             ([1, 2], 6)])
+
+def test_gf_frobenius_map():
+    f = ZZ.map([2, 0, 1, 0, 2, 2, 0, 2, 2, 2])
+    g = ZZ.map([1,1,0,2,0,1,0,2,0,1])
+    p = 3
+    b = gf_frobenius_monomial_base(g, p, ZZ)
+    h = gf_frobenius_map(f, g, b, p, ZZ)
+    h1 = gf_pow_mod(f, p, g, p, ZZ)
+    assert h == h1
+
+
+def test_gf_berlekamp():
+    f = gf_from_int_poly([1, -3, 1, -3, -1, -3, 1], 11)
+
+    Q = [[1, 0, 0, 0, 0, 0],
+         [3, 5, 8, 8, 6, 5],
+         [3, 6, 6, 1, 10, 0],
+         [9, 4, 10, 3, 7, 9],
+         [7, 8, 10, 0, 0, 8],
+         [8, 10, 7, 8, 10, 8]]
+
+    V = [[1, 0, 0, 0, 0, 0],
+         [0, 1, 1, 1, 1, 0],
+         [0, 0, 7, 9, 0, 1]]
+
+    assert gf_Qmatrix(f, 11, ZZ) == Q
+    assert gf_Qbasis(Q, 11, ZZ) == V
+
+    assert gf_berlekamp(f, 11, ZZ) == \
+        [[1, 1], [1, 5, 3], [1, 2, 3, 4]]
+
+    f = ZZ.map([1, 0, 1, 0, 10, 10, 8, 2, 8])
+
+    Q = ZZ.map([[1, 0, 0, 0, 0, 0, 0, 0],
+         [2, 1, 7, 11, 10, 12, 5, 11],
+         [3, 6, 4, 3, 0, 4, 7, 2],
+         [4, 3, 6, 5, 1, 6, 2, 3],
+         [2, 11, 8, 8, 3, 1, 3, 11],
+         [6, 11, 8, 6, 2, 7, 10, 9],
+         [5, 11, 7, 10, 0, 11, 7, 12],
+         [3, 3, 12, 5, 0, 11, 9, 12]])
+
+    V = [[1, 0, 0, 0, 0, 0, 0, 0],
+         [0, 5, 5, 0, 9, 5, 1, 0],
+         [0, 9, 11, 9, 10, 12, 0, 1]]
+
+    assert gf_Qmatrix(f, 13, ZZ) == Q
+    assert gf_Qbasis(Q, 13, ZZ) == V
+
+    assert gf_berlekamp(f, 13, ZZ) == \
+        [[1, 3], [1, 8, 4, 12], [1, 2, 3, 4, 6]]
+
+
+def test_gf_ddf():
+    f = gf_from_dict({15: ZZ(1), 0: ZZ(-1)}, 11, ZZ)
+    g = [([1, 0, 0, 0, 0, 10], 1),
+         ([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], 2)]
+
+    assert gf_ddf_zassenhaus(f, 11, ZZ) == g
+    assert gf_ddf_shoup(f, 11, ZZ) == g
+
+    f = gf_from_dict({63: ZZ(1), 0: ZZ(1)}, 2, ZZ)
+    g = [([1, 1], 1),
+         ([1, 1, 1], 2),
+         ([1, 1, 1, 1, 1, 1, 1], 3),
+         ([1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0,
+           0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0,
+           0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1], 6)]
+
+    assert gf_ddf_zassenhaus(f, 2, ZZ) == g
+    assert gf_ddf_shoup(f, 2, ZZ) == g
+
+    f = gf_from_dict({6: ZZ(1), 5: ZZ(-1), 4: ZZ(1), 3: ZZ(1), 1: ZZ(-1)}, 3, ZZ)
+    g = [([1, 1, 0], 1),
+         ([1, 1, 0, 1, 2], 2)]
+
+    assert gf_ddf_zassenhaus(f, 3, ZZ) == g
+    assert gf_ddf_shoup(f, 3, ZZ) == g
+
+    f = ZZ.map([1, 2, 5, 26, 677, 436, 791, 325, 456, 24, 577])
+    g = [([1, 701], 1),
+         ([1, 110, 559, 532, 694, 151, 110, 70, 735, 122], 9)]
+
+    assert gf_ddf_zassenhaus(f, 809, ZZ) == g
+    assert gf_ddf_shoup(f, 809, ZZ) == g
+
+    p = ZZ(nextprime(int((2**15 * pi).evalf())))
+    f = gf_from_dict({15: 1, 1: 1, 0: 1}, p, ZZ)
+    g = [([1, 22730, 68144], 2),
+         ([1, 64876, 83977, 10787, 12561, 68608, 52650, 88001, 84356], 4),
+         ([1, 15347, 95022, 84569, 94508, 92335], 5)]
+
+    assert gf_ddf_zassenhaus(f, p, ZZ) == g
+    assert gf_ddf_shoup(f, p, ZZ) == g
+
+
+def test_gf_edf():
+    f = ZZ.map([1, 1, 0, 1, 2])
+    g = ZZ.map([[1, 0, 1], [1, 1, 2]])
+
+    assert gf_edf_zassenhaus(f, 2, 3, ZZ) == g
+    assert gf_edf_shoup(f, 2, 3, ZZ) == g
+
+
+def test_issue_23174():
+    f = ZZ.map([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
+    g = ZZ.map([[1, 0, 0, 1, 1, 1, 0, 0, 1], [1, 1, 1, 0, 1, 0, 1, 1, 1]])
+
+    assert gf_edf_zassenhaus(f, 8, 2, ZZ) == g
+
+
+def test_gf_factor():
+    assert gf_factor([], 11, ZZ) == (0, [])
+    assert gf_factor([1], 11, ZZ) == (1, [])
+    assert gf_factor([1, 1], 11, ZZ) == (1, [([1, 1], 1)])
+
+    assert gf_factor_sqf([], 11, ZZ) == (0, [])
+    assert gf_factor_sqf([1], 11, ZZ) == (1, [])
+    assert gf_factor_sqf([1, 1], 11, ZZ) == (1, [[1, 1]])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+
+    assert gf_factor_sqf([], 11, ZZ) == (0, [])
+    assert gf_factor_sqf([1], 11, ZZ) == (1, [])
+    assert gf_factor_sqf([1, 1], 11, ZZ) == (1, [[1, 1]])
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+
+    assert gf_factor_sqf([], 11, ZZ) == (0, [])
+    assert gf_factor_sqf([1], 11, ZZ) == (1, [])
+    assert gf_factor_sqf([1, 1], 11, ZZ) == (1, [[1, 1]])
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+
+    assert gf_factor_sqf(ZZ.map([]), 11, ZZ) == (0, [])
+    assert gf_factor_sqf(ZZ.map([1]), 11, ZZ) == (1, [])
+    assert gf_factor_sqf(ZZ.map([1, 1]), 11, ZZ) == (1, [[1, 1]])
+
+    f, p = ZZ.map([1, 0, 0, 1, 0]), 2
+
+    g = (1, [([1, 0], 1),
+             ([1, 1], 1),
+             ([1, 1, 1], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    g = (1, [[1, 0],
+             [1, 1],
+             [1, 1, 1]])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    f, p = gf_from_int_poly([1, -3, 1, -3, -1, -3, 1], 11), 11
+
+    g = (1, [([1, 1], 1),
+             ([1, 5, 3], 1),
+             ([1, 2, 3, 4], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    f, p = [1, 5, 8, 4], 11
+
+    g = (1, [([1, 1], 1), ([1, 2], 2)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    f, p = [1, 1, 10, 1, 0, 10, 10, 10, 0, 0], 11
+
+    g = (1, [([1, 0], 2), ([1, 9, 5], 1), ([1, 3, 0, 8, 5, 2], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    f, p = gf_from_dict({32: 1, 0: 1}, 11, ZZ), 11
+
+    g = (1, [([1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 10], 1),
+             ([1, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 10], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    f, p = gf_from_dict({32: ZZ(8), 0: ZZ(5)}, 11, ZZ), 11
+
+    g = (8, [([1, 3], 1),
+             ([1, 8], 1),
+             ([1, 0, 9], 1),
+             ([1, 2, 2], 1),
+             ([1, 9, 2], 1),
+             ([1, 0, 5, 0, 7], 1),
+             ([1, 0, 6, 0, 7], 1),
+             ([1, 0, 0, 0, 1, 0, 0, 0, 6], 1),
+             ([1, 0, 0, 0, 10, 0, 0, 0, 6], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    f, p = gf_from_dict({63: ZZ(8), 0: ZZ(5)}, 11, ZZ), 11
+
+    g = (8, [([1, 7], 1),
+             ([1, 4, 5], 1),
+             ([1, 6, 8, 2], 1),
+             ([1, 9, 9, 2], 1),
+             ([1, 0, 0, 9, 0, 0, 4], 1),
+             ([1, 2, 0, 8, 4, 6, 4], 1),
+             ([1, 2, 3, 8, 0, 6, 4], 1),
+             ([1, 2, 6, 0, 8, 4, 4], 1),
+             ([1, 3, 3, 1, 6, 8, 4], 1),
+             ([1, 5, 6, 0, 8, 6, 4], 1),
+             ([1, 6, 2, 7, 9, 8, 4], 1),
+             ([1, 10, 4, 7, 10, 7, 4], 1),
+             ([1, 10, 10, 1, 4, 9, 4], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'berlekamp')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    # Gathen polynomials: x**n + x + 1 (mod p > 2**n * pi)
+
+    p = ZZ(nextprime(int((2**15 * pi).evalf())))
+    f = gf_from_dict({15: 1, 1: 1, 0: 1}, p, ZZ)
+
+    assert gf_sqf_p(f, p, ZZ) is True
+
+    g = (1, [([1, 22730, 68144], 1),
+             ([1, 81553, 77449, 86810, 4724], 1),
+             ([1, 86276, 56779, 14859, 31575], 1),
+             ([1, 15347, 95022, 84569, 94508, 92335], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    g = (1, [[1, 22730, 68144],
+             [1, 81553, 77449, 86810, 4724],
+             [1, 86276, 56779, 14859, 31575],
+             [1, 15347, 95022, 84569, 94508, 92335]])
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    # Shoup polynomials: f = a_0 x**n + a_1 x**(n-1) + ... + a_n
+    # (mod p > 2**(n-2) * pi), where a_n = a_{n-1}**2 + 1, a_0 = 1
+
+    p = ZZ(nextprime(int((2**4 * pi).evalf())))
+    f = ZZ.map([1, 2, 5, 26, 41, 39, 38])
+
+    assert gf_sqf_p(f, p, ZZ) is True
+
+    g = (1, [([1, 44, 26], 1),
+             ([1, 11, 25, 18, 30], 1)])
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor(f, p, ZZ) == g
+
+    g = (1, [[1, 44, 26],
+             [1, 11, 25, 18, 30]])
+
+    config.setup('GF_FACTOR_METHOD', 'zassenhaus')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'shoup')
+    assert gf_factor_sqf(f, p, ZZ) == g
+
+    config.setup('GF_FACTOR_METHOD', 'other')
+    raises(KeyError, lambda: gf_factor([1, 1], 11, ZZ))
+    config.setup('GF_FACTOR_METHOD')
+
+
+def test_gf_csolve():
+    assert gf_value([1, 7, 2, 4], 11) == 2204
+
+    assert linear_congruence(4, 3, 5) == [2]
+    assert linear_congruence(0, 3, 5) == []
+    assert linear_congruence(6, 1, 4) == []
+    assert linear_congruence(0, 5, 5) == [0, 1, 2, 3, 4]
+    assert linear_congruence(3, 12, 15) == [4, 9, 14]
+    assert linear_congruence(6, 0, 18) == [0, 3, 6, 9, 12, 15]
+    # _csolve_prime_las_vegas
+    assert _csolve_prime_las_vegas([2, 3, 1], 5) == [2, 4]
+    assert _csolve_prime_las_vegas([2, 0, 1], 5) == []
+    from sympy.ntheory import primerange
+    for p in primerange(2, 100):
+        # f = x**(p-1) - 1
+        f = gf_sub_ground(gf_pow([1, 0], p - 1, p, ZZ), 1, p, ZZ)
+        assert _csolve_prime_las_vegas(f, p) == list(range(1, p))
+    # with power = 1
+    assert csolve_prime([1, 3, 2, 17], 7) == [3]
+    assert csolve_prime([1, 3, 1, 5], 5) == [0, 1]
+    assert csolve_prime([3, 6, 9, 3], 3) == [0, 1, 2]
+    # with power > 1
+    assert csolve_prime(
+        [1, 1, 223], 3, 4) == [4, 13, 22, 31, 40, 49, 58, 67, 76]
+    assert csolve_prime([3, 5, 2, 25], 5, 3) == [16, 50, 99]
+    assert csolve_prime([3, 2, 2, 49], 7, 3) == [147, 190, 234]
+
+    assert gf_csolve([1, 1, 7], 189) == [13, 49, 76, 112, 139, 175]
+    assert gf_csolve([1, 3, 4, 1, 30], 60) == [10, 30]
+    assert gf_csolve([1, 1, 7], 15) == []

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_groebnertools.py

@@ -0,0 +1,533 @@
+"""Tests for Groebner bases. """
+
+from sympy.polys.groebnertools import (
+    groebner, sig, sig_key,
+    lbp, lbp_key, critical_pair,
+    cp_key, is_rewritable_or_comparable,
+    Sign, Polyn, Num, s_poly, f5_reduce,
+    groebner_lcm, groebner_gcd, is_groebner,
+    is_reduced
+)
+
+from sympy.polys.fglmtools import _representing_matrices
+from sympy.polys.orderings import lex, grlex
+
+from sympy.polys.rings import ring, xring
+from sympy.polys.domains import ZZ, QQ
+
+from sympy.testing.pytest import slow
+from sympy.polys import polyconfig as config
+
+def _do_test_groebner():
+    R, x,y = ring("x,y", QQ, lex)
+    f = x**2 + 2*x*y**2
+    g = x*y + 2*y**3 - 1
+
+    assert groebner([f, g], R) == [x, y**3 - QQ(1,2)]
+
+    R, y,x = ring("y,x", QQ, lex)
+    f = 2*x**2*y + y**2
+    g = 2*x**3 + x*y - 1
+
+    assert groebner([f, g], R) == [y, x**3 - QQ(1,2)]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = x - z**2
+    g = y - z**3
+
+    assert groebner([f, g], R) == [f, g]
+
+    R, x,y = ring("x,y", QQ, grlex)
+    f = x**3 - 2*x*y
+    g = x**2*y + x - 2*y**2
+
+    assert groebner([f, g], R) == [x**2, x*y, -QQ(1,2)*x + y**2]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = -x**2 + y
+    g = -x**3 + z
+
+    assert groebner([f, g], R) == [x**2 - y, x*y - z, x*z - y**2, y**3 - z**2]
+
+    R, x,y,z = ring("x,y,z", QQ, grlex)
+    f = -x**2 + y
+    g = -x**3 + z
+
+    assert groebner([f, g], R) == [y**3 - z**2, x**2 - y, x*y - z, x*z - y**2]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = -x**2 + z
+    g = -x**3 + y
+
+    assert groebner([f, g], R) == [x**2 - z, x*y - z**2, x*z - y, y**2 - z**3]
+
+    R, x,y,z = ring("x,y,z", QQ, grlex)
+    f = -x**2 + z
+    g = -x**3 + y
+
+    assert groebner([f, g], R) == [-y**2 + z**3, x**2 - z, x*y - z**2, x*z - y]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = x - y**2
+    g = -y**3 + z
+
+    assert groebner([f, g], R) == [x - y**2, y**3 - z]
+
+    R, x,y,z = ring("x,y,z", QQ, grlex)
+    f = x - y**2
+    g = -y**3 + z
+
+    assert groebner([f, g], R) == [x**2 - y*z, x*y - z, -x + y**2]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = x - z**2
+    g = y - z**3
+
+    assert groebner([f, g], R) == [x - z**2, y - z**3]
+
+    R, x,y,z = ring("x,y,z", QQ, grlex)
+    f = x - z**2
+    g = y - z**3
+
+    assert groebner([f, g], R) == [x**2 - y*z, x*z - y, -x + z**2]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = -y**2 + z
+    g = x - y**3
+
+    assert groebner([f, g], R) == [x - y*z, y**2 - z]
+
+    R, x,y,z = ring("x,y,z", QQ, grlex)
+    f = -y**2 + z
+    g = x - y**3
+
+    assert groebner([f, g], R) == [-x**2 + z**3, x*y - z**2, y**2 - z, -x + y*z]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = y - z**2
+    g = x - z**3
+
+    assert groebner([f, g], R) == [x - z**3, y - z**2]
+
+    R, x,y,z = ring("x,y,z", QQ, grlex)
+    f = y - z**2
+    g = x - z**3
+
+    assert groebner([f, g], R) == [-x**2 + y**3, x*z - y**2, -x + y*z, -y + z**2]
+
+    R, x,y,z = ring("x,y,z", QQ, lex)
+    f = 4*x**2*y**2 + 4*x*y + 1
+    g = x**2 + y**2 - 1
+
+    assert groebner([f, g], R) == [
+        x - 4*y**7 + 8*y**5 - 7*y**3 + 3*y,
+        y**8 - 2*y**6 + QQ(3,2)*y**4 - QQ(1,2)*y**2 + QQ(1,16),
+    ]
+
+def test_groebner_buchberger():
+    with config.using(groebner='buchberger'):
+        _do_test_groebner()
+
+def test_groebner_f5b():
+    with config.using(groebner='f5b'):
+        _do_test_groebner()
+
+def _do_test_benchmark_minpoly():
+    R, x,y,z = ring("x,y,z", QQ, lex)
+
+    F = [x**3 + x + 1, y**2 + y + 1, (x + y) * z - (x**2 + y)]
+    G = [x + QQ(155,2067)*z**5 - QQ(355,689)*z**4 + QQ(6062,2067)*z**3 - QQ(3687,689)*z**2 + QQ(6878,2067)*z - QQ(25,53),
+         y + QQ(4,53)*z**5 - QQ(91,159)*z**4 + QQ(523,159)*z**3 - QQ(387,53)*z**2 + QQ(1043,159)*z - QQ(308,159),
+         z**6 - 7*z**5 + 41*z**4 - 82*z**3 + 89*z**2 - 46*z + 13]
+
+    assert groebner(F, R) == G
+
+def test_benchmark_minpoly_buchberger():
+    with config.using(groebner='buchberger'):
+        _do_test_benchmark_minpoly()
+
+def test_benchmark_minpoly_f5b():
+    with config.using(groebner='f5b'):
+        _do_test_benchmark_minpoly()
+
+
+def test_benchmark_coloring():
+    V = range(1, 12 + 1)
+    E = [(1, 2), (2, 3), (1, 4), (1, 6), (1, 12), (2, 5), (2, 7), (3, 8), (3, 10),
+         (4, 11), (4, 9), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11),
+         (11, 12), (5, 12), (5, 9), (6, 10), (7, 11), (8, 12), (3, 4)]
+
+    R, V = xring([ "x%d" % v for v in V ], QQ, lex)
+    E = [(V[i - 1], V[j - 1]) for i, j in E]
+
+    x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 = V
+
+    I3 = [x**3 - 1 for x in V]
+    Ig = [x**2 + x*y + y**2 for x, y in E]
+
+    I = I3 + Ig
+
+    assert groebner(I[:-1], R) == [
+        x1 + x11 + x12,
+        x2 - x11,
+        x3 - x12,
+        x4 - x12,
+        x5 + x11 + x12,
+        x6 - x11,
+        x7 - x12,
+        x8 + x11 + x12,
+        x9 - x11,
+        x10 + x11 + x12,
+        x11**2 + x11*x12 + x12**2,
+        x12**3 - 1,
+    ]
+
+    assert groebner(I, R) == [1]
+
+
+def _do_test_benchmark_katsura_3():
+    R, x0,x1,x2 = ring("x:3", ZZ, lex)
+    I = [x0 + 2*x1 + 2*x2 - 1,
+         x0**2 + 2*x1**2 + 2*x2**2 - x0,
+         2*x0*x1 + 2*x1*x2 - x1]
+
+    assert groebner(I, R) == [
+        -7 + 7*x0 + 8*x2 + 158*x2**2 - 420*x2**3,
+        7*x1 + 3*x2 - 79*x2**2 + 210*x2**3,
+        x2 + x2**2 - 40*x2**3 + 84*x2**4,
+    ]
+
+    R, x0,x1,x2 = ring("x:3", ZZ, grlex)
+    I = [ i.set_ring(R) for i in I ]
+
+    assert groebner(I, R) == [
+        7*x1 + 3*x2 - 79*x2**2 + 210*x2**3,
+        -x1 + x2 - 3*x2**2 + 5*x1**2,
+        -x1 - 4*x2 + 10*x1*x2 + 12*x2**2,
+        -1 + x0 + 2*x1 + 2*x2,
+    ]
+
+def test_benchmark_katsura3_buchberger():
+    with config.using(groebner='buchberger'):
+        _do_test_benchmark_katsura_3()
+
+def test_benchmark_katsura3_f5b():
+    with config.using(groebner='f5b'):
+        _do_test_benchmark_katsura_3()
+
+def _do_test_benchmark_katsura_4():
+    R, x0,x1,x2,x3 = ring("x:4", ZZ, lex)
+    I = [x0 + 2*x1 + 2*x2 + 2*x3 - 1,
+         x0**2 + 2*x1**2 + 2*x2**2 + 2*x3**2 - x0,
+         2*x0*x1 + 2*x1*x2 + 2*x2*x3 - x1,
+         x1**2 + 2*x0*x2 + 2*x1*x3 - x2]
+
+    assert groebner(I, R) == [
+        5913075*x0 - 159690237696*x3**7 + 31246269696*x3**6 + 27439610544*x3**5 - 6475723368*x3**4 - 838935856*x3**3 + 275119624*x3**2 + 4884038*x3 - 5913075,
+        1971025*x1 - 97197721632*x3**7 + 73975630752*x3**6 - 12121915032*x3**5 - 2760941496*x3**4 + 814792828*x3**3 - 1678512*x3**2 - 9158924*x3,
+        5913075*x2 + 371438283744*x3**7 - 237550027104*x3**6 + 22645939824*x3**5 + 11520686172*x3**4 - 2024910556*x3**3 - 132524276*x3**2 + 30947828*x3,
+        128304*x3**8 - 93312*x3**7 + 15552*x3**6 + 3144*x3**5 -
+        1120*x3**4 + 36*x3**3 + 15*x3**2 - x3,
+    ]
+
+    R, x0,x1,x2,x3 = ring("x:4", ZZ, grlex)
+    I = [ i.set_ring(R) for i in I ]
+
+    assert groebner(I, R) == [
+        393*x1 - 4662*x2**2 + 4462*x2*x3 - 59*x2 + 224532*x3**4 - 91224*x3**3 - 678*x3**2 + 2046*x3,
+        -x1 + 196*x2**3 - 21*x2**2 + 60*x2*x3 - 18*x2 - 168*x3**3 + 83*x3**2 - 9*x3,
+        -6*x1 + 1134*x2**2*x3 - 189*x2**2 - 466*x2*x3 + 32*x2 - 630*x3**3 + 57*x3**2 + 51*x3,
+        33*x1 + 63*x2**2 + 2268*x2*x3**2 - 188*x2*x3 + 34*x2 + 2520*x3**3 - 849*x3**2 + 3*x3,
+        7*x1**2 - x1 - 7*x2**2 - 24*x2*x3 + 3*x2 - 15*x3**2 + 5*x3,
+        14*x1*x2 - x1 + 14*x2**2 + 18*x2*x3 - 4*x2 + 6*x3**2 - 2*x3,
+        14*x1*x3 - x1 + 7*x2**2 + 32*x2*x3 - 4*x2 + 27*x3**2 - 9*x3,
+        x0 + 2*x1 + 2*x2 + 2*x3 - 1,
+    ]
+
+def test_benchmark_kastura_4_buchberger():
+    with config.using(groebner='buchberger'):
+        _do_test_benchmark_katsura_4()
+
+def test_benchmark_kastura_4_f5b():
+    with config.using(groebner='f5b'):
+        _do_test_benchmark_katsura_4()
+
+def _do_test_benchmark_czichowski():
+    R, x,t = ring("x,t", ZZ, lex)
+    I = [9*x**8 + 36*x**7 - 32*x**6 - 252*x**5 - 78*x**4 + 468*x**3 + 288*x**2 - 108*x + 9,
+         (-72 - 72*t)*x**7 + (-256 - 252*t)*x**6 + (192 + 192*t)*x**5 + (1280 + 1260*t)*x**4 + (312 + 312*t)*x**3 + (-404*t)*x**2 + (-576 - 576*t)*x + 96 + 108*t]
+
+    assert groebner(I, R) == [
+        3725588592068034903797967297424801242396746870413359539263038139343329273586196480000*x -
+        160420835591776763325581422211936558925462474417709511019228211783493866564923546661604487873*t**7 -
+        1406108495478033395547109582678806497509499966197028487131115097902188374051595011248311352864*t**6 -
+        5241326875850889518164640374668786338033653548841427557880599579174438246266263602956254030352*t**5 -
+        10758917262823299139373269714910672770004760114329943852726887632013485035262879510837043892416*t**4 -
+        13119383576444715672578819534846747735372132018341964647712009275306635391456880068261130581248*t**3 -
+        9491412317016197146080450036267011389660653495578680036574753839055748080962214787557853941760*t**2 -
+        3767520915562795326943800040277726397326609797172964377014046018280260848046603967211258368000*t -
+        632314652371226552085897259159210286886724229880266931574701654721512325555116066073245696000,
+        610733380717522355121*t**8 +
+        6243748742141230639968*t**7 +
+        27761407182086143225024*t**6 +
+        70066148869420956398592*t**5 +
+        109701225644313784229376*t**4 +
+        109009005495588442152960*t**3 +
+        67072101084384786432000*t**2 +
+        23339979742629593088000*t +
+        3513592776846090240000,
+    ]
+
+    R, x,t = ring("x,t", ZZ, grlex)
+    I = [ i.set_ring(R) for i in I ]
+
+    assert groebner(I, R) == [
+        16996618586000601590732959134095643086442*t**3*x -
+        32936701459297092865176560282688198064839*t**3 +
+        78592411049800639484139414821529525782364*t**2*x -
+        120753953358671750165454009478961405619916*t**2 +
+        120988399875140799712152158915653654637280*t*x -
+        144576390266626470824138354942076045758736*t +
+        60017634054270480831259316163620768960*x**2 +
+        61976058033571109604821862786675242894400*x -
+        56266268491293858791834120380427754600960,
+        576689018321912327136790519059646508441672750656050290242749*t**4 +
+        2326673103677477425562248201573604572527893938459296513327336*t**3 +
+        110743790416688497407826310048520299245819959064297990236000*t**2*x +
+        3308669114229100853338245486174247752683277925010505284338016*t**2 +
+        323150205645687941261103426627818874426097912639158572428800*t*x +
+        1914335199925152083917206349978534224695445819017286960055680*t +
+        861662882561803377986838989464278045397192862768588480000*x**2 +
+        235296483281783440197069672204341465480107019878814196672000*x +
+        361850798943225141738895123621685122544503614946436727532800,
+       -117584925286448670474763406733005510014188341867*t**3 +
+        68566565876066068463853874568722190223721653044*t**2*x -
+        435970731348366266878180788833437896139920683940*t**2 +
+        196297602447033751918195568051376792491869233408*t*x -
+        525011527660010557871349062870980202067479780112*t +
+        517905853447200553360289634770487684447317120*x**3 +
+        569119014870778921949288951688799397569321920*x**2 +
+        138877356748142786670127389526667463202210102080*x -
+        205109210539096046121625447192779783475018619520,
+       -3725142681462373002731339445216700112264527*t**3 +
+        583711207282060457652784180668273817487940*t**2*x -
+        12381382393074485225164741437227437062814908*t**2 +
+        151081054097783125250959636747516827435040*t*x**2 +
+        1814103857455163948531448580501928933873280*t*x -
+        13353115629395094645843682074271212731433648*t +
+        236415091385250007660606958022544983766080*x**2 +
+        1390443278862804663728298060085399578417600*x -
+        4716885828494075789338754454248931750698880,
+    ]
+
+# NOTE: This is very slow (> 2 minutes on 3.4 GHz) without GMPY
+@slow
+def test_benchmark_czichowski_buchberger():
+    with config.using(groebner='buchberger'):
+        _do_test_benchmark_czichowski()
+
+def test_benchmark_czichowski_f5b():
+    with config.using(groebner='f5b'):
+        _do_test_benchmark_czichowski()
+
+def _do_test_benchmark_cyclic_4():
+    R, a,b,c,d = ring("a,b,c,d", ZZ, lex)
+
+    I = [a + b + c + d,
+         a*b + a*d + b*c + b*d,
+         a*b*c + a*b*d + a*c*d + b*c*d,
+         a*b*c*d - 1]
+
+    assert groebner(I, R) == [
+        4*a + 3*d**9 - 4*d**5 - 3*d,
+        4*b + 4*c - 3*d**9 + 4*d**5 + 7*d,
+        4*c**2 + 3*d**10 - 4*d**6 - 3*d**2,
+        4*c*d**4 + 4*c - d**9 + 4*d**5 + 5*d, d**12 - d**8 - d**4 + 1
+    ]
+
+    R, a,b,c,d = ring("a,b,c,d", ZZ, grlex)
+    I = [ i.set_ring(R) for i in I ]
+
+    assert groebner(I, R) == [
+        3*b*c - c**2 + d**6 - 3*d**2,
+        -b + 3*c**2*d**3 - c - d**5 - 4*d,
+        -b + 3*c*d**4 + 2*c + 2*d**5 + 2*d,
+        c**4 + 2*c**2*d**2 - d**4 - 2,
+        c**3*d + c*d**3 + d**4 + 1,
+        b*c**2 - c**3 - c**2*d - 2*c*d**2 - d**3,
+        b**2 - c**2, b*d + c**2 + c*d + d**2,
+        a + b + c + d
+    ]
+
+def test_benchmark_cyclic_4_buchberger():
+    with config.using(groebner='buchberger'):
+        _do_test_benchmark_cyclic_4()
+
+def test_benchmark_cyclic_4_f5b():
+    with config.using(groebner='f5b'):
+        _do_test_benchmark_cyclic_4()
+
+def test_sig_key():
+    s1 = sig((0,) * 3, 2)
+    s2 = sig((1,) * 3, 4)
+    s3 = sig((2,) * 3, 2)
+
+    assert sig_key(s1, lex) > sig_key(s2, lex)
+    assert sig_key(s2, lex) < sig_key(s3, lex)
+
+
+def test_lbp_key():
+    R, x,y,z,t = ring("x,y,z,t", ZZ, lex)
+
+    p1 = lbp(sig((0,) * 4, 3), R.zero, 12)
+    p2 = lbp(sig((0,) * 4, 4), R.zero, 13)
+    p3 = lbp(sig((0,) * 4, 4), R.zero, 12)
+
+    assert lbp_key(p1) > lbp_key(p2)
+    assert lbp_key(p2) < lbp_key(p3)
+
+
+def test_critical_pair():
+    # from cyclic4 with grlex
+    R, x,y,z,t = ring("x,y,z,t", QQ, grlex)
+
+    p1 = (((0, 0, 0, 0), 4), y*z*t**2 + z**2*t**2 - t**4 - 1, 4)
+    q1 = (((0, 0, 0, 0), 2), -y**2 - y*t - z*t - t**2, 2)
+
+    p2 = (((0, 0, 0, 2), 3), z**3*t**2 + z**2*t**3 - z - t, 5)
+    q2 = (((0, 0, 2, 2), 2), y*z + z*t**5 + z*t + t**6, 13)
+
+    assert critical_pair(p1, q1, R) == (
+        ((0, 0, 1, 2), 2), ((0, 0, 1, 2), QQ(-1, 1)), (((0, 0, 0, 0), 2), -y**2 - y*t - z*t - t**2, 2),
+        ((0, 1, 0, 0), 4), ((0, 1, 0, 0), QQ(1, 1)), (((0, 0, 0, 0), 4), y*z*t**2 + z**2*t**2 - t**4 - 1, 4)
+    )
+    assert critical_pair(p2, q2, R) == (
+        ((0, 0, 4, 2), 2), ((0, 0, 2, 0), QQ(1, 1)), (((0, 0, 2, 2), 2), y*z + z*t**5 + z*t + t**6, 13),
+        ((0, 0, 0, 5), 3), ((0, 0, 0, 3), QQ(1, 1)), (((0, 0, 0, 2), 3), z**3*t**2 + z**2*t**3 - z - t, 5)
+    )
+
+def test_cp_key():
+    # from cyclic4 with grlex
+    R, x,y,z,t = ring("x,y,z,t", QQ, grlex)
+
+    p1 = (((0, 0, 0, 0), 4), y*z*t**2 + z**2*t**2 - t**4 - 1, 4)
+    q1 = (((0, 0, 0, 0), 2), -y**2 - y*t - z*t - t**2, 2)
+
+    p2 = (((0, 0, 0, 2), 3), z**3*t**2 + z**2*t**3 - z - t, 5)
+    q2 = (((0, 0, 2, 2), 2), y*z + z*t**5 + z*t + t**6, 13)
+
+    cp1 = critical_pair(p1, q1, R)
+    cp2 = critical_pair(p2, q2, R)
+
+    assert cp_key(cp1, R) < cp_key(cp2, R)
+
+    cp1 = critical_pair(p1, p2, R)
+    cp2 = critical_pair(q1, q2, R)
+
+    assert cp_key(cp1, R) < cp_key(cp2, R)
+
+
+def test_is_rewritable_or_comparable():
+    # from katsura4 with grlex
+    R, x,y,z,t = ring("x,y,z,t", QQ, grlex)
+
+    p = lbp(sig((0, 0, 2, 1), 2), R.zero, 2)
+    B = [lbp(sig((0, 0, 0, 1), 2), QQ(2,45)*y**2 + QQ(1,5)*y*z + QQ(5,63)*y*t + z**2*t + QQ(4,45)*z**2 + QQ(76,35)*z*t**2 - QQ(32,105)*z*t + QQ(13,7)*t**3 - QQ(13,21)*t**2, 6)]
+
+    # rewritable:
+    assert is_rewritable_or_comparable(Sign(p), Num(p), B) is True
+
+    p = lbp(sig((0, 1, 1, 0), 2), R.zero, 7)
+    B = [lbp(sig((0, 0, 0, 0), 3), QQ(10,3)*y*z + QQ(4,3)*y*t - QQ(1,3)*y + 4*z**2 + QQ(22,3)*z*t - QQ(4,3)*z + 4*t**2 - QQ(4,3)*t, 3)]
+
+    # comparable:
+    assert is_rewritable_or_comparable(Sign(p), Num(p), B) is True
+
+
+def test_f5_reduce():
+    # katsura3 with lex
+    R, x,y,z = ring("x,y,z", QQ, lex)
+
+    F = [(((0, 0, 0), 1), x + 2*y + 2*z - 1, 1),
+         (((0, 0, 0), 2), 6*y**2 + 8*y*z - 2*y + 6*z**2 - 2*z, 2),
+         (((0, 0, 0), 3), QQ(10,3)*y*z - QQ(1,3)*y + 4*z**2 - QQ(4,3)*z, 3),
+         (((0, 0, 1), 2), y + 30*z**3 - QQ(79,7)*z**2 + QQ(3,7)*z, 4),
+         (((0, 0, 2), 2), z**4 - QQ(10,21)*z**3 + QQ(1,84)*z**2 + QQ(1,84)*z, 5)]
+
+    cp = critical_pair(F[0], F[1], R)
+    s = s_poly(cp)
+
+    assert f5_reduce(s, F) == (((0, 2, 0), 1), R.zero, 1)
+
+    s = lbp(sig(Sign(s)[0], 100), Polyn(s), Num(s))
+    assert f5_reduce(s, F) == s
+
+
+def test_representing_matrices():
+    R, x,y = ring("x,y", QQ, grlex)
+
+    basis = [(0, 0), (0, 1), (1, 0), (1, 1)]
+    F = [x**2 - x - 3*y + 1, -2*x + y**2 + y - 1]
+
+    assert _representing_matrices(basis, F, R) == [
+        [[QQ(0, 1), QQ(0, 1),-QQ(1, 1), QQ(3, 1)],
+         [QQ(0, 1), QQ(0, 1), QQ(3, 1),-QQ(4, 1)],
+         [QQ(1, 1), QQ(0, 1), QQ(1, 1), QQ(6, 1)],
+         [QQ(0, 1), QQ(1, 1), QQ(0, 1), QQ(1, 1)]],
+        [[QQ(0, 1), QQ(1, 1), QQ(0, 1),-QQ(2, 1)],
+         [QQ(1, 1),-QQ(1, 1), QQ(0, 1), QQ(6, 1)],
+         [QQ(0, 1), QQ(2, 1), QQ(0, 1), QQ(3, 1)],
+         [QQ(0, 1), QQ(0, 1), QQ(1, 1),-QQ(1, 1)]]]
+
+def test_groebner_lcm():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert groebner_lcm(x**2 - y**2, x - y) == x**2 - y**2
+    assert groebner_lcm(2*x**2 - 2*y**2, 2*x - 2*y) == 2*x**2 - 2*y**2
+
+    R, x,y,z = ring("x,y,z", QQ)
+
+    assert groebner_lcm(x**2 - y**2, x - y) == x**2 - y**2
+    assert groebner_lcm(2*x**2 - 2*y**2, 2*x - 2*y) == 2*x**2 - 2*y**2
+
+    R, x,y = ring("x,y", ZZ)
+
+    assert groebner_lcm(x**2*y, x*y**2) == x**2*y**2
+
+    f = 2*x*y**5 - 3*x*y**4 - 2*x*y**3 + 3*x*y**2
+    g = y**5 - 2*y**3 + y
+    h = 2*x*y**7 - 3*x*y**6 - 4*x*y**5 + 6*x*y**4 + 2*x*y**3 - 3*x*y**2
+
+    assert groebner_lcm(f, g) == h
+
+    f = x**3 - 3*x**2*y - 9*x*y**2 - 5*y**3
+    g = x**4 + 6*x**3*y + 12*x**2*y**2 + 10*x*y**3 + 3*y**4
+    h = x**5 + x**4*y - 18*x**3*y**2 - 50*x**2*y**3 - 47*x*y**4 - 15*y**5
+
+    assert groebner_lcm(f, g) == h
+
+def test_groebner_gcd():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert groebner_gcd(x**2 - y**2, x - y) == x - y
+    assert groebner_gcd(2*x**2 - 2*y**2, 2*x - 2*y) == 2*x - 2*y
+
+    R, x,y,z = ring("x,y,z", QQ)
+
+    assert groebner_gcd(x**2 - y**2, x - y) == x - y
+    assert groebner_gcd(2*x**2 - 2*y**2, 2*x - 2*y) == x - y
+
+def test_is_groebner():
+    R, x,y = ring("x,y", QQ, grlex)
+    valid_groebner = [x**2, x*y, -QQ(1,2)*x + y**2]
+    invalid_groebner = [x**3, x*y, -QQ(1,2)*x + y**2]
+    assert is_groebner(valid_groebner, R) is True
+    assert is_groebner(invalid_groebner, R) is False
+
+def test_is_reduced():
+    R, x, y = ring("x,y", QQ, lex)
+    f = x**2 + 2*x*y**2
+    g = x*y + 2*y**3 - 1
+    assert is_reduced([f, g], R) ==  False
+    G = groebner([f, g], R)
+    assert is_reduced(G, R) == True

pllava/lib/python3.10/site-packages/sympy/polys/tests/test_heuristicgcd.py

@@ -0,0 +1,152 @@
+from sympy.polys.rings import ring
+from sympy.polys.domains import ZZ
+from sympy.polys.heuristicgcd import heugcd
+
+
+def test_heugcd_univariate_integers():
+    R, x = ring("x", ZZ)
+
+    f = x**4 + 8*x**3 + 21*x**2 + 22*x + 8
+    g = x**3 + 6*x**2 + 11*x + 6
+
+    h = x**2 + 3*x + 2
+
+    cff = x**2 + 5*x + 4
+    cfg = x + 3
+
+    assert heugcd(f, g) == (h, cff, cfg)
+
+    f = x**4 - 4
+    g = x**4 + 4*x**2 + 4
+
+    h = x**2 + 2
+
+    cff = x**2 - 2
+    cfg = x**2 + 2
+
+    assert heugcd(f, g) == (h, cff, cfg)
+
+    f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
+    g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
+
+    h = 1
+
+    cff = f
+    cfg = g
+
+    assert heugcd(f, g) == (h, cff, cfg)
+
+    f = - 352518131239247345597970242177235495263669787845475025293906825864749649589178600387510272*x**49 \
+        + 46818041807522713962450042363465092040687472354933295397472942006618953623327997952*x**42 \
+        + 378182690892293941192071663536490788434899030680411695933646320291525827756032*x**35 \
+        + 112806468807371824947796775491032386836656074179286744191026149539708928*x**28 \
+        - 12278371209708240950316872681744825481125965781519138077173235712*x**21 \
+        + 289127344604779611146960547954288113529690984687482920704*x**14 \
+        + 19007977035740498977629742919480623972236450681*x**7 \
+        + 311973482284542371301330321821976049
+
+    g =   365431878023781158602430064717380211405897160759702125019136*x**21 \
+        + 197599133478719444145775798221171663643171734081650688*x**14 \
+        - 9504116979659010018253915765478924103928886144*x**7 \
+        - 311973482284542371301330321821976049
+
+    # TODO: assert heugcd(f, f.diff(x))[0] == g
+
+    f = 1317378933230047068160*x + 2945748836994210856960
+    g = 120352542776360960*x + 269116466014453760
+
+    h = 120352542776360960*x + 269116466014453760
+    cff = 10946
+    cfg = 1
+
+    assert heugcd(f, g) == (h, cff, cfg)
+
+def test_heugcd_multivariate_integers():
+    R, x, y = ring("x,y", ZZ)
+
+    f, g = 2*x**2 + 4*x + 2, x + 1
+    assert heugcd(f, g) == (x + 1, 2*x + 2, 1)
+
+    f, g = x + 1, 2*x**2 + 4*x + 2
+    assert heugcd(f, g) == (x + 1, 1, 2*x + 2)
+
+    R, x, y, z, u = ring("x,y,z,u", ZZ)
+
+    f, g = u**2 + 2*u + 1, 2*u + 2
+    assert heugcd(f, g) == (u + 1, u + 1, 2)
+
+    f, g = z**2*u**2 + 2*z**2*u + z**2 + z*u + z, u**2 + 2*u + 1
+    h, cff, cfg = u + 1, z**2*u + z**2 + z, u + 1
+
+    assert heugcd(f, g) == (h, cff, cfg)
+    assert heugcd(g, f) == (h, cfg, cff)
+
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f, g, h = R.fateman_poly_F_1()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    R, x, y, z, u, v = ring("x,y,z,u,v", ZZ)
+
+    f, g, h = R.fateman_poly_F_1()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    R, x, y, z, u, v, a, b = ring("x,y,z,u,v,a,b", ZZ)
+
+    f, g, h = R.fateman_poly_F_1()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    R, x, y, z, u, v, a, b, c, d = ring("x,y,z,u,v,a,b,c,d", ZZ)
+
+    f, g, h = R.fateman_poly_F_1()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f, g, h = R.fateman_poly_F_2()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    f, g, h = R.fateman_poly_F_3()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    R, x, y, z, t = ring("x,y,z,t", ZZ)
+
+    f, g, h = R.fateman_poly_F_3()
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+
+def test_issue_10996():
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f = 12*x**6*y**7*z**3 - 3*x**4*y**9*z**3 + 12*x**3*y**5*z**4
+    g = -48*x**7*y**8*z**3 + 12*x**5*y**10*z**3 - 48*x**5*y**7*z**2 + \
+    36*x**4*y**7*z - 48*x**4*y**6*z**4 + 12*x**3*y**9*z**2 - 48*x**3*y**4 \
+    - 9*x**2*y**9*z - 48*x**2*y**5*z**3 + 12*x*y**6 + 36*x*y**5*z**2 - 48*y**2*z
+
+    H, cff, cfg = heugcd(f, g)
+
+    assert H == 12*x**3*y**4 - 3*x*y**6 + 12*y**2*z
+    assert H*cff == f and H*cfg == g
+
+
+def test_issue_25793():
+    R, x = ring("x", ZZ)
+    f = x - 4851  # failure starts for values more than 4850
+    g = f*(2*x + 1)
+    H, cff, cfg = R.dup_zz_heu_gcd(f, g)
+    assert H == f
+    # needs a test for dmp, too, that fails in master before this change