Add files using upload-large-folder tool

.gitattributes

@@ -597,3 +597,4 @@ valley/lib/python3.10/site-packages/idna/__pycache__/uts46data.cpython-310.pyc f
 wemm/lib/libtinfow.so.6.4 filter=lfs diff=lfs merge=lfs -text
 valley/lib/python3.10/site-packages/triton/backends/nvidia/bin/nvdisasm filter=lfs diff=lfs merge=lfs -text
 valley/lib/python3.10/site-packages/triton/_C/libproton.so filter=lfs diff=lfs merge=lfs -text
+valley/lib/python3.10/site-packages/sympy/core/__pycache__/expr.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

valley/lib/python3.10/site-packages/sympy/core/__pycache__/expr.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40c19bd2fb1a3ca3f66df799fe6dcbf980142bc875bde7ab5ec0359e57f50d49
+size 114993

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

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

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

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

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

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

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

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

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

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

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

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

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

valley/lib/python3.10/site-packages/sympy/polys/tests/test_hypothesis.py

@@ -0,0 +1,36 @@
+from hypothesis import given
+from hypothesis import strategies as st
+from sympy.abc import x
+from sympy.polys.polytools import Poly
+
+
+def polys(*, nonzero=False, domain="ZZ"):
+    # This is a simple strategy, but sufficient the tests below
+    elems = {"ZZ": st.integers(), "QQ": st.fractions()}
+    coeff_st = st.lists(elems[domain])
+    if nonzero:
+        coeff_st = coeff_st.filter(any)
+    return st.builds(Poly, coeff_st, st.just(x), domain=st.just(domain))
+
+
+@given(f=polys(), g=polys(), r=polys())
+def test_gcd_hypothesis(f, g, r):
+    gcd_1 = f.gcd(g)
+    gcd_2 = g.gcd(f)
+    assert gcd_1 == gcd_2
+
+    # multiply by r
+    gcd_3 = g.gcd(f + r * g)
+    assert gcd_1 == gcd_3
+
+
+@given(f_z=polys(), g_z=polys(nonzero=True))
+def test_poly_hypothesis_integers(f_z, g_z):
+    remainder_z = f_z.rem(g_z)
+    assert g_z.degree() >= remainder_z.degree() or remainder_z.degree() == 0
+
+
+@given(f_q=polys(domain="QQ"), g_q=polys(nonzero=True, domain="QQ"))
+def test_poly_hypothesis_rationals(f_q, g_q):
+    remainder_q = f_q.rem(g_q)
+    assert g_q.degree() >= remainder_q.degree() or remainder_q.degree() == 0

valley/lib/python3.10/site-packages/sympy/polys/tests/test_injections.py

@@ -0,0 +1,39 @@
+"""Tests for functions that inject symbols into the global namespace. """
+
+from sympy.polys.rings import vring
+from sympy.polys.fields import vfield
+from sympy.polys.domains import QQ
+
+def test_vring():
+    ns = {'vring':vring, 'QQ':QQ}
+    exec('R = vring("r", QQ)', ns)
+    exec('assert r == R.gens[0]', ns)
+
+    exec('R = vring("rb rbb rcc rzz _rx", QQ)', ns)
+    exec('assert rb == R.gens[0]', ns)
+    exec('assert rbb == R.gens[1]', ns)
+    exec('assert rcc == R.gens[2]', ns)
+    exec('assert rzz == R.gens[3]', ns)
+    exec('assert _rx == R.gens[4]', ns)
+
+    exec('R = vring(["rd", "re", "rfg"], QQ)', ns)
+    exec('assert rd == R.gens[0]', ns)
+    exec('assert re == R.gens[1]', ns)
+    exec('assert rfg == R.gens[2]', ns)
+
+def test_vfield():
+    ns = {'vfield':vfield, 'QQ':QQ}
+    exec('F = vfield("f", QQ)', ns)
+    exec('assert f == F.gens[0]', ns)
+
+    exec('F = vfield("fb fbb fcc fzz _fx", QQ)', ns)
+    exec('assert fb == F.gens[0]', ns)
+    exec('assert fbb == F.gens[1]', ns)
+    exec('assert fcc == F.gens[2]', ns)
+    exec('assert fzz == F.gens[3]', ns)
+    exec('assert _fx == F.gens[4]', ns)
+
+    exec('F = vfield(["fd", "fe", "ffg"], QQ)', ns)
+    exec('assert fd == F.gens[0]', ns)
+    exec('assert fe == F.gens[1]', ns)
+    exec('assert ffg == F.gens[2]', ns)

valley/lib/python3.10/site-packages/sympy/polys/tests/test_multivariate_resultants.py

@@ -0,0 +1,294 @@
+"""Tests for Dixon's and Macaulay's classes. """
+
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import factor
+from sympy.core import symbols
+from sympy.tensor.indexed import IndexedBase
+
+from sympy.polys.multivariate_resultants import (DixonResultant,
+                                                 MacaulayResultant)
+
+c, d = symbols("a, b")
+x, y = symbols("x, y")
+
+p =  c * x + y
+q =  x + d * y
+
+dixon = DixonResultant(polynomials=[p, q], variables=[x, y])
+macaulay = MacaulayResultant(polynomials=[p, q], variables=[x, y])
+
+def test_dixon_resultant_init():
+    """Test init method of DixonResultant."""
+    a = IndexedBase("alpha")
+
+    assert dixon.polynomials == [p, q]
+    assert dixon.variables == [x, y]
+    assert dixon.n == 2
+    assert dixon.m == 2
+    assert dixon.dummy_variables == [a[0], a[1]]
+
+def test_get_dixon_polynomial_numerical():
+    """Test Dixon's polynomial for a numerical example."""
+    a = IndexedBase("alpha")
+
+    p = x + y
+    q = x ** 2 + y **3
+    h = x ** 2 + y
+
+    dixon = DixonResultant([p, q, h], [x, y])
+    polynomial = -x * y ** 2 * a[0] - x * y ** 2 * a[1] - x * y * a[0] \
+    * a[1] - x * y * a[1] ** 2 - x * a[0] * a[1] ** 2 + x * a[0] - \
+    y ** 2 * a[0] * a[1] + y ** 2 * a[1] - y * a[0] * a[1] ** 2 + y * \
+    a[1] ** 2
+
+    assert dixon.get_dixon_polynomial().as_expr().expand() == polynomial
+
+def test_get_max_degrees():
+    """Tests max degrees function."""
+
+    p = x + y
+    q = x ** 2 + y **3
+    h = x ** 2 + y
+
+    dixon = DixonResultant(polynomials=[p, q, h], variables=[x, y])
+    dixon_polynomial = dixon.get_dixon_polynomial()
+
+    assert dixon.get_max_degrees(dixon_polynomial) == [1, 2]
+
+def test_get_dixon_matrix():
+    """Test Dixon's resultant for a numerical example."""
+
+    x, y = symbols('x, y')
+
+    p = x + y
+    q = x ** 2 + y ** 3
+    h = x ** 2 + y
+
+    dixon = DixonResultant([p, q, h], [x, y])
+    polynomial = dixon.get_dixon_polynomial()
+
+    assert dixon.get_dixon_matrix(polynomial).det() == 0
+
+def test_get_dixon_matrix_example_two():
+    """Test Dixon's matrix for example from [Palancz08]_."""
+    x, y, z = symbols('x, y, z')
+
+    f = x ** 2 + y ** 2 - 1 + z * 0
+    g = x ** 2 + z ** 2 - 1 + y * 0
+    h = y ** 2 + z ** 2 - 1
+
+    example_two = DixonResultant([f, g, h], [y, z])
+    poly = example_two.get_dixon_polynomial()
+    matrix = example_two.get_dixon_matrix(poly)
+
+    expr = 1 - 8 * x ** 2 + 24 * x ** 4 - 32 * x ** 6 + 16 * x ** 8
+    assert (matrix.det() - expr).expand() == 0
+
+def test_KSY_precondition():
+    """Tests precondition for KSY Resultant."""
+    A, B, C = symbols('A, B, C')
+
+    m1 = Matrix([[1, 2, 3],
+                 [4, 5, 12],
+                 [6, 7, 18]])
+
+    m2 = Matrix([[0, C**2],
+                 [-2 * C, -C ** 2]])
+
+    m3 = Matrix([[1, 0],
+                 [0, 1]])
+
+    m4 = Matrix([[A**2, 0, 1],
+                 [A, 1, 1 / A]])
+
+    m5 = Matrix([[5, 1],
+                 [2, B],
+                 [0, 1],
+                 [0, 0]])
+
+    assert dixon.KSY_precondition(m1) == False
+    assert dixon.KSY_precondition(m2) == True
+    assert dixon.KSY_precondition(m3) == True
+    assert dixon.KSY_precondition(m4) == False
+    assert dixon.KSY_precondition(m5) == True
+
+def test_delete_zero_rows_and_columns():
+    """Tests method for deleting rows and columns containing only zeros."""
+    A, B, C = symbols('A, B, C')
+
+    m1 = Matrix([[0, 0],
+                 [0, 0],
+                 [1, 2]])
+
+    m2 = Matrix([[0, 1, 2],
+                 [0, 3, 4],
+                 [0, 5, 6]])
+
+    m3 = Matrix([[0, 0, 0, 0],
+                 [0, 1, 2, 0],
+                 [0, 3, 4, 0],
+                 [0, 0, 0, 0]])
+
+    m4 = Matrix([[1, 0, 2],
+                 [0, 0, 0],
+                 [3, 0, 4]])
+
+    m5 = Matrix([[0, 0, 0, 1],
+                 [0, 0, 0, 2],
+                 [0, 0, 0, 3],
+                 [0, 0, 0, 4]])
+
+    m6 = Matrix([[0, 0, A],
+                 [B, 0, 0],
+                 [0, 0, C]])
+
+    assert dixon.delete_zero_rows_and_columns(m1) == Matrix([[1, 2]])
+
+    assert dixon.delete_zero_rows_and_columns(m2) == Matrix([[1, 2],
+                                                             [3, 4],
+                                                             [5, 6]])
+
+    assert dixon.delete_zero_rows_and_columns(m3) == Matrix([[1, 2],
+                                                             [3, 4]])
+
+    assert dixon.delete_zero_rows_and_columns(m4) == Matrix([[1, 2],
+                                                             [3, 4]])
+
+    assert dixon.delete_zero_rows_and_columns(m5) == Matrix([[1],
+                                                             [2],
+                                                             [3],
+                                                             [4]])
+
+    assert dixon.delete_zero_rows_and_columns(m6) == Matrix([[0, A],
+                                                             [B, 0],
+                                                             [0, C]])
+
+def test_product_leading_entries():
+    """Tests product of leading entries method."""
+    A, B = symbols('A, B')
+
+    m1 = Matrix([[1, 2, 3],
+                 [0, 4, 5],
+                 [0, 0, 6]])
+
+    m2 = Matrix([[0, 0, 1],
+                 [2, 0, 3]])
+
+    m3 = Matrix([[0, 0, 0],
+                 [1, 2, 3],
+                 [0, 0, 0]])
+
+    m4 = Matrix([[0, 0, A],
+                 [1, 2, 3],
+                 [B, 0, 0]])
+
+    assert dixon.product_leading_entries(m1) == 24
+    assert dixon.product_leading_entries(m2) == 2
+    assert dixon.product_leading_entries(m3) == 1
+    assert dixon.product_leading_entries(m4) == A * B
+
+def test_get_KSY_Dixon_resultant_example_one():
+    """Tests the KSY Dixon resultant for example one"""
+    x, y, z = symbols('x, y, z')
+
+    p = x * y * z
+    q = x**2 - z**2
+    h = x + y + z
+    dixon = DixonResultant([p, q, h], [x, y])
+    dixon_poly = dixon.get_dixon_polynomial()
+    dixon_matrix = dixon.get_dixon_matrix(dixon_poly)
+    D = dixon.get_KSY_Dixon_resultant(dixon_matrix)
+
+    assert D == -z**3
+
+def test_get_KSY_Dixon_resultant_example_two():
+    """Tests the KSY Dixon resultant for example two"""
+    x, y, A = symbols('x, y, A')
+
+    p = x * y + x * A + x - A**2 - A + y**2 + y
+    q = x**2 + x * A - x + x * y + y * A - y
+    h = x**2 + x * y + 2 * x - x * A - y * A - 2 * A
+
+    dixon = DixonResultant([p, q, h], [x, y])
+    dixon_poly = dixon.get_dixon_polynomial()
+    dixon_matrix = dixon.get_dixon_matrix(dixon_poly)
+    D = factor(dixon.get_KSY_Dixon_resultant(dixon_matrix))
+
+    assert D == -8*A*(A - 1)*(A + 2)*(2*A - 1)**2
+
+def test_macaulay_resultant_init():
+    """Test init method of MacaulayResultant."""
+
+    assert macaulay.polynomials == [p, q]
+    assert macaulay.variables == [x, y]
+    assert macaulay.n == 2
+    assert macaulay.degrees == [1, 1]
+    assert macaulay.degree_m == 1
+    assert macaulay.monomials_size == 2
+
+def test_get_degree_m():
+    assert macaulay._get_degree_m() == 1
+
+def test_get_size():
+    assert macaulay.get_size() == 2
+
+def test_macaulay_example_one():
+    """Tests the Macaulay for example from [Bruce97]_"""
+
+    x, y, z = symbols('x, y, z')
+    a_1_1, a_1_2, a_1_3 = symbols('a_1_1, a_1_2, a_1_3')
+    a_2_2, a_2_3, a_3_3 = symbols('a_2_2, a_2_3, a_3_3')
+    b_1_1, b_1_2, b_1_3 = symbols('b_1_1, b_1_2, b_1_3')
+    b_2_2, b_2_3, b_3_3 = symbols('b_2_2, b_2_3, b_3_3')
+    c_1, c_2, c_3 = symbols('c_1, c_2, c_3')
+
+    f_1 = a_1_1 * x ** 2 + a_1_2 * x * y + a_1_3 * x * z + \
+          a_2_2 * y ** 2 + a_2_3 * y * z + a_3_3 * z ** 2
+    f_2 = b_1_1 * x ** 2 + b_1_2 * x * y + b_1_3 * x * z + \
+          b_2_2 * y ** 2 + b_2_3 * y * z + b_3_3 * z ** 2
+    f_3 = c_1 * x + c_2 * y + c_3 * z
+
+    mac = MacaulayResultant([f_1, f_2, f_3], [x, y, z])
+
+    assert mac.degrees == [2, 2, 1]
+    assert mac.degree_m == 3
+
+    assert mac.monomial_set == [x ** 3, x ** 2 * y, x ** 2 * z,
+                                x * y ** 2,
+                                x * y * z, x * z ** 2, y ** 3,
+                                y ** 2 *z, y * z ** 2, z ** 3]
+    assert mac.monomials_size == 10
+    assert mac.get_row_coefficients() == [[x, y, z], [x, y, z],
+                                          [x * y, x * z, y * z, z ** 2]]
+
+    matrix = mac.get_matrix()
+    assert matrix.shape == (mac.monomials_size, mac.monomials_size)
+    assert mac.get_submatrix(matrix) == Matrix([[a_1_1, a_2_2],
+                                                [b_1_1, b_2_2]])
+
+def test_macaulay_example_two():
+    """Tests the Macaulay formulation for example from [Stiller96]_."""
+
+    x, y, z = symbols('x, y, z')
+    a_0, a_1, a_2 = symbols('a_0, a_1, a_2')
+    b_0, b_1, b_2 = symbols('b_0, b_1, b_2')
+    c_0, c_1, c_2, c_3, c_4 = symbols('c_0, c_1, c_2, c_3, c_4')
+
+    f = a_0 * y -  a_1 * x + a_2 * z
+    g = b_1 * x ** 2 + b_0 * y ** 2 - b_2 * z ** 2
+    h = c_0 * y - c_1 * x ** 3 + c_2 * x ** 2 * z - c_3 * x * z ** 2 + \
+        c_4 * z ** 3
+
+    mac = MacaulayResultant([f, g, h], [x, y, z])
+
+    assert mac.degrees == [1, 2, 3]
+    assert mac.degree_m == 4
+    assert mac.monomials_size == 15
+    assert len(mac.get_row_coefficients()) == mac.n
+
+    matrix = mac.get_matrix()
+    assert matrix.shape == (mac.monomials_size, mac.monomials_size)
+    assert mac.get_submatrix(matrix) == Matrix([[-a_1, a_0, a_2, 0],
+                                                [0, -a_1, 0, 0],
+                                                [0, 0, -a_1, 0],
+                                                [0, 0, 0, -a_1]])

valley/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])

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

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

valley/lib/python3.10/site-packages/sympy/polys/tests/test_polyroots.py

@@ -0,0 +1,758 @@
+"""Tests for algorithms for computing symbolic roots of polynomials. """
+
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.functions.elementary.complexes import (conjugate, im, re)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.polys.domains.integerring import ZZ
+from sympy.sets.sets import Interval
+from sympy.simplify.powsimp import powsimp
+
+from sympy.polys import Poly, cyclotomic_poly, intervals, nroots, rootof
+
+from sympy.polys.polyroots import (root_factors, roots_linear,
+    roots_quadratic, roots_cubic, roots_quartic, roots_quintic,
+    roots_cyclotomic, roots_binomial, preprocess_roots, roots)
+
+from sympy.polys.orthopolys import legendre_poly
+from sympy.polys.polyerrors import PolynomialError, \
+    UnsolvableFactorError
+from sympy.polys.polyutils import _nsort
+
+from sympy.testing.pytest import raises, slow
+from sympy.core.random import verify_numerically
+import mpmath
+from itertools import product
+
+
+
+a, b, c, d, e, q, t, x, y, z = symbols('a,b,c,d,e,q,t,x,y,z')
+
+
+def _check(roots):
+    # this is the desired invariant for roots returned
+    # by all_roots. It is trivially true for linear
+    # polynomials.
+    nreal = sum(1 if i.is_real else 0 for i in roots)
+    assert sorted(roots[:nreal]) == list(roots[:nreal])
+    for ix in range(nreal, len(roots), 2):
+        if not (
+                roots[ix + 1] == roots[ix] or
+                roots[ix + 1] == conjugate(roots[ix])):
+            return False
+    return True
+
+
+def test_roots_linear():
+    assert roots_linear(Poly(2*x + 1, x)) == [Rational(-1, 2)]
+
+
+def test_roots_quadratic():
+    assert roots_quadratic(Poly(2*x**2, x)) == [0, 0]
+    assert roots_quadratic(Poly(2*x**2 + 3*x, x)) == [Rational(-3, 2), 0]
+    assert roots_quadratic(Poly(2*x**2 + 3, x)) == [-I*sqrt(6)/2, I*sqrt(6)/2]
+    assert roots_quadratic(Poly(2*x**2 + 4*x + 3, x)) == [-1 - I*sqrt(2)/2, -1 + I*sqrt(2)/2]
+    _check(Poly(2*x**2 + 4*x + 3, x).all_roots())
+
+    f = x**2 + (2*a*e + 2*c*e)/(a - c)*x + (d - b + a*e**2 - c*e**2)/(a - c)
+    assert roots_quadratic(Poly(f, x)) == \
+        [-e*(a + c)/(a - c) - sqrt(a*b + c*d - a*d - b*c + 4*a*c*e**2)/(a - c),
+         -e*(a + c)/(a - c) + sqrt(a*b + c*d - a*d - b*c + 4*a*c*e**2)/(a - c)]
+
+    # check for simplification
+    f = Poly(y*x**2 - 2*x - 2*y, x)
+    assert roots_quadratic(f) == \
+        [-sqrt(2*y**2 + 1)/y + 1/y, sqrt(2*y**2 + 1)/y + 1/y]
+    f = Poly(x**2 + (-y**2 - 2)*x + y**2 + 1, x)
+    assert roots_quadratic(f) == \
+        [1,y**2 + 1]
+
+    f = Poly(sqrt(2)*x**2 - 1, x)
+    r = roots_quadratic(f)
+    assert r == _nsort(r)
+
+    # issue 8255
+    f = Poly(-24*x**2 - 180*x + 264)
+    assert [w.n(2) for w in f.all_roots(radicals=True)] == \
+           [w.n(2) for w in f.all_roots(radicals=False)]
+    for _a, _b, _c in product((-2, 2), (-2, 2), (0, -1)):
+        f = Poly(_a*x**2 + _b*x + _c)
+        roots = roots_quadratic(f)
+        assert roots == _nsort(roots)
+
+
+def test_issue_7724():
+    eq = Poly(x**4*I + x**2 + I, x)
+    assert roots(eq) == {
+        sqrt(I/2 + sqrt(5)*I/2): 1,
+        sqrt(-sqrt(5)*I/2 + I/2): 1,
+        -sqrt(I/2 + sqrt(5)*I/2): 1,
+        -sqrt(-sqrt(5)*I/2 + I/2): 1}
+
+
+def test_issue_8438():
+    p = Poly([1, y, -2, -3], x).as_expr()
+    roots = roots_cubic(Poly(p, x), x)
+    z = Rational(-3, 2) - I*7/2  # this will fail in code given in commit msg
+    post = [r.subs(y, z) for r in roots]
+    assert set(post) == \
+    set(roots_cubic(Poly(p.subs(y, z), x)))
+    # /!\ if p is not made an expression, this is *very* slow
+    assert all(p.subs({y: z, x: i}).n(2, chop=True) == 0 for i in post)
+
+
+def test_issue_8285():
+    roots = (Poly(4*x**8 - 1, x)*Poly(x**2 + 1)).all_roots()
+    assert _check(roots)
+    f = Poly(x**4 + 5*x**2 + 6, x)
+    ro = [rootof(f, i) for i in range(4)]
+    roots = Poly(x**4 + 5*x**2 + 6, x).all_roots()
+    assert roots == ro
+    assert _check(roots)
+    # more than 2 complex roots from which to identify the
+    # imaginary ones
+    roots = Poly(2*x**8 - 1).all_roots()
+    assert _check(roots)
+    assert len(Poly(2*x**10 - 1).all_roots()) == 10  # doesn't fail
+
+
+def test_issue_8289():
+    roots = (Poly(x**2 + 2)*Poly(x**4 + 2)).all_roots()
+    assert _check(roots)
+    roots = Poly(x**6 + 3*x**3 + 2, x).all_roots()
+    assert _check(roots)
+    roots = Poly(x**6 - x + 1).all_roots()
+    assert _check(roots)
+    # all imaginary roots with multiplicity of 2
+    roots = Poly(x**4 + 4*x**2 + 4, x).all_roots()
+    assert _check(roots)
+
+
+def test_issue_14291():
+    assert Poly(((x - 1)**2 + 1)*((x - 1)**2 + 2)*(x - 1)
+        ).all_roots() == [1, 1 - I, 1 + I, 1 - sqrt(2)*I, 1 + sqrt(2)*I]
+    p = x**4 + 10*x**2 + 1
+    ans = [rootof(p, i) for i in range(4)]
+    assert Poly(p).all_roots() == ans
+    _check(ans)
+
+
+def test_issue_13340():
+    eq = Poly(y**3 + exp(x)*y + x, y, domain='EX')
+    roots_d = roots(eq)
+    assert len(roots_d) == 3
+
+
+def test_issue_14522():
+    eq = Poly(x**4 + x**3*(16 + 32*I) + x**2*(-285 + 386*I) + x*(-2824 - 448*I) - 2058 - 6053*I, x)
+    roots_eq = roots(eq)
+    assert all(eq(r) == 0 for r in roots_eq)
+
+
+def test_issue_15076():
+    sol = roots_quartic(Poly(t**4 - 6*t**2 + t/x - 3, t))
+    assert sol[0].has(x)
+
+
+def test_issue_16589():
+    eq = Poly(x**4 - 8*sqrt(2)*x**3 + 4*x**3 - 64*sqrt(2)*x**2 + 1024*x, x)
+    roots_eq = roots(eq)
+    assert 0 in roots_eq
+
+
+def test_roots_cubic():
+    assert roots_cubic(Poly(2*x**3, x)) == [0, 0, 0]
+    assert roots_cubic(Poly(x**3 - 3*x**2 + 3*x - 1, x)) == [1, 1, 1]
+
+    # valid for arbitrary y (issue 21263)
+    r = root(y, 3)
+    assert roots_cubic(Poly(x**3 - y, x)) == [r,
+        r*(-S.Half + sqrt(3)*I/2),
+        r*(-S.Half - sqrt(3)*I/2)]
+    # simpler form when y is negative
+    assert roots_cubic(Poly(x**3 - -1, x)) == \
+        [-1, S.Half - I*sqrt(3)/2, S.Half + I*sqrt(3)/2]
+    assert roots_cubic(Poly(2*x**3 - 3*x**2 - 3*x - 1, x))[0] == \
+         S.Half + 3**Rational(1, 3)/2 + 3**Rational(2, 3)/2
+    eq = -x**3 + 2*x**2 + 3*x - 2
+    assert roots(eq, trig=True, multiple=True) == \
+           roots_cubic(Poly(eq, x), trig=True) == [
+        Rational(2, 3) + 2*sqrt(13)*cos(acos(8*sqrt(13)/169)/3)/3,
+        -2*sqrt(13)*sin(-acos(8*sqrt(13)/169)/3 + pi/6)/3 + Rational(2, 3),
+        -2*sqrt(13)*cos(-acos(8*sqrt(13)/169)/3 + pi/3)/3 + Rational(2, 3),
+        ]
+
+
+def test_roots_quartic():
+    assert roots_quartic(Poly(x**4, x)) == [0, 0, 0, 0]
+    assert roots_quartic(Poly(x**4 + x**3, x)) in [
+        [-1, 0, 0, 0],
+        [0, -1, 0, 0],
+        [0, 0, -1, 0],
+        [0, 0, 0, -1]
+    ]
+    assert roots_quartic(Poly(x**4 - x**3, x)) in [
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1]
+    ]
+
+    lhs = roots_quartic(Poly(x**4 + x, x))
+    rhs = [S.Half + I*sqrt(3)/2, S.Half - I*sqrt(3)/2, S.Zero, -S.One]
+
+    assert sorted(lhs, key=hash) == sorted(rhs, key=hash)
+
+    # test of all branches of roots quartic
+    for i, (a, b, c, d) in enumerate([(1, 2, 3, 0),
+                                      (3, -7, -9, 9),
+                                      (1, 2, 3, 4),
+                                      (1, 2, 3, 4),
+                                      (-7, -3, 3, -6),
+                                      (-3, 5, -6, -4),
+                                      (6, -5, -10, -3)]):
+        if i == 2:
+            c = -a*(a**2/S(8) - b/S(2))
+        elif i == 3:
+            d = a*(a*(a**2*Rational(3, 256) - b/S(16)) + c/S(4))
+        eq = x**4 + a*x**3 + b*x**2 + c*x + d
+        ans = roots_quartic(Poly(eq, x))
+        assert all(eq.subs(x, ai).n(chop=True) == 0 for ai in ans)
+
+    # not all symbolic quartics are unresolvable
+    eq = Poly(q*x + q/4 + x**4 + x**3 + 2*x**2 - Rational(1, 3), x)
+    sol = roots_quartic(eq)
+    assert all(verify_numerically(eq.subs(x, i), 0) for i in sol)
+    z = symbols('z', negative=True)
+    eq = x**4 + 2*x**3 + 3*x**2 + x*(z + 11) + 5
+    zans = roots_quartic(Poly(eq, x))
+    assert all(verify_numerically(eq.subs(((x, i), (z, -1))), 0) for i in zans)
+    # but some are (see also issue 4989)
+    # it's ok if the solution is not Piecewise, but the tests below should pass
+    eq = Poly(y*x**4 + x**3 - x + z, x)
+    ans = roots_quartic(eq)
+    assert all(type(i) == Piecewise for i in ans)
+    reps = (
+        {"y": Rational(-1, 3), "z": Rational(-1, 4)},  # 4 real
+        {"y": Rational(-1, 3), "z": Rational(-1, 2)},  # 2 real
+        {"y": Rational(-1, 3), "z": -2})  # 0 real
+    for rep in reps:
+        sol = roots_quartic(Poly(eq.subs(rep), x))
+        assert all(verify_numerically(w.subs(rep) - s, 0) for w, s in zip(ans, sol))
+
+
+def test_issue_21287():
+    assert not any(isinstance(i, Piecewise) for i in roots_quartic(
+        Poly(x**4 - x**2*(3 + 5*I) + 2*x*(-1 + I) - 1 + 3*I, x)))
+
+
+def test_roots_quintic():
+    eqs = (x**5 - 2,
+            (x/2 + 1)**5 - 5*(x/2 + 1) + 12,
+            x**5 - 110*x**3 - 55*x**2 + 2310*x + 979)
+    for eq in eqs:
+        roots = roots_quintic(Poly(eq))
+        assert len(roots) == 5
+        assert all(eq.subs(x, r.n(10)).n(chop = 1e-5) == 0 for r in roots)
+
+
+def test_roots_cyclotomic():
+    assert roots_cyclotomic(cyclotomic_poly(1, x, polys=True)) == [1]
+    assert roots_cyclotomic(cyclotomic_poly(2, x, polys=True)) == [-1]
+    assert roots_cyclotomic(cyclotomic_poly(
+        3, x, polys=True)) == [Rational(-1, 2) - I*sqrt(3)/2, Rational(-1, 2) + I*sqrt(3)/2]
+    assert roots_cyclotomic(cyclotomic_poly(4, x, polys=True)) == [-I, I]
+    assert roots_cyclotomic(cyclotomic_poly(
+        6, x, polys=True)) == [S.Half - I*sqrt(3)/2, S.Half + I*sqrt(3)/2]
+
+    assert roots_cyclotomic(cyclotomic_poly(7, x, polys=True)) == [
+        -cos(pi/7) - I*sin(pi/7),
+        -cos(pi/7) + I*sin(pi/7),
+        -cos(pi*Rational(3, 7)) - I*sin(pi*Rational(3, 7)),
+        -cos(pi*Rational(3, 7)) + I*sin(pi*Rational(3, 7)),
+        cos(pi*Rational(2, 7)) - I*sin(pi*Rational(2, 7)),
+        cos(pi*Rational(2, 7)) + I*sin(pi*Rational(2, 7)),
+    ]
+
+    assert roots_cyclotomic(cyclotomic_poly(8, x, polys=True)) == [
+        -sqrt(2)/2 - I*sqrt(2)/2,
+        -sqrt(2)/2 + I*sqrt(2)/2,
+        sqrt(2)/2 - I*sqrt(2)/2,
+        sqrt(2)/2 + I*sqrt(2)/2,
+    ]
+
+    assert roots_cyclotomic(cyclotomic_poly(12, x, polys=True)) == [
+        -sqrt(3)/2 - I/2,
+        -sqrt(3)/2 + I/2,
+        sqrt(3)/2 - I/2,
+        sqrt(3)/2 + I/2,
+    ]
+
+    assert roots_cyclotomic(
+        cyclotomic_poly(1, x, polys=True), factor=True) == [1]
+    assert roots_cyclotomic(
+        cyclotomic_poly(2, x, polys=True), factor=True) == [-1]
+
+    assert roots_cyclotomic(cyclotomic_poly(3, x, polys=True), factor=True) == \
+        [-root(-1, 3), -1 + root(-1, 3)]
+    assert roots_cyclotomic(cyclotomic_poly(4, x, polys=True), factor=True) == \
+        [-I, I]
+    assert roots_cyclotomic(cyclotomic_poly(5, x, polys=True), factor=True) == \
+        [-root(-1, 5), -root(-1, 5)**3, root(-1, 5)**2, -1 - root(-1, 5)**2 + root(-1, 5) + root(-1, 5)**3]
+
+    assert roots_cyclotomic(cyclotomic_poly(6, x, polys=True), factor=True) == \
+        [1 - root(-1, 3), root(-1, 3)]
+
+
+def test_roots_binomial():
+    assert roots_binomial(Poly(5*x, x)) == [0]
+    assert roots_binomial(Poly(5*x**4, x)) == [0, 0, 0, 0]
+    assert roots_binomial(Poly(5*x + 2, x)) == [Rational(-2, 5)]
+
+    A = 10**Rational(3, 4)/10
+
+    assert roots_binomial(Poly(5*x**4 + 2, x)) == \
+        [-A - A*I, -A + A*I, A - A*I, A + A*I]
+    _check(roots_binomial(Poly(x**8 - 2)))
+
+    a1 = Symbol('a1', nonnegative=True)
+    b1 = Symbol('b1', nonnegative=True)
+
+    r0 = roots_quadratic(Poly(a1*x**2 + b1, x))
+    r1 = roots_binomial(Poly(a1*x**2 + b1, x))
+
+    assert powsimp(r0[0]) == powsimp(r1[0])
+    assert powsimp(r0[1]) == powsimp(r1[1])
+    for a, b, s, n in product((1, 2), (1, 2), (-1, 1), (2, 3, 4, 5)):
+        if a == b and a != 1:  # a == b == 1 is sufficient
+            continue
+        p = Poly(a*x**n + s*b)
+        ans = roots_binomial(p)
+        assert ans == _nsort(ans)
+
+    # issue 8813
+    assert roots(Poly(2*x**3 - 16*y**3, x)) == {
+        2*y*(Rational(-1, 2) - sqrt(3)*I/2): 1,
+        2*y: 1,
+        2*y*(Rational(-1, 2) + sqrt(3)*I/2): 1}
+
+
+def test_roots_preprocessing():
+    f = a*y*x**2 + y - b
+
+    coeff, poly = preprocess_roots(Poly(f, x))
+
+    assert coeff == 1
+    assert poly == Poly(a*y*x**2 + y - b, x)
+
+    f = c**3*x**3 + c**2*x**2 + c*x + a
+
+    coeff, poly = preprocess_roots(Poly(f, x))
+
+    assert coeff == 1/c
+    assert poly == Poly(x**3 + x**2 + x + a, x)
+
+    f = c**3*x**3 + c**2*x**2 + a
+
+    coeff, poly = preprocess_roots(Poly(f, x))
+
+    assert coeff == 1/c
+    assert poly == Poly(x**3 + x**2 + a, x)
+
+    f = c**3*x**3 + c*x + a
+
+    coeff, poly = preprocess_roots(Poly(f, x))
+
+    assert coeff == 1/c
+    assert poly == Poly(x**3 + x + a, x)
+
+    f = c**3*x**3 + a
+
+    coeff, poly = preprocess_roots(Poly(f, x))
+
+    assert coeff == 1/c
+    assert poly == Poly(x**3 + a, x)
+
+    E, F, J, L = symbols("E,F,J,L")
+
+    f = -21601054687500000000*E**8*J**8/L**16 + \
+        508232812500000000*F*x*E**7*J**7/L**14 - \
+        4269543750000000*E**6*F**2*J**6*x**2/L**12 + \
+        16194716250000*E**5*F**3*J**5*x**3/L**10 - \
+        27633173750*E**4*F**4*J**4*x**4/L**8 + \
+        14840215*E**3*F**5*J**3*x**5/L**6 + \
+        54794*E**2*F**6*J**2*x**6/(5*L**4) - \
+        1153*E*J*F**7*x**7/(80*L**2) + \
+        633*F**8*x**8/160000
+
+    coeff, poly = preprocess_roots(Poly(f, x))
+
+    assert coeff == 20*E*J/(F*L**2)
+    assert poly == 633*x**8 - 115300*x**7 + 4383520*x**6 + 296804300*x**5 - 27633173750*x**4 + \
+        809735812500*x**3 - 10673859375000*x**2 + 63529101562500*x - 135006591796875
+
+    f = Poly(-y**2 + x**2*exp(x), y, domain=ZZ[x, exp(x)])
+    g = Poly(-y**2 + exp(x), y, domain=ZZ[exp(x)])
+
+    assert preprocess_roots(f) == (x, g)
+
+
+def test_roots0():
+    assert roots(1, x) == {}
+    assert roots(x, x) == {S.Zero: 1}
+    assert roots(x**9, x) == {S.Zero: 9}
+    assert roots(((x - 2)*(x + 3)*(x - 4)).expand(), x) == {-S(3): 1, S(2): 1, S(4): 1}
+
+    assert roots(2*x + 1, x) == {Rational(-1, 2): 1}
+    assert roots((2*x + 1)**2, x) == {Rational(-1, 2): 2}
+    assert roots((2*x + 1)**5, x) == {Rational(-1, 2): 5}
+    assert roots((2*x + 1)**10, x) == {Rational(-1, 2): 10}
+
+    assert roots(x**4 - 1, x) == {I: 1, S.One: 1, -S.One: 1, -I: 1}
+    assert roots((x**4 - 1)**2, x) == {I: 2, S.One: 2, -S.One: 2, -I: 2}
+
+    assert roots(((2*x - 3)**2).expand(), x) == {Rational( 3, 2): 2}
+    assert roots(((2*x + 3)**2).expand(), x) == {Rational(-3, 2): 2}
+
+    assert roots(((2*x - 3)**3).expand(), x) == {Rational( 3, 2): 3}
+    assert roots(((2*x + 3)**3).expand(), x) == {Rational(-3, 2): 3}
+
+    assert roots(((2*x - 3)**5).expand(), x) == {Rational( 3, 2): 5}
+    assert roots(((2*x + 3)**5).expand(), x) == {Rational(-3, 2): 5}
+
+    assert roots(((a*x - b)**5).expand(), x) == { b/a: 5}
+    assert roots(((a*x + b)**5).expand(), x) == {-b/a: 5}
+
+    assert roots(x**2 + (-a - 1)*x + a, x) == {a: 1, S.One: 1}
+
+    assert roots(x**4 - 2*x**2 + 1, x) == {S.One: 2, S.NegativeOne: 2}
+
+    assert roots(x**6 - 4*x**4 + 4*x**3 - x**2, x) == \
+        {S.One: 2, -1 - sqrt(2): 1, S.Zero: 2, -1 + sqrt(2): 1}
+
+    assert roots(x**8 - 1, x) == {
+        sqrt(2)/2 + I*sqrt(2)/2: 1,
+        sqrt(2)/2 - I*sqrt(2)/2: 1,
+        -sqrt(2)/2 + I*sqrt(2)/2: 1,
+        -sqrt(2)/2 - I*sqrt(2)/2: 1,
+        S.One: 1, -S.One: 1, I: 1, -I: 1
+    }
+
+    f = -2016*x**2 - 5616*x**3 - 2056*x**4 + 3324*x**5 + 2176*x**6 - \
+        224*x**7 - 384*x**8 - 64*x**9
+
+    assert roots(f) == {S.Zero: 2, -S(2): 2, S(2): 1, Rational(-7, 2): 1,
+                Rational(-3, 2): 1, Rational(-1, 2): 1, Rational(3, 2): 1}
+
+    assert roots((a + b + c)*x - (a + b + c + d), x) == {(a + b + c + d)/(a + b + c): 1}
+
+    assert roots(x**3 + x**2 - x + 1, x, cubics=False) == {}
+    assert roots(((x - 2)*(
+        x + 3)*(x - 4)).expand(), x, cubics=False) == {-S(3): 1, S(2): 1, S(4): 1}
+    assert roots(((x - 2)*(x + 3)*(x - 4)*(x - 5)).expand(), x, cubics=False) == \
+        {-S(3): 1, S(2): 1, S(4): 1, S(5): 1}
+    assert roots(x**3 + 2*x**2 + 4*x + 8, x) == {-S(2): 1, -2*I: 1, 2*I: 1}
+    assert roots(x**3 + 2*x**2 + 4*x + 8, x, cubics=True) == \
+        {-2*I: 1, 2*I: 1, -S(2): 1}
+    assert roots((x**2 - x)*(x**3 + 2*x**2 + 4*x + 8), x ) == \
+        {S.One: 1, S.Zero: 1, -S(2): 1, -2*I: 1, 2*I: 1}
+
+    r1_2, r1_3 = S.Half, Rational(1, 3)
+
+    x0 = (3*sqrt(33) + 19)**r1_3
+    x1 = 4/x0/3
+    x2 = x0/3
+    x3 = sqrt(3)*I/2
+    x4 = x3 - r1_2
+    x5 = -x3 - r1_2
+    assert roots(x**3 + x**2 - x + 1, x, cubics=True) == {
+        -x1 - x2 - r1_3: 1,
+        -x1/x4 - x2*x4 - r1_3: 1,
+        -x1/x5 - x2*x5 - r1_3: 1,
+    }
+
+    f = (x**2 + 2*x + 3).subs(x, 2*x**2 + 3*x).subs(x, 5*x - 4)
+
+    r13_20, r1_20 = [ Rational(*r)
+        for r in ((13, 20), (1, 20)) ]
+
+    s2 = sqrt(2)
+    assert roots(f, x) == {
+        r13_20 + r1_20*sqrt(1 - 8*I*s2): 1,
+        r13_20 - r1_20*sqrt(1 - 8*I*s2): 1,
+        r13_20 + r1_20*sqrt(1 + 8*I*s2): 1,
+        r13_20 - r1_20*sqrt(1 + 8*I*s2): 1,
+    }
+
+    f = x**4 + x**3 + x**2 + x + 1
+
+    r1_4, r1_8, r5_8 = [ Rational(*r) for r in ((1, 4), (1, 8), (5, 8)) ]
+
+    assert roots(f, x) == {
+        -r1_4 + r1_4*5**r1_2 + I*(r5_8 + r1_8*5**r1_2)**r1_2: 1,
+        -r1_4 + r1_4*5**r1_2 - I*(r5_8 + r1_8*5**r1_2)**r1_2: 1,
+        -r1_4 - r1_4*5**r1_2 + I*(r5_8 - r1_8*5**r1_2)**r1_2: 1,
+        -r1_4 - r1_4*5**r1_2 - I*(r5_8 - r1_8*5**r1_2)**r1_2: 1,
+    }
+
+    f = z**3 + (-2 - y)*z**2 + (1 + 2*y - 2*x**2)*z - y + 2*x**2
+
+    assert roots(f, z) == {
+        S.One: 1,
+        S.Half + S.Half*y + S.Half*sqrt(1 - 2*y + y**2 + 8*x**2): 1,
+        S.Half + S.Half*y - S.Half*sqrt(1 - 2*y + y**2 + 8*x**2): 1,
+    }
+
+    assert roots(a*b*c*x**3 + 2*x**2 + 4*x + 8, x, cubics=False) == {}
+    assert roots(a*b*c*x**3 + 2*x**2 + 4*x + 8, x, cubics=True) != {}
+
+    assert roots(x**4 - 1, x, filter='Z') == {S.One: 1, -S.One: 1}
+    assert roots(x**4 - 1, x, filter='I') == {I: 1, -I: 1}
+
+    assert roots((x - 1)*(x + 1), x) == {S.One: 1, -S.One: 1}
+    assert roots(
+        (x - 1)*(x + 1), x, predicate=lambda r: r.is_positive) == {S.One: 1}
+
+    assert roots(x**4 - 1, x, filter='Z', multiple=True) == [-S.One, S.One]
+    assert roots(x**4 - 1, x, filter='I', multiple=True) == [I, -I]
+
+    ar, br = symbols('a, b', real=True)
+    p = x**2*(ar-br)**2 + 2*x*(br-ar) + 1
+    assert roots(p, x, filter='R') == {1/(ar - br): 2}
+
+    assert roots(x**3, x, multiple=True) == [S.Zero, S.Zero, S.Zero]
+    assert roots(1234, x, multiple=True) == []
+
+    f = x**6 - x**5 + x**4 - x**3 + x**2 - x + 1
+
+    assert roots(f) == {
+        -I*sin(pi/7) + cos(pi/7): 1,
+        -I*sin(pi*Rational(2, 7)) - cos(pi*Rational(2, 7)): 1,
+        -I*sin(pi*Rational(3, 7)) + cos(pi*Rational(3, 7)): 1,
+        I*sin(pi/7) + cos(pi/7): 1,
+        I*sin(pi*Rational(2, 7)) - cos(pi*Rational(2, 7)): 1,
+        I*sin(pi*Rational(3, 7)) + cos(pi*Rational(3, 7)): 1,
+    }
+
+    g = ((x**2 + 1)*f**2).expand()
+
+    assert roots(g) == {
+        -I*sin(pi/7) + cos(pi/7): 2,
+        -I*sin(pi*Rational(2, 7)) - cos(pi*Rational(2, 7)): 2,
+        -I*sin(pi*Rational(3, 7)) + cos(pi*Rational(3, 7)): 2,
+        I*sin(pi/7) + cos(pi/7): 2,
+        I*sin(pi*Rational(2, 7)) - cos(pi*Rational(2, 7)): 2,
+        I*sin(pi*Rational(3, 7)) + cos(pi*Rational(3, 7)): 2,
+        -I: 1, I: 1,
+    }
+
+    r = roots(x**3 + 40*x + 64)
+    real_root = [rx for rx in r if rx.is_real][0]
+    cr = 108 + 6*sqrt(1074)
+    assert real_root == -2*root(cr, 3)/3 + 20/root(cr, 3)
+
+    eq = Poly((7 + 5*sqrt(2))*x**3 + (-6 - 4*sqrt(2))*x**2 + (-sqrt(2) - 1)*x + 2, x, domain='EX')
+    assert roots(eq) == {-1 + sqrt(2): 1, -2 + 2*sqrt(2): 1, -sqrt(2) + 1: 1}
+
+    eq = Poly(41*x**5 + 29*sqrt(2)*x**5 - 153*x**4 - 108*sqrt(2)*x**4 +
+    175*x**3 + 125*sqrt(2)*x**3 - 45*x**2 - 30*sqrt(2)*x**2 - 26*sqrt(2)*x -
+    26*x + 24, x, domain='EX')
+    assert roots(eq) == {-sqrt(2) + 1: 1, -2 + 2*sqrt(2): 1, -1 + sqrt(2): 1,
+                         -4 + 4*sqrt(2): 1, -3 + 3*sqrt(2): 1}
+
+    eq = Poly(x**3 - 2*x**2 + 6*sqrt(2)*x**2 - 8*sqrt(2)*x + 23*x - 14 +
+            14*sqrt(2), x, domain='EX')
+    assert roots(eq) == {-2*sqrt(2) + 2: 1, -2*sqrt(2) + 1: 1, -2*sqrt(2) - 1: 1}
+
+    assert roots(Poly((x + sqrt(2))**3 - 7, x, domain='EX')) == \
+        {-sqrt(2) + root(7, 3)*(-S.Half - sqrt(3)*I/2): 1,
+         -sqrt(2) + root(7, 3)*(-S.Half + sqrt(3)*I/2): 1,
+         -sqrt(2) + root(7, 3): 1}
+
+def test_roots_slow():
+    """Just test that calculating these roots does not hang. """
+    a, b, c, d, x = symbols("a,b,c,d,x")
+
+    f1 = x**2*c + (a/b) + x*c*d - a
+    f2 = x**2*(a + b*(c - d)*a) + x*a*b*c/(b*d - d) + (a*d - c/d)
+
+    assert list(roots(f1, x).values()) == [1, 1]
+    assert list(roots(f2, x).values()) == [1, 1]
+
+    (zz, yy, xx, zy, zx, yx, k) = symbols("zz,yy,xx,zy,zx,yx,k")
+
+    e1 = (zz - k)*(yy - k)*(xx - k) + zy*yx*zx + zx - zy - yx
+    e2 = (zz - k)*yx*yx + zx*(yy - k)*zx + zy*zy*(xx - k)
+
+    assert list(roots(e1 - e2, k).values()) == [1, 1, 1]
+
+    f = x**3 + 2*x**2 + 8
+    R = list(roots(f).keys())
+
+    assert not any(i for i in [f.subs(x, ri).n(chop=True) for ri in R])
+
+
+def test_roots_inexact():
+    R1 = roots(x**2 + x + 1, x, multiple=True)
+    R2 = roots(x**2 + x + 1.0, x, multiple=True)
+
+    for r1, r2 in zip(R1, R2):
+        assert abs(r1 - r2) < 1e-12
+
+    f = x**4 + 3.0*sqrt(2.0)*x**3 - (78.0 + 24.0*sqrt(3.0))*x**2 \
+        + 144.0*(2*sqrt(3.0) + 9.0)
+
+    R1 = roots(f, multiple=True)
+    R2 = (-12.7530479110482, -3.85012393732929,
+          4.89897948556636, 7.46155167569183)
+
+    for r1, r2 in zip(R1, R2):
+        assert abs(r1 - r2) < 1e-10
+
+
+def test_roots_preprocessed():
+    E, F, J, L = symbols("E,F,J,L")
+
+    f = -21601054687500000000*E**8*J**8/L**16 + \
+        508232812500000000*F*x*E**7*J**7/L**14 - \
+        4269543750000000*E**6*F**2*J**6*x**2/L**12 + \
+        16194716250000*E**5*F**3*J**5*x**3/L**10 - \
+        27633173750*E**4*F**4*J**4*x**4/L**8 + \
+        14840215*E**3*F**5*J**3*x**5/L**6 + \
+        54794*E**2*F**6*J**2*x**6/(5*L**4) - \
+        1153*E*J*F**7*x**7/(80*L**2) + \
+        633*F**8*x**8/160000
+
+    assert roots(f, x) == {}
+
+    R1 = roots(f.evalf(), x, multiple=True)
+    R2 = [-1304.88375606366, 97.1168816800648, 186.946430171876, 245.526792947065,
+          503.441004174773, 791.549343830097, 1273.16678129348, 1850.10650616851]
+
+    w = Wild('w')
+    p = w*E*J/(F*L**2)
+
+    assert len(R1) == len(R2)
+
+    for r1, r2 in zip(R1, R2):
+        match = r1.match(p)
+        assert match is not None and abs(match[w] - r2) < 1e-10
+
+
+def test_roots_strict():
+    assert roots(x**2 - 2*x + 1, strict=False) == {1: 2}
+    assert roots(x**2 - 2*x + 1, strict=True) == {1: 2}
+
+    assert roots(x**6 - 2*x**5 - x**2 + 3*x - 2, strict=False) == {2: 1}
+    raises(UnsolvableFactorError, lambda: roots(x**6 - 2*x**5 - x**2 + 3*x - 2, strict=True))
+
+
+def test_roots_mixed():
+    f = -1936 - 5056*x - 7592*x**2 + 2704*x**3 - 49*x**4
+
+    _re, _im = intervals(f, all=True)
+    _nroots = nroots(f)
+    _sroots = roots(f, multiple=True)
+
+    _re = [ Interval(a, b) for (a, b), _ in _re ]
+    _im = [ Interval(re(a), re(b))*Interval(im(a), im(b)) for (a, b),
+            _ in _im ]
+
+    _intervals = _re + _im
+    _sroots = [ r.evalf() for r in _sroots ]
+
+    _nroots = sorted(_nroots, key=lambda x: x.sort_key())
+    _sroots = sorted(_sroots, key=lambda x: x.sort_key())
+
+    for _roots in (_nroots, _sroots):
+        for i, r in zip(_intervals, _roots):
+            if r.is_real:
+                assert r in i
+            else:
+                assert (re(r), im(r)) in i
+
+
+def test_root_factors():
+    assert root_factors(Poly(1, x)) == [Poly(1, x)]
+    assert root_factors(Poly(x, x)) == [Poly(x, x)]
+
+    assert root_factors(x**2 - 1, x) == [x + 1, x - 1]
+    assert root_factors(x**2 - y, x) == [x - sqrt(y), x + sqrt(y)]
+
+    assert root_factors((x**4 - 1)**2) == \
+        [x + 1, x + 1, x - 1, x - 1, x - I, x - I, x + I, x + I]
+
+    assert root_factors(Poly(x**4 - 1, x), filter='Z') == \
+        [Poly(x + 1, x), Poly(x - 1, x), Poly(x**2 + 1, x)]
+    assert root_factors(8*x**2 + 12*x**4 + 6*x**6 + x**8, x, filter='Q') == \
+        [x, x, x**6 + 6*x**4 + 12*x**2 + 8]
+
+
+@slow
+def test_nroots1():
+    n = 64
+    p = legendre_poly(n, x, polys=True)
+
+    raises(mpmath.mp.NoConvergence, lambda: p.nroots(n=3, maxsteps=5))
+
+    roots = p.nroots(n=3)
+    # The order of roots matters. They are ordered from smallest to the
+    # largest.
+    assert [str(r) for r in roots] == \
+            ['-0.999', '-0.996', '-0.991', '-0.983', '-0.973', '-0.961',
+            '-0.946', '-0.930', '-0.911', '-0.889', '-0.866', '-0.841',
+            '-0.813', '-0.784', '-0.753', '-0.720', '-0.685', '-0.649',
+            '-0.611', '-0.572', '-0.531', '-0.489', '-0.446', '-0.402',
+            '-0.357', '-0.311', '-0.265', '-0.217', '-0.170', '-0.121',
+            '-0.0730', '-0.0243', '0.0243', '0.0730', '0.121', '0.170',
+            '0.217', '0.265', '0.311', '0.357', '0.402', '0.446', '0.489',
+            '0.531', '0.572', '0.611', '0.649', '0.685', '0.720', '0.753',
+            '0.784', '0.813', '0.841', '0.866', '0.889', '0.911', '0.930',
+            '0.946', '0.961', '0.973', '0.983', '0.991', '0.996', '0.999']
+
+def test_nroots2():
+    p = Poly(x**5 + 3*x + 1, x)
+
+    roots = p.nroots(n=3)
+    # The order of roots matters. The roots are ordered by their real
+    # components (if they agree, then by their imaginary components),
+    # with real roots appearing first.
+    assert [str(r) for r in roots] == \
+            ['-0.332', '-0.839 - 0.944*I', '-0.839 + 0.944*I',
+                '1.01 - 0.937*I', '1.01 + 0.937*I']
+
+    roots = p.nroots(n=5)
+    assert [str(r) for r in roots] == \
+            ['-0.33199', '-0.83907 - 0.94385*I', '-0.83907 + 0.94385*I',
+              '1.0051 - 0.93726*I', '1.0051 + 0.93726*I']
+
+
+def test_roots_composite():
+    assert len(roots(Poly(y**3 + y**2*sqrt(x) + y + x, y, composite=True))) == 3
+
+
+def test_issue_19113():
+    eq = cos(x)**3 - cos(x) + 1
+    raises(PolynomialError, lambda: roots(eq))
+
+
+def test_issue_17454():
+    assert roots([1, -3*(-4 - 4*I)**2/8 + 12*I, 0], multiple=True) == [0, 0]
+
+
+def test_issue_20913():
+    assert Poly(x + 9671406556917067856609794, x).real_roots() == [-9671406556917067856609794]
+    assert Poly(x**3 + 4, x).real_roots() == [-2**(S(2)/3)]
+
+
+def test_issue_22768():
+    e = Rational(1, 3)
+    r = (-1/a)**e*(a + 1)**(5*e)
+    assert roots(Poly(a*x**3 + (a + 1)**5, x)) == {
+        r: 1,
+        -r*(1 + sqrt(3)*I)/2: 1,
+        r*(-1 + sqrt(3)*I)/2: 1}

valley/lib/python3.10/site-packages/sympy/polys/tests/test_polyutils.py

@@ -0,0 +1,300 @@
+"""Tests for useful utilities for higher level polynomial classes. """
+
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Integer, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.testing.pytest import raises
+
+from sympy.polys.polyutils import (
+    _nsort,
+    _sort_gens,
+    _unify_gens,
+    _analyze_gens,
+    _sort_factors,
+    parallel_dict_from_expr,
+    dict_from_expr,
+)
+
+from sympy.polys.polyerrors import PolynomialError
+
+from sympy.polys.domains import ZZ
+
+x, y, z, p, q, r, s, t, u, v, w = symbols('x,y,z,p,q,r,s,t,u,v,w')
+A, B = symbols('A,B', commutative=False)
+
+
+def test__nsort():
+    # issue 6137
+    r = S('''[3/2 + sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) - 4/sqrt(-7/3 +
+    61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3)) -
+    61/(18*(-415/216 + 13*I/12)**(1/3)))/2 - sqrt(-7/3 + 61/(18*(-415/216
+    + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3))/2, 3/2 - sqrt(-7/3
+    + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 +
+    13*I/12)**(1/3))/2 - sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) -
+    4/sqrt(-7/3 + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 +
+    13*I/12)**(1/3)) - 61/(18*(-415/216 + 13*I/12)**(1/3)))/2, 3/2 +
+    sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) + 4/sqrt(-7/3 +
+    61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3)) -
+    61/(18*(-415/216 + 13*I/12)**(1/3)))/2 + sqrt(-7/3 + 61/(18*(-415/216
+    + 13*I/12)**(1/3)) + 2*(-415/216 + 13*I/12)**(1/3))/2, 3/2 + sqrt(-7/3
+    + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 +
+    13*I/12)**(1/3))/2 - sqrt(-14/3 - 2*(-415/216 + 13*I/12)**(1/3) +
+    4/sqrt(-7/3 + 61/(18*(-415/216 + 13*I/12)**(1/3)) + 2*(-415/216 +
+    13*I/12)**(1/3)) - 61/(18*(-415/216 + 13*I/12)**(1/3)))/2]''')
+    ans = [r[1], r[0], r[-1], r[-2]]
+    assert _nsort(r) == ans
+    assert len(_nsort(r, separated=True)[0]) == 0
+    b, c, a = exp(-1000), exp(-999), exp(-1001)
+    assert _nsort((b, c, a)) == [a, b, c]
+    # issue 12560
+    a = cos(1)**2 + sin(1)**2 - 1
+    assert _nsort([a]) == [a]
+
+
+def test__sort_gens():
+    assert _sort_gens([]) == ()
+
+    assert _sort_gens([x]) == (x,)
+    assert _sort_gens([p]) == (p,)
+    assert _sort_gens([q]) == (q,)
+
+    assert _sort_gens([x, p]) == (x, p)
+    assert _sort_gens([p, x]) == (x, p)
+    assert _sort_gens([q, p]) == (p, q)
+
+    assert _sort_gens([q, p, x]) == (x, p, q)
+
+    assert _sort_gens([x, p, q], wrt=x) == (x, p, q)
+    assert _sort_gens([x, p, q], wrt=p) == (p, x, q)
+    assert _sort_gens([x, p, q], wrt=q) == (q, x, p)
+
+    assert _sort_gens([x, p, q], wrt='x') == (x, p, q)
+    assert _sort_gens([x, p, q], wrt='p') == (p, x, q)
+    assert _sort_gens([x, p, q], wrt='q') == (q, x, p)
+
+    assert _sort_gens([x, p, q], wrt='x,q') == (x, q, p)
+    assert _sort_gens([x, p, q], wrt='q,x') == (q, x, p)
+    assert _sort_gens([x, p, q], wrt='p,q') == (p, q, x)
+    assert _sort_gens([x, p, q], wrt='q,p') == (q, p, x)
+
+    assert _sort_gens([x, p, q], wrt='x, q') == (x, q, p)
+    assert _sort_gens([x, p, q], wrt='q, x') == (q, x, p)
+    assert _sort_gens([x, p, q], wrt='p, q') == (p, q, x)
+    assert _sort_gens([x, p, q], wrt='q, p') == (q, p, x)
+
+    assert _sort_gens([x, p, q], wrt=[x, 'q']) == (x, q, p)
+    assert _sort_gens([x, p, q], wrt=[q, 'x']) == (q, x, p)
+    assert _sort_gens([x, p, q], wrt=[p, 'q']) == (p, q, x)
+    assert _sort_gens([x, p, q], wrt=[q, 'p']) == (q, p, x)
+
+    assert _sort_gens([x, p, q], wrt=['x', 'q']) == (x, q, p)
+    assert _sort_gens([x, p, q], wrt=['q', 'x']) == (q, x, p)
+    assert _sort_gens([x, p, q], wrt=['p', 'q']) == (p, q, x)
+    assert _sort_gens([x, p, q], wrt=['q', 'p']) == (q, p, x)
+
+    assert _sort_gens([x, p, q], sort='x > p > q') == (x, p, q)
+    assert _sort_gens([x, p, q], sort='p > x > q') == (p, x, q)
+    assert _sort_gens([x, p, q], sort='p > q > x') == (p, q, x)
+
+    assert _sort_gens([x, p, q], wrt='x', sort='q > p') == (x, q, p)
+    assert _sort_gens([x, p, q], wrt='p', sort='q > x') == (p, q, x)
+    assert _sort_gens([x, p, q], wrt='q', sort='p > x') == (q, p, x)
+
+    # https://github.com/sympy/sympy/issues/19353
+    n1 = Symbol('\n1')
+    assert _sort_gens([n1]) == (n1,)
+    assert _sort_gens([x, n1]) == (x, n1)
+
+    X = symbols('x0,x1,x2,x10,x11,x12,x20,x21,x22')
+
+    assert _sort_gens(X) == X
+
+
+def test__unify_gens():
+    assert _unify_gens([], []) == ()
+
+    assert _unify_gens([x], [x]) == (x,)
+    assert _unify_gens([y], [y]) == (y,)
+
+    assert _unify_gens([x, y], [x]) == (x, y)
+    assert _unify_gens([x], [x, y]) == (x, y)
+
+    assert _unify_gens([x, y], [x, y]) == (x, y)
+    assert _unify_gens([y, x], [y, x]) == (y, x)
+
+    assert _unify_gens([x], [y]) == (x, y)
+    assert _unify_gens([y], [x]) == (y, x)
+
+    assert _unify_gens([x], [y, x]) == (y, x)
+    assert _unify_gens([y, x], [x]) == (y, x)
+
+    assert _unify_gens([x, y, z], [x, y, z]) == (x, y, z)
+    assert _unify_gens([z, y, x], [x, y, z]) == (z, y, x)
+    assert _unify_gens([x, y, z], [z, y, x]) == (x, y, z)
+    assert _unify_gens([z, y, x], [z, y, x]) == (z, y, x)
+
+    assert _unify_gens([x, y, z], [t, x, p, q, z]) == (t, x, y, p, q, z)
+
+
+def test__analyze_gens():
+    assert _analyze_gens((x, y, z)) == (x, y, z)
+    assert _analyze_gens([x, y, z]) == (x, y, z)
+
+    assert _analyze_gens(([x, y, z],)) == (x, y, z)
+    assert _analyze_gens(((x, y, z),)) == (x, y, z)
+
+
+def test__sort_factors():
+    assert _sort_factors([], multiple=True) == []
+    assert _sort_factors([], multiple=False) == []
+
+    F = [[1, 2, 3], [1, 2], [1]]
+    G = [[1], [1, 2], [1, 2, 3]]
+
+    assert _sort_factors(F, multiple=False) == G
+
+    F = [[1, 2], [1, 2, 3], [1, 2], [1]]
+    G = [[1], [1, 2], [1, 2], [1, 2, 3]]
+
+    assert _sort_factors(F, multiple=False) == G
+
+    F = [[2, 2], [1, 2, 3], [1, 2], [1]]
+    G = [[1], [1, 2], [2, 2], [1, 2, 3]]
+
+    assert _sort_factors(F, multiple=False) == G
+
+    F = [([1, 2, 3], 1), ([1, 2], 1), ([1], 1)]
+    G = [([1], 1), ([1, 2], 1), ([1, 2, 3], 1)]
+
+    assert _sort_factors(F, multiple=True) == G
+
+    F = [([1, 2], 1), ([1, 2, 3], 1), ([1, 2], 1), ([1], 1)]
+    G = [([1], 1), ([1, 2], 1), ([1, 2], 1), ([1, 2, 3], 1)]
+
+    assert _sort_factors(F, multiple=True) == G
+
+    F = [([2, 2], 1), ([1, 2, 3], 1), ([1, 2], 1), ([1], 1)]
+    G = [([1], 1), ([1, 2], 1), ([2, 2], 1), ([1, 2, 3], 1)]
+
+    assert _sort_factors(F, multiple=True) == G
+
+    F = [([2, 2], 1), ([1, 2, 3], 1), ([1, 2], 2), ([1], 1)]
+    G = [([1], 1), ([2, 2], 1), ([1, 2], 2), ([1, 2, 3], 1)]
+
+    assert _sort_factors(F, multiple=True) == G
+
+
+def test__dict_from_expr_if_gens():
+    assert dict_from_expr(
+        Integer(17), gens=(x,)) == ({(0,): Integer(17)}, (x,))
+    assert dict_from_expr(
+        Integer(17), gens=(x, y)) == ({(0, 0): Integer(17)}, (x, y))
+    assert dict_from_expr(
+        Integer(17), gens=(x, y, z)) == ({(0, 0, 0): Integer(17)}, (x, y, z))
+
+    assert dict_from_expr(
+        Integer(-17), gens=(x,)) == ({(0,): Integer(-17)}, (x,))
+    assert dict_from_expr(
+        Integer(-17), gens=(x, y)) == ({(0, 0): Integer(-17)}, (x, y))
+    assert dict_from_expr(Integer(
+        -17), gens=(x, y, z)) == ({(0, 0, 0): Integer(-17)}, (x, y, z))
+
+    assert dict_from_expr(
+        Integer(17)*x, gens=(x,)) == ({(1,): Integer(17)}, (x,))
+    assert dict_from_expr(
+        Integer(17)*x, gens=(x, y)) == ({(1, 0): Integer(17)}, (x, y))
+    assert dict_from_expr(Integer(
+        17)*x, gens=(x, y, z)) == ({(1, 0, 0): Integer(17)}, (x, y, z))
+
+    assert dict_from_expr(
+        Integer(17)*x**7, gens=(x,)) == ({(7,): Integer(17)}, (x,))
+    assert dict_from_expr(
+        Integer(17)*x**7*y, gens=(x, y)) == ({(7, 1): Integer(17)}, (x, y))
+    assert dict_from_expr(Integer(17)*x**7*y*z**12, gens=(
+        x, y, z)) == ({(7, 1, 12): Integer(17)}, (x, y, z))
+
+    assert dict_from_expr(x + 2*y + 3*z, gens=(x,)) == \
+        ({(1,): Integer(1), (0,): 2*y + 3*z}, (x,))
+    assert dict_from_expr(x + 2*y + 3*z, gens=(x, y)) == \
+        ({(1, 0): Integer(1), (0, 1): Integer(2), (0, 0): 3*z}, (x, y))
+    assert dict_from_expr(x + 2*y + 3*z, gens=(x, y, z)) == \
+        ({(1, 0, 0): Integer(
+            1), (0, 1, 0): Integer(2), (0, 0, 1): Integer(3)}, (x, y, z))
+
+    assert dict_from_expr(x*y + 2*x*z + 3*y*z, gens=(x,)) == \
+        ({(1,): y + 2*z, (0,): 3*y*z}, (x,))
+    assert dict_from_expr(x*y + 2*x*z + 3*y*z, gens=(x, y)) == \
+        ({(1, 1): Integer(1), (1, 0): 2*z, (0, 1): 3*z}, (x, y))
+    assert dict_from_expr(x*y + 2*x*z + 3*y*z, gens=(x, y, z)) == \
+        ({(1, 1, 0): Integer(
+            1), (1, 0, 1): Integer(2), (0, 1, 1): Integer(3)}, (x, y, z))
+
+    assert dict_from_expr(2**y*x, gens=(x,)) == ({(1,): 2**y}, (x,))
+    assert dict_from_expr(Integral(x, (x, 1, 2)) + x) == (
+        {(0, 1): 1, (1, 0): 1}, (x, Integral(x, (x, 1, 2))))
+    raises(PolynomialError, lambda: dict_from_expr(2**y*x, gens=(x, y)))
+
+
+def test__dict_from_expr_no_gens():
+    assert dict_from_expr(Integer(17)) == ({(): Integer(17)}, ())
+
+    assert dict_from_expr(x) == ({(1,): Integer(1)}, (x,))
+    assert dict_from_expr(y) == ({(1,): Integer(1)}, (y,))
+
+    assert dict_from_expr(x*y) == ({(1, 1): Integer(1)}, (x, y))
+    assert dict_from_expr(
+        x + y) == ({(1, 0): Integer(1), (0, 1): Integer(1)}, (x, y))
+
+    assert dict_from_expr(sqrt(2)) == ({(1,): Integer(1)}, (sqrt(2),))
+    assert dict_from_expr(sqrt(2), greedy=False) == ({(): sqrt(2)}, ())
+
+    assert dict_from_expr(x*y, domain=ZZ[x]) == ({(1,): x}, (y,))
+    assert dict_from_expr(x*y, domain=ZZ[y]) == ({(1,): y}, (x,))
+
+    assert dict_from_expr(3*sqrt(
+        2)*pi*x*y, extension=None) == ({(1, 1, 1, 1): 3}, (x, y, pi, sqrt(2)))
+    assert dict_from_expr(3*sqrt(
+        2)*pi*x*y, extension=True) == ({(1, 1, 1): 3*sqrt(2)}, (x, y, pi))
+
+    assert dict_from_expr(3*sqrt(
+        2)*pi*x*y, extension=True) == ({(1, 1, 1): 3*sqrt(2)}, (x, y, pi))
+
+    f = cos(x)*sin(x) + cos(x)*sin(y) + cos(y)*sin(x) + cos(y)*sin(y)
+
+    assert dict_from_expr(f) == ({(0, 1, 0, 1): 1, (0, 1, 1, 0): 1,
+        (1, 0, 0, 1): 1, (1, 0, 1, 0): 1}, (cos(x), cos(y), sin(x), sin(y)))
+
+
+def test__parallel_dict_from_expr_if_gens():
+    assert parallel_dict_from_expr([x + 2*y + 3*z, Integer(7)], gens=(x,)) == \
+        ([{(1,): Integer(1), (0,): 2*y + 3*z}, {(0,): Integer(7)}], (x,))
+
+
+def test__parallel_dict_from_expr_no_gens():
+    assert parallel_dict_from_expr([x*y, Integer(3)]) == \
+        ([{(1, 1): Integer(1)}, {(0, 0): Integer(3)}], (x, y))
+    assert parallel_dict_from_expr([x*y, 2*z, Integer(3)]) == \
+        ([{(1, 1, 0): Integer(
+            1)}, {(0, 0, 1): Integer(2)}, {(0, 0, 0): Integer(3)}], (x, y, z))
+    assert parallel_dict_from_expr((Mul(x, x**2, evaluate=False),)) == \
+        ([{(3,): 1}], (x,))
+
+
+def test_parallel_dict_from_expr():
+    assert parallel_dict_from_expr([Eq(x, 1), Eq(
+        x**2, 2)]) == ([{(0,): -Integer(1), (1,): Integer(1)},
+                        {(0,): -Integer(2), (2,): Integer(1)}], (x,))
+    raises(PolynomialError, lambda: parallel_dict_from_expr([A*B - B*A]))
+
+
+def test_dict_from_expr():
+    assert dict_from_expr(Eq(x, 1)) == \
+        ({(0,): -Integer(1), (1,): Integer(1)}, (x,))
+    raises(PolynomialError, lambda: dict_from_expr(A*B - B*A))
+    raises(PolynomialError, lambda: dict_from_expr(S.true))

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

valley/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)]'

valley/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]

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported/CMakeLists-Fortran.txt.in

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION "@CMAKE_VERSION@")
+project("@TRY_COMPILE_PROJECT_NAME@" LANGUAGES Fortran)
+
+cmake_policy(SET CMP0069 NEW)
+
+add_library(foo foo.f)
+add_executable(boo main.f)
+target_link_libraries(boo PUBLIC foo)

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported/foo.c

@@ -0,0 +1,4 @@
+int foo(void)
+{
+  return 0x42;
+}

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported/foo.cpp

@@ -0,0 +1,4 @@
+int foo()
+{
+  return 0x42;
+}

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported/foo.f

@@ -0,0 +1,2 @@
+	SUBROUTINE FOO
+	END

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported/main.c

@@ -0,0 +1,6 @@
+int foo(void);
+
+int main(void)
+{
+  return foo();
+}

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CheckIPOSupported/main.f

@@ -0,0 +1,3 @@
+	PROGRAM BOO
+	CALL FOO()
+	END

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CompilerId/GHS_default.gpj.in

@@ -0,0 +1,8 @@
+#!gbuild
+@bsp_name@
+@os_dir@
+primaryTarget=@ghs_primary_target@
+[Project]
+     {isdefined(GHS_BSP)} -bsp $GHS_BSP
+     {isdefined(GHS_OS)} -os_dir $GHS_OS
+GHS_lib.gpj [Library]

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CompilerId/GHS_lib.gpj.in

@@ -0,0 +1,3 @@
+#!gbuild
+[Library]
+@id_src@

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CompilerId/VS-10.csproj.in

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{CAE07175-D007-4FC3-BFE8-47B392814159}</ProjectGuid>
+    <RootNamespace>CompilerId@id_lang@</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+    @id_system@
+    @id_system_version@
+    @id_TargetFrameworkVersion@
+    @id_TargetFrameworkIdentifier@
+    @id_TargetFrameworkTargetsVersion@
+    @id_WindowsTargetPlatformVersion@
+    @id_WindowsSDKDesktopARMSupport@
+  </PropertyGroup>
+  <PropertyGroup>
+    @id_PreferredToolArchitecture@
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|@id_platform@'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    @id_toolset@
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <!-- ============================================================ -->
+  <!-- ==                set preprocessor definitions            == -->
+  <!-- ============================================================ -->
+  <PropertyGroup>
+    <DefineConstants></DefineConstants>
+    <UnknownValue>Unknown</UnknownValue>
+  </PropertyGroup>
+  <!-- Platform -->
+  <PropertyGroup Condition="'$(Platform)'!=''">
+    <DefineConstants>$(DefineConstants);Platform$(Platform)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'==''">
+    <DefineConstants>$(DefineConstants);Platform$(UnknownValue)</DefineConstants>
+  </PropertyGroup>
+  <!-- PlatformToolset -->
+  <PropertyGroup Condition="'$(PlatformToolset)'!=''">
+    <DefineConstants>$(DefineConstants);PlatformToolset$(PlatformToolset)</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(PlatformToolset)'==''">
+    <DefineConstants>$(DefineConstants);PlatformToolset$(UnknownValue)</DefineConstants>
+  </PropertyGroup>
+  <!-- ============================================================ -->
+  <PropertyGroup>
+    <OutputPath Condition="'$(Configuration)|$(Platform)'=='Debug|@id_platform@'">.\</OutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="@id_src@" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>if not "$(RoslynTargetsPath)"=="" if exist "$(RoslynTargetsPath)\@id_cl@" set _CSC=$(RoslynTargetsPath)
+if exist "$(MSBuildToolsPath)\@id_cl@" set _CSC=$(MSBuildToolsPath)
+if "%_CSC%"=="" exit -1
+%40echo CMAKE_@id_lang@_COMPILER=%_CSC%\@id_cl@</PostBuildEvent>
+  </PropertyGroup>
+</Project>

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CompilerId/VS-Intel.vfproj.in

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectCreator="Intel Fortran"
+	Keyword="Console Application"
+	Version="@CMAKE_VS_INTEL_Fortran_PROJECT_VERSION@"
+	ProjectIdGuid="{AB67BAB7-D7AE-4E97-B492-FE5420447509}"
+	>
+	<Platforms>
+		<Platform Name="@id_platform@"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|@id_platform@"
+			OutputDirectory="."
+			IntermediateDirectory="$(ConfigurationName)"
+			@id_UseCompiler@>
+			<Tool
+				Name="VFFortranCompilerTool"
+				DebugInformationFormat="debugEnabled"
+				Optimization="optimizeDisabled"
+				Preprocess="preprocessYes"
+				RuntimeLibrary="rtMultiThreadedDebugDLL"
+			/>
+			<Tool
+				Name="VFLinkerTool"
+				LinkIncremental="linkIncrementalNo"
+				GenerateDebugInformation="true"
+				SubSystem="subSystemConsole"
+			/>
+			<Tool
+				Name="VFPostBuildEventTool"
+				CommandLine="for %%i in (@id_cl@) do @echo CMAKE_@id_lang@_COMPILER=%%~$PATH:i"
+			/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter Name="Source Files" Filter="F">
+			<File RelativePath="@id_src@"/>
+		</Filter>
+	</Files>
+	<Globals/>
+</VisualStudioProject>

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/CompilerId/main.swift.in

@@ -0,0 +1 @@
+print("CMakeSwiftCompilerId")

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/PatchInfo.txt.in

@@ -0,0 +1,6 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The update step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command=@cmd@
+work_dir=@work_dir@

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/RepositoryInfo.txt.in

@@ -0,0 +1,9 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The download step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+method=@method@
+command=@cmd@
+source_dir=@source_dir@
+work_dir=@work_dir@
+@extra_repo_info@

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/UpdateInfo.txt.in

@@ -0,0 +1,7 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The patch step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command (connected)=@cmd@
+command (disconnected)=@cmd_disconnected@
+work_dir=@work_dir@

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/cfgcmd.txt.in

@@ -0,0 +1 @@
+cmd='@cmd@'

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/extractfile.cmake.in

@@ -0,0 +1,65 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# Make file names absolute:
+#
+get_filename_component(filename "@filename@" ABSOLUTE)
+get_filename_component(directory "@directory@" ABSOLUTE)
+
+message(VERBOSE "extracting...
+     src='${filename}'
+     dst='${directory}'"
+)
+
+if(NOT EXISTS "${filename}")
+  message(FATAL_ERROR "File to extract does not exist: '${filename}'")
+endif()
+
+# Prepare a space for extracting:
+#
+set(i 1234)
+while(EXISTS "${directory}/../ex-@name@${i}")
+  math(EXPR i "${i} + 1")
+endwhile()
+set(ut_dir "${directory}/../ex-@name@${i}")
+file(MAKE_DIRECTORY "${ut_dir}")
+
+# Extract it:
+#
+message(VERBOSE "extracting... [tar @args@]")
+execute_process(COMMAND ${CMAKE_COMMAND} -E tar @args@ ${filename} @options@
+  WORKING_DIRECTORY ${ut_dir}
+  RESULT_VARIABLE rv
+)
+
+if(NOT rv EQUAL 0)
+  message(VERBOSE "extracting... [error clean up]")
+  file(REMOVE_RECURSE "${ut_dir}")
+  message(FATAL_ERROR "Extract of '${filename}' failed")
+endif()
+
+# Analyze what came out of the tar file:
+#
+message(VERBOSE "extracting... [analysis]")
+file(GLOB contents "${ut_dir}/*")
+list(REMOVE_ITEM contents "${ut_dir}/.DS_Store")
+list(LENGTH contents n)
+if(NOT n EQUAL 1 OR NOT IS_DIRECTORY "${contents}")
+  set(contents "${ut_dir}")
+endif()
+
+# Move "the one" directory to the final directory:
+#
+message(VERBOSE "extracting... [rename]")
+file(REMOVE_RECURSE ${directory})
+get_filename_component(contents ${contents} ABSOLUTE)
+file(RENAME ${contents} ${directory})
+
+# Clean up:
+#
+message(VERBOSE "extracting... [clean up]")
+file(REMOVE_RECURSE "${ut_dir}")
+
+message(VERBOSE "extracting... done")

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/gitupdate.cmake.in

@@ -0,0 +1,317 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# Even at VERBOSE level, we don't want to see the commands executed, but
+# enabling them to be shown for DEBUG may be useful to help diagnose problems.
+cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+if(active_log_level MATCHES "DEBUG|TRACE")
+  set(maybe_show_command COMMAND_ECHO STDOUT)
+else()
+  set(maybe_show_command "")
+endif()
+
+function(do_fetch)
+  message(VERBOSE "Fetching latest from the remote @git_remote_name@")
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git fetch --tags --force "@git_remote_name@"
+    WORKING_DIRECTORY "@work_dir@"
+    COMMAND_ERROR_IS_FATAL LAST
+    ${maybe_show_command}
+  )
+endfunction()
+
+function(get_hash_for_ref ref out_var err_var)
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git rev-parse "${ref}^0"
+    WORKING_DIRECTORY "@work_dir@"
+    RESULT_VARIABLE error_code
+    OUTPUT_VARIABLE ref_hash
+    ERROR_VARIABLE error_msg
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(error_code)
+    set(${out_var} "" PARENT_SCOPE)
+  else()
+    set(${out_var} "${ref_hash}" PARENT_SCOPE)
+  endif()
+  set(${err_var} "${error_msg}" PARENT_SCOPE)
+endfunction()
+
+get_hash_for_ref(HEAD head_sha error_msg)
+if(head_sha STREQUAL "")
+  message(FATAL_ERROR "Failed to get the hash for HEAD:\n${error_msg}")
+endif()
+
+if("${can_fetch}" STREQUAL "")
+  set(can_fetch "@can_fetch_default@")
+endif()
+
+execute_process(
+  COMMAND "@git_EXECUTABLE@" --git-dir=.git show-ref "@git_tag@"
+  WORKING_DIRECTORY "@work_dir@"
+  OUTPUT_VARIABLE show_ref_output
+)
+if(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/remotes/")
+  # Given a full remote/branch-name and we know about it already. Since
+  # branches can move around, we should always fetch, if permitted.
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "@git_tag@")
+
+elseif(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/tags/")
+  # Given a tag name that we already know about. We don't know if the tag we
+  # have matches the remote though (tags can move), so we should fetch. As a
+  # special case to preserve backward compatibility, if we are already at the
+  # same commit as the tag we hold locally, don't do a fetch and assume the tag
+  # hasn't moved on the remote.
+  # FIXME: We should provide an option to always fetch for this case
+  get_hash_for_ref("@git_tag@" tag_sha error_msg)
+  if(tag_sha STREQUAL head_sha)
+    message(VERBOSE "Already at requested tag: @git_tag@")
+    return()
+  endif()
+
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "@git_tag@")
+
+elseif(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/heads/")
+  # Given a branch name without any remote and we already have a branch by that
+  # name. We might already have that branch checked out or it might be a
+  # different branch. It isn't fully safe to use a bare branch name without the
+  # remote, so do a fetch (if allowed) and replace the ref with one that
+  # includes the remote.
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "@git_remote_name@/@git_tag@")
+
+else()
+  get_hash_for_ref("@git_tag@" tag_sha error_msg)
+  if(tag_sha STREQUAL head_sha)
+    # Have the right commit checked out already
+    message(VERBOSE "Already at requested ref: ${tag_sha}")
+    return()
+
+  elseif(tag_sha STREQUAL "")
+    # We don't know about this ref yet, so we have no choice but to fetch.
+    if(NOT can_fetch)
+      message(FATAL_ERROR
+        "Requested git ref \"@git_tag@\" is not present locally, and not "
+        "allowed to contact remote due to UPDATE_DISCONNECTED setting."
+      )
+    endif()
+
+    # We deliberately swallow any error message at the default log level
+    # because it can be confusing for users to see a failed git command.
+    # That failure is being handled here, so it isn't an error.
+    if(NOT error_msg STREQUAL "")
+      message(DEBUG "${error_msg}")
+    endif()
+    do_fetch()
+    set(checkout_name "@git_tag@")
+
+  else()
+    # We have the commit, so we know we were asked to find a commit hash
+    # (otherwise it would have been handled further above), but we don't
+    # have that commit checked out yet. We don't need to fetch from the remote.
+    set(checkout_name "@git_tag@")
+    if(NOT error_msg STREQUAL "")
+      message(WARNING "${error_msg}")
+    endif()
+
+  endif()
+endif()
+
+set(git_update_strategy "@git_update_strategy@")
+if(git_update_strategy STREQUAL "")
+  # Backward compatibility requires REBASE as the default behavior
+  set(git_update_strategy REBASE)
+endif()
+
+if(git_update_strategy MATCHES "^REBASE(_CHECKOUT)?$")
+  # Asked to potentially try to rebase first, maybe with fallback to checkout.
+  # We can't if we aren't already on a branch and we shouldn't if that local
+  # branch isn't tracking the one we want to checkout.
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git symbolic-ref -q HEAD
+    WORKING_DIRECTORY "@work_dir@"
+    OUTPUT_VARIABLE current_branch
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    # Don't test for an error. If this isn't a branch, we get a non-zero error
+    # code but empty output.
+  )
+
+  if(current_branch STREQUAL "")
+    # Not on a branch, checkout is the only sensible option since any rebase
+    # would always fail (and backward compatibility requires us to checkout in
+    # this situation)
+    set(git_update_strategy CHECKOUT)
+
+  else()
+    execute_process(
+      COMMAND "@git_EXECUTABLE@" --git-dir=.git for-each-ref "--format=%(upstream:short)" "${current_branch}"
+      WORKING_DIRECTORY "@work_dir@"
+      OUTPUT_VARIABLE upstream_branch
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      COMMAND_ERROR_IS_FATAL ANY  # There is no error if no upstream is set
+    )
+    if(NOT upstream_branch STREQUAL checkout_name)
+      # Not safe to rebase when asked to checkout a different branch to the one
+      # we are tracking. If we did rebase, we could end up with arbitrary
+      # commits added to the ref we were asked to checkout if the current local
+      # branch happens to be able to rebase onto the target branch. There would
+      # be no error message and the user wouldn't know this was occurring.
+      set(git_update_strategy CHECKOUT)
+    endif()
+
+  endif()
+elseif(NOT git_update_strategy STREQUAL "CHECKOUT")
+  message(FATAL_ERROR "Unsupported git update strategy: ${git_update_strategy}")
+endif()
+
+
+# Check if stash is needed
+execute_process(
+  COMMAND "@git_EXECUTABLE@" --git-dir=.git status --porcelain
+  WORKING_DIRECTORY "@work_dir@"
+  RESULT_VARIABLE error_code
+  OUTPUT_VARIABLE repo_status
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to get the status")
+endif()
+string(LENGTH "${repo_status}" need_stash)
+
+# If not in clean state, stash changes in order to be able to perform a
+# rebase or checkout without losing those changes permanently
+if(need_stash)
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git stash save @git_stash_save_options@
+    WORKING_DIRECTORY "@work_dir@"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+endif()
+
+if(git_update_strategy STREQUAL "CHECKOUT")
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git checkout "${checkout_name}"
+    WORKING_DIRECTORY "@work_dir@"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+else()
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git rebase "${checkout_name}"
+    WORKING_DIRECTORY "@work_dir@"
+    RESULT_VARIABLE error_code
+    OUTPUT_VARIABLE rebase_output
+    ERROR_VARIABLE  rebase_output
+  )
+  if(error_code)
+    # Rebase failed, undo the rebase attempt before continuing
+    execute_process(
+      COMMAND "@git_EXECUTABLE@" --git-dir=.git rebase --abort
+      WORKING_DIRECTORY "@work_dir@"
+      ${maybe_show_command}
+    )
+
+    if(NOT git_update_strategy STREQUAL "REBASE_CHECKOUT")
+      # Not allowed to do a checkout as a fallback, so cannot proceed
+      if(need_stash)
+        execute_process(
+          COMMAND "@git_EXECUTABLE@" --git-dir=.git stash pop --index --quiet
+          WORKING_DIRECTORY "@work_dir@"
+          ${maybe_show_command}
+          )
+      endif()
+      message(FATAL_ERROR "\nFailed to rebase in: '@work_dir@'."
+                          "\nOutput from the attempted rebase follows:"
+                          "\n${rebase_output}"
+                          "\n\nYou will have to resolve the conflicts manually")
+    endif()
+
+    # Fall back to checkout. We create an annotated tag so that the user
+    # can manually inspect the situation and revert if required.
+    # We can't log the failed rebase output because MSVC sees it and
+    # intervenes, causing the build to fail even though it completes.
+    # Write it to a file instead.
+    string(TIMESTAMP tag_timestamp "%Y%m%dT%H%M%S" UTC)
+    set(tag_name _cmake_ExternalProject_moved_from_here_${tag_timestamp}Z)
+    set(error_log_file ${CMAKE_CURRENT_LIST_DIR}/rebase_error_${tag_timestamp}Z.log)
+    file(WRITE ${error_log_file} "${rebase_output}")
+    message(WARNING "Rebase failed, output has been saved to ${error_log_file}"
+                    "\nFalling back to checkout, previous commit tagged as ${tag_name}")
+    execute_process(
+      COMMAND "@git_EXECUTABLE@" --git-dir=.git tag -a
+              -m "ExternalProject attempting to move from here to ${checkout_name}"
+              ${tag_name}
+      WORKING_DIRECTORY "@work_dir@"
+      COMMAND_ERROR_IS_FATAL ANY
+      ${maybe_show_command}
+    )
+
+    execute_process(
+      COMMAND "@git_EXECUTABLE@" --git-dir=.git checkout "${checkout_name}"
+      WORKING_DIRECTORY "@work_dir@"
+      COMMAND_ERROR_IS_FATAL ANY
+      ${maybe_show_command}
+    )
+  endif()
+endif()
+
+if(need_stash)
+  # Put back the stashed changes
+  execute_process(
+    COMMAND "@git_EXECUTABLE@" --git-dir=.git stash pop --index --quiet
+    WORKING_DIRECTORY "@work_dir@"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+    )
+  if(error_code)
+    # Stash pop --index failed: Try again dropping the index
+    execute_process(
+      COMMAND "@git_EXECUTABLE@" --git-dir=.git reset --hard --quiet
+      WORKING_DIRECTORY "@work_dir@"
+      ${maybe_show_command}
+    )
+    execute_process(
+      COMMAND "@git_EXECUTABLE@" --git-dir=.git stash pop --quiet
+      WORKING_DIRECTORY "@work_dir@"
+      RESULT_VARIABLE error_code
+      ${maybe_show_command}
+    )
+    if(error_code)
+      # Stash pop failed: Restore previous state.
+      execute_process(
+        COMMAND "@git_EXECUTABLE@" --git-dir=.git reset --hard --quiet ${head_sha}
+        WORKING_DIRECTORY "@work_dir@"
+        ${maybe_show_command}
+      )
+      execute_process(
+        COMMAND "@git_EXECUTABLE@" --git-dir=.git stash pop --index --quiet
+        WORKING_DIRECTORY "@work_dir@"
+        ${maybe_show_command}
+      )
+      message(FATAL_ERROR "\nFailed to unstash changes in: '@work_dir@'."
+                          "\nYou will have to resolve the conflicts manually")
+    endif()
+  endif()
+endif()
+
+set(init_submodules "@init_submodules@")
+if(init_submodules)
+  execute_process(
+    COMMAND "@git_EXECUTABLE@"
+            --git-dir=.git @git_submodules_config_options@
+            submodule update @git_submodules_recurse@ --init @git_submodules@
+    WORKING_DIRECTORY "@work_dir@"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+endif()

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/hgclone.cmake.in

@@ -0,0 +1,62 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+if(EXISTS "@hgclone_stampfile@" AND EXISTS "@hgclone_infofile@" AND
+  "@hgclone_stampfile@" IS_NEWER_THAN "@hgclone_infofile@")
+  message(VERBOSE
+    "Avoiding repeated hg clone, stamp file is up to date: "
+    "'@hgclone_stampfile@'"
+  )
+  return()
+endif()
+
+# Even at VERBOSE level, we don't want to see the commands executed, but
+# enabling them to be shown for DEBUG may be useful to help diagnose problems.
+cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+if(active_log_level MATCHES "DEBUG|TRACE")
+  set(maybe_show_command COMMAND_ECHO STDOUT)
+else()
+  set(maybe_show_command "")
+endif()
+
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E rm -rf "@source_dir@"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to remove directory: '@source_dir@'")
+endif()
+
+execute_process(
+  COMMAND "@hg_EXECUTABLE@" clone -U "@hg_repository@" "@src_name@"
+  WORKING_DIRECTORY "@work_dir@"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to clone repository: '@hg_repository@'")
+endif()
+
+execute_process(
+  COMMAND "@hg_EXECUTABLE@" update @hg_tag@
+  WORKING_DIRECTORY "@work_dir@/@src_name@"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to checkout tag: '@hg_tag@'")
+endif()
+
+# Complete success, update the script-last-run stamp file:
+#
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E copy "@hgclone_infofile@" "@hgclone_stampfile@"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to copy script-last-run stamp file: '@hgclone_stampfile@'")
+endif()

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/shared_internal_commands.cmake

@@ -0,0 +1,1982 @@
+cmake_policy(VERSION 3.25)
+
+# Determine the remote URL of the project containing the working_directory.
+# This will leave output_variable unset if the URL can't be determined.
+function(_ep_get_git_remote_url output_variable working_directory)
+  set("${output_variable}" "" PARENT_SCOPE)
+
+  find_package(Git QUIET REQUIRED)
+
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} symbolic-ref --short HEAD
+    WORKING_DIRECTORY "${working_directory}"
+    OUTPUT_VARIABLE git_symbolic_ref
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+  )
+
+  if(NOT git_symbolic_ref STREQUAL "")
+    # We are potentially on a branch. See if that branch is associated with
+    # an upstream remote (might be just a local one or not a branch at all).
+    execute_process(
+      COMMAND ${GIT_EXECUTABLE} config branch.${git_symbolic_ref}.remote
+      WORKING_DIRECTORY "${working_directory}"
+      OUTPUT_VARIABLE git_remote_name
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_QUIET
+    )
+  endif()
+
+  if(NOT git_remote_name)
+    # Can't select a remote based on a branch. If there's only one remote,
+    # or we have multiple remotes but one is called "origin", choose that.
+    execute_process(
+      COMMAND ${GIT_EXECUTABLE} remote
+      WORKING_DIRECTORY "${working_directory}"
+      OUTPUT_VARIABLE git_remote_list
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_QUIET
+    )
+    string(REPLACE "\n" ";" git_remote_list "${git_remote_list}")
+    list(LENGTH git_remote_list git_remote_list_length)
+
+    if(git_remote_list_length EQUAL 0)
+      message(FATAL_ERROR "Git remote not found in parent project.")
+    elseif(git_remote_list_length EQUAL 1)
+      list(GET git_remote_list 0 git_remote_name)
+    else()
+      set(base_warning_msg "Multiple git remotes found for parent project")
+      if("origin" IN_LIST git_remote_list)
+        message(WARNING "${base_warning_msg}, defaulting to origin.")
+        set(git_remote_name "origin")
+      else()
+        message(FATAL_ERROR "${base_warning_msg}, none of which are origin.")
+      endif()
+    endif()
+  endif()
+
+  if(GIT_VERSION VERSION_LESS 1.7.5)
+    set(_git_remote_url_cmd_args config remote.${git_remote_name}.url)
+  elseif(GIT_VERSION VERSION_LESS 2.7)
+    set(_git_remote_url_cmd_args ls-remote --get-url ${git_remote_name})
+  else()
+    set(_git_remote_url_cmd_args remote get-url ${git_remote_name})
+  endif()
+
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} ${_git_remote_url_cmd_args}
+    WORKING_DIRECTORY "${working_directory}"
+    OUTPUT_VARIABLE git_remote_url
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    COMMAND_ERROR_IS_FATAL LAST
+    ENCODING UTF-8   # Needed to handle non-ascii characters in local paths
+  )
+
+  set("${output_variable}" "${git_remote_url}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_is_relative_git_remote output_variable remote_url)
+  if(remote_url MATCHES "^\\.\\./")
+    set("${output_variable}" TRUE PARENT_SCOPE)
+  else()
+    set("${output_variable}" FALSE PARENT_SCOPE)
+  endif()
+endfunction()
+
+
+# Return an absolute remote URL given an existing remote URL and relative path.
+# The output_variable will be set to an empty string if an absolute URL
+# could not be computed (no error message is output).
+function(_ep_resolve_relative_git_remote
+  output_variable
+  parent_remote_url
+  relative_remote_url
+)
+  set("${output_variable}" "" PARENT_SCOPE)
+
+  if(parent_remote_url STREQUAL "")
+    return()
+  endif()
+
+  string(REGEX MATCH
+    "^(([A-Za-z0-9][A-Za-z0-9+.-]*)://)?(([^/@]+)@)?(\\[[A-Za-z0-9:]+\\]|[^/:]+)?([/:]/?)(.+(\\.git)?/?)$"
+    git_remote_url_components
+    "${parent_remote_url}"
+  )
+
+  set(protocol "${CMAKE_MATCH_1}")
+  set(auth "${CMAKE_MATCH_3}")
+  set(host "${CMAKE_MATCH_5}")
+  set(separator "${CMAKE_MATCH_6}")
+  set(path "${CMAKE_MATCH_7}")
+
+  string(REPLACE "/" ";" remote_path_components "${path}")
+  string(REPLACE "/" ";" relative_path_components "${relative_remote_url}")
+
+  foreach(relative_path_component IN LISTS relative_path_components)
+    if(NOT relative_path_component STREQUAL "..")
+      break()
+    endif()
+
+    list(LENGTH remote_path_components remote_path_component_count)
+
+    if(remote_path_component_count LESS 1)
+      return()
+    endif()
+
+    list(POP_BACK remote_path_components)
+    list(POP_FRONT relative_path_components)
+  endforeach()
+
+  list(APPEND final_path_components ${remote_path_components} ${relative_path_components})
+  list(JOIN final_path_components "/" path)
+
+  set("${output_variable}" "${protocol}${auth}${host}${separator}${path}" PARENT_SCOPE)
+endfunction()
+
+
+# The output_variable will be set to the original git_repository if it
+# could not be resolved (no error message is output). The original value is
+# also returned if it doesn't need to be resolved.
+function(_ep_resolve_git_remote
+  output_variable
+  git_repository
+  cmp0150
+  cmp0150_old_base_dir
+)
+  if(git_repository STREQUAL "")
+    set("${output_variable}" "" PARENT_SCOPE)
+    return()
+  endif()
+
+  _ep_is_relative_git_remote(_git_repository_is_relative "${git_repository}")
+
+  if(NOT _git_repository_is_relative)
+    set("${output_variable}" "${git_repository}" PARENT_SCOPE)
+    return()
+  endif()
+
+  if(cmp0150 STREQUAL "NEW")
+    _ep_get_git_remote_url(_parent_git_remote_url "${CMAKE_CURRENT_SOURCE_DIR}")
+    _ep_resolve_relative_git_remote(_resolved_git_remote_url "${_parent_git_remote_url}" "${git_repository}")
+
+    if(_resolved_git_remote_url STREQUAL "")
+      message(FATAL_ERROR
+        "Failed to resolve relative git remote URL:\n"
+        "  Relative URL: ${git_repository}\n"
+        "  Parent URL:   ${_parent_git_remote_url}"
+      )
+    endif()
+    set("${output_variable}" "${_resolved_git_remote_url}" PARENT_SCOPE)
+    return()
+  elseif(cmp0150 STREQUAL "")
+    cmake_policy(GET_WARNING CMP0150 _cmp0150_warning)
+    message(AUTHOR_WARNING
+      "${_cmp0150_warning}\n"
+      "A relative GIT_REPOSITORY path was detected. "
+      "This will be interpreted as a local path to where the project is being cloned. "
+      "Set GIT_REPOSITORY to an absolute path or set policy CMP0150 to NEW to avoid "
+      "this warning."
+    )
+  endif()
+
+  set("${output_variable}" "${cmp0150_old_base_dir}/${git_repository}" PARENT_SCOPE)
+endfunction()
+
+
+macro(_ep_get_hash_algos out_var)
+  set(${out_var}
+    MD5
+    SHA1
+    SHA224
+    SHA256
+    SHA384
+    SHA512
+    SHA3_224
+    SHA3_256
+    SHA3_384
+    SHA3_512
+  )
+endmacro()
+
+
+macro(_ep_get_hash_regex out_var)
+  _ep_get_hash_algos(${out_var})
+  list(JOIN ${out_var} "|" ${out_var})
+  set(${out_var} "^(${${out_var}})=([0-9A-Fa-f]+)$")
+endmacro()
+
+
+function(_ep_parse_arguments_to_vars
+  f
+  keywords
+  name
+  ns
+  args
+)
+  # Transfer the arguments into variables in the calling scope.
+  # Because some keywords can be repeated, we can't use cmake_parse_arguments().
+  # Instead, we loop through the args and consider the namespace starting with
+  # an upper-case letter followed by at least two more upper-case letters,
+  # numbers or underscores to be keywords.
+
+  foreach(key IN LISTS keywords)
+    unset(${ns}${key})
+  endforeach()
+
+  set(key)
+
+  foreach(arg IN LISTS args)
+    set(is_value 1)
+
+    if(arg MATCHES "^[A-Z][A-Z0-9_][A-Z0-9_]+$" AND
+      NOT (("x${arg}x" STREQUAL "x${key}x") AND
+    ("x${key}x" STREQUAL "xCOMMANDx")) AND
+      NOT arg MATCHES "^(TRUE|FALSE|YES)$")
+      if(arg IN_LIST keywords)
+        set(is_value 0)
+      endif()
+    endif()
+
+    if(is_value)
+      if(key)
+        # Value
+        list(APPEND ${ns}${key} "${arg}")
+      else()
+        # Missing Keyword
+        message(AUTHOR_WARNING
+          "value '${arg}' with no previous keyword in ${f}"
+        )
+      endif()
+    else()
+      set(key "${arg}")
+    endif()
+  endforeach()
+
+  foreach(key IN LISTS keywords)
+    if(DEFINED ${ns}${key})
+      set(${ns}${key} "${${ns}${key}}" PARENT_SCOPE)
+    else()
+      unset(${ns}${key} PARENT_SCOPE)
+    endif()
+  endforeach()
+
+endfunction()
+
+
+# NOTE: This cannot be a macro because that will evaluate anything that looks
+#       like a CMake variable in any of the args.
+function(_ep_parse_arguments
+  f
+  keywords
+  name
+  ns
+  args
+)
+  _ep_parse_arguments_to_vars(
+    "${f}"
+    "${keywords}"
+    ${name}
+    ${ns}
+    "${args}"
+  )
+
+  foreach(key IN LISTS keywords)
+    if(DEFINED ${ns}${key})
+      set(${ns}${key} "${${ns}${key}}" PARENT_SCOPE)
+    else()
+      unset(${ns}${key} PARENT_SCOPE)
+    endif()
+  endforeach()
+
+  # Transfer the arguments to the target as target properties. These are
+  # read by the various steps, potentially from different scopes.
+  foreach(key IN LISTS keywords)
+    if(DEFINED ${ns}${key})
+      set_property(TARGET ${name} PROPERTY ${ns}${key} "${${ns}${key}}")
+    endif()
+  endforeach()
+
+endfunction()
+
+
+function(_ep_get_tls_version name tls_version_var)
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  set(tls_version_regex "^1\\.[0-3]$")
+  set(tls_version "${_EP_TLS_VERSION}")
+  if(NOT "x${tls_version}" STREQUAL "x")
+    if(NOT tls_version MATCHES "${tls_version_regex}")
+      message(FATAL_ERROR "TLS_VERSION '${tls_version}' not known")
+    endif()
+  elseif(NOT "x${CMAKE_TLS_VERSION}" STREQUAL "x")
+    set(tls_version "${CMAKE_TLS_VERSION}")
+    if(NOT tls_version MATCHES "${tls_version_regex}")
+      message(FATAL_ERROR "CMAKE_TLS_VERSION '${tls_version}' not known")
+    endif()
+  elseif(NOT "x$ENV{CMAKE_TLS_VERSION}" STREQUAL "x")
+    set(tls_version "$ENV{CMAKE_TLS_VERSION}")
+    if(NOT tls_version MATCHES "${tls_version_regex}")
+      message(FATAL_ERROR "ENV{CMAKE_TLS_VERSION} '${tls_version}' not known")
+    endif()
+  endif()
+  set("${tls_version_var}" "${tls_version}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_get_tls_verify name tls_verify_var)
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  set(tls_verify "${_EP_TLS_VERIFY}")
+  if("x${tls_verify}" STREQUAL "x")
+    if(NOT "x${CMAKE_TLS_VERIFY}" STREQUAL "x")
+      set(tls_verify "${CMAKE_TLS_VERIFY}")
+    elseif(NOT "x$ENV{CMAKE_TLS_VERIFY}" STREQUAL "x")
+      set(tls_verify "$ENV{CMAKE_TLS_VERIFY}")
+    endif()
+  endif()
+  set("${tls_verify_var}" "${tls_verify}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_get_tls_cainfo name tls_cainfo_var)
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  set(tls_cainfo "${_EP_TLS_CAINFO}")
+  if("x${tls_cainfo}" STREQUAL "x" AND DEFINED CMAKE_TLS_CAINFO)
+    set(tls_cainfo "${CMAKE_TLS_CAINFO}")
+  endif()
+  set("${tls_cainfo_var}" "${tls_cainfo}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_get_netrc name netrc_var)
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  set(netrc "${_EP_NETRC}")
+  if("x${netrc}" STREQUAL "x" AND DEFINED CMAKE_NETRC)
+    set(netrc "${CMAKE_NETRC}")
+  endif()
+  set("${netrc_var}" "${netrc}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_get_netrc_file name netrc_file_var)
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  set(netrc_file "${_EP_NETRC_FILE}")
+  if("x${netrc_file}" STREQUAL "x" AND DEFINED CMAKE_NETRC_FILE)
+    set(netrc_file "${CMAKE_NETRC_FILE}")
+  endif()
+  set("${netrc_file_var}" "${netrc_file}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_write_gitclone_script
+  script_filename
+  source_dir
+  git_EXECUTABLE
+  git_repository
+  git_tag
+  git_remote_name
+  init_submodules
+  git_submodules_recurse
+  git_submodules
+  git_shallow
+  git_progress
+  git_config
+  src_name
+  work_dir
+  gitclone_infofile
+  gitclone_stampfile
+  tls_version
+  tls_verify
+)
+
+  if(NOT GIT_VERSION_STRING VERSION_LESS 1.8.5)
+    # Use `git checkout <tree-ish> --` to avoid ambiguity with a local path.
+    set(git_checkout_explicit-- "--")
+  else()
+    # Use `git checkout <branch>` even though this risks ambiguity with a
+    # local path.  Unfortunately we cannot use `git checkout <tree-ish> --`
+    # because that will not search for remote branch names, a common use case.
+    set(git_checkout_explicit-- "")
+  endif()
+  if("${git_tag}" STREQUAL "")
+    message(FATAL_ERROR "Tag for git checkout should not be empty.")
+  endif()
+
+  if(GIT_VERSION_STRING VERSION_LESS 2.20 OR
+    2.21 VERSION_LESS_EQUAL GIT_VERSION_STRING)
+    set(git_clone_options "--no-checkout")
+  else()
+    set(git_clone_options)
+  endif()
+  if(git_shallow)
+    if(NOT GIT_VERSION_STRING VERSION_LESS 1.7.10)
+      list(APPEND git_clone_options "--depth 1 --no-single-branch")
+    else()
+      list(APPEND git_clone_options "--depth 1")
+    endif()
+  endif()
+  if(git_progress)
+    list(APPEND git_clone_options --progress)
+  endif()
+  foreach(config IN LISTS git_config)
+    list(APPEND git_clone_options --config \"${config}\")
+  endforeach()
+  if(NOT ${git_remote_name} STREQUAL "origin")
+    list(APPEND git_clone_options --origin \"${git_remote_name}\")
+  endif()
+
+  # The clone config option is sticky, it will apply to all subsequent git
+  # update operations. The submodules config option is not sticky, because
+  # git doesn't provide any way to do that. Thus, we will have to pass the
+  # same config option in the update step too for submodules, but not for
+  # the main git repo.
+  set(git_submodules_config_options "")
+  if(NOT "x${tls_version}" STREQUAL "x")
+    list(APPEND git_clone_options -c http.sslVersion=tlsv${tls_version})
+    list(APPEND git_submodules_config_options -c http.sslVersion=tlsv${tls_version})
+  endif()
+  if(NOT "x${tls_verify}" STREQUAL "x")
+    if(tls_verify)
+      # Default git behavior is "true", but the user might have changed the
+      # global default to "false". Since TLS_VERIFY was given, ensure we honor
+      # the specified setting regardless of what the global default might be.
+      list(APPEND git_clone_options -c http.sslVerify=true)
+      list(APPEND git_submodules_config_options -c http.sslVerify=true)
+    else()
+      list(APPEND git_clone_options -c http.sslVerify=false)
+      list(APPEND git_submodules_config_options -c http.sslVerify=false)
+    endif()
+  endif()
+
+  string (REPLACE ";" " " git_clone_options "${git_clone_options}")
+
+  configure_file(
+    ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/gitclone.cmake.in
+    ${script_filename}
+    @ONLY
+  )
+endfunction()
+
+
+function(_ep_write_hgclone_script
+  script_filename
+  source_dir
+  hg_EXECUTABLE
+  hg_repository
+  hg_tag
+  src_name
+  work_dir
+  hgclone_infofile
+  hgclone_stampfile
+)
+
+  if("${hg_tag}" STREQUAL "")
+    message(FATAL_ERROR "Tag for hg checkout should not be empty.")
+  endif()
+
+  configure_file(
+    ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/hgclone.cmake.in
+    ${script_filename}
+    @ONLY
+  )
+endfunction()
+
+
+function(_ep_write_gitupdate_script
+  script_filename
+  git_EXECUTABLE
+  git_tag
+  git_remote_name
+  init_submodules
+  git_submodules_recurse
+  git_submodules
+  git_repository
+  work_dir
+  git_update_strategy
+  tls_version
+  tls_verify
+)
+
+  if("${git_tag}" STREQUAL "")
+    message(FATAL_ERROR "Tag for git checkout should not be empty.")
+  endif()
+  set(git_stash_save_options --quiet)
+  if(GIT_VERSION_STRING VERSION_GREATER_EQUAL 1.7.7)
+    # This avoids stashing files covered by .gitignore
+    list(APPEND git_stash_save_options --include-untracked)
+  elseif(GIT_VERSION_STRING VERSION_GREATER_EQUAL 1.7.6)
+    # Untracked files, but also ignored files, so potentially slower
+    list(APPEND git_stash_save_options --all)
+  endif()
+
+  # The submodules config option is not sticky, git doesn't provide any way
+  # to do that. We have to pass this config option for the update step too.
+  # We don't need to set it for the non-submodule update because it gets
+  # recorded as part of the clone operation in a sticky manner.
+  set(git_submodules_config_options "")
+  if(NOT "x${tls_version}" STREQUAL "x")
+    list(APPEND git_submodules_config_options -c http.sslVersion=tlsv${tls_version})
+  endif()
+  if(NOT "x${tls_verify}" STREQUAL "x")
+    if(tls_verify)
+      # Default git behavior is "true", but the user might have changed the
+      # global default to "false". Since TLS_VERIFY was given, ensure we honor
+      # the specified setting regardless of what the global default might be.
+      list(APPEND git_submodules_config_options -c http.sslVerify=true)
+    else()
+      list(APPEND git_submodules_config_options -c http.sslVerify=false)
+    endif()
+  endif()
+
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/gitupdate.cmake.in"
+    "${script_filename}"
+    @ONLY
+  )
+endfunction()
+
+
+function(_ep_write_downloadfile_script
+  script_filename
+  REMOTE
+  LOCAL
+  timeout
+  inactivity_timeout
+  no_progress
+  hash
+  tls_version
+  tls_verify
+  tls_cainfo
+  userpwd
+  http_headers
+  netrc
+  netrc_file
+)
+  if("x${REMOTE}" STREQUAL "x")
+    message(FATAL_ERROR "REMOTE can't be empty")
+  endif()
+  if("x${LOCAL}" STREQUAL "x")
+    message(FATAL_ERROR "LOCAL can't be empty")
+  endif()
+
+  # REMOTE could contain special characters that parse as separate arguments.
+  # Things like parentheses are legitimate characters in a URL, but would be
+  # seen as the start of a new unquoted argument by the cmake language parser.
+  # Avoid those special cases by preparing quoted strings for direct inclusion
+  # in the foreach() call that iterates over the set of URLs in REMOTE.
+  set(REMOTE "[====[${REMOTE}]====]")
+  string(REPLACE ";" "]====] [====[" REMOTE "${REMOTE}")
+
+  if(timeout)
+    set(TIMEOUT_ARGS TIMEOUT ${timeout})
+    set(TIMEOUT_MSG "${timeout} seconds")
+  else()
+    set(TIMEOUT_ARGS "# no TIMEOUT")
+    set(TIMEOUT_MSG "none")
+  endif()
+  if(inactivity_timeout)
+    set(INACTIVITY_TIMEOUT_ARGS INACTIVITY_TIMEOUT ${inactivity_timeout})
+    set(INACTIVITY_TIMEOUT_MSG "${inactivity_timeout} seconds")
+  else()
+    set(INACTIVITY_TIMEOUT_ARGS "# no INACTIVITY_TIMEOUT")
+    set(INACTIVITY_TIMEOUT_MSG "none")
+  endif()
+
+  if(no_progress)
+    set(SHOW_PROGRESS "")
+  else()
+    set(SHOW_PROGRESS "SHOW_PROGRESS")
+  endif()
+
+  _ep_get_hash_regex(_ep_hash_regex)
+  if("${hash}" MATCHES "${_ep_hash_regex}")
+    set(ALGO "${CMAKE_MATCH_1}")
+    string(TOLOWER "${CMAKE_MATCH_2}" EXPECT_VALUE)
+  else()
+    set(ALGO "")
+    set(EXPECT_VALUE "")
+  endif()
+
+  set(TLS_VERSION_CODE "")
+  if(NOT "x${tls_version}" STREQUAL "x")
+    set(TLS_VERSION_CODE "set(CMAKE_TLS_VERSION \"${tls_version}\")")
+  endif()
+
+  set(TLS_VERIFY_CODE "")
+  if(NOT "x${tls_verify}" STREQUAL "x")
+    set(TLS_VERIFY_CODE "set(CMAKE_TLS_VERIFY \"${tls_verify}\")")
+  endif()
+
+  set(TLS_CAINFO_CODE "")
+  if(NOT "x${tls_cainfo}" STREQUAL "x")
+    set(TLS_CAINFO_CODE "set(CMAKE_TLS_CAINFO \"${tls_cainfo}\")")
+  endif()
+
+  set(NETRC_CODE "")
+  if(NOT "x${netrc}" STREQUAL "x")
+    set(NETRC_CODE "set(CMAKE_NETRC \"${netrc}\")")
+  endif()
+
+  set(NETRC_FILE_CODE "")
+  if(NOT "x${netrc_file}" STREQUAL "x")
+    set(NETRC_FILE_CODE "set(CMAKE_NETRC_FILE \"${netrc_file}\")")
+  endif()
+
+  if(userpwd STREQUAL ":")
+    set(USERPWD_ARGS)
+  else()
+    set(USERPWD_ARGS USERPWD "${userpwd}")
+  endif()
+
+  set(HTTP_HEADERS_ARGS "")
+  if(NOT http_headers STREQUAL "")
+    foreach(header IN LISTS http_headers)
+      string(PREPEND HTTP_HEADERS_ARGS
+        "HTTPHEADER \"${header}\"\n        "
+      )
+    endforeach()
+  endif()
+
+  # Used variables:
+  # * TLS_VERSION_CODE
+  # * TLS_VERIFY_CODE
+  # * TLS_CAINFO_CODE
+  # * ALGO
+  # * EXPECT_VALUE
+  # * REMOTE
+  # * LOCAL
+  # * SHOW_PROGRESS
+  # * TIMEOUT_ARGS
+  # * TIMEOUT_MSG
+  # * USERPWD_ARGS
+  # * HTTP_HEADERS_ARGS
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/download.cmake.in"
+    "${script_filename}"
+    @ONLY
+  )
+endfunction()
+
+
+function(_ep_write_verifyfile_script
+  script_filename
+  LOCAL
+  hash
+)
+  _ep_get_hash_regex(_ep_hash_regex)
+  if("${hash}" MATCHES "${_ep_hash_regex}")
+    set(ALGO "${CMAKE_MATCH_1}")
+    string(TOLOWER "${CMAKE_MATCH_2}" EXPECT_VALUE)
+  else()
+    set(ALGO "")
+    set(EXPECT_VALUE "")
+  endif()
+
+  # Used variables:
+  # * ALGO
+  # * EXPECT_VALUE
+  # * LOCAL
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/verify.cmake.in"
+    "${script_filename}"
+    @ONLY
+  )
+endfunction()
+
+
+function(_ep_write_extractfile_script
+  script_filename
+  name
+  filename
+  directory
+  options
+)
+  set(args "")
+
+  if(filename MATCHES
+    "(\\.|=)(7z|tar\\.bz2|tar\\.gz|tar\\.xz|tbz2|tgz|txz|zip)$")
+    set(args xfz)
+  endif()
+
+  if(filename MATCHES "(\\.|=)tar$")
+    set(args xf)
+  endif()
+
+  if(args STREQUAL "")
+    message(FATAL_ERROR
+      "Do not know how to extract '${filename}' -- known types are: "
+      ".7z, .tar, .tar.bz2, .tar.gz, .tar.xz, .tbz2, .tgz, .txz and .zip"
+    )
+  endif()
+
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/extractfile.cmake.in"
+    "${script_filename}"
+    @ONLY
+  )
+endfunction()
+
+
+function(_ep_is_dir_empty dir empty_var)
+  file(GLOB gr "${dir}/*")
+  if("${gr}" STREQUAL "")
+    set(${empty_var} 1 PARENT_SCOPE)
+  else()
+    set(${empty_var} 0 PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(_ep_get_git_submodules_recurse git_submodules_recurse)
+  # Checks for GIT_SUBMODULES_RECURSE argument. Default is ON, which sets
+  # git_submodules_recurse output variable to "--recursive". Otherwise, the
+  # output variable is set to an empty value "".
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  if(NOT DEFINED _EP_GIT_SUBMODULES_RECURSE)
+    set(recurseFlag "--recursive")
+  else()
+    if(_EP_GIT_SUBMODULES_RECURSE)
+      set(recurseFlag "--recursive")
+    else()
+      set(recurseFlag "")
+    endif()
+  endif()
+  set(${git_submodules_recurse} "${recurseFlag}" PARENT_SCOPE)
+
+  # The git submodule update '--recursive' flag requires git >= v1.6.5
+  if(recurseFlag AND GIT_VERSION_STRING VERSION_LESS 1.6.5)
+    message(FATAL_ERROR
+      "git version 1.6.5 or later required for --recursive flag with "
+      "'git submodule ...': GIT_VERSION_STRING='${GIT_VERSION_STRING}'"
+    )
+  endif()
+endfunction()
+
+
+function(_ep_add_script_commands script_var work_dir cmd)
+  # We only support a subset of what ep_replace_location_tags() handles
+  set(location_tags
+    SOURCE_DIR
+    SOURCE_SUBDIR
+    BINARY_DIR
+    TMP_DIR
+    DOWNLOAD_DIR
+    DOWNLOADED_FILE
+  )
+
+  # There can be multiple COMMANDs, but we have to split those up to
+  # one command per call to execute_process()
+  string(CONCAT execute_process_cmd
+    "execute_process(\n"
+    "  WORKING_DIRECTORY \"${work_dir}\"\n"
+    "  COMMAND_ERROR_IS_FATAL LAST\n"
+  )
+  cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+  if(active_log_level MATCHES "VERBOSE|DEBUG|TRACE")
+    string(APPEND execute_process_cmd "  COMMAND_ECHO STDOUT\n")
+  endif()
+  string(APPEND execute_process_cmd "  COMMAND ")
+
+  string(APPEND ${script_var} "${execute_process_cmd}")
+
+  foreach(cmd_arg IN LISTS cmd)
+    if(cmd_arg STREQUAL "COMMAND")
+      string(APPEND ${script_var} "\n)\n${execute_process_cmd}")
+    else()
+      if(_EP_LIST_SEPARATOR)
+        string(REPLACE "${_EP_LIST_SEPARATOR}" "\\;" cmd_arg "${cmd_arg}")
+      endif()
+      foreach(dir IN LISTS location_tags)
+        string(REPLACE "<${dir}>" "${_EP_${dir}}" cmd_arg "${cmd_arg}")
+      endforeach()
+      string(APPEND ${script_var} " [====[${cmd_arg}]====]")
+    endif()
+  endforeach()
+
+  string(APPEND ${script_var} "\n)")
+  set(${script_var} "${${script_var}}" PARENT_SCOPE)
+endfunction()
+
+
+function(_ep_add_download_command name)
+  set(noValueOptions )
+  set(singleValueOptions
+    SCRIPT_FILE        # These should only be used by FetchContent
+    DEPENDS_VARIABLE   #
+  )
+  set(multiValueOptions )
+  cmake_parse_arguments(PARSE_ARGV 1 arg
+    "${noValueOptions}" "${singleValueOptions}" "${multiValueOptions}"
+  )
+
+  # The various _EP_... variables mentioned here and throughout this function
+  # are expected to already have been set by the caller via a call to
+  # _ep_parse_arguments() or ep_parse_arguments_to_vars(). Other variables
+  # with different names are assigned to for historical reasons only to keep
+  # the code more readable and minimize change.
+
+  set(source_dir     "${_EP_SOURCE_DIR}")
+  set(stamp_dir      "${_EP_STAMP_DIR}")
+  set(download_dir   "${_EP_DOWNLOAD_DIR}")
+  set(tmp_dir        "${_EP_TMP_DIR}")
+
+  set(cmd            "${_EP_DOWNLOAD_COMMAND}")
+  set(cvs_repository "${_EP_CVS_REPOSITORY}")
+  set(svn_repository "${_EP_SVN_REPOSITORY}")
+  set(git_repository "${_EP_GIT_REPOSITORY}")
+  set(hg_repository  "${_EP_HG_REPOSITORY}")
+  set(url            "${_EP_URL}")
+  set(fname          "${_EP_DOWNLOAD_NAME}")
+
+  # TODO: Perhaps file:// should be copied to download dir before extraction.
+  string(REGEX REPLACE "file://" "" url "${url}")
+
+  set(step_script_contents)
+  set(depends)
+  set(comment)
+  set(work_dir)
+  set(extra_repo_info)
+
+  if(DEFINED _EP_DOWNLOAD_COMMAND)
+    set(work_dir ${download_dir})
+    set(method custom)
+    if(NOT "x${cmd}" STREQUAL "x" AND arg_SCRIPT_FILE)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+
+  elseif(cvs_repository)
+    set(method cvs)
+    find_package(CVS QUIET)
+    if(NOT CVS_EXECUTABLE)
+      message(FATAL_ERROR "error: could not find cvs for checkout of ${name}")
+    endif()
+
+    set(cvs_module "${_EP_CVS_MODULE}")
+    if(NOT cvs_module)
+      message(FATAL_ERROR "error: no CVS_MODULE")
+    endif()
+
+    set(cvs_tag "${_EP_CVS_TAG}")
+    get_filename_component(src_name "${source_dir}" NAME)
+    get_filename_component(work_dir "${source_dir}" PATH)
+    set(comment "Performing download step (CVS checkout) for '${name}'")
+    set(cmd
+      ${CVS_EXECUTABLE}
+      -d ${cvs_repository}
+      -q
+      co ${cvs_tag}
+      -d ${src_name}
+      ${cvs_module}
+    )
+    if(arg_SCRIPT_FILE)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+
+  elseif(svn_repository)
+    set(method svn)
+    find_package(Subversion QUIET)
+    if(NOT Subversion_SVN_EXECUTABLE)
+      message(FATAL_ERROR "error: could not find svn for checkout of ${name}")
+    endif()
+
+    set(svn_trust_cert "${_EP_SVN_TRUST_CERT}")
+    set(uses_terminal  "${_EP_USES_TERMINAL_DOWNLOAD}")
+
+    get_filename_component(src_name "${source_dir}" NAME)
+    get_filename_component(work_dir "${source_dir}" PATH)
+    set(comment "Performing download step (SVN checkout) for '${name}'")
+    set(cmd
+      ${Subversion_SVN_EXECUTABLE}
+      co
+      ${svn_repository}
+      ${_EP_SVN_REVISION}
+    )
+    # The --trust-server-cert option requires --non-interactive
+    if(svn_trust_cert OR NOT uses_terminal)
+      list(APPEND cmd "--non-interactive")
+    endif()
+    if(svn_trust_cert)
+      list(APPEND cmd "--trust-server-cert")
+    endif()
+    if(DEFINED _EP_SVN_USERNAME)
+      list(APPEND cmd "--username=${_EP_SVN_USERNAME}")
+    endif()
+    if(DEFINED _EP_SVN_PASSWORD)
+      list(APPEND cmd "--password=${_EP_SVN_PASSWORD}")
+    endif()
+    list(APPEND cmd ${src_name})
+
+    if(arg_SCRIPT_FILE)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+
+  elseif(git_repository)
+    set(method git)
+    # FetchContent gives us these directly, so don't try to recompute them
+    if(NOT GIT_EXECUTABLE OR NOT GIT_VERSION_STRING)
+      unset(CMAKE_MODULE_PATH) # Use CMake builtin find module
+      find_package(Git QUIET)
+      if(NOT GIT_EXECUTABLE)
+        message(FATAL_ERROR "error: could not find git for clone of ${name}")
+      endif()
+    endif()
+
+    _ep_get_git_submodules_recurse(git_submodules_recurse)
+
+    set(git_tag "${_EP_GIT_TAG}")
+    if(NOT git_tag)
+      set(git_tag "master")
+    endif()
+
+    set(git_init_submodules TRUE)
+    if(DEFINED _EP_GIT_SUBMODULES)
+      set(git_submodules "${_EP_GIT_SUBMODULES}")
+      if(git_submodules STREQUAL "" AND _EP_CMP0097 STREQUAL "NEW")
+        set(git_init_submodules FALSE)
+      endif()
+    endif()
+
+    set(git_remote_name "${_EP_GIT_REMOTE_NAME}")
+    if(NOT git_remote_name)
+      set(git_remote_name "origin")
+    endif()
+
+    _ep_get_tls_version(${name} tls_version)
+    _ep_get_tls_verify(${name} tls_verify)
+    set(git_shallow  "${_EP_GIT_SHALLOW}")
+    set(git_progress "${_EP_GIT_PROGRESS}")
+    set(git_config   "${_EP_GIT_CONFIG}")
+
+    # If git supports it, make checkouts quiet when checking out a git hash.
+    # This avoids the very noisy detached head message.
+    if(GIT_VERSION_STRING VERSION_GREATER_EQUAL 1.7.7)
+      list(PREPEND git_config advice.detachedHead=false)
+    endif()
+
+    # The command doesn't expose any details, so we need to record additional
+    # information in the RepositoryInfo.txt file. For the download step, only
+    # the things specifically affecting the clone operation should be recorded.
+    # If the repo changes, the clone script should be run again.
+    # But if only the tag changes, avoid running the clone script again.
+    # Let the 'always' running update step checkout the new tag.
+    #
+    set(extra_repo_info
+      "repository=${git_repository}
+remote=${git_remote_name}
+init_submodules=${git_init_submodules}
+recurse_submodules=${git_submodules_recurse}
+submodules=${git_submodules}
+CMP0097=${_EP_CMP0097}
+      ")
+    get_filename_component(src_name "${source_dir}" NAME)
+    get_filename_component(work_dir "${source_dir}" PATH)
+
+    # Since git clone doesn't succeed if the non-empty source_dir exists,
+    # create a cmake script to invoke as download command.
+    # The script will delete the source directory and then call git clone.
+    #
+    set(clone_script ${tmp_dir}/${name}-gitclone.cmake)
+    _ep_write_gitclone_script(
+      ${clone_script}
+      ${source_dir}
+      ${GIT_EXECUTABLE}
+      ${git_repository}
+      ${git_tag}
+      ${git_remote_name}
+      ${git_init_submodules}
+      "${git_submodules_recurse}"
+      "${git_submodules}"
+      "${git_shallow}"
+      "${git_progress}"
+      "${git_config}"
+      ${src_name}
+      ${work_dir}
+      ${stamp_dir}/${name}-gitinfo.txt
+      ${stamp_dir}/${name}-gitclone-lastrun.txt
+      "${tls_version}"
+      "${tls_verify}"
+    )
+    set(comment "Performing download step (git clone) for '${name}'")
+    set(cmd ${CMAKE_COMMAND}
+      -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+      -P ${clone_script}
+    )
+
+    if(arg_SCRIPT_FILE)
+      set(step_script_contents "include(\"${clone_script}\")")
+      list(APPEND depends ${clone_script})
+    endif()
+
+  elseif(hg_repository)
+    set(method hg)
+    find_package(Hg QUIET)
+    if(NOT HG_EXECUTABLE)
+      message(FATAL_ERROR "error: could not find hg for clone of ${name}")
+    endif()
+
+    set(hg_tag "${_EP_HG_TAG}")
+    if(NOT hg_tag)
+      set(hg_tag "tip")
+    endif()
+
+    # The command doesn't expose any details, so we need to record additional
+    # information in the RepositoryInfo.txt file. For the download step, only
+    # the things specifically affecting the clone operation should be recorded.
+    # If the repo changes, the clone script should be run again.
+    # But if only the tag changes, avoid running the clone script again.
+    # Let the 'always' running update step checkout the new tag.
+    #
+    set(extra_repo_info "repository=${hg_repository}")
+    get_filename_component(src_name "${source_dir}" NAME)
+    get_filename_component(work_dir "${source_dir}" PATH)
+
+    # Since hg clone doesn't succeed if the non-empty source_dir exists,
+    # create a cmake script to invoke as download command.
+    # The script will delete the source directory and then call hg clone.
+    #
+    set(clone_script ${tmp_dir}/${name}-hgclone.cmake)
+    _ep_write_hgclone_script(
+      ${clone_script}
+      ${source_dir}
+      ${HG_EXECUTABLE}
+      ${hg_repository}
+      ${hg_tag}
+      ${src_name}
+      ${work_dir}
+      ${stamp_dir}/${name}-hginfo.txt
+      ${stamp_dir}/${name}-hgclone-lastrun.txt
+    )
+    set(comment "Performing download step (hg clone) for '${name}'")
+    set(cmd ${CMAKE_COMMAND}
+      -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+      -P ${clone_script}
+    )
+
+    if(arg_SCRIPT_FILE)
+      set(step_script_contents "include(\"${clone_script}\")")
+      list(APPEND depends ${clone_script})
+    endif()
+
+  elseif(url)
+    set(method url)
+    get_filename_component(work_dir "${source_dir}" PATH)
+    set(hash "${_EP_URL_HASH}")
+    _ep_get_hash_regex(_ep_hash_regex)
+    if(hash AND NOT "${hash}" MATCHES "${_ep_hash_regex}")
+      _ep_get_hash_algos(_ep_hash_algos)
+      list(JOIN _ep_hash_algos "|" _ep_hash_algos)
+      message(FATAL_ERROR
+        "URL_HASH is set to\n"
+        "  ${hash}\n"
+        "but must be ALGO=value where ALGO is\n"
+        "  ${_ep_hash_algos}\n"
+        "and value is a hex string."
+      )
+    endif()
+    set(md5 "${_EP_URL_MD5}")
+    if(md5 AND NOT "MD5=${md5}" MATCHES "${_ep_hash_regex}")
+      message(FATAL_ERROR
+        "URL_MD5 is set to\n"
+        "  ${md5}\n"
+        "but must be a hex string."
+      )
+    endif()
+    if(md5 AND NOT hash)
+      set(hash "MD5=${md5}")
+    endif()
+    set(extra_repo_info
+      "url(s)=${url}
+hash=${hash}
+      ")
+
+    list(LENGTH url url_list_length)
+    if(NOT "${url_list_length}" STREQUAL "1")
+      foreach(entry IN LISTS url)
+        if(NOT "${entry}" MATCHES "^[a-z]+://")
+          message(FATAL_ERROR
+            "At least one entry of URL is a path (invalid in a list)"
+          )
+        endif()
+      endforeach()
+      if("x${fname}" STREQUAL "x")
+        list(GET url 0 fname)
+      endif()
+    endif()
+
+    if(IS_DIRECTORY "${url}")
+      get_filename_component(abs_dir "${url}" ABSOLUTE)
+      set(comment "Performing download step (DIR copy) for '${name}'")
+      set(cmd
+        ${CMAKE_COMMAND} -E rm -rf ${source_dir}
+        COMMAND ${CMAKE_COMMAND} -E copy_directory ${abs_dir} ${source_dir}
+      )
+      if(arg_SCRIPT_FILE)
+        # While it may be tempting to implement the two operations directly
+        # with file(), the behavior is different. file(COPY) preserves input
+        # file timestamps, which we don't want. Therefore, still use the same
+        # external commands so that we get the same behavior.
+        _ep_add_script_commands(
+          step_script_contents
+          "${work_dir}"
+          "${cmd}"   # Must be a single quoted argument
+        )
+      endif()
+    else()
+      set(no_extract "${_EP_DOWNLOAD_NO_EXTRACT}")
+      string(APPEND extra_repo_info "no_extract=${no_extract}\n")
+      set(verify_script "${stamp_dir}/verify-${name}.cmake")
+      if("${url}" MATCHES "^[a-z]+://")
+        # TODO: Should download and extraction be different steps?
+        if("x${fname}" STREQUAL "x")
+          set(fname "${url}")
+        endif()
+        set(ext_regex [[7z|tar|tar\.bz2|tar\.gz|tar\.xz|tbz2|tgz|txz|zip]])
+        if("${fname}" MATCHES "([^/\\?#]+(\\.|=)(${ext_regex}))([/?#].*)?$")
+          set(fname "${CMAKE_MATCH_1}")
+        elseif(no_extract)
+          get_filename_component(fname "${fname}" NAME)
+        else()
+          # Fall back to a default file name.  The actual file name does not
+          # matter because it is used only internally and our extraction tool
+          # inspects the file content directly.  If it turns out the wrong URL
+          # was given that will be revealed during the build which is an easier
+          # place for users to diagnose than an error here anyway.
+          set(fname "archive.tar")
+        endif()
+        string(REPLACE ";" "-" fname "${fname}")
+        set(file ${download_dir}/${fname})
+        set(timeout "${_EP_TIMEOUT}")
+        set(inactivity_timeout "${_EP_INACTIVITY_TIMEOUT}")
+        set(no_progress "${_EP_DOWNLOAD_NO_PROGRESS}")
+        _ep_get_tls_version(${name} tls_version)
+        _ep_get_tls_verify(${name} tls_verify)
+        _ep_get_tls_cainfo(${name} tls_cainfo)
+        _ep_get_netrc(${name} netrc)
+        _ep_get_netrc_file(${name} netrc_file)
+        set(http_username "${_EP_HTTP_USERNAME}")
+        set(http_password "${_EP_HTTP_PASSWORD}")
+        set(http_headers  "${_EP_HTTP_HEADER}")
+        set(download_script "${stamp_dir}/download-${name}.cmake")
+        _ep_write_downloadfile_script(
+          "${download_script}"
+          "${url}"
+          "${file}"
+          "${timeout}"
+          "${inactivity_timeout}"
+          "${no_progress}"
+          "${hash}"
+          "${tls_version}"
+          "${tls_verify}"
+          "${tls_cainfo}"
+          "${http_username}:${http_password}"
+          "${http_headers}"
+          "${netrc}"
+          "${netrc_file}"
+        )
+        set(cmd
+          ${CMAKE_COMMAND}
+            -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+            -P "${download_script}"
+          COMMAND
+        )
+        if(arg_SCRIPT_FILE)
+          set(step_script_contents "include(\"${download_script}\")\n")
+        endif()
+
+        if (no_extract)
+          set(steps "download and verify")
+        else ()
+          set(steps "download, verify and extract")
+        endif ()
+        set(comment "Performing download step (${steps}) for '${name}'")
+        # already verified by 'download_script'
+        # We use file(CONFIGURE) instead of file(WRITE) to avoid updating the
+        # timestamp when the file already existed and was empty.
+        file(CONFIGURE OUTPUT "${verify_script}" CONTENT "")
+
+        # Rather than adding everything to the RepositoryInfo.txt file, it is
+        # more robust to just depend on the download script. That way, we will
+        # re-download if any aspect of the download changes.
+        list(APPEND depends "${download_script}")
+      else()
+        set(file "${url}")
+        if (no_extract)
+          set(steps "verify")
+        else ()
+          set(steps "verify and extract")
+        endif ()
+        set(comment "Performing download step (${steps}) for '${name}'")
+        _ep_write_verifyfile_script(
+          "${verify_script}"
+          "${file}"
+          "${hash}"
+        )
+      endif()
+      list(APPEND cmd ${CMAKE_COMMAND}
+        -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+        -P ${verify_script}
+      )
+      if(arg_SCRIPT_FILE)
+        string(APPEND step_script_contents "include(\"${verify_script}\")\n")
+        list(APPEND depends ${verify_script})
+      endif()
+      set(extract_timestamp "${_EP_DOWNLOAD_EXTRACT_TIMESTAMP}")
+      if(no_extract)
+        if(DEFINED _EP_DOWNLOAD_EXTRACT_TIMESTAMP)
+          message(FATAL_ERROR
+            "Cannot specify DOWNLOAD_EXTRACT_TIMESTAMP when using "
+            "DOWNLOAD_NO_EXTRACT TRUE"
+          )
+        endif()
+        if(arg_SCRIPT_FILE)
+          # There's no target to record the location of the downloaded file.
+          # Instead, we copy it to the source directory within the script,
+          # which is what FetchContent always does in this situation.
+          cmake_path(SET safe_file NORMALIZE "${file}")
+          cmake_path(GET safe_file FILENAME filename)
+          string(APPEND step_script_contents
+            "file(COPY_FILE\n"
+            "  \"${file}\"\n"
+            "  \"${source_dir}/${filename}\"\n"
+            "  ONLY_IF_DIFFERENT\n"
+            "  INPUT_MAY_BE_RECENT\n"
+            ")"
+          )
+          list(APPEND depends ${source_dir}/${filename})
+        else()
+          set_property(TARGET ${name} PROPERTY _EP_DOWNLOADED_FILE ${file})
+        endif()
+      else()
+        if(NOT DEFINED _EP_DOWNLOAD_EXTRACT_TIMESTAMP)
+          # Default depends on policy CMP0135
+          if(_EP_CMP0135 STREQUAL "")
+            message(AUTHOR_WARNING
+              "The DOWNLOAD_EXTRACT_TIMESTAMP option was not given and policy "
+              "CMP0135 is not set. The policy's OLD behavior will be used. "
+              "When using a URL download, the timestamps of extracted files "
+              "should preferably be that of the time of extraction, otherwise "
+              "code that depends on the extracted contents might not be "
+              "rebuilt if the URL changes. The OLD behavior preserves the "
+              "timestamps from the archive instead, but this is usually not "
+              "what you want. Update your project to the NEW behavior or "
+              "specify the DOWNLOAD_EXTRACT_TIMESTAMP option with a value of "
+              "true to avoid this robustness issue."
+            )
+            set(extract_timestamp TRUE)
+          elseif(_EP_CMP0135 STREQUAL "NEW")
+            set(extract_timestamp FALSE)
+          else()
+            set(extract_timestamp TRUE)
+          endif()
+        endif()
+        if(extract_timestamp)
+          set(options "")
+        else()
+          set(options "--touch")
+        endif()
+        set(extract_script "${stamp_dir}/extract-${name}.cmake")
+        _ep_write_extractfile_script(
+          "${extract_script}"
+          "${name}"
+          "${file}"
+          "${source_dir}"
+          "${options}"
+        )
+        list(APPEND cmd
+          COMMAND ${CMAKE_COMMAND}
+            -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+            -P ${extract_script}
+        )
+        if(arg_SCRIPT_FILE)
+          string(APPEND step_script_contents "include(\"${extract_script}\")\n")
+          list(APPEND depends ${extract_script})
+        endif()
+      endif ()
+    endif()
+  else()
+    set(method source_dir)
+    _ep_is_dir_empty("${source_dir}" empty)
+    if(${empty})
+      message(FATAL_ERROR
+        "No download info given for '${name}' and its source directory:\n"
+        " ${source_dir}\n"
+        "is not an existing non-empty directory.  Please specify one of:\n"
+        " * SOURCE_DIR with an existing non-empty directory\n"
+        " * DOWNLOAD_COMMAND\n"
+        " * URL\n"
+        " * GIT_REPOSITORY\n"
+        " * SVN_REPOSITORY\n"
+        " * HG_REPOSITORY\n"
+        " * CVS_REPOSITORY and CVS_MODULE"
+      )
+    endif()
+    if(arg_SCRIPT_FILE)
+      set(step_script_contents "message(VERBOSE [[Using SOURCE_DIR as is]])")
+    endif()
+  endif()
+
+  # We use configure_file() to write the repo_info_file so that the file's
+  # timestamp is not updated if we don't change the contents
+
+  set(repo_info_file ${stamp_dir}/${name}-${method}info.txt)
+  list(APPEND depends ${repo_info_file})
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/RepositoryInfo.txt.in"
+    "${repo_info_file}"
+    @ONLY
+  )
+
+  if(arg_SCRIPT_FILE)
+    set(step_name download)
+    configure_file(
+      "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/stepscript.cmake.in"
+      "${arg_SCRIPT_FILE}"
+      @ONLY
+    )
+    set(${arg_DEPENDS_VARIABLE} "${depends}" PARENT_SCOPE)
+    return()
+  endif()
+
+  # Nothing below this point is applicable when we've been asked to put the
+  # download step in a script file (which is the FetchContent case).
+
+  if(_EP_LOG_DOWNLOAD)
+    set(log LOG 1)
+  else()
+    set(log "")
+  endif()
+
+  if(_EP_USES_TERMINAL_DOWNLOAD)
+    set(uses_terminal USES_TERMINAL 1)
+  else()
+    set(uses_terminal "")
+  endif()
+
+  set(__cmdQuoted)
+  foreach(__item IN LISTS cmd)
+    string(APPEND __cmdQuoted " [==[${__item}]==]")
+  endforeach()
+  cmake_language(EVAL CODE "
+    ExternalProject_Add_Step(\${name} download
+      INDEPENDENT TRUE
+      COMMENT \${comment}
+      COMMAND ${__cmdQuoted}
+      WORKING_DIRECTORY \${work_dir}
+      DEPENDS \${depends}
+      DEPENDEES mkdir
+      ${log}
+      ${uses_terminal}
+    )"
+  )
+endfunction()
+
+function(_ep_get_update_disconnected var name)
+  # Note that the arguments are assumed to have already been parsed and have
+  # been translated into variables with the prefix _EP_... by a call to
+  # ep_parse_arguments() or ep_parse_arguments_to_vars().
+  if(DEFINED _EP_UPDATE_DISCONNECTED)
+    set(update_disconnected "${_EP_UPDATE_DISCONNECTED}")
+  else()
+    get_property(update_disconnected
+      DIRECTORY
+      PROPERTY EP_UPDATE_DISCONNECTED
+    )
+  endif()
+  set(${var} "${update_disconnected}" PARENT_SCOPE)
+endfunction()
+
+function(_ep_add_update_command name)
+  set(noValueOptions )
+  set(singleValueOptions
+    SCRIPT_FILE       # These should only be used by FetchContent
+    DEPEND_VARIABLE   #
+  )
+  set(multiValueOptions )
+  cmake_parse_arguments(PARSE_ARGV 1 arg
+    "${noValueOptions}" "${singleValueOptions}" "${multiValueOptions}"
+  )
+
+  # The various _EP_... variables mentioned here and throughout this function
+  # are expected to already have been set by the caller via a call to
+  # _ep_parse_arguments() or ep_parse_arguments_to_vars(). Other variables
+  # with different names are assigned to for historical reasons only to keep
+  # the code more readable and minimize change.
+
+  set(source_dir     "${_EP_SOURCE_DIR}")
+  set(stamp_dir      "${_EP_STAMP_DIR}")
+  set(tmp_dir        "${_EP_TMP_DIR}")
+
+  set(cmd            "${_EP_UPDATE_COMMAND}")
+  set(cvs_repository "${_EP_CVS_REPOSITORY}")
+  set(svn_repository "${_EP_SVN_REPOSITORY}")
+  set(git_repository "${_EP_GIT_REPOSITORY}")
+  set(hg_repository  "${_EP_HG_REPOSITORY}")
+
+  _ep_get_update_disconnected(update_disconnected ${name})
+
+  set(work_dir)
+  set(cmd_disconnected)
+  set(comment)
+  set(comment_disconnected)
+  set(always)
+  set(file_deps)
+
+  if(DEFINED _EP_UPDATE_COMMAND)
+    set(work_dir ${source_dir})
+    if(NOT "x${cmd}" STREQUAL "x")
+      set(always 1)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+
+  elseif(cvs_repository)
+    if(NOT CVS_EXECUTABLE)
+      message(FATAL_ERROR "error: could not find cvs for update of ${name}")
+    endif()
+    set(work_dir ${source_dir})
+    set(comment "Performing update step (CVS update) for '${name}'")
+    set(cvs_tag "${_EP_CVS_TAG}")
+    set(cmd ${CVS_EXECUTABLE} -d ${cvs_repository} -q up -dP ${cvs_tag})
+    set(always 1)
+
+    if(arg_SCRIPT_FILE)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+
+  elseif(svn_repository)
+    if(NOT Subversion_SVN_EXECUTABLE)
+      message(FATAL_ERROR "error: could not find svn for update of ${name}")
+    endif()
+    set(work_dir ${source_dir})
+    set(comment "Performing update step (SVN update) for '${name}'")
+    set(svn_trust_cert "${_EP_SVN_TRUST_CERT}")
+    set(uses_terminal  "${_EP_USES_TERMINAL_UPDATE}")
+    set(cmd
+      ${Subversion_SVN_EXECUTABLE}
+      up
+      ${_EP_SVN_REVISION}
+    )
+    # The --trust-server-cert option requires --non-interactive
+    if(svn_trust_cert OR NOT uses_terminal)
+      list(APPEND cmd "--non-interactive")
+    endif()
+    if(svn_trust_cert)
+      list(APPEND cmd --trust-server-cert)
+    endif()
+    if(DEFINED _EP_SVN_USERNAME)
+      list(APPEND cmd "--username=${_EP_SVN_USERNAME}")
+    endif()
+    if(DEFINED _EP_SVN_PASSWORD)
+      list(APPEND cmd "--password=${_EP_SVN_PASSWORD}")
+    endif()
+    set(always 1)
+
+    if(arg_SCRIPT_FILE)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+
+  elseif(git_repository)
+    # FetchContent gives us these directly, so don't try to recompute them
+    if(NOT GIT_EXECUTABLE OR NOT GIT_VERSION_STRING)
+      unset(CMAKE_MODULE_PATH) # Use CMake builtin find module
+      find_package(Git QUIET)
+      if(NOT GIT_EXECUTABLE)
+        message(FATAL_ERROR "error: could not find git for fetch of ${name}")
+      endif()
+    endif()
+    set(work_dir ${source_dir})
+    set(comment "Performing update step for '${name}'")
+    set(comment_disconnected "Performing disconnected update step for '${name}'")
+
+    if(update_disconnected)
+      set(can_fetch_default NO)
+    else()
+      set(can_fetch_default YES)
+    endif()
+
+    set(git_tag "${_EP_GIT_TAG}")
+    if(NOT git_tag)
+      set(git_tag "master")
+    endif()
+
+    set(git_remote_name "${_EP_GIT_REMOTE_NAME}")
+    if(NOT git_remote_name)
+      set(git_remote_name "origin")
+    endif()
+
+    set(git_init_submodules TRUE)
+    if(DEFINED _EP_GIT_SUBMODULES)
+      set(git_submodules "${_EP_GIT_SUBMODULES}")
+      if(git_submodules STREQUAL "" AND _EP_CMP0097 STREQUAL "NEW")
+        set(git_init_submodules FALSE)
+      endif()
+    endif()
+
+    set(git_update_strategy "${_EP_GIT_REMOTE_UPDATE_STRATEGY}")
+    if(NOT git_update_strategy)
+      set(git_update_strategy "${CMAKE_EP_GIT_REMOTE_UPDATE_STRATEGY}")
+    endif()
+    if(NOT git_update_strategy)
+      set(git_update_strategy REBASE)
+    endif()
+    set(strategies CHECKOUT REBASE REBASE_CHECKOUT)
+    if(NOT git_update_strategy IN_LIST strategies)
+      message(FATAL_ERROR
+        "'${git_update_strategy}' is not one of the supported strategies: "
+        "${strategies}"
+      )
+    endif()
+
+    _ep_get_git_submodules_recurse(git_submodules_recurse)
+
+    _ep_get_tls_version(${name} tls_version)
+    _ep_get_tls_verify(${name} tls_verify)
+
+    set(update_script "${tmp_dir}/${name}-gitupdate.cmake")
+    list(APPEND file_deps ${update_script})
+    _ep_write_gitupdate_script(
+      "${update_script}"
+      "${GIT_EXECUTABLE}"
+      "${git_tag}"
+      "${git_remote_name}"
+      "${git_init_submodules}"
+      "${git_submodules_recurse}"
+      "${git_submodules}"
+      "${git_repository}"
+      "${work_dir}"
+      "${git_update_strategy}"
+      "${tls_version}"
+      "${tls_verify}"
+    )
+    set(cmd ${CMAKE_COMMAND}
+      -Dcan_fetch=YES
+      -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+      -P ${update_script}
+    )
+    set(cmd_disconnected ${CMAKE_COMMAND}
+      -Dcan_fetch=NO
+      -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE
+      -P ${update_script}
+    )
+    set(always 1)
+
+    if(arg_SCRIPT_FILE)
+      set(step_script_contents "include(\"${update_script}\")")
+    endif()
+
+  elseif(hg_repository)
+    if(NOT HG_EXECUTABLE)
+      message(FATAL_ERROR "error: could not find hg for pull of ${name}")
+    endif()
+    set(work_dir ${source_dir})
+    set(comment "Performing update step (hg pull) for '${name}'")
+    set(comment_disconnected "Performing disconnected update step for '${name}'")
+
+    set(hg_tag "${_EP_HG_TAG}")
+    if(NOT hg_tag)
+      set(hg_tag "tip")
+    endif()
+
+    if("${HG_VERSION_STRING}" STREQUAL "2.1")
+      set(notesAnchor
+        "#A2.1.1:_revert_pull_return_code_change.2C_compile_issue_on_OS_X"
+      )
+      message(WARNING
+        "Mercurial 2.1 does not distinguish an empty pull from a failed pull:
+ http://mercurial.selenic.com/wiki/UpgradeNotes${notesAnchor}
+ http://thread.gmane.org/gmane.comp.version-control.mercurial.devel/47656
+Update to Mercurial >= 2.1.1.
+")
+    endif()
+
+    set(cmd
+      ${HG_EXECUTABLE} pull
+      COMMAND ${HG_EXECUTABLE} update ${hg_tag}
+    )
+    set(cmd_disconnected ${HG_EXECUTABLE} update ${hg_tag})
+    set(always 1)
+
+    if(arg_SCRIPT_FILE)
+      # These commands are simple, and we know whether updates need to be
+      # disconnected or not for this case, so write them directly instead of
+      # forming them from "cmd" and "cmd_disconnected".
+      if(NOT update_disconnected)
+        string(APPEND step_script_contents
+          "execute_process(\n"
+          "  WORKING_DIRECTORY \"${work_dir}\"\n"
+          "  COMMAND_ERROR_IS_FATAL LAST\n"
+          "  COMMAND \"${HG_EXECUTABLE}\" pull\n"
+          ")"
+        )
+      endif()
+      string(APPEND step_script_contents
+        "execute_process(\n"
+        "  WORKING_DIRECTORY \"${work_dir}\"\n"
+        "  COMMAND_ERROR_IS_FATAL LAST\n"
+        "  COMMAND \"${HG_EXECUTABLE}\" update \"${hg_tag}\"\n"
+        ")"
+      )
+    endif()
+  endif()
+
+  # We use configure_file() to write the update_info_file so that the file's
+  # timestamp is not updated if we don't change the contents
+  if(NOT DEFINED cmd_disconnected)
+    set(cmd_disconnected "${cmd}")
+  endif()
+  set(update_info_file ${stamp_dir}/${name}-update-info.txt)
+  list(APPEND file_deps ${update_info_file})
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/UpdateInfo.txt.in"
+    "${update_info_file}"
+    @ONLY
+  )
+
+  if(arg_SCRIPT_FILE)
+    set(step_name update)
+    configure_file(
+      "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/stepscript.cmake.in"
+      "${arg_SCRIPT_FILE}"
+      @ONLY
+    )
+    set(${arg_DEPENDS_VARIABLE} "${file_deps}" PARENT_SCOPE)
+    return()
+  endif()
+
+  # Nothing below this point is applicable when we've been asked to put the
+  # update step in a script file (which is the FetchContent case).
+
+  if(_EP_LOG_UPDATE)
+    set(log LOG 1)
+  else()
+    set(log "")
+  endif()
+
+  if(_EP_USES_TERMINAL_UPDATE)
+    set(uses_terminal USES_TERMINAL 1)
+  else()
+    set(uses_terminal "")
+  endif()
+
+  set(__cmdQuoted)
+  foreach(__item IN LISTS cmd)
+    string(APPEND __cmdQuoted " [==[${__item}]==]")
+  endforeach()
+  cmake_language(EVAL CODE "
+    ExternalProject_Add_Step(${name} update
+      INDEPENDENT TRUE
+      COMMENT \${comment}
+      COMMAND ${__cmdQuoted}
+      ALWAYS \${always}
+      EXCLUDE_FROM_MAIN \${update_disconnected}
+      WORKING_DIRECTORY \${work_dir}
+      DEPENDEES download
+      DEPENDS \${file_deps}
+      ${log}
+      ${uses_terminal}
+    )"
+  )
+  if(update_disconnected)
+    if(NOT DEFINED comment_disconnected)
+      set(comment_disconnected "${comment}")
+    endif()
+    set(__cmdQuoted)
+    foreach(__item IN LISTS cmd_disconnected)
+      string(APPEND __cmdQuoted " [==[${__item}]==]")
+    endforeach()
+
+    cmake_language(EVAL CODE "
+      ExternalProject_Add_Step(${name} update_disconnected
+        INDEPENDENT TRUE
+        COMMENT \${comment_disconnected}
+        COMMAND ${__cmdQuoted}
+        WORKING_DIRECTORY \${work_dir}
+        DEPENDEES download
+        DEPENDS \${file_deps}
+        ${log}
+        ${uses_terminal}
+      )"
+    )
+  endif()
+
+endfunction()
+
+
+function(_ep_add_patch_command name)
+  set(noValueOptions )
+  set(singleValueOptions
+    SCRIPT_FILE        # These should only be used by FetchContent
+  )
+  set(multiValueOptions )
+  cmake_parse_arguments(PARSE_ARGV 1 arg
+    "${noValueOptions}" "${singleValueOptions}" "${multiValueOptions}"
+  )
+
+  # The various _EP_... variables mentioned here and throughout this function
+  # are expected to already have been set by the caller via a call to
+  # _ep_parse_arguments() or ep_parse_arguments_to_vars(). Other variables
+  # with different names are assigned to for historical reasons only to keep
+  # the code more readable and minimize change.
+
+  set(source_dir "${_EP_SOURCE_DIR}")
+  set(stamp_dir  "${_EP_STAMP_DIR}")
+
+  set(cmd "${_EP_PATCH_COMMAND}")
+  set(step_script_contents "")
+
+  set(work_dir)
+  if(DEFINED _EP_PATCH_COMMAND)
+    set(work_dir ${source_dir})
+    if(arg_SCRIPT_FILE)
+      _ep_add_script_commands(
+        step_script_contents
+        "${work_dir}"
+        "${cmd}"   # Must be a single quoted argument
+      )
+    endif()
+  endif()
+
+  # We use configure_file() to write the patch_info_file so that the file's
+  # timestamp is not updated if we don't change the contents
+  set(patch_info_file ${stamp_dir}/${name}-patch-info.txt)
+  configure_file(
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/PatchInfo.txt.in"
+    "${patch_info_file}"
+    @ONLY
+  )
+
+  if(arg_SCRIPT_FILE)
+    set(step_name patch)
+    configure_file(
+      "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/stepscript.cmake.in"
+      "${arg_SCRIPT_FILE}"
+      @ONLY
+    )
+    return()
+  endif()
+
+  # Nothing below this point is applicable when we've been asked to put the
+  # patch step in a script file (which is the FetchContent case).
+
+  if(_EP_LOG_PATCH)
+    set(log LOG 1)
+  else()
+    set(log "")
+  endif()
+
+  if(_EP_USES_TERMINAL_PATCH)
+    set(uses_terminal USES_TERMINAL 1)
+  else()
+    set(uses_terminal "")
+  endif()
+
+  _ep_get_update_disconnected(update_disconnected ${name})
+
+  set(__cmdQuoted)
+  foreach(__item IN LISTS cmd)
+    string(APPEND __cmdQuoted " [==[${__item}]==]")
+  endforeach()
+  cmake_language(EVAL CODE "
+    ExternalProject_Add_Step(${name} patch
+      INDEPENDENT TRUE
+      COMMAND ${__cmdQuoted}
+      WORKING_DIRECTORY \${work_dir}
+      EXCLUDE_FROM_MAIN \${update_disconnected}
+      DEPENDEES update
+      DEPENDS \${patch_info_file}
+      ${log}
+      ${uses_terminal}
+    )"
+  )
+
+  if(update_disconnected)
+    cmake_language(EVAL CODE "
+      ExternalProject_Add_Step(${name} patch_disconnected
+        INDEPENDENT TRUE
+        COMMAND ${__cmdQuoted}
+        WORKING_DIRECTORY \${work_dir}
+        DEPENDEES update_disconnected
+        DEPENDS \${patch_info_file}
+        ${log}
+        ${uses_terminal}
+      )"
+    )
+  endif()
+
+endfunction()
+
+
+macro(_ep_get_add_keywords out_var)
+  set(${out_var}
+    #
+    # Directory options
+    #
+    PREFIX
+    TMP_DIR
+    STAMP_DIR
+    LOG_DIR
+    DOWNLOAD_DIR
+    SOURCE_DIR
+    BINARY_DIR
+    INSTALL_DIR
+    #
+    # Download step options
+    #
+    DOWNLOAD_COMMAND
+    #
+    URL
+    URL_HASH
+    URL_MD5
+    DOWNLOAD_NAME
+    DOWNLOAD_EXTRACT_TIMESTAMP
+    DOWNLOAD_NO_EXTRACT
+    DOWNLOAD_NO_PROGRESS
+    TIMEOUT
+    INACTIVITY_TIMEOUT
+    HTTP_USERNAME
+    HTTP_PASSWORD
+    HTTP_HEADER
+    TLS_VERSION    # Also used for git clone operations
+    TLS_VERIFY     # Also used for git clone operations
+    TLS_CAINFO
+    NETRC
+    NETRC_FILE
+    #
+    GIT_REPOSITORY
+    GIT_TAG
+    GIT_REMOTE_NAME
+    GIT_SUBMODULES
+    GIT_SUBMODULES_RECURSE
+    GIT_SHALLOW
+    GIT_PROGRESS
+    GIT_CONFIG
+    GIT_REMOTE_UPDATE_STRATEGY
+    #
+    SVN_REPOSITORY
+    SVN_REVISION
+    SVN_USERNAME
+    SVN_PASSWORD
+    SVN_TRUST_CERT
+    #
+    HG_REPOSITORY
+    HG_TAG
+    #
+    CVS_REPOSITORY
+    CVS_MODULE
+    CVS_TAG
+    #
+    # Update step options
+    #
+    UPDATE_COMMAND
+    UPDATE_DISCONNECTED
+    #
+    # Patch step options
+    #
+    PATCH_COMMAND
+    #
+    # Configure step options
+    #
+    CONFIGURE_COMMAND
+    CMAKE_COMMAND
+    CMAKE_GENERATOR
+    CMAKE_GENERATOR_PLATFORM
+    CMAKE_GENERATOR_TOOLSET
+    CMAKE_GENERATOR_INSTANCE
+    CMAKE_ARGS
+    CMAKE_CACHE_ARGS
+    CMAKE_CACHE_DEFAULT_ARGS
+    SOURCE_SUBDIR
+    CONFIGURE_HANDLED_BY_BUILD
+    #
+    # Build step options
+    #
+    BUILD_COMMAND
+    BUILD_IN_SOURCE
+    BUILD_ALWAYS
+    BUILD_BYPRODUCTS
+    BUILD_JOB_SERVER_AWARE
+    #
+    # Install step options
+    #
+    INSTALL_COMMAND
+    INSTALL_BYPRODUCTS
+    #
+    # Test step options
+    #
+    TEST_COMMAND
+    TEST_BEFORE_INSTALL
+    TEST_AFTER_INSTALL
+    TEST_EXCLUDE_FROM_MAIN
+    #
+    # Logging options
+    #
+    LOG_DOWNLOAD
+    LOG_UPDATE
+    LOG_PATCH
+    LOG_CONFIGURE
+    LOG_BUILD
+    LOG_INSTALL
+    LOG_TEST
+    LOG_MERGED_STDOUTERR
+    LOG_OUTPUT_ON_FAILURE
+    #
+    # Terminal access options
+    #
+    USES_TERMINAL_DOWNLOAD
+    USES_TERMINAL_UPDATE
+    USES_TERMINAL_PATCH
+    USES_TERMINAL_CONFIGURE
+    USES_TERMINAL_BUILD
+    USES_TERMINAL_INSTALL
+    USES_TERMINAL_TEST
+    #
+    # Target options
+    #
+    DEPENDS
+    EXCLUDE_FROM_ALL
+    STEP_TARGETS
+    INDEPENDENT_STEP_TARGETS
+    #
+    # Miscellaneous options
+    #
+    LIST_SEPARATOR
+    #
+    # Internal options (undocumented)
+    #
+    EXTERNALPROJECT_INTERNAL_ARGUMENT_SEPARATOR
+  )
+endmacro()

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/stepscript.cmake.in

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+message(VERBOSE "Executing @step_name@ step for @name@")
+
+block(SCOPE_FOR VARIABLES)
+
+@step_script_contents@
+
+endblock()

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/ExternalProject/verify.cmake.in

@@ -0,0 +1,37 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+if("@LOCAL@" STREQUAL "")
+  message(FATAL_ERROR "LOCAL can't be empty")
+endif()
+
+if(NOT EXISTS "@LOCAL@")
+  message(FATAL_ERROR "File not found: @LOCAL@")
+endif()
+
+if("@ALGO@" STREQUAL "")
+  message(WARNING "File cannot be verified since no URL_HASH specified")
+  return()
+endif()
+
+if("@EXPECT_VALUE@" STREQUAL "")
+  message(FATAL_ERROR "EXPECT_VALUE can't be empty")
+endif()
+
+message(VERBOSE "verifying file...
+     file='@LOCAL@'")
+
+file("@ALGO@" "@LOCAL@" actual_value)
+
+if(NOT "${actual_value}" STREQUAL "@EXPECT_VALUE@")
+  message(FATAL_ERROR "error: @ALGO@ hash of
+  @LOCAL@
+does not match expected value
+  expected: '@EXPECT_VALUE@'
+    actual: '${actual_value}'
+")
+endif()
+
+message(VERBOSE "verifying file... done")

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FetchContent/package-config-version.cmake.in

@@ -0,0 +1,8 @@
+# Automatically generated by CMake's FetchContent module.
+# Do not edit this file, it will be regenerated every time CMake runs.
+
+# Version not available, assuming it is compatible. We must also say it is an
+# exact match to ensure find_package() calls with the EXACT keyword still get
+# redirected.
+set(PACKAGE_VERSION_COMPATIBLE TRUE)
+set(PACKAGE_VERSION_EXACT TRUE)

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FortranCInterface/Detect.cmake

@@ -0,0 +1,196 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+configure_file(${FortranCInterface_SOURCE_DIR}/Input.cmake.in
+               ${FortranCInterface_BINARY_DIR}/Input.cmake @ONLY)
+
+# Detect the Fortran/C interface on the first run or when the
+# configuration changes.
+if(NOT EXISTS ${FortranCInterface_BINARY_DIR}/Output.cmake
+    OR NOT EXISTS ${FortranCInterface_BINARY_DIR}/Input.cmake
+    OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake
+      IS_NEWER_THAN ${FortranCInterface_BINARY_DIR}/Input.cmake
+    OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake
+      IS_NEWER_THAN ${FortranCInterface_SOURCE_DIR}/Output.cmake.in
+    OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake
+      IS_NEWER_THAN ${FortranCInterface_SOURCE_DIR}/CMakeLists.txt
+    OR NOT ${FortranCInterface_BINARY_DIR}/Output.cmake
+      IS_NEWER_THAN ${CMAKE_CURRENT_LIST_FILE}
+    )
+  message(CHECK_START "Detecting Fortran/C Interface")
+else()
+  return()
+endif()
+
+# Invalidate verification results.
+unset(FortranCInterface_VERIFIED_C CACHE)
+unset(FortranCInterface_VERIFIED_CXX CACHE)
+
+set(_result)
+
+# Perform detection with only one architecture so that
+# the info strings are not repeated.
+if(CMAKE_OSX_ARCHITECTURES MATCHES "^([^;]+)(;|$)")
+  set(_FortranCInterface_OSX_ARCH "-DCMAKE_OSX_ARCHITECTURES=${CMAKE_MATCH_1}")
+else()
+  set(_FortranCInterface_OSX_ARCH "")
+endif()
+
+cmake_policy(GET CMP0056 _FortranCInterface_CMP0056)
+if(_FortranCInterface_CMP0056 STREQUAL "NEW")
+  set(_FortranCInterface_EXE_LINKER_FLAGS "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}")
+else()
+  set(_FortranCInterface_EXE_LINKER_FLAGS "")
+endif()
+unset(_FortranCInterface_CMP0056)
+
+# Build a sample project which reports symbols.
+set(CMAKE_TRY_COMPILE_CONFIGURATION Release)
+try_compile(FortranCInterface_COMPILED
+  PROJECT FortranCInterface
+  TARGET FortranCInterface
+  SOURCE_DIR ${FortranCInterface_SOURCE_DIR}
+  BINARY_DIR ${FortranCInterface_BINARY_DIR}
+  LOG_DESCRIPTION "Fortran/C interface test project"
+  CMAKE_FLAGS
+    "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}"
+    "-DCMAKE_Fortran_FLAGS:STRING=${CMAKE_Fortran_FLAGS}"
+    "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE}"
+    "-DCMAKE_Fortran_FLAGS_RELEASE:STRING=${CMAKE_Fortran_FLAGS_RELEASE}"
+    ${_FortranCInterface_OSX_ARCH}
+    ${_FortranCInterface_EXE_LINKER_FLAGS}
+  )
+set(FortranCInterface_COMPILED ${FortranCInterface_COMPILED})
+unset(FortranCInterface_COMPILED CACHE)
+unset(_FortranCInterface_EXE_LINKER_FLAGS)
+unset(_FortranCInterface_OSX_ARCH)
+
+# Locate the sample project executable.
+set(FortranCInterface_EXE)
+if(FortranCInterface_COMPILED)
+  include(${FortranCInterface_BINARY_DIR}/exe-Release.cmake OPTIONAL)
+else()
+  set(_result "Failed to compile")
+endif()
+
+# Load symbols from INFO:symbol[] strings in the executable.
+set(FortranCInterface_SYMBOLS)
+if(FortranCInterface_EXE)
+  cmake_policy(PUSH)
+  cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
+  file(STRINGS "${FortranCInterface_EXE}" _info_strings
+    LIMIT_COUNT 8 REGEX "INFO:[A-Za-z0-9_]+\\[[^]]*\\]")
+  cmake_policy(POP)
+  foreach(info ${_info_strings})
+    if("${info}" MATCHES "INFO:symbol\\[([^]]*)\\]")
+      list(APPEND FortranCInterface_SYMBOLS ${CMAKE_MATCH_1})
+    endif()
+  endforeach()
+elseif(NOT _result)
+  set(_result "Failed to load sample executable")
+endif()
+
+set(_case_mysub "LOWER")
+set(_case_my_sub "LOWER")
+set(_case_MYSUB "UPPER")
+set(_case_MY_SUB "UPPER")
+set(_global_regex  "^(_*)(mysub|MYSUB)([_$]*)$")
+set(_global__regex "^(_*)(my_sub|MY_SUB)([_$]*)$")
+set(_module_regex "^([A-Za-z_$]*)(mymodule|MYMODULE)([A-Za-z_$]*)(mysub|MYSUB)([_$]*)$")
+set(_module__regex "^([A-Za-z_$]*)(my_module|MY_MODULE)([A-Za-z_$]*)(my_sub|MY_SUB)([_$]*)$")
+
+# Parse the symbol names.
+foreach(symbol ${FortranCInterface_SYMBOLS})
+  foreach(form "" "_")
+    # Look for global symbols.
+    string(REGEX REPLACE "${_global_${form}regex}"
+                         "\\1;\\2;\\3" pieces "${symbol}")
+    list(LENGTH pieces len)
+    if(len EQUAL 3)
+      set(FortranCInterface_GLOBAL_${form}SYMBOL "${symbol}")
+      list(GET pieces 0 FortranCInterface_GLOBAL_${form}PREFIX)
+      list(GET pieces 1 name)
+      list(GET pieces 2 FortranCInterface_GLOBAL_${form}SUFFIX)
+      set(FortranCInterface_GLOBAL_${form}CASE "${_case_${name}}")
+    endif()
+
+    # Look for module symbols.
+    string(REGEX REPLACE "${_module_${form}regex}"
+                         "\\1;\\2;\\3;\\4;\\5" pieces "${symbol}")
+    list(LENGTH pieces len)
+    if(len EQUAL 5)
+      set(FortranCInterface_MODULE_${form}SYMBOL "${symbol}")
+      list(GET pieces 0 FortranCInterface_MODULE_${form}PREFIX)
+      list(GET pieces 1 module)
+      list(GET pieces 2 FortranCInterface_MODULE_${form}MIDDLE)
+      list(GET pieces 3 name)
+      list(GET pieces 4 FortranCInterface_MODULE_${form}SUFFIX)
+      set(FortranCInterface_MODULE_${form}CASE "${_case_${name}}")
+    endif()
+  endforeach()
+endforeach()
+
+# Construct mangling macro definitions.
+set(_name_LOWER "name")
+set(_name_UPPER "NAME")
+foreach(form "" "_")
+  if(FortranCInterface_GLOBAL_${form}SYMBOL)
+    if(FortranCInterface_GLOBAL_${form}PREFIX)
+      set(_prefix "${FortranCInterface_GLOBAL_${form}PREFIX}##")
+    else()
+      set(_prefix "")
+    endif()
+    if(FortranCInterface_GLOBAL_${form}SUFFIX)
+      set(_suffix "##${FortranCInterface_GLOBAL_${form}SUFFIX}")
+    else()
+      set(_suffix "")
+    endif()
+    set(_name "${_name_${FortranCInterface_GLOBAL_${form}CASE}}")
+    set(FortranCInterface_GLOBAL${form}_MACRO
+      "(name,NAME) ${_prefix}${_name}${_suffix}")
+  endif()
+  if(FortranCInterface_MODULE_${form}SYMBOL)
+    if(FortranCInterface_MODULE_${form}PREFIX)
+      set(_prefix "${FortranCInterface_MODULE_${form}PREFIX}##")
+    else()
+      set(_prefix "")
+    endif()
+    if(FortranCInterface_MODULE_${form}SUFFIX)
+      set(_suffix "##${FortranCInterface_MODULE_${form}SUFFIX}")
+    else()
+      set(_suffix "")
+    endif()
+    set(_name "${_name_${FortranCInterface_MODULE_${form}CASE}}")
+    set(_middle "##${FortranCInterface_MODULE_${form}MIDDLE}##")
+    set(FortranCInterface_MODULE${form}_MACRO
+      "(mod_name,name, mod_NAME,NAME) ${_prefix}mod_${_name}${_middle}${_name}${_suffix}")
+  endif()
+endforeach()
+
+# Summarize what is available.
+foreach(scope GLOBAL MODULE)
+  if(FortranCInterface_${scope}_SYMBOL AND
+      FortranCInterface_${scope}__SYMBOL)
+    set(FortranCInterface_${scope}_FOUND 1)
+  else()
+    set(FortranCInterface_${scope}_FOUND 0)
+  endif()
+endforeach()
+
+# Record the detection results.
+configure_file(${FortranCInterface_SOURCE_DIR}/Output.cmake.in
+               ${FortranCInterface_BINARY_DIR}/Output.cmake @ONLY)
+
+# Report the results.
+if(FortranCInterface_GLOBAL_FOUND)
+  if(FortranCInterface_MODULE_FOUND)
+    set(_result "Found GLOBAL and MODULE mangling")
+  else()
+    set(_result "Found GLOBAL but not MODULE mangling")
+  endif()
+  set(_result_type CHECK_PASS)
+elseif(NOT _result)
+  set(_result "Failed to recognize symbols")
+  set(_result_type CHECK_FAIL)
+endif()
+message(${_result_type} "${_result}")

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/FortranCInterface/call_sub.f

@@ -0,0 +1,4 @@
+        subroutine call_sub
+          call mysub()
+          call my_sub()
+        end

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Android/Determine-Compiler-NDK.cmake

@@ -0,0 +1,276 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# In Android NDK r19 and above there is a single clang toolchain.
+if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
+  if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION AND NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION STREQUAL "clang")
+    message(FATAL_ERROR
+      "Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value '${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}' "
+      "is not supported by this NDK.  It must be 'clang' or not set at all."
+      )
+  endif()
+  message(STATUS "Android: Selected unified Clang toolchain")
+  set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "clang")
+  set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/clang${_ANDROID_HOST_EXT}")
+  set(_ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${CMAKE_ANDROID_ARCH_TRIPLE}")
+  set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "")
+  set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "")
+  set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/${CMAKE_ANDROID_ARCH_TRIPLE}-")
+  set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
+  set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/clang++${_ANDROID_HOST_EXT}")
+  set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${CMAKE_ANDROID_ARCH_TRIPLE}")
+  set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "")
+  set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "")
+  set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED}/bin/${CMAKE_ANDROID_ARCH_TRIPLE}-")
+  set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
+  set(_CMAKE_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_ARCH_TRIPLE}-")
+  return()
+endif()
+
+# In Android NDK releases there is build system toolchain selection logic in
+# these files:
+#
+# * <ndk>/build/core/init.mk
+# * <ndk>/build/core/setup-toolchain.mk
+# * <ndk>/[build/core/]toolchains/<toolchain>/{config.mk,setup.mk}
+#
+# We parse information out of the ``config.mk`` and ``setup.mk`` files below.
+#
+# There is also a "toolchains" directory with the prebuilt toolchains themselves:
+#
+# * <triple-or-arch>-<gcc-version>/prebuilt/<host>/bin/<triple>-gcc(.exe)?
+#   The gcc compiler to be invoked.
+#
+# * llvm*/prebuilt/<host>/bin/clang
+#   The clang compiler to be invoked with flags:
+#     -target <triple>
+#     -gcc-toolchain <ndk>/toolchains/<triple-or-arch>-<gcc-version>
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
+
+# Glob available toolchains in the NDK, restricted by any version request.
+if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION STREQUAL "clang")
+  set(_ANDROID_TOOL_PATTERNS "*-clang" "*-clang[0-9].[0-9]")
+elseif(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
+  if(NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION MATCHES "^(clang)?[0-9]\\.[0-9]$")
+    message(FATAL_ERROR
+      "Android: The CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION value '${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}' "
+      "is not one of the allowed forms:\n"
+      "  <major>.<minor>       = GCC of specified version\n"
+      "  clang<major>.<minor>  = Clang of specified version\n"
+      "  clang                 = Clang of most recent available version\n"
+      )
+  endif()
+  set(_ANDROID_TOOL_PATTERNS "*-${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}")
+else()
+  # If we can find any gcc toolchains then use one by default.
+  # Otherwise we look for clang toolchains (e.g. NDK r18+).
+  file(GLOB _ANDROID_CONFIG_MKS_FOR_GCC
+    "${CMAKE_ANDROID_NDK}/build/core/toolchains/*-[0-9].[0-9]/config.mk"
+    "${CMAKE_ANDROID_NDK}/toolchains/*-[0-9].[0-9]/config.mk"
+    )
+  if(_ANDROID_CONFIG_MKS_FOR_GCC)
+    set(_ANDROID_TOOL_PATTERNS "*-[0-9].[0-9]")
+  else()
+    set(_ANDROID_TOOL_PATTERNS "*-clang")
+  endif()
+  unset(_ANDROID_CONFIG_MKS_FOR_GCC)
+endif()
+set(_ANDROID_CONFIG_MK_PATTERNS)
+foreach(base "build/core/toolchains" "toolchains")
+  foreach(pattern IN LISTS _ANDROID_TOOL_PATTERNS)
+    list(APPEND _ANDROID_CONFIG_MK_PATTERNS
+      "${CMAKE_ANDROID_NDK}/${base}/${pattern}/config.mk"
+      )
+  endforeach()
+endforeach()
+unset(_ANDROID_TOOL_PATTERNS)
+file(GLOB _ANDROID_CONFIG_MKS ${_ANDROID_CONFIG_MK_PATTERNS})
+unset(_ANDROID_CONFIG_MK_PATTERNS)
+
+# Find the newest toolchain version matching the ABI.
+set(_ANDROID_TOOL_NAME "")
+set(_ANDROID_TOOL_VERS 0)
+set(_ANDROID_TOOL_VERS_NDK "")
+set(_ANDROID_TOOL_SETUP_MK "")
+foreach(config_mk IN LISTS _ANDROID_CONFIG_MKS)
+  # Check that the toolchain matches the ABI.
+  file(STRINGS "${config_mk}" _ANDROID_TOOL_ABIS REGEX "^TOOLCHAIN_ABIS :=.* ${CMAKE_ANDROID_ARCH_ABI}( |$)")
+  if(NOT _ANDROID_TOOL_ABIS)
+    continue()
+  endif()
+  unset(_ANDROID_TOOL_ABIS)
+
+  # Check the version.
+  if("${config_mk}" MATCHES [[/([^/]+-((clang)?([0-9]\.[0-9]|)))/config.mk$]])
+    set(_ANDROID_CUR_NAME "${CMAKE_MATCH_1}")
+    set(_ANDROID_CUR_VERS "${CMAKE_MATCH_4}")
+    set(_ANDROID_CUR_VERS_NDK "${CMAKE_MATCH_2}")
+    if(_ANDROID_TOOL_VERS STREQUAL "")
+      # already the latest possible
+    elseif(_ANDROID_CUR_VERS STREQUAL "" OR _ANDROID_CUR_VERS VERSION_GREATER _ANDROID_TOOL_VERS)
+      set(_ANDROID_TOOL_NAME "${_ANDROID_CUR_NAME}")
+      set(_ANDROID_TOOL_VERS "${_ANDROID_CUR_VERS}")
+      set(_ANDROID_TOOL_VERS_NDK "${_ANDROID_CUR_VERS_NDK}")
+      string(REPLACE "/config.mk" "/setup.mk" _ANDROID_TOOL_SETUP_MK "${config_mk}")
+    endif()
+    unset(_ANDROID_CUR_TOOL)
+    unset(_ANDROID_CUR_VERS)
+    unset(_ANDROID_CUR_VERS_NDK)
+  endif()
+endforeach()
+
+# Verify that we have a suitable toolchain.
+if(NOT _ANDROID_TOOL_NAME)
+  if(_ANDROID_CONFIG_MKS)
+    string(REPLACE ";" "\n  " _ANDROID_TOOLS_MSG "after considering:;${_ANDROID_CONFIG_MKS}")
+  else()
+    set(_ANDROID_TOOLS_MSG "")
+  endif()
+  if(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
+    string(CONCAT _ANDROID_TOOLS_MSG
+      "of the version specified by CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION:\n"
+      "  ${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}\n"
+      "${_ANDROID_TOOLS_MSG}")
+  endif()
+  message(FATAL_ERROR
+    "Android: No toolchain for ABI '${CMAKE_ANDROID_ARCH_ABI}' found in the NDK:\n"
+    "  ${CMAKE_ANDROID_NDK}\n"
+    "${_ANDROID_TOOLS_MSG}"
+    )
+endif()
+unset(_ANDROID_CONFIG_MKS)
+
+# For clang toolchains we still need to find a gcc toolchain.
+if(_ANDROID_TOOL_NAME MATCHES "-clang")
+  set(_ANDROID_TOOL_CLANG_NAME "${_ANDROID_TOOL_NAME}")
+  set(_ANDROID_TOOL_CLANG_VERS "${_ANDROID_TOOL_VERS}")
+  set(_ANDROID_TOOL_NAME "")
+  set(_ANDROID_TOOL_VERS "")
+else()
+  set(_ANDROID_TOOL_CLANG_NAME "")
+  set(_ANDROID_TOOL_CLANG_VERS "")
+endif()
+
+# Parse the toolchain setup.mk file to extract information we need.
+# Their content is not standardized across toolchains or NDK versions,
+# so we match known cases.  Note that the parsing is stateful across
+# lines because we need to substitute for some Make variable references.
+if(CMAKE_ANDROID_NDK_TOOLCHAIN_DEBUG)
+  message(STATUS "loading: ${_ANDROID_TOOL_SETUP_MK}")
+endif()
+file(STRINGS "${_ANDROID_TOOL_SETUP_MK}" _ANDROID_TOOL_SETUP REGEX "^(LLVM|TOOLCHAIN)_[A-Z_]+ +:= +.*$")
+unset(_ANDROID_TOOL_SETUP_MK)
+set(_ANDROID_TOOL_PREFIX "")
+set(_ANDROID_TOOL_NAME_ONLY "")
+set(_ANDROID_TOOL_LLVM_NAME "llvm")
+set(_ANDROID_TOOL_LLVM_VERS "")
+foreach(line IN LISTS _ANDROID_TOOL_SETUP)
+  if(CMAKE_ANDROID_NDK_TOOLCHAIN_DEBUG)
+    message(STATUS "setup.mk: ${line}")
+  endif()
+
+  if(line MATCHES [[^TOOLCHAIN_PREFIX +:= +.*/bin/([^$/ ]*) *$]])
+    # We just matched the toolchain prefix with no Make variable references.
+    set(_ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
+  elseif(_ANDROID_TOOL_CLANG_NAME)
+    # For clang toolchains we need to find more information.
+    if(line MATCHES [[^TOOLCHAIN_VERSION +:= +([0-9.]+) *$]])
+      # We just matched the gcc toolchain version number.  Save it for later.
+      set(_ANDROID_TOOL_VERS "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^TOOLCHAIN_NAME +:= +(.*\$\(TOOLCHAIN_VERSION\)) *$]])
+      # We just matched the gcc toolchain name with a version number placeholder, so substitute it.
+      # The gcc toolchain version number will have already been extracted from a TOOLCHAIN_VERSION line.
+      string(REPLACE "$(TOOLCHAIN_VERSION)" "${_ANDROID_TOOL_VERS}" _ANDROID_TOOL_NAME "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^TOOLCHAIN_NAME +:= +([^$/ ]+) *$]])
+      # We just matched the gcc toolchain name without version number.  Save it for later.
+      set(_ANDROID_TOOL_NAME_ONLY "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^TOOLCHAIN_PREFIX +:= +.*/bin/(\$\(TOOLCHAIN_NAME\)-) *$]])
+      # We just matched the toolchain prefix with a name placeholder, so substitute it.
+      # The gcc toolchain name will have already been extracted without version number from a TOOLCHAIN_NAME line.
+      string(REPLACE "$(TOOLCHAIN_NAME)" "${_ANDROID_TOOL_NAME_ONLY}" _ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^LLVM_VERSION +:= +([0-9.]+)$]])
+      # We just matched the llvm prebuilt binary toolchain version number.  Save it for later.
+      set(_ANDROID_TOOL_LLVM_VERS "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^LLVM_NAME +:= +(llvm-\$\(LLVM_VERSION\)) *$]])
+      # We just matched the llvm prebuilt binary toolchain directory name with a version number placeholder,
+      # so substitute it. The llvm prebuilt binary toolchain version number will have already been extracted
+      # from a LLVM_VERSION line.
+      string(REPLACE "$(LLVM_VERSION)" "${_ANDROID_TOOL_LLVM_VERS}" _ANDROID_TOOL_LLVM_NAME "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^LLVM_TOOLCHAIN_PREBUILT_ROOT +:= +\$\(call get-toolchain-root.*,([^$ ]+)\) *$]])
+      # We just matched the llvm prebuilt binary toolchain directory name.
+      set(_ANDROID_TOOL_LLVM_NAME "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^TOOLCHAIN_ROOT +:= +\$\(call get-toolchain-root.*,(\$\(TOOLCHAIN_NAME\)-[0-9.]+)\) *$]])
+      # We just matched a placeholder for the name followed by a version number.
+      # The gcc toolchain name will have already been extracted without version number from a TOOLCHAIN_NAME line.
+      # Substitute for the placeholder to get the full gcc toolchain name.
+      string(REPLACE "$(TOOLCHAIN_NAME)" "${_ANDROID_TOOL_NAME_ONLY}" _ANDROID_TOOL_NAME "${CMAKE_MATCH_1}")
+    elseif(line MATCHES [[^TOOLCHAIN_ROOT +:= +\$\(call get-toolchain-root.*,([^$ ]+)\) *$]])
+      # We just matched the full gcc toolchain name without placeholder.
+      set(_ANDROID_TOOL_NAME "${CMAKE_MATCH_1}")
+    endif()
+  endif()
+endforeach()
+unset(_ANDROID_TOOL_NAME_ONLY)
+unset(_ANDROID_TOOL_LLVM_VERS)
+unset(_ANDROID_TOOL_SETUP)
+
+# Fall back to parsing the version and prefix from the tool name.
+if(NOT _ANDROID_TOOL_VERS AND "${_ANDROID_TOOL_NAME}" MATCHES "-([0-9.]+)$")
+  set(_ANDROID_TOOL_VERS "${CMAKE_MATCH_1}")
+endif()
+if(NOT _ANDROID_TOOL_PREFIX AND "${_ANDROID_TOOL_NAME}" MATCHES "^(.*-)[0-9.]+$")
+  set(_ANDROID_TOOL_PREFIX "${CMAKE_MATCH_1}")
+endif()
+
+# Help CMakeFindBinUtils locate things.
+set(_CMAKE_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_PREFIX}")
+
+set(_ANDROID_TOOL_NDK_TOOLCHAIN_VERSION "${_ANDROID_TOOL_VERS_NDK}")
+
+# _ANDROID_TOOL_PREFIX should now match `gcc -dumpmachine`.
+string(REGEX REPLACE "-$" "" _ANDROID_TOOL_C_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_PREFIX}")
+
+set(_ANDROID_TOOL_C_TOOLCHAIN_VERSION "${_ANDROID_TOOL_VERS}")
+set(_ANDROID_TOOL_C_TOOLCHAIN_PREFIX "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/${_ANDROID_TOOL_PREFIX}")
+set(_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX "${_ANDROID_HOST_EXT}")
+
+set(_ANDROID_TOOL_CXX_TOOLCHAIN_MACHINE "${_ANDROID_TOOL_C_TOOLCHAIN_MACHINE}")
+set(_ANDROID_TOOL_CXX_TOOLCHAIN_VERSION "${_ANDROID_TOOL_C_TOOLCHAIN_VERSION}")
+set(_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX "${_ANDROID_TOOL_C_TOOLCHAIN_PREFIX}")
+set(_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX "${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}")
+
+if(_ANDROID_TOOL_CLANG_NAME)
+  message(STATUS "Android: Selected Clang toolchain '${_ANDROID_TOOL_CLANG_NAME}' with GCC toolchain '${_ANDROID_TOOL_NAME}'")
+  set(_ANDROID_TOOL_C_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/clang${_ANDROID_HOST_EXT}")
+  set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN ${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG})
+  set(_ANDROID_TOOL_CXX_COMPILER "${CMAKE_ANDROID_NDK}/toolchains/${_ANDROID_TOOL_LLVM_NAME}/prebuilt/${CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG}/bin/clang++${_ANDROID_HOST_EXT}")
+  set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN}")
+else()
+  message(STATUS "Android: Selected GCC toolchain '${_ANDROID_TOOL_NAME}'")
+  set(_ANDROID_TOOL_C_COMPILER "${_ANDROID_TOOL_C_TOOLCHAIN_PREFIX}gcc${_ANDROID_TOOL_C_TOOLCHAIN_SUFFIX}")
+  set(_ANDROID_TOOL_C_COMPILER_EXTERNAL_TOOLCHAIN "")
+  set(_ANDROID_TOOL_CXX_COMPILER "${_ANDROID_TOOL_CXX_TOOLCHAIN_PREFIX}g++${_ANDROID_TOOL_CXX_TOOLCHAIN_SUFFIX}")
+  set(_ANDROID_TOOL_CXX_COMPILER_EXTERNAL_TOOLCHAIN "")
+endif()
+
+if(CMAKE_ANDROID_NDK_TOOLCHAIN_DEBUG)
+  message(STATUS "_ANDROID_TOOL_NAME=${_ANDROID_TOOL_NAME}")
+  message(STATUS "_ANDROID_TOOL_VERS=${_ANDROID_TOOL_VERS}")
+  message(STATUS "_ANDROID_TOOL_VERS_NDK=${_ANDROID_TOOL_VERS_NDK}")
+  message(STATUS "_ANDROID_TOOL_PREFIX=${_ANDROID_TOOL_PREFIX}")
+  message(STATUS "_ANDROID_TOOL_CLANG_NAME=${_ANDROID_TOOL_CLANG_NAME}")
+  message(STATUS "_ANDROID_TOOL_CLANG_VERS=${_ANDROID_TOOL_CLANG_VERS}")
+  message(STATUS "_ANDROID_TOOL_LLVM_NAME=${_ANDROID_TOOL_LLVM_NAME}")
+endif()
+
+unset(_ANDROID_TOOL_NAME)
+unset(_ANDROID_TOOL_VERS)
+unset(_ANDROID_TOOL_VERS_NDK)
+unset(_ANDROID_TOOL_PREFIX)
+unset(_ANDROID_TOOL_CLANG_NAME)
+unset(_ANDROID_TOOL_CLANG_VERS)
+unset(_ANDROID_TOOL_LLVM_NAME)
+
+cmake_policy(POP)

wemm/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Android/VCXProjInspect.vcxproj.in

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|@vcx_platform@">
+      <Configuration>Debug</Configuration>
+      <Platform>@vcx_platform@</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{14D44772-ECF7-47BD-9E29-BC62FAF940A5}</ProjectGuid>
+    <RootNamespace>VCXProjInspect</RootNamespace>
+    <Keyword>Android</Keyword>
+    <ApplicationType>Android</ApplicationType>
+    <ApplicationTypeRevision>@vcx_revision@</ApplicationTypeRevision>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|@vcx_platform@'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <AndroidAPILevel>android-21</AndroidAPILevel>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|@vcx_platform@'">false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|@vcx_platform@'">
+    <PostBuildEvent>
+      <Command>%40echo CMAKE_ANDROID_NDK=$(VS_NdkRoot)</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>