Add files using upload-large-folder tool

.gitattributes

@@ -1617,3 +1617,4 @@ evalkit_internvl/lib/python3.10/site-packages/sympy/matrices/__pycache__/matrixb
 evalkit_tf437/lib/python3.10/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
 evalkit_internvl/lib/python3.10/site-packages/sympy/core/__pycache__/function.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_internvl/lib/python3.10/site-packages/sympy/core/__pycache__/numbers.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/sympy/stats/__pycache__/crv_types.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

evalkit_internvl/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)

evalkit_internvl/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

evalkit_internvl/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)

evalkit_internvl/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

evalkit_internvl/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

evalkit_internvl/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)

evalkit_internvl/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

evalkit_internvl/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

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_orderings.py

@@ -0,0 +1,124 @@
+"""Tests of monomial orderings. """
+
+from sympy.polys.orderings import (
+    monomial_key, lex, grlex, grevlex, ilex, igrlex,
+    LexOrder, InverseOrder, ProductOrder, build_product_order,
+)
+
+from sympy.abc import x, y, z, t
+from sympy.core import S
+from sympy.testing.pytest import raises
+
+def test_lex_order():
+    assert lex((1, 2, 3)) == (1, 2, 3)
+    assert str(lex) == 'lex'
+
+    assert lex((1, 2, 3)) == lex((1, 2, 3))
+
+    assert lex((2, 2, 3)) > lex((1, 2, 3))
+    assert lex((1, 3, 3)) > lex((1, 2, 3))
+    assert lex((1, 2, 4)) > lex((1, 2, 3))
+
+    assert lex((0, 2, 3)) < lex((1, 2, 3))
+    assert lex((1, 1, 3)) < lex((1, 2, 3))
+    assert lex((1, 2, 2)) < lex((1, 2, 3))
+
+    assert lex.is_global is True
+    assert lex == LexOrder()
+    assert lex != grlex
+
+def test_grlex_order():
+    assert grlex((1, 2, 3)) == (6, (1, 2, 3))
+    assert str(grlex) == 'grlex'
+
+    assert grlex((1, 2, 3)) == grlex((1, 2, 3))
+
+    assert grlex((2, 2, 3)) > grlex((1, 2, 3))
+    assert grlex((1, 3, 3)) > grlex((1, 2, 3))
+    assert grlex((1, 2, 4)) > grlex((1, 2, 3))
+
+    assert grlex((0, 2, 3)) < grlex((1, 2, 3))
+    assert grlex((1, 1, 3)) < grlex((1, 2, 3))
+    assert grlex((1, 2, 2)) < grlex((1, 2, 3))
+
+    assert grlex((2, 2, 3)) > grlex((1, 2, 4))
+    assert grlex((1, 3, 3)) > grlex((1, 2, 4))
+
+    assert grlex((0, 2, 3)) < grlex((1, 2, 2))
+    assert grlex((1, 1, 3)) < grlex((1, 2, 2))
+
+    assert grlex((0, 1, 1)) > grlex((0, 0, 2))
+    assert grlex((0, 3, 1)) < grlex((2, 2, 1))
+
+    assert grlex.is_global is True
+
+def test_grevlex_order():
+    assert grevlex((1, 2, 3)) == (6, (-3, -2, -1))
+    assert str(grevlex) == 'grevlex'
+
+    assert grevlex((1, 2, 3)) == grevlex((1, 2, 3))
+
+    assert grevlex((2, 2, 3)) > grevlex((1, 2, 3))
+    assert grevlex((1, 3, 3)) > grevlex((1, 2, 3))
+    assert grevlex((1, 2, 4)) > grevlex((1, 2, 3))
+
+    assert grevlex((0, 2, 3)) < grevlex((1, 2, 3))
+    assert grevlex((1, 1, 3)) < grevlex((1, 2, 3))
+    assert grevlex((1, 2, 2)) < grevlex((1, 2, 3))
+
+    assert grevlex((2, 2, 3)) > grevlex((1, 2, 4))
+    assert grevlex((1, 3, 3)) > grevlex((1, 2, 4))
+
+    assert grevlex((0, 2, 3)) < grevlex((1, 2, 2))
+    assert grevlex((1, 1, 3)) < grevlex((1, 2, 2))
+
+    assert grevlex((0, 1, 1)) > grevlex((0, 0, 2))
+    assert grevlex((0, 3, 1)) < grevlex((2, 2, 1))
+
+    assert grevlex.is_global is True
+
+def test_InverseOrder():
+    ilex = InverseOrder(lex)
+    igrlex = InverseOrder(grlex)
+
+    assert ilex((1, 2, 3)) > ilex((2, 0, 3))
+    assert igrlex((1, 2, 3)) < igrlex((0, 2, 3))
+    assert str(ilex) == "ilex"
+    assert str(igrlex) == "igrlex"
+    assert ilex.is_global is False
+    assert igrlex.is_global is False
+    assert ilex != igrlex
+    assert ilex == InverseOrder(LexOrder())
+
+def test_ProductOrder():
+    P = ProductOrder((grlex, lambda m: m[:2]), (grlex, lambda m: m[2:]))
+    assert P((1, 3, 3, 4, 5)) > P((2, 1, 5, 5, 5))
+    assert str(P) == "ProductOrder(grlex, grlex)"
+    assert P.is_global is True
+    assert ProductOrder((grlex, None), (ilex, None)).is_global is None
+    assert ProductOrder((igrlex, None), (ilex, None)).is_global is False
+
+def test_monomial_key():
+    assert monomial_key() == lex
+
+    assert monomial_key('lex') == lex
+    assert monomial_key('grlex') == grlex
+    assert monomial_key('grevlex') == grevlex
+
+    raises(ValueError, lambda: monomial_key('foo'))
+    raises(ValueError, lambda: monomial_key(1))
+
+    M = [x, x**2*z**2, x*y, x**2, S.One, y**2, x**3, y, z, x*y**2*z, x**2*y**2]
+    assert sorted(M, key=monomial_key('lex', [z, y, x])) == \
+        [S.One, x, x**2, x**3, y, x*y, y**2, x**2*y**2, z, x*y**2*z, x**2*z**2]
+    assert sorted(M, key=monomial_key('grlex', [z, y, x])) == \
+        [S.One, x, y, z, x**2, x*y, y**2, x**3, x**2*y**2, x*y**2*z, x**2*z**2]
+    assert sorted(M, key=monomial_key('grevlex', [z, y, x])) == \
+        [S.One, x, y, z, x**2, x*y, y**2, x**3, x**2*y**2, x**2*z**2, x*y**2*z]
+
+def test_build_product_order():
+    assert build_product_order((("grlex", x, y), ("grlex", z, t)), [x, y, z, t])((4, 5, 6, 7)) == \
+        ((9, (4, 5)), (13, (6, 7)))
+
+    assert build_product_order((("grlex", x, y), ("grlex", z, t)), [x, y, z, t]) == \
+        build_product_order((("grlex", x, y), ("grlex", z, t)), [x, y, z, t])

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_partfrac.py

@@ -0,0 +1,249 @@
+"""Tests for algorithms for partial fraction decomposition of rational
+functions. """
+
+from sympy.polys.partfrac import (
+    apart_undetermined_coeffs,
+    apart,
+    apart_list, assemble_partfrac_list
+)
+
+from sympy.core.expr import Expr
+from sympy.core.function import Lambda
+from sympy.core.numbers import (E, I, Rational, pi, all_close)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import (Poly, factor)
+from sympy.polys.rationaltools import together
+from sympy.polys.rootoftools import RootSum
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import x, y, a, b, c
+
+
+def test_apart():
+    assert apart(1) == 1
+    assert apart(1, x) == 1
+
+    f, g = (x**2 + 1)/(x + 1), 2/(x + 1) + x - 1
+
+    assert apart(f, full=False) == g
+    assert apart(f, full=True) == g
+
+    f, g = 1/(x + 2)/(x + 1), 1/(1 + x) - 1/(2 + x)
+
+    assert apart(f, full=False) == g
+    assert apart(f, full=True) == g
+
+    f, g = 1/(x + 1)/(x + 5), -1/(5 + x)/4 + 1/(1 + x)/4
+
+    assert apart(f, full=False) == g
+    assert apart(f, full=True) == g
+
+    assert apart((E*x + 2)/(x - pi)*(x - 1), x) == \
+        2 - E + E*pi + E*x + (E*pi + 2)*(pi - 1)/(x - pi)
+
+    assert apart(Eq((x**2 + 1)/(x + 1), x), x) == Eq(x - 1 + 2/(x + 1), x)
+
+    assert apart(x/2, y) == x/2
+
+    f, g = (x+y)/(2*x - y), Rational(3, 2)*y/(2*x - y) + S.Half
+
+    assert apart(f, x, full=False) == g
+    assert apart(f, x, full=True) == g
+
+    f, g = (x+y)/(2*x - y), 3*x/(2*x - y) - 1
+
+    assert apart(f, y, full=False) == g
+    assert apart(f, y, full=True) == g
+
+    raises(NotImplementedError, lambda: apart(1/(x + 1)/(y + 2)))
+
+
+def test_apart_matrix():
+    M = Matrix(2, 2, lambda i, j: 1/(x + i + 1)/(x + j))
+
+    assert apart(M) == Matrix([
+        [1/x - 1/(x + 1), (x + 1)**(-2)],
+        [1/(2*x) - (S.Half)/(x + 2), 1/(x + 1) - 1/(x + 2)],
+    ])
+
+
+def test_apart_symbolic():
+    f = a*x**4 + (2*b + 2*a*c)*x**3 + (4*b*c - a**2 + a*c**2)*x**2 + \
+        (-2*a*b + 2*b*c**2)*x - b**2
+    g = a**2*x**4 + (2*a*b + 2*c*a**2)*x**3 + (4*a*b*c + b**2 +
+        a**2*c**2)*x**2 + (2*c*b**2 + 2*a*b*c**2)*x + b**2*c**2
+
+    assert apart(f/g, x) == 1/a - 1/(x + c)**2 - b**2/(a*(a*x + b)**2)
+
+    assert apart(1/((x + a)*(x + b)*(x + c)), x) == \
+        1/((a - c)*(b - c)*(c + x)) - 1/((a - b)*(b - c)*(b + x)) + \
+        1/((a - b)*(a - c)*(a + x))
+
+
+def _make_extension_example():
+    # https://github.com/sympy/sympy/issues/18531
+    from sympy.core import Mul
+    def mul2(expr):
+        # 2-arg mul hack...
+        return Mul(2, expr, evaluate=False)
+
+    f = ((x**2 + 1)**3/((x - 1)**2*(x + 1)**2*(-x**2 + 2*x + 1)*(x**2 + 2*x - 1)))
+    g = (1/mul2(x - sqrt(2) + 1)
+       - 1/mul2(x - sqrt(2) - 1)
+       + 1/mul2(x + 1 + sqrt(2))
+       - 1/mul2(x - 1 + sqrt(2))
+       + 1/mul2((x + 1)**2)
+       + 1/mul2((x - 1)**2))
+    return f, g
+
+
+def test_apart_extension():
+    f = 2/(x**2 + 1)
+    g = I/(x + I) - I/(x - I)
+
+    assert apart(f, extension=I) == g
+    assert apart(f, gaussian=True) == g
+
+    f = x/((x - 2)*(x + I))
+
+    assert factor(together(apart(f)).expand()) == f
+
+    f, g = _make_extension_example()
+
+    # XXX: Only works with dotprodsimp. See test_apart_extension_xfail below
+    from sympy.matrices import dotprodsimp
+    with dotprodsimp(True):
+        assert apart(f, x, extension={sqrt(2)}) == g
+
+
+def test_apart_extension_xfail():
+    f, g = _make_extension_example()
+    assert apart(f, x, extension={sqrt(2)}) == g
+
+
+def test_apart_full():
+    f = 1/(x**2 + 1)
+
+    assert apart(f, full=False) == f
+    assert apart(f, full=True).dummy_eq(
+        -RootSum(x**2 + 1, Lambda(a, a/(x - a)), auto=False)/2)
+
+    f = 1/(x**3 + x + 1)
+
+    assert apart(f, full=False) == f
+    assert apart(f, full=True).dummy_eq(
+        RootSum(x**3 + x + 1,
+        Lambda(a, (a**2*Rational(6, 31) - a*Rational(9, 31) + Rational(4, 31))/(x - a)), auto=False))
+
+    f = 1/(x**5 + 1)
+
+    assert apart(f, full=False) == \
+        (Rational(-1, 5))*((x**3 - 2*x**2 + 3*x - 4)/(x**4 - x**3 + x**2 -
+         x + 1)) + (Rational(1, 5))/(x + 1)
+    assert apart(f, full=True).dummy_eq(
+        -RootSum(x**4 - x**3 + x**2 - x + 1,
+        Lambda(a, a/(x - a)), auto=False)/5 + (Rational(1, 5))/(x + 1))
+
+
+def test_apart_full_floats():
+    # https://github.com/sympy/sympy/issues/26648
+    f = (
+        6.43369157032015e-9*x**3 + 1.35203404799555e-5*x**2
+        + 0.00357538393743079*x + 0.085
+        )/(
+        4.74334912634438e-11*x**4 + 4.09576274286244e-6*x**3
+        + 0.00334241812250921*x**2 + 0.15406018058983*x + 1.0
+    )
+
+    expected = (
+        133.599202650992/(x + 85524.0054884464)
+        + 1.07757928431867/(x + 774.88576677949)
+        + 0.395006955518971/(x + 40.7977016133126)
+        + 0.564264854137341/(x + 7.79746609204661)
+    )
+
+    f_apart = apart(f, full=True).evalf()
+
+    # There is a significant floating point error in this operation.
+    assert all_close(f_apart, expected, rtol=1e-3, atol=1e-5)
+
+
+def test_apart_undetermined_coeffs():
+    p = Poly(2*x - 3)
+    q = Poly(x**9 - x**8 - x**6 + x**5 - 2*x**2 + 3*x - 1)
+    r = (-x**7 - x**6 - x**5 + 4)/(x**8 - x**5 - 2*x + 1) + 1/(x - 1)
+
+    assert apart_undetermined_coeffs(p, q) == r
+
+    p = Poly(1, x, domain='ZZ[a,b]')
+    q = Poly((x + a)*(x + b), x, domain='ZZ[a,b]')
+    r = 1/((a - b)*(b + x)) - 1/((a - b)*(a + x))
+
+    assert apart_undetermined_coeffs(p, q) == r
+
+
+def test_apart_list():
+    from sympy.utilities.iterables import numbered_symbols
+    def dummy_eq(i, j):
+        if type(i) in (list, tuple):
+            return all(dummy_eq(i, j) for i, j in zip(i, j))
+        return i == j or i.dummy_eq(j)
+
+    w0, w1, w2 = Symbol("w0"), Symbol("w1"), Symbol("w2")
+    _a = Dummy("a")
+
+    f = (-2*x - 2*x**2) / (3*x**2 - 6*x)
+    got = apart_list(f, x, dummies=numbered_symbols("w"))
+    ans = (-1, Poly(Rational(2, 3), x, domain='QQ'),
+        [(Poly(w0 - 2, w0, domain='ZZ'), Lambda(_a, 2), Lambda(_a, -_a + x), 1)])
+    assert dummy_eq(got, ans)
+
+    got = apart_list(2/(x**2-2), x, dummies=numbered_symbols("w"))
+    ans = (1, Poly(0, x, domain='ZZ'), [(Poly(w0**2 - 2, w0, domain='ZZ'),
+        Lambda(_a, _a/2),
+        Lambda(_a, -_a + x), 1)])
+    assert dummy_eq(got, ans)
+
+    f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2)
+    got = apart_list(f, x, dummies=numbered_symbols("w"))
+    ans = (1, Poly(0, x, domain='ZZ'),
+        [(Poly(w0 - 2, w0, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1),
+        (Poly(w1**2 - 1, w1, domain='ZZ'), Lambda(_a, -3*_a - 6), Lambda(_a, -_a + x), 2),
+        (Poly(w2 + 1, w2, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1)])
+    assert dummy_eq(got, ans)
+
+
+def test_assemble_partfrac_list():
+    f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2)
+    pfd = apart_list(f)
+    assert assemble_partfrac_list(pfd) == -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
+
+    a = Dummy("a")
+    pfd = (1, Poly(0, x, domain='ZZ'), [([sqrt(2),-sqrt(2)], Lambda(a, a/2), Lambda(a, -a + x), 1)])
+    assert assemble_partfrac_list(pfd) == -1/(sqrt(2)*(x + sqrt(2))) + 1/(sqrt(2)*(x - sqrt(2)))
+
+
+@XFAIL
+def test_noncommutative_pseudomultivariate():
+    # apart doesn't go inside noncommutative expressions
+    class foo(Expr):
+        is_commutative=False
+    e = x/(x + x*y)
+    c = 1/(1 + y)
+    assert apart(e + foo(e)) == c + foo(c)
+    assert apart(e*foo(e)) == c*foo(c)
+
+def test_noncommutative():
+    class foo(Expr):
+        is_commutative=False
+    e = x/(x + x*y)
+    c = 1/(1 + y)
+    assert apart(e + foo()) == c + foo()
+
+def test_issue_5798():
+    assert apart(
+        2*x/(x**2 + 1) - (x - 1)/(2*(x**2 + 1)) + 1/(2*(x + 1)) - 2/x) == \
+        (3*x + 1)/(x**2 + 1)/2 + 1/(x + 1)/2 - 2/x

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_polyclasses.py

@@ -0,0 +1,588 @@
+"""Tests for OO layer of several polynomial representations. """
+
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.polyclasses import DMP, DMF, ANP
+from sympy.polys.polyerrors import (CoercionFailed, ExactQuotientFailed,
+                                    NotInvertible)
+from sympy.polys.specialpolys import f_polys
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = [ f.to_dense() for f in f_polys() ]
+
+def test_DMP___init__():
+    f = DMP([[ZZ(0)], [], [ZZ(0), ZZ(1), ZZ(2)], [ZZ(3)]], ZZ)
+
+    assert f._rep == [[1, 2], [3]]
+    assert f.dom == ZZ
+    assert f.lev == 1
+
+    f = DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ, 1)
+
+    assert f._rep == [[1, 2], [3]]
+    assert f.dom == ZZ
+    assert f.lev == 1
+
+    f = DMP.from_dict({(1, 1): ZZ(1), (0, 0): ZZ(2)}, 1, ZZ)
+
+    assert f._rep == [[1, 0], [2]]
+    assert f.dom == ZZ
+    assert f.lev == 1
+
+
+def test_DMP_rep_deprecation():
+    f = DMP([1, 2, 3], ZZ)
+
+    with warns_deprecated_sympy():
+        assert f.rep == [1, 2, 3]
+
+
+def test_DMP___eq__():
+    assert DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ) == \
+        DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ)
+
+    assert DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ) == \
+        DMP([[QQ(1), QQ(2)], [QQ(3)]], QQ)
+    assert DMP([[QQ(1), QQ(2)], [QQ(3)]], QQ) == \
+        DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ)
+
+    assert DMP([[[ZZ(1)]]], ZZ) != DMP([[ZZ(1)]], ZZ)
+    assert DMP([[ZZ(1)]], ZZ) != DMP([[[ZZ(1)]]], ZZ)
+
+
+def test_DMP___bool__():
+    assert bool(DMP([[]], ZZ)) is False
+    assert bool(DMP([[ZZ(1)]], ZZ)) is True
+
+
+def test_DMP_to_dict():
+    f = DMP([[ZZ(3)], [], [ZZ(2)], [], [ZZ(8)]], ZZ)
+
+    assert f.to_dict() == \
+        {(4, 0): 3, (2, 0): 2, (0, 0): 8}
+    assert f.to_sympy_dict() == \
+        {(4, 0): ZZ.to_sympy(3), (2, 0): ZZ.to_sympy(2), (0, 0):
+         ZZ.to_sympy(8)}
+
+
+def test_DMP_properties():
+    assert DMP([[]], ZZ).is_zero is True
+    assert DMP([[ZZ(1)]], ZZ).is_zero is False
+
+    assert DMP([[ZZ(1)]], ZZ).is_one is True
+    assert DMP([[ZZ(2)]], ZZ).is_one is False
+
+    assert DMP([[ZZ(1)]], ZZ).is_ground is True
+    assert DMP([[ZZ(1)], [ZZ(2)], [ZZ(1)]], ZZ).is_ground is False
+
+    assert DMP([[ZZ(1)], [ZZ(2), ZZ(0)], [ZZ(1), ZZ(0)]], ZZ).is_sqf is True
+    assert DMP([[ZZ(1)], [ZZ(2), ZZ(0)], [ZZ(1), ZZ(0), ZZ(0)]], ZZ).is_sqf is False
+
+    assert DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ).is_monic is True
+    assert DMP([[ZZ(2), ZZ(2)], [ZZ(3)]], ZZ).is_monic is False
+
+    assert DMP([[ZZ(1), ZZ(2)], [ZZ(3)]], ZZ).is_primitive is True
+    assert DMP([[ZZ(2), ZZ(4)], [ZZ(6)]], ZZ).is_primitive is False
+
+
+def test_DMP_arithmetics():
+    f = DMP([[ZZ(2)], [ZZ(2), ZZ(0)]], ZZ)
+
+    assert f.mul_ground(2) == DMP([[ZZ(4)], [ZZ(4), ZZ(0)]], ZZ)
+    assert f.quo_ground(2) == DMP([[ZZ(1)], [ZZ(1), ZZ(0)]], ZZ)
+
+    raises(ExactQuotientFailed, lambda: f.exquo_ground(3))
+
+    f = DMP([[ZZ(-5)]], ZZ)
+    g = DMP([[ZZ(5)]], ZZ)
+
+    assert f.abs() == g
+    assert abs(f) == g
+
+    assert g.neg() == f
+    assert -g == f
+
+    h = DMP([[]], ZZ)
+
+    assert f.add(g) == h
+    assert f + g == h
+    assert g + f == h
+    assert f + 5 == h
+    assert 5 + f == h
+
+    h = DMP([[ZZ(-10)]], ZZ)
+
+    assert f.sub(g) == h
+    assert f - g == h
+    assert g - f == -h
+    assert f - 5 == h
+    assert 5 - f == -h
+
+    h = DMP([[ZZ(-25)]], ZZ)
+
+    assert f.mul(g) == h
+    assert f * g == h
+    assert g * f == h
+    assert f * 5 == h
+    assert 5 * f == h
+
+    h = DMP([[ZZ(25)]], ZZ)
+
+    assert f.sqr() == h
+    assert f.pow(2) == h
+    assert f**2 == h
+
+    raises(TypeError, lambda: f.pow('x'))
+
+    f = DMP([[ZZ(1)], [], [ZZ(1), ZZ(0), ZZ(0)]], ZZ)
+    g = DMP([[ZZ(2)], [ZZ(-2), ZZ(0)]], ZZ)
+
+    q = DMP([[ZZ(2)], [ZZ(2), ZZ(0)]], ZZ)
+    r = DMP([[ZZ(8), ZZ(0), ZZ(0)]], ZZ)
+
+    assert f.pdiv(g) == (q, r)
+    assert f.pquo(g) == q
+    assert f.prem(g) == r
+
+    raises(ExactQuotientFailed, lambda: f.pexquo(g))
+
+    f = DMP([[ZZ(1)], [], [ZZ(1), ZZ(0), ZZ(0)]], ZZ)
+    g = DMP([[ZZ(1)], [ZZ(-1), ZZ(0)]], ZZ)
+
+    q = DMP([[ZZ(1)], [ZZ(1), ZZ(0)]], ZZ)
+    r = DMP([[ZZ(2), ZZ(0), ZZ(0)]], ZZ)
+
+    assert f.div(g) == (q, r)
+    assert f.quo(g) == q
+    assert f.rem(g) == r
+
+    assert divmod(f, g) == (q, r)
+    assert f // g == q
+    assert f % g == r
+
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f = DMP([ZZ(1), ZZ(0), ZZ(-1)], ZZ)
+    g = DMP([ZZ(2), ZZ(-2)], ZZ)
+
+    q = DMP([], ZZ)
+    r = f
+
+    pq = DMP([ZZ(2), ZZ(2)], ZZ)
+    pr = DMP([], ZZ)
+
+    assert f.div(g) == (q, r)
+    assert f.quo(g) == q
+    assert f.rem(g) == r
+
+    assert divmod(f, g) == (q, r)
+    assert f // g == q
+    assert f % g == r
+
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    assert f.pdiv(g) == (pq, pr)
+    assert f.pquo(g) == pq
+    assert f.prem(g) == pr
+    assert f.pexquo(g) == pq
+
+
+def test_DMP_functionality():
+    f = DMP([[ZZ(1)], [ZZ(2), ZZ(0)], [ZZ(1), ZZ(0), ZZ(0)]], ZZ)
+    g = DMP([[ZZ(1)], [ZZ(1), ZZ(0)]], ZZ)
+    h = DMP([[ZZ(1)]], ZZ)
+
+    assert f.degree() == 2
+    assert f.degree_list() == (2, 2)
+    assert f.total_degree() == 2
+
+    assert f.LC() == ZZ(1)
+    assert f.TC() == ZZ(0)
+    assert f.nth(1, 1) == ZZ(2)
+
+    raises(TypeError, lambda: f.nth(0, 'x'))
+
+    assert f.max_norm() == 2
+    assert f.l1_norm() == 4
+
+    u = DMP([[ZZ(2)], [ZZ(2), ZZ(0)]], ZZ)
+
+    assert f.diff(m=1, j=0) == u
+    assert f.diff(m=1, j=1) == u
+
+    raises(TypeError, lambda: f.diff(m='x', j=0))
+
+    u = DMP([ZZ(1), ZZ(2), ZZ(1)], ZZ)
+    v = DMP([ZZ(1), ZZ(2), ZZ(1)], ZZ)
+
+    assert f.eval(a=1, j=0) == u
+    assert f.eval(a=1, j=1) == v
+
+    assert f.eval(1).eval(1) == ZZ(4)
+
+    assert f.cofactors(g) == (g, g, h)
+    assert f.gcd(g) == g
+    assert f.lcm(g) == f
+
+    u = DMP([[QQ(45), QQ(30), QQ(5)]], QQ)
+    v = DMP([[QQ(1), QQ(2, 3), QQ(1, 9)]], QQ)
+
+    assert u.monic() == v
+
+    assert (4*f).content() == ZZ(4)
+    assert (4*f).primitive() == (ZZ(4), f)
+
+    f = DMP([QQ(1,3), QQ(1)], QQ)
+    g = DMP([QQ(1,7), QQ(1)], QQ)
+
+    assert f.cancel(g) == f.cancel(g, include=True) == (
+        DMP([QQ(7), QQ(21)], QQ),
+        DMP([QQ(3), QQ(21)], QQ)
+    )
+    assert f.cancel(g, include=False) == (
+        QQ(7),
+        QQ(3),
+        DMP([QQ(1), QQ(3)], QQ),
+        DMP([QQ(1), QQ(7)], QQ)
+    )
+
+    f = DMP([[ZZ(1)], [ZZ(2)], [ZZ(3)], [ZZ(4)], [ZZ(5)], [ZZ(6)]], ZZ)
+
+    assert f.trunc(3) == DMP([[ZZ(1)], [ZZ(-1)], [], [ZZ(1)], [ZZ(-1)], []], ZZ)
+
+    f = DMP(f_4, ZZ)
+
+    assert f.sqf_part() == -f
+    assert f.sqf_list() == (ZZ(-1), [(-f, 1)])
+
+    f = DMP([[ZZ(-1)], [], [], [ZZ(5)]], ZZ)
+    g = DMP([[ZZ(3), ZZ(1)], [], []], ZZ)
+    h = DMP([[ZZ(45), ZZ(30), ZZ(5)]], ZZ)
+
+    r = DMP([ZZ(675), ZZ(675), ZZ(225), ZZ(25)], ZZ)
+
+    assert f.subresultants(g) == [f, g, h]
+    assert f.resultant(g) == r
+
+    f = DMP([ZZ(1), ZZ(3), ZZ(9), ZZ(-13)], ZZ)
+
+    assert f.discriminant() == -11664
+
+    f = DMP([QQ(2), QQ(0)], QQ)
+    g = DMP([QQ(1), QQ(0), QQ(-16)], QQ)
+
+    s = DMP([QQ(1, 32), QQ(0)], QQ)
+    t = DMP([QQ(-1, 16)], QQ)
+    h = DMP([QQ(1)], QQ)
+
+    assert f.half_gcdex(g) == (s, h)
+    assert f.gcdex(g) == (s, t, h)
+
+    assert f.invert(g) == s
+
+    f = DMP([[QQ(1)], [QQ(2)], [QQ(3)]], QQ)
+
+    raises(ValueError, lambda: f.half_gcdex(f))
+    raises(ValueError, lambda: f.gcdex(f))
+
+    raises(ValueError, lambda: f.invert(f))
+
+    f = DMP(ZZ.map([1, 0, 20, 0, 150, 0, 500, 0, 625, -2, 0, -10, 9]), ZZ)
+    g = DMP([ZZ(1), ZZ(0), ZZ(0), ZZ(-2), ZZ(9)], ZZ)
+    h = DMP([ZZ(1), ZZ(0), ZZ(5), ZZ(0)], ZZ)
+
+    assert g.compose(h) == f
+    assert f.decompose() == [g, h]
+
+    f = DMP([[QQ(1)], [QQ(2)], [QQ(3)]], QQ)
+
+    raises(ValueError, lambda: f.decompose())
+    raises(ValueError, lambda: f.sturm())
+
+
+def test_DMP_exclude():
+    f = [[[[[[[[[[[[[[[[[[[[[[[[[[ZZ(1)]], [[]]]]]]]]]]]]]]]]]]]]]]]]]]
+    J = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+        18, 19, 20, 21, 22, 24, 25]
+
+    assert DMP(f, ZZ).exclude() == (J, DMP([ZZ(1), ZZ(0)], ZZ))
+    assert DMP([[ZZ(1)], [ZZ(1), ZZ(0)]], ZZ).exclude() ==\
+            ([], DMP([[ZZ(1)], [ZZ(1), ZZ(0)]], ZZ))
+
+
+def test_DMF__init__():
+    f = DMF(([[0], [], [0, 1, 2], [3]], [[1, 2, 3]]), ZZ)
+
+    assert f.num == [[1, 2], [3]]
+    assert f.den == [[1, 2, 3]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[1, 2], [3]], [[1, 2, 3]]), ZZ, 1)
+
+    assert f.num == [[1, 2], [3]]
+    assert f.den == [[1, 2, 3]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[-1], [-2]], [[3], [-4]]), ZZ)
+
+    assert f.num == [[-1], [-2]]
+    assert f.den == [[3], [-4]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[1], [2]], [[-3], [4]]), ZZ)
+
+    assert f.num == [[-1], [-2]]
+    assert f.den == [[3], [-4]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[1], [2]], [[-3], [4]]), ZZ)
+
+    assert f.num == [[-1], [-2]]
+    assert f.den == [[3], [-4]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[]], [[-3], [4]]), ZZ)
+
+    assert f.num == [[]]
+    assert f.den == [[1]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(17, ZZ, 1)
+
+    assert f.num == [[17]]
+    assert f.den == [[1]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[1], [2]]), ZZ)
+
+    assert f.num == [[1], [2]]
+    assert f.den == [[1]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF([[0], [], [0, 1, 2], [3]], ZZ)
+
+    assert f.num == [[1, 2], [3]]
+    assert f.den == [[1]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF({(1, 1): 1, (0, 0): 2}, ZZ, 1)
+
+    assert f.num == [[1, 0], [2]]
+    assert f.den == [[1]]
+    assert f.lev == 1
+    assert f.dom == ZZ
+
+    f = DMF(([[QQ(1)], [QQ(2)]], [[-QQ(3)], [QQ(4)]]), QQ)
+
+    assert f.num == [[-QQ(1)], [-QQ(2)]]
+    assert f.den == [[QQ(3)], [-QQ(4)]]
+    assert f.lev == 1
+    assert f.dom == QQ
+
+    f = DMF(([[QQ(1, 5)], [QQ(2, 5)]], [[-QQ(3, 7)], [QQ(4, 7)]]), QQ)
+
+    assert f.num == [[-QQ(7)], [-QQ(14)]]
+    assert f.den == [[QQ(15)], [-QQ(20)]]
+    assert f.lev == 1
+    assert f.dom == QQ
+
+    raises(ValueError, lambda: DMF(([1], [[1]]), ZZ))
+    raises(ZeroDivisionError, lambda: DMF(([1], []), ZZ))
+
+
+def test_DMF__bool__():
+    assert bool(DMF([[]], ZZ)) is False
+    assert bool(DMF([[1]], ZZ)) is True
+
+
+def test_DMF_properties():
+    assert DMF([[]], ZZ).is_zero is True
+    assert DMF([[]], ZZ).is_one is False
+
+    assert DMF([[1]], ZZ).is_zero is False
+    assert DMF([[1]], ZZ).is_one is True
+
+    assert DMF(([[1]], [[2]]), ZZ).is_one is False
+
+
+def test_DMF_arithmetics():
+    f = DMF([[7], [-9]], ZZ)
+    g = DMF([[-7], [9]], ZZ)
+
+    assert f.neg() == -f == g
+
+    f = DMF(([[1]], [[1], []]), ZZ)
+    g = DMF(([[1]], [[1, 0]]), ZZ)
+
+    h = DMF(([[1], [1, 0]], [[1, 0], []]), ZZ)
+
+    assert f.add(g) == f + g == h
+    assert g.add(f) == g + f == h
+
+    h = DMF(([[-1], [1, 0]], [[1, 0], []]), ZZ)
+
+    assert f.sub(g) == f - g == h
+
+    h = DMF(([[1]], [[1, 0], []]), ZZ)
+
+    assert f.mul(g) == f*g == h
+    assert g.mul(f) == g*f == h
+
+    h = DMF(([[1, 0]], [[1], []]), ZZ)
+
+    assert f.quo(g) == f/g == h
+
+    h = DMF(([[1]], [[1], [], [], []]), ZZ)
+
+    assert f.pow(3) == f**3 == h
+
+    h = DMF(([[1]], [[1, 0, 0, 0]]), ZZ)
+
+    assert g.pow(3) == g**3 == h
+
+    h = DMF(([[1, 0]], [[1]]), ZZ)
+
+    assert g.pow(-1) == g**-1 == h
+
+
+def test_ANP___init__():
+    rep = [QQ(1), QQ(1)]
+    mod = [QQ(1), QQ(0), QQ(1)]
+
+    f = ANP(rep, mod, QQ)
+
+    assert f.to_list() == [QQ(1), QQ(1)]
+    assert f.mod_to_list() == [QQ(1), QQ(0), QQ(1)]
+    assert f.dom == QQ
+
+    rep = {1: QQ(1), 0: QQ(1)}
+    mod = {2: QQ(1), 0: QQ(1)}
+
+    f = ANP(rep, mod, QQ)
+
+    assert f.to_list() == [QQ(1), QQ(1)]
+    assert f.mod_to_list() == [QQ(1), QQ(0), QQ(1)]
+    assert f.dom == QQ
+
+    f = ANP(1, mod, QQ)
+
+    assert f.to_list() == [QQ(1)]
+    assert f.mod_to_list() == [QQ(1), QQ(0), QQ(1)]
+    assert f.dom == QQ
+
+    f = ANP([1, 0.5], mod, QQ)
+
+    assert all(QQ.of_type(a) for a in f.to_list())
+
+    raises(CoercionFailed, lambda: ANP([sqrt(2)], mod, QQ))
+
+
+def test_ANP___eq__():
+    a = ANP([QQ(1), QQ(1)], [QQ(1), QQ(0), QQ(1)], QQ)
+    b = ANP([QQ(1), QQ(1)], [QQ(1), QQ(0), QQ(2)], QQ)
+
+    assert (a == a) is True
+    assert (a != a) is False
+
+    assert (a == b) is False
+    assert (a != b) is True
+
+    b = ANP([QQ(1), QQ(2)], [QQ(1), QQ(0), QQ(1)], QQ)
+
+    assert (a == b) is False
+    assert (a != b) is True
+
+
+def test_ANP___bool__():
+    assert bool(ANP([], [QQ(1), QQ(0), QQ(1)], QQ)) is False
+    assert bool(ANP([QQ(1)], [QQ(1), QQ(0), QQ(1)], QQ)) is True
+
+
+def test_ANP_properties():
+    mod = [QQ(1), QQ(0), QQ(1)]
+
+    assert ANP([QQ(0)], mod, QQ).is_zero is True
+    assert ANP([QQ(1)], mod, QQ).is_zero is False
+
+    assert ANP([QQ(1)], mod, QQ).is_one is True
+    assert ANP([QQ(2)], mod, QQ).is_one is False
+
+
+def test_ANP_arithmetics():
+    mod = [QQ(1), QQ(0), QQ(0), QQ(-2)]
+
+    a = ANP([QQ(2), QQ(-1), QQ(1)], mod, QQ)
+    b = ANP([QQ(1), QQ(2)], mod, QQ)
+
+    c = ANP([QQ(-2), QQ(1), QQ(-1)], mod, QQ)
+
+    assert a.neg() == -a == c
+
+    c = ANP([QQ(2), QQ(0), QQ(3)], mod, QQ)
+
+    assert a.add(b) == a + b == c
+    assert b.add(a) == b + a == c
+
+    c = ANP([QQ(2), QQ(-2), QQ(-1)], mod, QQ)
+
+    assert a.sub(b) == a - b == c
+
+    c = ANP([QQ(-2), QQ(2), QQ(1)], mod, QQ)
+
+    assert b.sub(a) == b - a == c
+
+    c = ANP([QQ(3), QQ(-1), QQ(6)], mod, QQ)
+
+    assert a.mul(b) == a*b == c
+    assert b.mul(a) == b*a == c
+
+    c = ANP([QQ(-1, 43), QQ(9, 43), QQ(5, 43)], mod, QQ)
+
+    assert a.pow(0) == a**(0) == ANP(1, mod, QQ)
+    assert a.pow(1) == a**(1) == a
+
+    assert a.pow(-1) == a**(-1) == c
+
+    assert a.quo(a) == a.mul(a.pow(-1)) == a*a**(-1) == ANP(1, mod, QQ)
+
+    c = ANP([], [1, 0, 0, -2], QQ)
+    r1 = a.rem(b)
+
+    (q, r2) = a.div(b)
+
+    assert r1 == r2 == c == a % b
+
+    raises(NotInvertible, lambda: a.div(c))
+    raises(NotInvertible, lambda: a.rem(c))
+
+    # Comparison with "hard-coded" value fails despite looking identical
+    # from sympy import Rational
+    # c = ANP([Rational(11, 10), Rational(-1, 5), Rational(-3, 5)], [1, 0, 0, -2], QQ)
+
+    assert q == a/b # == c
+
+def test_ANP_unify():
+    mod_z = [ZZ(1), ZZ(0), ZZ(-2)]
+    mod_q = [QQ(1), QQ(0), QQ(-2)]
+
+    a = ANP([QQ(1)], mod_q, QQ)
+    b = ANP([ZZ(1)], mod_z, ZZ)
+
+    assert a.unify(b)[0] == QQ
+    assert b.unify(a)[0] == QQ
+    assert a.unify(a)[0] == QQ
+    assert b.unify(b)[0] == ZZ
+
+    assert a.unify_ANP(b)[-1] == QQ
+    assert b.unify_ANP(a)[-1] == QQ
+    assert a.unify_ANP(a)[-1] == QQ
+    assert b.unify_ANP(b)[-1] == ZZ

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_polyoptions.py

@@ -0,0 +1,485 @@
+"""Tests for options manager for :class:`Poly` and public API functions. """
+
+from sympy.polys.polyoptions import (
+    Options, Expand, Gens, Wrt, Sort, Order, Field, Greedy, Domain,
+    Split, Gaussian, Extension, Modulus, Symmetric, Strict, Auto,
+    Frac, Formal, Polys, Include, All, Gen, Symbols, Method)
+
+from sympy.polys.orderings import lex
+from sympy.polys.domains import FF, GF, ZZ, QQ, QQ_I, RR, CC, EX
+
+from sympy.polys.polyerrors import OptionError, GeneratorsError
+
+from sympy.core.numbers import (I, Integer)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.testing.pytest import raises
+from sympy.abc import x, y, z
+
+
+def test_Options_clone():
+    opt = Options((x, y, z), {'domain': 'ZZ'})
+
+    assert opt.gens == (x, y, z)
+    assert opt.domain == ZZ
+    assert ('order' in opt) is False
+
+    new_opt = opt.clone({'gens': (x, y), 'order': 'lex'})
+
+    assert opt.gens == (x, y, z)
+    assert opt.domain == ZZ
+    assert ('order' in opt) is False
+
+    assert new_opt.gens == (x, y)
+    assert new_opt.domain == ZZ
+    assert ('order' in new_opt) is True
+
+
+def test_Expand_preprocess():
+    assert Expand.preprocess(False) is False
+    assert Expand.preprocess(True) is True
+
+    assert Expand.preprocess(0) is False
+    assert Expand.preprocess(1) is True
+
+    raises(OptionError, lambda: Expand.preprocess(x))
+
+
+def test_Expand_postprocess():
+    opt = {'expand': True}
+    Expand.postprocess(opt)
+
+    assert opt == {'expand': True}
+
+
+def test_Gens_preprocess():
+    assert Gens.preprocess((None,)) == ()
+    assert Gens.preprocess((x, y, z)) == (x, y, z)
+    assert Gens.preprocess(((x, y, z),)) == (x, y, z)
+
+    a = Symbol('a', commutative=False)
+
+    raises(GeneratorsError, lambda: Gens.preprocess((x, x, y)))
+    raises(GeneratorsError, lambda: Gens.preprocess((x, y, a)))
+
+
+def test_Gens_postprocess():
+    opt = {'gens': (x, y)}
+    Gens.postprocess(opt)
+
+    assert opt == {'gens': (x, y)}
+
+
+def test_Wrt_preprocess():
+    assert Wrt.preprocess(x) == ['x']
+    assert Wrt.preprocess('') == []
+    assert Wrt.preprocess(' ') == []
+    assert Wrt.preprocess('x,y') == ['x', 'y']
+    assert Wrt.preprocess('x y') == ['x', 'y']
+    assert Wrt.preprocess('x, y') == ['x', 'y']
+    assert Wrt.preprocess('x , y') == ['x', 'y']
+    assert Wrt.preprocess(' x, y') == ['x', 'y']
+    assert Wrt.preprocess(' x,  y') == ['x', 'y']
+    assert Wrt.preprocess([x, y]) == ['x', 'y']
+
+    raises(OptionError, lambda: Wrt.preprocess(','))
+    raises(OptionError, lambda: Wrt.preprocess(0))
+
+
+def test_Wrt_postprocess():
+    opt = {'wrt': ['x']}
+    Wrt.postprocess(opt)
+
+    assert opt == {'wrt': ['x']}
+
+
+def test_Sort_preprocess():
+    assert Sort.preprocess([x, y, z]) == ['x', 'y', 'z']
+    assert Sort.preprocess((x, y, z)) == ['x', 'y', 'z']
+
+    assert Sort.preprocess('x > y > z') == ['x', 'y', 'z']
+    assert Sort.preprocess('x>y>z') == ['x', 'y', 'z']
+
+    raises(OptionError, lambda: Sort.preprocess(0))
+    raises(OptionError, lambda: Sort.preprocess({x, y, z}))
+
+
+def test_Sort_postprocess():
+    opt = {'sort': 'x > y'}
+    Sort.postprocess(opt)
+
+    assert opt == {'sort': 'x > y'}
+
+
+def test_Order_preprocess():
+    assert Order.preprocess('lex') == lex
+
+
+def test_Order_postprocess():
+    opt = {'order': True}
+    Order.postprocess(opt)
+
+    assert opt == {'order': True}
+
+
+def test_Field_preprocess():
+    assert Field.preprocess(False) is False
+    assert Field.preprocess(True) is True
+
+    assert Field.preprocess(0) is False
+    assert Field.preprocess(1) is True
+
+    raises(OptionError, lambda: Field.preprocess(x))
+
+
+def test_Field_postprocess():
+    opt = {'field': True}
+    Field.postprocess(opt)
+
+    assert opt == {'field': True}
+
+
+def test_Greedy_preprocess():
+    assert Greedy.preprocess(False) is False
+    assert Greedy.preprocess(True) is True
+
+    assert Greedy.preprocess(0) is False
+    assert Greedy.preprocess(1) is True
+
+    raises(OptionError, lambda: Greedy.preprocess(x))
+
+
+def test_Greedy_postprocess():
+    opt = {'greedy': True}
+    Greedy.postprocess(opt)
+
+    assert opt == {'greedy': True}
+
+
+def test_Domain_preprocess():
+    assert Domain.preprocess(ZZ) == ZZ
+    assert Domain.preprocess(QQ) == QQ
+    assert Domain.preprocess(EX) == EX
+    assert Domain.preprocess(FF(2)) == FF(2)
+    assert Domain.preprocess(ZZ[x, y]) == ZZ[x, y]
+
+    assert Domain.preprocess('Z') == ZZ
+    assert Domain.preprocess('Q') == QQ
+
+    assert Domain.preprocess('ZZ') == ZZ
+    assert Domain.preprocess('QQ') == QQ
+
+    assert Domain.preprocess('EX') == EX
+
+    assert Domain.preprocess('FF(23)') == FF(23)
+    assert Domain.preprocess('GF(23)') == GF(23)
+
+    raises(OptionError, lambda: Domain.preprocess('Z[]'))
+
+    assert Domain.preprocess('Z[x]') == ZZ[x]
+    assert Domain.preprocess('Q[x]') == QQ[x]
+    assert Domain.preprocess('R[x]') == RR[x]
+    assert Domain.preprocess('C[x]') == CC[x]
+
+    assert Domain.preprocess('ZZ[x]') == ZZ[x]
+    assert Domain.preprocess('QQ[x]') == QQ[x]
+    assert Domain.preprocess('RR[x]') == RR[x]
+    assert Domain.preprocess('CC[x]') == CC[x]
+
+    assert Domain.preprocess('Z[x,y]') == ZZ[x, y]
+    assert Domain.preprocess('Q[x,y]') == QQ[x, y]
+    assert Domain.preprocess('R[x,y]') == RR[x, y]
+    assert Domain.preprocess('C[x,y]') == CC[x, y]
+
+    assert Domain.preprocess('ZZ[x,y]') == ZZ[x, y]
+    assert Domain.preprocess('QQ[x,y]') == QQ[x, y]
+    assert Domain.preprocess('RR[x,y]') == RR[x, y]
+    assert Domain.preprocess('CC[x,y]') == CC[x, y]
+
+    raises(OptionError, lambda: Domain.preprocess('Z()'))
+
+    assert Domain.preprocess('Z(x)') == ZZ.frac_field(x)
+    assert Domain.preprocess('Q(x)') == QQ.frac_field(x)
+
+    assert Domain.preprocess('ZZ(x)') == ZZ.frac_field(x)
+    assert Domain.preprocess('QQ(x)') == QQ.frac_field(x)
+
+    assert Domain.preprocess('Z(x,y)') == ZZ.frac_field(x, y)
+    assert Domain.preprocess('Q(x,y)') == QQ.frac_field(x, y)
+
+    assert Domain.preprocess('ZZ(x,y)') == ZZ.frac_field(x, y)
+    assert Domain.preprocess('QQ(x,y)') == QQ.frac_field(x, y)
+
+    assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I)
+    assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I)
+
+    assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
+    assert Domain.preprocess(
+        'QQ<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
+
+    raises(OptionError, lambda: Domain.preprocess('abc'))
+
+
+def test_Domain_postprocess():
+    raises(GeneratorsError, lambda: Domain.postprocess({'gens': (x, y),
+           'domain': ZZ[y, z]}))
+
+    raises(GeneratorsError, lambda: Domain.postprocess({'gens': (),
+           'domain': EX}))
+    raises(GeneratorsError, lambda: Domain.postprocess({'domain': EX}))
+
+
+def test_Split_preprocess():
+    assert Split.preprocess(False) is False
+    assert Split.preprocess(True) is True
+
+    assert Split.preprocess(0) is False
+    assert Split.preprocess(1) is True
+
+    raises(OptionError, lambda: Split.preprocess(x))
+
+
+def test_Split_postprocess():
+    raises(NotImplementedError, lambda: Split.postprocess({'split': True}))
+
+
+def test_Gaussian_preprocess():
+    assert Gaussian.preprocess(False) is False
+    assert Gaussian.preprocess(True) is True
+
+    assert Gaussian.preprocess(0) is False
+    assert Gaussian.preprocess(1) is True
+
+    raises(OptionError, lambda: Gaussian.preprocess(x))
+
+
+def test_Gaussian_postprocess():
+    opt = {'gaussian': True}
+    Gaussian.postprocess(opt)
+
+    assert opt == {
+        'gaussian': True,
+        'domain': QQ_I,
+    }
+
+
+def test_Extension_preprocess():
+    assert Extension.preprocess(True) is True
+    assert Extension.preprocess(1) is True
+
+    assert Extension.preprocess([]) is None
+
+    assert Extension.preprocess(sqrt(2)) == {sqrt(2)}
+    assert Extension.preprocess([sqrt(2)]) == {sqrt(2)}
+
+    assert Extension.preprocess([sqrt(2), I]) == {sqrt(2), I}
+
+    raises(OptionError, lambda: Extension.preprocess(False))
+    raises(OptionError, lambda: Extension.preprocess(0))
+
+
+def test_Extension_postprocess():
+    opt = {'extension': {sqrt(2)}}
+    Extension.postprocess(opt)
+
+    assert opt == {
+        'extension': {sqrt(2)},
+        'domain': QQ.algebraic_field(sqrt(2)),
+    }
+
+    opt = {'extension': True}
+    Extension.postprocess(opt)
+
+    assert opt == {'extension': True}
+
+
+def test_Modulus_preprocess():
+    assert Modulus.preprocess(23) == 23
+    assert Modulus.preprocess(Integer(23)) == 23
+
+    raises(OptionError, lambda: Modulus.preprocess(0))
+    raises(OptionError, lambda: Modulus.preprocess(x))
+
+
+def test_Modulus_postprocess():
+    opt = {'modulus': 5}
+    Modulus.postprocess(opt)
+
+    assert opt == {
+        'modulus': 5,
+        'domain': FF(5),
+    }
+
+    opt = {'modulus': 5, 'symmetric': False}
+    Modulus.postprocess(opt)
+
+    assert opt == {
+        'modulus': 5,
+        'domain': FF(5, False),
+        'symmetric': False,
+    }
+
+
+def test_Symmetric_preprocess():
+    assert Symmetric.preprocess(False) is False
+    assert Symmetric.preprocess(True) is True
+
+    assert Symmetric.preprocess(0) is False
+    assert Symmetric.preprocess(1) is True
+
+    raises(OptionError, lambda: Symmetric.preprocess(x))
+
+
+def test_Symmetric_postprocess():
+    opt = {'symmetric': True}
+    Symmetric.postprocess(opt)
+
+    assert opt == {'symmetric': True}
+
+
+def test_Strict_preprocess():
+    assert Strict.preprocess(False) is False
+    assert Strict.preprocess(True) is True
+
+    assert Strict.preprocess(0) is False
+    assert Strict.preprocess(1) is True
+
+    raises(OptionError, lambda: Strict.preprocess(x))
+
+
+def test_Strict_postprocess():
+    opt = {'strict': True}
+    Strict.postprocess(opt)
+
+    assert opt == {'strict': True}
+
+
+def test_Auto_preprocess():
+    assert Auto.preprocess(False) is False
+    assert Auto.preprocess(True) is True
+
+    assert Auto.preprocess(0) is False
+    assert Auto.preprocess(1) is True
+
+    raises(OptionError, lambda: Auto.preprocess(x))
+
+
+def test_Auto_postprocess():
+    opt = {'auto': True}
+    Auto.postprocess(opt)
+
+    assert opt == {'auto': True}
+
+
+def test_Frac_preprocess():
+    assert Frac.preprocess(False) is False
+    assert Frac.preprocess(True) is True
+
+    assert Frac.preprocess(0) is False
+    assert Frac.preprocess(1) is True
+
+    raises(OptionError, lambda: Frac.preprocess(x))
+
+
+def test_Frac_postprocess():
+    opt = {'frac': True}
+    Frac.postprocess(opt)
+
+    assert opt == {'frac': True}
+
+
+def test_Formal_preprocess():
+    assert Formal.preprocess(False) is False
+    assert Formal.preprocess(True) is True
+
+    assert Formal.preprocess(0) is False
+    assert Formal.preprocess(1) is True
+
+    raises(OptionError, lambda: Formal.preprocess(x))
+
+
+def test_Formal_postprocess():
+    opt = {'formal': True}
+    Formal.postprocess(opt)
+
+    assert opt == {'formal': True}
+
+
+def test_Polys_preprocess():
+    assert Polys.preprocess(False) is False
+    assert Polys.preprocess(True) is True
+
+    assert Polys.preprocess(0) is False
+    assert Polys.preprocess(1) is True
+
+    raises(OptionError, lambda: Polys.preprocess(x))
+
+
+def test_Polys_postprocess():
+    opt = {'polys': True}
+    Polys.postprocess(opt)
+
+    assert opt == {'polys': True}
+
+
+def test_Include_preprocess():
+    assert Include.preprocess(False) is False
+    assert Include.preprocess(True) is True
+
+    assert Include.preprocess(0) is False
+    assert Include.preprocess(1) is True
+
+    raises(OptionError, lambda: Include.preprocess(x))
+
+
+def test_Include_postprocess():
+    opt = {'include': True}
+    Include.postprocess(opt)
+
+    assert opt == {'include': True}
+
+
+def test_All_preprocess():
+    assert All.preprocess(False) is False
+    assert All.preprocess(True) is True
+
+    assert All.preprocess(0) is False
+    assert All.preprocess(1) is True
+
+    raises(OptionError, lambda: All.preprocess(x))
+
+
+def test_All_postprocess():
+    opt = {'all': True}
+    All.postprocess(opt)
+
+    assert opt == {'all': True}
+
+
+def test_Gen_postprocess():
+    opt = {'gen': x}
+    Gen.postprocess(opt)
+
+    assert opt == {'gen': x}
+
+
+def test_Symbols_preprocess():
+    raises(OptionError, lambda: Symbols.preprocess(x))
+
+
+def test_Symbols_postprocess():
+    opt = {'symbols': [x, y, z]}
+    Symbols.postprocess(opt)
+
+    assert opt == {'symbols': [x, y, z]}
+
+
+def test_Method_preprocess():
+    raises(OptionError, lambda: Method.preprocess(10))
+
+
+def test_Method_postprocess():
+    opt = {'method': 'f5b'}
+    Method.postprocess(opt)
+
+    assert opt == {'method': 'f5b'}

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_pythonrational.py

@@ -0,0 +1,139 @@
+"""Tests for PythonRational type. """
+
+from sympy.polys.domains import PythonRational as QQ
+from sympy.testing.pytest import raises
+
+def test_PythonRational__init__():
+    assert QQ(0).numerator == 0
+    assert QQ(0).denominator == 1
+    assert QQ(0, 1).numerator == 0
+    assert QQ(0, 1).denominator == 1
+    assert QQ(0, -1).numerator == 0
+    assert QQ(0, -1).denominator == 1
+
+    assert QQ(1).numerator == 1
+    assert QQ(1).denominator == 1
+    assert QQ(1, 1).numerator == 1
+    assert QQ(1, 1).denominator == 1
+    assert QQ(-1, -1).numerator == 1
+    assert QQ(-1, -1).denominator == 1
+
+    assert QQ(-1).numerator == -1
+    assert QQ(-1).denominator == 1
+    assert QQ(-1, 1).numerator == -1
+    assert QQ(-1, 1).denominator == 1
+    assert QQ( 1, -1).numerator == -1
+    assert QQ( 1, -1).denominator == 1
+
+    assert QQ(1, 2).numerator == 1
+    assert QQ(1, 2).denominator == 2
+    assert QQ(3, 4).numerator == 3
+    assert QQ(3, 4).denominator == 4
+
+    assert QQ(2, 2).numerator == 1
+    assert QQ(2, 2).denominator == 1
+    assert QQ(2, 4).numerator == 1
+    assert QQ(2, 4).denominator == 2
+
+def test_PythonRational__hash__():
+    assert hash(QQ(0)) == hash(0)
+    assert hash(QQ(1)) == hash(1)
+    assert hash(QQ(117)) == hash(117)
+
+def test_PythonRational__int__():
+    assert int(QQ(-1, 4)) == 0
+    assert int(QQ( 1, 4)) == 0
+    assert int(QQ(-5, 4)) == -1
+    assert int(QQ( 5, 4)) == 1
+
+def test_PythonRational__float__():
+    assert float(QQ(-1, 2)) == -0.5
+    assert float(QQ( 1, 2)) == 0.5
+
+def test_PythonRational__abs__():
+    assert abs(QQ(-1, 2)) == QQ(1, 2)
+    assert abs(QQ( 1, 2)) == QQ(1, 2)
+
+def test_PythonRational__pos__():
+    assert +QQ(-1, 2) == QQ(-1, 2)
+    assert +QQ( 1, 2) == QQ( 1, 2)
+
+def test_PythonRational__neg__():
+    assert -QQ(-1, 2) == QQ( 1, 2)
+    assert -QQ( 1, 2) == QQ(-1, 2)
+
+def test_PythonRational__add__():
+    assert QQ(-1, 2) + QQ( 1, 2) == QQ(0)
+    assert QQ( 1, 2) + QQ(-1, 2) == QQ(0)
+
+    assert QQ(1, 2) + QQ(1, 2) == QQ(1)
+    assert QQ(1, 2) + QQ(3, 2) == QQ(2)
+    assert QQ(3, 2) + QQ(1, 2) == QQ(2)
+    assert QQ(3, 2) + QQ(3, 2) == QQ(3)
+
+    assert 1 + QQ(1, 2) == QQ(3, 2)
+    assert QQ(1, 2) + 1 == QQ(3, 2)
+
+def test_PythonRational__sub__():
+    assert QQ(-1, 2) - QQ( 1, 2) == QQ(-1)
+    assert QQ( 1, 2) - QQ(-1, 2) == QQ( 1)
+
+    assert QQ(1, 2) - QQ(1, 2) == QQ( 0)
+    assert QQ(1, 2) - QQ(3, 2) == QQ(-1)
+    assert QQ(3, 2) - QQ(1, 2) == QQ( 1)
+    assert QQ(3, 2) - QQ(3, 2) == QQ( 0)
+
+    assert 1 - QQ(1, 2) == QQ( 1, 2)
+    assert QQ(1, 2) - 1 == QQ(-1, 2)
+
+def test_PythonRational__mul__():
+    assert QQ(-1, 2) * QQ( 1, 2) == QQ(-1, 4)
+    assert QQ( 1, 2) * QQ(-1, 2) == QQ(-1, 4)
+
+    assert QQ(1, 2) * QQ(1, 2) == QQ(1, 4)
+    assert QQ(1, 2) * QQ(3, 2) == QQ(3, 4)
+    assert QQ(3, 2) * QQ(1, 2) == QQ(3, 4)
+    assert QQ(3, 2) * QQ(3, 2) == QQ(9, 4)
+
+    assert 2 * QQ(1, 2) == QQ(1)
+    assert QQ(1, 2) * 2 == QQ(1)
+
+def test_PythonRational__truediv__():
+    assert QQ(-1, 2) / QQ( 1, 2) == QQ(-1)
+    assert QQ( 1, 2) / QQ(-1, 2) == QQ(-1)
+
+    assert QQ(1, 2) / QQ(1, 2) == QQ(1)
+    assert QQ(1, 2) / QQ(3, 2) == QQ(1, 3)
+    assert QQ(3, 2) / QQ(1, 2) == QQ(3)
+    assert QQ(3, 2) / QQ(3, 2) == QQ(1)
+
+    assert 2 / QQ(1, 2) == QQ(4)
+    assert QQ(1, 2) / 2 == QQ(1, 4)
+
+    raises(ZeroDivisionError, lambda: QQ(1, 2) / QQ(0))
+    raises(ZeroDivisionError, lambda: QQ(1, 2) / 0)
+
+def test_PythonRational__pow__():
+    assert QQ(1)**10 == QQ(1)
+    assert QQ(2)**10 == QQ(1024)
+
+    assert QQ(1)**(-10) == QQ(1)
+    assert QQ(2)**(-10) == QQ(1, 1024)
+
+def test_PythonRational__eq__():
+    assert (QQ(1, 2) == QQ(1, 2)) is True
+    assert (QQ(1, 2) != QQ(1, 2)) is False
+
+    assert (QQ(1, 2) == QQ(1, 3)) is False
+    assert (QQ(1, 2) != QQ(1, 3)) is True
+
+def test_PythonRational__lt_le_gt_ge__():
+    assert (QQ(1, 2) < QQ(1, 4)) is False
+    assert (QQ(1, 2) <= QQ(1, 4)) is False
+    assert (QQ(1, 2) > QQ(1, 4)) is True
+    assert (QQ(1, 2) >= QQ(1, 4)) is True
+
+    assert (QQ(1, 4) < QQ(1, 2)) is True
+    assert (QQ(1, 4) <= QQ(1, 2)) is True
+    assert (QQ(1, 4) > QQ(1, 2)) is False
+    assert (QQ(1, 4) >= QQ(1, 2)) is False

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_rationaltools.py

@@ -0,0 +1,63 @@
+"""Tests for tools for manipulation of rational expressions. """
+
+from sympy.polys.rationaltools import together
+
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import Integral
+from sympy.abc import x, y, z
+
+A, B = symbols('A,B', commutative=False)
+
+
+def test_together():
+    assert together(0) == 0
+    assert together(1) == 1
+
+    assert together(x*y*z) == x*y*z
+    assert together(x + y) == x + y
+
+    assert together(1/x) == 1/x
+
+    assert together(1/x + 1) == (x + 1)/x
+    assert together(1/x + 3) == (3*x + 1)/x
+    assert together(1/x + x) == (x**2 + 1)/x
+
+    assert together(1/x + S.Half) == (x + 2)/(2*x)
+    assert together(S.Half + x/2) == Mul(S.Half, x + 1, evaluate=False)
+
+    assert together(1/x + 2/y) == (2*x + y)/(y*x)
+    assert together(1/(1 + 1/x)) == x/(1 + x)
+    assert together(x/(1 + 1/x)) == x**2/(1 + x)
+
+    assert together(1/x + 1/y + 1/z) == (x*y + x*z + y*z)/(x*y*z)
+    assert together(1/(1 + x + 1/y + 1/z)) == y*z/(y + z + y*z + x*y*z)
+
+    assert together(1/(x*y) + 1/(x*y)**2) == y**(-2)*x**(-2)*(1 + x*y)
+    assert together(1/(x*y) + 1/(x*y)**4) == y**(-4)*x**(-4)*(1 + x**3*y**3)
+    assert together(1/(x**7*y) + 1/(x*y)**4) == y**(-4)*x**(-7)*(x**3 + y**3)
+
+    assert together(5/(2 + 6/(3 + 7/(4 + 8/(5 + 9/x))))) == \
+        Rational(5, 2)*((171 + 119*x)/(279 + 203*x))
+
+    assert together(1 + 1/(x + 1)**2) == (1 + (x + 1)**2)/(x + 1)**2
+    assert together(1 + 1/(x*(1 + x))) == (1 + x*(1 + x))/(x*(1 + x))
+    assert together(
+        1/(x*(x + 1)) + 1/(x*(x + 2))) == (3 + 2*x)/(x*(1 + x)*(2 + x))
+    assert together(1 + 1/(2*x + 2)**2) == (4*(x + 1)**2 + 1)/(4*(x + 1)**2)
+
+    assert together(sin(1/x + 1/y)) == sin(1/x + 1/y)
+    assert together(sin(1/x + 1/y), deep=True) == sin((x + y)/(x*y))
+
+    assert together(1/exp(x) + 1/(x*exp(x))) == (1 + x)/(x*exp(x))
+    assert together(1/exp(2*x) + 1/(x*exp(3*x))) == (1 + exp(x)*x)/(x*exp(3*x))
+
+    assert together(Integral(1/x + 1/y, x)) == Integral((x + y)/(x*y), x)
+    assert together(Eq(1/x + 1/y, 1 + 1/z)) == Eq((x + y)/(x*y), (z + 1)/z)
+
+    assert together((A*B)**-1 + (B*A)**-1) == (A*B)**-1 + (B*A)**-1

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_rootoftools.py

@@ -0,0 +1,653 @@
+"""Tests for the implementation of RootOf class and related tools. """
+
+from sympy.polys.polytools import Poly
+import sympy.polys.rootoftools as rootoftools
+from sympy.polys.rootoftools import (rootof, RootOf, CRootOf, RootSum,
+    _pure_key_dict as D)
+
+from sympy.polys.polyerrors import (
+    MultivariatePolynomialError,
+    GeneratorsNeeded,
+    PolynomialError,
+)
+
+from sympy.core.function import (Function, Lambda)
+from sympy.core.numbers import (Float, I, Rational)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import tan
+from sympy.integrals.integrals import Integral
+from sympy.polys.orthopolys import legendre_poly
+from sympy.solvers.solvers import solve
+
+
+from sympy.testing.pytest import raises, slow
+from sympy.core.expr import unchanged
+
+from sympy.abc import a, b, x, y, z, r
+
+
+def test_CRootOf___new__():
+    assert rootof(x, 0) == 0
+    assert rootof(x, -1) == 0
+
+    assert rootof(x, S.Zero) == 0
+
+    assert rootof(x - 1, 0) == 1
+    assert rootof(x - 1, -1) == 1
+
+    assert rootof(x + 1, 0) == -1
+    assert rootof(x + 1, -1) == -1
+
+    assert rootof(x**2 + 2*x + 3, 0) == -1 - I*sqrt(2)
+    assert rootof(x**2 + 2*x + 3, 1) == -1 + I*sqrt(2)
+    assert rootof(x**2 + 2*x + 3, -1) == -1 + I*sqrt(2)
+    assert rootof(x**2 + 2*x + 3, -2) == -1 - I*sqrt(2)
+
+    r = rootof(x**2 + 2*x + 3, 0, radicals=False)
+    assert isinstance(r, RootOf) is True
+
+    r = rootof(x**2 + 2*x + 3, 1, radicals=False)
+    assert isinstance(r, RootOf) is True
+
+    r = rootof(x**2 + 2*x + 3, -1, radicals=False)
+    assert isinstance(r, RootOf) is True
+
+    r = rootof(x**2 + 2*x + 3, -2, radicals=False)
+    assert isinstance(r, RootOf) is True
+
+    assert rootof((x - 1)*(x + 1), 0, radicals=False) == -1
+    assert rootof((x - 1)*(x + 1), 1, radicals=False) == 1
+    assert rootof((x - 1)*(x + 1), -1, radicals=False) == 1
+    assert rootof((x - 1)*(x + 1), -2, radicals=False) == -1
+
+    assert rootof((x - 1)*(x + 1), 0, radicals=True) == -1
+    assert rootof((x - 1)*(x + 1), 1, radicals=True) == 1
+    assert rootof((x - 1)*(x + 1), -1, radicals=True) == 1
+    assert rootof((x - 1)*(x + 1), -2, radicals=True) == -1
+
+    assert rootof((x - 1)*(x**3 + x + 3), 0) == rootof(x**3 + x + 3, 0)
+    assert rootof((x - 1)*(x**3 + x + 3), 1) == 1
+    assert rootof((x - 1)*(x**3 + x + 3), 2) == rootof(x**3 + x + 3, 1)
+    assert rootof((x - 1)*(x**3 + x + 3), 3) == rootof(x**3 + x + 3, 2)
+    assert rootof((x - 1)*(x**3 + x + 3), -1) == rootof(x**3 + x + 3, 2)
+    assert rootof((x - 1)*(x**3 + x + 3), -2) == rootof(x**3 + x + 3, 1)
+    assert rootof((x - 1)*(x**3 + x + 3), -3) == 1
+    assert rootof((x - 1)*(x**3 + x + 3), -4) == rootof(x**3 + x + 3, 0)
+
+    assert rootof(x**4 + 3*x**3, 0) == -3
+    assert rootof(x**4 + 3*x**3, 1) == 0
+    assert rootof(x**4 + 3*x**3, 2) == 0
+    assert rootof(x**4 + 3*x**3, 3) == 0
+
+    raises(GeneratorsNeeded, lambda: rootof(0, 0))
+    raises(GeneratorsNeeded, lambda: rootof(1, 0))
+
+    raises(PolynomialError, lambda: rootof(Poly(0, x), 0))
+    raises(PolynomialError, lambda: rootof(Poly(1, x), 0))
+    raises(PolynomialError, lambda: rootof(x - y, 0))
+    # issue 8617
+    raises(PolynomialError, lambda: rootof(exp(x), 0))
+
+    raises(NotImplementedError, lambda: rootof(x**3 - x + sqrt(2), 0))
+    raises(NotImplementedError, lambda: rootof(x**3 - x + I, 0))
+
+    raises(IndexError, lambda: rootof(x**2 - 1, -4))
+    raises(IndexError, lambda: rootof(x**2 - 1, -3))
+    raises(IndexError, lambda: rootof(x**2 - 1, 2))
+    raises(IndexError, lambda: rootof(x**2 - 1, 3))
+    raises(ValueError, lambda: rootof(x**2 - 1, x))
+
+    assert rootof(Poly(x - y, x), 0) == y
+
+    assert rootof(Poly(x**2 - y, x), 0) == -sqrt(y)
+    assert rootof(Poly(x**2 - y, x), 1) == sqrt(y)
+
+    assert rootof(Poly(x**3 - y, x), 0) == y**Rational(1, 3)
+
+    assert rootof(y*x**3 + y*x + 2*y, x, 0) == -1
+    raises(NotImplementedError, lambda: rootof(x**3 + x + 2*y, x, 0))
+
+    assert rootof(x**3 + x + 1, 0).is_commutative is True
+
+
+def test_CRootOf_attributes():
+    r = rootof(x**3 + x + 3, 0)
+    assert r.is_number
+    assert r.free_symbols == set()
+    # if the following assertion fails then multivariate polynomials
+    # are apparently supported and the RootOf.free_symbols routine
+    # should be changed to return whatever symbols would not be
+    # the PurePoly dummy symbol
+    raises(NotImplementedError, lambda: rootof(Poly(x**3 + y*x + 1, x), 0))
+
+
+def test_CRootOf___eq__():
+    assert (rootof(x**3 + x + 3, 0) == rootof(x**3 + x + 3, 0)) is True
+    assert (rootof(x**3 + x + 3, 0) == rootof(x**3 + x + 3, 1)) is False
+    assert (rootof(x**3 + x + 3, 1) == rootof(x**3 + x + 3, 1)) is True
+    assert (rootof(x**3 + x + 3, 1) == rootof(x**3 + x + 3, 2)) is False
+    assert (rootof(x**3 + x + 3, 2) == rootof(x**3 + x + 3, 2)) is True
+
+    assert (rootof(x**3 + x + 3, 0) == rootof(y**3 + y + 3, 0)) is True
+    assert (rootof(x**3 + x + 3, 0) == rootof(y**3 + y + 3, 1)) is False
+    assert (rootof(x**3 + x + 3, 1) == rootof(y**3 + y + 3, 1)) is True
+    assert (rootof(x**3 + x + 3, 1) == rootof(y**3 + y + 3, 2)) is False
+    assert (rootof(x**3 + x + 3, 2) == rootof(y**3 + y + 3, 2)) is True
+
+
+def test_CRootOf___eval_Eq__():
+    f = Function('f')
+    eq = x**3 + x + 3
+    r = rootof(eq, 2)
+    r1 = rootof(eq, 1)
+    assert Eq(r, r1) is S.false
+    assert Eq(r, r) is S.true
+    assert unchanged(Eq, r, x)
+    assert Eq(r, 0) is S.false
+    assert Eq(r, S.Infinity) is S.false
+    assert Eq(r, I) is S.false
+    assert unchanged(Eq, r, f(0))
+    sol = solve(eq)
+    for s in sol:
+        if s.is_real:
+            assert Eq(r, s) is S.false
+    r = rootof(eq, 0)
+    for s in sol:
+        if s.is_real:
+            assert Eq(r, s) is S.true
+    eq = x**3 + x + 1
+    sol = solve(eq)
+    assert [Eq(rootof(eq, i), j) for i in range(3) for j in sol
+        ].count(True) == 3
+    assert Eq(rootof(eq, 0), 1 + S.ImaginaryUnit) == False
+
+
+def test_CRootOf_is_real():
+    assert rootof(x**3 + x + 3, 0).is_real is True
+    assert rootof(x**3 + x + 3, 1).is_real is False
+    assert rootof(x**3 + x + 3, 2).is_real is False
+
+
+def test_CRootOf_is_complex():
+    assert rootof(x**3 + x + 3, 0).is_complex is True
+
+
+def test_CRootOf_subs():
+    assert rootof(x**3 + x + 1, 0).subs(x, y) == rootof(y**3 + y + 1, 0)
+
+
+def test_CRootOf_diff():
+    assert rootof(x**3 + x + 1, 0).diff(x) == 0
+    assert rootof(x**3 + x + 1, 0).diff(y) == 0
+
+
+@slow
+def test_CRootOf_evalf():
+    real = rootof(x**3 + x + 3, 0).evalf(n=20)
+
+    assert real.epsilon_eq(Float("-1.2134116627622296341"))
+
+    re, im = rootof(x**3 + x + 3, 1).evalf(n=20).as_real_imag()
+
+    assert re.epsilon_eq( Float("0.60670583138111481707"))
+    assert im.epsilon_eq(-Float("1.45061224918844152650"))
+
+    re, im = rootof(x**3 + x + 3, 2).evalf(n=20).as_real_imag()
+
+    assert re.epsilon_eq(Float("0.60670583138111481707"))
+    assert im.epsilon_eq(Float("1.45061224918844152650"))
+
+    p = legendre_poly(4, x, polys=True)
+    roots = [str(r.n(17)) for r in p.real_roots()]
+    # magnitudes are given by
+    # sqrt(3/S(7) - 2*sqrt(6/S(5))/7)
+    #   and
+    # sqrt(3/S(7) + 2*sqrt(6/S(5))/7)
+    assert roots == [
+            "-0.86113631159405258",
+            "-0.33998104358485626",
+             "0.33998104358485626",
+             "0.86113631159405258",
+             ]
+
+    re = rootof(x**5 - 5*x + 12, 0).evalf(n=20)
+    assert re.epsilon_eq(Float("-1.84208596619025438271"))
+
+    re, im = rootof(x**5 - 5*x + 12, 1).evalf(n=20).as_real_imag()
+    assert re.epsilon_eq(Float("-0.351854240827371999559"))
+    assert im.epsilon_eq(Float("-1.709561043370328882010"))
+
+    re, im = rootof(x**5 - 5*x + 12, 2).evalf(n=20).as_real_imag()
+    assert re.epsilon_eq(Float("-0.351854240827371999559"))
+    assert im.epsilon_eq(Float("+1.709561043370328882010"))
+
+    re, im = rootof(x**5 - 5*x + 12, 3).evalf(n=20).as_real_imag()
+    assert re.epsilon_eq(Float("+1.272897223922499190910"))
+    assert im.epsilon_eq(Float("-0.719798681483861386681"))
+
+    re, im = rootof(x**5 - 5*x + 12, 4).evalf(n=20).as_real_imag()
+    assert re.epsilon_eq(Float("+1.272897223922499190910"))
+    assert im.epsilon_eq(Float("+0.719798681483861386681"))
+
+    # issue 6393
+    assert str(rootof(x**5 + 2*x**4 + x**3 - 68719476736, 0).n(3)) == '147.'
+    eq = (531441*x**11 + 3857868*x**10 + 13730229*x**9 + 32597882*x**8 +
+        55077472*x**7 + 60452000*x**6 + 32172064*x**5 - 4383808*x**4 -
+        11942912*x**3 - 1506304*x**2 + 1453312*x + 512)
+    a, b = rootof(eq, 1).n(2).as_real_imag()
+    c, d = rootof(eq, 2).n(2).as_real_imag()
+    assert a == c
+    assert b < d
+    assert b == -d
+    # issue 6451
+    r = rootof(legendre_poly(64, x), 7)
+    assert r.n(2) == r.n(100).n(2)
+    # issue 9019
+    r0 = rootof(x**2 + 1, 0, radicals=False)
+    r1 = rootof(x**2 + 1, 1, radicals=False)
+    assert r0.n(4) == Float(-1.0, 4) * I
+    assert r1.n(4) == Float(1.0, 4) * I
+
+    # make sure verification is used in case a max/min traps the "root"
+    assert str(rootof(4*x**5 + 16*x**3 + 12*x**2 + 7, 0).n(3)) == '-0.976'
+
+    # watch out for UnboundLocalError
+    c = CRootOf(90720*x**6 - 4032*x**4 + 84*x**2 - 1, 0)
+    assert c._eval_evalf(2)  # doesn't fail
+
+    # watch out for imaginary parts that don't want to evaluate
+    assert str(RootOf(x**16 + 32*x**14 + 508*x**12 + 5440*x**10 +
+        39510*x**8 + 204320*x**6 + 755548*x**4 + 1434496*x**2 +
+        877969, 10).n(2)) == '-3.4*I'
+    assert abs(RootOf(x**4 + 10*x**2 + 1, 0).n(2)) < 0.4
+
+    # check reset and args
+    r = [RootOf(x**3 + x + 3, i) for i in range(3)]
+    r[0]._reset()
+    for ri in r:
+        i = ri._get_interval()
+        ri.n(2)
+        assert i != ri._get_interval()
+        ri._reset()
+        assert i == ri._get_interval()
+        assert i == i.func(*i.args)
+
+
+def test_issue_24978():
+    # Irreducible poly with negative leading coeff is normalized
+    # (factor of -1 is extracted), before being stored as CRootOf.poly.
+    f = -x**2 + 2
+    r = CRootOf(f, 0)
+    assert r.poly.as_expr() == x**2 - 2
+    # An action that prompts calculation of an interval puts r.poly in
+    # the cache.
+    r.n()
+    assert r.poly in rootoftools._reals_cache
+
+
+def test_CRootOf_evalf_caching_bug():
+    r = rootof(x**5 - 5*x + 12, 1)
+    r.n()
+    a = r._get_interval()
+    r = rootof(x**5 - 5*x + 12, 1)
+    r.n()
+    b = r._get_interval()
+    assert a == b
+
+
+def test_CRootOf_real_roots():
+    assert Poly(x**5 + x + 1).real_roots() == [rootof(x**3 - x**2 + 1, 0)]
+    assert Poly(x**5 + x + 1).real_roots(radicals=False) == [rootof(
+        x**3 - x**2 + 1, 0)]
+
+    # https://github.com/sympy/sympy/issues/20902
+    p = Poly(-3*x**4 - 10*x**3 - 12*x**2 - 6*x - 1, x, domain='ZZ')
+    assert CRootOf.real_roots(p) == [S(-1), S(-1), S(-1), S(-1)/3]
+
+
+def test_CRootOf_all_roots():
+    assert Poly(x**5 + x + 1).all_roots() == [
+        rootof(x**3 - x**2 + 1, 0),
+        Rational(-1, 2) - sqrt(3)*I/2,
+        Rational(-1, 2) + sqrt(3)*I/2,
+        rootof(x**3 - x**2 + 1, 1),
+        rootof(x**3 - x**2 + 1, 2),
+    ]
+
+    assert Poly(x**5 + x + 1).all_roots(radicals=False) == [
+        rootof(x**3 - x**2 + 1, 0),
+        rootof(x**2 + x + 1, 0, radicals=False),
+        rootof(x**2 + x + 1, 1, radicals=False),
+        rootof(x**3 - x**2 + 1, 1),
+        rootof(x**3 - x**2 + 1, 2),
+    ]
+
+
+def test_CRootOf_eval_rational():
+    p = legendre_poly(4, x, polys=True)
+    roots = [r.eval_rational(n=18) for r in p.real_roots()]
+    for root in roots:
+        assert isinstance(root, Rational)
+    roots = [str(root.n(17)) for root in roots]
+    assert roots == [
+            "-0.86113631159405258",
+            "-0.33998104358485626",
+             "0.33998104358485626",
+             "0.86113631159405258",
+             ]
+
+
+def test_CRootOf_lazy():
+    # irreducible poly with both real and complex roots:
+    f = Poly(x**3 + 2*x + 2)
+
+    # real root:
+    CRootOf.clear_cache()
+    r = CRootOf(f, 0)
+    # Not yet in cache, after construction:
+    assert r.poly not in rootoftools._reals_cache
+    assert r.poly not in rootoftools._complexes_cache
+    r.evalf()
+    # In cache after evaluation:
+    assert r.poly in rootoftools._reals_cache
+    assert r.poly not in rootoftools._complexes_cache
+
+    # complex root:
+    CRootOf.clear_cache()
+    r = CRootOf(f, 1)
+    # Not yet in cache, after construction:
+    assert r.poly not in rootoftools._reals_cache
+    assert r.poly not in rootoftools._complexes_cache
+    r.evalf()
+    # In cache after evaluation:
+    assert r.poly in rootoftools._reals_cache
+    assert r.poly in rootoftools._complexes_cache
+
+    # composite poly with both real and complex roots:
+    f = Poly((x**2 - 2)*(x**2 + 1))
+
+    # real root:
+    CRootOf.clear_cache()
+    r = CRootOf(f, 0)
+    # In cache immediately after construction:
+    assert r.poly in rootoftools._reals_cache
+    assert r.poly not in rootoftools._complexes_cache
+
+    # complex root:
+    CRootOf.clear_cache()
+    r = CRootOf(f, 2)
+    # In cache immediately after construction:
+    assert r.poly in rootoftools._reals_cache
+    assert r.poly in rootoftools._complexes_cache
+
+
+def test_RootSum___new__():
+    f = x**3 + x + 3
+
+    g = Lambda(r, log(r*x))
+    s = RootSum(f, g)
+
+    assert isinstance(s, RootSum) is True
+
+    assert RootSum(f**2, g) == 2*RootSum(f, g)
+    assert RootSum((x - 7)*f**3, g) == log(7*x) + 3*RootSum(f, g)
+
+    # issue 5571
+    assert hash(RootSum((x - 7)*f**3, g)) == hash(log(7*x) + 3*RootSum(f, g))
+
+    raises(MultivariatePolynomialError, lambda: RootSum(x**3 + x + y))
+    raises(ValueError, lambda: RootSum(x**2 + 3, lambda x: x))
+
+    assert RootSum(f, exp) == RootSum(f, Lambda(x, exp(x)))
+    assert RootSum(f, log) == RootSum(f, Lambda(x, log(x)))
+
+    assert isinstance(RootSum(f, auto=False), RootSum) is True
+
+    assert RootSum(f) == 0
+    assert RootSum(f, Lambda(x, x)) == 0
+    assert RootSum(f, Lambda(x, x**2)) == -2
+
+    assert RootSum(f, Lambda(x, 1)) == 3
+    assert RootSum(f, Lambda(x, 2)) == 6
+
+    assert RootSum(f, auto=False).is_commutative is True
+
+    assert RootSum(f, Lambda(x, 1/(x + x**2))) == Rational(11, 3)
+    assert RootSum(f, Lambda(x, y/(x + x**2))) == Rational(11, 3)*y
+
+    assert RootSum(x**2 - 1, Lambda(x, 3*x**2), x) == 6
+    assert RootSum(x**2 - y, Lambda(x, 3*x**2), x) == 6*y
+
+    assert RootSum(x**2 - 1, Lambda(x, z*x**2), x) == 2*z
+    assert RootSum(x**2 - y, Lambda(x, z*x**2), x) == 2*z*y
+
+    assert RootSum(
+        x**2 - 1, Lambda(x, exp(x)), quadratic=True) == exp(-1) + exp(1)
+
+    assert RootSum(x**3 + a*x + a**3, tan, x) == \
+        RootSum(x**3 + x + 1, Lambda(x, tan(a*x)))
+    assert RootSum(a**3*x**3 + a*x + 1, tan, x) == \
+        RootSum(x**3 + x + 1, Lambda(x, tan(x/a)))
+
+
+def test_RootSum_free_symbols():
+    assert RootSum(x**3 + x + 3, Lambda(r, exp(r))).free_symbols == set()
+    assert RootSum(x**3 + x + 3, Lambda(r, exp(a*r))).free_symbols == {a}
+    assert RootSum(
+        x**3 + x + y, Lambda(r, exp(a*r)), x).free_symbols == {a, y}
+
+
+def test_RootSum___eq__():
+    f = Lambda(x, exp(x))
+
+    assert (RootSum(x**3 + x + 1, f) == RootSum(x**3 + x + 1, f)) is True
+    assert (RootSum(x**3 + x + 1, f) == RootSum(y**3 + y + 1, f)) is True
+
+    assert (RootSum(x**3 + x + 1, f) == RootSum(x**3 + x + 2, f)) is False
+    assert (RootSum(x**3 + x + 1, f) == RootSum(y**3 + y + 2, f)) is False
+
+
+def test_RootSum_doit():
+    rs = RootSum(x**2 + 1, exp)
+
+    assert isinstance(rs, RootSum) is True
+    assert rs.doit() == exp(-I) + exp(I)
+
+    rs = RootSum(x**2 + a, exp, x)
+
+    assert isinstance(rs, RootSum) is True
+    assert rs.doit() == exp(-sqrt(-a)) + exp(sqrt(-a))
+
+
+def test_RootSum_evalf():
+    rs = RootSum(x**2 + 1, exp)
+
+    assert rs.evalf(n=20, chop=True).epsilon_eq(Float("1.0806046117362794348"))
+    assert rs.evalf(n=15, chop=True).epsilon_eq(Float("1.08060461173628"))
+
+    rs = RootSum(x**2 + a, exp, x)
+
+    assert rs.evalf() == rs
+
+
+def test_RootSum_diff():
+    f = x**3 + x + 3
+
+    g = Lambda(r, exp(r*x))
+    h = Lambda(r, r*exp(r*x))
+
+    assert RootSum(f, g).diff(x) == RootSum(f, h)
+
+
+def test_RootSum_subs():
+    f = x**3 + x + 3
+    g = Lambda(r, exp(r*x))
+
+    F = y**3 + y + 3
+    G = Lambda(r, exp(r*y))
+
+    assert RootSum(f, g).subs(y, 1) == RootSum(f, g)
+    assert RootSum(f, g).subs(x, y) == RootSum(F, G)
+
+
+def test_RootSum_rational():
+    assert RootSum(
+        z**5 - z + 1, Lambda(z, z/(x - z))) == (4*x - 5)/(x**5 - x + 1)
+
+    f = 161*z**3 + 115*z**2 + 19*z + 1
+    g = Lambda(z, z*log(
+        -3381*z**4/4 - 3381*z**3/4 - 625*z**2/2 - z*Rational(125, 2) - 5 + exp(x)))
+
+    assert RootSum(f, g).diff(x) == -(
+        (5*exp(2*x) - 6*exp(x) + 4)*exp(x)/(exp(3*x) - exp(2*x) + 1))/7
+
+
+def test_RootSum_independent():
+    f = (x**3 - a)**2*(x**4 - b)**3
+
+    g = Lambda(x, 5*tan(x) + 7)
+    h = Lambda(x, tan(x))
+
+    r0 = RootSum(x**3 - a, h, x)
+    r1 = RootSum(x**4 - b, h, x)
+
+    assert RootSum(f, g, x).as_ordered_terms() == [10*r0, 15*r1, 126]
+
+
+def test_issue_7876():
+    l1 = Poly(x**6 - x + 1, x).all_roots()
+    l2 = [rootof(x**6 - x + 1, i) for i in range(6)]
+    assert frozenset(l1) == frozenset(l2)
+
+
+def test_issue_8316():
+    f = Poly(7*x**8 - 9)
+    assert len(f.all_roots()) == 8
+    f = Poly(7*x**8 - 10)
+    assert len(f.all_roots()) == 8
+
+
+def test__imag_count():
+    from sympy.polys.rootoftools import _imag_count_of_factor
+    def imag_count(p):
+        return sum(_imag_count_of_factor(f)*m for f, m in
+        p.factor_list()[1])
+    assert imag_count(Poly(x**6 + 10*x**2 + 1)) == 2
+    assert imag_count(Poly(x**2)) == 0
+    assert imag_count(Poly([1]*3 + [-1], x)) == 0
+    assert imag_count(Poly(x**3 + 1)) == 0
+    assert imag_count(Poly(x**2 + 1)) == 2
+    assert imag_count(Poly(x**2 - 1)) == 0
+    assert imag_count(Poly(x**4 - 1)) == 2
+    assert imag_count(Poly(x**4 + 1)) == 0
+    assert imag_count(Poly([1, 2, 3], x)) == 0
+    assert imag_count(Poly(x**3 + x + 1)) == 0
+    assert imag_count(Poly(x**4 + x + 1)) == 0
+    def q(r1, r2, p):
+        return Poly(((x - r1)*(x - r2)).subs(x, x**p), x)
+    assert imag_count(q(-1, -2, 2)) == 4
+    assert imag_count(q(-1, 2, 2)) == 2
+    assert imag_count(q(1, 2, 2)) == 0
+    assert imag_count(q(1, 2, 4)) == 4
+    assert imag_count(q(-1, 2, 4)) == 2
+    assert imag_count(q(-1, -2, 4)) == 0
+
+
+def test_RootOf_is_imaginary():
+    r = RootOf(x**4 + 4*x**2 + 1, 1)
+    i = r._get_interval()
+    assert r.is_imaginary and i.ax*i.bx <= 0
+
+
+def test_is_disjoint():
+    eq = x**3 + 5*x + 1
+    ir = rootof(eq, 0)._get_interval()
+    ii = rootof(eq, 1)._get_interval()
+    assert ir.is_disjoint(ii)
+    assert ii.is_disjoint(ir)
+
+
+def test_pure_key_dict():
+    p = D()
+    assert (x in p) is False
+    assert (1 in p) is False
+    p[x] = 1
+    assert x in p
+    assert y in p
+    assert p[y] == 1
+    raises(KeyError, lambda: p[1])
+    def dont(k):
+        p[k] = 2
+    raises(ValueError, lambda: dont(1))
+
+
+@slow
+def test_eval_approx_relative():
+    CRootOf.clear_cache()
+    t = [CRootOf(x**3 + 10*x + 1, i) for i in range(3)]
+    assert [i.eval_rational(1e-1) for i in t] == [
+        Rational(-21, 220), Rational(15, 256) - I*805/256,
+        Rational(15, 256) + I*805/256]
+    t[0]._reset()
+    assert [i.eval_rational(1e-1, 1e-4) for i in t] == [
+        Rational(-21, 220), Rational(3275, 65536) - I*414645/131072,
+        Rational(3275, 65536) + I*414645/131072]
+    assert S(t[0]._get_interval().dx) < 1e-1
+    assert S(t[1]._get_interval().dx) < 1e-1
+    assert S(t[1]._get_interval().dy) < 1e-4
+    assert S(t[2]._get_interval().dx) < 1e-1
+    assert S(t[2]._get_interval().dy) < 1e-4
+    t[0]._reset()
+    assert [i.eval_rational(1e-4, 1e-4) for i in t] == [
+        Rational(-2001, 20020), Rational(6545, 131072) - I*414645/131072,
+        Rational(6545, 131072) + I*414645/131072]
+    assert S(t[0]._get_interval().dx) < 1e-4
+    assert S(t[1]._get_interval().dx) < 1e-4
+    assert S(t[1]._get_interval().dy) < 1e-4
+    assert S(t[2]._get_interval().dx) < 1e-4
+    assert S(t[2]._get_interval().dy) < 1e-4
+    # in the following, the actual relative precision is
+    # less than tested, but it should never be greater
+    t[0]._reset()
+    assert [i.eval_rational(n=2) for i in t] == [
+        Rational(-202201, 2024022), Rational(104755, 2097152) - I*6634255/2097152,
+        Rational(104755, 2097152) + I*6634255/2097152]
+    assert abs(S(t[0]._get_interval().dx)/t[0]) < 1e-2
+    assert abs(S(t[1]._get_interval().dx)/t[1]).n() < 1e-2
+    assert abs(S(t[1]._get_interval().dy)/t[1]).n() < 1e-2
+    assert abs(S(t[2]._get_interval().dx)/t[2]).n() < 1e-2
+    assert abs(S(t[2]._get_interval().dy)/t[2]).n() < 1e-2
+    t[0]._reset()
+    assert [i.eval_rational(n=3) for i in t] == [
+        Rational(-202201, 2024022), Rational(1676045, 33554432) - I*106148135/33554432,
+        Rational(1676045, 33554432) + I*106148135/33554432]
+    assert abs(S(t[0]._get_interval().dx)/t[0]) < 1e-3
+    assert abs(S(t[1]._get_interval().dx)/t[1]).n() < 1e-3
+    assert abs(S(t[1]._get_interval().dy)/t[1]).n() < 1e-3
+    assert abs(S(t[2]._get_interval().dx)/t[2]).n() < 1e-3
+    assert abs(S(t[2]._get_interval().dy)/t[2]).n() < 1e-3
+
+    t[0]._reset()
+    a = [i.eval_approx(2) for i in t]
+    assert [str(i) for i in a] == [
+        '-0.10', '0.05 - 3.2*I', '0.05 + 3.2*I']
+    assert all(abs(((a[i] - t[i])/t[i]).n()) < 1e-2 for i in range(len(a)))
+
+
+def test_issue_15920():
+    r = rootof(x**5 - x + 1, 0)
+    p = Integral(x, (x, 1, y))
+    assert unchanged(Eq, r, p)
+
+
+def test_issue_19113():
+    eq = y**3 - y + 1
+    # generator is a canonical x in RootOf
+    assert str(Poly(eq).real_roots()) == '[CRootOf(x**3 - x + 1, 0)]'
+    assert str(Poly(eq.subs(y, tan(y))).real_roots()
+        ) == '[CRootOf(x**3 - x + 1, 0)]'
+    assert str(Poly(eq.subs(y, tan(x))).real_roots()
+        ) == '[CRootOf(x**3 - x + 1, 0)]'

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_specialpolys.py

@@ -0,0 +1,152 @@
+"""Tests for functions for generating interesting polynomials. """
+
+from sympy.core.add import Add
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.ntheory.generate import prime
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.polytools import Poly
+from sympy.utilities.iterables import permute_signs
+from sympy.testing.pytest import raises
+
+from sympy.polys.specialpolys import (
+    swinnerton_dyer_poly,
+    cyclotomic_poly,
+    symmetric_poly,
+    random_poly,
+    interpolating_poly,
+    fateman_poly_F_1,
+    dmp_fateman_poly_F_1,
+    fateman_poly_F_2,
+    dmp_fateman_poly_F_2,
+    fateman_poly_F_3,
+    dmp_fateman_poly_F_3,
+)
+
+from sympy.abc import x, y, z
+
+
+def test_swinnerton_dyer_poly():
+    raises(ValueError, lambda: swinnerton_dyer_poly(0, x))
+
+    assert swinnerton_dyer_poly(1, x, polys=True) == Poly(x**2 - 2)
+
+    assert swinnerton_dyer_poly(1, x) == x**2 - 2
+    assert swinnerton_dyer_poly(2, x) == x**4 - 10*x**2 + 1
+    assert swinnerton_dyer_poly(
+        3, x) == x**8 - 40*x**6 + 352*x**4 - 960*x**2 + 576
+    # we only need to check that the polys arg works but
+    # we may as well test that the roots are correct
+    p = [sqrt(prime(i)) for i in range(1, 5)]
+    assert str([i.n(3) for i in
+        swinnerton_dyer_poly(4, polys=True).all_roots()]
+        ) == str(sorted([Add(*i).n(3) for i in permute_signs(p)]))
+
+
+def test_cyclotomic_poly():
+    raises(ValueError, lambda: cyclotomic_poly(0, x))
+
+    assert cyclotomic_poly(1, x, polys=True) == Poly(x - 1)
+
+    assert cyclotomic_poly(1, x) == x - 1
+    assert cyclotomic_poly(2, x) == x + 1
+    assert cyclotomic_poly(3, x) == x**2 + x + 1
+    assert cyclotomic_poly(4, x) == x**2 + 1
+    assert cyclotomic_poly(5, x) == x**4 + x**3 + x**2 + x + 1
+    assert cyclotomic_poly(6, x) == x**2 - x + 1
+
+
+def test_symmetric_poly():
+    raises(ValueError, lambda: symmetric_poly(-1, x, y, z))
+    raises(ValueError, lambda: symmetric_poly(5, x, y, z))
+
+    assert symmetric_poly(1, x, y, z, polys=True) == Poly(x + y + z)
+    assert symmetric_poly(1, (x, y, z), polys=True) == Poly(x + y + z)
+
+    assert symmetric_poly(0, x, y, z) == 1
+    assert symmetric_poly(1, x, y, z) == x + y + z
+    assert symmetric_poly(2, x, y, z) == x*y + x*z + y*z
+    assert symmetric_poly(3, x, y, z) == x*y*z
+
+
+def test_random_poly():
+    poly = random_poly(x, 10, -100, 100, polys=False)
+
+    assert Poly(poly).degree() == 10
+    assert all(-100 <= coeff <= 100 for coeff in Poly(poly).coeffs()) is True
+
+    poly = random_poly(x, 10, -100, 100, polys=True)
+
+    assert poly.degree() == 10
+    assert all(-100 <= coeff <= 100 for coeff in poly.coeffs()) is True
+
+
+def test_interpolating_poly():
+    x0, x1, x2, x3, y0, y1, y2, y3 = symbols('x:4, y:4')
+
+    assert interpolating_poly(0, x) == 0
+    assert interpolating_poly(1, x) == y0
+
+    assert interpolating_poly(2, x) == \
+        y0*(x - x1)/(x0 - x1) + y1*(x - x0)/(x1 - x0)
+
+    assert interpolating_poly(3, x) == \
+        y0*(x - x1)*(x - x2)/((x0 - x1)*(x0 - x2)) + \
+        y1*(x - x0)*(x - x2)/((x1 - x0)*(x1 - x2)) + \
+        y2*(x - x0)*(x - x1)/((x2 - x0)*(x2 - x1))
+
+    assert interpolating_poly(4, x) == \
+        y0*(x - x1)*(x - x2)*(x - x3)/((x0 - x1)*(x0 - x2)*(x0 - x3)) + \
+        y1*(x - x0)*(x - x2)*(x - x3)/((x1 - x0)*(x1 - x2)*(x1 - x3)) + \
+        y2*(x - x0)*(x - x1)*(x - x3)/((x2 - x0)*(x2 - x1)*(x2 - x3)) + \
+        y3*(x - x0)*(x - x1)*(x - x2)/((x3 - x0)*(x3 - x1)*(x3 - x2))
+
+    raises(ValueError, lambda:
+        interpolating_poly(2, x, (x, 2), (1, 3)))
+    raises(ValueError, lambda:
+        interpolating_poly(2, x, (x + y, 2), (1, 3)))
+    raises(ValueError, lambda:
+        interpolating_poly(2, x + y, (x, 2), (1, 3)))
+    raises(ValueError, lambda:
+        interpolating_poly(2, 3, (4, 5), (6, 7)))
+    raises(ValueError, lambda:
+        interpolating_poly(2, 3, (4, 5), (6, 7, 8)))
+    assert interpolating_poly(0, x, (1, 2), (3, 4)) == 0
+    assert interpolating_poly(1, x, (1, 2), (3, 4)) == 3
+    assert interpolating_poly(2, x, (1, 2), (3, 4)) == x + 2
+
+
+def test_fateman_poly_F_1():
+    f, g, h = fateman_poly_F_1(1)
+    F, G, H = dmp_fateman_poly_F_1(1, ZZ)
+
+    assert [ t.rep.to_list() for t in [f, g, h] ] == [F, G, H]
+
+    f, g, h = fateman_poly_F_1(3)
+    F, G, H = dmp_fateman_poly_F_1(3, ZZ)
+
+    assert [ t.rep.to_list() for t in [f, g, h] ] == [F, G, H]
+
+
+def test_fateman_poly_F_2():
+    f, g, h = fateman_poly_F_2(1)
+    F, G, H = dmp_fateman_poly_F_2(1, ZZ)
+
+    assert [ t.rep.to_list() for t in [f, g, h] ] == [F, G, H]
+
+    f, g, h = fateman_poly_F_2(3)
+    F, G, H = dmp_fateman_poly_F_2(3, ZZ)
+
+    assert [ t.rep.to_list() for t in [f, g, h] ] == [F, G, H]
+
+
+def test_fateman_poly_F_3():
+    f, g, h = fateman_poly_F_3(1)
+    F, G, H = dmp_fateman_poly_F_3(1, ZZ)
+
+    assert [ t.rep.to_list() for t in [f, g, h] ] == [F, G, H]
+
+    f, g, h = fateman_poly_F_3(3)
+    F, G, H = dmp_fateman_poly_F_3(3, ZZ)
+
+    assert [ t.rep.to_list() for t in [f, g, h] ] == [F, G, H]

evalkit_internvl/lib/python3.10/site-packages/sympy/polys/tests/test_sqfreetools.py

@@ -0,0 +1,160 @@
+"""Tests for square-free decomposition algorithms and related tools. """
+
+from sympy.polys.rings import ring
+from sympy.polys.domains import FF, ZZ, QQ
+from sympy.polys.specialpolys import f_polys
+
+from sympy.testing.pytest import raises
+from sympy.external.gmpy import MPQ
+
+f_0, f_1, f_2, f_3, f_4, f_5, f_6 = f_polys()
+
+def test_dup_sqf():
+    R, x = ring("x", ZZ)
+
+    assert R.dup_sqf_part(0) == 0
+    assert R.dup_sqf_p(0) is True
+
+    assert R.dup_sqf_part(7) == 1
+    assert R.dup_sqf_p(7) is True
+
+    assert R.dup_sqf_part(2*x + 2) == x + 1
+    assert R.dup_sqf_p(2*x + 2) is True
+
+    assert R.dup_sqf_part(x**3 + x + 1) == x**3 + x + 1
+    assert R.dup_sqf_p(x**3 + x + 1) is True
+
+    assert R.dup_sqf_part(-x**3 + x + 1) == x**3 - x - 1
+    assert R.dup_sqf_p(-x**3 + x + 1) is True
+
+    assert R.dup_sqf_part(2*x**3 + 3*x**2) == 2*x**2 + 3*x
+    assert R.dup_sqf_p(2*x**3 + 3*x**2) is False
+
+    assert R.dup_sqf_part(-2*x**3 + 3*x**2) == 2*x**2 - 3*x
+    assert R.dup_sqf_p(-2*x**3 + 3*x**2) is False
+
+    assert R.dup_sqf_list(0) == (0, [])
+    assert R.dup_sqf_list(1) == (1, [])
+
+    assert R.dup_sqf_list(x) == (1, [(x, 1)])
+    assert R.dup_sqf_list(2*x**2) == (2, [(x, 2)])
+    assert R.dup_sqf_list(3*x**3) == (3, [(x, 3)])
+
+    assert R.dup_sqf_list(-x**5 + x**4 + x - 1) == \
+        (-1, [(x**3 + x**2 + x + 1, 1), (x - 1, 2)])
+    assert R.dup_sqf_list(x**8 + 6*x**6 + 12*x**4 + 8*x**2) == \
+        ( 1, [(x, 2), (x**2 + 2, 3)])
+
+    assert R.dup_sqf_list(2*x**2 + 4*x + 2) == (2, [(x + 1, 2)])
+
+    R, x = ring("x", QQ)
+    assert R.dup_sqf_list(2*x**2 + 4*x + 2) == (2, [(x + 1, 2)])
+
+    R, x = ring("x", FF(2))
+    assert R.dup_sqf_list(x**2 + 1) == (1, [(x + 1, 2)])
+
+    R, x = ring("x", FF(3))
+    assert R.dup_sqf_list(x**10 + 2*x**7 + 2*x**4 + x) == \
+        (1, [(x, 1),
+             (x + 1, 3),
+             (x + 2, 6)])
+
+    R1, x = ring("x", ZZ)
+    R2, y = ring("y", FF(3))
+
+    f = x**3 + 1
+    g = y**3 + 1
+
+    assert R1.dup_sqf_part(f) == f
+    assert R2.dup_sqf_part(g) == y + 1
+
+    assert R1.dup_sqf_p(f) is True
+    assert R2.dup_sqf_p(g) is False
+
+    R, x, y = ring("x,y", ZZ)
+
+    A = x**4 - 3*x**2 + 6
+    D = x**6 - 5*x**4 + 5*x**2 + 4
+
+    f, g = D, R.dmp_sub(A, R.dmp_mul(R.dmp_diff(D, 1), y))
+    res = R.dmp_resultant(f, g)
+    h = (4*y**2 + 1).drop(x)
+
+    assert R.drop(x).dup_sqf_list(res) == (45796, [(h, 3)])
+
+    Rt, t = ring("t", ZZ)
+    R, x = ring("x", Rt)
+    assert R.dup_sqf_list_include(t**3*x**2) == [(t**3, 1), (x, 2)]
+
+
+def test_dmp_sqf():
+    R, x, y = ring("x,y", ZZ)
+    assert R.dmp_sqf_part(0) == 0
+    assert R.dmp_sqf_p(0) is True
+
+    assert R.dmp_sqf_part(7) == 1
+    assert R.dmp_sqf_p(7) is True
+
+    assert R.dmp_sqf_list(3) == (3, [])
+    assert R.dmp_sqf_list_include(3) == [(3, 1)]
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    assert R.dmp_sqf_p(f_0) is True
+    assert R.dmp_sqf_p(f_0**2) is False
+    assert R.dmp_sqf_p(f_1) is True
+    assert R.dmp_sqf_p(f_1**2) is False
+    assert R.dmp_sqf_p(f_2) is True
+    assert R.dmp_sqf_p(f_2**2) is False
+    assert R.dmp_sqf_p(f_3) is True
+    assert R.dmp_sqf_p(f_3**2) is False
+    assert R.dmp_sqf_p(f_5) is False
+    assert R.dmp_sqf_p(f_5**2) is False
+
+    assert R.dmp_sqf_p(f_4) is True
+    assert R.dmp_sqf_part(f_4) == -f_4
+
+    assert R.dmp_sqf_part(f_5) == x + y - z
+
+    R, x, y, z, t = ring("x,y,z,t", ZZ)
+    assert R.dmp_sqf_p(f_6) is True
+    assert R.dmp_sqf_part(f_6) == f_6
+
+    R, x = ring("x", ZZ)
+    f = -x**5 + x**4 + x - 1
+
+    assert R.dmp_sqf_list(f) == (-1, [(x**3 + x**2 + x + 1, 1), (x - 1, 2)])
+    assert R.dmp_sqf_list_include(f) == [(-x**3 - x**2 - x - 1, 1), (x - 1, 2)]
+
+    R, x, y = ring("x,y", ZZ)
+    f = -x**5 + x**4 + x - 1
+
+    assert R.dmp_sqf_list(f) == (-1, [(x**3 + x**2 + x + 1, 1), (x - 1, 2)])
+    assert R.dmp_sqf_list_include(f) == [(-x**3 - x**2 - x - 1, 1), (x - 1, 2)]
+
+    f = -x**2 + 2*x - 1
+    assert R.dmp_sqf_list_include(f) == [(-1, 1), (x - 1, 2)]
+
+    f = (y**2 + 1)**2*(x**2 + 2*x + 2)
+    assert R.dmp_sqf_p(f) is False
+    assert R.dmp_sqf_list(f) == (1, [(x**2 + 2*x + 2, 1), (y**2 + 1, 2)])
+
+    R, x, y = ring("x,y", FF(2))
+    raises(NotImplementedError, lambda: R.dmp_sqf_list(y**2 + 1))
+
+
+def test_dup_gff_list():
+    R, x = ring("x", ZZ)
+
+    f = x**5 + 2*x**4 - x**3 - 2*x**2
+    assert R.dup_gff_list(f) == [(x, 1), (x + 2, 4)]
+
+    g = x**9 - 20*x**8 + 166*x**7 - 744*x**6 + 1965*x**5 - 3132*x**4 + 2948*x**3 - 1504*x**2 + 320*x
+    assert R.dup_gff_list(g) == [(x**2 - 5*x + 4, 1), (x**2 - 5*x + 4, 2), (x, 3)]
+
+    raises(ValueError, lambda: R.dup_gff_list(0))
+
+def test_issue_26178():
+    R, x, y, z = ring(['x', 'y', 'z'], QQ)
+    assert (x**2 - 2*y**2 + 1).sqf_list() == (MPQ(1,1), [(x**2 - 2*y**2 + 1, 1)])
+    assert (x**2 - 2*z**2 + 1).sqf_list() == (MPQ(1,1), [(x**2 - 2*z**2 + 1, 1)])
+    assert (y**2 - 2*z**2 + 1).sqf_list() == (MPQ(1,1), [(y**2 - 2*z**2 + 1, 1)])

evalkit_internvl/lib/python3.10/site-packages/sympy/stats/__pycache__/crv_types.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21065f3ec96be31a86edd9d79fe5d1446785eb2778d8e763c82c51dc673e5d78
+size 129032

evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: google-auth-oauthlib
+Version: 1.2.1
+Summary: Google Authentication Library
+Home-page: https://github.com/GoogleCloudPlatform/google-auth-library-python-oauthlib
+Author: Google Cloud Platform
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Keywords: google auth oauth client oauthlib
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: google-auth >=2.15.0
+Requires-Dist: requests-oauthlib >=0.7.0
+Provides-Extra: tool
+Requires-Dist: click >=6.0.0 ; extra == 'tool'
+
+oauthlib integration for Google Auth
+====================================
+
+|pypi|
+
+This library provides `oauthlib`_ integration with `google-auth`_.
+
+.. |build| image:: https://travis-ci.org/googleapis/google-auth-library-python-oauthlib.svg?branch=main
+   :target: https://googleapis.dev/python/google-auth-oauthlib/latest/index.html
+.. |pypi| image:: https://img.shields.io/pypi/v/google-auth-oauthlib.svg
+   :target: https://pypi.python.org/pypi/google-auth-oauthlib
+
+.. _oauthlib: https://github.com/idan/oauthlib
+.. _google-auth: https://github.com/googleapis/google-auth-library-python
+
+Installing
+----------
+
+You can install using `pip`_::
+
+    $ pip install google-auth-oauthlib
+
+.. _pip: https://pip.pypa.io/en/stable/
+
+Documentation
+-------------
+
+The latest documentation is available at `google-auth-oauthlib.googleapis.dev`_.
+
+.. _google-auth-oauthlib.googleapis.dev: https://googleapis.dev/python/google-auth-oauthlib/latest/index.html
+
+Supported Python Versions
+-------------------------
+Python >= 3.6
+
+
+Unsupported Python Versions
+---------------------------
+
+Python == 2.7, Python == 3.5.
+
+The last version of this library compatible with Python 2.7 and 3.5 is
+`google-auth-oauthlib==0.4.1`.
+
+License
+-------
+
+Apache 2.0 - See `the LICENSE`_ for more information.
+
+.. _the LICENSE: https://github.com/googleapis/google-auth-library-python-oauthlib/blob/main/LICENSE

evalkit_tf437/lib/python3.10/site-packages/google_auth_oauthlib-1.2.1.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+docs
+google_auth_oauthlib
+scripts
+testing

evalkit_tf437/lib/python3.10/site-packages/prompt_toolkit/formatted_text/ansi.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+from string import Formatter
+from typing import Generator
+
+from prompt_toolkit.output.vt100 import BG_ANSI_COLORS, FG_ANSI_COLORS
+from prompt_toolkit.output.vt100 import _256_colors as _256_colors_table
+
+from .base import StyleAndTextTuples
+
+__all__ = [
+    "ANSI",
+    "ansi_escape",
+]
+
+
+class ANSI:
+    """
+    ANSI formatted text.
+    Take something ANSI escaped text, for use as a formatted string. E.g.
+
+    ::
+
+        ANSI('\\x1b[31mhello \\x1b[32mworld')
+
+    Characters between ``\\001`` and ``\\002`` are supposed to have a zero width
+    when printed, but these are literally sent to the terminal output. This can
+    be used for instance, for inserting Final Term prompt commands.  They will
+    be translated into a prompt_toolkit '[ZeroWidthEscape]' fragment.
+    """
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+        self._formatted_text: StyleAndTextTuples = []
+
+        # Default style attributes.
+        self._color: str | None = None
+        self._bgcolor: str | None = None
+        self._bold = False
+        self._underline = False
+        self._strike = False
+        self._italic = False
+        self._blink = False
+        self._reverse = False
+        self._hidden = False
+
+        # Process received text.
+        parser = self._parse_corot()
+        parser.send(None)  # type: ignore
+        for c in value:
+            parser.send(c)
+
+    def _parse_corot(self) -> Generator[None, str, None]:
+        """
+        Coroutine that parses the ANSI escape sequences.
+        """
+        style = ""
+        formatted_text = self._formatted_text
+
+        while True:
+            # NOTE: CSI is a special token within a stream of characters that
+            #       introduces an ANSI control sequence used to set the
+            #       style attributes of the following characters.
+            csi = False
+
+            c = yield
+
+            # Everything between \001 and \002 should become a ZeroWidthEscape.
+            if c == "\001":
+                escaped_text = ""
+                while c != "\002":
+                    c = yield
+                    if c == "\002":
+                        formatted_text.append(("[ZeroWidthEscape]", escaped_text))
+                        c = yield
+                        break
+                    else:
+                        escaped_text += c
+
+            # Check for CSI
+            if c == "\x1b":
+                # Start of color escape sequence.
+                square_bracket = yield
+                if square_bracket == "[":
+                    csi = True
+                else:
+                    continue
+            elif c == "\x9b":
+                csi = True
+
+            if csi:
+                # Got a CSI sequence. Color codes are following.
+                current = ""
+                params = []
+
+                while True:
+                    char = yield
+
+                    # Construct number
+                    if char.isdigit():
+                        current += char
+
+                    # Eval number
+                    else:
+                        # Limit and save number value
+                        params.append(min(int(current or 0), 9999))
+
+                        # Get delimiter token if present
+                        if char == ";":
+                            current = ""
+
+                        # Check and evaluate color codes
+                        elif char == "m":
+                            # Set attributes and token.
+                            self._select_graphic_rendition(params)
+                            style = self._create_style_string()
+                            break
+
+                        # Check and evaluate cursor forward
+                        elif char == "C":
+                            for i in range(params[0]):
+                                # add <SPACE> using current style
+                                formatted_text.append((style, " "))
+                            break
+
+                        else:
+                            # Ignore unsupported sequence.
+                            break
+            else:
+                # Add current character.
+                # NOTE: At this point, we could merge the current character
+                #       into the previous tuple if the style did not change,
+                #       however, it's not worth the effort given that it will
+                #       be "Exploded" once again when it's rendered to the
+                #       output.
+                formatted_text.append((style, c))
+
+    def _select_graphic_rendition(self, attrs: list[int]) -> None:
+        """
+        Taken a list of graphics attributes and apply changes.
+        """
+        if not attrs:
+            attrs = [0]
+        else:
+            attrs = list(attrs[::-1])
+
+        while attrs:
+            attr = attrs.pop()
+
+            if attr in _fg_colors:
+                self._color = _fg_colors[attr]
+            elif attr in _bg_colors:
+                self._bgcolor = _bg_colors[attr]
+            elif attr == 1:
+                self._bold = True
+            # elif attr == 2:
+            #   self._faint = True
+            elif attr == 3:
+                self._italic = True
+            elif attr == 4:
+                self._underline = True
+            elif attr == 5:
+                self._blink = True  # Slow blink
+            elif attr == 6:
+                self._blink = True  # Fast blink
+            elif attr == 7:
+                self._reverse = True
+            elif attr == 8:
+                self._hidden = True
+            elif attr == 9:
+                self._strike = True
+            elif attr == 22:
+                self._bold = False  # Normal intensity
+            elif attr == 23:
+                self._italic = False
+            elif attr == 24:
+                self._underline = False
+            elif attr == 25:
+                self._blink = False
+            elif attr == 27:
+                self._reverse = False
+            elif attr == 28:
+                self._hidden = False
+            elif attr == 29:
+                self._strike = False
+            elif not attr:
+                # Reset all style attributes
+                self._color = None
+                self._bgcolor = None
+                self._bold = False
+                self._underline = False
+                self._strike = False
+                self._italic = False
+                self._blink = False
+                self._reverse = False
+                self._hidden = False
+
+            elif attr in (38, 48) and len(attrs) > 1:
+                n = attrs.pop()
+
+                # 256 colors.
+                if n == 5 and len(attrs) >= 1:
+                    if attr == 38:
+                        m = attrs.pop()
+                        self._color = _256_colors.get(m)
+                    elif attr == 48:
+                        m = attrs.pop()
+                        self._bgcolor = _256_colors.get(m)
+
+                # True colors.
+                if n == 2 and len(attrs) >= 3:
+                    try:
+                        color_str = (
+                            f"#{attrs.pop():02x}{attrs.pop():02x}{attrs.pop():02x}"
+                        )
+                    except IndexError:
+                        pass
+                    else:
+                        if attr == 38:
+                            self._color = color_str
+                        elif attr == 48:
+                            self._bgcolor = color_str
+
+    def _create_style_string(self) -> str:
+        """
+        Turn current style flags into a string for usage in a formatted text.
+        """
+        result = []
+        if self._color:
+            result.append(self._color)
+        if self._bgcolor:
+            result.append("bg:" + self._bgcolor)
+        if self._bold:
+            result.append("bold")
+        if self._underline:
+            result.append("underline")
+        if self._strike:
+            result.append("strike")
+        if self._italic:
+            result.append("italic")
+        if self._blink:
+            result.append("blink")
+        if self._reverse:
+            result.append("reverse")
+        if self._hidden:
+            result.append("hidden")
+
+        return " ".join(result)
+
+    def __repr__(self) -> str:
+        return f"ANSI({self.value!r})"
+
+    def __pt_formatted_text__(self) -> StyleAndTextTuples:
+        return self._formatted_text
+
+    def format(self, *args: str, **kwargs: str) -> ANSI:
+        """
+        Like `str.format`, but make sure that the arguments are properly
+        escaped. (No ANSI escapes can be injected.)
+        """
+        return ANSI(FORMATTER.vformat(self.value, args, kwargs))
+
+    def __mod__(self, value: object) -> ANSI:
+        """
+        ANSI('<b>%s</b>') % value
+        """
+        if not isinstance(value, tuple):
+            value = (value,)
+
+        value = tuple(ansi_escape(i) for i in value)
+        return ANSI(self.value % value)
+
+
+# Mapping of the ANSI color codes to their names.
+_fg_colors = {v: k for k, v in FG_ANSI_COLORS.items()}
+_bg_colors = {v: k for k, v in BG_ANSI_COLORS.items()}
+
+# Mapping of the escape codes for 256colors to their 'ffffff' value.
+_256_colors = {}
+
+for i, (r, g, b) in enumerate(_256_colors_table.colors):
+    _256_colors[i] = f"#{r:02x}{g:02x}{b:02x}"
+
+
+def ansi_escape(text: object) -> str:
+    """
+    Replace characters with a special meaning.
+    """
+    return str(text).replace("\x1b", "?").replace("\b", "?")
+
+
+class ANSIFormatter(Formatter):
+    def format_field(self, value: object, format_spec: str) -> str:
+        return ansi_escape(format(value, format_spec))
+
+
+FORMATTER = ANSIFormatter()

evalkit_tf437/lib/python3.10/site-packages/xformers/_deprecation_warning.py

@@ -0,0 +1,12 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import warnings
+
+
+def deprecated_function(self):
+    name = repr(self)  # self.__name__
+    msg = f"{name} is deprecated and is not maintained anymore. It might be removed in a future version of xFormers"
+    warnings.warn(msg, FutureWarning, stacklevel=2)

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/__init__.py

@@ -0,0 +1,131 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+
+from .fmha import (
+    AttentionBias,
+    AttentionOp,
+    AttentionOpBase,
+    AttentionOpDispatch,
+    LowerTriangularMask,
+    MemoryEfficientAttentionCutlassFwdFlashBwOp,
+    MemoryEfficientAttentionCutlassOp,
+    MemoryEfficientAttentionFlashAttentionOp,
+    MemoryEfficientAttentionOp,
+    MemoryEfficientAttentionTritonFwdFlashBwOp,
+    TritonFlashAttentionOp,
+    memory_efficient_attention,
+    memory_efficient_attention_backward,
+    memory_efficient_attention_forward,
+    memory_efficient_attention_forward_requires_grad,
+)
+from .indexing import index_select_cat, scaled_index_add
+from .modpar_layers import ColumnParallelLinear, RowParallelLinear
+from .rmsnorm import RMSNorm
+from .rope_padded import rope_padded
+from .seqpar import sequence_parallel_leading_matmul, sequence_parallel_trailing_matmul
+from .sequence_parallel_fused_ops import (
+    fused_allgather_and_anything,
+    fused_allgather_and_linear,
+    fused_anything_and_reducescatter,
+    fused_linear_and_reducescatter,
+)
+from .sp24 import Sparse24Tensor, sparsify24, sparsify24_like
+from .swiglu_op import (
+    SwiGLU,
+    SwiGLUEagerOp,
+    SwiGLUFusedOp,
+    SwiGLUOp,
+    SwiGLUOpDispatch,
+    SwiGLUPackedFusedOp,
+    swiglu,
+)
+from .tiled_matmul import tiled_matmul
+from .unbind import get_stack_strides, stack_or_none, unbind
+
+# BW compatibility
+AttentionMask = AttentionBias
+
+
+def masked_matmul(a, b, mask=None):
+    if torch.overrides.has_torch_function((a, b, mask)):
+        return torch.overrides.handle_torch_function(
+            masked_matmul, (a, b, mask), a, b, mask
+        )
+
+    att = a @ b
+
+    if mask is None:
+        return att
+
+    if mask.dtype == torch.bool:
+        if mask.ndim == 2:
+            mask = mask.unsqueeze(0).expand(att.shape[0], -1, -1)
+        # mask is presumed false == ignore
+        att[~mask] = float("-inf")
+    else:
+        # mask is presumed additive
+        att += mask
+    return att
+
+
+__all__ = [
+    # fmha
+    "AttentionBias",
+    "AttentionMask",
+    "AttentionOp",
+    "AttentionOpBase",
+    "AttentionOpDispatch",
+    "LowerTriangularMask",
+    "MemoryEfficientAttentionCutlassFwdFlashBwOp",
+    "MemoryEfficientAttentionCutlassOp",
+    "MemoryEfficientAttentionFlashAttentionOp",
+    "MemoryEfficientAttentionOp",
+    "MemoryEfficientAttentionTritonFwdFlashBwOp",
+    "TritonFlashAttentionOp",
+    "memory_efficient_attention",
+    "memory_efficient_attention_backward",
+    "memory_efficient_attention_forward",
+    "memory_efficient_attention_forward_requires_grad",
+    # indexing
+    "index_select_cat",
+    "scaled_index_add",
+    # modpar_layers
+    "ColumnParallelLinear",
+    "RowParallelLinear",
+    # rmsnorm
+    "RMSNorm",
+    # rope_padded
+    "rope_padded",
+    # seqpar
+    "sequence_parallel_leading_matmul",
+    "sequence_parallel_trailing_matmul",
+    # sequence_parallel_fused_ops
+    "fused_allgather_and_anything",
+    "fused_allgather_and_linear",
+    "fused_anything_and_reducescatter",
+    "fused_linear_and_reducescatter",
+    # swiglu_op
+    "SwiGLU",
+    "SwiGLUEagerOp",
+    "SwiGLUFusedOp",
+    "SwiGLUOp",
+    "SwiGLUOpDispatch",
+    "SwiGLUPackedFusedOp",
+    "swiglu",
+    # tiled_matmul
+    "tiled_matmul",
+    # unbind
+    "get_stack_strides",
+    "stack_or_none",
+    "unbind",
+    # sp24
+    "sparsify24",
+    "sparsify24_like",
+    "Sparse24Tensor",
+    # .
+    "masked_matmul",
+]

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+# One reason this module is called `_triton` instead of just `triton` is this:
+# https://github.com/openai/triton/commit/c6040bcbd8a046785462481b2830b3fff5fc4aab
+
+from typing import TYPE_CHECKING
+
+import xformers
+
+if TYPE_CHECKING or xformers._is_triton_available():
+    from .k_index_select_cat import index_select_cat_bwd, index_select_cat_fwd
+    from .k_scaled_index_add import scaled_index_add_bwd, scaled_index_add_fwd
+else:
+    index_select_cat_fwd = index_select_cat_bwd = None
+    scaled_index_add_fwd = scaled_index_add_bwd = None

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/k_index_select_cat.py

@@ -0,0 +1,184 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+import triton
+import triton.language as tl
+
+
+@triton.jit
+def index_select_cat_fwd_kernel(
+    output_ptr,  # *Pointer* to output tensor.
+    source_ptr,  # *Pointer* to source tensor.
+    index_ptr,  # *Pointer* to index tensor.
+    num_indices,
+    num_cols,
+    stride0,  # Stride information of source tensor.
+    stride1,
+    BLOCK_SIZE_INDEX: tl.constexpr,  # Number of indices each program should process.
+    BLOCK_SIZE_COL: tl.constexpr,  # Number of cols each program should process.
+):
+    pid0 = tl.program_id(axis=0)  # We use 2D launch grid
+    pid1 = tl.program_id(axis=1)
+
+    indices = pid0 * BLOCK_SIZE_INDEX + tl.arange(0, BLOCK_SIZE_INDEX)
+    rows = tl.load(index_ptr + indices, mask=(indices < num_indices))
+    cols = pid1 * BLOCK_SIZE_COL + tl.arange(0, BLOCK_SIZE_COL)
+
+    source_offsets = source_ptr + rows[:, None] * stride0 + cols[None, :] * stride1
+    mask = (indices[:, None] < num_indices) & (cols[None, :] < num_cols)
+    output = tl.load(source_offsets, mask=mask)
+
+    output_offsets = output_ptr + indices[:, None] * stride0 + cols[None, :] * stride1
+    tl.store(output_offsets, output, mask=mask)
+
+
+def index_select_cat_fwd(
+    output: torch.Tensor,
+    source: torch.Tensor,
+    index: torch.Tensor,
+):
+    if not (source.is_cuda and index.is_cuda):
+        raise ValueError("The index tensor and the source tensor must be of type CUDA!")
+
+    if not source.ndim == 2:
+        raise ValueError(f"Expected 2-dimensional tensor, got {source.ndim}.")
+    if not index.ndim == 1:
+        raise ValueError(f"Expected 1-dimensional tensor, got {index.ndim}.")
+
+    num_rows, num_cols = source.shape
+    num_indices = index.shape[0]
+
+    if not num_indices < num_rows:
+        raise ValueError(
+            "The number of indices cannot exceed the number of rows in the source matrix."
+        )
+
+    stride0, stride1 = source.stride(0), source.stride(1)
+
+    def grid(meta):
+        return (
+            triton.cdiv(num_indices, meta["BLOCK_SIZE_INDEX"]),
+            triton.cdiv(num_cols, meta["BLOCK_SIZE_COL"]),
+        )
+
+    index_select_cat_fwd_kernel[grid](
+        output,
+        source,
+        index,
+        num_indices,
+        num_cols,
+        stride0,
+        stride1,
+        BLOCK_SIZE_INDEX=1,
+        BLOCK_SIZE_COL=512,
+    )
+
+    return output
+
+
+@triton.jit
+def index_select_cat_bwd_kernel(
+    grad_source_ptr,  # *Pointer* to grad_source tensor.
+    index_ptr,  # *Pointer* to index tensor.
+    grad_output_ptr,  # *Pointer* to grad_output tensor.
+    num_rows,
+    num_indices,
+    num_cols,
+    stride0,  # Stride information of input and source tensor.
+    stride1,
+    BLOCK_SIZE_INDEX: tl.constexpr,  # Number of indices each program should process.
+    BLOCK_SIZE_COL: tl.constexpr,  # Number of cols each program should process.
+):
+    pid0 = tl.program_id(axis=0)  # We use 3D launch grid
+    pid1 = tl.program_id(axis=1)
+
+    cols = pid1 * BLOCK_SIZE_COL + tl.arange(0, BLOCK_SIZE_COL)
+
+    # load grad_output
+    grad_output_indices = pid0 * BLOCK_SIZE_INDEX + tl.arange(0, BLOCK_SIZE_INDEX)
+    grad_output_offsets = (
+        grad_output_ptr
+        + grad_output_indices[:, None] * stride0
+        + cols[None, :] * stride1
+    )
+    grad_output_mask = (grad_output_indices[:, None] < num_indices) & (
+        cols[None, :] < num_cols
+    )
+    grad_output = tl.load(grad_output_offsets, mask=grad_output_mask).to(tl.float32)
+
+    # select indices from grad_source
+    grad_source_indices = tl.load(
+        index_ptr + grad_output_indices, mask=(grad_output_indices < num_indices)
+    )
+    grad_source_offsets = (
+        grad_source_ptr
+        + grad_source_indices[:, None] * stride0
+        + cols[None, :] * stride1
+    )
+
+    # compute scaled index add and save
+    tl.store(grad_source_offsets, grad_output, mask=grad_output_mask)
+
+
+def index_select_cat_bwd(
+    grad_source: torch.Tensor,
+    index: torch.Tensor,
+    grad_output: torch.Tensor,
+):
+    if not (grad_source.is_cuda and grad_output.is_cuda):
+        raise ValueError("The grad_source and grad_output tensor must be of type CUDA!")
+
+    if not (grad_source.ndim == 2 and grad_output.ndim == 2):
+        raise ValueError(
+            f"The grad_source and grad_output must be three-dimensional "
+            f"(got {grad_source.ndim} and {grad_output.ndim})!"
+        )
+    if not grad_source.shape[1] == grad_output.shape[1]:
+        raise ValueError(
+            f"The number of elements along dimension 1 of grad_source and grad_output must be the same "
+            f"(got {grad_source.shape[1]} and {grad_output.shape[1]})"
+        )
+
+    num_rows, num_cols = grad_source.shape
+    num_indices, num_cols = grad_output.shape
+    if not num_rows >= num_indices:
+        raise ValueError(
+            f"The number of elements along dimension 0 of grad_source must be larger than that of grad_output "
+            f"(got {num_rows} and {num_indices})!"
+        )
+    if not index.shape[0] == num_indices:
+        raise ValueError(
+            f"The number of indices and the number of elements along dimension 0 of grad_output must match "
+            f"(got {index.shape[0]} and {num_indices})!"
+        )
+
+    stride0, stride1 = grad_source.stride(0), grad_source.stride(1)
+    if not (grad_output.stride(0) == stride0 and grad_output.stride(1) == stride1):
+        raise ValueError(
+            f"The strides of the grad_source and grad_output tensors must match "
+            f"(got {stride0} vs. {grad_output.stride(0)}, {stride1} vs. {grad_output.stride(1)})!"
+        )
+
+    def grid(meta):
+        return (
+            triton.cdiv(num_indices, meta["BLOCK_SIZE_INDEX"]),
+            triton.cdiv(num_cols, meta["BLOCK_SIZE_COL"]),
+        )
+
+    index_select_cat_bwd_kernel[grid](
+        grad_source,
+        index,
+        grad_output,
+        num_rows,
+        num_indices,
+        num_cols,
+        grad_source.stride(0),
+        grad_source.stride(1),
+        BLOCK_SIZE_INDEX=1,
+        BLOCK_SIZE_COL=512,
+    )
+
+    return

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/rmsnorm_kernels.py

@@ -0,0 +1,158 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+import torch
+import triton
+import triton.language as tl
+
+if hasattr(tl, "libdevice"):
+    tl_math = tl.libdevice
+else:
+    tl_math = tl.math
+
+
+@triton.jit
+def _rms_norm_kernel(
+    x_ptr,
+    h1_ptr,
+    w_ptr,
+    eps,
+    stride,
+    N_COLS: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+    INCLUDE_WEIGHT: tl.constexpr,
+):
+    row = tl.program_id(0)
+    x_ptr += row * stride
+    h1_ptr += row * stride
+
+    _mean = tl.zeros([BLOCK_SIZE], dtype=tl.float32)
+    for offset in range(0, N_COLS, BLOCK_SIZE):
+        cols = offset + tl.arange(0, BLOCK_SIZE)
+        a = tl.load(
+            x_ptr + cols, mask=cols < N_COLS, other=0.0, eviction_policy="evict_last"
+        ).to(tl.float32)
+        _mean += a * a
+    rstd = tl_math.rsqrt((tl.sum(_mean, axis=0) / N_COLS) + eps)
+    for offset in range(0, N_COLS, BLOCK_SIZE):
+        cols = offset + tl.arange(0, BLOCK_SIZE)
+        mask = cols < N_COLS
+        a = tl.load(
+            x_ptr + cols, mask=mask, other=0.0, eviction_policy="evict_first"
+        ).to(tl.float32)
+        if INCLUDE_WEIGHT:
+            w = tl.load(w_ptr + cols, mask=mask)
+            tl.store(h1_ptr + cols, a * rstd * w, mask=mask)
+        else:
+            tl.store(h1_ptr + cols, a * rstd, mask=mask)
+
+
+@triton.jit
+def _rms_norm_add_kernel(
+    x_ptr,
+    y_ptr,
+    h1_ptr,
+    w_ptr,
+    eps,
+    stride,
+    N_COLS: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+    INCLUDE_WEIGHT: tl.constexpr,
+):
+    row = tl.program_id(0)
+    x_ptr += row * stride
+    y_ptr += row * stride
+    h1_ptr += row * stride
+
+    _mean = tl.zeros([BLOCK_SIZE], dtype=tl.float32)
+    for offset in range(0, N_COLS, BLOCK_SIZE):
+        cols = offset + tl.arange(0, BLOCK_SIZE)
+        mask = cols < N_COLS
+        ax = tl.load(
+            x_ptr + cols, mask=mask, other=0.0, eviction_policy="evict_last"
+        ).to(tl.float32)
+        ay = tl.load(
+            y_ptr + cols, mask=mask, other=0.0, eviction_policy="evict_first"
+        ).to(tl.float32)
+        a = ax + ay
+        tl.store(x_ptr + cols, a, mask=mask)
+        _mean += a * a
+    rstd = tl_math.rsqrt((tl.sum(_mean, axis=0) / N_COLS) + eps)
+    for offset in range(0, N_COLS, BLOCK_SIZE):
+        cols = offset + tl.arange(0, BLOCK_SIZE)
+        mask = cols < N_COLS
+        a = tl.load(
+            x_ptr + cols, mask=mask, other=0.0, eviction_policy="evict_first"
+        ).to(tl.float32)
+        if INCLUDE_WEIGHT:
+            w = tl.load(w_ptr + cols, mask=mask)
+            tl.store(h1_ptr + cols, a * rstd * w, mask=mask)
+        else:
+            tl.store(h1_ptr + cols, a * rstd, mask=mask)
+
+
+def _rms_norm_forward(x, attn_norm_weights, eps):
+    if not x.is_contiguous():
+        raise ValueError("data must be contiguous")
+    if attn_norm_weights is not None:
+        if not attn_norm_weights.is_contiguous():
+            raise ValueError("weights must be contiguous")
+    out = torch.empty_like(x)
+    x_arg = x.reshape(-1, x.shape[-1])
+    M, N = x_arg.shape
+    # Less than 64KB per feature: enqueue fused kernel
+    MAX_FUSED_SIZE = 65536 // x.element_size()
+    BLOCK_SIZE = min(MAX_FUSED_SIZE, triton.next_power_of_2(N))
+    BLOCK_SIZE = max(BLOCK_SIZE, 128)
+    BLOCK_SIZE = min(BLOCK_SIZE, 8192)
+    # heuristics for number of warps
+    num_warps = min(max(BLOCK_SIZE // 256, 1), 8)
+    _rms_norm_kernel[(M,)](
+        x_arg,
+        out,
+        attn_norm_weights,
+        eps,
+        x_arg.stride(0),
+        N,
+        BLOCK_SIZE=BLOCK_SIZE,
+        num_warps=num_warps,
+        INCLUDE_WEIGHT=attn_norm_weights is not None,
+    )
+    return out
+
+
+def _rms_norm_add_forward(x, y, attn_norm_weights, eps):
+    # x, y contiguous of same shape [..., n]
+    # output of same shape, normed over the last dim.
+    if not x.is_contiguous():
+        raise ValueError("x must be contiguous")
+    if not y.is_contiguous():
+        raise ValueError("y must be contiguous")
+    if attn_norm_weights is not None:
+        if not attn_norm_weights.is_contiguous():
+            raise ValueError("weights must be contiguous")
+    out = torch.empty_like(x)
+    x_arg = x.reshape(-1, x.shape[-1])
+    y_arg = y.reshape(-1, x.shape[-1])
+    M, N = x_arg.shape
+    # Less than 64KB per feature: enqueue fused kernel
+    MAX_FUSED_SIZE = 65536 // x.element_size()
+    BLOCK_SIZE = min(MAX_FUSED_SIZE, triton.next_power_of_2(N))
+    BLOCK_SIZE = max(BLOCK_SIZE, 128)
+    BLOCK_SIZE = min(BLOCK_SIZE, 8192)
+    # heuristics for number of warps
+    num_warps = min(max(BLOCK_SIZE // 256, 1), 8)
+    _rms_norm_add_kernel[(M,)](
+        x_arg,
+        y_arg,
+        out,
+        attn_norm_weights,
+        eps,
+        x_arg.stride(0),
+        N,
+        BLOCK_SIZE=BLOCK_SIZE,
+        num_warps=num_warps,
+        INCLUDE_WEIGHT=attn_norm_weights is not None,
+    )
+    return out

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/rope_padded_kernels.py

@@ -0,0 +1,188 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+import triton  # type: ignore
+import triton.language as tl  # type: ignore
+
+if hasattr(tl, "libdevice"):
+    tl_math = tl.libdevice
+else:
+    tl_math = tl.math
+
+
+@triton.jit
+def _rope_padded_kernel(
+    xq,
+    xk,
+    xv,
+    out_q,
+    cache_k,
+    cache_v,
+    seqstartq,
+    seqstartk,
+    seqlenk,
+    theta,
+    k_start: tl.constexpr,
+    v_start: tl.constexpr,
+    n_groups,
+    dim: tl.constexpr,  # dimension of each head
+    stride_xqM,
+    stride_xqG,
+    stride_xqH,
+    stride_xkM,
+    stride_xkG,
+    stride_xkH,
+    stride_xvM,
+    stride_xvG,
+    stride_xvH,
+    stride_cachekM,
+    stride_cachekG,
+    stride_cachekH,
+    stride_cachevM,
+    stride_cachevG,
+    stride_cachevH,
+    stride_seqstartq,
+    stride_seqstartk,
+    stride_seqlenk,
+    stride_outqM,
+    stride_outqG,
+    stride_outqH,
+    internal_dtype: tl.constexpr,
+    # If True, seqstartq and seqstartk are not used but rather we
+    # assume that every batch element has the same number of
+    # queries (i.e. num_queries := tl.num_programs(1) )
+    # and the same cache space cache_padding_length.
+    # Always False when called below.
+    const_batch_strides: tl.constexpr,
+    # If const_batch_strides==True, the common cache length for each batch element.
+    # (Only the first seqlenk[i] elements are actually in use, and only the last
+    #  num_queries of those are actually written to.)
+    cache_padding_length,
+    # offset added to all values in seqlenk before using them.
+    # Always 0 when called below.
+    seqlenk_shift: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+    adjacents: tl.constexpr,
+):
+    """
+    Each letter in this diagram is a whole row of length dim.
+
+     INPUT      xq        xk       xv
+
+        head_dim ─►
+
+      batch   qqqqqq      kk       vv
+        │     qqqqqq      kk       vv
+        ▼     qqqqqq      kk       vv
+
+    head_idx:  (goes across all heads of all 3 inputs)
+              ▲     ▲     ▲ ▲      ▲ ▲
+              │     │     │ │      │ │
+                          │        │
+              0  k_start  │v_start │n_total_heads
+                          │        │
+                          │        │
+                      k_start    v_start
+
+    Output is to out_q (same shape as xq), an xk-shaped part
+    of cache_k and an xv-shaped part of cache_v
+    """
+    batch_elt = tl.program_id(0)
+    query_pos_in_batch_elt = tl.program_id(1)
+    group_head_idx = tl.program_id(2)
+    group_idx = group_head_idx % n_groups
+    head_idx = group_head_idx // n_groups
+
+    if internal_dtype == "f32":
+        theta = theta.to(tl.float32)
+    elif internal_dtype == "f64":
+        theta = theta.to(tl.float64)
+
+    if const_batch_strides:
+        query_pos = query_pos_in_batch_elt + tl.num_programs(1) * batch_elt
+        end_query_pos = tl.num_programs(1) * (batch_elt + 1)
+    else:
+        query_pos = query_pos_in_batch_elt + tl.load(
+            seqstartq + batch_elt * stride_seqstartq
+        )
+        end_query_pos = tl.load(seqstartq + (batch_elt + 1) * stride_seqstartq)
+        if query_pos >= end_query_pos:
+            return
+
+    is_q = head_idx < k_start
+    is_v = head_idx >= v_start
+
+    xq += query_pos * stride_xqM + head_idx * stride_xqH + group_idx * stride_xqG
+    out_q += (
+        query_pos * stride_outqM + head_idx * stride_outqH + group_idx * stride_outqG
+    )
+
+    if const_batch_strides:
+        cache_start = cache_padding_length * batch_elt
+    else:
+        cache_start = tl.load(seqstartk + batch_elt * stride_seqstartk)
+    end_of_batch_elt_cache = (
+        cache_start + tl.load(seqlenk + batch_elt * stride_seqlenk) + seqlenk_shift
+    )
+
+    cache_pos = end_of_batch_elt_cache - (end_query_pos - query_pos)
+    seq_pos = cache_pos - cache_start
+    cache_k += (
+        (head_idx - k_start) * stride_cachekH
+        + cache_pos * stride_cachekM
+        + group_idx * stride_cachekG
+    )
+    xk += (
+        query_pos * stride_xkM
+        + (head_idx - k_start) * stride_xkH
+        + group_idx * stride_xkG
+    )
+    in_qk = tl.where(is_q, xq, xk)
+    out_qk = tl.where(is_q, out_q, cache_k)
+
+    cache_v += (
+        (head_idx - v_start) * stride_cachevH
+        + cache_pos * stride_cachevM
+        + group_idx * stride_cachevG
+    )
+    xv += (
+        query_pos * stride_xvM
+        + (head_idx - v_start) * stride_xvH
+        + group_idx * stride_xvG
+    )
+
+    out = tl.where(is_v, cache_v, out_qk)
+    x_in = tl.where(is_v, xv, in_qk)
+
+    for offset in range(0, dim // 2, BLOCK_SIZE // 2):
+        c = tl.arange(0, BLOCK_SIZE // 2)
+        powers = (offset + c) * 2.0
+        if adjacents:
+            cols_re = (offset + c) * 2
+            cols_im = cols_re + 1
+        else:
+            cols_re = offset + c
+            cols_im = cols_re + dim // 2
+
+        mask = cols_im < dim
+
+        re_x = tl.load(x_in + cols_re, mask=mask)
+        im_x = tl.load(x_in + cols_im, mask=mask)
+        # freqs = seq_pos / (theta ** (powers / dim))
+        freqs = seq_pos * tl_math.pow(theta, powers / (-dim))
+        sines = tl.sin(freqs)
+        cosines = tl.cos(freqs)
+        re_out = re_x * cosines - im_x * sines
+        im_out = im_x * cosines + re_x * sines
+
+        re_out_ = tl.where(is_v, re_x, re_out)
+        im_out_ = tl.where(is_v, im_x, im_out)
+        if internal_dtype == "f64":
+            if re_x.dtype == tl.bfloat16:
+                # triton 2.0.0 crashes if you try to convert
+                # float64 directly to bfloat16, so make an intermediate step.
+                re_out_ = re_out_.to(tl.float32)
+                im_out_ = im_out_.to(tl.float32)
+        tl.store(out + cols_re, re_out_, mask=mask)
+        tl.store(out + cols_im, im_out_, mask=mask)

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/_triton/tiled_matmul_kernels.py

@@ -0,0 +1,430 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import itertools
+from typing import List, Tuple
+
+import torch
+import triton
+import triton.language as tl
+from triton.ops.matmul_perf_model import early_config_prune, estimate_matmul_time
+
+
+def init_to_zero(*names):
+    def result(nargs):
+        for name in names:
+            nargs[name].zero_()
+
+    return result
+
+
+def gen_config(
+    block_m: int,
+    block_n: int,
+    block_k: int,
+    stages: int,
+    warps: int,
+    split_k: int = 1,
+    group_m: int = 8,
+) -> triton.Config:
+    """A more compact way to define a triton.Config, so it fits on one line"""
+
+    return triton.Config(
+        {
+            "BLOCK_M": block_m,
+            "BLOCK_N": block_n,
+            "BLOCK_K": block_k,
+            "SPLIT_K": split_k,
+            "GROUP_M": group_m,
+        },
+        num_stages=stages,
+        num_warps=warps,
+        pre_hook=init_to_zero(*[f"C{i+1}{j+1}" for i in range(3) for j in range(3)])
+        if split_k > 1
+        else init_to_zero(),
+    )
+
+
+BASIC_MATMUL_CONFIGS = [
+    gen_config(block_m=128, block_n=256, block_k=32, stages=3, warps=8),
+    gen_config(block_m=256, block_n=128, block_k=32, stages=3, warps=8),
+    gen_config(block_m=256, block_n=64, block_k=32, stages=4, warps=4),
+    gen_config(block_m=64, block_n=256, block_k=32, stages=4, warps=4),
+    gen_config(block_m=128, block_n=128, block_k=32, stages=4, warps=4),
+    gen_config(block_m=128, block_n=64, block_k=32, stages=4, warps=4),
+    gen_config(block_m=64, block_n=128, block_k=32, stages=4, warps=4),
+    gen_config(block_m=128, block_n=32, block_k=32, stages=4, warps=4),
+    gen_config(block_m=64, block_n=32, block_k=32, stages=5, warps=2),
+]
+
+
+INT8_MATMUL_CONFIGS = [
+    gen_config(block_m=128, block_n=256, block_k=128, stages=3, warps=8),
+    gen_config(block_m=256, block_n=128, block_k=128, stages=3, warps=8),
+    gen_config(block_m=256, block_n=64, block_k=128, stages=4, warps=4),
+    gen_config(block_m=64, block_n=256, block_k=128, stages=4, warps=4),
+    gen_config(block_m=128, block_n=128, block_k=128, stages=4, warps=4),
+    gen_config(block_m=128, block_n=64, block_k=64, stages=4, warps=4),
+    gen_config(block_m=64, block_n=128, block_k=64, stages=4, warps=4),
+    gen_config(block_m=128, block_n=32, block_k=64, stages=4, warps=4),
+    gen_config(block_m=64, block_n=32, block_k=64, stages=5, warps=2),
+]
+
+
+IO_BOUND_MATMUL_CONFIGS_STAGES = [2, 3, 4, 5, 6]
+IO_BOUND_MATMUL_CONFIGS_BLOCK_M = [16, 32]
+IO_BOUND_MATMUL_CONFIGS_BLOCK_K = [32, 64]
+IO_BOUND_MATMUL_CONFIGS_BLOCK_N = [32, 64, 128, 256]
+IO_BOUND_MATMUL_CONFIGS_SPLIT_K = [1, 2, 4, 8, 16]
+
+
+IO_BOUND_MATMUL_CONFIGS = [
+    gen_config(
+        block_m=block_m,
+        block_n=block_n,
+        block_k=block_k,
+        stages=stages,
+        warps=2 if block_n <= 64 else 4,
+        split_k=split_k,
+    )
+    for stages, block_m, block_k, block_n, split_k in itertools.product(
+        IO_BOUND_MATMUL_CONFIGS_STAGES,
+        IO_BOUND_MATMUL_CONFIGS_BLOCK_M,
+        IO_BOUND_MATMUL_CONFIGS_BLOCK_K,
+        IO_BOUND_MATMUL_CONFIGS_BLOCK_N,
+        IO_BOUND_MATMUL_CONFIGS_SPLIT_K,
+    )
+]
+
+
+TRITON_CONFIGS = BASIC_MATMUL_CONFIGS + INT8_MATMUL_CONFIGS + IO_BOUND_MATMUL_CONFIGS
+
+
+def our_estimate_matmul_time(
+    A11, B11, C11, M1, M2, M3, N1, N2, N3, K1, K2, K3, **kwargs
+):
+    """Call into Triton's upstream cost model, with the right args
+
+    The upstream function expects arguments to have certain names. Since we
+    renamed a few of them in our implementation, we rename them back.
+
+    At the time of writing (July 2023) the arguments that Triton expects are:
+    M, N, K, A, B, C, BLOCK_M, BLOCK_N, BLOCK_K, SPLIT_K, num_warps, num_stages.
+
+    """
+    return estimate_matmul_time(
+        M=M1 + M2 + M3, N=N1 + N2 + N3, K=K1 + K2 + K3, A=A11, B=B11, C=C11, **kwargs
+    )
+
+
+def our_early_config_prune(config, named_args):
+    new_named_args = named_args.copy()
+    new_named_args["M"] = named_args["M1"] + named_args["M2"] + named_args["M3"]
+    new_named_args["N"] = named_args["N1"] + named_args["N2"] + named_args["N3"]
+    new_named_args["K"] = named_args["K1"] + named_args["K2"] + named_args["K3"]
+    new_named_args["A"] = named_args["A11"]
+    new_named_args["B"] = named_args["B11"]
+    new_named_args["C"] = named_args["C11"]
+    return early_config_prune(config, new_named_args)
+
+
+@triton.autotune(
+    configs=TRITON_CONFIGS,
+    key=["M1", "M2", "M3", "N1", "N2", "N3", "K1", "K2", "K3"],
+    prune_configs_by={
+        "early_config_prune": our_early_config_prune,
+        "perf_model": our_estimate_matmul_time,
+        "top_k": 10,
+    },
+)
+@triton.heuristics(
+    {
+        "EVEN_K": lambda args: all(
+            k % (args["BLOCK_K"] * args["SPLIT_K"]) == 0
+            for k in [args["K1"], args["K2"], args["K3"]]
+        ),
+    }
+)
+@triton.jit()
+def _xformers_tiled_matmul_kernel(
+    A11,
+    A12,
+    A13,
+    A21,
+    A22,
+    A23,
+    A31,
+    A32,
+    A33,
+    B11,
+    B12,
+    B13,
+    B21,
+    B22,
+    B23,
+    B31,
+    B32,
+    B33,
+    C11,
+    C12,
+    C13,
+    C21,
+    C22,
+    C23,
+    C31,
+    C32,
+    C33,
+    M1,
+    M2,
+    M3,
+    N1,
+    N2,
+    N3,
+    K1,
+    K2,
+    K3,
+    stride_am1,
+    stride_am2,
+    stride_am3,
+    stride_ak1,
+    stride_ak2,
+    stride_ak3,
+    stride_bk1,
+    stride_bk2,
+    stride_bk3,
+    stride_bn1,
+    stride_bn2,
+    stride_bn3,
+    stride_cm1,
+    stride_cm2,
+    stride_cm3,
+    stride_cn1,
+    stride_cn2,
+    stride_cn3,
+    BLOCK_M: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    BLOCK_N: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    BLOCK_K: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    GROUP_M: tl.constexpr,
+    SPLIT_K: tl.constexpr,  # DO NOT CHANGE NAME: MUST MATCH PERF MODEL
+    EVEN_K: tl.constexpr,
+    ACC_TYPE: tl.constexpr,
+):
+    # matrix multiplication
+    pid = tl.program_id(0)
+    pid_k = tl.program_id(1)
+    grid_m1 = tl.cdiv(M1, BLOCK_M)
+    grid_m2 = tl.cdiv(M2, BLOCK_M)
+    grid_m3 = tl.cdiv(M3, BLOCK_M)
+    grid_n1 = tl.cdiv(N1, BLOCK_N)
+    grid_n2 = tl.cdiv(N2, BLOCK_N)
+    grid_n3 = tl.cdiv(N3, BLOCK_N)
+    grid_m = grid_m1 + grid_m2 + grid_m3
+    grid_n = grid_n1 + grid_n2 + grid_n3
+
+    # re-order program ID for better L2 performance
+    width = GROUP_M * grid_n
+    group_id = pid // width
+    group_size = min(grid_m - group_id * GROUP_M, GROUP_M)
+    pid_m = group_id * GROUP_M + (pid % group_size)
+    pid_n = (pid % width) // (group_size)
+
+    # We use tl.where to circumvent a regression in alignment auto-detection:
+    # https://github.com/openai/triton/issues/1784
+
+    A1 = tl.where(pid_m < grid_m1, A11, tl.where(pid_m < grid_m1 + grid_m2, A21, A31))
+    A2 = tl.where(pid_m < grid_m1, A12, tl.where(pid_m < grid_m1 + grid_m2, A22, A32))
+    A3 = tl.where(pid_m < grid_m1, A13, tl.where(pid_m < grid_m1 + grid_m2, A23, A33))
+    B1 = tl.where(pid_n < grid_n1, B11, tl.where(pid_n < grid_n1 + grid_n2, B12, B13))
+    B2 = tl.where(pid_n < grid_n1, B21, tl.where(pid_n < grid_n1 + grid_n2, B22, B23))
+    B3 = tl.where(pid_n < grid_n1, B31, tl.where(pid_n < grid_n1 + grid_n2, B32, B33))
+    C = tl.where(
+        pid_m < grid_m1,
+        tl.where(pid_n < grid_n1, C11, tl.where(pid_n < grid_n1 + grid_n2, C12, C13)),
+        tl.where(
+            pid_m < grid_m1 + grid_m2,
+            tl.where(
+                pid_n < grid_n1, C21, tl.where(pid_n < grid_n1 + grid_n2, C22, C23)
+            ),
+            tl.where(
+                pid_n < grid_n1, C31, tl.where(pid_n < grid_n1 + grid_n2, C32, C33)
+            ),
+        ),
+    )
+    M = tl.where(pid_m < grid_m1, M1, tl.where(pid_m < grid_m1 + grid_m2, M2, M3))
+    N = tl.where(pid_n < grid_n1, N1, tl.where(pid_n < grid_n1 + grid_n2, N2, N3))
+    stride_ak = tl.where(
+        pid_m < grid_m1,
+        stride_ak1,
+        tl.where(pid_m < grid_m1 + grid_m2, stride_ak2, stride_ak3),
+    )
+    stride_bk = tl.where(
+        pid_n < grid_n1,
+        stride_bk1,
+        tl.where(pid_n < grid_n1 + grid_n2, stride_bk2, stride_bk3),
+    )
+    stride_cn = tl.where(
+        pid_m < grid_m1,
+        stride_cn1,
+        tl.where(pid_m < grid_m1 + grid_m2, stride_cn2, stride_cn3),
+    )
+    stride_cm = tl.where(
+        pid_n < grid_n1,
+        stride_cm1,
+        tl.where(pid_n < grid_n1 + grid_n2, stride_cm2, stride_cm3),
+    )
+    pid_m = tl.where(
+        pid_m < grid_m1,
+        pid_m,
+        tl.where(pid_m < grid_m1 + grid_m2, pid_m - grid_m1, pid_m - grid_m1 - grid_m2),
+    )
+    pid_n = tl.where(
+        pid_n < grid_n1,
+        pid_n,
+        tl.where(pid_n < grid_n1 + grid_n2, pid_n - grid_n1, pid_n - grid_n1 - grid_n2),
+    )
+
+    # do matrix multiplication
+    rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    ram = tl.max_contiguous(tl.multiple_of(rm % M, BLOCK_M), BLOCK_M)
+    rbn = tl.max_contiguous(tl.multiple_of(rn % N, BLOCK_N), BLOCK_N)
+    # pointers
+    acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=ACC_TYPE)
+    grid_k1 = tl.cdiv(K1, BLOCK_K)
+    grid_k2 = tl.cdiv(K2, BLOCK_K)
+    grid_k3 = tl.cdiv(K3, BLOCK_K)
+    for tile in range(pid_k, grid_k1 + grid_k2 + grid_k3, SPLIT_K):
+        A = tl.where(tile < grid_k1, A1, tl.where(tile < grid_k1 + grid_k2, A2, A3))
+        B = tl.where(tile < grid_k1, B1, tl.where(tile < grid_k1 + grid_k2, B2, B3))
+        K = tl.where(tile < grid_k1, K1, tl.where(tile < grid_k1 + grid_k2, K2, K3))
+        stride_am = tl.where(
+            tile < grid_k1,
+            stride_am1,
+            tl.where(tile < grid_k1 + grid_k2, stride_am2, stride_am3),
+        )
+        stride_bn = tl.where(
+            tile < grid_k1,
+            stride_bn1,
+            tl.where(tile < grid_k1 + grid_k2, stride_bn2, stride_bn3),
+        )
+        my_tile = tl.where(
+            tile < grid_k1,
+            tile,
+            tl.where(
+                tile < grid_k1 + grid_k2, tile - grid_k1, tile - grid_k1 - grid_k2
+            ),
+        )
+        rk = my_tile * BLOCK_K + tl.arange(0, BLOCK_K)
+        Ain = A + (ram[:, None] * stride_am + rk[None, :] * stride_ak)
+        Bin = B + (rk[:, None] * stride_bk + rbn[None, :] * stride_bn)
+        if EVEN_K:
+            a = tl.load(Ain)
+            b = tl.load(Bin)
+        else:
+            a = tl.load(Ain, mask=rk[None, :] < K, other=0.0)
+            b = tl.load(Bin, mask=rk[:, None] < K, other=0.0)
+        acc += tl.dot(a, b, allow_tf32=False)
+    acc = acc.to(C.dtype.element_ty)
+    # rematerialize rm and rn to save registers
+    rm = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    rn = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    C = C + (rm[:, None] * stride_cm + rn[None, :] * stride_cn)
+    mask = (rm < M)[:, None] & (rn < N)[None, :]
+    # handles write-back with reduction-splitting
+    if SPLIT_K == 1:
+        tl.store(C, acc, mask=mask)
+    else:
+        tl.atomic_add(C, acc, mask=mask)
+
+
+def _check_row_or_column(row_or_col_type, row_or_col_idx, tensor_name, dim_name, vals):
+    assert len(vals) > 0
+    for pos, val in enumerate(vals[1:]):
+        assert val == vals[0], (
+            f"the tensors on {row_or_col_type} {row_or_col_idx} of the {tensor_name} "
+            f"must all have the same stride along the {dim_name} dimension, got "
+            f"{vals[0]} at position 0 and {val} at position {pos + 1}"
+        )
+    return vals[0]
+
+
+def _get_strides(
+    ts: List[List[torch.Tensor]], tensor_name, dim_0_name, dim_1_name
+) -> Tuple[List[int], List[int]]:
+    strides_0 = [
+        _check_row_or_column(
+            "column", idx, tensor_name, dim_0_name, [y.stride(0) for y in x]
+        )
+        for idx, x in enumerate(zip(*ts))
+    ]
+    strides_1 = [
+        _check_row_or_column(
+            "row", idx, tensor_name, dim_1_name, [y.stride(1) for y in x]
+        )
+        for idx, x in enumerate(ts)
+    ]
+    assert all(s == 1 for s in strides_0) or all(s == 1 for s in strides_1)
+    while len(strides_0) < 3:
+        strides_0.append(1 if strides_0[0] == 1 else 0)
+    while len(strides_1) < 3:
+        strides_1.append(1 if strides_1[0] == 1 else 0)
+    return strides_0, strides_1
+
+
+def _launch_triton_matmul(
+    a: List[List[torch.Tensor]],
+    b: List[List[torch.Tensor]],
+    c: List[List[torch.Tensor]],
+    ms: List[int],
+    ns: List[int],
+    ks: List[int],
+) -> None:
+    strides_am, strides_ak = _get_strides(a, "first operand", "m", "k")
+    strides_bk, strides_bn = _get_strides(b, "second operand", "k", "n")
+    strides_cm, strides_cn = _get_strides(c, "output", "m", "n")
+
+    # accumulator types
+    ACC_TYPE = (
+        tl.float32
+        if c[0][0].dtype in [torch.float16, torch.bfloat16, torch.float32]
+        else tl.int32
+    )
+
+    # launch kernel
+    def grid(META):
+        return (
+            sum(triton.cdiv(m, META["BLOCK_M"]) for m in ms)
+            * sum(triton.cdiv(n, META["BLOCK_N"]) for n in ns),
+            META["SPLIT_K"],
+        )
+
+    _xformers_tiled_matmul_kernel[grid](
+        *[
+            a[min(i, len(a) - 1)][min(j, len(a[0]) - 1)]
+            for i in range(3)
+            for j in range(3)
+        ],
+        *[
+            b[min(i, len(b) - 1)][min(j, len(b[0]) - 1)]
+            for i in range(3)
+            for j in range(3)
+        ],
+        *[
+            c[min(i, len(c) - 1)][min(j, len(c[0]) - 1)]
+            for i in range(3)
+            for j in range(3)
+        ],
+        *[ms[i] if len(ms) > i else 0 for i in range(3)],
+        *[ns[i] if len(ns) > i else 0 for i in range(3)],
+        *[ks[i] if len(ks) > i else 0 for i in range(3)],
+        *strides_am,
+        *strides_ak,
+        *strides_bk,
+        *strides_bn,
+        *strides_cm,
+        *strides_cn,
+        ACC_TYPE=ACC_TYPE,
+    )

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/common.py

@@ -0,0 +1,186 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import inspect
+from dataclasses import dataclass
+from functools import wraps
+from typing import Any, Callable, Dict, List, Type, TypeVar, Union
+
+import torch
+from torch.torch_version import TorchVersion
+from typing_extensions import Annotated, get_args, get_origin
+
+from .. import _is_triton_available
+
+
+def get_operator(library: str, name: str):
+    def no_such_operator(*args, **kwargs):
+        raise RuntimeError(
+            f"No such operator {library}::{name} - did you forget to build xformers with `python setup.py develop`?"
+        )
+
+    try:
+        return getattr(getattr(torch.ops, library), name)
+    except (RuntimeError, AttributeError):
+        return no_such_operator
+
+
+def get_xformers_operator(name: str):
+    return get_operator("xformers", name)
+
+
+class BaseOperator:
+    OPERATOR: Any
+    NAME: str
+    OPERATOR_CATEGORY: str
+
+    @classmethod
+    def is_available(cls) -> bool:
+        if cls.OPERATOR is None or cls.OPERATOR.__name__ == "no_such_operator":
+            return False
+        return True
+
+    @classmethod
+    def operator_flop(cls, *inputs) -> int:
+        """Calculate number of FLOP given inputs to `OPERATOR`"""
+        return -1
+
+
+OPERATORS_REGISTRY: List[Type[BaseOperator]] = []
+FUNC_TO_XFORMERS_OPERATOR: Dict[Any, Type[BaseOperator]] = {}
+
+ClsT = TypeVar("ClsT")
+
+
+def register_operator(cls: ClsT) -> ClsT:
+    global OPERATORS_REGISTRY, FUNC_TO_XFORMERS_OPERATOR
+    OPERATORS_REGISTRY.append(cls)  # type: ignore
+    FUNC_TO_XFORMERS_OPERATOR[cls.OPERATOR] = cls  # type: ignore
+    return cls
+
+
+# post-2.0, avoids a warning
+# (`torch.Tensor.storage` will also be deleted in the future)
+_GET_TENSOR_STORAGE = getattr(torch.Tensor, "untyped_storage", None)
+if _GET_TENSOR_STORAGE is None:  # pre-2.0, `untyped_storage` didn't exist
+    _GET_TENSOR_STORAGE = torch.Tensor.storage
+
+
+def _get_storage_base(x: torch.Tensor) -> int:
+    return _GET_TENSOR_STORAGE(x).data_ptr()  # type: ignore
+
+
+@dataclass(frozen=True)
+class Alias:
+    name: str
+    write: bool
+
+
+def make_pytorch_cuda_operator(fn: ClsT) -> ClsT:
+    return turn_into_pytorch_op(fn, "CUDA")
+
+
+def make_pytorch_operator_for_dispatch_key(dispatch_key: str) -> Callable[[ClsT], ClsT]:
+    def decorator(fn: ClsT) -> ClsT:
+        return turn_into_pytorch_op(fn, dispatch_key)
+
+    return decorator
+
+
+def turn_into_pytorch_op(fn: ClsT, dispatch_key: str) -> ClsT:
+    from .. import get_python_lib
+
+    def render_arg_type(annotation) -> str:
+        # Optional[T] is an alias for Union[T, None]
+        if get_origin(annotation) is Union:
+            inner_types = [
+                t for t in get_args(annotation) if t is not type(None)  # noqa: E721
+            ]
+            if len(inner_types) == 1:
+                return f"{render_arg_type(inner_types[0])}?"
+        if get_origin(annotation) is list:
+            (inner_type,) = get_args(annotation)
+            return f"{render_arg_type(inner_type)}[]"
+        if get_origin(annotation) is tuple:
+            return (
+                "("
+                + ", ".join([render_arg_type(t) for t in get_args(annotation)])
+                + ")"
+            )
+        if get_origin(annotation) is Annotated:
+            inner_type, annotation = get_args(annotation)
+            if isinstance(annotation, Alias):
+                alias = annotation.name + ("!" if annotation.write else "")
+                return f"{render_arg_type(inner_type)}({alias})"
+        if annotation is torch.Tensor:
+            return "Tensor"
+        if annotation is bool:
+            return "bool"
+        if annotation is int:
+            return "int"
+        if annotation is float:
+            return "float"
+        if annotation is torch.dtype:
+            return "ScalarType"
+        if annotation is torch.distributed.ProcessGroup:
+            return "__torch__.torch.classes.c10d.ProcessGroup"
+        assert False, f"Unable to parse annotation: `{annotation}`"
+
+    def render_default_value(default):
+        if default is inspect.Parameter.empty:
+            return ""
+        return f" = {default!r}"
+
+    sign = inspect.signature(fn)  # type: ignore
+    arguments = [
+        f"{render_arg_type(arg.annotation)} {arg.name}{render_default_value(arg.default)}"
+        for arg in sign.parameters.values()
+    ]
+    op_name = fn.__name__  # type: ignore
+    definition = f"{op_name}({', '.join(arguments)}) -> {render_arg_type(sign.return_annotation)}"
+
+    def callee(*args, **kwargs):
+        ba = sign.bind(*args, **kwargs)
+        for name, value in ba.arguments.items():
+            if sign.parameters[name].annotation is torch.distributed.ProcessGroup:
+                from .._C import unbox_process_group
+
+                ba.arguments[name] = unbox_process_group(value)
+        return fn(*ba.args, **ba.kwargs)
+
+    xformers_lib = get_python_lib()
+    xformers_lib.define(definition)
+    xformers_lib.impl(op_name, callee, dispatch_key)
+    dispatcher_impl = getattr(getattr(torch.ops, xformers_lib.ns), op_name)
+
+    @wraps(fn)  # type: ignore[arg-type]
+    def caller(*args, **kwargs):
+        ba = sign.bind(*args, **kwargs)
+        for name, value in ba.arguments.items():
+            if sign.parameters[name].annotation is torch.distributed.ProcessGroup:
+                from .._C import box_process_group
+
+                ba.arguments[name] = box_process_group(value)
+        return dispatcher_impl(*ba.args, **ba.kwargs)
+
+    return caller  # type: ignore
+
+
+def _has_triton2():
+    if not _is_triton_available():
+        return False
+    import triton
+
+    tv = TorchVersion(triton.__version__)
+    return tv >= (2, 1) or tv == (2, 0)
+
+
+def _has_triton21():
+    if not _is_triton_available():
+        return False
+    import triton
+
+    tv = TorchVersion(triton.__version__)
+    return tv >= (2, 1)

evalkit_tf437/lib/python3.10/site-packages/xformers/ops/differentiable_collectives.py

@@ -0,0 +1,178 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from typing import Optional, Tuple
+
+import torch
+import torch.distributed
+
+
+def all_reduce(
+    x: torch.Tensor, *, process_group: torch.distributed.ProcessGroup
+) -> None:
+    assert x.is_contiguous()
+
+    mp_size = process_group.size()
+    if mp_size == 1:
+        return
+
+    torch.distributed.all_reduce(
+        tensor=x, op=torch.distributed.ReduceOp.SUM, group=process_group
+    )
+
+
+def gather_along_first_dim_async(
+    input_: torch.Tensor, *, process_group: torch.distributed.ProcessGroup
+) -> Tuple[torch.Tensor, Optional[torch.distributed.Work]]:
+    assert input_.is_contiguous()
+    mp_size = process_group.size()
+    if mp_size == 1:
+        return input_, None
+
+    output = input_.new_empty((input_.shape[0] * mp_size,) + input_.shape[1:])
+    handle = torch.distributed.all_gather_into_tensor(
+        output_tensor=output,
+        input_tensor=input_,
+        group=process_group,
+        async_op=True,
+    )
+
+    return output, handle
+
+
+def reduce_scatter_along_first_dim_async(
+    input_: torch.Tensor, *, process_group: torch.distributed.ProcessGroup
+) -> Tuple[torch.Tensor, Optional[torch.distributed.Work]]:
+    assert input_.is_contiguous()
+    mp_size = process_group.size()
+    if mp_size == 1:
+        return input_, None
+
+    assert input_.shape[0] % mp_size == 0
+    output = input_.new_empty((input_.shape[0] // mp_size,) + input_.shape[1:])
+    handle = torch.distributed.reduce_scatter_tensor(
+        output=output,
+        input=input_,
+        op=torch.distributed.ReduceOp.SUM,
+        group=process_group,
+        async_op=True,
+    )
+
+    return output, handle
+
+
+def gather_along_first_dim(
+    input_: torch.Tensor, *, process_group: torch.distributed.ProcessGroup
+) -> torch.Tensor:
+    output, handle = gather_along_first_dim_async(input_, process_group=process_group)
+    if handle is not None:
+        handle.wait()
+    return output
+
+
+def reduce_scatter_along_first_dim(
+    input_: torch.Tensor, *, process_group: torch.distributed.ProcessGroup
+) -> torch.Tensor:
+    output, handle = reduce_scatter_along_first_dim_async(
+        input_, process_group=process_group
+    )
+    if handle is not None:
+        handle.wait()
+    return output
+
+
+class _CopyToModelParallelRegion(torch.autograd.Function):
+    @staticmethod
+    def forward(  # type: ignore[override]
+        ctx, input_: torch.Tensor, process_group: torch.distributed.ProcessGroup
+    ) -> torch.Tensor:
+        ctx.process_group = process_group
+        return input_
+
+    @staticmethod
+    def backward(  # type: ignore[override]
+        ctx, grad_output: torch.Tensor
+    ) -> Tuple[torch.Tensor, None]:
+        all_reduce(grad_output, process_group=ctx.process_group)
+        return grad_output, None
+
+
+def copy_to_model_parallel_region(
+    x: torch.Tensor, process_group: torch.distributed.ProcessGroup
+) -> torch.Tensor:
+    return _CopyToModelParallelRegion.apply(x, process_group)
+
+
+class _ReduceFromModelParallelRegion(torch.autograd.Function):
+    @staticmethod
+    def forward(  # type: ignore[override]
+        ctx, input_: torch.Tensor, process_group: torch.distributed.ProcessGroup
+    ) -> torch.Tensor:
+        all_reduce(input_, process_group=process_group)
+        ctx.mark_dirty(input_)
+        return input_
+
+    @staticmethod
+    def backward(  # type: ignore[override]
+        ctx, grad_output: torch.Tensor
+    ) -> Tuple[torch.Tensor, None]:
+        return grad_output, None
+
+
+def reduce_from_model_parallel_region(
+    x: torch.Tensor, process_group: torch.distributed.ProcessGroup
+) -> torch.Tensor:
+    return _ReduceFromModelParallelRegion.apply(x, process_group)
+
+
+class _GatherFromSequenceParallelRegion(torch.autograd.Function):
+    @staticmethod
+    def forward(  # type: ignore[override]
+        ctx, x: torch.Tensor, process_group: torch.distributed.ProcessGroup
+    ) -> torch.Tensor:
+        ctx.process_group = process_group
+        return gather_along_first_dim(x, process_group=process_group)
+
+    @staticmethod
+    def backward(  # type: ignore[override]
+        ctx, grad_output: torch.Tensor
+    ) -> Tuple[torch.Tensor, None]:
+        return (
+            reduce_scatter_along_first_dim(
+                grad_output, process_group=ctx.process_group
+            ),
+            None,
+        )
+
+
+def gather_from_sequence_parallel_region(
+    x: torch.Tensor, process_group: torch.distributed.ProcessGroup
+) -> torch.Tensor:
+    return _GatherFromSequenceParallelRegion.apply(x, process_group)
+
+
+class _ScatterToSequenceParallelRegion(torch.autograd.Function):
+    @staticmethod
+    def forward(  # type: ignore[override]
+        ctx, x: torch.Tensor, process_group: torch.distributed.ProcessGroup
+    ) -> torch.Tensor:
+        ctx.process_group = process_group
+        return reduce_scatter_along_first_dim(x, process_group=process_group)
+
+    @staticmethod
+    def backward(  # type: ignore[override]
+        ctx, grad_output: torch.Tensor
+    ) -> Tuple[torch.Tensor, None]:
+        return (
+            gather_along_first_dim(grad_output, process_group=ctx.process_group),
+            None,
+        )
+
+
+def scatter_to_sequence_parallel_region(
+    x: torch.Tensor, process_group: torch.distributed.ProcessGroup
+) -> torch.Tensor:
+    return _ScatterToSequenceParallelRegion.apply(x, process_group)