Add files using upload-large-folder tool

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/galoisgroups.py

@@ -0,0 +1,623 @@
+"""
+Compute Galois groups of polynomials.
+
+We use algorithms from [1], with some modifications to use lookup tables for
+resolvents.
+
+References
+==========
+
+.. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+
+"""
+
+from collections import defaultdict
+import random
+
+from sympy.core.symbol import Dummy, symbols
+from sympy.ntheory.primetest import is_square
+from sympy.polys.domains import ZZ
+from sympy.polys.densebasic import dup_random
+from sympy.polys.densetools import dup_eval
+from sympy.polys.euclidtools import dup_discriminant
+from sympy.polys.factortools import dup_factor_list, dup_irreducible_p
+from sympy.polys.numberfields.galois_resolvents import (
+    GaloisGroupException, get_resolvent_by_lookup, define_resolvents,
+    Resolvent,
+)
+from sympy.polys.numberfields.utilities import coeff_search
+from sympy.polys.polytools import (Poly, poly_from_expr,
+                                   PolificationFailed, ComputationFailed)
+from sympy.polys.sqfreetools import dup_sqf_p
+from sympy.utilities import public
+
+
+class MaxTriesException(GaloisGroupException):
+    ...
+
+
+def tschirnhausen_transformation(T, max_coeff=10, max_tries=30, history=None,
+                                 fixed_order=True):
+    r"""
+    Given a univariate, monic, irreducible polynomial over the integers, find
+    another such polynomial defining the same number field.
+
+    Explanation
+    ===========
+
+    See Alg 6.3.4 of [1].
+
+    Parameters
+    ==========
+
+    T : Poly
+        The given polynomial
+    max_coeff : int
+        When choosing a transformation as part of the process,
+        keep the coeffs between plus and minus this.
+    max_tries : int
+        Consider at most this many transformations.
+    history : set, None, optional (default=None)
+        Pass a set of ``Poly.rep``'s in order to prevent any of these
+        polynomials from being returned as the polynomial ``U`` i.e. the
+        transformation of the given polynomial *T*. The given poly *T* will
+        automatically be added to this set, before we try to find a new one.
+    fixed_order : bool, default True
+        If ``True``, work through candidate transformations A(x) in a fixed
+        order, from small coeffs to large, resulting in deterministic behavior.
+        If ``False``, the A(x) are chosen randomly, while still working our way
+        up from small coefficients to larger ones.
+
+    Returns
+    =======
+
+    Pair ``(A, U)``
+
+        ``A`` and ``U`` are ``Poly``, ``A`` is the
+        transformation, and ``U`` is the transformed polynomial that defines
+        the same number field as *T*. The polynomial ``A`` maps the roots of
+        *T* to the roots of ``U``.
+
+    Raises
+    ======
+
+    MaxTriesException
+        if could not find a polynomial before exceeding *max_tries*.
+
+    """
+    X = Dummy('X')
+    n = T.degree()
+    if history is None:
+        history = set()
+    history.add(T.rep)
+
+    if fixed_order:
+        coeff_generators = {}
+        deg_coeff_sum = 3
+        current_degree = 2
+
+    def get_coeff_generator(degree):
+        gen = coeff_generators.get(degree, coeff_search(degree, 1))
+        coeff_generators[degree] = gen
+        return gen
+
+    for i in range(max_tries):
+
+        # We never use linear A(x), since applying a fixed linear transformation
+        # to all roots will only multiply the discriminant of T by a square
+        # integer. This will change nothing important. In particular, if disc(T)
+        # was zero before, it will still be zero now, and typically we apply
+        # the transformation in hopes of replacing T by a squarefree poly.
+
+        if fixed_order:
+            # If d is degree and c max coeff, we move through the dc-space
+            # along lines of constant sum. First d + c = 3 with (d, c) = (2, 1).
+            # Then d + c = 4 with (d, c) = (3, 1), (2, 2). Then d + c = 5 with
+            # (d, c) = (4, 1), (3, 2), (2, 3), and so forth. For a given (d, c)
+            # we go though all sets of coeffs where max = c, before moving on.
+            gen = get_coeff_generator(current_degree)
+            coeffs = next(gen)
+            m = max(abs(c) for c in coeffs)
+            if current_degree + m > deg_coeff_sum:
+                if current_degree == 2:
+                    deg_coeff_sum += 1
+                    current_degree = deg_coeff_sum - 1
+                else:
+                    current_degree -= 1
+                gen = get_coeff_generator(current_degree)
+                coeffs = next(gen)
+            a = [ZZ(1)] + [ZZ(c) for c in coeffs]
+
+        else:
+            # We use a progressive coeff bound, up to the max specified, since it
+            # is preferable to succeed with smaller coeffs.
+            # Give each coeff bound five tries, before incrementing.
+            C = min(i//5 + 1, max_coeff)
+            d = random.randint(2, n - 1)
+            a = dup_random(d, -C, C, ZZ)
+
+        A = Poly(a, T.gen)
+        U = Poly(T.resultant(X - A), X)
+        if U.rep not in history and dup_sqf_p(U.rep.to_list(), ZZ):
+            return A, U
+    raise MaxTriesException
+
+
+def has_square_disc(T):
+    """Convenience to check if a Poly or dup has square discriminant. """
+    d = T.discriminant() if isinstance(T, Poly) else dup_discriminant(T, ZZ)
+    return is_square(d)
+
+
+def _galois_group_degree_3(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 3.
+
+    Explanation
+    ===========
+
+    Uses Prop 6.3.5 of [1].
+
+    """
+    from sympy.combinatorics.galois import S3TransitiveSubgroups
+    return ((S3TransitiveSubgroups.A3, True) if has_square_disc(T)
+            else (S3TransitiveSubgroups.S3, False))
+
+
+def _galois_group_degree_4_root_approx(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 4.
+
+    Explanation
+    ===========
+
+    Follows Alg 6.3.7 of [1], using a pure root approximation approach.
+
+    """
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.combinatorics.galois import S4TransitiveSubgroups
+
+    X = symbols('X0 X1 X2 X3')
+    # We start by considering the resolvent for the form
+    #   F = X0*X2 + X1*X3
+    # and the group G = S4. In this case, the stabilizer H is D4 = < (0123), (02) >,
+    # and a set of representatives of G/H is {I, (01), (03)}
+    F1 = X[0]*X[2] + X[1]*X[3]
+    s1 = [
+        Permutation(3),
+        Permutation(3)(0, 1),
+        Permutation(3)(0, 3)
+    ]
+    R1 = Resolvent(F1, X, s1)
+
+    # In the second half of the algorithm (if we reach it), we use another
+    # form and set of coset representatives. However, we may need to permute
+    # them first, so cannot form their resolvent now.
+    F2_pre = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[0]**2
+    s2_pre = [
+        Permutation(3),
+        Permutation(3)(0, 2)
+    ]
+
+    history = set()
+    for i in range(max_tries):
+        if i > 0:
+            # If we're retrying, need a new polynomial T.
+            _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                                history=history,
+                                                fixed_order=not randomize)
+
+        R_dup, _, i0 = R1.eval_for_poly(T, find_integer_root=True)
+        # If R is not squarefree, must retry.
+        if not dup_sqf_p(R_dup, ZZ):
+            continue
+
+        # By Prop 6.3.1 of [1], Gal(T) is contained in A4 iff disc(T) is square.
+        sq_disc = has_square_disc(T)
+
+        if i0 is None:
+            # By Thm 6.3.3 of [1], Gal(T) is not conjugate to any subgroup of the
+            # stabilizer H = D4 that we chose. This means Gal(T) is either A4 or S4.
+            return ((S4TransitiveSubgroups.A4, True) if sq_disc
+                    else (S4TransitiveSubgroups.S4, False))
+
+        # Gal(T) is conjugate to a subgroup of H = D4, so it is either V, C4
+        # or D4 itself.
+
+        if sq_disc:
+            # Neither C4 nor D4 is contained in A4, so Gal(T) must be V.
+            return (S4TransitiveSubgroups.V, True)
+
+        # Gal(T) can only be D4 or C4.
+        # We will now use our second resolvent, with G being that conjugate of D4 that
+        # Gal(T) is contained in. To determine the right conjugate, we will need
+        # the permutation corresponding to the integer root we found.
+        sigma = s1[i0]
+        # Applying sigma means permuting the args of F, and
+        # conjugating the set of coset representatives.
+        F2 = F2_pre.subs(zip(X, sigma(X)), simultaneous=True)
+        s2 = [sigma*tau*sigma for tau in s2_pre]
+        R2 = Resolvent(F2, X, s2)
+        R_dup, _, _ = R2.eval_for_poly(T)
+        d = dup_discriminant(R_dup, ZZ)
+        # If d is zero (R has a repeated root), must retry.
+        if d == 0:
+            continue
+        if is_square(d):
+            return (S4TransitiveSubgroups.C4, False)
+        else:
+            return (S4TransitiveSubgroups.D4, False)
+
+    raise MaxTriesException
+
+
+def _galois_group_degree_4_lookup(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 4.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.6 of [1], but uses resolvent coeff lookup.
+
+    """
+    from sympy.combinatorics.galois import S4TransitiveSubgroups
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 0)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    # Compute list L of degrees of irreducible factors of R, in increasing order:
+    fl = dup_factor_list(R_dup, ZZ)
+    L = sorted(sum([
+        [len(r) - 1] * e for r, e in fl[1]
+    ], []))
+
+    if L == [6]:
+        return ((S4TransitiveSubgroups.A4, True) if has_square_disc(T)
+            else (S4TransitiveSubgroups.S4, False))
+
+    if L == [1, 1, 4]:
+        return (S4TransitiveSubgroups.C4, False)
+
+    if L == [2, 2, 2]:
+        return (S4TransitiveSubgroups.V, True)
+
+    assert L == [2, 4]
+    return (S4TransitiveSubgroups.D4, False)
+
+
+def _galois_group_degree_5_hybrid(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 5.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.9 of [1], but uses a hybrid approach, combining resolvent
+    coeff lookup, with root approximation.
+
+    """
+    from sympy.combinatorics.galois import S5TransitiveSubgroups
+    from sympy.combinatorics.permutations import Permutation
+
+    X5 = symbols("X0,X1,X2,X3,X4")
+    res = define_resolvents()
+    F51, _, s51 = res[(5, 1)]
+    F51 = F51.as_expr(*X5)
+    R51 = Resolvent(F51, X5, s51)
+
+    history = set()
+    reached_second_stage = False
+    for i in range(max_tries):
+        if i > 0:
+            _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                                history=history,
+                                                fixed_order=not randomize)
+        R51_dup = get_resolvent_by_lookup(T, 1)
+        if not dup_sqf_p(R51_dup, ZZ):
+            continue
+
+        # First stage
+        # If we have not yet reached the second stage, then the group still
+        # might be S5, A5, or M20, so must test for that.
+        if not reached_second_stage:
+            sq_disc = has_square_disc(T)
+
+            if dup_irreducible_p(R51_dup, ZZ):
+                return ((S5TransitiveSubgroups.A5, True) if sq_disc
+                        else (S5TransitiveSubgroups.S5, False))
+
+            if not sq_disc:
+                return (S5TransitiveSubgroups.M20, False)
+
+        # Second stage
+        reached_second_stage = True
+        # R51 must have an integer root for T.
+        # To choose our second resolvent, we need to know which conjugate of
+        # F51 is a root.
+        rounded_roots = R51.round_roots_to_integers_for_poly(T)
+        # These are integers, and candidates to be roots of R51.
+        # We find the first one that actually is a root.
+        for permutation_index, candidate_root in rounded_roots.items():
+            if not dup_eval(R51_dup, candidate_root, ZZ):
+                break
+
+        X = X5
+        F2_pre = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[4]**2 + X[4]*X[0]**2
+        s2_pre = [
+            Permutation(4),
+            Permutation(4)(0, 1)(2, 4)
+        ]
+
+        i0 = permutation_index
+        sigma = s51[i0]
+        F2 = F2_pre.subs(zip(X, sigma(X)), simultaneous=True)
+        s2 = [sigma*tau*sigma for tau in s2_pre]
+        R2 = Resolvent(F2, X, s2)
+        R_dup, _, _ = R2.eval_for_poly(T)
+        d = dup_discriminant(R_dup, ZZ)
+
+        if d == 0:
+            continue
+        if is_square(d):
+            return (S5TransitiveSubgroups.C5, True)
+        else:
+            return (S5TransitiveSubgroups.D5, True)
+
+    raise MaxTriesException
+
+
+def _galois_group_degree_5_lookup_ext_factor(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 5.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.9 of [1], but uses resolvent coeff lookup, plus
+    factorization over an algebraic extension.
+
+    """
+    from sympy.combinatorics.galois import S5TransitiveSubgroups
+
+    _T = T
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 1)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    sq_disc = has_square_disc(T)
+
+    if dup_irreducible_p(R_dup, ZZ):
+        return ((S5TransitiveSubgroups.A5, True) if sq_disc
+                else (S5TransitiveSubgroups.S5, False))
+
+    if not sq_disc:
+        return (S5TransitiveSubgroups.M20, False)
+
+    # If we get this far, Gal(T) can only be D5 or C5.
+    # But for Gal(T) to have order 5, T must already split completely in
+    # the extension field obtained by adjoining a single one of its roots.
+    fl = Poly(_T, domain=ZZ.alg_field_from_poly(_T)).factor_list()[1]
+    if len(fl) == 5:
+        return (S5TransitiveSubgroups.C5, True)
+    else:
+        return (S5TransitiveSubgroups.D5, True)
+
+
+def _galois_group_degree_6_lookup(T, max_tries=30, randomize=False):
+    r"""
+    Compute the Galois group of a polynomial of degree 6.
+
+    Explanation
+    ===========
+
+    Based on Alg 6.3.10 of [1], but uses resolvent coeff lookup.
+
+    """
+    from sympy.combinatorics.galois import S6TransitiveSubgroups
+
+    # First resolvent:
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 1)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    fl = dup_factor_list(R_dup, ZZ)
+
+    # Group the factors by degree.
+    factors_by_deg = defaultdict(list)
+    for r, _ in fl[1]:
+        factors_by_deg[len(r) - 1].append(r)
+
+    L = sorted(sum([
+        [d] * len(ff) for d, ff in factors_by_deg.items()
+    ], []))
+
+    T_has_sq_disc = has_square_disc(T)
+
+    if L == [1, 2, 3]:
+        f1 = factors_by_deg[3][0]
+        return ((S6TransitiveSubgroups.C6, False) if has_square_disc(f1)
+                else (S6TransitiveSubgroups.D6, False))
+
+    elif L == [3, 3]:
+        f1, f2 = factors_by_deg[3]
+        any_square = has_square_disc(f1) or has_square_disc(f2)
+        return ((S6TransitiveSubgroups.G18, False) if any_square
+                else (S6TransitiveSubgroups.G36m, False))
+
+    elif L == [2, 4]:
+        if T_has_sq_disc:
+            return (S6TransitiveSubgroups.S4p, True)
+        else:
+            f1 = factors_by_deg[4][0]
+            return ((S6TransitiveSubgroups.A4xC2, False) if has_square_disc(f1)
+                    else (S6TransitiveSubgroups.S4xC2, False))
+
+    elif L == [1, 1, 4]:
+        return ((S6TransitiveSubgroups.A4, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.S4m, False))
+
+    elif L == [1, 5]:
+        return ((S6TransitiveSubgroups.PSL2F5, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.PGL2F5, False))
+
+    elif L == [1, 1, 1, 3]:
+        return (S6TransitiveSubgroups.S3, False)
+
+    assert L == [6]
+
+    # Second resolvent:
+
+    history = set()
+    for i in range(max_tries):
+        R_dup = get_resolvent_by_lookup(T, 2)
+        if dup_sqf_p(R_dup, ZZ):
+            break
+        _, T = tschirnhausen_transformation(T, max_tries=max_tries,
+                                            history=history,
+                                            fixed_order=not randomize)
+    else:
+        raise MaxTriesException
+
+    T_has_sq_disc = has_square_disc(T)
+
+    if dup_irreducible_p(R_dup, ZZ):
+        return ((S6TransitiveSubgroups.A6, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.S6, False))
+    else:
+        return ((S6TransitiveSubgroups.G36p, True) if T_has_sq_disc
+                else (S6TransitiveSubgroups.G72, False))
+
+
+@public
+def galois_group(f, *gens, by_name=False, max_tries=30, randomize=False, **args):
+    r"""
+    Compute the Galois group for polynomials *f* up to degree 6.
+
+    Examples
+    ========
+
+    >>> from sympy import galois_group
+    >>> from sympy.abc import x
+    >>> f = x**4 + 1
+    >>> G, alt = galois_group(f)
+    >>> print(G)
+    PermutationGroup([
+    (0 1)(2 3),
+    (0 2)(1 3)])
+
+    The group is returned along with a boolean, indicating whether it is
+    contained in the alternating group $A_n$, where $n$ is the degree of *T*.
+    Along with other group properties, this can help determine which group it
+    is:
+
+    >>> alt
+    True
+    >>> G.order()
+    4
+
+    Alternatively, the group can be returned by name:
+
+    >>> G_name, _ = galois_group(f, by_name=True)
+    >>> print(G_name)
+    S4TransitiveSubgroups.V
+
+    The group itself can then be obtained by calling the name's
+    ``get_perm_group()`` method:
+
+    >>> G_name.get_perm_group()
+    PermutationGroup([
+    (0 1)(2 3),
+    (0 2)(1 3)])
+
+    Group names are values of the enum classes
+    :py:class:`sympy.combinatorics.galois.S1TransitiveSubgroups`,
+    :py:class:`sympy.combinatorics.galois.S2TransitiveSubgroups`,
+    etc.
+
+    Parameters
+    ==========
+
+    f : Expr
+        Irreducible polynomial over :ref:`ZZ` or :ref:`QQ`, whose Galois group
+        is to be determined.
+    gens : optional list of symbols
+        For converting *f* to Poly, and will be passed on to the
+        :py:func:`~.poly_from_expr` function.
+    by_name : bool, default False
+        If ``True``, the Galois group will be returned by name.
+        Otherwise it will be returned as a :py:class:`~.PermutationGroup`.
+    max_tries : int, default 30
+        Make at most this many attempts in those steps that involve
+        generating Tschirnhausen transformations.
+    randomize : bool, default False
+        If ``True``, then use random coefficients when generating Tschirnhausen
+        transformations. Otherwise try transformations in a fixed order. Both
+        approaches start with small coefficients and degrees and work upward.
+    args : optional
+        For converting *f* to Poly, and will be passed on to the
+        :py:func:`~.poly_from_expr` function.
+
+    Returns
+    =======
+
+    Pair ``(G, alt)``
+        The first element ``G`` indicates the Galois group. It is an instance
+        of one of the :py:class:`sympy.combinatorics.galois.S1TransitiveSubgroups`
+        :py:class:`sympy.combinatorics.galois.S2TransitiveSubgroups`, etc. enum
+        classes if *by_name* was ``True``, and a :py:class:`~.PermutationGroup`
+        if ``False``.
+
+        The second element is a boolean, saying whether the group is contained
+        in the alternating group $A_n$ ($n$ the degree of *T*).
+
+    Raises
+    ======
+
+    ValueError
+        if *f* is of an unsupported degree.
+
+    MaxTriesException
+        if could not complete before exceeding *max_tries* in those steps
+        that involve generating Tschirnhausen transformations.
+
+    See Also
+    ========
+
+    .Poly.galois_group
+
+    """
+    gens = gens or []
+    args = args or {}
+
+    try:
+        F, opt = poly_from_expr(f, *gens, **args)
+    except PolificationFailed as exc:
+        raise ComputationFailed('galois_group', 1, exc)
+
+    return F.galois_group(by_name=by_name, max_tries=max_tries,
+                          randomize=randomize)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/minpoly.py

@@ -0,0 +1,882 @@
+"""Minimal polynomials for algebraic numbers."""
+
+from functools import reduce
+
+from sympy.core.add import Add
+from sympy.core.exprtools import Factors
+from sympy.core.function import expand_mul, expand_multinomial, _mexpand
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi, _illegal)
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.core.traversal import preorder_traversal
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt, cbrt
+from sympy.functions.elementary.trigonometric import cos, sin, tan
+from sympy.ntheory.factor_ import divisors
+from sympy.utilities.iterables import subsets
+
+from sympy.polys.domains import ZZ, QQ, FractionField
+from sympy.polys.orthopolys import dup_chebyshevt
+from sympy.polys.polyerrors import (
+    NotAlgebraic,
+    GeneratorsError,
+)
+from sympy.polys.polytools import (
+    Poly, PurePoly, invert, factor_list, groebner, resultant,
+    degree, poly_from_expr, parallel_poly_from_expr, lcm
+)
+from sympy.polys.polyutils import dict_from_expr, expr_from_dict
+from sympy.polys.ring_series import rs_compose_add
+from sympy.polys.rings import ring
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.utilities import (
+    numbered_symbols, public, sift
+)
+
+
+def _choose_factor(factors, x, v, dom=QQ, prec=200, bound=5):
+    """
+    Return a factor having root ``v``
+    It is assumed that one of the factors has root ``v``.
+    """
+
+    if isinstance(factors[0], tuple):
+        factors = [f[0] for f in factors]
+    if len(factors) == 1:
+        return factors[0]
+
+    prec1 = 10
+    points = {}
+    symbols = dom.symbols if hasattr(dom, 'symbols') else []
+    while prec1 <= prec:
+        # when dealing with non-Rational numbers we usually evaluate
+        # with `subs` argument but we only need a ballpark evaluation
+        fe = [f.as_expr().xreplace({x:v}) for f in factors]
+        if v.is_number:
+            fe = [f.n(prec) for f in fe]
+
+        # assign integers [0, n) to symbols (if any)
+        for n in subsets(range(bound), k=len(symbols), repetition=True):
+            for s, i in zip(symbols, n):
+                points[s] = i
+
+            # evaluate the expression at these points
+            candidates = [(abs(f.subs(points).n(prec1)), i)
+                for i,f in enumerate(fe)]
+
+            # if we get invalid numbers (e.g. from division by zero)
+            # we try again
+            if any(i in _illegal for i, _ in candidates):
+                continue
+
+            # find the smallest two -- if they differ significantly
+            # then we assume we have found the factor that becomes
+            # 0 when v is substituted into it
+            can = sorted(candidates)
+            (a, ix), (b, _) = can[:2]
+            if b > a * 10**6:  # XXX what to use?
+                return factors[ix]
+
+        prec1 *= 2
+
+    raise NotImplementedError("multiple candidates for the minimal polynomial of %s" % v)
+
+
+def _is_sum_surds(p):
+    return all(f.is_Rational or f.is_Pow and
+        f.base.is_Rational and (2*f.exp).is_Integer and f.is_extended_real
+        for t in Add.make_args(p) for f in Mul.make_args(t))
+
+
+def _separate_sq(p):
+    """
+    helper function for ``_minimal_polynomial_sq``
+
+    It selects a rational ``g`` such that the polynomial ``p``
+    consists of a sum of terms whose surds squared have gcd equal to ``g``
+    and a sum of terms with surds squared prime with ``g``;
+    then it takes the field norm to eliminate ``sqrt(g)``
+
+    See simplify.simplify.split_surds and polytools.sqf_norm.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.abc import x
+    >>> from sympy.polys.numberfields.minpoly import _separate_sq
+    >>> p= -x + sqrt(2) + sqrt(3) + sqrt(7)
+    >>> p = _separate_sq(p); p
+    -x**2 + 2*sqrt(3)*x + 2*sqrt(7)*x - 2*sqrt(21) - 8
+    >>> p = _separate_sq(p); p
+    -x**4 + 4*sqrt(7)*x**3 - 32*x**2 + 8*sqrt(7)*x + 20
+    >>> p = _separate_sq(p); p
+    -x**8 + 48*x**6 - 536*x**4 + 1728*x**2 - 400
+
+    """
+    def is_sqrt(expr):
+        return expr.is_Pow and expr.exp is S.Half
+    # p = c1*sqrt(q1) + ... + cn*sqrt(qn) -> a = [(c1, q1), .., (cn, qn)]
+    a = []
+    for y in p.args:
+        if not y.is_Mul:
+            if is_sqrt(y):
+                a.append((S.One, y**2))
+            elif y.is_Atom:
+                a.append((y, S.One))
+            elif y.is_Pow and y.exp.is_integer:
+                a.append((y, S.One))
+            else:
+                raise NotImplementedError
+        else:
+            T, F = sift(y.args, is_sqrt, binary=True)
+            a.append((Mul(*F), Mul(*T)**2))
+    a.sort(key=lambda z: z[1])
+    if a[-1][1] is S.One:
+        # there are no surds
+        return p
+    surds = [z for y, z in a]
+    for i in range(len(surds)):
+        if surds[i] != 1:
+            break
+    from sympy.simplify.radsimp import _split_gcd
+    g, b1, b2 = _split_gcd(*surds[i:])
+    a1 = []
+    a2 = []
+    for y, z in a:
+        if z in b1:
+            a1.append(y*z**S.Half)
+        else:
+            a2.append(y*z**S.Half)
+    p1 = Add(*a1)
+    p2 = Add(*a2)
+    p = _mexpand(p1**2) - _mexpand(p2**2)
+    return p
+
+def _minimal_polynomial_sq(p, n, x):
+    """
+    Returns the minimal polynomial for the ``nth-root`` of a sum of surds
+    or ``None`` if it fails.
+
+    Parameters
+    ==========
+
+    p : sum of surds
+    n : positive integer
+    x : variable of the returned polynomial
+
+    Examples
+    ========
+
+    >>> from sympy.polys.numberfields.minpoly import _minimal_polynomial_sq
+    >>> from sympy import sqrt
+    >>> from sympy.abc import x
+    >>> q = 1 + sqrt(2) + sqrt(3)
+    >>> _minimal_polynomial_sq(q, 3, x)
+    x**12 - 4*x**9 - 4*x**6 + 16*x**3 - 8
+
+    """
+    p = sympify(p)
+    n = sympify(n)
+    if not n.is_Integer or not n > 0 or not _is_sum_surds(p):
+        return None
+    pn = p**Rational(1, n)
+    # eliminate the square roots
+    p -= x
+    while 1:
+        p1 = _separate_sq(p)
+        if p1 is p:
+            p = p1.subs({x:x**n})
+            break
+        else:
+            p = p1
+
+    # _separate_sq eliminates field extensions in a minimal way, so that
+    # if n = 1 then `p = constant*(minimal_polynomial(p))`
+    # if n > 1 it contains the minimal polynomial as a factor.
+    if n == 1:
+        p1 = Poly(p)
+        if p.coeff(x**p1.degree(x)) < 0:
+            p = -p
+        p = p.primitive()[1]
+        return p
+    # by construction `p` has root `pn`
+    # the minimal polynomial is the factor vanishing in x = pn
+    factors = factor_list(p)[1]
+
+    result = _choose_factor(factors, x, pn)
+    return result
+
+def _minpoly_op_algebraic_element(op, ex1, ex2, x, dom, mp1=None, mp2=None):
+    """
+    return the minimal polynomial for ``op(ex1, ex2)``
+
+    Parameters
+    ==========
+
+    op : operation ``Add`` or ``Mul``
+    ex1, ex2 : expressions for the algebraic elements
+    x : indeterminate of the polynomials
+    dom: ground domain
+    mp1, mp2 : minimal polynomials for ``ex1`` and ``ex2`` or None
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, Add, Mul, QQ
+    >>> from sympy.polys.numberfields.minpoly import _minpoly_op_algebraic_element
+    >>> from sympy.abc import x, y
+    >>> p1 = sqrt(sqrt(2) + 1)
+    >>> p2 = sqrt(sqrt(2) - 1)
+    >>> _minpoly_op_algebraic_element(Mul, p1, p2, x, QQ)
+    x - 1
+    >>> q1 = sqrt(y)
+    >>> q2 = 1 / y
+    >>> _minpoly_op_algebraic_element(Add, q1, q2, x, QQ.frac_field(y))
+    x**2*y**2 - 2*x*y - y**3 + 1
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Resultant
+    .. [2] I.M. Isaacs, Proc. Amer. Math. Soc. 25 (1970), 638
+           "Degrees of sums in a separable field extension".
+
+    """
+    y = Dummy(str(x))
+    if mp1 is None:
+        mp1 = _minpoly_compose(ex1, x, dom)
+    if mp2 is None:
+        mp2 = _minpoly_compose(ex2, y, dom)
+    else:
+        mp2 = mp2.subs({x: y})
+
+    if op is Add:
+        # mp1a = mp1.subs({x: x - y})
+        if dom == QQ:
+            R, X = ring('X', QQ)
+            p1 = R(dict_from_expr(mp1)[0])
+            p2 = R(dict_from_expr(mp2)[0])
+        else:
+            (p1, p2), _ = parallel_poly_from_expr((mp1, x - y), x, y)
+            r = p1.compose(p2)
+            mp1a = r.as_expr()
+
+    elif op is Mul:
+        mp1a = _muly(mp1, x, y)
+    else:
+        raise NotImplementedError('option not available')
+
+    if op is Mul or dom != QQ:
+        r = resultant(mp1a, mp2, gens=[y, x])
+    else:
+        r = rs_compose_add(p1, p2)
+        r = expr_from_dict(r.as_expr_dict(), x)
+
+    deg1 = degree(mp1, x)
+    deg2 = degree(mp2, y)
+    if op is Mul and deg1 == 1 or deg2 == 1:
+        # if deg1 = 1, then mp1 = x - a; mp1a = x - y - a;
+        # r = mp2(x - a), so that `r` is irreducible
+        return r
+
+    r = Poly(r, x, domain=dom)
+    _, factors = r.factor_list()
+    res = _choose_factor(factors, x, op(ex1, ex2), dom)
+    return res.as_expr()
+
+
+def _invertx(p, x):
+    """
+    Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
+    """
+    p1 = poly_from_expr(p, x)[0]
+
+    n = degree(p1)
+    a = [c * x**(n - i) for (i,), c in p1.terms()]
+    return Add(*a)
+
+
+def _muly(p, x, y):
+    """
+    Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
+    """
+    p1 = poly_from_expr(p, x)[0]
+
+    n = degree(p1)
+    a = [c * x**i * y**(n - i) for (i,), c in p1.terms()]
+    return Add(*a)
+
+
+def _minpoly_pow(ex, pw, x, dom, mp=None):
+    """
+    Returns ``minpoly(ex**pw, x)``
+
+    Parameters
+    ==========
+
+    ex : algebraic element
+    pw : rational number
+    x : indeterminate of the polynomial
+    dom: ground domain
+    mp : minimal polynomial of ``p``
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, QQ, Rational
+    >>> from sympy.polys.numberfields.minpoly import _minpoly_pow, minpoly
+    >>> from sympy.abc import x, y
+    >>> p = sqrt(1 + sqrt(2))
+    >>> _minpoly_pow(p, 2, x, QQ)
+    x**2 - 2*x - 1
+    >>> minpoly(p**2, x)
+    x**2 - 2*x - 1
+    >>> _minpoly_pow(y, Rational(1, 3), x, QQ.frac_field(y))
+    x**3 - y
+    >>> minpoly(y**Rational(1, 3), x)
+    x**3 - y
+
+    """
+    pw = sympify(pw)
+    if not mp:
+        mp = _minpoly_compose(ex, x, dom)
+    if not pw.is_rational:
+        raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+    if pw < 0:
+        if mp == x:
+            raise ZeroDivisionError('%s is zero' % ex)
+        mp = _invertx(mp, x)
+        if pw == -1:
+            return mp
+        pw = -pw
+        ex = 1/ex
+
+    y = Dummy(str(x))
+    mp = mp.subs({x: y})
+    n, d = pw.as_numer_denom()
+    res = Poly(resultant(mp, x**d - y**n, gens=[y]), x, domain=dom)
+    _, factors = res.factor_list()
+    res = _choose_factor(factors, x, ex**pw, dom)
+    return res.as_expr()
+
+
+def _minpoly_add(x, dom, *a):
+    """
+    returns ``minpoly(Add(*a), dom, x)``
+    """
+    mp = _minpoly_op_algebraic_element(Add, a[0], a[1], x, dom)
+    p = a[0] + a[1]
+    for px in a[2:]:
+        mp = _minpoly_op_algebraic_element(Add, p, px, x, dom, mp1=mp)
+        p = p + px
+    return mp
+
+
+def _minpoly_mul(x, dom, *a):
+    """
+    returns ``minpoly(Mul(*a), dom, x)``
+    """
+    mp = _minpoly_op_algebraic_element(Mul, a[0], a[1], x, dom)
+    p = a[0] * a[1]
+    for px in a[2:]:
+        mp = _minpoly_op_algebraic_element(Mul, p, px, x, dom, mp1=mp)
+        p = p * px
+    return mp
+
+
+def _minpoly_sin(ex, x):
+    """
+    Returns the minimal polynomial of ``sin(ex)``
+    see https://mathworld.wolfram.com/TrigonometryAngles.html
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a is pi:
+        if c.is_rational:
+            n = c.q
+            q = sympify(n)
+            if q.is_prime:
+                # for a = pi*p/q with q odd prime, using chebyshevt
+                # write sin(q*a) = mp(sin(a))*sin(a);
+                # the roots of mp(x) are sin(pi*p/q) for p = 1,..., q - 1
+                a = dup_chebyshevt(n, ZZ)
+                return Add(*[x**(n - i - 1)*a[i] for i in range(n)])
+            if c.p == 1:
+                if q == 9:
+                    return 64*x**6 - 96*x**4 + 36*x**2 - 3
+
+            if n % 2 == 1:
+                # for a = pi*p/q with q odd, use
+                # sin(q*a) = 0 to see that the minimal polynomial must be
+                # a factor of dup_chebyshevt(n, ZZ)
+                a = dup_chebyshevt(n, ZZ)
+                a = [x**(n - i)*a[i] for i in range(n + 1)]
+                r = Add(*a)
+                _, factors = factor_list(r)
+                res = _choose_factor(factors, x, ex)
+                return res
+
+            expr = ((1 - cos(2*c*pi))/2)**S.Half
+            res = _minpoly_compose(expr, x, QQ)
+            return res
+
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_cos(ex, x):
+    """
+    Returns the minimal polynomial of ``cos(ex)``
+    see https://mathworld.wolfram.com/TrigonometryAngles.html
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a is pi:
+        if c.is_rational:
+            if c.p == 1:
+                if c.q == 7:
+                    return 8*x**3 - 4*x**2 - 4*x + 1
+                if c.q == 9:
+                    return 8*x**3 - 6*x - 1
+            elif c.p == 2:
+                q = sympify(c.q)
+                if q.is_prime:
+                    s = _minpoly_sin(ex, x)
+                    return _mexpand(s.subs({x:sqrt((1 - x)/2)}))
+
+            # for a = pi*p/q, cos(q*a) =T_q(cos(a)) = (-1)**p
+            n = int(c.q)
+            a = dup_chebyshevt(n, ZZ)
+            a = [x**(n - i)*a[i] for i in range(n + 1)]
+            r = Add(*a) - (-1)**c.p
+            _, factors = factor_list(r)
+            res = _choose_factor(factors, x, ex)
+            return res
+
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_tan(ex, x):
+    """
+    Returns the minimal polynomial of ``tan(ex)``
+    see https://github.com/sympy/sympy/issues/21430
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a is pi:
+        if c.is_rational:
+            c = c * 2
+            n = int(c.q)
+            a = n if c.p % 2 == 0 else 1
+            terms = []
+            for k in range((c.p+1)%2, n+1, 2):
+                terms.append(a*x**k)
+                a = -(a*(n-k-1)*(n-k)) // ((k+1)*(k+2))
+
+            r = Add(*terms)
+            _, factors = factor_list(r)
+            res = _choose_factor(factors, x, ex)
+            return res
+
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_exp(ex, x):
+    """
+    Returns the minimal polynomial of ``exp(ex)``
+    """
+    c, a = ex.args[0].as_coeff_Mul()
+    if a == I*pi:
+        if c.is_rational:
+            q = sympify(c.q)
+            if c.p == 1 or c.p == -1:
+                if q == 3:
+                    return x**2 - x + 1
+                if q == 4:
+                    return x**4 + 1
+                if q == 6:
+                    return x**4 - x**2 + 1
+                if q == 8:
+                    return x**8 + 1
+                if q == 9:
+                    return x**6 - x**3 + 1
+                if q == 10:
+                    return x**8 - x**6 + x**4 - x**2 + 1
+                if q.is_prime:
+                    s = 0
+                    for i in range(q):
+                        s += (-x)**i
+                    return s
+
+            # x**(2*q) = product(factors)
+            factors = [cyclotomic_poly(i, x) for i in divisors(2*q)]
+            mp = _choose_factor(factors, x, ex)
+            return mp
+        else:
+            raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+    raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+
+
+def _minpoly_rootof(ex, x):
+    """
+    Returns the minimal polynomial of a ``CRootOf`` object.
+    """
+    p = ex.expr
+    p = p.subs({ex.poly.gens[0]:x})
+    _, factors = factor_list(p, x)
+    result = _choose_factor(factors, x, ex)
+    return result
+
+
+def _minpoly_compose(ex, x, dom):
+    """
+    Computes the minimal polynomial of an algebraic element
+    using operations on minimal polynomials
+
+    Examples
+    ========
+
+    >>> from sympy import minimal_polynomial, sqrt, Rational
+    >>> from sympy.abc import x, y
+    >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=True)
+    x**2 - 2*x - 1
+    >>> minimal_polynomial(sqrt(y) + 1/y, x, compose=True)
+    x**2*y**2 - 2*x*y - y**3 + 1
+
+    """
+    if ex.is_Rational:
+        return ex.q*x - ex.p
+    if ex is I:
+        _, factors = factor_list(x**2 + 1, x, domain=dom)
+        return x**2 + 1 if len(factors) == 1 else x - I
+
+    if ex is S.GoldenRatio:
+        _, factors = factor_list(x**2 - x - 1, x, domain=dom)
+        if len(factors) == 1:
+            return x**2 - x - 1
+        else:
+            return _choose_factor(factors, x, (1 + sqrt(5))/2, dom=dom)
+
+    if ex is S.TribonacciConstant:
+        _, factors = factor_list(x**3 - x**2 - x - 1, x, domain=dom)
+        if len(factors) == 1:
+            return x**3 - x**2 - x - 1
+        else:
+            fac = (1 + cbrt(19 - 3*sqrt(33)) + cbrt(19 + 3*sqrt(33))) / 3
+            return _choose_factor(factors, x, fac, dom=dom)
+
+    if hasattr(dom, 'symbols') and ex in dom.symbols:
+        return x - ex
+
+    if dom.is_QQ and _is_sum_surds(ex):
+        # eliminate the square roots
+        v = ex
+        ex -= x
+        while 1:
+            ex1 = _separate_sq(ex)
+            if ex1 is ex:
+                return _choose_factor(factor_list(ex)[1], x, v)
+            else:
+                ex = ex1
+
+    if ex.is_Add:
+        res = _minpoly_add(x, dom, *ex.args)
+    elif ex.is_Mul:
+        f = Factors(ex).factors
+        r = sift(f.items(), lambda itx: itx[0].is_Rational and itx[1].is_Rational)
+        if r[True] and dom == QQ:
+            ex1 = Mul(*[bx**ex for bx, ex in r[False] + r[None]])
+            r1 = dict(r[True])
+            dens = [y.q for y in r1.values()]
+            lcmdens = reduce(lcm, dens, 1)
+            neg1 = S.NegativeOne
+            expn1 = r1.pop(neg1, S.Zero)
+            nums = [base**(y.p*lcmdens // y.q) for base, y in r1.items()]
+            ex2 = Mul(*nums)
+            mp1 = minimal_polynomial(ex1, x)
+            # use the fact that in SymPy canonicalization products of integers
+            # raised to rational powers are organized in relatively prime
+            # bases, and that in ``base**(n/d)`` a perfect power is
+            # simplified with the root
+            # Powers of -1 have to be treated separately to preserve sign.
+            mp2 = ex2.q*x**lcmdens - ex2.p*neg1**(expn1*lcmdens)
+            ex2 = neg1**expn1 * ex2**Rational(1, lcmdens)
+            res = _minpoly_op_algebraic_element(Mul, ex1, ex2, x, dom, mp1=mp1, mp2=mp2)
+        else:
+            res = _minpoly_mul(x, dom, *ex.args)
+    elif ex.is_Pow:
+        res = _minpoly_pow(ex.base, ex.exp, x, dom)
+    elif ex.__class__ is sin:
+        res = _minpoly_sin(ex, x)
+    elif ex.__class__ is cos:
+        res = _minpoly_cos(ex, x)
+    elif ex.__class__ is tan:
+        res = _minpoly_tan(ex, x)
+    elif ex.__class__ is exp:
+        res = _minpoly_exp(ex, x)
+    elif ex.__class__ is CRootOf:
+        res = _minpoly_rootof(ex, x)
+    else:
+        raise NotAlgebraic("%s does not seem to be an algebraic element" % ex)
+    return res
+
+
+@public
+def minimal_polynomial(ex, x=None, compose=True, polys=False, domain=None):
+    """
+    Computes the minimal polynomial of an algebraic element.
+
+    Parameters
+    ==========
+
+    ex : Expr
+        Element or expression whose minimal polynomial is to be calculated.
+
+    x : Symbol, optional
+        Independent variable of the minimal polynomial
+
+    compose : boolean, optional (default=True)
+        Method to use for computing minimal polynomial. If ``compose=True``
+        (default) then ``_minpoly_compose`` is used, if ``compose=False`` then
+        groebner bases are used.
+
+    polys : boolean, optional (default=False)
+        If ``True`` returns a ``Poly`` object else an ``Expr`` object.
+
+    domain : Domain, optional
+        Ground domain
+
+    Notes
+    =====
+
+    By default ``compose=True``, the minimal polynomial of the subexpressions of ``ex``
+    are computed, then the arithmetic operations on them are performed using the resultant
+    and factorization.
+    If ``compose=False``, a bottom-up algorithm is used with ``groebner``.
+    The default algorithm stalls less frequently.
+
+    If no ground domain is given, it will be generated automatically from the expression.
+
+    Examples
+    ========
+
+    >>> from sympy import minimal_polynomial, sqrt, solve, QQ
+    >>> from sympy.abc import x, y
+
+    >>> minimal_polynomial(sqrt(2), x)
+    x**2 - 2
+    >>> minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2)))
+    x - sqrt(2)
+    >>> minimal_polynomial(sqrt(2) + sqrt(3), x)
+    x**4 - 10*x**2 + 1
+    >>> minimal_polynomial(solve(x**3 + x + 3)[0], x)
+    x**3 + x + 3
+    >>> minimal_polynomial(sqrt(y), x)
+    x**2 - y
+
+    """
+
+    ex = sympify(ex)
+    if ex.is_number:
+        # not sure if it's always needed but try it for numbers (issue 8354)
+        ex = _mexpand(ex, recursive=True)
+    for expr in preorder_traversal(ex):
+        if expr.is_AlgebraicNumber:
+            compose = False
+            break
+
+    if x is not None:
+        x, cls = sympify(x), Poly
+    else:
+        x, cls = Dummy('x'), PurePoly
+
+    if not domain:
+        if ex.free_symbols:
+            domain = FractionField(QQ, list(ex.free_symbols))
+        else:
+            domain = QQ
+    if hasattr(domain, 'symbols') and x in domain.symbols:
+        raise GeneratorsError("the variable %s is an element of the ground "
+                              "domain %s" % (x, domain))
+
+    if compose:
+        result = _minpoly_compose(ex, x, domain)
+        result = result.primitive()[1]
+        c = result.coeff(x**degree(result, x))
+        if c.is_negative:
+            result = expand_mul(-result)
+        return cls(result, x, field=True) if polys else result.collect(x)
+
+    if not domain.is_QQ:
+        raise NotImplementedError("groebner method only works for QQ")
+
+    result = _minpoly_groebner(ex, x, cls)
+    return cls(result, x, field=True) if polys else result.collect(x)
+
+
+def _minpoly_groebner(ex, x, cls):
+    """
+    Computes the minimal polynomial of an algebraic number
+    using Groebner bases
+
+    Examples
+    ========
+
+    >>> from sympy import minimal_polynomial, sqrt, Rational
+    >>> from sympy.abc import x
+    >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=False)
+    x**2 - 2*x - 1
+
+    """
+
+    generator = numbered_symbols('a', cls=Dummy)
+    mapping, symbols = {}, {}
+
+    def update_mapping(ex, exp, base=None):
+        a = next(generator)
+        symbols[ex] = a
+
+        if base is not None:
+            mapping[ex] = a**exp + base
+        else:
+            mapping[ex] = exp.as_expr(a)
+
+        return a
+
+    def bottom_up_scan(ex):
+        """
+        Transform a given algebraic expression *ex* into a multivariate
+        polynomial, by introducing fresh variables with defining equations.
+
+        Explanation
+        ===========
+
+        The critical elements of the algebraic expression *ex* are root
+        extractions, instances of :py:class:`~.AlgebraicNumber`, and negative
+        powers.
+
+        When we encounter a root extraction or an :py:class:`~.AlgebraicNumber`
+        we replace this expression with a fresh variable ``a_i``, and record
+        the defining polynomial for ``a_i``. For example, if ``a_0**(1/3)``
+        occurs, we will replace it with ``a_1``, and record the new defining
+        polynomial ``a_1**3 - a_0``.
+
+        When we encounter a negative power we transform it into a positive
+        power by algebraically inverting the base. This means computing the
+        minimal polynomial in ``x`` for the base, inverting ``x`` modulo this
+        poly (which generates a new polynomial) and then substituting the
+        original base expression for ``x`` in this last polynomial.
+
+        We return the transformed expression, and we record the defining
+        equations for new symbols using the ``update_mapping()`` function.
+
+        """
+        if ex.is_Atom:
+            if ex is S.ImaginaryUnit:
+                if ex not in mapping:
+                    return update_mapping(ex, 2, 1)
+                else:
+                    return symbols[ex]
+            elif ex.is_Rational:
+                return ex
+        elif ex.is_Add:
+            return Add(*[ bottom_up_scan(g) for g in ex.args ])
+        elif ex.is_Mul:
+            return Mul(*[ bottom_up_scan(g) for g in ex.args ])
+        elif ex.is_Pow:
+            if ex.exp.is_Rational:
+                if ex.exp < 0:
+                    minpoly_base = _minpoly_groebner(ex.base, x, cls)
+                    inverse = invert(x, minpoly_base).as_expr()
+                    base_inv = inverse.subs(x, ex.base).expand()
+
+                    if ex.exp == -1:
+                        return bottom_up_scan(base_inv)
+                    else:
+                        ex = base_inv**(-ex.exp)
+                if not ex.exp.is_Integer:
+                    base, exp = (
+                        ex.base**ex.exp.p).expand(), Rational(1, ex.exp.q)
+                else:
+                    base, exp = ex.base, ex.exp
+                base = bottom_up_scan(base)
+                expr = base**exp
+
+                if expr not in mapping:
+                    if exp.is_Integer:
+                        return expr.expand()
+                    else:
+                        return update_mapping(expr, 1 / exp, -base)
+                else:
+                    return symbols[expr]
+        elif ex.is_AlgebraicNumber:
+            if ex not in mapping:
+                return update_mapping(ex, ex.minpoly_of_element())
+            else:
+                return symbols[ex]
+
+        raise NotAlgebraic("%s does not seem to be an algebraic number" % ex)
+
+    def simpler_inverse(ex):
+        """
+        Returns True if it is more likely that the minimal polynomial
+        algorithm works better with the inverse
+        """
+        if ex.is_Pow:
+            if (1/ex.exp).is_integer and ex.exp < 0:
+                if ex.base.is_Add:
+                    return True
+        if ex.is_Mul:
+            hit = True
+            for p in ex.args:
+                if p.is_Add:
+                    return False
+                if p.is_Pow:
+                    if p.base.is_Add and p.exp > 0:
+                        return False
+
+            if hit:
+                return True
+        return False
+
+    inverted = False
+    ex = expand_multinomial(ex)
+    if ex.is_AlgebraicNumber:
+        return ex.minpoly_of_element().as_expr(x)
+    elif ex.is_Rational:
+        result = ex.q*x - ex.p
+    else:
+        inverted = simpler_inverse(ex)
+        if inverted:
+            ex = ex**-1
+        res = None
+        if ex.is_Pow and (1/ex.exp).is_Integer:
+            n = 1/ex.exp
+            res = _minimal_polynomial_sq(ex.base, n, x)
+
+        elif _is_sum_surds(ex):
+            res = _minimal_polynomial_sq(ex, S.One, x)
+
+        if res is not None:
+            result = res
+
+        if res is None:
+            bus = bottom_up_scan(ex)
+            F = [x - bus] + list(mapping.values())
+            G = groebner(F, list(symbols.values()) + [x], order='lex')
+
+            _, factors = factor_list(G[-1])
+            # by construction G[-1] has root `ex`
+            result = _choose_factor(factors, x, ex)
+    if inverted:
+        result = _invertx(result, x)
+        if result.coeff(x**degree(result, x)) < 0:
+            result = expand_mul(-result)
+
+    return result
+
+
+@public
+def minpoly(ex, x=None, compose=True, polys=False, domain=None):
+    """This is a synonym for :py:func:`~.minimal_polynomial`."""
+    return minimal_polynomial(ex, x=x, compose=compose, polys=polys, domain=domain)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/modules.py

@@ -0,0 +1,2114 @@
+r"""Modules in number fields.
+
+The classes defined here allow us to work with finitely generated, free
+modules, whose generators are algebraic numbers.
+
+There is an abstract base class called :py:class:`~.Module`, which has two
+concrete subclasses, :py:class:`~.PowerBasis` and :py:class:`~.Submodule`.
+
+Every module is defined by its basis, or set of generators:
+
+* For a :py:class:`~.PowerBasis`, the generators are the first $n$ powers
+  (starting with the zeroth) of an algebraic integer $\theta$ of degree $n$.
+  The :py:class:`~.PowerBasis` is constructed by passing either the minimal
+  polynomial of $\theta$, or an :py:class:`~.AlgebraicField` having $\theta$
+  as its primitive element.
+
+* For a :py:class:`~.Submodule`, the generators are a set of
+  $\mathbb{Q}$-linear combinations of the generators of another module. That
+  other module is then the "parent" of the :py:class:`~.Submodule`. The
+  coefficients of the $\mathbb{Q}$-linear combinations may be given by an
+  integer matrix, and a positive integer denominator. Each column of the matrix
+  defines a generator.
+
+>>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+>>> from sympy.abc import x
+>>> from sympy.polys.matrices import DomainMatrix, DM
+>>> from sympy.polys.numberfields.modules import PowerBasis
+>>> T = Poly(cyclotomic_poly(5, x))
+>>> A = PowerBasis(T)
+>>> print(A)
+PowerBasis(x**4 + x**3 + x**2 + x + 1)
+>>> B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ), denom=3)
+>>> print(B)
+Submodule[[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]]/3
+>>> print(B.parent)
+PowerBasis(x**4 + x**3 + x**2 + x + 1)
+
+Thus, every module is either a :py:class:`~.PowerBasis`,
+or a :py:class:`~.Submodule`, some ancestor of which is a
+:py:class:`~.PowerBasis`. (If ``S`` is a :py:class:`~.Submodule`, then its
+ancestors are ``S.parent``, ``S.parent.parent``, and so on).
+
+The :py:class:`~.ModuleElement` class represents a linear combination of the
+generators of any module. Critically, the coefficients of this linear
+combination are not restricted to be integers, but may be any rational
+numbers. This is necessary so that any and all algebraic integers be
+representable, starting from the power basis in a primitive element $\theta$
+for the number field in question. For example, in a quadratic field
+$\mathbb{Q}(\sqrt{d})$ where $d \equiv 1 \mod{4}$, a denominator of $2$ is
+needed.
+
+A :py:class:`~.ModuleElement` can be constructed from an integer column vector
+and a denominator:
+
+>>> U = Poly(x**2 - 5)
+>>> M = PowerBasis(U)
+>>> e = M(DM([[1], [1]], ZZ), denom=2)
+>>> print(e)
+[1, 1]/2
+>>> print(e.module)
+PowerBasis(x**2 - 5)
+
+The :py:class:`~.PowerBasisElement` class is a subclass of
+:py:class:`~.ModuleElement` that represents elements of a
+:py:class:`~.PowerBasis`, and adds functionality pertinent to elements
+represented directly over powers of the primitive element $\theta$.
+
+
+Arithmetic with module elements
+===============================
+
+While a :py:class:`~.ModuleElement` represents a linear combination over the
+generators of a particular module, recall that every module is either a
+:py:class:`~.PowerBasis` or a descendant (along a chain of
+:py:class:`~.Submodule` objects) thereof, so that in fact every
+:py:class:`~.ModuleElement` represents an algebraic number in some field
+$\mathbb{Q}(\theta)$, where $\theta$ is the defining element of some
+:py:class:`~.PowerBasis`. It thus makes sense to talk about the number field
+to which a given :py:class:`~.ModuleElement` belongs.
+
+This means that any two :py:class:`~.ModuleElement` instances can be added,
+subtracted, multiplied, or divided, provided they belong to the same number
+field. Similarly, since $\mathbb{Q}$ is a subfield of every number field,
+any :py:class:`~.ModuleElement` may be added, multiplied, etc. by any
+rational number.
+
+>>> from sympy import QQ
+>>> from sympy.polys.numberfields.modules import to_col
+>>> T = Poly(cyclotomic_poly(5))
+>>> A = PowerBasis(T)
+>>> C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+>>> e = A(to_col([0, 2, 0, 0]), denom=3)
+>>> f = A(to_col([0, 0, 0, 7]), denom=5)
+>>> g = C(to_col([1, 1, 1, 1]))
+>>> e + f
+[0, 10, 0, 21]/15
+>>> e - f
+[0, 10, 0, -21]/15
+>>> e - g
+[-9, -7, -9, -9]/3
+>>> e + QQ(7, 10)
+[21, 20, 0, 0]/30
+>>> e * f
+[-14, -14, -14, -14]/15
+>>> e ** 2
+[0, 0, 4, 0]/9
+>>> f // g
+[7, 7, 7, 7]/15
+>>> f * QQ(2, 3)
+[0, 0, 0, 14]/15
+
+However, care must be taken with arithmetic operations on
+:py:class:`~.ModuleElement`, because the module $C$ to which the result will
+belong will be the nearest common ancestor (NCA) of the modules $A$, $B$ to
+which the two operands belong, and $C$ may be different from either or both
+of $A$ and $B$.
+
+>>> A = PowerBasis(T)
+>>> B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+>>> C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+>>> print((B(0) * C(0)).module == A)
+True
+
+Before the arithmetic operation is performed, copies of the two operands are
+automatically converted into elements of the NCA (the operands themselves are
+not modified). This upward conversion along an ancestor chain is easy: it just
+requires the successive multiplication by the defining matrix of each
+:py:class:`~.Submodule`.
+
+Conversely, downward conversion, i.e. representing a given
+:py:class:`~.ModuleElement` in a submodule, is also supported -- namely by
+the :py:meth:`~sympy.polys.numberfields.modules.Submodule.represent` method
+-- but is not guaranteed to succeed in general, since the given element may
+not belong to the submodule. The main circumstance in which this issue tends
+to arise is with multiplication, since modules, while closed under addition,
+need not be closed under multiplication.
+
+
+Multiplication
+--------------
+
+Generally speaking, a module need not be closed under multiplication, i.e. need
+not form a ring. However, many of the modules we work with in the context of
+number fields are in fact rings, and our classes do support multiplication.
+
+Specifically, any :py:class:`~.Module` can attempt to compute its own
+multiplication table, but this does not happen unless an attempt is made to
+multiply two :py:class:`~.ModuleElement` instances belonging to it.
+
+>>> A = PowerBasis(T)
+>>> print(A._mult_tab is None)
+True
+>>> a = A(0)*A(1)
+>>> print(A._mult_tab is None)
+False
+
+Every :py:class:`~.PowerBasis` is, by its nature, closed under multiplication,
+so instances of :py:class:`~.PowerBasis` can always successfully compute their
+multiplication table.
+
+When a :py:class:`~.Submodule` attempts to compute its multiplication table,
+it converts each of its own generators into elements of its parent module,
+multiplies them there, in every possible pairing, and then tries to
+represent the results in itself, i.e. as $\mathbb{Z}$-linear combinations
+over its own generators. This will succeed if and only if the submodule is
+in fact closed under multiplication.
+
+
+Module Homomorphisms
+====================
+
+Many important number theoretic algorithms require the calculation of the
+kernel of one or more module homomorphisms. Accordingly we have several
+lightweight classes, :py:class:`~.ModuleHomomorphism`,
+:py:class:`~.ModuleEndomorphism`, :py:class:`~.InnerEndomorphism`, and
+:py:class:`~.EndomorphismRing`, which provide the minimal necessary machinery
+to support this.
+
+"""
+
+from sympy.core.intfunc import igcd, ilcm
+from sympy.core.symbol import Dummy
+from sympy.polys.polyclasses import ANP
+from sympy.polys.polytools import Poly
+from sympy.polys.densetools import dup_clear_denoms
+from sympy.polys.domains.algebraicfield import AlgebraicField
+from sympy.polys.domains.finitefield import FF
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+from sympy.polys.matrices.exceptions import DMBadInputError
+from sympy.polys.matrices.normalforms import hermite_normal_form
+from sympy.polys.polyerrors import CoercionFailed, UnificationFailed
+from sympy.polys.polyutils import IntegerPowerable
+from .exceptions import ClosureFailure, MissingUnityError, StructureError
+from .utilities import AlgIntPowers, is_rat, get_num_denom
+
+
+def to_col(coeffs):
+    r"""Transform a list of integer coefficients into a column vector."""
+    return DomainMatrix([[ZZ(c) for c in coeffs]], (1, len(coeffs)), ZZ).transpose()
+
+
+class Module:
+    """
+    Generic finitely-generated module.
+
+    This is an abstract base class, and should not be instantiated directly.
+    The two concrete subclasses are :py:class:`~.PowerBasis` and
+    :py:class:`~.Submodule`.
+
+    Every :py:class:`~.Submodule` is derived from another module, referenced
+    by its ``parent`` attribute. If ``S`` is a submodule, then we refer to
+    ``S.parent``, ``S.parent.parent``, and so on, as the "ancestors" of
+    ``S``. Thus, every :py:class:`~.Module` is either a
+    :py:class:`~.PowerBasis` or a :py:class:`~.Submodule`, some ancestor of
+    which is a :py:class:`~.PowerBasis`.
+    """
+
+    @property
+    def n(self):
+        """The number of generators of this module."""
+        raise NotImplementedError
+
+    def mult_tab(self):
+        """
+        Get the multiplication table for this module (if closed under mult).
+
+        Explanation
+        ===========
+
+        Computes a dictionary ``M`` of dictionaries of lists, representing the
+        upper triangular half of the multiplication table.
+
+        In other words, if ``0 <= i <= j < self.n``, then ``M[i][j]`` is the
+        list ``c`` of coefficients such that
+        ``g[i] * g[j] == sum(c[k]*g[k], k in range(self.n))``,
+        where ``g`` is the list of generators of this module.
+
+        If ``j < i`` then ``M[i][j]`` is undefined.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> print(A.mult_tab())  # doctest: +SKIP
+        {0: {0: [1, 0, 0, 0], 1: [0, 1, 0, 0], 2: [0, 0, 1, 0],     3: [0, 0, 0, 1]},
+                          1: {1: [0, 0, 1, 0], 2: [0, 0, 0, 1],     3: [-1, -1, -1, -1]},
+                                           2: {2: [-1, -1, -1, -1], 3: [1, 0, 0, 0]},
+                                                                3: {3: [0, 1, 0, 0]}}
+
+        Returns
+        =======
+
+        dict of dict of lists
+
+        Raises
+        ======
+
+        ClosureFailure
+            If the module is not closed under multiplication.
+
+        """
+        raise NotImplementedError
+
+    @property
+    def parent(self):
+        """
+        The parent module, if any, for this module.
+
+        Explanation
+        ===========
+
+        For a :py:class:`~.Submodule` this is its ``parent`` attribute; for a
+        :py:class:`~.PowerBasis` this is ``None``.
+
+        Returns
+        =======
+
+        :py:class:`~.Module`, ``None``
+
+        See Also
+        ========
+
+        Module
+
+        """
+        return None
+
+    def represent(self, elt):
+        r"""
+        Represent a module element as an integer-linear combination over the
+        generators of this module.
+
+        Explanation
+        ===========
+
+        In our system, to "represent" always means to write a
+        :py:class:`~.ModuleElement` as a :ref:`ZZ`-linear combination over the
+        generators of the present :py:class:`~.Module`. Furthermore, the
+        incoming :py:class:`~.ModuleElement` must belong to an ancestor of
+        the present :py:class:`~.Module` (or to the present
+        :py:class:`~.Module` itself).
+
+        The most common application is to represent a
+        :py:class:`~.ModuleElement` in a :py:class:`~.Submodule`. For example,
+        this is involved in computing multiplication tables.
+
+        On the other hand, representing in a :py:class:`~.PowerBasis` is an
+        odd case, and one which tends not to arise in practice, except for
+        example when using a :py:class:`~.ModuleEndomorphism` on a
+        :py:class:`~.PowerBasis`.
+
+        In such a case, (1) the incoming :py:class:`~.ModuleElement` must
+        belong to the :py:class:`~.PowerBasis` itself (since the latter has no
+        proper ancestors) and (2) it is "representable" iff it belongs to
+        $\mathbb{Z}[\theta]$ (although generally a
+        :py:class:`~.PowerBasisElement` may represent any element of
+        $\mathbb{Q}(\theta)$, i.e. any algebraic number).
+
+        Examples
+        ========
+
+        >>> from sympy import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis, to_col
+        >>> from sympy.abc import zeta
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> a = A(to_col([2, 4, 6, 8]))
+
+        The :py:class:`~.ModuleElement` ``a`` has all even coefficients.
+        If we represent ``a`` in the submodule ``B = 2*A``, the coefficients in
+        the column vector will be halved:
+
+        >>> B = A.submodule_from_gens([2*A(i) for i in range(4)])
+        >>> b = B.represent(a)
+        >>> print(b.transpose())  # doctest: +SKIP
+        DomainMatrix([[1, 2, 3, 4]], (1, 4), ZZ)
+
+        However, the element of ``B`` so defined still represents the same
+        algebraic number:
+
+        >>> print(a.poly(zeta).as_expr())
+        8*zeta**3 + 6*zeta**2 + 4*zeta + 2
+        >>> print(B(b).over_power_basis().poly(zeta).as_expr())
+        8*zeta**3 + 6*zeta**2 + 4*zeta + 2
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.ModuleElement`
+            The module element to be represented. Must belong to some ancestor
+            module of this module (including this module itself).
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            This will be a column vector, representing the coefficients of a
+            linear combination of this module's generators, which equals the
+            given element.
+
+        Raises
+        ======
+
+        ClosureFailure
+            If the given element cannot be represented as a :ref:`ZZ`-linear
+            combination over this module.
+
+        See Also
+        ========
+
+        .Submodule.represent
+        .PowerBasis.represent
+
+        """
+        raise NotImplementedError
+
+    def ancestors(self, include_self=False):
+        """
+        Return the list of ancestor modules of this module, from the
+        foundational :py:class:`~.PowerBasis` downward, optionally including
+        ``self``.
+
+        See Also
+        ========
+
+        Module
+
+        """
+        c = self.parent
+        a = [] if c is None else c.ancestors(include_self=True)
+        if include_self:
+            a.append(self)
+        return a
+
+    def power_basis_ancestor(self):
+        """
+        Return the :py:class:`~.PowerBasis` that is an ancestor of this module.
+
+        See Also
+        ========
+
+        Module
+
+        """
+        if isinstance(self, PowerBasis):
+            return self
+        c = self.parent
+        if c is not None:
+            return c.power_basis_ancestor()
+        return None
+
+    def nearest_common_ancestor(self, other):
+        """
+        Locate the nearest common ancestor of this module and another.
+
+        Returns
+        =======
+
+        :py:class:`~.Module`, ``None``
+
+        See Also
+        ========
+
+        Module
+
+        """
+        sA = self.ancestors(include_self=True)
+        oA = other.ancestors(include_self=True)
+        nca = None
+        for sa, oa in zip(sA, oA):
+            if sa == oa:
+                nca = sa
+            else:
+                break
+        return nca
+
+    @property
+    def number_field(self):
+        r"""
+        Return the associated :py:class:`~.AlgebraicField`, if any.
+
+        Explanation
+        ===========
+
+        A :py:class:`~.PowerBasis` can be constructed on a :py:class:`~.Poly`
+        $f$ or on an :py:class:`~.AlgebraicField` $K$. In the latter case, the
+        :py:class:`~.PowerBasis` and all its descendant modules will return $K$
+        as their ``.number_field`` property, while in the former case they will
+        all return ``None``.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicField`, ``None``
+
+        """
+        return self.power_basis_ancestor().number_field
+
+    def is_compat_col(self, col):
+        """Say whether *col* is a suitable column vector for this module."""
+        return isinstance(col, DomainMatrix) and col.shape == (self.n, 1) and col.domain.is_ZZ
+
+    def __call__(self, spec, denom=1):
+        r"""
+        Generate a :py:class:`~.ModuleElement` belonging to this module.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis, to_col
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> e = A(to_col([1, 2, 3, 4]), denom=3)
+        >>> print(e)  # doctest: +SKIP
+        [1, 2, 3, 4]/3
+        >>> f = A(2)
+        >>> print(f)  # doctest: +SKIP
+        [0, 0, 1, 0]
+
+        Parameters
+        ==========
+
+        spec : :py:class:`~.DomainMatrix`, int
+            Specifies the numerators of the coefficients of the
+            :py:class:`~.ModuleElement`. Can be either a column vector over
+            :ref:`ZZ`, whose length must equal the number $n$ of generators of
+            this module, or else an integer ``j``, $0 \leq j < n$, which is a
+            shorthand for column $j$ of $I_n$, the $n \times n$ identity
+            matrix.
+        denom : int, optional (default=1)
+            Denominator for the coefficients of the
+            :py:class:`~.ModuleElement`.
+
+        Returns
+        =======
+
+        :py:class:`~.ModuleElement`
+            The coefficients are the entries of the *spec* vector, divided by
+            *denom*.
+
+        """
+        if isinstance(spec, int) and 0 <= spec < self.n:
+            spec = DomainMatrix.eye(self.n, ZZ)[:, spec].to_dense()
+        if not self.is_compat_col(spec):
+            raise ValueError('Compatible column vector required.')
+        return make_mod_elt(self, spec, denom=denom)
+
+    def starts_with_unity(self):
+        """Say whether the module's first generator equals unity."""
+        raise NotImplementedError
+
+    def basis_elements(self):
+        """
+        Get list of :py:class:`~.ModuleElement` being the generators of this
+        module.
+        """
+        return [self(j) for j in range(self.n)]
+
+    def zero(self):
+        """Return a :py:class:`~.ModuleElement` representing zero."""
+        return self(0) * 0
+
+    def one(self):
+        """
+        Return a :py:class:`~.ModuleElement` representing unity,
+        and belonging to the first ancestor of this module (including
+        itself) that starts with unity.
+        """
+        return self.element_from_rational(1)
+
+    def element_from_rational(self, a):
+        """
+        Return a :py:class:`~.ModuleElement` representing a rational number.
+
+        Explanation
+        ===========
+
+        The returned :py:class:`~.ModuleElement` will belong to the first
+        module on this module's ancestor chain (including this module
+        itself) that starts with unity.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly, QQ
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> a = A.element_from_rational(QQ(2, 3))
+        >>> print(a)  # doctest: +SKIP
+        [2, 0, 0, 0]/3
+
+        Parameters
+        ==========
+
+        a : int, :ref:`ZZ`, :ref:`QQ`
+
+        Returns
+        =======
+
+        :py:class:`~.ModuleElement`
+
+        """
+        raise NotImplementedError
+
+    def submodule_from_gens(self, gens, hnf=True, hnf_modulus=None):
+        """
+        Form the submodule generated by a list of :py:class:`~.ModuleElement`
+        belonging to this module.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> gens = [A(0), 2*A(1), 3*A(2), 4*A(3)//5]
+        >>> B = A.submodule_from_gens(gens)
+        >>> print(B)  # doctest: +SKIP
+        Submodule[[5, 0, 0, 0], [0, 10, 0, 0], [0, 0, 15, 0], [0, 0, 0, 4]]/5
+
+        Parameters
+        ==========
+
+        gens : list of :py:class:`~.ModuleElement` belonging to this module.
+        hnf : boolean, optional (default=True)
+            If True, we will reduce the matrix into Hermite Normal Form before
+            forming the :py:class:`~.Submodule`.
+        hnf_modulus : int, None, optional (default=None)
+            Modulus for use in the HNF reduction algorithm. See
+            :py:func:`~sympy.polys.matrices.normalforms.hermite_normal_form`.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        See Also
+        ========
+
+        submodule_from_matrix
+
+        """
+        if not all(g.module == self for g in gens):
+            raise ValueError('Generators must belong to this module.')
+        n = len(gens)
+        if n == 0:
+            raise ValueError('Need at least one generator.')
+        m = gens[0].n
+        d = gens[0].denom if n == 1 else ilcm(*[g.denom for g in gens])
+        B = DomainMatrix.zeros((m, 0), ZZ).hstack(*[(d // g.denom) * g.col for g in gens])
+        if hnf:
+            B = hermite_normal_form(B, D=hnf_modulus)
+        return self.submodule_from_matrix(B, denom=d)
+
+    def submodule_from_matrix(self, B, denom=1):
+        """
+        Form the submodule generated by the elements of this module indicated
+        by the columns of a matrix, with an optional denominator.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+        >>> from sympy.polys.matrices import DM
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> B = A.submodule_from_matrix(DM([
+        ...     [0, 10, 0, 0],
+        ...     [0,  0, 7, 0],
+        ... ], ZZ).transpose(), denom=15)
+        >>> print(B)  # doctest: +SKIP
+        Submodule[[0, 10, 0, 0], [0, 0, 7, 0]]/15
+
+        Parameters
+        ==========
+
+        B : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            Each column gives the numerators of the coefficients of one
+            generator of the submodule. Thus, the number of rows of *B* must
+            equal the number of generators of the present module.
+        denom : int, optional (default=1)
+            Common denominator for all generators of the submodule.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        Raises
+        ======
+
+        ValueError
+            If the given matrix *B* is not over :ref:`ZZ` or its number of rows
+            does not equal the number of generators of the present module.
+
+        See Also
+        ========
+
+        submodule_from_gens
+
+        """
+        m, n = B.shape
+        if not B.domain.is_ZZ:
+            raise ValueError('Matrix must be over ZZ.')
+        if not m == self.n:
+            raise ValueError('Matrix row count must match base module.')
+        return Submodule(self, B, denom=denom)
+
+    def whole_submodule(self):
+        """
+        Return a submodule equal to this entire module.
+
+        Explanation
+        ===========
+
+        This is useful when you have a :py:class:`~.PowerBasis` and want to
+        turn it into a :py:class:`~.Submodule` (in order to use methods
+        belonging to the latter).
+
+        """
+        B = DomainMatrix.eye(self.n, ZZ)
+        return self.submodule_from_matrix(B)
+
+    def endomorphism_ring(self):
+        """Form the :py:class:`~.EndomorphismRing` for this module."""
+        return EndomorphismRing(self)
+
+
+class PowerBasis(Module):
+    """The module generated by the powers of an algebraic integer."""
+
+    def __init__(self, T):
+        """
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`, :py:class:`~.AlgebraicField`
+            Either (1) the monic, irreducible, univariate polynomial over
+            :ref:`ZZ`, a root of which is the generator of the power basis,
+            or (2) an :py:class:`~.AlgebraicField` whose primitive element
+            is the generator of the power basis.
+
+        """
+        K = None
+        if isinstance(T, AlgebraicField):
+            K, T = T, T.ext.minpoly_of_element()
+        # Sometimes incoming Polys are formally over QQ, although all their
+        # coeffs are integral. We want them to be formally over ZZ.
+        T = T.set_domain(ZZ)
+        self.K = K
+        self.T = T
+        self._n = T.degree()
+        self._mult_tab = None
+
+    @property
+    def number_field(self):
+        return self.K
+
+    def __repr__(self):
+        return f'PowerBasis({self.T.as_expr()})'
+
+    def __eq__(self, other):
+        if isinstance(other, PowerBasis):
+            return self.T == other.T
+        return NotImplemented
+
+    @property
+    def n(self):
+        return self._n
+
+    def mult_tab(self):
+        if self._mult_tab is None:
+            self.compute_mult_tab()
+        return self._mult_tab
+
+    def compute_mult_tab(self):
+        theta_pow = AlgIntPowers(self.T)
+        M = {}
+        n = self.n
+        for u in range(n):
+            M[u] = {}
+            for v in range(u, n):
+                M[u][v] = theta_pow[u + v]
+        self._mult_tab = M
+
+    def represent(self, elt):
+        r"""
+        Represent a module element as an integer-linear combination over the
+        generators of this module.
+
+        See Also
+        ========
+
+        .Module.represent
+        .Submodule.represent
+
+        """
+        if elt.module == self and elt.denom == 1:
+            return elt.column()
+        else:
+            raise ClosureFailure('Element not representable in ZZ[theta].')
+
+    def starts_with_unity(self):
+        return True
+
+    def element_from_rational(self, a):
+        return self(0) * a
+
+    def element_from_poly(self, f):
+        """
+        Produce an element of this module, representing *f* after reduction mod
+        our defining minimal polynomial.
+
+        Parameters
+        ==========
+
+        f : :py:class:`~.Poly` over :ref:`ZZ` in same var as our defining poly.
+
+        Returns
+        =======
+
+        :py:class:`~.PowerBasisElement`
+
+        """
+        n, k = self.n, f.degree()
+        if k >= n:
+            f = f % self.T
+        if f == 0:
+            return self.zero()
+        d, c = dup_clear_denoms(f.rep.to_list(), QQ, convert=True)
+        c = list(reversed(c))
+        ell = len(c)
+        z = [ZZ(0)] * (n - ell)
+        col = to_col(c + z)
+        return self(col, denom=d)
+
+    def _element_from_rep_and_mod(self, rep, mod):
+        """
+        Produce a PowerBasisElement representing a given algebraic number.
+
+        Parameters
+        ==========
+
+        rep : list of coeffs
+            Represents the number as polynomial in the primitive element of the
+            field.
+
+        mod : list of coeffs
+            Represents the minimal polynomial of the primitive element of the
+            field.
+
+        Returns
+        =======
+
+        :py:class:`~.PowerBasisElement`
+
+        """
+        if mod != self.T.rep.to_list():
+            raise UnificationFailed('Element does not appear to be in the same field.')
+        return self.element_from_poly(Poly(rep, self.T.gen))
+
+    def element_from_ANP(self, a):
+        """Convert an ANP into a PowerBasisElement. """
+        return self._element_from_rep_and_mod(a.to_list(), a.mod_to_list())
+
+    def element_from_alg_num(self, a):
+        """Convert an AlgebraicNumber into a PowerBasisElement. """
+        return self._element_from_rep_and_mod(a.rep.to_list(), a.minpoly.rep.to_list())
+
+
+class Submodule(Module, IntegerPowerable):
+    """A submodule of another module."""
+
+    def __init__(self, parent, matrix, denom=1, mult_tab=None):
+        """
+        Parameters
+        ==========
+
+        parent : :py:class:`~.Module`
+            The module from which this one is derived.
+        matrix : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            The matrix whose columns define this submodule's generators as
+            linear combinations over the parent's generators.
+        denom : int, optional (default=1)
+            Denominator for the coefficients given by the matrix.
+        mult_tab : dict, ``None``, optional
+            If already known, the multiplication table for this module may be
+            supplied.
+
+        """
+        self._parent = parent
+        self._matrix = matrix
+        self._denom = denom
+        self._mult_tab = mult_tab
+        self._n = matrix.shape[1]
+        self._QQ_matrix = None
+        self._starts_with_unity = None
+        self._is_sq_maxrank_HNF = None
+
+    def __repr__(self):
+        r = 'Submodule' + repr(self.matrix.transpose().to_Matrix().tolist())
+        if self.denom > 1:
+            r += f'/{self.denom}'
+        return r
+
+    def reduced(self):
+        """
+        Produce a reduced version of this submodule.
+
+        Explanation
+        ===========
+
+        In the reduced version, it is guaranteed that 1 is the only positive
+        integer dividing both the submodule's denominator, and every entry in
+        the submodule's matrix.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        """
+        if self.denom == 1:
+            return self
+        g = igcd(self.denom, *self.coeffs)
+        if g == 1:
+            return self
+        return type(self)(self.parent, (self.matrix / g).convert_to(ZZ), denom=self.denom // g, mult_tab=self._mult_tab)
+
+    def discard_before(self, r):
+        """
+        Produce a new module by discarding all generators before a given
+        index *r*.
+        """
+        W = self.matrix[:, r:]
+        s = self.n - r
+        M = None
+        mt = self._mult_tab
+        if mt is not None:
+            M = {}
+            for u in range(s):
+                M[u] = {}
+                for v in range(u, s):
+                    M[u][v] = mt[r + u][r + v][r:]
+        return Submodule(self.parent, W, denom=self.denom, mult_tab=M)
+
+    @property
+    def n(self):
+        return self._n
+
+    def mult_tab(self):
+        if self._mult_tab is None:
+            self.compute_mult_tab()
+        return self._mult_tab
+
+    def compute_mult_tab(self):
+        gens = self.basis_element_pullbacks()
+        M = {}
+        n = self.n
+        for u in range(n):
+            M[u] = {}
+            for v in range(u, n):
+                M[u][v] = self.represent(gens[u] * gens[v]).flat()
+        self._mult_tab = M
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @property
+    def matrix(self):
+        return self._matrix
+
+    @property
+    def coeffs(self):
+        return self.matrix.flat()
+
+    @property
+    def denom(self):
+        return self._denom
+
+    @property
+    def QQ_matrix(self):
+        """
+        :py:class:`~.DomainMatrix` over :ref:`QQ`, equal to
+        ``self.matrix / self.denom``, and guaranteed to be dense.
+
+        Explanation
+        ===========
+
+        Depending on how it is formed, a :py:class:`~.DomainMatrix` may have
+        an internal representation that is sparse or dense. We guarantee a
+        dense representation here, so that tests for equivalence of submodules
+        always come out as expected.
+
+        Examples
+        ========
+
+        >>> from sympy.polys import Poly, cyclotomic_poly, ZZ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> T = Poly(cyclotomic_poly(5, x))
+        >>> A = PowerBasis(T)
+        >>> B = A.submodule_from_matrix(3*DomainMatrix.eye(4, ZZ), denom=6)
+        >>> C = A.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=2)
+        >>> print(B.QQ_matrix == C.QQ_matrix)
+        True
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix` over :ref:`QQ`
+
+        """
+        if self._QQ_matrix is None:
+            self._QQ_matrix = (self.matrix / self.denom).to_dense()
+        return self._QQ_matrix
+
+    def starts_with_unity(self):
+        if self._starts_with_unity is None:
+            self._starts_with_unity = self(0).equiv(1)
+        return self._starts_with_unity
+
+    def is_sq_maxrank_HNF(self):
+        if self._is_sq_maxrank_HNF is None:
+            self._is_sq_maxrank_HNF = is_sq_maxrank_HNF(self._matrix)
+        return self._is_sq_maxrank_HNF
+
+    def is_power_basis_submodule(self):
+        return isinstance(self.parent, PowerBasis)
+
+    def element_from_rational(self, a):
+        if self.starts_with_unity():
+            return self(0) * a
+        else:
+            return self.parent.element_from_rational(a)
+
+    def basis_element_pullbacks(self):
+        """
+        Return list of this submodule's basis elements as elements of the
+        submodule's parent module.
+        """
+        return [e.to_parent() for e in self.basis_elements()]
+
+    def represent(self, elt):
+        """
+        Represent a module element as an integer-linear combination over the
+        generators of this module.
+
+        See Also
+        ========
+
+        .Module.represent
+        .PowerBasis.represent
+
+        """
+        if elt.module == self:
+            return elt.column()
+        elif elt.module == self.parent:
+            try:
+                # The given element should be a ZZ-linear combination over our
+                # basis vectors; however, due to the presence of denominators,
+                # we need to solve over QQ.
+                A = self.QQ_matrix
+                b = elt.QQ_col
+                x = A._solve(b)[0].transpose()
+                x = x.convert_to(ZZ)
+            except DMBadInputError:
+                raise ClosureFailure('Element outside QQ-span of this basis.')
+            except CoercionFailed:
+                raise ClosureFailure('Element in QQ-span but not ZZ-span of this basis.')
+            return x
+        elif isinstance(self.parent, Submodule):
+            coeffs_in_parent = self.parent.represent(elt)
+            parent_element = self.parent(coeffs_in_parent)
+            return self.represent(parent_element)
+        else:
+            raise ClosureFailure('Element outside ancestor chain of this module.')
+
+    def is_compat_submodule(self, other):
+        return isinstance(other, Submodule) and other.parent == self.parent
+
+    def __eq__(self, other):
+        if self.is_compat_submodule(other):
+            return other.QQ_matrix == self.QQ_matrix
+        return NotImplemented
+
+    def add(self, other, hnf=True, hnf_modulus=None):
+        """
+        Add this :py:class:`~.Submodule` to another.
+
+        Explanation
+        ===========
+
+        This represents the module generated by the union of the two modules'
+        sets of generators.
+
+        Parameters
+        ==========
+
+        other : :py:class:`~.Submodule`
+        hnf : boolean, optional (default=True)
+            If ``True``, reduce the matrix of the combined module to its
+            Hermite Normal Form.
+        hnf_modulus : :ref:`ZZ`, None, optional
+            If a positive integer is provided, use this as modulus in the
+            HNF reduction. See
+            :py:func:`~sympy.polys.matrices.normalforms.hermite_normal_form`.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        """
+        d, e = self.denom, other.denom
+        m = ilcm(d, e)
+        a, b = m // d, m // e
+        B = (a * self.matrix).hstack(b * other.matrix)
+        if hnf:
+            B = hermite_normal_form(B, D=hnf_modulus)
+        return self.parent.submodule_from_matrix(B, denom=m)
+
+    def __add__(self, other):
+        if self.is_compat_submodule(other):
+            return self.add(other)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def mul(self, other, hnf=True, hnf_modulus=None):
+        """
+        Multiply this :py:class:`~.Submodule` by a rational number, a
+        :py:class:`~.ModuleElement`, or another :py:class:`~.Submodule`.
+
+        Explanation
+        ===========
+
+        To multiply by a rational number or :py:class:`~.ModuleElement` means
+        to form the submodule whose generators are the products of this
+        quantity with all the generators of the present submodule.
+
+        To multiply by another :py:class:`~.Submodule` means to form the
+        submodule whose generators are all the products of one generator from
+        the one submodule, and one generator from the other.
+
+        Parameters
+        ==========
+
+        other : int, :ref:`ZZ`, :ref:`QQ`, :py:class:`~.ModuleElement`, :py:class:`~.Submodule`
+        hnf : boolean, optional (default=True)
+            If ``True``, reduce the matrix of the product module to its
+            Hermite Normal Form.
+        hnf_modulus : :ref:`ZZ`, None, optional
+            If a positive integer is provided, use this as modulus in the
+            HNF reduction. See
+            :py:func:`~sympy.polys.matrices.normalforms.hermite_normal_form`.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+
+        """
+        if is_rat(other):
+            a, b = get_num_denom(other)
+            if a == b == 1:
+                return self
+            else:
+                return Submodule(self.parent,
+                             self.matrix * a, denom=self.denom * b,
+                             mult_tab=None).reduced()
+        elif isinstance(other, ModuleElement) and other.module == self.parent:
+            # The submodule is multiplied by an element of the parent module.
+            # We presume this means we want a new submodule of the parent module.
+            gens = [other * e for e in self.basis_element_pullbacks()]
+            return self.parent.submodule_from_gens(gens, hnf=hnf, hnf_modulus=hnf_modulus)
+        elif self.is_compat_submodule(other):
+            # This case usually means you're multiplying ideals, and want another
+            # ideal, i.e. another submodule of the same parent module.
+            alphas, betas = self.basis_element_pullbacks(), other.basis_element_pullbacks()
+            gens = [a * b for a in alphas for b in betas]
+            return self.parent.submodule_from_gens(gens, hnf=hnf, hnf_modulus=hnf_modulus)
+        return NotImplemented
+
+    def __mul__(self, other):
+        return self.mul(other)
+
+    __rmul__ = __mul__
+
+    def _first_power(self):
+        return self
+
+    def reduce_element(self, elt):
+        r"""
+        If this submodule $B$ has defining matrix $W$ in square, maximal-rank
+        Hermite normal form, then, given an element $x$ of the parent module
+        $A$, we produce an element $y \in A$ such that $x - y \in B$, and the
+        $i$th coordinate of $y$ satisfies $0 \leq y_i < w_{i,i}$. This
+        representative $y$ is unique, in the sense that every element of
+        the coset $x + B$ reduces to it under this procedure.
+
+        Explanation
+        ===========
+
+        In the special case where $A$ is a power basis for a number field $K$,
+        and $B$ is a submodule representing an ideal $I$, this operation
+        represents one of a few important ways of reducing an element of $K$
+        modulo $I$ to obtain a "small" representative. See [Cohen00]_ Section
+        1.4.3.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, Poly, symbols
+        >>> t = symbols('t')
+        >>> k = QQ.alg_field_from_poly(Poly(t**3 + t**2 - 2*t + 8))
+        >>> Zk = k.maximal_order()
+        >>> A = Zk.parent
+        >>> B = (A(2) - 3*A(0))*Zk
+        >>> B.reduce_element(A(2))
+        [3, 0, 0]
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.ModuleElement`
+            An element of this submodule's parent module.
+
+        Returns
+        =======
+
+        elt : :py:class:`~.ModuleElement`
+            An element of this submodule's parent module.
+
+        Raises
+        ======
+
+        NotImplementedError
+            If the given :py:class:`~.ModuleElement` does not belong to this
+            submodule's parent module.
+        StructureError
+            If this submodule's defining matrix is not in square, maximal-rank
+            Hermite normal form.
+
+        References
+        ==========
+
+        .. [Cohen00] Cohen, H. *Advanced Topics in Computational Number
+           Theory.*
+
+        """
+        if not elt.module == self.parent:
+            raise NotImplementedError
+        if not self.is_sq_maxrank_HNF():
+            msg = "Reduction not implemented unless matrix square max-rank HNF"
+            raise StructureError(msg)
+        B = self.basis_element_pullbacks()
+        a = elt
+        for i in range(self.n - 1, -1, -1):
+            b = B[i]
+            q = a.coeffs[i]*b.denom // (b.coeffs[i]*a.denom)
+            a -= q*b
+        return a
+
+
+def is_sq_maxrank_HNF(dm):
+    r"""
+    Say whether a :py:class:`~.DomainMatrix` is in that special case of Hermite
+    Normal Form, in which the matrix is also square and of maximal rank.
+
+    Explanation
+    ===========
+
+    We commonly work with :py:class:`~.Submodule` instances whose matrix is in
+    this form, and it can be useful to be able to check that this condition is
+    satisfied.
+
+    For example this is the case with the :py:class:`~.Submodule` ``ZK``
+    returned by :py:func:`~sympy.polys.numberfields.basis.round_two`, which
+    represents the maximal order in a number field, and with ideals formed
+    therefrom, such as ``2 * ZK``.
+
+    """
+    if dm.domain.is_ZZ and dm.is_square and dm.is_upper:
+        n = dm.shape[0]
+        for i in range(n):
+            d = dm[i, i].element
+            if d <= 0:
+                return False
+            for j in range(i + 1, n):
+                if not (0 <= dm[i, j].element < d):
+                    return False
+        return True
+    return False
+
+
+def make_mod_elt(module, col, denom=1):
+    r"""
+    Factory function which builds a :py:class:`~.ModuleElement`, but ensures
+    that it is a :py:class:`~.PowerBasisElement` if the module is a
+    :py:class:`~.PowerBasis`.
+    """
+    if isinstance(module, PowerBasis):
+        return PowerBasisElement(module, col, denom=denom)
+    else:
+        return ModuleElement(module, col, denom=denom)
+
+
+class ModuleElement(IntegerPowerable):
+    r"""
+    Represents an element of a :py:class:`~.Module`.
+
+    NOTE: Should not be constructed directly. Use the
+    :py:meth:`~.Module.__call__` method or the :py:func:`make_mod_elt()`
+    factory function instead.
+    """
+
+    def __init__(self, module, col, denom=1):
+        """
+        Parameters
+        ==========
+
+        module : :py:class:`~.Module`
+            The module to which this element belongs.
+        col : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+            Column vector giving the numerators of the coefficients of this
+            element.
+        denom : int, optional (default=1)
+            Denominator for the coefficients of this element.
+
+        """
+        self.module = module
+        self.col = col
+        self.denom = denom
+        self._QQ_col = None
+
+    def __repr__(self):
+        r = str([int(c) for c in self.col.flat()])
+        if self.denom > 1:
+            r += f'/{self.denom}'
+        return r
+
+    def reduced(self):
+        """
+        Produce a reduced version of this ModuleElement, i.e. one in which the
+        gcd of the denominator together with all numerator coefficients is 1.
+        """
+        if self.denom == 1:
+            return self
+        g = igcd(self.denom, *self.coeffs)
+        if g == 1:
+            return self
+        return type(self)(self.module,
+                            (self.col / g).convert_to(ZZ),
+                            denom=self.denom // g)
+
+    def reduced_mod_p(self, p):
+        """
+        Produce a version of this :py:class:`~.ModuleElement` in which all
+        numerator coefficients have been reduced mod *p*.
+        """
+        return make_mod_elt(self.module,
+                            self.col.convert_to(FF(p)).convert_to(ZZ),
+                            denom=self.denom)
+
+    @classmethod
+    def from_int_list(cls, module, coeffs, denom=1):
+        """
+        Make a :py:class:`~.ModuleElement` from a list of ints (instead of a
+        column vector).
+        """
+        col = to_col(coeffs)
+        return cls(module, col, denom=denom)
+
+    @property
+    def n(self):
+        """The length of this element's column."""
+        return self.module.n
+
+    def __len__(self):
+        return self.n
+
+    def column(self, domain=None):
+        """
+        Get a copy of this element's column, optionally converting to a domain.
+        """
+        if domain is None:
+            return self.col.copy()
+        else:
+            return self.col.convert_to(domain)
+
+    @property
+    def coeffs(self):
+        return self.col.flat()
+
+    @property
+    def QQ_col(self):
+        """
+        :py:class:`~.DomainMatrix` over :ref:`QQ`, equal to
+        ``self.col / self.denom``, and guaranteed to be dense.
+
+        See Also
+        ========
+
+        .Submodule.QQ_matrix
+
+        """
+        if self._QQ_col is None:
+            self._QQ_col = (self.col / self.denom).to_dense()
+        return self._QQ_col
+
+    def to_parent(self):
+        """
+        Transform into a :py:class:`~.ModuleElement` belonging to the parent of
+        this element's module.
+        """
+        if not isinstance(self.module, Submodule):
+            raise ValueError('Not an element of a Submodule.')
+        return make_mod_elt(
+            self.module.parent, self.module.matrix * self.col,
+            denom=self.module.denom * self.denom)
+
+    def to_ancestor(self, anc):
+        """
+        Transform into a :py:class:`~.ModuleElement` belonging to a given
+        ancestor of this element's module.
+
+        Parameters
+        ==========
+
+        anc : :py:class:`~.Module`
+
+        """
+        if anc == self.module:
+            return self
+        else:
+            return self.to_parent().to_ancestor(anc)
+
+    def over_power_basis(self):
+        """
+        Transform into a :py:class:`~.PowerBasisElement` over our
+        :py:class:`~.PowerBasis` ancestor.
+        """
+        e = self
+        while not isinstance(e.module, PowerBasis):
+            e = e.to_parent()
+        return e
+
+    def is_compat(self, other):
+        """
+        Test whether other is another :py:class:`~.ModuleElement` with same
+        module.
+        """
+        return isinstance(other, ModuleElement) and other.module == self.module
+
+    def unify(self, other):
+        """
+        Try to make a compatible pair of :py:class:`~.ModuleElement`, one
+        equivalent to this one, and one equivalent to the other.
+
+        Explanation
+        ===========
+
+        We search for the nearest common ancestor module for the pair of
+        elements, and represent each one there.
+
+        Returns
+        =======
+
+        Pair ``(e1, e2)``
+            Each ``ei`` is a :py:class:`~.ModuleElement`, they belong to the
+            same :py:class:`~.Module`, ``e1`` is equivalent to ``self``, and
+            ``e2`` is equivalent to ``other``.
+
+        Raises
+        ======
+
+        UnificationFailed
+            If ``self`` and ``other`` have no common ancestor module.
+
+        """
+        if self.module == other.module:
+            return self, other
+        nca = self.module.nearest_common_ancestor(other.module)
+        if nca is not None:
+            return self.to_ancestor(nca), other.to_ancestor(nca)
+        raise UnificationFailed(f"Cannot unify {self} with {other}")
+
+    def __eq__(self, other):
+        if self.is_compat(other):
+            return self.QQ_col == other.QQ_col
+        return NotImplemented
+
+    def equiv(self, other):
+        """
+        A :py:class:`~.ModuleElement` may test as equivalent to a rational
+        number or another :py:class:`~.ModuleElement`, if they represent the
+        same algebraic number.
+
+        Explanation
+        ===========
+
+        This method is intended to check equivalence only in those cases in
+        which it is easy to test; namely, when *other* is either a
+        :py:class:`~.ModuleElement` that can be unified with this one (i.e. one
+        which shares a common :py:class:`~.PowerBasis` ancestor), or else a
+        rational number (which is easy because every :py:class:`~.PowerBasis`
+        represents every rational number).
+
+        Parameters
+        ==========
+
+        other : int, :ref:`ZZ`, :ref:`QQ`, :py:class:`~.ModuleElement`
+
+        Returns
+        =======
+
+        bool
+
+        Raises
+        ======
+
+        UnificationFailed
+            If ``self`` and ``other`` do not share a common
+            :py:class:`~.PowerBasis` ancestor.
+
+        """
+        if self == other:
+            return True
+        elif isinstance(other, ModuleElement):
+            a, b = self.unify(other)
+            return a == b
+        elif is_rat(other):
+            if isinstance(self, PowerBasisElement):
+                return self == self.module(0) * other
+            else:
+                return self.over_power_basis().equiv(other)
+        return False
+
+    def __add__(self, other):
+        """
+        A :py:class:`~.ModuleElement` can be added to a rational number, or to
+        another :py:class:`~.ModuleElement`.
+
+        Explanation
+        ===========
+
+        When the other summand is a rational number, it will be converted into
+        a :py:class:`~.ModuleElement` (belonging to the first ancestor of this
+        module that starts with unity).
+
+        In all cases, the sum belongs to the nearest common ancestor (NCA) of
+        the modules of the two summands. If the NCA does not exist, we return
+        ``NotImplemented``.
+        """
+        if self.is_compat(other):
+            d, e = self.denom, other.denom
+            m = ilcm(d, e)
+            u, v = m // d, m // e
+            col = to_col([u * a + v * b for a, b in zip(self.coeffs, other.coeffs)])
+            return type(self)(self.module, col, denom=m).reduced()
+        elif isinstance(other, ModuleElement):
+            try:
+                a, b = self.unify(other)
+            except UnificationFailed:
+                return NotImplemented
+            return a + b
+        elif is_rat(other):
+            return self + self.module.element_from_rational(other)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return self * -1
+
+    def __sub__(self, other):
+        return self + (-other)
+
+    def __rsub__(self, other):
+        return -self + other
+
+    def __mul__(self, other):
+        """
+        A :py:class:`~.ModuleElement` can be multiplied by a rational number,
+        or by another :py:class:`~.ModuleElement`.
+
+        Explanation
+        ===========
+
+        When the multiplier is a rational number, the product is computed by
+        operating directly on the coefficients of this
+        :py:class:`~.ModuleElement`.
+
+        When the multiplier is another :py:class:`~.ModuleElement`, the product
+        will belong to the nearest common ancestor (NCA) of the modules of the
+        two operands, and that NCA must have a multiplication table. If the NCA
+        does not exist, we return ``NotImplemented``. If the NCA does not have
+        a mult. table, ``ClosureFailure`` will be raised.
+        """
+        if self.is_compat(other):
+            M = self.module.mult_tab()
+            A, B = self.col.flat(), other.col.flat()
+            n = self.n
+            C = [0] * n
+            for u in range(n):
+                for v in range(u, n):
+                    c = A[u] * B[v]
+                    if v > u:
+                        c += A[v] * B[u]
+                    if c != 0:
+                        R = M[u][v]
+                        for k in range(n):
+                            C[k] += c * R[k]
+            d = self.denom * other.denom
+            return self.from_int_list(self.module, C, denom=d)
+        elif isinstance(other, ModuleElement):
+            try:
+                a, b = self.unify(other)
+            except UnificationFailed:
+                return NotImplemented
+            return a * b
+        elif is_rat(other):
+            a, b = get_num_denom(other)
+            if a == b == 1:
+                return self
+            else:
+                return make_mod_elt(self.module,
+                                 self.col * a, denom=self.denom * b).reduced()
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def _zeroth_power(self):
+        return self.module.one()
+
+    def _first_power(self):
+        return self
+
+    def __floordiv__(self, a):
+        if is_rat(a):
+            a = QQ(a)
+            return self * (1/a)
+        elif isinstance(a, ModuleElement):
+            return self * (1//a)
+        return NotImplemented
+
+    def __rfloordiv__(self, a):
+        return a // self.over_power_basis()
+
+    def __mod__(self, m):
+        r"""
+        Reduce this :py:class:`~.ModuleElement` mod a :py:class:`~.Submodule`.
+
+        Parameters
+        ==========
+
+        m : int, :ref:`ZZ`, :ref:`QQ`, :py:class:`~.Submodule`
+            If a :py:class:`~.Submodule`, reduce ``self`` relative to this.
+            If an integer or rational, reduce relative to the
+            :py:class:`~.Submodule` that is our own module times this constant.
+
+        See Also
+        ========
+
+        .Submodule.reduce_element
+
+        """
+        if is_rat(m):
+            m = m * self.module.whole_submodule()
+        if isinstance(m, Submodule) and m.parent == self.module:
+            return m.reduce_element(self)
+        return NotImplemented
+
+
+class PowerBasisElement(ModuleElement):
+    r"""
+    Subclass for :py:class:`~.ModuleElement` instances whose module is a
+    :py:class:`~.PowerBasis`.
+    """
+
+    @property
+    def T(self):
+        """Access the defining polynomial of the :py:class:`~.PowerBasis`."""
+        return self.module.T
+
+    def numerator(self, x=None):
+        """Obtain the numerator as a polynomial over :ref:`ZZ`."""
+        x = x or self.T.gen
+        return Poly(reversed(self.coeffs), x, domain=ZZ)
+
+    def poly(self, x=None):
+        """Obtain the number as a polynomial over :ref:`QQ`."""
+        return self.numerator(x=x) // self.denom
+
+    @property
+    def is_rational(self):
+        """Say whether this element represents a rational number."""
+        return self.col[1:, :].is_zero_matrix
+
+    @property
+    def generator(self):
+        """
+        Return a :py:class:`~.Symbol` to be used when expressing this element
+        as a polynomial.
+
+        If we have an associated :py:class:`~.AlgebraicField` whose primitive
+        element has an alias symbol, we use that. Otherwise we use the variable
+        of the minimal polynomial defining the power basis to which we belong.
+        """
+        K = self.module.number_field
+        return K.ext.alias if K and K.ext.is_aliased else self.T.gen
+
+    def as_expr(self, x=None):
+        """Create a Basic expression from ``self``. """
+        return self.poly(x or self.generator).as_expr()
+
+    def norm(self, T=None):
+        """Compute the norm of this number."""
+        T = T or self.T
+        x = T.gen
+        A = self.numerator(x=x)
+        return T.resultant(A) // self.denom ** self.n
+
+    def inverse(self):
+        f = self.poly()
+        f_inv = f.invert(self.T)
+        return self.module.element_from_poly(f_inv)
+
+    def __rfloordiv__(self, a):
+        return self.inverse() * a
+
+    def _negative_power(self, e, modulo=None):
+        return self.inverse() ** abs(e)
+
+    def to_ANP(self):
+        """Convert to an equivalent :py:class:`~.ANP`. """
+        return ANP(list(reversed(self.QQ_col.flat())), QQ.map(self.T.rep.to_list()), QQ)
+
+    def to_alg_num(self):
+        """
+        Try to convert to an equivalent :py:class:`~.AlgebraicNumber`.
+
+        Explanation
+        ===========
+
+        In general, the conversion from an :py:class:`~.AlgebraicNumber` to a
+        :py:class:`~.PowerBasisElement` throws away information, because an
+        :py:class:`~.AlgebraicNumber` specifies a complex embedding, while a
+        :py:class:`~.PowerBasisElement` does not. However, in some cases it is
+        possible to convert a :py:class:`~.PowerBasisElement` back into an
+        :py:class:`~.AlgebraicNumber`, namely when the associated
+        :py:class:`~.PowerBasis` has a reference to an
+        :py:class:`~.AlgebraicField`.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicNumber`
+
+        Raises
+        ======
+
+        StructureError
+            If the :py:class:`~.PowerBasis` to which this element belongs does
+            not have an associated :py:class:`~.AlgebraicField`.
+
+        """
+        K = self.module.number_field
+        if K:
+            return K.to_alg_num(self.to_ANP())
+        raise StructureError("No associated AlgebraicField")
+
+
+class ModuleHomomorphism:
+    r"""A homomorphism from one module to another."""
+
+    def __init__(self, domain, codomain, mapping):
+        r"""
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The domain of the mapping.
+
+        codomain : :py:class:`~.Module`
+            The codomain of the mapping.
+
+        mapping : callable
+            An arbitrary callable is accepted, but should be chosen so as
+            to represent an actual module homomorphism. In particular, should
+            accept elements of *domain* and return elements of *codomain*.
+
+        Examples
+        ========
+
+        >>> from sympy import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis, ModuleHomomorphism
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> A = PowerBasis(T)
+        >>> B = A.submodule_from_gens([2*A(j) for j in range(4)])
+        >>> phi = ModuleHomomorphism(A, B, lambda x: 6*x)
+        >>> print(phi.matrix())  # doctest: +SKIP
+        DomainMatrix([[3, 0, 0, 0], [0, 3, 0, 0], [0, 0, 3, 0], [0, 0, 0, 3]], (4, 4), ZZ)
+
+        """
+        self.domain = domain
+        self.codomain = codomain
+        self.mapping = mapping
+
+    def matrix(self, modulus=None):
+        r"""
+        Compute the matrix of this homomorphism.
+
+        Parameters
+        ==========
+
+        modulus : int, optional
+            A positive prime number $p$ if the matrix should be reduced mod
+            $p$.
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix`
+            The matrix is over :ref:`ZZ`, or else over :ref:`GF(p)` if a
+            modulus was given.
+
+        """
+        basis = self.domain.basis_elements()
+        cols = [self.codomain.represent(self.mapping(elt)) for elt in basis]
+        if not cols:
+            return DomainMatrix.zeros((self.codomain.n, 0), ZZ).to_dense()
+        M = cols[0].hstack(*cols[1:])
+        if modulus:
+            M = M.convert_to(FF(modulus))
+        return M
+
+    def kernel(self, modulus=None):
+        r"""
+        Compute a Submodule representing the kernel of this homomorphism.
+
+        Parameters
+        ==========
+
+        modulus : int, optional
+            A positive prime number $p$ if the kernel should be computed mod
+            $p$.
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+            This submodule's generators span the kernel of this
+            homomorphism over :ref:`ZZ`, or else over :ref:`GF(p)` if a
+            modulus was given.
+
+        """
+        M = self.matrix(modulus=modulus)
+        if modulus is None:
+            M = M.convert_to(QQ)
+        # Note: Even when working over a finite field, what we want here is
+        # the pullback into the integers, so in this case the conversion to ZZ
+        # below is appropriate. When working over ZZ, the kernel should be a
+        # ZZ-submodule, so, while the conversion to QQ above was required in
+        # order for the nullspace calculation to work, conversion back to ZZ
+        # afterward should always work.
+        # TODO:
+        #  Watch <https://github.com/sympy/sympy/issues/21834>, which calls
+        #  for fraction-free algorithms. If this is implemented, we can skip
+        #  the conversion to `QQ` above.
+        K = M.nullspace().convert_to(ZZ).transpose()
+        return self.domain.submodule_from_matrix(K)
+
+
+class ModuleEndomorphism(ModuleHomomorphism):
+    r"""A homomorphism from one module to itself."""
+
+    def __init__(self, domain, mapping):
+        r"""
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The common domain and codomain of the mapping.
+
+        mapping : callable
+            An arbitrary callable is accepted, but should be chosen so as
+            to represent an actual module endomorphism. In particular, should
+            accept and return elements of *domain*.
+
+        """
+        super().__init__(domain, domain, mapping)
+
+
+class InnerEndomorphism(ModuleEndomorphism):
+    r"""
+    An inner endomorphism on a module, i.e. the endomorphism corresponding to
+    multiplication by a fixed element.
+    """
+
+    def __init__(self, domain, multiplier):
+        r"""
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The domain and codomain of the endomorphism.
+
+        multiplier : :py:class:`~.ModuleElement`
+            The element $a$ defining the mapping as $x \mapsto a x$.
+
+        """
+        super().__init__(domain, lambda x: multiplier * x)
+        self.multiplier = multiplier
+
+
+class EndomorphismRing:
+    r"""The ring of endomorphisms on a module."""
+
+    def __init__(self, domain):
+        """
+        Parameters
+        ==========
+
+        domain : :py:class:`~.Module`
+            The domain and codomain of the endomorphisms.
+
+        """
+        self.domain = domain
+
+    def inner_endomorphism(self, multiplier):
+        r"""
+        Form an inner endomorphism belonging to this endomorphism ring.
+
+        Parameters
+        ==========
+
+        multiplier : :py:class:`~.ModuleElement`
+            Element $a$ defining the inner endomorphism $x \mapsto a x$.
+
+        Returns
+        =======
+
+        :py:class:`~.InnerEndomorphism`
+
+        """
+        return InnerEndomorphism(self.domain, multiplier)
+
+    def represent(self, element):
+        r"""
+        Represent an element of this endomorphism ring, as a single column
+        vector.
+
+        Explanation
+        ===========
+
+        Let $M$ be a module, and $E$ its ring of endomorphisms. Let $N$ be
+        another module, and consider a homomorphism $\varphi: N \rightarrow E$.
+        In the event that $\varphi$ is to be represented by a matrix $A$, each
+        column of $A$ must represent an element of $E$. This is possible when
+        the elements of $E$ are themselves representable as matrices, by
+        stacking the columns of such a matrix into a single column.
+
+        This method supports calculating such matrices $A$, by representing
+        an element of this endomorphism ring first as a matrix, and then
+        stacking that matrix's columns into a single column.
+
+        Examples
+        ========
+
+        Note that in these examples we print matrix transposes, to make their
+        columns easier to inspect.
+
+        >>> from sympy import Poly, cyclotomic_poly
+        >>> from sympy.polys.numberfields.modules import PowerBasis
+        >>> from sympy.polys.numberfields.modules import ModuleHomomorphism
+        >>> T = Poly(cyclotomic_poly(5))
+        >>> M = PowerBasis(T)
+        >>> E = M.endomorphism_ring()
+
+        Let $\zeta$ be a primitive 5th root of unity, a generator of our field,
+        and consider the inner endomorphism $\tau$ on the ring of integers,
+        induced by $\zeta$:
+
+        >>> zeta = M(1)
+        >>> tau = E.inner_endomorphism(zeta)
+        >>> tau.matrix().transpose()  # doctest: +SKIP
+        DomainMatrix(
+            [[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [-1, -1, -1, -1]],
+            (4, 4), ZZ)
+
+        The matrix representation of $\tau$ is as expected. The first column
+        shows that multiplying by $\zeta$ carries $1$ to $\zeta$, the second
+        column that it carries $\zeta$ to $\zeta^2$, and so forth.
+
+        The ``represent`` method of the endomorphism ring ``E`` stacks these
+        into a single column:
+
+        >>> E.represent(tau).transpose()  # doctest: +SKIP
+        DomainMatrix(
+            [[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1]],
+            (1, 16), ZZ)
+
+        This is useful when we want to consider a homomorphism $\varphi$ having
+        ``E`` as codomain:
+
+        >>> phi = ModuleHomomorphism(M, E, lambda x: E.inner_endomorphism(x))
+
+        and we want to compute the matrix of such a homomorphism:
+
+        >>> phi.matrix().transpose()  # doctest: +SKIP
+        DomainMatrix(
+            [[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+            [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1],
+            [0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1, 1, 0, 0, 0],
+            [0, 0, 0, 1, -1, -1, -1, -1, 1, 0, 0, 0, 0, 1, 0, 0]],
+            (4, 16), ZZ)
+
+        Note that the stacked matrix of $\tau$ occurs as the second column in
+        this example. This is because $\zeta$ is the second basis element of
+        ``M``, and $\varphi(\zeta) = \tau$.
+
+        Parameters
+        ==========
+
+        element : :py:class:`~.ModuleEndomorphism` belonging to this ring.
+
+        Returns
+        =======
+
+        :py:class:`~.DomainMatrix`
+            Column vector equalling the vertical stacking of all the columns
+            of the matrix that represents the given *element* as a mapping.
+
+        """
+        if isinstance(element, ModuleEndomorphism) and element.domain == self.domain:
+            M = element.matrix()
+            # Transform the matrix into a single column, which should reproduce
+            # the original columns, one after another.
+            m, n = M.shape
+            if n == 0:
+                return M
+            return M[:, 0].vstack(*[M[:, j] for j in range(1, n)])
+        raise NotImplementedError
+
+
+def find_min_poly(alpha, domain, x=None, powers=None):
+    r"""
+    Find a polynomial of least degree (not necessarily irreducible) satisfied
+    by an element of a finitely-generated ring with unity.
+
+    Examples
+    ========
+
+    For the $n$th cyclotomic field, $n$ an odd prime, consider the quadratic
+    equation whose roots are the two periods of length $(n-1)/2$. Article 356
+    of Gauss tells us that we should get $x^2 + x - (n-1)/4$ or
+    $x^2 + x + (n+1)/4$ according to whether $n$ is 1 or 3 mod 4, respectively.
+
+    >>> from sympy import Poly, cyclotomic_poly, primitive_root, QQ
+    >>> from sympy.abc import x
+    >>> from sympy.polys.numberfields.modules import PowerBasis, find_min_poly
+    >>> n = 13
+    >>> g = primitive_root(n)
+    >>> C = PowerBasis(Poly(cyclotomic_poly(n, x)))
+    >>> ee = [g**(2*k+1) % n for k in range((n-1)//2)]
+    >>> eta = sum(C(e) for e in ee)
+    >>> print(find_min_poly(eta, QQ, x=x).as_expr())
+    x**2 + x - 3
+    >>> n = 19
+    >>> g = primitive_root(n)
+    >>> C = PowerBasis(Poly(cyclotomic_poly(n, x)))
+    >>> ee = [g**(2*k+2) % n for k in range((n-1)//2)]
+    >>> eta = sum(C(e) for e in ee)
+    >>> print(find_min_poly(eta, QQ, x=x).as_expr())
+    x**2 + x + 5
+
+    Parameters
+    ==========
+
+    alpha : :py:class:`~.ModuleElement`
+        The element whose min poly is to be found, and whose module has
+        multiplication and starts with unity.
+
+    domain : :py:class:`~.Domain`
+        The desired domain of the polynomial.
+
+    x : :py:class:`~.Symbol`, optional
+        The desired variable for the polynomial.
+
+    powers : list, optional
+        If desired, pass an empty list. The powers of *alpha* (as
+        :py:class:`~.ModuleElement` instances) from the zeroth up to the degree
+        of the min poly will be recorded here, as we compute them.
+
+    Returns
+    =======
+
+    :py:class:`~.Poly`, ``None``
+        The minimal polynomial for alpha, or ``None`` if no polynomial could be
+        found over the desired domain.
+
+    Raises
+    ======
+
+    MissingUnityError
+        If the module to which alpha belongs does not start with unity.
+    ClosureFailure
+        If the module to which alpha belongs is not closed under
+        multiplication.
+
+    """
+    R = alpha.module
+    if not R.starts_with_unity():
+        raise MissingUnityError("alpha must belong to finitely generated ring with unity.")
+    if powers is None:
+        powers = []
+    one = R(0)
+    powers.append(one)
+    powers_matrix = one.column(domain=domain)
+    ak = alpha
+    m = None
+    for k in range(1, R.n + 1):
+        powers.append(ak)
+        ak_col = ak.column(domain=domain)
+        try:
+            X = powers_matrix._solve(ak_col)[0]
+        except DMBadInputError:
+            # This means alpha^k still isn't in the domain-span of the lower powers.
+            powers_matrix = powers_matrix.hstack(ak_col)
+            ak *= alpha
+        else:
+            # alpha^k is in the domain-span of the lower powers, so we have found a
+            # minimal-degree poly for alpha.
+            coeffs = [1] + [-c for c in reversed(X.to_list_flat())]
+            x = x or Dummy('x')
+            if domain.is_FF:
+                m = Poly(coeffs, x, modulus=domain.mod)
+            else:
+                m = Poly(coeffs, x, domain=domain)
+            break
+    return m

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/primes.py

@@ -0,0 +1,784 @@
+"""Prime ideals in number fields. """
+
+from sympy.polys.polytools import Poly
+from sympy.polys.domains.finitefield import FF
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.polyutils import IntegerPowerable
+from sympy.utilities.decorator import public
+from .basis import round_two, nilradical_mod_p
+from .exceptions import StructureError
+from .modules import ModuleEndomorphism, find_min_poly
+from .utilities import coeff_search, supplement_a_subspace
+
+
+def _check_formal_conditions_for_maximal_order(submodule):
+    r"""
+    Several functions in this module accept an argument which is to be a
+    :py:class:`~.Submodule` representing the maximal order in a number field,
+    such as returned by the :py:func:`~sympy.polys.numberfields.basis.round_two`
+    algorithm.
+
+    We do not attempt to check that the given ``Submodule`` actually represents
+    a maximal order, but we do check a basic set of formal conditions that the
+    ``Submodule`` must satisfy, at a minimum. The purpose is to catch an
+    obviously ill-formed argument.
+    """
+    prefix = 'The submodule representing the maximal order should '
+    cond = None
+    if not submodule.is_power_basis_submodule():
+        cond = 'be a direct submodule of a power basis.'
+    elif not submodule.starts_with_unity():
+        cond = 'have 1 as its first generator.'
+    elif not submodule.is_sq_maxrank_HNF():
+        cond = 'have square matrix, of maximal rank, in Hermite Normal Form.'
+    if cond is not None:
+        raise StructureError(prefix + cond)
+
+
+class PrimeIdeal(IntegerPowerable):
+    r"""
+    A prime ideal in a ring of algebraic integers.
+    """
+
+    def __init__(self, ZK, p, alpha, f, e=None):
+        """
+        Parameters
+        ==========
+
+        ZK : :py:class:`~.Submodule`
+            The maximal order where this ideal lives.
+        p : int
+            The rational prime this ideal divides.
+        alpha : :py:class:`~.PowerBasisElement`
+            Such that the ideal is equal to ``p*ZK + alpha*ZK``.
+        f : int
+            The inertia degree.
+        e : int, ``None``, optional
+            The ramification index, if already known. If ``None``, we will
+            compute it here.
+
+        """
+        _check_formal_conditions_for_maximal_order(ZK)
+        self.ZK = ZK
+        self.p = p
+        self.alpha = alpha
+        self.f = f
+        self._test_factor = None
+        self.e = e if e is not None else self.valuation(p * ZK)
+
+    def __str__(self):
+        if self.is_inert:
+            return f'({self.p})'
+        return f'({self.p}, {self.alpha.as_expr()})'
+
+    @property
+    def is_inert(self):
+        """
+        Say whether the rational prime we divide is inert, i.e. stays prime in
+        our ring of integers.
+        """
+        return self.f == self.ZK.n
+
+    def repr(self, field_gen=None, just_gens=False):
+        """
+        Print a representation of this prime ideal.
+
+        Examples
+        ========
+
+        >>> from sympy import cyclotomic_poly, QQ
+        >>> from sympy.abc import x, zeta
+        >>> T = cyclotomic_poly(7, x)
+        >>> K = QQ.algebraic_field((T, zeta))
+        >>> P = K.primes_above(11)
+        >>> print(P[0].repr())
+        [ (11, x**3 + 5*x**2 + 4*x - 1) e=1, f=3 ]
+        >>> print(P[0].repr(field_gen=zeta))
+        [ (11, zeta**3 + 5*zeta**2 + 4*zeta - 1) e=1, f=3 ]
+        >>> print(P[0].repr(field_gen=zeta, just_gens=True))
+        (11, zeta**3 + 5*zeta**2 + 4*zeta - 1)
+
+        Parameters
+        ==========
+
+        field_gen : :py:class:`~.Symbol`, ``None``, optional (default=None)
+            The symbol to use for the generator of the field. This will appear
+            in our representation of ``self.alpha``. If ``None``, we use the
+            variable of the defining polynomial of ``self.ZK``.
+        just_gens : bool, optional (default=False)
+            If ``True``, just print the "(p, alpha)" part, showing "just the
+            generators" of the prime ideal. Otherwise, print a string of the
+            form "[ (p, alpha) e=..., f=... ]", giving the ramification index
+            and inertia degree, along with the generators.
+
+        """
+        field_gen = field_gen or self.ZK.parent.T.gen
+        p, alpha, e, f = self.p, self.alpha, self.e, self.f
+        alpha_rep = str(alpha.numerator(x=field_gen).as_expr())
+        if alpha.denom > 1:
+            alpha_rep = f'({alpha_rep})/{alpha.denom}'
+        gens = f'({p}, {alpha_rep})'
+        if just_gens:
+            return gens
+        return f'[ {gens} e={e}, f={f} ]'
+
+    def __repr__(self):
+        return self.repr()
+
+    def as_submodule(self):
+        r"""
+        Represent this prime ideal as a :py:class:`~.Submodule`.
+
+        Explanation
+        ===========
+
+        The :py:class:`~.PrimeIdeal` class serves to bundle information about
+        a prime ideal, such as its inertia degree, ramification index, and
+        two-generator representation, as well as to offer helpful methods like
+        :py:meth:`~.PrimeIdeal.valuation` and
+        :py:meth:`~.PrimeIdeal.test_factor`.
+
+        However, in order to be added and multiplied by other ideals or
+        rational numbers, it must first be converted into a
+        :py:class:`~.Submodule`, which is a class that supports these
+        operations.
+
+        In many cases, the user need not perform this conversion deliberately,
+        since it is automatically performed by the arithmetic operator methods
+        :py:meth:`~.PrimeIdeal.__add__` and :py:meth:`~.PrimeIdeal.__mul__`.
+
+        Raising a :py:class:`~.PrimeIdeal` to a non-negative integer power is
+        also supported.
+
+        Examples
+        ========
+
+        >>> from sympy import Poly, cyclotomic_poly, prime_decomp
+        >>> T = Poly(cyclotomic_poly(7))
+        >>> P0 = prime_decomp(7, T)[0]
+        >>> print(P0**6 == 7*P0.ZK)
+        True
+
+        Note that, on both sides of the equation above, we had a
+        :py:class:`~.Submodule`. In the next equation we recall that adding
+        ideals yields their GCD. This time, we need a deliberate conversion
+        to :py:class:`~.Submodule` on the right:
+
+        >>> print(P0 + 7*P0.ZK == P0.as_submodule())
+        True
+
+        Returns
+        =======
+
+        :py:class:`~.Submodule`
+            Will be equal to ``self.p * self.ZK + self.alpha * self.ZK``.
+
+        See Also
+        ========
+
+        __add__
+        __mul__
+
+        """
+        M = self.p * self.ZK + self.alpha * self.ZK
+        # Pre-set expensive boolean properties whose value we already know:
+        M._starts_with_unity = False
+        M._is_sq_maxrank_HNF = True
+        return M
+
+    def __eq__(self, other):
+        if isinstance(other, PrimeIdeal):
+            return self.as_submodule() == other.as_submodule()
+        return NotImplemented
+
+    def __add__(self, other):
+        """
+        Convert to a :py:class:`~.Submodule` and add to another
+        :py:class:`~.Submodule`.
+
+        See Also
+        ========
+
+        as_submodule
+
+        """
+        return self.as_submodule() + other
+
+    __radd__ = __add__
+
+    def __mul__(self, other):
+        """
+        Convert to a :py:class:`~.Submodule` and multiply by another
+        :py:class:`~.Submodule` or a rational number.
+
+        See Also
+        ========
+
+        as_submodule
+
+        """
+        return self.as_submodule() * other
+
+    __rmul__ = __mul__
+
+    def _zeroth_power(self):
+        return self.ZK
+
+    def _first_power(self):
+        return self
+
+    def test_factor(self):
+        r"""
+        Compute a test factor for this prime ideal.
+
+        Explanation
+        ===========
+
+        Write $\mathfrak{p}$ for this prime ideal, $p$ for the rational prime
+        it divides. Then, for computing $\mathfrak{p}$-adic valuations it is
+        useful to have a number $\beta \in \mathbb{Z}_K$ such that
+        $p/\mathfrak{p} = p \mathbb{Z}_K + \beta \mathbb{Z}_K$.
+
+        Essentially, this is the same as the number $\Psi$ (or the "reagent")
+        from Kummer's 1847 paper (*Ueber die Zerlegung...*, Crelle vol. 35) in
+        which ideal divisors were invented.
+        """
+        if self._test_factor is None:
+            self._test_factor = _compute_test_factor(self.p, [self.alpha], self.ZK)
+        return self._test_factor
+
+    def valuation(self, I):
+        r"""
+        Compute the $\mathfrak{p}$-adic valuation of integral ideal I at this
+        prime ideal.
+
+        Parameters
+        ==========
+
+        I : :py:class:`~.Submodule`
+
+        See Also
+        ========
+
+        prime_valuation
+
+        """
+        return prime_valuation(I, self)
+
+    def reduce_element(self, elt):
+        """
+        Reduce a :py:class:`~.PowerBasisElement` to a "small representative"
+        modulo this prime ideal.
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.PowerBasisElement`
+            The element to be reduced.
+
+        Returns
+        =======
+
+        :py:class:`~.PowerBasisElement`
+            The reduced element.
+
+        See Also
+        ========
+
+        reduce_ANP
+        reduce_alg_num
+        .Submodule.reduce_element
+
+        """
+        return self.as_submodule().reduce_element(elt)
+
+    def reduce_ANP(self, a):
+        """
+        Reduce an :py:class:`~.ANP` to a "small representative" modulo this
+        prime ideal.
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.ANP`
+            The element to be reduced.
+
+        Returns
+        =======
+
+        :py:class:`~.ANP`
+            The reduced element.
+
+        See Also
+        ========
+
+        reduce_element
+        reduce_alg_num
+        .Submodule.reduce_element
+
+        """
+        elt = self.ZK.parent.element_from_ANP(a)
+        red = self.reduce_element(elt)
+        return red.to_ANP()
+
+    def reduce_alg_num(self, a):
+        """
+        Reduce an :py:class:`~.AlgebraicNumber` to a "small representative"
+        modulo this prime ideal.
+
+        Parameters
+        ==========
+
+        elt : :py:class:`~.AlgebraicNumber`
+            The element to be reduced.
+
+        Returns
+        =======
+
+        :py:class:`~.AlgebraicNumber`
+            The reduced element.
+
+        See Also
+        ========
+
+        reduce_element
+        reduce_ANP
+        .Submodule.reduce_element
+
+        """
+        elt = self.ZK.parent.element_from_alg_num(a)
+        red = self.reduce_element(elt)
+        return a.field_element(list(reversed(red.QQ_col.flat())))
+
+
+def _compute_test_factor(p, gens, ZK):
+    r"""
+    Compute the test factor for a :py:class:`~.PrimeIdeal` $\mathfrak{p}$.
+
+    Parameters
+    ==========
+
+    p : int
+        The rational prime $\mathfrak{p}$ divides
+
+    gens : list of :py:class:`PowerBasisElement`
+        A complete set of generators for $\mathfrak{p}$ over *ZK*, EXCEPT that
+        an element equivalent to rational *p* can and should be omitted (since
+        it has no effect except to waste time).
+
+    ZK : :py:class:`~.Submodule`
+        The maximal order where the prime ideal $\mathfrak{p}$ lives.
+
+    Returns
+    =======
+
+    :py:class:`~.PowerBasisElement`
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+    (See Proposition 4.8.15.)
+
+    """
+    _check_formal_conditions_for_maximal_order(ZK)
+    E = ZK.endomorphism_ring()
+    matrices = [E.inner_endomorphism(g).matrix(modulus=p) for g in gens]
+    B = DomainMatrix.zeros((0, ZK.n), FF(p)).vstack(*matrices)
+    # A nonzero element of the nullspace of B will represent a
+    # lin comb over the omegas which (i) is not a multiple of p
+    # (since it is nonzero over FF(p)), while (ii) is such that
+    # its product with each g in gens _is_ a multiple of p (since
+    # B represents multiplication by these generators). Theory
+    # predicts that such an element must exist, so nullspace should
+    # be non-trivial.
+    x = B.nullspace()[0, :].transpose()
+    beta = ZK.parent(ZK.matrix * x.convert_to(ZZ), denom=ZK.denom)
+    return beta
+
+
+@public
+def prime_valuation(I, P):
+    r"""
+    Compute the *P*-adic valuation for an integral ideal *I*.
+
+    Examples
+    ========
+
+    >>> from sympy import QQ
+    >>> from sympy.polys.numberfields import prime_valuation
+    >>> K = QQ.cyclotomic_field(5)
+    >>> P = K.primes_above(5)
+    >>> ZK = K.maximal_order()
+    >>> print(prime_valuation(25*ZK, P[0]))
+    8
+
+    Parameters
+    ==========
+
+    I : :py:class:`~.Submodule`
+        An integral ideal whose valuation is desired.
+
+    P : :py:class:`~.PrimeIdeal`
+        The prime at which to compute the valuation.
+
+    Returns
+    =======
+
+    int
+
+    See Also
+    ========
+
+    .PrimeIdeal.valuation
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 4.8.17.)
+
+    """
+    p, ZK = P.p, P.ZK
+    n, W, d = ZK.n, ZK.matrix, ZK.denom
+
+    A = W.convert_to(QQ).inv() * I.matrix * d / I.denom
+    # Although A must have integer entries, given that I is an integral ideal,
+    # as a DomainMatrix it will still be over QQ, so we convert back:
+    A = A.convert_to(ZZ)
+    D = A.det()
+    if D % p != 0:
+        return 0
+
+    beta = P.test_factor()
+
+    f = d ** n // W.det()
+    need_complete_test = (f % p == 0)
+    v = 0
+    while True:
+        # Entering the loop, the cols of A represent lin combs of omegas.
+        # Turn them into lin combs of thetas:
+        A = W * A
+        # And then one column at a time...
+        for j in range(n):
+            c = ZK.parent(A[:, j], denom=d)
+            c *= beta
+            # ...turn back into lin combs of omegas, after multiplying by beta:
+            c = ZK.represent(c).flat()
+            for i in range(n):
+                A[i, j] = c[i]
+        if A[n - 1, n - 1].element % p != 0:
+            break
+        A = A / p
+        # As noted above, domain converts to QQ even when division goes evenly.
+        # So must convert back, even when we don't "need_complete_test".
+        if need_complete_test:
+            # In this case, having a non-integer entry is actually just our
+            # halting condition.
+            try:
+                A = A.convert_to(ZZ)
+            except CoercionFailed:
+                break
+        else:
+            # In this case theory says we should not have any non-integer entries.
+            A = A.convert_to(ZZ)
+        v += 1
+    return v
+
+
+def _two_elt_rep(gens, ZK, p, f=None, Np=None):
+    r"""
+    Given a set of *ZK*-generators of a prime ideal, compute a set of just two
+    *ZK*-generators for the same ideal, one of which is *p* itself.
+
+    Parameters
+    ==========
+
+    gens : list of :py:class:`PowerBasisElement`
+        Generators for the prime ideal over *ZK*, the ring of integers of the
+        field $K$.
+
+    ZK : :py:class:`~.Submodule`
+        The maximal order in $K$.
+
+    p : int
+        The rational prime divided by the prime ideal.
+
+    f : int, optional
+        The inertia degree of the prime ideal, if known.
+
+    Np : int, optional
+        The norm $p^f$ of the prime ideal, if known.
+        NOTE: There is no reason to supply both *f* and *Np*. Either one will
+        save us from having to compute the norm *Np* ourselves. If both are known,
+        *Np* is preferred since it saves one exponentiation.
+
+    Returns
+    =======
+
+    :py:class:`~.PowerBasisElement` representing a single algebraic integer
+    alpha such that the prime ideal is equal to ``p*ZK + alpha*ZK``.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+    (See Algorithm 4.7.10.)
+
+    """
+    _check_formal_conditions_for_maximal_order(ZK)
+    pb = ZK.parent
+    T = pb.T
+    # Detect the special cases in which either (a) all generators are multiples
+    # of p, or (b) there are no generators (so `all` is vacuously true):
+    if all((g % p).equiv(0) for g in gens):
+        return pb.zero()
+
+    if Np is None:
+        if f is not None:
+            Np = p**f
+        else:
+            Np = abs(pb.submodule_from_gens(gens).matrix.det())
+
+    omega = ZK.basis_element_pullbacks()
+    beta = [p*om for om in omega[1:]]  # note: we omit omega[0] == 1
+    beta += gens
+    search = coeff_search(len(beta), 1)
+    for c in search:
+        alpha = sum(ci*betai for ci, betai in zip(c, beta))
+        # Note: It may be tempting to reduce alpha mod p here, to try to work
+        # with smaller numbers, but must not do that, as it can result in an
+        # infinite loop! E.g. try factoring 2 in Q(sqrt(-7)).
+        n = alpha.norm(T) // Np
+        if n % p != 0:
+            # Now can reduce alpha mod p.
+            return alpha % p
+
+
+def _prime_decomp_easy_case(p, ZK):
+    r"""
+    Compute the decomposition of rational prime *p* in the ring of integers
+    *ZK* (given as a :py:class:`~.Submodule`), in the "easy case", i.e. the
+    case where *p* does not divide the index of $\theta$ in *ZK*, where
+    $\theta$ is the generator of the ``PowerBasis`` of which *ZK* is a
+    ``Submodule``.
+    """
+    T = ZK.parent.T
+    T_bar = Poly(T, modulus=p)
+    lc, fl = T_bar.factor_list()
+    if len(fl) == 1 and fl[0][1] == 1:
+        return [PrimeIdeal(ZK, p, ZK.parent.zero(), ZK.n, 1)]
+    return [PrimeIdeal(ZK, p,
+                       ZK.parent.element_from_poly(Poly(t, domain=ZZ)),
+                       t.degree(), e)
+            for t, e in fl]
+
+
+def _prime_decomp_compute_kernel(I, p, ZK):
+    r"""
+    Parameters
+    ==========
+
+    I : :py:class:`~.Module`
+        An ideal of ``ZK/pZK``.
+    p : int
+        The rational prime being factored.
+    ZK : :py:class:`~.Submodule`
+        The maximal order.
+
+    Returns
+    =======
+
+    Pair ``(N, G)``, where:
+
+        ``N`` is a :py:class:`~.Module` representing the kernel of the map
+        ``a |--> a**p - a`` on ``(O/pO)/I``, guaranteed to be a module with
+        unity.
+
+        ``G`` is a :py:class:`~.Module` representing a basis for the separable
+        algebra ``A = O/I`` (see Cohen).
+
+    """
+    W = I.matrix
+    n, r = W.shape
+    # Want to take the Fp-basis given by the columns of I, adjoin (1, 0, ..., 0)
+    # (which we know is not already in there since I is a basis for a prime ideal)
+    # and then supplement this with additional columns to make an invertible n x n
+    # matrix. This will then represent a full basis for ZK, whose first r columns
+    # are pullbacks of the basis for I.
+    if r == 0:
+        B = W.eye(n, ZZ)
+    else:
+        B = W.hstack(W.eye(n, ZZ)[:, 0])
+    if B.shape[1] < n:
+        B = supplement_a_subspace(B.convert_to(FF(p))).convert_to(ZZ)
+
+    G = ZK.submodule_from_matrix(B)
+    # Must compute G's multiplication table _before_ discarding the first r
+    # columns. (See Step 9 in Alg 6.2.9 in Cohen, where the betas are actually
+    # needed in order to represent each product of gammas. However, once we've
+    # found the representations, then we can ignore the betas.)
+    G.compute_mult_tab()
+    G = G.discard_before(r)
+
+    phi = ModuleEndomorphism(G, lambda x: x**p - x)
+    N = phi.kernel(modulus=p)
+    assert N.starts_with_unity()
+    return N, G
+
+
+def _prime_decomp_maximal_ideal(I, p, ZK):
+    r"""
+    We have reached the case where we have a maximal (hence prime) ideal *I*,
+    which we know because the quotient ``O/I`` is a field.
+
+    Parameters
+    ==========
+
+    I : :py:class:`~.Module`
+        An ideal of ``O/pO``.
+    p : int
+        The rational prime being factored.
+    ZK : :py:class:`~.Submodule`
+        The maximal order.
+
+    Returns
+    =======
+
+    :py:class:`~.PrimeIdeal` instance representing this prime
+
+    """
+    m, n = I.matrix.shape
+    f = m - n
+    G = ZK.matrix * I.matrix
+    gens = [ZK.parent(G[:, j], denom=ZK.denom) for j in range(G.shape[1])]
+    alpha = _two_elt_rep(gens, ZK, p, f=f)
+    return PrimeIdeal(ZK, p, alpha, f)
+
+
+def _prime_decomp_split_ideal(I, p, N, G, ZK):
+    r"""
+    Perform the step in the prime decomposition algorithm where we have determined
+    the quotient ``ZK/I`` is _not_ a field, and we want to perform a non-trivial
+    factorization of *I* by locating an idempotent element of ``ZK/I``.
+    """
+    assert I.parent == ZK and G.parent is ZK and N.parent is G
+    # Since ZK/I is not a field, the kernel computed in the previous step contains
+    # more than just the prime field Fp, and our basis N for the nullspace therefore
+    # contains at least a second column (which represents an element outside Fp).
+    # Let alpha be such an element:
+    alpha = N(1).to_parent()
+    assert alpha.module is G
+
+    alpha_powers = []
+    m = find_min_poly(alpha, FF(p), powers=alpha_powers)
+    # TODO (future work):
+    #  We don't actually need full factorization, so might use a faster method
+    #  to just break off a single non-constant factor m1?
+    lc, fl = m.factor_list()
+    m1 = fl[0][0]
+    m2 = m.quo(m1)
+    U, V, g = m1.gcdex(m2)
+    # Sanity check: theory says m is squarefree, so m1, m2 should be coprime:
+    assert g == 1
+    E = list(reversed(Poly(U * m1, domain=ZZ).rep.to_list()))
+    eps1 = sum(E[i]*alpha_powers[i] for i in range(len(E)))
+    eps2 = 1 - eps1
+    idemps = [eps1, eps2]
+    factors = []
+    for eps in idemps:
+        e = eps.to_parent()
+        assert e.module is ZK
+        D = I.matrix.convert_to(FF(p)).hstack(*[
+            (e * om).column(domain=FF(p)) for om in ZK.basis_elements()
+        ])
+        W = D.columnspace().convert_to(ZZ)
+        H = ZK.submodule_from_matrix(W)
+        factors.append(H)
+    return factors
+
+
+@public
+def prime_decomp(p, T=None, ZK=None, dK=None, radical=None):
+    r"""
+    Compute the decomposition of rational prime *p* in a number field.
+
+    Explanation
+    ===========
+
+    Ordinarily this should be accessed through the
+    :py:meth:`~.AlgebraicField.primes_above` method of an
+    :py:class:`~.AlgebraicField`.
+
+    Examples
+    ========
+
+    >>> from sympy import Poly, QQ
+    >>> from sympy.abc import x, theta
+    >>> T = Poly(x ** 3 + x ** 2 - 2 * x + 8)
+    >>> K = QQ.algebraic_field((T, theta))
+    >>> print(K.primes_above(2))
+    [[ (2, x**2 + 1) e=1, f=1 ], [ (2, (x**2 + 3*x + 2)/2) e=1, f=1 ],
+     [ (2, (3*x**2 + 3*x)/2) e=1, f=1 ]]
+
+    Parameters
+    ==========
+
+    p : int
+        The rational prime whose decomposition is desired.
+
+    T : :py:class:`~.Poly`, optional
+        Monic irreducible polynomial defining the number field $K$ in which to
+        factor. NOTE: at least one of *T* or *ZK* must be provided.
+
+    ZK : :py:class:`~.Submodule`, optional
+        The maximal order for $K$, if already known.
+        NOTE: at least one of *T* or *ZK* must be provided.
+
+    dK : int, optional
+        The discriminant of the field $K$, if already known.
+
+    radical : :py:class:`~.Submodule`, optional
+        The nilradical mod *p* in the integers of $K$, if already known.
+
+    Returns
+    =======
+
+    List of :py:class:`~.PrimeIdeal` instances.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 6.2.9.)
+
+    """
+    if T is None and ZK is None:
+        raise ValueError('At least one of T or ZK must be provided.')
+    if ZK is not None:
+        _check_formal_conditions_for_maximal_order(ZK)
+    if T is None:
+        T = ZK.parent.T
+    radicals = {}
+    if dK is None or ZK is None:
+        ZK, dK = round_two(T, radicals=radicals)
+    dT = T.discriminant()
+    f_squared = dT // dK
+    if f_squared % p != 0:
+        return _prime_decomp_easy_case(p, ZK)
+    radical = radical or radicals.get(p) or nilradical_mod_p(ZK, p)
+    stack = [radical]
+    primes = []
+    while stack:
+        I = stack.pop()
+        N, G = _prime_decomp_compute_kernel(I, p, ZK)
+        if N.n == 1:
+            P = _prime_decomp_maximal_ideal(I, p, ZK)
+            primes.append(P)
+        else:
+            I1, I2 = _prime_decomp_split_ideal(I, p, N, G, ZK)
+            stack.extend([I1, I2])
+    return primes

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/resolvent_lookup.py

@@ -0,0 +1,456 @@
+"""Lookup table for Galois resolvents for polys of degree 4 through 6. """
+# This table was generated by a call to
+# `sympy.polys.numberfields.galois_resolvents.generate_lambda_lookup()`.
+# The entire job took 543.23s.
+# Of this, Case (6, 1) took 539.03s.
+# The final polynomial of Case (6, 1) alone took 455.09s.
+resolvent_coeff_lambdas = {
+    (4, 0): [
+        lambda s1, s2, s3, s4: (-2*s1*s2 + 6*s3),
+        lambda s1, s2, s3, s4: (2*s1**3*s3 + s1**2*s2**2 + s1**2*s4 - 17*s1*s2*s3 + 2*s2**3 - 8*s2*s4 + 24*s3**2),
+        lambda s1, s2, s3, s4: (-2*s1**5*s4 - 2*s1**4*s2*s3 + 10*s1**3*s2*s4 + 8*s1**3*s3**2 + 10*s1**2*s2**2*s3 -
+12*s1**2*s3*s4 - 2*s1*s2**4 - 54*s1*s2*s3**2 + 32*s1*s4**2 + 8*s2**3*s3 - 32*s2*s3*s4
++ 56*s3**3),
+        lambda s1, s2, s3, s4: (2*s1**6*s2*s4 + s1**6*s3**2 - 5*s1**5*s3*s4 - 11*s1**4*s2**2*s4 - 13*s1**4*s2*s3**2
++ 7*s1**4*s4**2 + 3*s1**3*s2**3*s3 + 30*s1**3*s2*s3*s4 + 22*s1**3*s3**3 + 10*s1**2*s2**3*s4
++ 33*s1**2*s2**2*s3**2 - 72*s1**2*s2*s4**2 - 36*s1**2*s3**2*s4 - 13*s1*s2**4*s3 +
+48*s1*s2**2*s3*s4 - 116*s1*s2*s3**3 + 144*s1*s3*s4**2 + s2**6 - 12*s2**4*s4 + 22*s2**3*s3**2
++ 48*s2**2*s4**2 - 120*s2*s3**2*s4 + 96*s3**4 - 64*s4**3),
+        lambda s1, s2, s3, s4: (-2*s1**8*s3*s4 - s1**7*s4**2 + 22*s1**6*s2*s3*s4 + 2*s1**6*s3**3 - 2*s1**5*s2**3*s4
+- s1**5*s2**2*s3**2 - 29*s1**5*s3**2*s4 - 60*s1**4*s2**2*s3*s4 - 19*s1**4*s2*s3**3
++ 38*s1**4*s3*s4**2 + 9*s1**3*s2**4*s4 + 10*s1**3*s2**3*s3**2 + 24*s1**3*s2**2*s4**2
++ 134*s1**3*s2*s3**2*s4 + 28*s1**3*s3**4 + 16*s1**3*s4**3 - s1**2*s2**5*s3 - 4*s1**2*s2**3*s3*s4
++ 34*s1**2*s2**2*s3**3 - 288*s1**2*s2*s3*s4**2 - 104*s1**2*s3**3*s4 - 19*s1*s2**4*s3**2
++ 120*s1*s2**2*s3**2*s4 - 128*s1*s2*s3**4 + 336*s1*s3**2*s4**2 + 2*s2**6*s3 - 24*s2**4*s3*s4
++ 28*s2**3*s3**3 + 96*s2**2*s3*s4**2 - 176*s2*s3**3*s4 + 96*s3**5 - 128*s3*s4**3),
+        lambda s1, s2, s3, s4: (s1**10*s4**2 - 11*s1**8*s2*s4**2 - 2*s1**8*s3**2*s4 + s1**7*s2**2*s3*s4 + 15*s1**7*s3*s4**2
++ 45*s1**6*s2**2*s4**2 + 17*s1**6*s2*s3**2*s4 + s1**6*s3**4 - 5*s1**6*s4**3 - 12*s1**5*s2**3*s3*s4
+- 133*s1**5*s2*s3*s4**2 - 22*s1**5*s3**3*s4 + s1**4*s2**5*s4 - 76*s1**4*s2**3*s4**2
+- 6*s1**4*s2**2*s3**2*s4 - 12*s1**4*s2*s3**4 + 32*s1**4*s2*s4**3 + 128*s1**4*s3**2*s4**2
++ 29*s1**3*s2**4*s3*s4 + 2*s1**3*s2**3*s3**3 + 344*s1**3*s2**2*s3*s4**2 + 48*s1**3*s2*s3**3*s4
++ 16*s1**3*s3**5 - 48*s1**3*s3*s4**3 - 4*s1**2*s2**6*s4 + 32*s1**2*s2**4*s4**2 - 134*s1**2*s2**3*s3**2*s4
++ 36*s1**2*s2**2*s3**4 - 64*s1**2*s2**2*s4**3 - 648*s1**2*s2*s3**2*s4**2 - 48*s1**2*s3**4*s4
++ 16*s1*s2**5*s3*s4 - 12*s1*s2**4*s3**3 - 128*s1*s2**3*s3*s4**2 + 296*s1*s2**2*s3**3*s4
+- 96*s1*s2*s3**5 + 256*s1*s2*s3*s4**3 + 416*s1*s3**3*s4**2 + s2**6*s3**2 - 28*s2**4*s3**2*s4
++ 16*s2**3*s3**4 + 176*s2**2*s3**2*s4**2 - 224*s2*s3**4*s4 + 64*s3**6 - 320*s3**2*s4**3)
+    ],
+    (4, 1): [
+        lambda s1, s2, s3, s4: (-s2),
+        lambda s1, s2, s3, s4: (s1*s3 - 4*s4),
+        lambda s1, s2, s3, s4: (-s1**2*s4 + 4*s2*s4 - s3**2)
+    ],
+    (5, 1): [
+        lambda s1, s2, s3, s4, s5: (-2*s1*s3 + 8*s4),
+        lambda s1, s2, s3, s4, s5: (-8*s1**3*s5 + 2*s1**2*s2*s4 + s1**2*s3**2 + 30*s1*s2*s5 - 14*s1*s3*s4 - 6*s2**2*s4
++ 2*s2*s3**2 - 50*s3*s5 + 40*s4**2),
+        lambda s1, s2, s3, s4, s5: (16*s1**4*s3*s5 - 2*s1**4*s4**2 - 2*s1**3*s2**2*s5 - 2*s1**3*s2*s3*s4 - 44*s1**3*s4*s5
+- 66*s1**2*s2*s3*s5 + 21*s1**2*s2*s4**2 + 6*s1**2*s3**2*s4 - 50*s1**2*s5**2 + 9*s1*s2**3*s5
++ 5*s1*s2**2*s3*s4 - 2*s1*s2*s3**3 + 190*s1*s2*s4*s5 + 120*s1*s3**2*s5 - 80*s1*s3*s4**2
+- 15*s2**2*s3*s5 - 40*s2**2*s4**2 + 21*s2*s3**2*s4 + 125*s2*s5**2 - 2*s3**4 - 400*s3*s4*s5
++ 160*s4**3),
+        lambda s1, s2, s3, s4, s5: (16*s1**6*s5**2 - 8*s1**5*s2*s4*s5 - 8*s1**5*s3**2*s5 + 2*s1**5*s3*s4**2 + 2*s1**4*s2**2*s3*s5
++ s1**4*s2**2*s4**2 - 120*s1**4*s2*s5**2 + 68*s1**4*s3*s4*s5 - 8*s1**4*s4**3 + 46*s1**3*s2**2*s4*s5
++ 28*s1**3*s2*s3**2*s5 - 19*s1**3*s2*s3*s4**2 + 250*s1**3*s3*s5**2 - 144*s1**3*s4**2*s5
+- 9*s1**2*s2**3*s3*s5 - 6*s1**2*s2**3*s4**2 + 3*s1**2*s2**2*s3**2*s4 + 225*s1**2*s2**2*s5**2
+- 354*s1**2*s2*s3*s4*s5 + 76*s1**2*s2*s4**3 - 70*s1**2*s3**3*s5 + 41*s1**2*s3**2*s4**2
+- 200*s1**2*s4*s5**2 - 54*s1*s2**3*s4*s5 + 45*s1*s2**2*s3**2*s5 + 30*s1*s2**2*s3*s4**2
+- 19*s1*s2*s3**3*s4 - 875*s1*s2*s3*s5**2 + 640*s1*s2*s4**2*s5 + 2*s1*s3**5 + 630*s1*s3**2*s4*s5
+- 264*s1*s3*s4**3 + 9*s2**4*s4**2 - 6*s2**3*s3**2*s4 + s2**2*s3**4 + 90*s2**2*s3*s4*s5
+- 136*s2**2*s4**3 - 50*s2*s3**3*s5 + 76*s2*s3**2*s4**2 + 500*s2*s4*s5**2 - 8*s3**4*s4
++ 625*s3**2*s5**2 - 1400*s3*s4**2*s5 + 400*s4**4),
+        lambda s1, s2, s3, s4, s5: (-32*s1**7*s3*s5**2 + 8*s1**7*s4**2*s5 + 8*s1**6*s2**2*s5**2 + 8*s1**6*s2*s3*s4*s5
+- 2*s1**6*s2*s4**3 + 48*s1**6*s4*s5**2 - 2*s1**5*s2**3*s4*s5 + 264*s1**5*s2*s3*s5**2
+- 94*s1**5*s2*s4**2*s5 - 24*s1**5*s3**2*s4*s5 + 6*s1**5*s3*s4**3 - 56*s1**5*s5**3
+- 66*s1**4*s2**3*s5**2 - 50*s1**4*s2**2*s3*s4*s5 + 19*s1**4*s2**2*s4**3 + 8*s1**4*s2*s3**3*s5
+- 2*s1**4*s2*s3**2*s4**2 - 318*s1**4*s2*s4*s5**2 - 352*s1**4*s3**2*s5**2 + 166*s1**4*s3*s4**2*s5
++ 3*s1**4*s4**4 + 15*s1**3*s2**4*s4*s5 - 2*s1**3*s2**3*s3**2*s5 - s1**3*s2**3*s3*s4**2
+- 574*s1**3*s2**2*s3*s5**2 + 347*s1**3*s2**2*s4**2*s5 + 194*s1**3*s2*s3**2*s4*s5 -
+89*s1**3*s2*s3*s4**3 + 350*s1**3*s2*s5**3 - 8*s1**3*s3**4*s5 + 4*s1**3*s3**3*s4**2
++ 1090*s1**3*s3*s4*s5**2 - 364*s1**3*s4**3*s5 + 162*s1**2*s2**4*s5**2 + 33*s1**2*s2**3*s3*s4*s5
+- 51*s1**2*s2**3*s4**3 - 32*s1**2*s2**2*s3**3*s5 + 28*s1**2*s2**2*s3**2*s4**2 + 305*s1**2*s2**2*s4*s5**2
+- 2*s1**2*s2*s3**4*s4 + 1340*s1**2*s2*s3**2*s5**2 - 901*s1**2*s2*s3*s4**2*s5 + 76*s1**2*s2*s4**4
+- 234*s1**2*s3**3*s4*s5 + 102*s1**2*s3**2*s4**3 - 750*s1**2*s3*s5**3 - 550*s1**2*s4**2*s5**2
+- 27*s1*s2**5*s4*s5 + 9*s1*s2**4*s3**2*s5 + 3*s1*s2**4*s3*s4**2 - s1*s2**3*s3**3*s4
++ 180*s1*s2**3*s3*s5**2 - 366*s1*s2**3*s4**2*s5 - 231*s1*s2**2*s3**2*s4*s5 + 212*s1*s2**2*s3*s4**3
+- 375*s1*s2**2*s5**3 + 112*s1*s2*s3**4*s5 - 89*s1*s2*s3**3*s4**2 - 3075*s1*s2*s3*s4*s5**2
++ 1640*s1*s2*s4**3*s5 + 6*s1*s3**5*s4 - 850*s1*s3**3*s5**2 + 1220*s1*s3**2*s4**2*s5
+- 384*s1*s3*s4**4 + 2500*s1*s4*s5**3 - 108*s2**5*s5**2 + 117*s2**4*s3*s4*s5 + 32*s2**4*s4**3
+- 31*s2**3*s3**3*s5 - 51*s2**3*s3**2*s4**2 + 525*s2**3*s4*s5**2 + 19*s2**2*s3**4*s4
+- 325*s2**2*s3**2*s5**2 + 260*s2**2*s3*s4**2*s5 - 256*s2**2*s4**4 - 2*s2*s3**6 + 105*s2*s3**3*s4*s5
++ 76*s2*s3**2*s4**3 + 625*s2*s3*s5**3 - 500*s2*s4**2*s5**2 - 58*s3**5*s5 + 3*s3**4*s4**2
++ 2750*s3**2*s4*s5**2 - 2400*s3*s4**3*s5 + 512*s4**5 - 3125*s5**4),
+        lambda s1, s2, s3, s4, s5: (16*s1**8*s3**2*s5**2 - 8*s1**8*s3*s4**2*s5 + s1**8*s4**4 - 8*s1**7*s2**2*s3*s5**2
++ 2*s1**7*s2**2*s4**2*s5 - 48*s1**7*s3*s4*s5**2 + 12*s1**7*s4**3*s5 + s1**6*s2**4*s5**2
++ 12*s1**6*s2**2*s4*s5**2 - 144*s1**6*s2*s3**2*s5**2 + 88*s1**6*s2*s3*s4**2*s5 - 13*s1**6*s2*s4**4
++ 56*s1**6*s3*s5**3 + 86*s1**6*s4**2*s5**2 + 72*s1**5*s2**3*s3*s5**2 - 22*s1**5*s2**3*s4**2*s5
+- 4*s1**5*s2**2*s3**2*s4*s5 + s1**5*s2**2*s3*s4**3 - 14*s1**5*s2**2*s5**3 + 304*s1**5*s2*s3*s4*s5**2
+- 148*s1**5*s2*s4**3*s5 + 152*s1**5*s3**3*s5**2 - 54*s1**5*s3**2*s4**2*s5 + 5*s1**5*s3*s4**4
+- 468*s1**5*s4*s5**3 - 9*s1**4*s2**5*s5**2 + s1**4*s2**4*s3*s4*s5 - 76*s1**4*s2**3*s4*s5**2
++ 370*s1**4*s2**2*s3**2*s5**2 - 287*s1**4*s2**2*s3*s4**2*s5 + 65*s1**4*s2**2*s4**4
+- 28*s1**4*s2*s3**3*s4*s5 + 5*s1**4*s2*s3**2*s4**3 - 200*s1**4*s2*s3*s5**3 - 294*s1**4*s2*s4**2*s5**2
++ 8*s1**4*s3**5*s5 - 2*s1**4*s3**4*s4**2 - 676*s1**4*s3**2*s4*s5**2 + 180*s1**4*s3*s4**3*s5
++ 17*s1**4*s4**5 + 625*s1**4*s5**4 - 210*s1**3*s2**4*s3*s5**2 + 76*s1**3*s2**4*s4**2*s5
++ 43*s1**3*s2**3*s3**2*s4*s5 - 15*s1**3*s2**3*s3*s4**3 + 50*s1**3*s2**3*s5**3 - 6*s1**3*s2**2*s3**4*s5
++ 2*s1**3*s2**2*s3**3*s4**2 - 397*s1**3*s2**2*s3*s4*s5**2 + 514*s1**3*s2**2*s4**3*s5
+- 700*s1**3*s2*s3**3*s5**2 + 447*s1**3*s2*s3**2*s4**2*s5 - 118*s1**3*s2*s3*s4**4 +
+2300*s1**3*s2*s4*s5**3 - 12*s1**3*s3**4*s4*s5 + 6*s1**3*s3**3*s4**3 + 250*s1**3*s3**2*s5**3
++ 1470*s1**3*s3*s4**2*s5**2 - 276*s1**3*s4**4*s5 + 27*s1**2*s2**6*s5**2 - 9*s1**2*s2**5*s3*s4*s5
++ s1**2*s2**5*s4**3 + s1**2*s2**4*s3**3*s5 + 141*s1**2*s2**4*s4*s5**2 - 185*s1**2*s2**3*s3**2*s5**2
++ 168*s1**2*s2**3*s3*s4**2*s5 - 128*s1**2*s2**3*s4**4 + 93*s1**2*s2**2*s3**3*s4*s5
++ 19*s1**2*s2**2*s3**2*s4**3 - 125*s1**2*s2**2*s3*s5**3 - 610*s1**2*s2**2*s4**2*s5**2
+- 36*s1**2*s2*s3**5*s5 + 5*s1**2*s2*s3**4*s4**2 + 1995*s1**2*s2*s3**2*s4*s5**2 - 1174*s1**2*s2*s3*s4**3*s5
+- 16*s1**2*s2*s4**5 - 3125*s1**2*s2*s5**4 + 375*s1**2*s3**4*s5**2 - 172*s1**2*s3**3*s4**2*s5
++ 82*s1**2*s3**2*s4**4 - 3500*s1**2*s3*s4*s5**3 - 1450*s1**2*s4**3*s5**2 + 198*s1*s2**5*s3*s5**2
+- 78*s1*s2**5*s4**2*s5 - 95*s1*s2**4*s3**2*s4*s5 + 44*s1*s2**4*s3*s4**3 + 25*s1*s2**3*s3**4*s5
+- 15*s1*s2**3*s3**3*s4**2 + 15*s1*s2**3*s3*s4*s5**2 - 384*s1*s2**3*s4**3*s5 + s1*s2**2*s3**5*s4
++ 525*s1*s2**2*s3**3*s5**2 - 528*s1*s2**2*s3**2*s4**2*s5 + 384*s1*s2**2*s3*s4**4 -
+1750*s1*s2**2*s4*s5**3 - 29*s1*s2*s3**4*s4*s5 - 118*s1*s2*s3**3*s4**3 + 625*s1*s2*s3**2*s5**3
+- 850*s1*s2*s3*s4**2*s5**2 + 1760*s1*s2*s4**4*s5 + 38*s1*s3**6*s5 + 5*s1*s3**5*s4**2
+- 2050*s1*s3**3*s4*s5**2 + 780*s1*s3**2*s4**3*s5 - 192*s1*s3*s4**5 + 3125*s1*s3*s5**4
++ 7500*s1*s4**2*s5**3 - 27*s2**7*s5**2 + 18*s2**6*s3*s4*s5 - 4*s2**6*s4**3 - 4*s2**5*s3**3*s5
++ s2**5*s3**2*s4**2 - 99*s2**5*s4*s5**2 - 150*s2**4*s3**2*s5**2 + 196*s2**4*s3*s4**2*s5
++ 48*s2**4*s4**4 + 12*s2**3*s3**3*s4*s5 - 128*s2**3*s3**2*s4**3 + 1200*s2**3*s4**2*s5**2
+- 12*s2**2*s3**5*s5 + 65*s2**2*s3**4*s4**2 - 725*s2**2*s3**2*s4*s5**2 - 160*s2**2*s3*s4**3*s5
+- 192*s2**2*s4**5 + 3125*s2**2*s5**4 - 13*s2*s3**6*s4 - 125*s2*s3**4*s5**2 + 590*s2*s3**3*s4**2*s5
+- 16*s2*s3**2*s4**4 - 1250*s2*s3*s4*s5**3 - 2000*s2*s4**3*s5**2 + s3**8 - 124*s3**5*s4*s5
++ 17*s3**4*s4**3 + 3250*s3**2*s4**2*s5**2 - 1600*s3*s4**4*s5 + 256*s4**6 - 9375*s4*s5**4)
+    ],
+    (6, 1): [
+        lambda s1, s2, s3, s4, s5, s6: (8*s1*s5 - 2*s2*s4 - 18*s6),
+        lambda s1, s2, s3, s4, s5, s6: (-50*s1**2*s4*s6 + 40*s1**2*s5**2 + 30*s1*s2*s3*s6 - 14*s1*s2*s4*s5 - 6*s1*s3**2*s5
++ 2*s1*s3*s4**2 - 30*s1*s5*s6 - 8*s2**3*s6 + 2*s2**2*s3*s5 + s2**2*s4**2 + 114*s2*s4*s6
+- 50*s2*s5**2 - 54*s3**2*s6 + 30*s3*s4*s5 - 8*s4**3 - 135*s6**2),
+        lambda s1, s2, s3, s4, s5, s6: (125*s1**3*s3*s6**2 - 400*s1**3*s4*s5*s6 + 160*s1**3*s5**3 - 50*s1**2*s2**2*s6**2 +
+190*s1**2*s2*s3*s5*s6 + 120*s1**2*s2*s4**2*s6 - 80*s1**2*s2*s4*s5**2 - 15*s1**2*s3**2*s4*s6
+- 40*s1**2*s3**2*s5**2 + 21*s1**2*s3*s4**2*s5 - 2*s1**2*s4**4 + 900*s1**2*s4*s6**2
+- 80*s1**2*s5**2*s6 - 44*s1*s2**3*s5*s6 - 66*s1*s2**2*s3*s4*s6 + 21*s1*s2**2*s3*s5**2
++ 6*s1*s2**2*s4**2*s5 + 9*s1*s2*s3**3*s6 + 5*s1*s2*s3**2*s4*s5 - 2*s1*s2*s3*s4**3
+- 990*s1*s2*s3*s6**2 + 920*s1*s2*s4*s5*s6 - 400*s1*s2*s5**3 - 135*s1*s3**2*s5*s6 -
+126*s1*s3*s4**2*s6 + 190*s1*s3*s4*s5**2 - 44*s1*s4**3*s5 - 2070*s1*s5*s6**2 + 16*s2**4*s4*s6
+- 2*s2**4*s5**2 - 2*s2**3*s3**2*s6 - 2*s2**3*s3*s4*s5 + 304*s2**3*s6**2 - 126*s2**2*s3*s5*s6
+- 232*s2**2*s4**2*s6 + 120*s2**2*s4*s5**2 + 198*s2*s3**2*s4*s6 - 15*s2*s3**2*s5**2
+- 66*s2*s3*s4**2*s5 + 16*s2*s4**4 - 1440*s2*s4*s6**2 + 900*s2*s5**2*s6 - 27*s3**4*s6
++ 9*s3**3*s4*s5 - 2*s3**2*s4**3 + 1350*s3**2*s6**2 - 990*s3*s4*s5*s6 + 125*s3*s5**3
++ 304*s4**3*s6 - 50*s4**2*s5**2 + 3240*s6**3),
+        lambda s1, s2, s3, s4, s5, s6: (500*s1**4*s3*s5*s6**2 + 625*s1**4*s4**2*s6**2 - 1400*s1**4*s4*s5**2*s6 + 400*s1**4*s5**4
+- 200*s1**3*s2**2*s5*s6**2 - 875*s1**3*s2*s3*s4*s6**2 + 640*s1**3*s2*s3*s5**2*s6 +
+630*s1**3*s2*s4**2*s5*s6 - 264*s1**3*s2*s4*s5**3 + 90*s1**3*s3**2*s4*s5*s6 - 136*s1**3*s3**2*s5**3
+- 50*s1**3*s3*s4**3*s6 + 76*s1**3*s3*s4**2*s5**2 - 1125*s1**3*s3*s6**3 - 8*s1**3*s4**4*s5
++ 2550*s1**3*s4*s5*s6**2 - 200*s1**3*s5**3*s6 + 250*s1**2*s2**3*s4*s6**2 - 144*s1**2*s2**3*s5**2*s6
++ 225*s1**2*s2**2*s3**2*s6**2 - 354*s1**2*s2**2*s3*s4*s5*s6 + 76*s1**2*s2**2*s3*s5**3
+- 70*s1**2*s2**2*s4**3*s6 + 41*s1**2*s2**2*s4**2*s5**2 + 450*s1**2*s2**2*s6**3 - 54*s1**2*s2*s3**3*s5*s6
++ 45*s1**2*s2*s3**2*s4**2*s6 + 30*s1**2*s2*s3**2*s4*s5**2 - 19*s1**2*s2*s3*s4**3*s5
+- 2880*s1**2*s2*s3*s5*s6**2 + 2*s1**2*s2*s4**5 - 3480*s1**2*s2*s4**2*s6**2 + 4692*s1**2*s2*s4*s5**2*s6
+- 1400*s1**2*s2*s5**4 + 9*s1**2*s3**4*s5**2 - 6*s1**2*s3**3*s4**2*s5 + s1**2*s3**2*s4**4
++ 1485*s1**2*s3**2*s4*s6**2 - 522*s1**2*s3**2*s5**2*s6 - 1257*s1**2*s3*s4**2*s5*s6
++ 640*s1**2*s3*s4*s5**3 + 218*s1**2*s4**4*s6 - 144*s1**2*s4**3*s5**2 + 1350*s1**2*s4*s6**3
+- 5175*s1**2*s5**2*s6**2 - 120*s1*s2**4*s3*s6**2 + 68*s1*s2**4*s4*s5*s6 - 8*s1*s2**4*s5**3
++ 46*s1*s2**3*s3**2*s5*s6 + 28*s1*s2**3*s3*s4**2*s6 - 19*s1*s2**3*s3*s4*s5**2 + 868*s1*s2**3*s5*s6**2
+- 9*s1*s2**2*s3**3*s4*s6 - 6*s1*s2**2*s3**3*s5**2 + 3*s1*s2**2*s3**2*s4**2*s5 + 2484*s1*s2**2*s3*s4*s6**2
+- 1257*s1*s2**2*s3*s5**2*s6 - 1356*s1*s2**2*s4**2*s5*s6 + 630*s1*s2**2*s4*s5**3 -
+891*s1*s2*s3**3*s6**2 + 882*s1*s2*s3**2*s4*s5*s6 + 90*s1*s2*s3**2*s5**3 + 84*s1*s2*s3*s4**3*s6
+- 354*s1*s2*s3*s4**2*s5**2 + 3240*s1*s2*s3*s6**3 + 68*s1*s2*s4**4*s5 - 4392*s1*s2*s4*s5*s6**2
++ 2550*s1*s2*s5**3*s6 + 54*s1*s3**4*s5*s6 - 54*s1*s3**3*s4**2*s6 - 54*s1*s3**3*s4*s5**2
++ 46*s1*s3**2*s4**3*s5 + 2727*s1*s3**2*s5*s6**2 - 8*s1*s3*s4**5 + 756*s1*s3*s4**2*s6**2
+- 2880*s1*s3*s4*s5**2*s6 + 500*s1*s3*s5**4 + 868*s1*s4**3*s5*s6 - 200*s1*s4**2*s5**3
++ 8100*s1*s5*s6**3 + 16*s2**6*s6**2 - 8*s2**5*s3*s5*s6 - 8*s2**5*s4**2*s6 + 2*s2**5*s4*s5**2
++ 2*s2**4*s3**2*s4*s6 + s2**4*s3**2*s5**2 - 688*s2**4*s4*s6**2 + 218*s2**4*s5**2*s6
++ 234*s2**3*s3**2*s6**2 + 84*s2**3*s3*s4*s5*s6 - 50*s2**3*s3*s5**3 + 168*s2**3*s4**3*s6
+- 70*s2**3*s4**2*s5**2 - 1224*s2**3*s6**3 - 54*s2**2*s3**3*s5*s6 - 144*s2**2*s3**2*s4**2*s6
++ 45*s2**2*s3**2*s4*s5**2 + 28*s2**2*s3*s4**3*s5 + 756*s2**2*s3*s5*s6**2 - 8*s2**2*s4**5
++ 4320*s2**2*s4**2*s6**2 - 3480*s2**2*s4*s5**2*s6 + 625*s2**2*s5**4 + 27*s2*s3**4*s4*s6
+- 9*s2*s3**3*s4**2*s5 + 2*s2*s3**2*s4**4 - 4752*s2*s3**2*s4*s6**2 + 1485*s2*s3**2*s5**2*s6
++ 2484*s2*s3*s4**2*s5*s6 - 875*s2*s3*s4*s5**3 - 688*s2*s4**4*s6 + 250*s2*s4**3*s5**2
+- 4536*s2*s4*s6**3 + 1350*s2*s5**2*s6**2 + 972*s3**4*s6**2 - 891*s3**3*s4*s5*s6 +
+234*s3**2*s4**3*s6 + 225*s3**2*s4**2*s5**2 - 1944*s3**2*s6**3 - 120*s3*s4**4*s5 +
+3240*s3*s4*s5*s6**2 - 1125*s3*s5**3*s6 + 16*s4**6 - 1224*s4**3*s6**2 + 450*s4**2*s5**2*s6),
+        lambda s1, s2, s3, s4, s5, s6: (-3125*s1**6*s6**4 + 2500*s1**5*s2*s5*s6**3 + 625*s1**5*s3*s4*s6**3 - 500*s1**5*s3*s5**2*s6**2
++ 2750*s1**5*s4**2*s5*s6**2 - 2400*s1**5*s4*s5**3*s6 + 512*s1**5*s5**5 - 750*s1**4*s2**2*s4*s6**3
+- 550*s1**4*s2**2*s5**2*s6**2 - 375*s1**4*s2*s3**2*s6**3 - 3075*s1**4*s2*s3*s4*s5*s6**2
++ 1640*s1**4*s2*s3*s5**3*s6 - 850*s1**4*s2*s4**3*s6**2 + 1220*s1**4*s2*s4**2*s5**2*s6
+- 384*s1**4*s2*s4*s5**4 + 22500*s1**4*s2*s6**4 + 525*s1**4*s3**3*s5*s6**2 - 325*s1**4*s3**2*s4**2*s6**2
++ 260*s1**4*s3**2*s4*s5**2*s6 - 256*s1**4*s3**2*s5**4 + 105*s1**4*s3*s4**3*s5*s6 +
+76*s1**4*s3*s4**2*s5**3 + 375*s1**4*s3*s5*s6**3 - 58*s1**4*s4**5*s6 + 3*s1**4*s4**4*s5**2
+- 12750*s1**4*s4**2*s6**3 + 3700*s1**4*s4*s5**2*s6**2 + 640*s1**4*s5**4*s6 + 350*s1**3*s2**3*s3*s6**3
++ 1090*s1**3*s2**3*s4*s5*s6**2 - 364*s1**3*s2**3*s5**3*s6 + 305*s1**3*s2**2*s3**2*s5*s6**2
++ 1340*s1**3*s2**2*s3*s4**2*s6**2 - 901*s1**3*s2**2*s3*s4*s5**2*s6 + 76*s1**3*s2**2*s3*s5**4
+- 234*s1**3*s2**2*s4**3*s5*s6 + 102*s1**3*s2**2*s4**2*s5**3 - 16650*s1**3*s2**2*s5*s6**3
++ 180*s1**3*s2*s3**3*s4*s6**2 - 366*s1**3*s2*s3**3*s5**2*s6 - 231*s1**3*s2*s3**2*s4**2*s5*s6
++ 212*s1**3*s2*s3**2*s4*s5**3 + 112*s1**3*s2*s3*s4**4*s6 - 89*s1**3*s2*s3*s4**3*s5**2
++ 10950*s1**3*s2*s3*s4*s6**3 + 1555*s1**3*s2*s3*s5**2*s6**2 + 6*s1**3*s2*s4**5*s5
+- 9540*s1**3*s2*s4**2*s5*s6**2 + 9016*s1**3*s2*s4*s5**3*s6 - 2400*s1**3*s2*s5**5 -
+108*s1**3*s3**5*s6**2 + 117*s1**3*s3**4*s4*s5*s6 + 32*s1**3*s3**4*s5**3 - 31*s1**3*s3**3*s4**3*s6
+- 51*s1**3*s3**3*s4**2*s5**2 - 2025*s1**3*s3**3*s6**3 + 19*s1**3*s3**2*s4**4*s5 +
+2955*s1**3*s3**2*s4*s5*s6**2 - 1436*s1**3*s3**2*s5**3*s6 - 2*s1**3*s3*s4**6 + 2770*s1**3*s3*s4**3*s6**2
+- 5123*s1**3*s3*s4**2*s5**2*s6 + 1640*s1**3*s3*s4*s5**4 - 40500*s1**3*s3*s6**4 + 914*s1**3*s4**4*s5*s6
+- 364*s1**3*s4**3*s5**3 + 53550*s1**3*s4*s5*s6**3 - 17930*s1**3*s5**3*s6**2 - 56*s1**2*s2**5*s6**3
+- 318*s1**2*s2**4*s3*s5*s6**2 - 352*s1**2*s2**4*s4**2*s6**2 + 166*s1**2*s2**4*s4*s5**2*s6
++ 3*s1**2*s2**4*s5**4 - 574*s1**2*s2**3*s3**2*s4*s6**2 + 347*s1**2*s2**3*s3**2*s5**2*s6
++ 194*s1**2*s2**3*s3*s4**2*s5*s6 - 89*s1**2*s2**3*s3*s4*s5**3 - 8*s1**2*s2**3*s4**4*s6
++ 4*s1**2*s2**3*s4**3*s5**2 + 560*s1**2*s2**3*s4*s6**3 + 3662*s1**2*s2**3*s5**2*s6**2
++ 162*s1**2*s2**2*s3**4*s6**2 + 33*s1**2*s2**2*s3**3*s4*s5*s6 - 51*s1**2*s2**2*s3**3*s5**3
+- 32*s1**2*s2**2*s3**2*s4**3*s6 + 28*s1**2*s2**2*s3**2*s4**2*s5**2 + 270*s1**2*s2**2*s3**2*s6**3
+- 2*s1**2*s2**2*s3*s4**4*s5 + 4872*s1**2*s2**2*s3*s4*s5*s6**2 - 5123*s1**2*s2**2*s3*s5**3*s6
++ 2144*s1**2*s2**2*s4**3*s6**2 - 2812*s1**2*s2**2*s4**2*s5**2*s6 + 1220*s1**2*s2**2*s4*s5**4
+- 37800*s1**2*s2**2*s6**4 - 27*s1**2*s2*s3**5*s5*s6 + 9*s1**2*s2*s3**4*s4**2*s6 +
+3*s1**2*s2*s3**4*s4*s5**2 - s1**2*s2*s3**3*s4**3*s5 - 3078*s1**2*s2*s3**3*s5*s6**2
+- 4014*s1**2*s2*s3**2*s4**2*s6**2 + 5412*s1**2*s2*s3**2*s4*s5**2*s6 + 260*s1**2*s2*s3**2*s5**4
+- 310*s1**2*s2*s3*s4**3*s5*s6 - 901*s1**2*s2*s3*s4**2*s5**3 - 3780*s1**2*s2*s3*s5*s6**3
++ 166*s1**2*s2*s4**4*s5**2 + 40320*s1**2*s2*s4**2*s6**3 - 25344*s1**2*s2*s4*s5**2*s6**2
++ 3700*s1**2*s2*s5**4*s6 + 918*s1**2*s3**4*s4*s6**2 + 27*s1**2*s3**4*s5**2*s6 - 342*s1**2*s3**3*s4**2*s5*s6
+- 366*s1**2*s3**3*s4*s5**3 + 32*s1**2*s3**2*s4**4*s6 + 347*s1**2*s3**2*s4**3*s5**2
+- 4590*s1**2*s3**2*s4*s6**3 + 594*s1**2*s3**2*s5**2*s6**2 - 94*s1**2*s3*s4**5*s5 +
+3618*s1**2*s3*s4**2*s5*s6**2 + 1555*s1**2*s3*s4*s5**3*s6 - 500*s1**2*s3*s5**5 + 8*s1**2*s4**7
+- 7192*s1**2*s4**4*s6**2 + 3662*s1**2*s4**3*s5**2*s6 - 550*s1**2*s4**2*s5**4 - 48600*s1**2*s4*s6**4
++ 1080*s1**2*s5**2*s6**3 + 48*s1*s2**6*s5*s6**2 + 264*s1*s2**5*s3*s4*s6**2 - 94*s1*s2**5*s3*s5**2*s6
+- 24*s1*s2**5*s4**2*s5*s6 + 6*s1*s2**5*s4*s5**3 - 66*s1*s2**4*s3**3*s6**2 - 50*s1*s2**4*s3**2*s4*s5*s6
++ 19*s1*s2**4*s3**2*s5**3 + 8*s1*s2**4*s3*s4**3*s6 - 2*s1*s2**4*s3*s4**2*s5**2 - 552*s1*s2**4*s3*s6**3
+- 2560*s1*s2**4*s4*s5*s6**2 + 914*s1*s2**4*s5**3*s6 + 15*s1*s2**3*s3**4*s5*s6 - 2*s1*s2**3*s3**3*s4**2*s6
+- s1*s2**3*s3**3*s4*s5**2 + 1602*s1*s2**3*s3**2*s5*s6**2 - 608*s1*s2**3*s3*s4**2*s6**2
+- 310*s1*s2**3*s3*s4*s5**2*s6 + 105*s1*s2**3*s3*s5**4 + 600*s1*s2**3*s4**3*s5*s6 -
+234*s1*s2**3*s4**2*s5**3 + 31368*s1*s2**3*s5*s6**3 + 756*s1*s2**2*s3**3*s4*s6**2 -
+342*s1*s2**2*s3**3*s5**2*s6 + 216*s1*s2**2*s3**2*s4**2*s5*s6 - 231*s1*s2**2*s3**2*s4*s5**3
+- 192*s1*s2**2*s3*s4**4*s6 + 194*s1*s2**2*s3*s4**3*s5**2 - 39096*s1*s2**2*s3*s4*s6**3
++ 3618*s1*s2**2*s3*s5**2*s6**2 - 24*s1*s2**2*s4**5*s5 + 9408*s1*s2**2*s4**2*s5*s6**2
+- 9540*s1*s2**2*s4*s5**3*s6 + 2750*s1*s2**2*s5**5 - 162*s1*s2*s3**5*s6**2 - 378*s1*s2*s3**4*s4*s5*s6
++ 117*s1*s2*s3**4*s5**3 + 150*s1*s2*s3**3*s4**3*s6 + 33*s1*s2*s3**3*s4**2*s5**2 +
+10044*s1*s2*s3**3*s6**3 - 50*s1*s2*s3**2*s4**4*s5 - 8640*s1*s2*s3**2*s4*s5*s6**2 +
+2955*s1*s2*s3**2*s5**3*s6 + 8*s1*s2*s3*s4**6 + 6144*s1*s2*s3*s4**3*s6**2 + 4872*s1*s2*s3*s4**2*s5**2*s6
+- 3075*s1*s2*s3*s4*s5**4 + 174960*s1*s2*s3*s6**4 - 2560*s1*s2*s4**4*s5*s6 + 1090*s1*s2*s4**3*s5**3
+- 148824*s1*s2*s4*s5*s6**3 + 53550*s1*s2*s5**3*s6**2 + 81*s1*s3**6*s5*s6 - 27*s1*s3**5*s4**2*s6
+- 27*s1*s3**5*s4*s5**2 + 15*s1*s3**4*s4**3*s5 + 2430*s1*s3**4*s5*s6**2 - 2*s1*s3**3*s4**5
+- 2052*s1*s3**3*s4**2*s6**2 - 3078*s1*s3**3*s4*s5**2*s6 + 525*s1*s3**3*s5**4 + 1602*s1*s3**2*s4**3*s5*s6
++ 305*s1*s3**2*s4**2*s5**3 + 18144*s1*s3**2*s5*s6**3 - 104*s1*s3*s4**5*s6 - 318*s1*s3*s4**4*s5**2
+- 33696*s1*s3*s4**2*s6**3 - 3780*s1*s3*s4*s5**2*s6**2 + 375*s1*s3*s5**4*s6 + 48*s1*s4**6*s5
++ 31368*s1*s4**3*s5*s6**2 - 16650*s1*s4**2*s5**3*s6 + 2500*s1*s4*s5**5 + 77760*s1*s5*s6**4
+- 32*s2**7*s4*s6**2 + 8*s2**7*s5**2*s6 + 8*s2**6*s3**2*s6**2 + 8*s2**6*s3*s4*s5*s6
+- 2*s2**6*s3*s5**3 + 96*s2**6*s6**3 - 2*s2**5*s3**3*s5*s6 - 104*s2**5*s3*s5*s6**2
++ 416*s2**5*s4**2*s6**2 - 58*s2**5*s5**4 - 312*s2**4*s3**2*s4*s6**2 + 32*s2**4*s3**2*s5**2*s6
+- 192*s2**4*s3*s4**2*s5*s6 + 112*s2**4*s3*s4*s5**3 - 8*s2**4*s4**3*s5**2 + 4224*s2**4*s4*s6**3
+- 7192*s2**4*s5**2*s6**2 + 54*s2**3*s3**4*s6**2 + 150*s2**3*s3**3*s4*s5*s6 - 31*s2**3*s3**3*s5**3
+- 32*s2**3*s3**2*s4**2*s5**2 - 864*s2**3*s3**2*s6**3 + 8*s2**3*s3*s4**4*s5 + 6144*s2**3*s3*s4*s5*s6**2
++ 2770*s2**3*s3*s5**3*s6 - 4032*s2**3*s4**3*s6**2 + 2144*s2**3*s4**2*s5**2*s6 - 850*s2**3*s4*s5**4
+- 16416*s2**3*s6**4 - 27*s2**2*s3**5*s5*s6 + 9*s2**2*s3**4*s4*s5**2 - 2*s2**2*s3**3*s4**3*s5
+- 2052*s2**2*s3**3*s5*s6**2 + 2376*s2**2*s3**2*s4**2*s6**2 - 4014*s2**2*s3**2*s4*s5**2*s6
+- 325*s2**2*s3**2*s5**4 - 608*s2**2*s3*s4**3*s5*s6 + 1340*s2**2*s3*s4**2*s5**3 - 33696*s2**2*s3*s5*s6**3
++ 416*s2**2*s4**5*s6 - 352*s2**2*s4**4*s5**2 - 6048*s2**2*s4**2*s6**3 + 40320*s2**2*s4*s5**2*s6**2
+- 12750*s2**2*s5**4*s6 - 324*s2*s3**4*s4*s6**2 + 918*s2*s3**4*s5**2*s6 + 756*s2*s3**3*s4**2*s5*s6
++ 180*s2*s3**3*s4*s5**3 - 312*s2*s3**2*s4**4*s6 - 574*s2*s3**2*s4**3*s5**2 + 43416*s2*s3**2*s4*s6**3
+- 4590*s2*s3**2*s5**2*s6**2 + 264*s2*s3*s4**5*s5 - 39096*s2*s3*s4**2*s5*s6**2 + 10950*s2*s3*s4*s5**3*s6
++ 625*s2*s3*s5**5 - 32*s2*s4**7 + 4224*s2*s4**4*s6**2 + 560*s2*s4**3*s5**2*s6 - 750*s2*s4**2*s5**4
++ 85536*s2*s4*s6**4 - 48600*s2*s5**2*s6**3 - 162*s3**5*s4*s5*s6 - 108*s3**5*s5**3
++ 54*s3**4*s4**3*s6 + 162*s3**4*s4**2*s5**2 - 11664*s3**4*s6**3 - 66*s3**3*s4**4*s5
++ 10044*s3**3*s4*s5*s6**2 - 2025*s3**3*s5**3*s6 + 8*s3**2*s4**6 - 864*s3**2*s4**3*s6**2
++ 270*s3**2*s4**2*s5**2*s6 - 375*s3**2*s4*s5**4 - 163296*s3**2*s6**4 - 552*s3*s4**4*s5*s6
++ 350*s3*s4**3*s5**3 + 174960*s3*s4*s5*s6**3 - 40500*s3*s5**3*s6**2 + 96*s4**6*s6
+- 56*s4**5*s5**2 - 16416*s4**3*s6**3 - 37800*s4**2*s5**2*s6**2 + 22500*s4*s5**4*s6
+- 3125*s5**6 - 93312*s6**5),
+        lambda s1, s2, s3, s4, s5, s6: (-9375*s1**7*s5*s6**4 + 3125*s1**6*s2*s4*s6**4 + 7500*s1**6*s2*s5**2*s6**3 + 3125*s1**6*s3**2*s6**4
+- 1250*s1**6*s3*s4*s5*s6**3 - 2000*s1**6*s3*s5**3*s6**2 + 3250*s1**6*s4**2*s5**2*s6**2
+- 1600*s1**6*s4*s5**4*s6 + 256*s1**6*s5**6 + 40625*s1**6*s6**5 - 3125*s1**5*s2**2*s3*s6**4
+- 3500*s1**5*s2**2*s4*s5*s6**3 - 1450*s1**5*s2**2*s5**3*s6**2 - 1750*s1**5*s2*s3**2*s5*s6**3
++ 625*s1**5*s2*s3*s4**2*s6**3 - 850*s1**5*s2*s3*s4*s5**2*s6**2 + 1760*s1**5*s2*s3*s5**4*s6
+- 2050*s1**5*s2*s4**3*s5*s6**2 + 780*s1**5*s2*s4**2*s5**3*s6 - 192*s1**5*s2*s4*s5**5
++ 35000*s1**5*s2*s5*s6**4 + 1200*s1**5*s3**3*s5**2*s6**2 - 725*s1**5*s3**2*s4**2*s5*s6**2
+- 160*s1**5*s3**2*s4*s5**3*s6 - 192*s1**5*s3**2*s5**5 - 125*s1**5*s3*s4**4*s6**2 +
+590*s1**5*s3*s4**3*s5**2*s6 - 16*s1**5*s3*s4**2*s5**4 - 20625*s1**5*s3*s4*s6**4 +
+17250*s1**5*s3*s5**2*s6**3 - 124*s1**5*s4**5*s5*s6 + 17*s1**5*s4**4*s5**3 - 20250*s1**5*s4**2*s5*s6**3
++ 1900*s1**5*s4*s5**3*s6**2 + 1344*s1**5*s5**5*s6 + 625*s1**4*s2**4*s6**4 + 2300*s1**4*s2**3*s3*s5*s6**3
++ 250*s1**4*s2**3*s4**2*s6**3 + 1470*s1**4*s2**3*s4*s5**2*s6**2 - 276*s1**4*s2**3*s5**4*s6
+- 125*s1**4*s2**2*s3**2*s4*s6**3 - 610*s1**4*s2**2*s3**2*s5**2*s6**2 + 1995*s1**4*s2**2*s3*s4**2*s5*s6**2
+- 1174*s1**4*s2**2*s3*s4*s5**3*s6 - 16*s1**4*s2**2*s3*s5**5 + 375*s1**4*s2**2*s4**4*s6**2
+- 172*s1**4*s2**2*s4**3*s5**2*s6 + 82*s1**4*s2**2*s4**2*s5**4 - 7750*s1**4*s2**2*s4*s6**4
+- 46650*s1**4*s2**2*s5**2*s6**3 + 15*s1**4*s2*s3**3*s4*s5*s6**2 - 384*s1**4*s2*s3**3*s5**3*s6
++ 525*s1**4*s2*s3**2*s4**3*s6**2 - 528*s1**4*s2*s3**2*s4**2*s5**2*s6 + 384*s1**4*s2*s3**2*s4*s5**4
+- 10125*s1**4*s2*s3**2*s6**4 - 29*s1**4*s2*s3*s4**4*s5*s6 - 118*s1**4*s2*s3*s4**3*s5**3
++ 36700*s1**4*s2*s3*s4*s5*s6**3 + 2410*s1**4*s2*s3*s5**3*s6**2 + 38*s1**4*s2*s4**6*s6
++ 5*s1**4*s2*s4**5*s5**2 + 5550*s1**4*s2*s4**3*s6**3 - 10040*s1**4*s2*s4**2*s5**2*s6**2
++ 5800*s1**4*s2*s4*s5**4*s6 - 1600*s1**4*s2*s5**6 - 292500*s1**4*s2*s6**5 - 99*s1**4*s3**5*s5*s6**2
+- 150*s1**4*s3**4*s4**2*s6**2 + 196*s1**4*s3**4*s4*s5**2*s6 + 48*s1**4*s3**4*s5**4
++ 12*s1**4*s3**3*s4**3*s5*s6 - 128*s1**4*s3**3*s4**2*s5**3 - 6525*s1**4*s3**3*s5*s6**3
+- 12*s1**4*s3**2*s4**5*s6 + 65*s1**4*s3**2*s4**4*s5**2 + 225*s1**4*s3**2*s4**2*s6**3
++ 80*s1**4*s3**2*s4*s5**2*s6**2 - 13*s1**4*s3*s4**6*s5 + 5145*s1**4*s3*s4**3*s5*s6**2
+- 6746*s1**4*s3*s4**2*s5**3*s6 + 1760*s1**4*s3*s4*s5**5 - 103500*s1**4*s3*s5*s6**4
++ s1**4*s4**8 + 954*s1**4*s4**5*s6**2 + 449*s1**4*s4**4*s5**2*s6 - 276*s1**4*s4**3*s5**4
++ 70125*s1**4*s4**2*s6**4 + 58900*s1**4*s4*s5**2*s6**3 - 23310*s1**4*s5**4*s6**2 -
+468*s1**3*s2**5*s5*s6**3 - 200*s1**3*s2**4*s3*s4*s6**3 - 294*s1**3*s2**4*s3*s5**2*s6**2
+- 676*s1**3*s2**4*s4**2*s5*s6**2 + 180*s1**3*s2**4*s4*s5**3*s6 + 17*s1**3*s2**4*s5**5
++ 50*s1**3*s2**3*s3**3*s6**3 - 397*s1**3*s2**3*s3**2*s4*s5*s6**2 + 514*s1**3*s2**3*s3**2*s5**3*s6
+- 700*s1**3*s2**3*s3*s4**3*s6**2 + 447*s1**3*s2**3*s3*s4**2*s5**2*s6 - 118*s1**3*s2**3*s3*s4*s5**4
++ 11700*s1**3*s2**3*s3*s6**4 - 12*s1**3*s2**3*s4**4*s5*s6 + 6*s1**3*s2**3*s4**3*s5**3
++ 10360*s1**3*s2**3*s4*s5*s6**3 + 11404*s1**3*s2**3*s5**3*s6**2 + 141*s1**3*s2**2*s3**4*s5*s6**2
+- 185*s1**3*s2**2*s3**3*s4**2*s6**2 + 168*s1**3*s2**2*s3**3*s4*s5**2*s6 - 128*s1**3*s2**2*s3**3*s5**4
++ 93*s1**3*s2**2*s3**2*s4**3*s5*s6 + 19*s1**3*s2**2*s3**2*s4**2*s5**3 + 5895*s1**3*s2**2*s3**2*s5*s6**3
+- 36*s1**3*s2**2*s3*s4**5*s6 + 5*s1**3*s2**2*s3*s4**4*s5**2 - 12020*s1**3*s2**2*s3*s4**2*s6**3
+- 5698*s1**3*s2**2*s3*s4*s5**2*s6**2 - 6746*s1**3*s2**2*s3*s5**4*s6 + 5064*s1**3*s2**2*s4**3*s5*s6**2
+- 762*s1**3*s2**2*s4**2*s5**3*s6 + 780*s1**3*s2**2*s4*s5**5 + 93900*s1**3*s2**2*s5*s6**4
++ 198*s1**3*s2*s3**5*s4*s6**2 - 78*s1**3*s2*s3**5*s5**2*s6 - 95*s1**3*s2*s3**4*s4**2*s5*s6
++ 44*s1**3*s2*s3**4*s4*s5**3 + 25*s1**3*s2*s3**3*s4**4*s6 - 15*s1**3*s2*s3**3*s4**3*s5**2
++ 1935*s1**3*s2*s3**3*s4*s6**3 - 2808*s1**3*s2*s3**3*s5**2*s6**2 + s1**3*s2*s3**2*s4**5*s5
+- 4844*s1**3*s2*s3**2*s4**2*s5*s6**2 + 8996*s1**3*s2*s3**2*s4*s5**3*s6 - 160*s1**3*s2*s3**2*s5**5
+- 3616*s1**3*s2*s3*s4**4*s6**2 + 500*s1**3*s2*s3*s4**3*s5**2*s6 - 1174*s1**3*s2*s3*s4**2*s5**4
++ 72900*s1**3*s2*s3*s4*s6**4 - 55665*s1**3*s2*s3*s5**2*s6**3 + 128*s1**3*s2*s4**5*s5*s6
++ 180*s1**3*s2*s4**4*s5**3 + 16240*s1**3*s2*s4**2*s5*s6**3 - 9330*s1**3*s2*s4*s5**3*s6**2
++ 1900*s1**3*s2*s5**5*s6 - 27*s1**3*s3**7*s6**2 + 18*s1**3*s3**6*s4*s5*s6 - 4*s1**3*s3**6*s5**3
+- 4*s1**3*s3**5*s4**3*s6 + s1**3*s3**5*s4**2*s5**2 + 54*s1**3*s3**5*s6**3 + 1143*s1**3*s3**4*s4*s5*s6**2
+- 820*s1**3*s3**4*s5**3*s6 + 923*s1**3*s3**3*s4**3*s6**2 + 57*s1**3*s3**3*s4**2*s5**2*s6
+- 384*s1**3*s3**3*s4*s5**4 + 29700*s1**3*s3**3*s6**4 - 547*s1**3*s3**2*s4**4*s5*s6
++ 514*s1**3*s3**2*s4**3*s5**3 - 10305*s1**3*s3**2*s4*s5*s6**3 - 7405*s1**3*s3**2*s5**3*s6**2
++ 108*s1**3*s3*s4**6*s6 - 148*s1**3*s3*s4**5*s5**2 - 11360*s1**3*s3*s4**3*s6**3 +
+22209*s1**3*s3*s4**2*s5**2*s6**2 + 2410*s1**3*s3*s4*s5**4*s6 - 2000*s1**3*s3*s5**6
++ 432000*s1**3*s3*s6**5 + 12*s1**3*s4**7*s5 - 22624*s1**3*s4**4*s5*s6**2 + 11404*s1**3*s4**3*s5**3*s6
+- 1450*s1**3*s4**2*s5**5 - 242100*s1**3*s4*s5*s6**4 + 58430*s1**3*s5**3*s6**3 + 56*s1**2*s2**6*s4*s6**3
++ 86*s1**2*s2**6*s5**2*s6**2 - 14*s1**2*s2**5*s3**2*s6**3 + 304*s1**2*s2**5*s3*s4*s5*s6**2
+- 148*s1**2*s2**5*s3*s5**3*s6 + 152*s1**2*s2**5*s4**3*s6**2 - 54*s1**2*s2**5*s4**2*s5**2*s6
++ 5*s1**2*s2**5*s4*s5**4 - 2472*s1**2*s2**5*s6**4 - 76*s1**2*s2**4*s3**3*s5*s6**2
++ 370*s1**2*s2**4*s3**2*s4**2*s6**2 - 287*s1**2*s2**4*s3**2*s4*s5**2*s6 + 65*s1**2*s2**4*s3**2*s5**4
+- 28*s1**2*s2**4*s3*s4**3*s5*s6 + 5*s1**2*s2**4*s3*s4**2*s5**3 - 8092*s1**2*s2**4*s3*s5*s6**3
++ 8*s1**2*s2**4*s4**5*s6 - 2*s1**2*s2**4*s4**4*s5**2 + 1096*s1**2*s2**4*s4**2*s6**3
+- 5144*s1**2*s2**4*s4*s5**2*s6**2 + 449*s1**2*s2**4*s5**4*s6 - 210*s1**2*s2**3*s3**4*s4*s6**2
++ 76*s1**2*s2**3*s3**4*s5**2*s6 + 43*s1**2*s2**3*s3**3*s4**2*s5*s6 - 15*s1**2*s2**3*s3**3*s4*s5**3
+- 6*s1**2*s2**3*s3**2*s4**4*s6 + 2*s1**2*s2**3*s3**2*s4**3*s5**2 + 1962*s1**2*s2**3*s3**2*s4*s6**3
++ 3181*s1**2*s2**3*s3**2*s5**2*s6**2 + 1684*s1**2*s2**3*s3*s4**2*s5*s6**2 + 500*s1**2*s2**3*s3*s4*s5**3*s6
++ 590*s1**2*s2**3*s3*s5**5 - 168*s1**2*s2**3*s4**4*s6**2 - 494*s1**2*s2**3*s4**3*s5**2*s6
+- 172*s1**2*s2**3*s4**2*s5**4 - 22080*s1**2*s2**3*s4*s6**4 + 58894*s1**2*s2**3*s5**2*s6**3
++ 27*s1**2*s2**2*s3**6*s6**2 - 9*s1**2*s2**2*s3**5*s4*s5*s6 + s1**2*s2**2*s3**5*s5**3
++ s1**2*s2**2*s3**4*s4**3*s6 - 486*s1**2*s2**2*s3**4*s6**3 + 1071*s1**2*s2**2*s3**3*s4*s5*s6**2
++ 57*s1**2*s2**2*s3**3*s5**3*s6 + 2262*s1**2*s2**2*s3**2*s4**3*s6**2 - 2742*s1**2*s2**2*s3**2*s4**2*s5**2*s6
+- 528*s1**2*s2**2*s3**2*s4*s5**4 - 29160*s1**2*s2**2*s3**2*s6**4 + 772*s1**2*s2**2*s3*s4**4*s5*s6
++ 447*s1**2*s2**2*s3*s4**3*s5**3 - 96732*s1**2*s2**2*s3*s4*s5*s6**3 + 22209*s1**2*s2**2*s3*s5**3*s6**2
+- 160*s1**2*s2**2*s4**6*s6 - 54*s1**2*s2**2*s4**5*s5**2 - 7992*s1**2*s2**2*s4**3*s6**3
++ 8634*s1**2*s2**2*s4**2*s5**2*s6**2 - 10040*s1**2*s2**2*s4*s5**4*s6 + 3250*s1**2*s2**2*s5**6
++ 529200*s1**2*s2**2*s6**5 - 351*s1**2*s2*s3**5*s5*s6**2 - 1215*s1**2*s2*s3**4*s4**2*s6**2
+- 360*s1**2*s2*s3**4*s4*s5**2*s6 + 196*s1**2*s2*s3**4*s5**4 + 741*s1**2*s2*s3**3*s4**3*s5*s6
++ 168*s1**2*s2*s3**3*s4**2*s5**3 + 11718*s1**2*s2*s3**3*s5*s6**3 - 106*s1**2*s2*s3**2*s4**5*s6
+- 287*s1**2*s2*s3**2*s4**4*s5**2 + 22572*s1**2*s2*s3**2*s4**2*s6**3 - 8892*s1**2*s2*s3**2*s4*s5**2*s6**2
++ 80*s1**2*s2*s3**2*s5**4*s6 + 88*s1**2*s2*s3*s4**6*s5 + 22144*s1**2*s2*s3*s4**3*s5*s6**2
+- 5698*s1**2*s2*s3*s4**2*s5**3*s6 - 850*s1**2*s2*s3*s4*s5**5 + 169560*s1**2*s2*s3*s5*s6**4
+- 8*s1**2*s2*s4**8 + 3032*s1**2*s2*s4**5*s6**2 - 5144*s1**2*s2*s4**4*s5**2*s6 + 1470*s1**2*s2*s4**3*s5**4
+- 249480*s1**2*s2*s4**2*s6**4 - 105390*s1**2*s2*s4*s5**2*s6**3 + 58900*s1**2*s2*s5**4*s6**2
++ 162*s1**2*s3**6*s4*s6**2 + 216*s1**2*s3**6*s5**2*s6 - 216*s1**2*s3**5*s4**2*s5*s6
+- 78*s1**2*s3**5*s4*s5**3 + 36*s1**2*s3**4*s4**4*s6 + 76*s1**2*s3**4*s4**3*s5**2 -
+3564*s1**2*s3**4*s4*s6**3 + 8802*s1**2*s3**4*s5**2*s6**2 - 22*s1**2*s3**3*s4**5*s5
+- 11475*s1**2*s3**3*s4**2*s5*s6**2 - 2808*s1**2*s3**3*s4*s5**3*s6 + 1200*s1**2*s3**3*s5**5
++ 2*s1**2*s3**2*s4**7 + 222*s1**2*s3**2*s4**4*s6**2 + 3181*s1**2*s3**2*s4**3*s5**2*s6
+- 610*s1**2*s3**2*s4**2*s5**4 - 165240*s1**2*s3**2*s4*s6**4 + 118260*s1**2*s3**2*s5**2*s6**3
++ 572*s1**2*s3*s4**5*s5*s6 - 294*s1**2*s3*s4**4*s5**3 - 32616*s1**2*s3*s4**2*s5*s6**3
+- 55665*s1**2*s3*s4*s5**3*s6**2 + 17250*s1**2*s3*s5**5*s6 - 232*s1**2*s4**7*s6 + 86*s1**2*s4**6*s5**2
++ 48408*s1**2*s4**4*s6**3 + 58894*s1**2*s4**3*s5**2*s6**2 - 46650*s1**2*s4**2*s5**4*s6
++ 7500*s1**2*s4*s5**6 - 129600*s1**2*s4*s6**5 + 41040*s1**2*s5**2*s6**4 - 48*s1*s2**7*s4*s5*s6**2
++ 12*s1*s2**7*s5**3*s6 + 12*s1*s2**6*s3**2*s5*s6**2 - 144*s1*s2**6*s3*s4**2*s6**2
++ 88*s1*s2**6*s3*s4*s5**2*s6 - 13*s1*s2**6*s3*s5**4 + 1680*s1*s2**6*s5*s6**3 + 72*s1*s2**5*s3**3*s4*s6**2
+- 22*s1*s2**5*s3**3*s5**2*s6 - 4*s1*s2**5*s3**2*s4**2*s5*s6 + s1*s2**5*s3**2*s4*s5**3
+- 144*s1*s2**5*s3*s4*s6**3 + 572*s1*s2**5*s3*s5**2*s6**2 + 736*s1*s2**5*s4**2*s5*s6**2
++ 128*s1*s2**5*s4*s5**3*s6 - 124*s1*s2**5*s5**5 - 9*s1*s2**4*s3**5*s6**2 + s1*s2**4*s3**4*s4*s5*s6
++ 36*s1*s2**4*s3**3*s6**3 - 2028*s1*s2**4*s3**2*s4*s5*s6**2 - 547*s1*s2**4*s3**2*s5**3*s6
+- 480*s1*s2**4*s3*s4**3*s6**2 + 772*s1*s2**4*s3*s4**2*s5**2*s6 - 29*s1*s2**4*s3*s4*s5**4
++ 6336*s1*s2**4*s3*s6**4 - 12*s1*s2**4*s4**3*s5**3 + 4368*s1*s2**4*s4*s5*s6**3 - 22624*s1*s2**4*s5**3*s6**2
++ 441*s1*s2**3*s3**4*s5*s6**2 + 336*s1*s2**3*s3**3*s4**2*s6**2 + 741*s1*s2**3*s3**3*s4*s5**2*s6
++ 12*s1*s2**3*s3**3*s5**4 - 868*s1*s2**3*s3**2*s4**3*s5*s6 + 93*s1*s2**3*s3**2*s4**2*s5**3
++ 11016*s1*s2**3*s3**2*s5*s6**3 + 176*s1*s2**3*s3*s4**5*s6 - 28*s1*s2**3*s3*s4**4*s5**2
++ 14784*s1*s2**3*s3*s4**2*s6**3 + 22144*s1*s2**3*s3*s4*s5**2*s6**2 + 5145*s1*s2**3*s3*s5**4*s6
+- 11344*s1*s2**3*s4**3*s5*s6**2 + 5064*s1*s2**3*s4**2*s5**3*s6 - 2050*s1*s2**3*s4*s5**5
+- 346896*s1*s2**3*s5*s6**4 - 54*s1*s2**2*s3**5*s4*s6**2 - 216*s1*s2**2*s3**5*s5**2*s6
++ 324*s1*s2**2*s3**4*s4**2*s5*s6 - 95*s1*s2**2*s3**4*s4*s5**3 - 80*s1*s2**2*s3**3*s4**4*s6
++ 43*s1*s2**2*s3**3*s4**3*s5**2 - 12204*s1*s2**2*s3**3*s4*s6**3 - 11475*s1*s2**2*s3**3*s5**2*s6**2
+- 4*s1*s2**2*s3**2*s4**5*s5 - 3888*s1*s2**2*s3**2*s4**2*s5*s6**2 - 4844*s1*s2**2*s3**2*s4*s5**3*s6
+- 725*s1*s2**2*s3**2*s5**5 - 1312*s1*s2**2*s3*s4**4*s6**2 + 1684*s1*s2**2*s3*s4**3*s5**2*s6
++ 1995*s1*s2**2*s3*s4**2*s5**4 + 139104*s1*s2**2*s3*s4*s6**4 - 32616*s1*s2**2*s3*s5**2*s6**3
++ 736*s1*s2**2*s4**5*s5*s6 - 676*s1*s2**2*s4**4*s5**3 + 131040*s1*s2**2*s4**2*s5*s6**3
++ 16240*s1*s2**2*s4*s5**3*s6**2 - 20250*s1*s2**2*s5**5*s6 - 27*s1*s2*s3**6*s4*s5*s6
++ 18*s1*s2*s3**6*s5**3 + 9*s1*s2*s3**5*s4**3*s6 - 9*s1*s2*s3**5*s4**2*s5**2 + 1944*s1*s2*s3**5*s6**3
++ s1*s2*s3**4*s4**4*s5 + 6156*s1*s2*s3**4*s4*s5*s6**2 + 1143*s1*s2*s3**4*s5**3*s6
++ 324*s1*s2*s3**3*s4**3*s6**2 + 1071*s1*s2*s3**3*s4**2*s5**2*s6 + 15*s1*s2*s3**3*s4*s5**4
+- 7776*s1*s2*s3**3*s6**4 - 2028*s1*s2*s3**2*s4**4*s5*s6 - 397*s1*s2*s3**2*s4**3*s5**3
++ 112860*s1*s2*s3**2*s4*s5*s6**3 - 10305*s1*s2*s3**2*s5**3*s6**2 + 336*s1*s2*s3*s4**6*s6
++ 304*s1*s2*s3*s4**5*s5**2 - 68976*s1*s2*s3*s4**3*s6**3 - 96732*s1*s2*s3*s4**2*s5**2*s6**2
++ 36700*s1*s2*s3*s4*s5**4*s6 - 1250*s1*s2*s3*s5**6 - 1477440*s1*s2*s3*s6**5 - 48*s1*s2*s4**7*s5
++ 4368*s1*s2*s4**4*s5*s6**2 + 10360*s1*s2*s4**3*s5**3*s6 - 3500*s1*s2*s4**2*s5**5
++ 935280*s1*s2*s4*s5*s6**4 - 242100*s1*s2*s5**3*s6**3 - 972*s1*s3**6*s5*s6**2 - 351*s1*s3**5*s4*s5**2*s6
+- 99*s1*s3**5*s5**4 + 441*s1*s3**4*s4**3*s5*s6 + 141*s1*s3**4*s4**2*s5**3 - 36936*s1*s3**4*s5*s6**3
+- 84*s1*s3**3*s4**5*s6 - 76*s1*s3**3*s4**4*s5**2 + 17496*s1*s3**3*s4**2*s6**3 + 11718*s1*s3**3*s4*s5**2*s6**2
+- 6525*s1*s3**3*s5**4*s6 + 12*s1*s3**2*s4**6*s5 + 11016*s1*s3**2*s4**3*s5*s6**2 +
+5895*s1*s3**2*s4**2*s5**3*s6 - 1750*s1*s3**2*s4*s5**5 - 252720*s1*s3**2*s5*s6**4 -
+2544*s1*s3*s4**5*s6**2 - 8092*s1*s3*s4**4*s5**2*s6 + 2300*s1*s3*s4**3*s5**4 + 536544*s1*s3*s4**2*s6**4
++ 169560*s1*s3*s4*s5**2*s6**3 - 103500*s1*s3*s5**4*s6**2 + 1680*s1*s4**6*s5*s6 - 468*s1*s4**5*s5**3
+- 346896*s1*s4**3*s5*s6**3 + 93900*s1*s4**2*s5**3*s6**2 + 35000*s1*s4*s5**5*s6 - 9375*s1*s5**7
++ 108864*s1*s5*s6**5 + 16*s2**8*s4**2*s6**2 - 8*s2**8*s4*s5**2*s6 + s2**8*s5**4 -
+8*s2**7*s3**2*s4*s6**2 + 2*s2**7*s3**2*s5**2*s6 - 96*s2**7*s4*s6**3 - 232*s2**7*s5**2*s6**2
++ s2**6*s3**4*s6**2 + 24*s2**6*s3**2*s6**3 + 336*s2**6*s3*s4*s5*s6**2 + 108*s2**6*s3*s5**3*s6
+- 32*s2**6*s4**3*s6**2 - 160*s2**6*s4**2*s5**2*s6 + 38*s2**6*s4*s5**4 + 144*s2**6*s6**4
+- 84*s2**5*s3**3*s5*s6**2 + 8*s2**5*s3**2*s4**2*s6**2 - 106*s2**5*s3**2*s4*s5**2*s6
+- 12*s2**5*s3**2*s5**4 + 176*s2**5*s3*s4**3*s5*s6 - 36*s2**5*s3*s4**2*s5**3 - 2544*s2**5*s3*s5*s6**3
+- 32*s2**5*s4**5*s6 + 8*s2**5*s4**4*s5**2 - 3072*s2**5*s4**2*s6**3 + 3032*s2**5*s4*s5**2*s6**2
++ 954*s2**5*s5**4*s6 + 36*s2**4*s3**4*s5**2*s6 - 80*s2**4*s3**3*s4**2*s5*s6 + 25*s2**4*s3**3*s4*s5**3
++ 16*s2**4*s3**2*s4**4*s6 - 6*s2**4*s3**2*s4**3*s5**2 + 2520*s2**4*s3**2*s4*s6**3
++ 222*s2**4*s3**2*s5**2*s6**2 - 1312*s2**4*s3*s4**2*s5*s6**2 - 3616*s2**4*s3*s4*s5**3*s6
+- 125*s2**4*s3*s5**5 + 1296*s2**4*s4**4*s6**2 - 168*s2**4*s4**3*s5**2*s6 + 375*s2**4*s4**2*s5**4
++ 19296*s2**4*s4*s6**4 + 48408*s2**4*s5**2*s6**3 + 9*s2**3*s3**5*s4*s5*s6 - 4*s2**3*s3**5*s5**3
+- 2*s2**3*s3**4*s4**3*s6 + s2**3*s3**4*s4**2*s5**2 - 432*s2**3*s3**4*s6**3 + 324*s2**3*s3**3*s4*s5*s6**2
++ 923*s2**3*s3**3*s5**3*s6 - 752*s2**3*s3**2*s4**3*s6**2 + 2262*s2**3*s3**2*s4**2*s5**2*s6
++ 525*s2**3*s3**2*s4*s5**4 - 9936*s2**3*s3**2*s6**4 - 480*s2**3*s3*s4**4*s5*s6 - 700*s2**3*s3*s4**3*s5**3
+- 68976*s2**3*s3*s4*s5*s6**3 - 11360*s2**3*s3*s5**3*s6**2 - 32*s2**3*s4**6*s6 + 152*s2**3*s4**5*s5**2
++ 6912*s2**3*s4**3*s6**3 - 7992*s2**3*s4**2*s5**2*s6**2 + 5550*s2**3*s4*s5**4*s6 -
+29376*s2**3*s6**5 + 108*s2**2*s3**4*s4**2*s6**2 - 1215*s2**2*s3**4*s4*s5**2*s6 - 150*s2**2*s3**4*s5**4
++ 336*s2**2*s3**3*s4**3*s5*s6 - 185*s2**2*s3**3*s4**2*s5**3 + 17496*s2**2*s3**3*s5*s6**3
++ 8*s2**2*s3**2*s4**5*s6 + 370*s2**2*s3**2*s4**4*s5**2 - 864*s2**2*s3**2*s4**2*s6**3
++ 22572*s2**2*s3**2*s4*s5**2*s6**2 + 225*s2**2*s3**2*s5**4*s6 - 144*s2**2*s3*s4**6*s5
++ 14784*s2**2*s3*s4**3*s5*s6**2 - 12020*s2**2*s3*s4**2*s5**3*s6 + 625*s2**2*s3*s4*s5**5
++ 536544*s2**2*s3*s5*s6**4 + 16*s2**2*s4**8 - 3072*s2**2*s4**5*s6**2 + 1096*s2**2*s4**4*s5**2*s6
++ 250*s2**2*s4**3*s5**4 - 93744*s2**2*s4**2*s6**4 - 249480*s2**2*s4*s5**2*s6**3 +
+70125*s2**2*s5**4*s6**2 + 162*s2*s3**6*s5**2*s6 - 54*s2*s3**5*s4**2*s5*s6 + 198*s2*s3**5*s4*s5**3
+- 210*s2*s3**4*s4**3*s5**2 - 3564*s2*s3**4*s5**2*s6**2 + 72*s2*s3**3*s4**5*s5 - 12204*s2*s3**3*s4**2*s5*s6**2
++ 1935*s2*s3**3*s4*s5**3*s6 - 8*s2*s3**2*s4**7 + 2520*s2*s3**2*s4**4*s6**2 + 1962*s2*s3**2*s4**3*s5**2*s6
+- 125*s2*s3**2*s4**2*s5**4 - 178848*s2*s3**2*s4*s6**4 - 165240*s2*s3**2*s5**2*s6**3
+- 144*s2*s3*s4**5*s5*s6 - 200*s2*s3*s4**4*s5**3 + 139104*s2*s3*s4**2*s5*s6**3 + 72900*s2*s3*s4*s5**3*s6**2
+- 20625*s2*s3*s5**5*s6 - 96*s2*s4**7*s6 + 56*s2*s4**6*s5**2 + 19296*s2*s4**4*s6**3
+- 22080*s2*s4**3*s5**2*s6**2 - 7750*s2*s4**2*s5**4*s6 + 3125*s2*s4*s5**6 + 248832*s2*s4*s6**5
+- 129600*s2*s5**2*s6**4 - 27*s3**7*s5**3 + 27*s3**6*s4**2*s5**2 - 9*s3**5*s4**4*s5
++ 1944*s3**5*s4*s5*s6**2 + 54*s3**5*s5**3*s6 + s3**4*s4**6 - 432*s3**4*s4**3*s6**2
+- 486*s3**4*s4**2*s5**2*s6 + 46656*s3**4*s6**4 + 36*s3**3*s4**4*s5*s6 + 50*s3**3*s4**3*s5**3
+- 7776*s3**3*s4*s5*s6**3 + 29700*s3**3*s5**3*s6**2 + 24*s3**2*s4**6*s6 - 14*s3**2*s4**5*s5**2
+- 9936*s3**2*s4**3*s6**3 - 29160*s3**2*s4**2*s5**2*s6**2 - 10125*s3**2*s4*s5**4*s6
++ 3125*s3**2*s5**6 + 1026432*s3**2*s6**5 + 6336*s3*s4**4*s5*s6**2 + 11700*s3*s4**3*s5**3*s6
+- 3125*s3*s4**2*s5**5 - 1477440*s3*s4*s5*s6**4 + 432000*s3*s5**3*s6**3 + 144*s4**6*s6**2
+- 2472*s4**5*s5**2*s6 + 625*s4**4*s5**4 - 29376*s4**3*s6**4 + 529200*s4**2*s5**2*s6**3
+- 292500*s4*s5**4*s6**2 + 40625*s5**6*s6 - 186624*s6**6)
+    ],
+    (6, 2): [
+        lambda s1, s2, s3, s4, s5, s6: (-s3),
+        lambda s1, s2, s3, s4, s5, s6: (-s1*s5 + s2*s4 - 9*s6),
+        lambda s1, s2, s3, s4, s5, s6: (s1*s2*s6 + 2*s1*s3*s5 - s1*s4**2 - s2**2*s5 + 6*s3*s6 + s4*s5),
+        lambda s1, s2, s3, s4, s5, s6: (s1**2*s4*s6 - s1**2*s5**2 - 3*s1*s2*s3*s6 + s1*s2*s4*s5 + 9*s1*s5*s6 + s2**3*s6 -
+9*s2*s4*s6 + s2*s5**2 + 3*s3**2*s6 - 3*s3*s4*s5 + s4**3 + 27*s6**2),
+        lambda s1, s2, s3, s4, s5, s6: (-2*s1**3*s6**2 + 2*s1**2*s2*s5*s6 + 2*s1**2*s3*s4*s6 - s1**2*s3*s5**2 - s1*s2**2*s4*s6
+- 3*s1*s2*s6**2 - 16*s1*s3*s5*s6 + 4*s1*s4**2*s6 + 2*s1*s4*s5**2 + 4*s2**2*s5*s6 +
+s2*s3*s4*s6 + 2*s2*s3*s5**2 - s2*s4**2*s5 - 9*s3*s6**2 - 3*s4*s5*s6 - 2*s5**3),
+        lambda s1, s2, s3, s4, s5, s6: (s1**3*s3*s6**2 - 3*s1**3*s4*s5*s6 + s1**3*s5**3 - s1**2*s2**2*s6**2 + s1**2*s2*s3*s5*s6
+- 2*s1**2*s4*s6**2 + 6*s1**2*s5**2*s6 + 16*s1*s2*s3*s6**2 - 3*s1*s2*s5**3 - s1*s3**2*s5*s6
+- 2*s1*s3*s4**2*s6 + s1*s3*s4*s5**2 - 30*s1*s5*s6**2 - 4*s2**3*s6**2 - 2*s2**2*s3*s5*s6
++ s2**2*s4**2*s6 + 18*s2*s4*s6**2 - 2*s2*s5**2*s6 - 15*s3**2*s6**2 + 16*s3*s4*s5*s6
++ s3*s5**3 - 4*s4**3*s6 - s4**2*s5**2 - 27*s6**3),
+        lambda s1, s2, s3, s4, s5, s6: (s1**4*s5*s6**2 + 2*s1**3*s2*s4*s6**2 - s1**3*s2*s5**2*s6 - s1**3*s3**2*s6**2 + 9*s1**3*s6**3
+- 14*s1**2*s2*s5*s6**2 - 11*s1**2*s3*s4*s6**2 + 6*s1**2*s3*s5**2*s6 + 3*s1**2*s4**2*s5*s6
+- s1**2*s4*s5**3 + 3*s1*s2**2*s5**2*s6 + 3*s1*s2*s3**2*s6**2 - s1*s2*s3*s4*s5*s6 +
+39*s1*s3*s5*s6**2 - 14*s1*s4*s5**2*s6 + s1*s5**4 - 11*s2*s3*s5**2*s6 + 2*s2*s4*s5**3
+- 3*s3**3*s6**2 + 3*s3**2*s4*s5*s6 - s3**2*s5**3 + 9*s5**3*s6),
+        lambda s1, s2, s3, s4, s5, s6: (-s1**4*s2*s6**3 + s1**4*s3*s5*s6**2 - 4*s1**3*s3*s6**3 + 10*s1**3*s4*s5*s6**2 - 4*s1**3*s5**3*s6
++ 8*s1**2*s2**2*s6**3 - 8*s1**2*s2*s3*s5*s6**2 - 2*s1**2*s2*s4**2*s6**2 + s1**2*s2*s4*s5**2*s6
++ s1**2*s3**2*s4*s6**2 - 6*s1**2*s4*s6**3 - 7*s1**2*s5**2*s6**2 - 24*s1*s2*s3*s6**3
+- 4*s1*s2*s4*s5*s6**2 + 10*s1*s2*s5**3*s6 + 8*s1*s3**2*s5*s6**2 + 8*s1*s3*s4**2*s6**2
+- 8*s1*s3*s4*s5**2*s6 + s1*s3*s5**4 + 36*s1*s5*s6**3 + 8*s2**2*s3*s5*s6**2 - 2*s2**2*s4*s5**2*s6
+- 2*s2*s3**2*s4*s6**2 + s2*s3**2*s5**2*s6 - 6*s2*s5**2*s6**2 + 18*s3**2*s6**3 - 24*s3*s4*s5*s6**2
+- 4*s3*s5**3*s6 + 8*s4**2*s5**2*s6 - s4*s5**4),
+        lambda s1, s2, s3, s4, s5, s6: (-s1**5*s4*s6**3 - 2*s1**4*s5*s6**3 + 3*s1**3*s2*s5**2*s6**2 + 3*s1**3*s3**2*s6**3
+- s1**3*s3*s4*s5*s6**2 - 8*s1**3*s6**4 + 16*s1**2*s2*s5*s6**3 + 8*s1**2*s3*s4*s6**3
+- 6*s1**2*s3*s5**2*s6**2 - 8*s1**2*s4**2*s5*s6**2 + 3*s1**2*s4*s5**3*s6 - 8*s1*s2**2*s5**2*s6**2
+- 8*s1*s2*s3**2*s6**3 + 8*s1*s2*s3*s4*s5*s6**2 - s1*s2*s3*s5**3*s6 - s1*s3**3*s5*s6**2
+- 24*s1*s3*s5*s6**3 + 16*s1*s4*s5**2*s6**2 - 2*s1*s5**4*s6 + 8*s2*s3*s5**2*s6**2 -
+s2*s5**5 + 8*s3**3*s6**3 - 8*s3**2*s4*s5*s6**2 + 3*s3**2*s5**3*s6 - 8*s5**3*s6**2),
+        lambda s1, s2, s3, s4, s5, s6: (s1**6*s6**4 - 4*s1**4*s2*s6**4 - 2*s1**4*s3*s5*s6**3 + s1**4*s4**2*s6**3 + 8*s1**3*s3*s6**4
+- 4*s1**3*s4*s5*s6**3 + 2*s1**3*s5**3*s6**2 + 8*s1**2*s2*s3*s5*s6**3 - 2*s1**2*s2*s4*s5**2*s6**2
+- 2*s1**2*s3**2*s4*s6**3 + s1**2*s3**2*s5**2*s6**2 - 4*s1*s2*s5**3*s6**2 - 12*s1*s3**2*s5*s6**3
++ 8*s1*s3*s4*s5**2*s6**2 - 2*s1*s3*s5**4*s6 + s2**2*s5**4*s6 - 2*s2*s3**2*s5**2*s6**2
++ s3**4*s6**3 + 8*s3*s5**3*s6**2 - 4*s4*s5**4*s6 + s5**6)
+    ],
+}

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/subfield.py

@@ -0,0 +1,516 @@
+r"""
+Functions in ``polys.numberfields.subfield`` solve the "Subfield Problem" and
+allied problems, for algebraic number fields.
+
+Following Cohen (see [Cohen93]_ Section 4.5), we can define the main problem as
+follows:
+
+* **Subfield Problem:**
+
+  Given two number fields $\mathbb{Q}(\alpha)$, $\mathbb{Q}(\beta)$
+  via the minimal polynomials for their generators $\alpha$ and $\beta$, decide
+  whether one field is isomorphic to a subfield of the other.
+
+From a solution to this problem flow solutions to the following problems as
+well:
+
+* **Primitive Element Problem:**
+
+  Given several algebraic numbers
+  $\alpha_1, \ldots, \alpha_m$, compute a single algebraic number $\theta$
+  such that $\mathbb{Q}(\alpha_1, \ldots, \alpha_m) = \mathbb{Q}(\theta)$.
+
+* **Field Isomorphism Problem:**
+
+  Decide whether two number fields
+  $\mathbb{Q}(\alpha)$, $\mathbb{Q}(\beta)$ are isomorphic.
+
+* **Field Membership Problem:**
+
+  Given two algebraic numbers $\alpha$,
+  $\beta$, decide whether $\alpha \in \mathbb{Q}(\beta)$, and if so write
+  $\alpha = f(\beta)$ for some $f(x) \in \mathbb{Q}[x]$.
+"""
+
+from sympy.core.add import Add
+from sympy.core.numbers import AlgebraicNumber
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify, _sympify
+from sympy.ntheory import sieve
+from sympy.polys.densetools import dup_eval
+from sympy.polys.domains import QQ
+from sympy.polys.numberfields.minpoly import _choose_factor, minimal_polynomial
+from sympy.polys.polyerrors import IsomorphismFailed
+from sympy.polys.polytools import Poly, PurePoly, factor_list
+from sympy.utilities import public
+
+from mpmath import MPContext
+
+
+def is_isomorphism_possible(a, b):
+    """Necessary but not sufficient test for isomorphism. """
+    n = a.minpoly.degree()
+    m = b.minpoly.degree()
+
+    if m % n != 0:
+        return False
+
+    if n == m:
+        return True
+
+    da = a.minpoly.discriminant()
+    db = b.minpoly.discriminant()
+
+    i, k, half = 1, m//n, db//2
+
+    while True:
+        p = sieve[i]
+        P = p**k
+
+        if P > half:
+            break
+
+        if ((da % p) % 2) and not (db % P):
+            return False
+
+        i += 1
+
+    return True
+
+
+def field_isomorphism_pslq(a, b):
+    """Construct field isomorphism using PSLQ algorithm. """
+    if not a.root.is_real or not b.root.is_real:
+        raise NotImplementedError("PSLQ doesn't support complex coefficients")
+
+    f = a.minpoly
+    g = b.minpoly.replace(f.gen)
+
+    n, m, prev = 100, b.minpoly.degree(), None
+    ctx = MPContext()
+
+    for i in range(1, 5):
+        A = a.root.evalf(n)
+        B = b.root.evalf(n)
+
+        basis = [1, B] + [ B**i for i in range(2, m) ] + [-A]
+
+        ctx.dps = n
+        coeffs = ctx.pslq(basis, maxcoeff=10**10, maxsteps=1000)
+
+        if coeffs is None:
+            # PSLQ can't find an integer linear combination. Give up.
+            break
+
+        if coeffs != prev:
+            prev = coeffs
+        else:
+            # Increasing precision didn't produce anything new. Give up.
+            break
+
+        # We have
+        #   c0 + c1*B + c2*B^2 + ... + cm-1*B^(m-1) - cm*A ~ 0.
+        # So bring cm*A to the other side, and divide through by cm,
+        # for an approximate representation of A as a polynomial in B.
+        # (We know cm != 0 since `b.minpoly` is irreducible.)
+        coeffs = [S(c)/coeffs[-1] for c in coeffs[:-1]]
+
+        # Throw away leading zeros.
+        while not coeffs[-1]:
+            coeffs.pop()
+
+        coeffs = list(reversed(coeffs))
+        h = Poly(coeffs, f.gen, domain='QQ')
+
+        # We only have A ~ h(B). We must check whether the relation is exact.
+        if f.compose(h).rem(g).is_zero:
+            # Now we know that h(b) is in fact equal to _some conjugate of_ a.
+            # But from the very precise approximation A ~ h(B) we can assume
+            # the conjugate is a itself.
+            return coeffs
+        else:
+            n *= 2
+
+    return None
+
+
+def field_isomorphism_factor(a, b):
+    """Construct field isomorphism via factorization. """
+    _, factors = factor_list(a.minpoly, extension=b)
+    for f, _ in factors:
+        if f.degree() == 1:
+            # Any linear factor f(x) represents some conjugate of a in QQ(b).
+            # We want to know whether this linear factor represents a itself.
+            # Let f = x - c
+            c = -f.rep.TC()
+            # Write c as polynomial in b
+            coeffs = c.to_sympy_list()
+            d, terms = len(coeffs) - 1, []
+            for i, coeff in enumerate(coeffs):
+                terms.append(coeff*b.root**(d - i))
+            r = Add(*terms)
+            # Check whether we got the number a
+            if a.minpoly.same_root(r, a):
+                return coeffs
+
+    # If none of the linear factors represented a in QQ(b), then in fact a is
+    # not an element of QQ(b).
+    return None
+
+
+@public
+def field_isomorphism(a, b, *, fast=True):
+    r"""
+    Find an embedding of one number field into another.
+
+    Explanation
+    ===========
+
+    This function looks for an isomorphism from $\mathbb{Q}(a)$ onto some
+    subfield of $\mathbb{Q}(b)$. Thus, it solves the Subfield Problem.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, field_isomorphism, I
+    >>> print(field_isomorphism(3, sqrt(2)))  # doctest: +SKIP
+    [3]
+    >>> print(field_isomorphism( I*sqrt(3), I*sqrt(3)/2))  # doctest: +SKIP
+    [2, 0]
+
+    Parameters
+    ==========
+
+    a : :py:class:`~.Expr`
+        Any expression representing an algebraic number.
+    b : :py:class:`~.Expr`
+        Any expression representing an algebraic number.
+    fast : boolean, optional (default=True)
+        If ``True``, we first attempt a potentially faster way of computing the
+        isomorphism, falling back on a slower method if this fails. If
+        ``False``, we go directly to the slower method, which is guaranteed to
+        return a result.
+
+    Returns
+    =======
+
+    List of rational numbers, or None
+        If $\mathbb{Q}(a)$ is not isomorphic to some subfield of
+        $\mathbb{Q}(b)$, then return ``None``. Otherwise, return a list of
+        rational numbers representing an element of $\mathbb{Q}(b)$ to which
+        $a$ may be mapped, in order to define a monomorphism, i.e. an
+        isomorphism from $\mathbb{Q}(a)$ to some subfield of $\mathbb{Q}(b)$.
+        The elements of the list are the coefficients of falling powers of $b$.
+
+    """
+    a, b = sympify(a), sympify(b)
+
+    if not a.is_AlgebraicNumber:
+        a = AlgebraicNumber(a)
+
+    if not b.is_AlgebraicNumber:
+        b = AlgebraicNumber(b)
+
+    a = a.to_primitive_element()
+    b = b.to_primitive_element()
+
+    if a == b:
+        return a.coeffs()
+
+    n = a.minpoly.degree()
+    m = b.minpoly.degree()
+
+    if n == 1:
+        return [a.root]
+
+    if m % n != 0:
+        return None
+
+    if fast:
+        try:
+            result = field_isomorphism_pslq(a, b)
+
+            if result is not None:
+                return result
+        except NotImplementedError:
+            pass
+
+    return field_isomorphism_factor(a, b)
+
+
+def _switch_domain(g, K):
+    # An algebraic relation f(a, b) = 0 over Q can also be written
+    # g(b) = 0 where g is in Q(a)[x] and h(a) = 0 where h is in Q(b)[x].
+    # This function transforms g into h where Q(b) = K.
+    frep = g.rep.inject()
+    hrep = frep.eject(K, front=True)
+
+    return g.new(hrep, g.gens[0])
+
+
+def _linsolve(p):
+    # Compute root of linear polynomial.
+    c, d = p.rep.to_list()
+    return -d/c
+
+
+@public
+def primitive_element(extension, x=None, *, ex=False, polys=False):
+    r"""
+    Find a single generator for a number field given by several generators.
+
+    Explanation
+    ===========
+
+    The basic problem is this: Given several algebraic numbers
+    $\alpha_1, \alpha_2, \ldots, \alpha_n$, find a single algebraic number
+    $\theta$ such that
+    $\mathbb{Q}(\alpha_1, \alpha_2, \ldots, \alpha_n) = \mathbb{Q}(\theta)$.
+
+    This function actually guarantees that $\theta$ will be a linear
+    combination of the $\alpha_i$, with non-negative integer coefficients.
+
+    Furthermore, if desired, this function will tell you how to express each
+    $\alpha_i$ as a $\mathbb{Q}$-linear combination of the powers of $\theta$.
+
+    Examples
+    ========
+
+    >>> from sympy import primitive_element, sqrt, S, minpoly, simplify
+    >>> from sympy.abc import x
+    >>> f, lincomb, reps = primitive_element([sqrt(2), sqrt(3)], x, ex=True)
+
+    Then ``lincomb`` tells us the primitive element as a linear combination of
+    the given generators ``sqrt(2)`` and ``sqrt(3)``.
+
+    >>> print(lincomb)
+    [1, 1]
+
+    This means the primtiive element is $\sqrt{2} + \sqrt{3}$.
+    Meanwhile ``f`` is the minimal polynomial for this primitive element.
+
+    >>> print(f)
+    x**4 - 10*x**2 + 1
+    >>> print(minpoly(sqrt(2) + sqrt(3), x))
+    x**4 - 10*x**2 + 1
+
+    Finally, ``reps`` (which was returned only because we set keyword arg
+    ``ex=True``) tells us how to recover each of the generators $\sqrt{2}$ and
+    $\sqrt{3}$ as $\mathbb{Q}$-linear combinations of the powers of the
+    primitive element $\sqrt{2} + \sqrt{3}$.
+
+    >>> print([S(r) for r in reps[0]])
+    [1/2, 0, -9/2, 0]
+    >>> theta = sqrt(2) + sqrt(3)
+    >>> print(simplify(theta**3/2 - 9*theta/2))
+    sqrt(2)
+    >>> print([S(r) for r in reps[1]])
+    [-1/2, 0, 11/2, 0]
+    >>> print(simplify(-theta**3/2 + 11*theta/2))
+    sqrt(3)
+
+    Parameters
+    ==========
+
+    extension : list of :py:class:`~.Expr`
+        Each expression must represent an algebraic number $\alpha_i$.
+    x : :py:class:`~.Symbol`, optional (default=None)
+        The desired symbol to appear in the computed minimal polynomial for the
+        primitive element $\theta$. If ``None``, we use a dummy symbol.
+    ex : boolean, optional (default=False)
+        If and only if ``True``, compute the representation of each $\alpha_i$
+        as a $\mathbb{Q}$-linear combination over the powers of $\theta$.
+    polys : boolean, optional (default=False)
+        If ``True``, return the minimal polynomial as a :py:class:`~.Poly`.
+        Otherwise return it as an :py:class:`~.Expr`.
+
+    Returns
+    =======
+
+    Pair (f, coeffs) or triple (f, coeffs, reps), where:
+        ``f`` is the minimal polynomial for the primitive element.
+        ``coeffs`` gives the primitive element as a linear combination of the
+        given generators.
+        ``reps`` is present if and only if argument ``ex=True`` was passed,
+        and is a list of lists of rational numbers. Each list gives the
+        coefficients of falling powers of the primitive element, to recover
+        one of the original, given generators.
+
+    """
+    if not extension:
+        raise ValueError("Cannot compute primitive element for empty extension")
+    extension = [_sympify(ext) for ext in extension]
+
+    if x is not None:
+        x, cls = sympify(x), Poly
+    else:
+        x, cls = Dummy('x'), PurePoly
+
+    def _canonicalize(f):
+        _, f = f.primitive()
+        if f.LC() < 0:
+            f = -f
+        return f
+
+    if not ex:
+        gen, coeffs = extension[0], [1]
+        g = minimal_polynomial(gen, x, polys=True)
+        for ext in extension[1:]:
+            if ext.is_Rational:
+                coeffs.append(0)
+                continue
+            _, factors = factor_list(g, extension=ext)
+            g = _choose_factor(factors, x, gen)
+            [s], _, g = g.sqf_norm()
+            gen += s*ext
+            coeffs.append(s)
+
+        g = _canonicalize(g)
+        if not polys:
+            return g.as_expr(), coeffs
+        else:
+            return cls(g), coeffs
+
+    gen, coeffs = extension[0], [1]
+    f = minimal_polynomial(gen, x, polys=True)
+    K = QQ.algebraic_field((f, gen))  # incrementally constructed field
+    reps = [K.unit]  # representations of extension elements in K
+    for ext in extension[1:]:
+        if ext.is_Rational:
+            coeffs.append(0)    # rational ext is not included in the expression of a primitive element
+            reps.append(K.convert(ext))    # but it is included in reps
+            continue
+        p = minimal_polynomial(ext, x, polys=True)
+        L = QQ.algebraic_field((p, ext))
+        _, factors = factor_list(f, domain=L)
+        f = _choose_factor(factors, x, gen)
+        [s], g, f = f.sqf_norm()
+        gen += s*ext
+        coeffs.append(s)
+        K = QQ.algebraic_field((f, gen))
+        h = _switch_domain(g, K)
+        erep = _linsolve(h.gcd(p))  # ext as element of K
+        ogen = K.unit - s*erep  # old gen as element of K
+        reps = [dup_eval(_.to_list(), ogen, K) for _ in reps] + [erep]
+
+    if K.ext.root.is_Rational:  # all extensions are rational
+        H = [K.convert(_).rep for _ in extension]
+        coeffs = [0]*len(extension)
+        f = cls(x, domain=QQ)
+    else:
+        H = [_.to_list() for _ in reps]
+
+    f = _canonicalize(f)
+    if not polys:
+        return f.as_expr(), coeffs, H
+    else:
+        return f, coeffs, H
+
+
+@public
+def to_number_field(extension, theta=None, *, gen=None, alias=None):
+    r"""
+    Express one algebraic number in the field generated by another.
+
+    Explanation
+    ===========
+
+    Given two algebraic numbers $\eta, \theta$, this function either expresses
+    $\eta$ as an element of $\mathbb{Q}(\theta)$, or else raises an exception
+    if $\eta \not\in \mathbb{Q}(\theta)$.
+
+    This function is essentially just a convenience, utilizing
+    :py:func:`~.field_isomorphism` (our solution of the Subfield Problem) to
+    solve this, the Field Membership Problem.
+
+    As an additional convenience, this function allows you to pass a list of
+    algebraic numbers $\alpha_1, \alpha_2, \ldots, \alpha_n$ instead of $\eta$.
+    It then computes $\eta$ for you, as a solution of the Primitive Element
+    Problem, using :py:func:`~.primitive_element` on the list of $\alpha_i$.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, to_number_field
+    >>> eta = sqrt(2)
+    >>> theta = sqrt(2) + sqrt(3)
+    >>> a = to_number_field(eta, theta)
+    >>> print(type(a))
+    <class 'sympy.core.numbers.AlgebraicNumber'>
+    >>> a.root
+    sqrt(2) + sqrt(3)
+    >>> print(a)
+    sqrt(2)
+    >>> a.coeffs()
+    [1/2, 0, -9/2, 0]
+
+    We get an :py:class:`~.AlgebraicNumber`, whose ``.root`` is $\theta$, whose
+    value is $\eta$, and whose ``.coeffs()`` show how to write $\eta$ as a
+    $\mathbb{Q}$-linear combination in falling powers of $\theta$.
+
+    Parameters
+    ==========
+
+    extension : :py:class:`~.Expr` or list of :py:class:`~.Expr`
+        Either the algebraic number that is to be expressed in the other field,
+        or else a list of algebraic numbers, a primitive element for which is
+        to be expressed in the other field.
+    theta : :py:class:`~.Expr`, None, optional (default=None)
+        If an :py:class:`~.Expr` representing an algebraic number, behavior is
+        as described under **Explanation**. If ``None``, then this function
+        reduces to a shorthand for calling :py:func:`~.primitive_element` on
+        ``extension`` and turning the computed primitive element into an
+        :py:class:`~.AlgebraicNumber`.
+    gen : :py:class:`~.Symbol`, None, optional (default=None)
+        If provided, this will be used as the generator symbol for the minimal
+        polynomial in the returned :py:class:`~.AlgebraicNumber`.
+    alias : str, :py:class:`~.Symbol`, None, optional (default=None)
+        If provided, this will be used as the alias symbol for the returned
+        :py:class:`~.AlgebraicNumber`.
+
+    Returns
+    =======
+
+    AlgebraicNumber
+        Belonging to $\mathbb{Q}(\theta)$ and equaling $\eta$.
+
+    Raises
+    ======
+
+    IsomorphismFailed
+        If $\eta \not\in \mathbb{Q}(\theta)$.
+
+    See Also
+    ========
+
+    field_isomorphism
+    primitive_element
+
+    """
+    if hasattr(extension, '__iter__'):
+        extension = list(extension)
+    else:
+        extension = [extension]
+
+    if len(extension) == 1 and isinstance(extension[0], tuple):
+        return AlgebraicNumber(extension[0], alias=alias)
+
+    minpoly, coeffs = primitive_element(extension, gen, polys=True)
+    root = sum(coeff*ext for coeff, ext in zip(coeffs, extension))
+
+    if theta is None:
+        return AlgebraicNumber((minpoly, root), alias=alias)
+    else:
+        theta = sympify(theta)
+
+        if not theta.is_AlgebraicNumber:
+            theta = AlgebraicNumber(theta, gen=gen, alias=alias)
+
+        coeffs = field_isomorphism(root, theta)
+
+        if coeffs is not None:
+            return AlgebraicNumber(theta, coeffs, alias=alias)
+        else:
+            raise IsomorphismFailed(
+                "%s is not in a subfield of %s" % (root, theta.root))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_basis.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_galoisgroups.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_minpoly.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_modules.py

@@ -0,0 +1,752 @@
+from sympy.abc import x, zeta
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.domains import FF, QQ, ZZ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.numberfields.exceptions import (
+    ClosureFailure, MissingUnityError, StructureError
+)
+from sympy.polys.numberfields.modules import (
+    Module, ModuleElement, ModuleEndomorphism, PowerBasis, PowerBasisElement,
+    find_min_poly, is_sq_maxrank_HNF, make_mod_elt, to_col,
+)
+from sympy.polys.numberfields.utilities import is_int
+from sympy.polys.polyerrors import UnificationFailed
+from sympy.testing.pytest import raises
+
+
+def test_to_col():
+    c = [1, 2, 3, 4]
+    m = to_col(c)
+    assert m.domain.is_ZZ
+    assert m.shape == (4, 1)
+    assert m.flat() == c
+
+
+def test_Module_NotImplemented():
+    M = Module()
+    raises(NotImplementedError, lambda: M.n)
+    raises(NotImplementedError, lambda: M.mult_tab())
+    raises(NotImplementedError, lambda: M.represent(None))
+    raises(NotImplementedError, lambda: M.starts_with_unity())
+    raises(NotImplementedError, lambda: M.element_from_rational(QQ(2, 3)))
+
+
+def test_Module_ancestors():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = B.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    assert C.ancestors(include_self=True) == [A, B, C]
+    assert D.ancestors(include_self=True) == [A, B, D]
+    assert C.power_basis_ancestor() == A
+    assert C.nearest_common_ancestor(D) == B
+    M = Module()
+    assert M.power_basis_ancestor() is None
+
+
+def test_Module_compat_col():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    col = to_col([1, 2, 3, 4])
+    row = col.transpose()
+    assert A.is_compat_col(col) is True
+    assert A.is_compat_col(row) is False
+    assert A.is_compat_col(1) is False
+    assert A.is_compat_col(DomainMatrix.eye(3, ZZ)[:, 0]) is False
+    assert A.is_compat_col(DomainMatrix.eye(4, QQ)[:, 0]) is False
+    assert A.is_compat_col(DomainMatrix.eye(4, ZZ)[:, 0]) is True
+
+
+def test_Module_call():
+    T = Poly(cyclotomic_poly(5, x))
+    B = PowerBasis(T)
+    assert B(0).col.flat() == [1, 0, 0, 0]
+    assert B(1).col.flat() == [0, 1, 0, 0]
+    col = DomainMatrix.eye(4, ZZ)[:, 2]
+    assert B(col).col == col
+    raises(ValueError, lambda: B(-1))
+
+
+def test_Module_starts_with_unity():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    assert A.starts_with_unity() is True
+    assert B.starts_with_unity() is False
+
+
+def test_Module_basis_elements():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    basis = B.basis_elements()
+    bp = B.basis_element_pullbacks()
+    for i, (e, p) in enumerate(zip(basis, bp)):
+        c = [0] * 4
+        assert e.module == B
+        assert p.module == A
+        c[i] = 1
+        assert e == B(to_col(c))
+        c[i] = 2
+        assert p == A(to_col(c))
+
+
+def test_Module_zero():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    assert A.zero().col.flat() == [0, 0, 0, 0]
+    assert A.zero().module == A
+    assert B.zero().col.flat() == [0, 0, 0, 0]
+    assert B.zero().module == B
+
+
+def test_Module_one():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    assert A.one().col.flat() == [1, 0, 0, 0]
+    assert A.one().module == A
+    assert B.one().col.flat() == [1, 0, 0, 0]
+    assert B.one().module == A
+
+
+def test_Module_element_from_rational():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    rA = A.element_from_rational(QQ(22, 7))
+    rB = B.element_from_rational(QQ(22, 7))
+    assert rA.coeffs == [22, 0, 0, 0]
+    assert rA.denom == 7
+    assert rA.module == A
+    assert rB.coeffs == [22, 0, 0, 0]
+    assert rB.denom == 7
+    assert rB.module == A
+
+
+def test_Module_submodule_from_gens():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    gens = [2*A(0), 2*A(1), 6*A(0), 6*A(1)]
+    B = A.submodule_from_gens(gens)
+    # Because the 3rd and 4th generators do not add anything new, we expect
+    # the cols of the matrix of B to just reproduce the first two gens:
+    M = gens[0].column().hstack(gens[1].column())
+    assert B.matrix == M
+    # At least one generator must be provided:
+    raises(ValueError, lambda: A.submodule_from_gens([]))
+    # All generators must belong to A:
+    raises(ValueError, lambda: A.submodule_from_gens([3*A(0), B(0)]))
+
+
+def test_Module_submodule_from_matrix():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    e = B(to_col([1, 2, 3, 4]))
+    f = e.to_parent()
+    assert f.col.flat() == [2, 4, 6, 8]
+    # Matrix must be over ZZ:
+    raises(ValueError, lambda: A.submodule_from_matrix(DomainMatrix.eye(4, QQ)))
+    # Number of rows of matrix must equal number of generators of module A:
+    raises(ValueError, lambda: A.submodule_from_matrix(2 * DomainMatrix.eye(5, ZZ)))
+
+
+def test_Module_whole_submodule():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.whole_submodule()
+    e = B(to_col([1, 2, 3, 4]))
+    f = e.to_parent()
+    assert f.col.flat() == [1, 2, 3, 4]
+    e0, e1, e2, e3 = B(0), B(1), B(2), B(3)
+    assert e2 * e3 == e0
+    assert e3 ** 2 == e1
+
+
+def test_PowerBasis_repr():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    assert repr(A) == 'PowerBasis(x**4 + x**3 + x**2 + x + 1)'
+
+
+def test_PowerBasis_eq():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = PowerBasis(T)
+    assert A == B
+
+
+def test_PowerBasis_mult_tab():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    M = A.mult_tab()
+    exp = {0: {0: [1, 0, 0, 0], 1: [0, 1, 0, 0], 2: [0, 0, 1, 0], 3: [0, 0, 0, 1]},
+           1: {1: [0, 0, 1, 0], 2: [0, 0, 0, 1], 3: [-1, -1, -1, -1]},
+           2: {2: [-1, -1, -1, -1], 3: [1, 0, 0, 0]},
+           3: {3: [0, 1, 0, 0]}}
+    # We get the table we expect:
+    assert M == exp
+    # And all entries are of expected type:
+    assert all(is_int(c) for u in M for v in M[u] for c in M[u][v])
+
+
+def test_PowerBasis_represent():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    col = to_col([1, 2, 3, 4])
+    a = A(col)
+    assert A.represent(a) == col
+    b = A(col, denom=2)
+    raises(ClosureFailure, lambda: A.represent(b))
+
+
+def test_PowerBasis_element_from_poly():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    f = Poly(1 + 2*x)
+    g = Poly(x**4)
+    h = Poly(0, x)
+    assert A.element_from_poly(f).coeffs == [1, 2, 0, 0]
+    assert A.element_from_poly(g).coeffs == [-1, -1, -1, -1]
+    assert A.element_from_poly(h).coeffs == [0, 0, 0, 0]
+
+
+def test_PowerBasis_element__conversions():
+    k = QQ.cyclotomic_field(5)
+    L = QQ.cyclotomic_field(7)
+    B = PowerBasis(k)
+
+    # ANP --> PowerBasisElement
+    a = k([QQ(1, 2), QQ(1, 3), 5, 7])
+    e = B.element_from_ANP(a)
+    assert e.coeffs == [42, 30, 2, 3]
+    assert e.denom == 6
+
+    # PowerBasisElement --> ANP
+    assert e.to_ANP() == a
+
+    # Cannot convert ANP from different field
+    d = L([QQ(1, 2), QQ(1, 3), 5, 7])
+    raises(UnificationFailed, lambda: B.element_from_ANP(d))
+
+    # AlgebraicNumber --> PowerBasisElement
+    alpha = k.to_alg_num(a)
+    eps = B.element_from_alg_num(alpha)
+    assert eps.coeffs == [42, 30, 2, 3]
+    assert eps.denom == 6
+
+    # PowerBasisElement --> AlgebraicNumber
+    assert eps.to_alg_num() == alpha
+
+    # Cannot convert AlgebraicNumber from different field
+    delta = L.to_alg_num(d)
+    raises(UnificationFailed, lambda: B.element_from_alg_num(delta))
+
+    # When we don't know the field:
+    C = PowerBasis(k.ext.minpoly)
+    # Can convert from AlgebraicNumber:
+    eps = C.element_from_alg_num(alpha)
+    assert eps.coeffs == [42, 30, 2, 3]
+    assert eps.denom == 6
+    # But can't convert back:
+    raises(StructureError, lambda: eps.to_alg_num())
+
+
+def test_Submodule_repr():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ), denom=3)
+    assert repr(B) == 'Submodule[[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]]/3'
+
+
+def test_Submodule_reduced():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(6 * DomainMatrix.eye(4, ZZ), denom=3)
+    D = C.reduced()
+    assert D.denom == 1 and D == C == B
+
+
+def test_Submodule_discard_before():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    B.compute_mult_tab()
+    C = B.discard_before(2)
+    assert C.parent == B.parent
+    assert B.is_sq_maxrank_HNF() and not C.is_sq_maxrank_HNF()
+    assert C.matrix == B.matrix[:, 2:]
+    assert C.mult_tab() == {0: {0: [-2, -2], 1: [0, 0]}, 1: {1: [0, 0]}}
+
+
+def test_Submodule_QQ_matrix():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(6 * DomainMatrix.eye(4, ZZ), denom=3)
+    assert C.QQ_matrix == B.QQ_matrix
+
+
+def test_Submodule_represent():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    a0 = A(to_col([6, 12, 18, 24]))
+    a1 = A(to_col([2, 4, 6, 8]))
+    a2 = A(to_col([1, 3, 5, 7]))
+
+    b1 = B.represent(a1)
+    assert b1.flat() == [1, 2, 3, 4]
+
+    c0 = C.represent(a0)
+    assert c0.flat() == [1, 2, 3, 4]
+
+    Y = A.submodule_from_matrix(DomainMatrix([
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+    ], (3, 4), ZZ).transpose())
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    z0 = Z(to_col([1, 2, 3, 4, 5, 6]))
+
+    raises(ClosureFailure, lambda: Y.represent(A(3)))
+    raises(ClosureFailure, lambda: B.represent(a2))
+    raises(ClosureFailure, lambda: B.represent(z0))
+
+
+def test_Submodule_is_compat_submodule():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = C.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    assert B.is_compat_submodule(C) is True
+    assert B.is_compat_submodule(A) is False
+    assert B.is_compat_submodule(D) is False
+
+
+def test_Submodule_eq():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = A.submodule_from_matrix(6 * DomainMatrix.eye(4, ZZ), denom=3)
+    assert C == B
+
+
+def test_Submodule_add():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(DomainMatrix([
+        [4, 0, 0, 0],
+        [0, 4, 0, 0],
+    ], (2, 4), ZZ).transpose(), denom=6)
+    C = A.submodule_from_matrix(DomainMatrix([
+        [0, 10, 0, 0],
+        [0,  0, 7, 0],
+    ], (2, 4), ZZ).transpose(), denom=15)
+    D = A.submodule_from_matrix(DomainMatrix([
+        [20,  0,  0, 0],
+        [ 0, 20,  0, 0],
+        [ 0,  0, 14, 0],
+    ], (3, 4), ZZ).transpose(), denom=30)
+    assert B + C == D
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    Y = Z.submodule_from_gens([Z(0), Z(1)])
+    raises(TypeError, lambda: B + Y)
+
+
+def test_Submodule_mul():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(DomainMatrix([
+        [0, 10, 0, 0],
+        [0, 0, 7, 0],
+    ], (2, 4), ZZ).transpose(), denom=15)
+    C1 = A.submodule_from_matrix(DomainMatrix([
+        [0, 20, 0, 0],
+        [0, 0, 14, 0],
+    ], (2, 4), ZZ).transpose(), denom=3)
+    C2 = A.submodule_from_matrix(DomainMatrix([
+        [0, 0, 10, 0],
+        [0, 0,  0, 7],
+    ], (2, 4), ZZ).transpose(), denom=15)
+    C3_unred = A.submodule_from_matrix(DomainMatrix([
+        [0, 0, 100, 0],
+        [0, 0, 0, 70],
+        [0, 0, 0, 70],
+        [-49, -49, -49, -49]
+    ], (4, 4), ZZ).transpose(), denom=225)
+    C3 = A.submodule_from_matrix(DomainMatrix([
+        [4900, 4900, 0, 0],
+        [4410, 4410, 10, 0],
+        [2107, 2107, 7, 7]
+    ], (3, 4), ZZ).transpose(), denom=225)
+    assert C * 1 == C
+    assert C ** 1 == C
+    assert C * 10 == C1
+    assert C * A(1) == C2
+    assert C.mul(C, hnf=False) == C3_unred
+    assert C * C == C3
+    assert C ** 2 == C3
+
+
+def test_Submodule_reduce_element():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.whole_submodule()
+    b = B(to_col([90, 84, 80, 75]), denom=120)
+
+    C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=2)
+    b_bar_expected = B(to_col([30, 24, 20, 15]), denom=120)
+    b_bar = C.reduce_element(b)
+    assert b_bar == b_bar_expected
+
+    C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=4)
+    b_bar_expected = B(to_col([0, 24, 20, 15]), denom=120)
+    b_bar = C.reduce_element(b)
+    assert b_bar == b_bar_expected
+
+    C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=8)
+    b_bar_expected = B(to_col([0, 9, 5, 0]), denom=120)
+    b_bar = C.reduce_element(b)
+    assert b_bar == b_bar_expected
+
+    a = A(to_col([1, 2, 3, 4]))
+    raises(NotImplementedError, lambda: C.reduce_element(a))
+
+    C = B.submodule_from_matrix(DomainMatrix([
+        [5, 4, 3, 2],
+        [0, 8, 7, 6],
+        [0, 0,11,12],
+        [0, 0, 0, 1]
+    ], (4, 4), ZZ).transpose())
+    raises(StructureError, lambda: C.reduce_element(b))
+
+
+def test_is_HNF():
+    M = DM([
+        [3, 2, 1],
+        [0, 2, 1],
+        [0, 0, 1]
+    ], ZZ)
+    M1 = DM([
+        [3, 2, 1],
+        [0, -2, 1],
+        [0, 0, 1]
+    ], ZZ)
+    M2 = DM([
+        [3, 2, 3],
+        [0, 2, 1],
+        [0, 0, 1]
+    ], ZZ)
+    assert is_sq_maxrank_HNF(M) is True
+    assert is_sq_maxrank_HNF(M1) is False
+    assert is_sq_maxrank_HNF(M2) is False
+
+
+def test_make_mod_elt():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    col = to_col([1, 2, 3, 4])
+    eA = make_mod_elt(A, col)
+    eB = make_mod_elt(B, col)
+    assert isinstance(eA, PowerBasisElement)
+    assert not isinstance(eB, PowerBasisElement)
+
+
+def test_ModuleElement_repr():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=2)
+    assert repr(e) == '[1, 2, 3, 4]/2'
+
+
+def test_ModuleElement_reduced():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([2, 4, 6, 8]), denom=2)
+    f = e.reduced()
+    assert f.denom == 1 and f == e
+
+
+def test_ModuleElement_reduced_mod_p():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([20, 40, 60, 80]))
+    f = e.reduced_mod_p(7)
+    assert f.coeffs == [-1, -2, -3, 3]
+
+
+def test_ModuleElement_from_int_list():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    c = [1, 2, 3, 4]
+    assert ModuleElement.from_int_list(A, c).coeffs == c
+
+
+def test_ModuleElement_len():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(0)
+    assert len(e) == 4
+
+
+def test_ModuleElement_column():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(0)
+    col1 = e.column()
+    assert col1 == e.col and col1 is not e.col
+    col2 = e.column(domain=FF(5))
+    assert col2.domain.is_FF
+
+
+def test_ModuleElement_QQ_col():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=1)
+    f = A(to_col([3, 6, 9, 12]), denom=3)
+    assert e.QQ_col == f.QQ_col
+
+
+def test_ModuleElement_to_ancestors():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = C.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    eD = D(0)
+    eC = eD.to_parent()
+    eB = eD.to_ancestor(B)
+    eA = eD.over_power_basis()
+    assert eC.module is C and eC.coeffs == [5, 0, 0, 0]
+    assert eB.module is B and eB.coeffs == [15, 0, 0, 0]
+    assert eA.module is A and eA.coeffs == [30, 0, 0, 0]
+
+    a = A(0)
+    raises(ValueError, lambda: a.to_parent())
+
+
+def test_ModuleElement_compatibility():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    D = B.submodule_from_matrix(5 * DomainMatrix.eye(4, ZZ))
+    assert C(0).is_compat(C(1)) is True
+    assert C(0).is_compat(D(0)) is False
+    u, v = C(0).unify(D(0))
+    assert u.module is B and v.module is B
+    assert C(C.represent(u)) == C(0) and D(D.represent(v)) == D(0)
+
+    u, v = C(0).unify(C(1))
+    assert u == C(0) and v == C(1)
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(UnificationFailed, lambda: C(0).unify(Z(1)))
+
+
+def test_ModuleElement_eq():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=1)
+    f = A(to_col([3, 6, 9, 12]), denom=3)
+    assert e == f
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    assert e != Z(0)
+    assert e != 3.14
+
+
+def test_ModuleElement_equiv():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 2, 3, 4]), denom=1)
+    f = A(to_col([3, 6, 9, 12]), denom=3)
+    assert e.equiv(f)
+
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    g = C(to_col([1, 2, 3, 4]), denom=1)
+    h = A(to_col([3, 6, 9, 12]), denom=1)
+    assert g.equiv(h)
+    assert C(to_col([5, 0, 0, 0]), denom=7).equiv(QQ(15, 7))
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(UnificationFailed, lambda: e.equiv(Z(0)))
+
+    assert e.equiv(3.14) is False
+
+
+def test_ModuleElement_add():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([1, 2, 3, 4]), denom=6)
+    f = A(to_col([5, 6, 7, 8]), denom=10)
+    g = C(to_col([1, 1, 1, 1]), denom=2)
+    assert e + f == A(to_col([10, 14, 18, 22]), denom=15)
+    assert e - f == A(to_col([-5, -4, -3, -2]), denom=15)
+    assert e + g == A(to_col([10, 11, 12, 13]), denom=6)
+    assert e + QQ(7, 10) == A(to_col([26, 10, 15, 20]), denom=30)
+    assert g + QQ(7, 10) == A(to_col([22, 15, 15, 15]), denom=10)
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(TypeError, lambda: e + Z(0))
+    raises(TypeError, lambda: e + 3.14)
+
+
+def test_ModuleElement_mul():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([0, 2, 0, 0]), denom=3)
+    f = A(to_col([0, 0, 0, 7]), denom=5)
+    g = C(to_col([0, 0, 0, 1]), denom=2)
+    h = A(to_col([0, 0, 3, 1]), denom=7)
+    assert e * f == A(to_col([-14, -14, -14, -14]), denom=15)
+    assert e * g == A(to_col([-1, -1, -1, -1]))
+    assert e * h == A(to_col([-2, -2, -2, 4]), denom=21)
+    assert e * QQ(6, 5) == A(to_col([0, 4, 0, 0]), denom=5)
+    assert (g * QQ(10, 21)).equiv(A(to_col([0, 0, 0, 5]), denom=7))
+    assert e // QQ(6, 5) == A(to_col([0, 5, 0, 0]), denom=9)
+
+    U = Poly(cyclotomic_poly(7, x))
+    Z = PowerBasis(U)
+    raises(TypeError, lambda: e * Z(0))
+    raises(TypeError, lambda: e * 3.14)
+    raises(TypeError, lambda: e // 3.14)
+    raises(ZeroDivisionError, lambda: e // 0)
+
+
+def test_ModuleElement_div():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([0, 2, 0, 0]), denom=3)
+    f = A(to_col([0, 0, 0, 7]), denom=5)
+    g = C(to_col([1, 1, 1, 1]))
+    assert e // f == 10*A(3)//21
+    assert e // g == -2*A(2)//9
+    assert 3 // g == -A(1)
+
+
+def test_ModuleElement_pow():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    C = A.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
+    e = A(to_col([0, 2, 0, 0]), denom=3)
+    g = C(to_col([0, 0, 0, 1]), denom=2)
+    assert e ** 3 == A(to_col([0, 0, 0, 8]), denom=27)
+    assert g ** 2 == C(to_col([0, 3, 0, 0]), denom=4)
+    assert e ** 0 == A(to_col([1, 0, 0, 0]))
+    assert g ** 0 == A(to_col([1, 0, 0, 0]))
+    assert e ** 1 == e
+    assert g ** 1 == g
+
+
+def test_ModuleElement_mod():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 15, 8, 0]), denom=2)
+    assert e % 7 == A(to_col([1, 1, 8, 0]), denom=2)
+    assert e % QQ(1, 2) == A.zero()
+    assert e % QQ(1, 3) == A(to_col([1, 1, 0, 0]), denom=6)
+
+    B = A.submodule_from_gens([A(0), 5*A(1), 3*A(2), A(3)])
+    assert e % B == A(to_col([1, 5, 2, 0]), denom=2)
+
+    C = B.whole_submodule()
+    raises(TypeError, lambda: e % C)
+
+
+def test_PowerBasisElement_polys():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 15, 8, 0]), denom=2)
+    assert e.numerator(x=zeta) == Poly(8 * zeta ** 2 + 15 * zeta + 1, domain=ZZ)
+    assert e.poly(x=zeta) == Poly(4 * zeta ** 2 + QQ(15, 2) * zeta + QQ(1, 2), domain=QQ)
+
+
+def test_PowerBasisElement_norm():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    lam = A(to_col([1, -1, 0, 0]))
+    assert lam.norm() == 5
+
+
+def test_PowerBasisElement_inverse():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    e = A(to_col([1, 1, 1, 1]))
+    assert 2 // e == -2*A(1)
+    assert e ** -3 == -A(3)
+
+
+def test_ModuleHomomorphism_matrix():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    phi = ModuleEndomorphism(A, lambda a: a ** 2)
+    M = phi.matrix()
+    assert M == DomainMatrix([
+        [1, 0, -1, 0],
+        [0, 0, -1, 1],
+        [0, 1, -1, 0],
+        [0, 0, -1, 0]
+    ], (4, 4), ZZ)
+
+
+def test_ModuleHomomorphism_kernel():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    phi = ModuleEndomorphism(A, lambda a: a ** 5)
+    N = phi.kernel()
+    assert N.n == 3
+
+
+def test_EndomorphismRing_represent():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    R = A.endomorphism_ring()
+    phi = R.inner_endomorphism(A(1))
+    col = R.represent(phi)
+    assert col.transpose() == DomainMatrix([
+        [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1]
+    ], (1, 16), ZZ)
+
+    B = A.submodule_from_matrix(DomainMatrix.zeros((4, 0), ZZ))
+    S = B.endomorphism_ring()
+    psi = S.inner_endomorphism(A(1))
+    col = S.represent(psi)
+    assert col == DomainMatrix([], (0, 0), ZZ)
+
+    raises(NotImplementedError, lambda: R.represent(3.14))
+
+
+def test_find_min_poly():
+    T = Poly(cyclotomic_poly(5, x))
+    A = PowerBasis(T)
+    powers = []
+    m = find_min_poly(A(1), QQ, x=x, powers=powers)
+    assert m == Poly(T, domain=QQ)
+    assert len(powers) == 5
+
+    # powers list need not be passed
+    m = find_min_poly(A(1), QQ, x=x)
+    assert m == Poly(T, domain=QQ)
+
+    B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
+    raises(MissingUnityError, lambda: find_min_poly(B(1), QQ))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_numbers.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_primes.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_subfield.py

@@ -0,0 +1,317 @@
+"""Tests for the subfield problem and allied problems. """
+
+from sympy.core.numbers import (AlgebraicNumber, I, pi, Rational)
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.external.gmpy import MPQ
+from sympy.polys.numberfields.subfield import (
+    is_isomorphism_possible,
+    field_isomorphism_pslq,
+    field_isomorphism,
+    primitive_element,
+    to_number_field,
+)
+from sympy.polys.domains import QQ
+from sympy.polys.polyerrors import IsomorphismFailed
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.testing.pytest import raises
+
+from sympy.abc import x
+
+Q = Rational
+
+
+def test_field_isomorphism_pslq():
+    a = AlgebraicNumber(I)
+    b = AlgebraicNumber(I*sqrt(3))
+
+    raises(NotImplementedError, lambda: field_isomorphism_pslq(a, b))
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(3))
+    c = AlgebraicNumber(sqrt(7))
+    d = AlgebraicNumber(sqrt(2) + sqrt(3))
+    e = AlgebraicNumber(sqrt(2) + sqrt(3) + sqrt(7))
+
+    assert field_isomorphism_pslq(a, a) == [1, 0]
+    assert field_isomorphism_pslq(a, b) is None
+    assert field_isomorphism_pslq(a, c) is None
+    assert field_isomorphism_pslq(a, d) == [Q(1, 2), 0, -Q(9, 2), 0]
+    assert field_isomorphism_pslq(
+        a, e) == [Q(1, 80), 0, -Q(1, 2), 0, Q(59, 20), 0]
+
+    assert field_isomorphism_pslq(b, a) is None
+    assert field_isomorphism_pslq(b, b) == [1, 0]
+    assert field_isomorphism_pslq(b, c) is None
+    assert field_isomorphism_pslq(b, d) == [-Q(1, 2), 0, Q(11, 2), 0]
+    assert field_isomorphism_pslq(b, e) == [-Q(
+        3, 640), 0, Q(67, 320), 0, -Q(297, 160), 0, Q(313, 80), 0]
+
+    assert field_isomorphism_pslq(c, a) is None
+    assert field_isomorphism_pslq(c, b) is None
+    assert field_isomorphism_pslq(c, c) == [1, 0]
+    assert field_isomorphism_pslq(c, d) is None
+    assert field_isomorphism_pslq(c, e) == [Q(
+        3, 640), 0, -Q(71, 320), 0, Q(377, 160), 0, -Q(469, 80), 0]
+
+    assert field_isomorphism_pslq(d, a) is None
+    assert field_isomorphism_pslq(d, b) is None
+    assert field_isomorphism_pslq(d, c) is None
+    assert field_isomorphism_pslq(d, d) == [1, 0]
+    assert field_isomorphism_pslq(d, e) == [-Q(
+        3, 640), 0, Q(71, 320), 0, -Q(377, 160), 0, Q(549, 80), 0]
+
+    assert field_isomorphism_pslq(e, a) is None
+    assert field_isomorphism_pslq(e, b) is None
+    assert field_isomorphism_pslq(e, c) is None
+    assert field_isomorphism_pslq(e, d) is None
+    assert field_isomorphism_pslq(e, e) == [1, 0]
+
+    f = AlgebraicNumber(3*sqrt(2) + 8*sqrt(7) - 5)
+
+    assert field_isomorphism_pslq(
+        f, e) == [Q(3, 80), 0, -Q(139, 80), 0, Q(347, 20), 0, -Q(761, 20), -5]
+
+
+def test_field_isomorphism():
+    assert field_isomorphism(3, sqrt(2)) == [3]
+
+    assert field_isomorphism( I*sqrt(3), I*sqrt(3)/2) == [ 2, 0]
+    assert field_isomorphism(-I*sqrt(3), I*sqrt(3)/2) == [-2, 0]
+
+    assert field_isomorphism( I*sqrt(3), -I*sqrt(3)/2) == [-2, 0]
+    assert field_isomorphism(-I*sqrt(3), -I*sqrt(3)/2) == [ 2, 0]
+
+    assert field_isomorphism( 2*I*sqrt(3)/7, 5*I*sqrt(3)/3) == [ Rational(6, 35), 0]
+    assert field_isomorphism(-2*I*sqrt(3)/7, 5*I*sqrt(3)/3) == [Rational(-6, 35), 0]
+
+    assert field_isomorphism( 2*I*sqrt(3)/7, -5*I*sqrt(3)/3) == [Rational(-6, 35), 0]
+    assert field_isomorphism(-2*I*sqrt(3)/7, -5*I*sqrt(3)/3) == [ Rational(6, 35), 0]
+
+    assert field_isomorphism(
+        2*I*sqrt(3)/7 + 27, 5*I*sqrt(3)/3) == [ Rational(6, 35), 27]
+    assert field_isomorphism(
+        -2*I*sqrt(3)/7 + 27, 5*I*sqrt(3)/3) == [Rational(-6, 35), 27]
+
+    assert field_isomorphism(
+        2*I*sqrt(3)/7 + 27, -5*I*sqrt(3)/3) == [Rational(-6, 35), 27]
+    assert field_isomorphism(
+        -2*I*sqrt(3)/7 + 27, -5*I*sqrt(3)/3) == [ Rational(6, 35), 27]
+
+    p = AlgebraicNumber( sqrt(2) + sqrt(3))
+    q = AlgebraicNumber(-sqrt(2) + sqrt(3))
+    r = AlgebraicNumber( sqrt(2) - sqrt(3))
+    s = AlgebraicNumber(-sqrt(2) - sqrt(3))
+
+    pos_coeffs = [ S.Half, S.Zero, Rational(-9, 2), S.Zero]
+    neg_coeffs = [Rational(-1, 2), S.Zero, Rational(9, 2), S.Zero]
+
+    a = AlgebraicNumber(sqrt(2))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == pos_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_coeffs
+    assert field_isomorphism(a, s, fast=True) == neg_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == pos_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_coeffs
+    assert field_isomorphism(a, s, fast=False) == neg_coeffs
+
+    a = AlgebraicNumber(-sqrt(2))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == neg_coeffs
+    assert field_isomorphism(a, q, fast=True) == pos_coeffs
+    assert field_isomorphism(a, r, fast=True) == neg_coeffs
+    assert field_isomorphism(a, s, fast=True) == pos_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == neg_coeffs
+    assert field_isomorphism(a, q, fast=False) == pos_coeffs
+    assert field_isomorphism(a, r, fast=False) == neg_coeffs
+    assert field_isomorphism(a, s, fast=False) == pos_coeffs
+
+    pos_coeffs = [ S.Half, S.Zero, Rational(-11, 2), S.Zero]
+    neg_coeffs = [Rational(-1, 2), S.Zero, Rational(11, 2), S.Zero]
+
+    a = AlgebraicNumber(sqrt(3))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == neg_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_coeffs
+    assert field_isomorphism(a, s, fast=True) == pos_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == neg_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_coeffs
+    assert field_isomorphism(a, s, fast=False) == pos_coeffs
+
+    a = AlgebraicNumber(-sqrt(3))
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == pos_coeffs
+    assert field_isomorphism(a, q, fast=True) == pos_coeffs
+    assert field_isomorphism(a, r, fast=True) == neg_coeffs
+    assert field_isomorphism(a, s, fast=True) == neg_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == pos_coeffs
+    assert field_isomorphism(a, q, fast=False) == pos_coeffs
+    assert field_isomorphism(a, r, fast=False) == neg_coeffs
+    assert field_isomorphism(a, s, fast=False) == neg_coeffs
+
+    pos_coeffs = [ Rational(3, 2), S.Zero, Rational(-33, 2), -S(8)]
+    neg_coeffs = [Rational(-3, 2), S.Zero, Rational(33, 2), -S(8)]
+
+    a = AlgebraicNumber(3*sqrt(3) - 8)
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == neg_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_coeffs
+    assert field_isomorphism(a, s, fast=True) == pos_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == neg_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_coeffs
+    assert field_isomorphism(a, s, fast=False) == pos_coeffs
+
+    a = AlgebraicNumber(3*sqrt(2) + 2*sqrt(3) + 1)
+
+    pos_1_coeffs = [ S.Half, S.Zero, Rational(-5, 2), S.One]
+    neg_5_coeffs = [Rational(-5, 2), S.Zero, Rational(49, 2), S.One]
+    pos_5_coeffs = [ Rational(5, 2), S.Zero, Rational(-49, 2), S.One]
+    neg_1_coeffs = [Rational(-1, 2), S.Zero, Rational(5, 2), S.One]
+
+    assert is_isomorphism_possible(a, p) is True
+    assert is_isomorphism_possible(a, q) is True
+    assert is_isomorphism_possible(a, r) is True
+    assert is_isomorphism_possible(a, s) is True
+
+    assert field_isomorphism(a, p, fast=True) == pos_1_coeffs
+    assert field_isomorphism(a, q, fast=True) == neg_5_coeffs
+    assert field_isomorphism(a, r, fast=True) == pos_5_coeffs
+    assert field_isomorphism(a, s, fast=True) == neg_1_coeffs
+
+    assert field_isomorphism(a, p, fast=False) == pos_1_coeffs
+    assert field_isomorphism(a, q, fast=False) == neg_5_coeffs
+    assert field_isomorphism(a, r, fast=False) == pos_5_coeffs
+    assert field_isomorphism(a, s, fast=False) == neg_1_coeffs
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(sqrt(3))
+    c = AlgebraicNumber(sqrt(7))
+
+    assert is_isomorphism_possible(a, b) is True
+    assert is_isomorphism_possible(b, a) is True
+
+    assert is_isomorphism_possible(c, p) is False
+
+    assert field_isomorphism(sqrt(2), sqrt(3), fast=True) is None
+    assert field_isomorphism(sqrt(3), sqrt(2), fast=True) is None
+
+    assert field_isomorphism(sqrt(2), sqrt(3), fast=False) is None
+    assert field_isomorphism(sqrt(3), sqrt(2), fast=False) is None
+
+    a = AlgebraicNumber(sqrt(2))
+    b = AlgebraicNumber(2 ** (S(1) / 3))
+
+    assert is_isomorphism_possible(a, b) is False
+    assert field_isomorphism(a, b) is None
+
+
+def test_primitive_element():
+    assert primitive_element([sqrt(2)], x) == (x**2 - 2, [1])
+    assert primitive_element(
+        [sqrt(2), sqrt(3)], x) == (x**4 - 10*x**2 + 1, [1, 1])
+
+    assert primitive_element([sqrt(2)], x, polys=True) == (Poly(x**2 - 2, domain='QQ'), [1])
+    assert primitive_element([sqrt(
+        2), sqrt(3)], x, polys=True) == (Poly(x**4 - 10*x**2 + 1, domain='QQ'), [1, 1])
+
+    assert primitive_element(
+        [sqrt(2)], x, ex=True) == (x**2 - 2, [1], [[1, 0]])
+    assert primitive_element([sqrt(2), sqrt(3)], x, ex=True) == \
+        (x**4 - 10*x**2 + 1, [1, 1], [[Q(1, 2), 0, -Q(9, 2), 0], [-
+         Q(1, 2), 0, Q(11, 2), 0]])
+
+    assert primitive_element(
+        [sqrt(2)], x, ex=True, polys=True) == (Poly(x**2 - 2, domain='QQ'), [1], [[1, 0]])
+    assert primitive_element([sqrt(2), sqrt(3)], x, ex=True, polys=True) == \
+        (Poly(x**4 - 10*x**2 + 1, domain='QQ'), [1, 1], [[Q(1, 2), 0, -Q(9, 2),
+         0], [-Q(1, 2), 0, Q(11, 2), 0]])
+
+    assert primitive_element([sqrt(2)], polys=True) == (Poly(x**2 - 2), [1])
+
+    raises(ValueError, lambda: primitive_element([], x, ex=False))
+    raises(ValueError, lambda: primitive_element([], x, ex=True))
+
+    # Issue 14117
+    a, b = I*sqrt(2*sqrt(2) + 3), I*sqrt(-2*sqrt(2) + 3)
+    assert primitive_element([a, b, I], x) == (x**4 + 6*x**2 + 1, [1, 0, 0])
+
+    assert primitive_element([sqrt(2), 0], x) == (x**2 - 2, [1, 0])
+    assert primitive_element([0, sqrt(2)], x) == (x**2 - 2, [1, 1])
+    assert primitive_element([sqrt(2), 0], x, ex=True) == (x**2 - 2, [1, 0], [[MPQ(1,1), MPQ(0,1)], []])
+    assert primitive_element([0, sqrt(2)], x, ex=True) == (x**2 - 2, [1, 1], [[], [MPQ(1,1), MPQ(0,1)]])
+
+
+def test_to_number_field():
+    assert to_number_field(sqrt(2)) == AlgebraicNumber(sqrt(2))
+    assert to_number_field(
+        [sqrt(2), sqrt(3)]) == AlgebraicNumber(sqrt(2) + sqrt(3))
+
+    a = AlgebraicNumber(sqrt(2) + sqrt(3), [S.Half, S.Zero, Rational(-9, 2), S.Zero])
+
+    assert to_number_field(sqrt(2), sqrt(2) + sqrt(3)) == a
+    assert to_number_field(sqrt(2), AlgebraicNumber(sqrt(2) + sqrt(3))) == a
+
+    raises(IsomorphismFailed, lambda: to_number_field(sqrt(2), sqrt(3)))
+
+
+def test_issue_22561():
+    a = to_number_field(sqrt(2), sqrt(2) + sqrt(3))
+    b = to_number_field(sqrt(2), sqrt(2) + sqrt(5))
+    assert field_isomorphism(a, b) == [1, 0]
+
+
+def test_issue_22736():
+    a = CRootOf(x**4 + x**3 + x**2 + x + 1, -1)
+    a._reset()
+    b = exp(2*I*pi/5)
+    assert field_isomorphism(a, b) == [1, 0]
+
+
+def test_issue_27798():
+    # https://github.com/sympy/sympy/issues/27798
+    a, b = CRootOf(49*x**3 - 49*x**2 + 14*x - 1, 2), CRootOf(49*x**3 - 49*x**2 + 14*x - 1, 0)
+    assert primitive_element([a, b], polys=True)[0].primitive()[0] == 1
+    assert primitive_element([a, b], polys=True, ex=True)[0].primitive()[0] == 1
+
+    f1, f2 = QQ.algebraic_field(a), QQ.algebraic_field(b)
+    f3 = f1.unify(f2)
+    assert f3.mod.primitive()[0] == 1
+    assert Poly(x, x, domain=f1) + Poly(x, x, domain=f2) == Poly(2*x, x, domain=f3)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_utilities.py

@@ -0,0 +1,113 @@
+from sympy.abc import x
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys import Poly, cyclotomic_poly
+from sympy.polys.domains import FF, QQ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.matrices.exceptions import DMRankError
+from sympy.polys.numberfields.utilities import (
+    AlgIntPowers, coeff_search, extract_fundamental_discriminant,
+    isolate, supplement_a_subspace,
+)
+from sympy.printing.lambdarepr import IntervalPrinter
+from sympy.testing.pytest import raises
+
+
+def test_AlgIntPowers_01():
+    T = Poly(cyclotomic_poly(5))
+    zeta_pow = AlgIntPowers(T)
+    raises(ValueError, lambda: zeta_pow[-1])
+    for e in range(10):
+        a = e % 5
+        if a < 4:
+            c = zeta_pow[e]
+            assert c[a] == 1 and all(c[i] == 0 for i in range(4) if i != a)
+        else:
+            assert zeta_pow[e] == [-1] * 4
+
+
+def test_AlgIntPowers_02():
+    T = Poly(x**3 + 2*x**2 + 3*x + 4)
+    m = 7
+    theta_pow = AlgIntPowers(T, m)
+    for e in range(10):
+        computed = theta_pow[e]
+        coeffs = (Poly(x)**e % T + Poly(x**3)).rep.to_list()[1:]
+        expected = [c % m for c in reversed(coeffs)]
+        assert computed == expected
+
+
+def test_coeff_search():
+    C = []
+    search = coeff_search(2, 1)
+    for i, c in enumerate(search):
+        C.append(c)
+        if i == 12:
+            break
+    assert C == [[1, 1], [1, 0], [1, -1], [0, 1], [2, 2], [2, 1], [2, 0], [2, -1], [2, -2], [1, 2], [1, -2], [0, 2], [3, 3]]
+
+
+def test_extract_fundamental_discriminant():
+    # To extract, integer must be 0 or 1 mod 4.
+    raises(ValueError, lambda: extract_fundamental_discriminant(2))
+    raises(ValueError, lambda: extract_fundamental_discriminant(3))
+    # Try many cases, of different forms:
+    cases = (
+        (0, {}, {0: 1}),
+        (1, {}, {}),
+        (8, {2: 3}, {}),
+        (-8, {2: 3, -1: 1}, {}),
+        (12, {2: 2, 3: 1}, {}),
+        (36, {}, {2: 1, 3: 1}),
+        (45, {5: 1}, {3: 1}),
+        (48, {2: 2, 3: 1}, {2: 1}),
+        (1125, {5: 1}, {3: 1, 5: 1}),
+    )
+    for a, D_expected, F_expected in cases:
+        D, F = extract_fundamental_discriminant(a)
+        assert D == D_expected
+        assert F == F_expected
+
+
+def test_supplement_a_subspace_1():
+    M = DM([[1, 7, 0], [2, 3, 4]], QQ).transpose()
+
+    # First supplement over QQ:
+    B = supplement_a_subspace(M)
+    assert B[:, :2] == M
+    assert B[:, 2] == DomainMatrix.eye(3, QQ).to_dense()[:, 0]
+
+    # Now supplement over FF(7):
+    M = M.convert_to(FF(7))
+    B = supplement_a_subspace(M)
+    assert B[:, :2] == M
+    # When we work mod 7, first col of M goes to [1, 0, 0],
+    # so the supplementary vector cannot equal this, as it did
+    # when we worked over QQ. Instead, we get the second std basis vector:
+    assert B[:, 2] == DomainMatrix.eye(3, FF(7)).to_dense()[:, 1]
+
+
+def test_supplement_a_subspace_2():
+    M = DM([[1, 0, 0], [2, 0, 0]], QQ).transpose()
+    with raises(DMRankError):
+        supplement_a_subspace(M)
+
+
+def test_IntervalPrinter():
+    ip = IntervalPrinter()
+    assert ip.doprint(x**Rational(1, 3)) == "x**(mpi('1/3'))"
+    assert ip.doprint(sqrt(x)) == "x**(mpi('1/2'))"
+
+
+def test_isolate():
+    assert isolate(1) == (1, 1)
+    assert isolate(S.Half) == (S.Half, S.Half)
+
+    assert isolate(sqrt(2)) == (1, 2)
+    assert isolate(-sqrt(2)) == (-2, -1)
+
+    assert isolate(sqrt(2), eps=Rational(1, 100)) == (Rational(24, 17), Rational(17, 12))
+    assert isolate(-sqrt(2), eps=Rational(1, 100)) == (Rational(-17, 12), Rational(-24, 17))
+
+    raises(NotImplementedError, lambda: isolate(I))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/numberfields/utilities.py

@@ -0,0 +1,474 @@
+"""Utilities for algebraic number theory. """
+
+from sympy.core.sympify import sympify
+from sympy.ntheory.factor_ import factorint
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.matrices.exceptions import DMRankError
+from sympy.polys.numberfields.minpoly import minpoly
+from sympy.printing.lambdarepr import IntervalPrinter
+from sympy.utilities.decorator import public
+from sympy.utilities.lambdify import lambdify
+
+from mpmath import mp
+
+
+def is_rat(c):
+    r"""
+    Test whether an argument is of an acceptable type to be used as a rational
+    number.
+
+    Explanation
+    ===========
+
+    Returns ``True`` on any argument of type ``int``, :ref:`ZZ`, or :ref:`QQ`.
+
+    See Also
+    ========
+
+    is_int
+
+    """
+    # ``c in QQ`` is too accepting (e.g. ``3.14 in QQ`` is ``True``),
+    # ``QQ.of_type(c)`` is too demanding (e.g. ``QQ.of_type(3)`` is ``False``).
+    #
+    # Meanwhile, if gmpy2 is installed then ``ZZ.of_type()`` accepts only
+    # ``mpz``, not ``int``, so we need another clause to ensure ``int`` is
+    # accepted.
+    return isinstance(c, int) or ZZ.of_type(c) or QQ.of_type(c)
+
+
+def is_int(c):
+    r"""
+    Test whether an argument is of an acceptable type to be used as an integer.
+
+    Explanation
+    ===========
+
+    Returns ``True`` on any argument of type ``int`` or :ref:`ZZ`.
+
+    See Also
+    ========
+
+    is_rat
+
+    """
+    # If gmpy2 is installed then ``ZZ.of_type()`` accepts only
+    # ``mpz``, not ``int``, so we need another clause to ensure ``int`` is
+    # accepted.
+    return isinstance(c, int) or ZZ.of_type(c)
+
+
+def get_num_denom(c):
+    r"""
+    Given any argument on which :py:func:`~.is_rat` is ``True``, return the
+    numerator and denominator of this number.
+
+    See Also
+    ========
+
+    is_rat
+
+    """
+    r = QQ(c)
+    return r.numerator, r.denominator
+
+
+@public
+def extract_fundamental_discriminant(a):
+    r"""
+    Extract a fundamental discriminant from an integer *a*.
+
+    Explanation
+    ===========
+
+    Given any rational integer *a* that is 0 or 1 mod 4, write $a = d f^2$,
+    where $d$ is either 1 or a fundamental discriminant, and return a pair
+    of dictionaries ``(D, F)`` giving the prime factorizations of $d$ and $f$
+    respectively, in the same format returned by :py:func:`~.factorint`.
+
+    A fundamental discriminant $d$ is different from unity, and is either
+    1 mod 4 and squarefree, or is 0 mod 4 and such that $d/4$ is squarefree
+    and 2 or 3 mod 4. This is the same as being the discriminant of some
+    quadratic field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.numberfields.utilities import extract_fundamental_discriminant
+    >>> print(extract_fundamental_discriminant(-432))
+    ({3: 1, -1: 1}, {2: 2, 3: 1})
+
+    For comparison:
+
+    >>> from sympy import factorint
+    >>> print(factorint(-432))
+    {2: 4, 3: 3, -1: 1}
+
+    Parameters
+    ==========
+
+    a: int, must be 0 or 1 mod 4
+
+    Returns
+    =======
+
+    Pair ``(D, F)``  of dictionaries.
+
+    Raises
+    ======
+
+    ValueError
+        If *a* is not 0 or 1 mod 4.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Prop. 5.1.3)
+
+    """
+    if a % 4 not in [0, 1]:
+        raise ValueError('To extract fundamental discriminant, number must be 0 or 1 mod 4.')
+    if a == 0:
+        return {}, {0: 1}
+    if a == 1:
+        return {}, {}
+    a_factors = factorint(a)
+    D = {}
+    F = {}
+    # First pass: just make d squarefree, and a/d a perfect square.
+    # We'll count primes (and units! i.e. -1) that are 3 mod 4 and present in d.
+    num_3_mod_4 = 0
+    for p, e in a_factors.items():
+        if e % 2 == 1:
+            D[p] = 1
+            if p % 4 == 3:
+                num_3_mod_4 += 1
+            if e >= 3:
+                F[p] = (e - 1) // 2
+        else:
+            F[p] = e // 2
+    # Second pass: if d is cong. to 2 or 3 mod 4, then we must steal away
+    # another factor of 4 from f**2 and give it to d.
+    even = 2 in D
+    if even or num_3_mod_4 % 2 == 1:
+        e2 = F[2]
+        assert e2 > 0
+        if e2 == 1:
+            del F[2]
+        else:
+            F[2] = e2 - 1
+        D[2] = 3 if even else 2
+    return D, F
+
+
+@public
+class AlgIntPowers:
+    r"""
+    Compute the powers of an algebraic integer.
+
+    Explanation
+    ===========
+
+    Given an algebraic integer $\theta$ by its monic irreducible polynomial
+    ``T`` over :ref:`ZZ`, this class computes representations of arbitrarily
+    high powers of $\theta$, as :ref:`ZZ`-linear combinations over
+    $\{1, \theta, \ldots, \theta^{n-1}\}$, where $n = \deg(T)$.
+
+    The representations are computed using the linear recurrence relations for
+    powers of $\theta$, derived from the polynomial ``T``. See [1], Sec. 4.2.2.
+
+    Optionally, the representations may be reduced with respect to a modulus.
+
+    Examples
+    ========
+
+    >>> from sympy import Poly, cyclotomic_poly
+    >>> from sympy.polys.numberfields.utilities import AlgIntPowers
+    >>> T = Poly(cyclotomic_poly(5))
+    >>> zeta_pow = AlgIntPowers(T)
+    >>> print(zeta_pow[0])
+    [1, 0, 0, 0]
+    >>> print(zeta_pow[1])
+    [0, 1, 0, 0]
+    >>> print(zeta_pow[4])  # doctest: +SKIP
+    [-1, -1, -1, -1]
+    >>> print(zeta_pow[24])  # doctest: +SKIP
+    [-1, -1, -1, -1]
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+
+    """
+
+    def __init__(self, T, modulus=None):
+        """
+        Parameters
+        ==========
+
+        T : :py:class:`~.Poly`
+            The monic irreducible polynomial over :ref:`ZZ` defining the
+            algebraic integer.
+
+        modulus : int, None, optional
+            If not ``None``, all representations will be reduced w.r.t. this.
+
+        """
+        self.T = T
+        self.modulus = modulus
+        self.n = T.degree()
+        self.powers_n_and_up = [[-c % self for c in reversed(T.rep.to_list())][:-1]]
+        self.max_so_far = self.n
+
+    def red(self, exp):
+        return exp if self.modulus is None else exp % self.modulus
+
+    def __rmod__(self, other):
+        return self.red(other)
+
+    def compute_up_through(self, e):
+        m = self.max_so_far
+        if e <= m: return
+        n = self.n
+        r = self.powers_n_and_up
+        c = r[0]
+        for k in range(m+1, e+1):
+            b = r[k-1-n][n-1]
+            r.append(
+                [c[0]*b % self] + [
+                    (r[k-1-n][i-1] + c[i]*b) % self for i in range(1, n)
+                ]
+            )
+        self.max_so_far = e
+
+    def get(self, e):
+        n = self.n
+        if e < 0:
+            raise ValueError('Exponent must be non-negative.')
+        elif e < n:
+            return [1 if i == e else 0 for i in range(n)]
+        else:
+            self.compute_up_through(e)
+            return self.powers_n_and_up[e - n]
+
+    def __getitem__(self, item):
+        return self.get(item)
+
+
+@public
+def coeff_search(m, R):
+    r"""
+    Generate coefficients for searching through polynomials.
+
+    Explanation
+    ===========
+
+    Lead coeff is always non-negative. Explore all combinations with coeffs
+    bounded in absolute value before increasing the bound. Skip the all-zero
+    list, and skip any repeats. See examples.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.numberfields.utilities import coeff_search
+    >>> cs = coeff_search(2, 1)
+    >>> C = [next(cs) for i in range(13)]
+    >>> print(C)
+    [[1, 1], [1, 0], [1, -1], [0, 1], [2, 2], [2, 1], [2, 0], [2, -1], [2, -2],
+     [1, 2], [1, -2], [0, 2], [3, 3]]
+
+    Parameters
+    ==========
+
+    m : int
+        Length of coeff list.
+    R : int
+        Initial max abs val for coeffs (will increase as search proceeds).
+
+    Returns
+    =======
+
+    generator
+        Infinite generator of lists of coefficients.
+
+    """
+    R0 = R
+    c = [R] * m
+    while True:
+        if R == R0 or R in c or -R in c:
+            yield c[:]
+        j = m - 1
+        while c[j] == -R:
+            j -= 1
+        c[j] -= 1
+        for i in range(j + 1, m):
+            c[i] = R
+        for j in range(m):
+            if c[j] != 0:
+                break
+        else:
+            R += 1
+            c = [R] * m
+
+
+def supplement_a_subspace(M):
+    r"""
+    Extend a basis for a subspace to a basis for the whole space.
+
+    Explanation
+    ===========
+
+    Given an $n \times r$ matrix *M* of rank $r$ (so $r \leq n$), this function
+    computes an invertible $n \times n$ matrix $B$ such that the first $r$
+    columns of $B$ equal *M*.
+
+    This operation can be interpreted as a way of extending a basis for a
+    subspace, to give a basis for the whole space.
+
+    To be precise, suppose you have an $n$-dimensional vector space $V$, with
+    basis $\{v_1, v_2, \ldots, v_n\}$, and an $r$-dimensional subspace $W$ of
+    $V$, spanned by a basis $\{w_1, w_2, \ldots, w_r\}$, where the $w_j$ are
+    given as linear combinations of the $v_i$. If the columns of *M* represent
+    the $w_j$ as such linear combinations, then the columns of the matrix $B$
+    computed by this function give a new basis $\{u_1, u_2, \ldots, u_n\}$ for
+    $V$, again relative to the $\{v_i\}$ basis, and such that $u_j = w_j$
+    for $1 \leq j \leq r$.
+
+    Examples
+    ========
+
+    Note: The function works in terms of columns, so in these examples we
+    print matrix transposes in order to make the columns easier to inspect.
+
+    >>> from sympy.polys.matrices import DM
+    >>> from sympy import QQ, FF
+    >>> from sympy.polys.numberfields.utilities import supplement_a_subspace
+    >>> M = DM([[1, 7, 0], [2, 3, 4]], QQ).transpose()
+    >>> print(supplement_a_subspace(M).to_Matrix().transpose())
+    Matrix([[1, 7, 0], [2, 3, 4], [1, 0, 0]])
+
+    >>> M2 = M.convert_to(FF(7))
+    >>> print(M2.to_Matrix().transpose())
+    Matrix([[1, 0, 0], [2, 3, -3]])
+    >>> print(supplement_a_subspace(M2).to_Matrix().transpose())
+    Matrix([[1, 0, 0], [2, 3, -3], [0, 1, 0]])
+
+    Parameters
+    ==========
+
+    M : :py:class:`~.DomainMatrix`
+        The columns give the basis for the subspace.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        This matrix is invertible and its first $r$ columns equal *M*.
+
+    Raises
+    ======
+
+    DMRankError
+        If *M* was not of maximal rank.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*
+       (See Sec. 2.3.2.)
+
+    """
+    n, r = M.shape
+    # Let In be the n x n identity matrix.
+    # Form the augmented matrix [M | In] and compute RREF.
+    Maug = M.hstack(M.eye(n, M.domain))
+    R, pivots = Maug.rref()
+    if pivots[:r] != tuple(range(r)):
+        raise DMRankError('M was not of maximal rank')
+    # Let J be the n x r matrix equal to the first r columns of In.
+    # Since M is of rank r, RREF reduces [M | In] to [J | A], where A is the product of
+    # elementary matrices Ei corresp. to the row ops performed by RREF. Since the Ei are
+    # invertible, so is A. Let B = A^(-1).
+    A = R[:, r:]
+    B = A.inv()
+    # Then B is the desired matrix. It is invertible, since B^(-1) == A.
+    # And A * [M | In] == [J | A]
+    #  => A * M == J
+    #  => M == B * J == the first r columns of B.
+    return B
+
+
+@public
+def isolate(alg, eps=None, fast=False):
+    """
+    Find a rational isolating interval for a real algebraic number.
+
+    Examples
+    ========
+
+    >>> from sympy import isolate, sqrt, Rational
+    >>> print(isolate(sqrt(2)))  # doctest: +SKIP
+    (1, 2)
+    >>> print(isolate(sqrt(2), eps=Rational(1, 100)))
+    (24/17, 17/12)
+
+    Parameters
+    ==========
+
+    alg : str, int, :py:class:`~.Expr`
+        The algebraic number to be isolated. Must be a real number, to use this
+        particular function. However, see also :py:meth:`.Poly.intervals`,
+        which isolates complex roots when you pass ``all=True``.
+    eps : positive element of :ref:`QQ`, None, optional (default=None)
+        Precision to be passed to :py:meth:`.Poly.refine_root`
+    fast : boolean, optional (default=False)
+        Say whether fast refinement procedure should be used.
+        (Will be passed to :py:meth:`.Poly.refine_root`.)
+
+    Returns
+    =======
+
+    Pair of rational numbers defining an isolating interval for the given
+    algebraic number.
+
+    See Also
+    ========
+
+    .Poly.intervals
+
+    """
+    alg = sympify(alg)
+
+    if alg.is_Rational:
+        return (alg, alg)
+    elif not alg.is_real:
+        raise NotImplementedError(
+            "complex algebraic numbers are not supported")
+
+    func = lambdify((), alg, modules="mpmath", printer=IntervalPrinter())
+
+    poly = minpoly(alg, polys=True)
+    intervals = poly.intervals(sqf=True)
+
+    dps, done = mp.dps, False
+
+    try:
+        while not done:
+            alg = func()
+
+            for a, b in intervals:
+                if a <= alg.a and alg.b <= b:
+                    done = True
+                    break
+            else:
+                mp.dps *= 2
+    finally:
+        mp.dps = dps
+
+    if eps is not None:
+        a, b = poly.refine_root(a, b, eps=eps, fast=fast)
+
+    return (a, b)

miniconda3/envs/ladir/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)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_constructor.py

@@ -0,0 +1,236 @@
+"""Tests for tools for constructing domains for expressions. """
+
+from sympy.testing.pytest import tooslow
+
+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 import rootof
+
+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_rootof():
+    r1 = rootof(x**3 + x + 1, 0)
+    r2 = rootof(x**3 + x + 1, 1)
+    K1 = QQ.algebraic_field(r1)
+    K2 = QQ.algebraic_field(r2)
+    assert construct_domain([r1]) == (EX, [EX(r1)])
+    assert construct_domain([r2]) == (EX, [EX(r2)])
+    assert construct_domain([r1, r2]) == (EX, [EX(r1), EX(r2)])
+
+    assert construct_domain([r1], extension=True) == (
+            K1, [K1.from_sympy(r1)])
+    assert construct_domain([r2], extension=True) == (
+            K2, [K2.from_sympy(r2)])
+
+
+@tooslow
+def test_rootof_primitive_element():
+    r1 = rootof(x**3 + x + 1, 0)
+    r2 = rootof(x**3 + x + 1, 1)
+    K12 = QQ.algebraic_field(r1 + r2)
+    assert construct_domain([r1, r2], extension=True) == (
+            K12, [K12.from_sympy(r1), K12.from_sympy(r2)])
+
+
+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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_densearith.py

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

miniconda3/envs/ladir/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)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_densetools.py

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

miniconda3/envs/ladir/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 happens 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

miniconda3/envs/ladir/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

miniconda3/envs/ladir/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)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_factortools.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_fields.py

@@ -0,0 +1,353 @@
+"""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] != field("x,y,z", ZZ)[0]
+    assert field("x,y,z", ZZ)[0] != field("x,y,z", QQ)[0]
+    assert field("x,y,z", QQ)[0] != field("x,y", QQ)[0]
+    assert field("x,y", QQ)[0] != 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 F.is_element(f)
+
+    f = F.from_expr(Rational(3, 7))
+    assert f == F(3)/7 and F.is_element(f)
+
+    f = F.from_expr(x)
+    assert f == X and F.is_element(f)
+
+    f = F.from_expr(Rational(3,7)*x)
+    assert f == X*Rational(3, 7) and F.is_element(f)
+
+    f = F.from_expr(1/x)
+    assert f == 1/X and F.is_element(f)
+
+    f = F.from_expr(x*y*z)
+    assert f == X*Y*Z and F.is_element(f)
+
+    f = F.from_expr(x*y/z)
+    assert f == X*Y/Z and F.is_element(f)
+
+    f = F.from_expr(x*y*z + x*y + x)
+    assert f == X*Y*Z + X*Y + X and F.is_element(f)
+
+    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 F.is_element(f)
+
+    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 F.is_element(f)
+
+    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

miniconda3/envs/ladir/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) == []

miniconda3/envs/ladir/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

miniconda3/envs/ladir/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

miniconda3/envs/ladir/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

miniconda3/envs/ladir/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)

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_modulargcd.py

@@ -0,0 +1,325 @@
+from sympy.polys.rings import ring
+from sympy.polys.domains import ZZ, QQ, AlgebraicField
+from sympy.polys.modulargcd import (
+    modgcd_univariate,
+    modgcd_bivariate,
+    _chinese_remainder_reconstruction_multivariate,
+    modgcd_multivariate,
+    _to_ZZ_poly,
+    _to_ANP_poly,
+    func_field_modgcd,
+    _func_field_modgcd_m)
+from sympy.functions.elementary.miscellaneous import sqrt
+
+
+def test_modgcd_univariate_integers():
+    R, x = ring("x", ZZ)
+
+    f, g = R.zero, R.zero
+    assert modgcd_univariate(f, g) == (0, 0, 0)
+
+    f, g = R.zero, x
+    assert modgcd_univariate(f, g) == (x, 0, 1)
+    assert modgcd_univariate(g, f) == (x, 1, 0)
+
+    f, g = R.zero, -x
+    assert modgcd_univariate(f, g) == (x, 0, -1)
+    assert modgcd_univariate(g, f) == (x, -1, 0)
+
+    f, g = 2*x, R(2)
+    assert modgcd_univariate(f, g) == (2, x, 1)
+
+    f, g = 2*x + 2, 6*x**2 - 6
+    assert modgcd_univariate(f, g) == (2*x + 2, 1, 3*x - 3)
+
+    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 modgcd_univariate(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 modgcd_univariate(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 modgcd_univariate(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
+
+    assert modgcd_univariate(f, f.diff(x))[0] == g
+
+    f = 1317378933230047068160*x + 2945748836994210856960
+    g = 120352542776360960*x + 269116466014453760
+
+    h = 120352542776360960*x + 269116466014453760
+    cff = 10946
+    cfg = 1
+
+    assert modgcd_univariate(f, g) == (h, cff, cfg)
+
+
+def test_modgcd_bivariate_integers():
+    R, x, y = ring("x,y", ZZ)
+
+    f, g = R.zero, R.zero
+    assert modgcd_bivariate(f, g) == (0, 0, 0)
+
+    f, g = 2*x, R(2)
+    assert modgcd_bivariate(f, g) == (2, x, 1)
+
+    f, g = x + 2*y, x + y
+    assert modgcd_bivariate(f, g) == (1, f, g)
+
+    f, g = x**2 + 2*x*y + y**2, x**3 + y**3
+    assert modgcd_bivariate(f, g) == (x + y, x + y, x**2 - x*y + y**2)
+
+    f, g = x*y**2 + 2*x*y + x, x*y**3 + x
+    assert modgcd_bivariate(f, g) == (x*y + x, y + 1, y**2 - y + 1)
+
+    f, g = x**2*y**2 + x**2*y + 1, x*y**2 + x*y + 1
+    assert modgcd_bivariate(f, g) == (1, f, g)
+
+    f = 2*x*y**2 + 4*x*y + 2*x + y**2 + 2*y + 1
+    g = 2*x*y**3 + 2*x + y**3 + 1
+    assert modgcd_bivariate(f, g) == (2*x*y + 2*x + y + 1, y + 1, y**2 - y + 1)
+
+    f, g = 2*x**2 + 4*x + 2, x + 1
+    assert modgcd_bivariate(f, g) == (x + 1, 2*x + 2, 1)
+
+    f, g = x + 1, 2*x**2 + 4*x + 2
+    assert modgcd_bivariate(f, g) == (x + 1, 1, 2*x + 2)
+
+    f = 2*x**2 + 4*x*y - 2*x - 4*y
+    g = x**2 + x - 2
+    assert modgcd_bivariate(f, g) == (x - 1, 2*x + 4*y, x + 2)
+
+    f = 2*x**2 + 2*x*y - 3*x - 3*y
+    g = 4*x*y - 2*x + 4*y**2 - 2*y
+    assert modgcd_bivariate(f, g) == (x + y, 2*x - 3, 4*y - 2)
+
+
+def test_chinese_remainder():
+    R, x, y = ring("x, y", ZZ)
+    p, q = 3, 5
+
+    hp = x**3*y - x**2 - 1
+    hq = -x**3*y - 2*x*y**2 + 2
+
+    hpq = _chinese_remainder_reconstruction_multivariate(hp, hq, p, q)
+
+    assert hpq.trunc_ground(p) == hp
+    assert hpq.trunc_ground(q) == hq
+
+    T, z = ring("z", R)
+    p, q = 3, 7
+
+    hp = (x*y + 1)*z**2 + x
+    hq = (x**2 - 3*y)*z + 2
+
+    hpq = _chinese_remainder_reconstruction_multivariate(hp, hq, p, q)
+
+    assert hpq.trunc_ground(p) == hp
+    assert hpq.trunc_ground(q) == hq
+
+
+def test_modgcd_multivariate_integers():
+    R, x, y = ring("x,y", ZZ)
+
+    f, g = R.zero, R.zero
+    assert modgcd_multivariate(f, g) == (0, 0, 0)
+
+    f, g = 2*x**2 + 4*x + 2, x + 1
+    assert modgcd_multivariate(f, g) == (x + 1, 2*x + 2, 1)
+
+    f, g = x + 1, 2*x**2 + 4*x + 2
+    assert modgcd_multivariate(f, g) == (x + 1, 1, 2*x + 2)
+
+    f = 2*x**2 + 2*x*y - 3*x - 3*y
+    g = 4*x*y - 2*x + 4*y**2 - 2*y
+    assert modgcd_multivariate(f, g) == (x + y, 2*x - 3, 4*y - 2)
+
+    f, g = x*y**2 + 2*x*y + x, x*y**3 + x
+    assert modgcd_multivariate(f, g) == (x*y + x, y + 1, y**2 - y + 1)
+
+    f, g = x**2*y**2 + x**2*y + 1, x*y**2 + x*y + 1
+    assert modgcd_multivariate(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 modgcd_multivariate(f, g) == (h, cff, cfg)
+
+    R, x, y, z, u = ring("x,y,z,u", ZZ)
+
+    f, g = x + y + z, -x - y - z - u
+    assert modgcd_multivariate(f, g) == (1, f, g)
+
+    f, g = u**2 + 2*u + 1, 2*u + 2
+    assert modgcd_multivariate(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 modgcd_multivariate(f, g) == (h, cff, cfg)
+    assert modgcd_multivariate(g, f) == (h, cfg, cff)
+
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f, g = x - y*z, x - y*z
+    assert modgcd_multivariate(f, g) == (x - y*z, 1, 1)
+
+    f, g, h = R.fateman_poly_F_1()
+    H, cff, cfg = modgcd_multivariate(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 = modgcd_multivariate(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 = modgcd_multivariate(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 = modgcd_multivariate(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 = modgcd_multivariate(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+    f, g, h = R.fateman_poly_F_3()
+    H, cff, cfg = modgcd_multivariate(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 = modgcd_multivariate(f, g)
+
+    assert H == h and H*cff == f and H*cfg == g
+
+
+def test_to_ZZ_ANP_poly():
+    A = AlgebraicField(QQ, sqrt(2))
+    R, x = ring("x", A)
+    f = x*(sqrt(2) + 1)
+
+    T, x_, z_ = ring("x_, z_", ZZ)
+    f_ = x_*z_ + x_
+
+    assert _to_ZZ_poly(f, T) == f_
+    assert _to_ANP_poly(f_, R) == f
+
+    R, x, t, s = ring("x, t, s", A)
+    f = x*t**2 + x*s + sqrt(2)
+
+    D, t_, s_ = ring("t_, s_", ZZ)
+    T, x_, z_ = ring("x_, z_", D)
+    f_ = (t_**2 + s_)*x_ + z_
+
+    assert _to_ZZ_poly(f, T) == f_
+    assert _to_ANP_poly(f_, R) == f
+
+
+def test_modgcd_algebraic_field():
+    A = AlgebraicField(QQ, sqrt(2))
+    R, x = ring("x", A)
+    one = A.one
+
+    f, g = 2*x, R(2)
+    assert func_field_modgcd(f, g) == (one, f, g)
+
+    f, g = 2*x, R(sqrt(2))
+    assert func_field_modgcd(f, g) == (one, f, g)
+
+    f, g = 2*x + 2, 6*x**2 - 6
+    assert func_field_modgcd(f, g) == (x + 1, R(2), 6*x - 6)
+
+    R, x, y = ring("x, y", A)
+
+    f, g = x + sqrt(2)*y, x + y
+    assert func_field_modgcd(f, g) == (one, f, g)
+
+    f, g = x*y + sqrt(2)*y**2, R(sqrt(2))*y
+    assert func_field_modgcd(f, g) == (y, x + sqrt(2)*y, R(sqrt(2)))
+
+    f, g = x**2 + 2*sqrt(2)*x*y + 2*y**2, x + sqrt(2)*y
+    assert func_field_modgcd(f, g) == (g, g, one)
+
+    A = AlgebraicField(QQ, sqrt(2), sqrt(3))
+    R, x, y, z = ring("x, y, z", A)
+
+    h = x**2*y**7 + sqrt(6)/21*z
+    f, g = h*(27*y**3 + 1), h*(y + x)
+    assert func_field_modgcd(f, g) == (h, 27*y**3+1, y+x)
+
+    h = x**13*y**3 + 1/2*x**10 + 1/sqrt(2)
+    f, g = h*(x + 1), h*sqrt(2)/sqrt(3)
+    assert func_field_modgcd(f, g) == (h, x + 1, R(sqrt(2)/sqrt(3)))
+
+    A = AlgebraicField(QQ, sqrt(2)**(-1)*sqrt(3))
+    R, x = ring("x", A)
+
+    f, g = x + 1, x - 1
+    assert func_field_modgcd(f, g) == (A.one, f, g)
+
+
+# when func_field_modgcd supports function fields, this test can be changed
+def test_modgcd_func_field():
+    D, t = ring("t", ZZ)
+    R, x, z = ring("x, z", D)
+
+    minpoly = (z**2*t**2 + z**2*t - 1).drop(0)
+    f, g = x + 1, x - 1
+
+    assert _func_field_modgcd_m(f, g, minpoly) == R.one

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_monomials.py

@@ -0,0 +1,269 @@
+"""Tests for tools and arithmetics for monomials of distributed polynomials. """
+
+from sympy.polys.monomials import (
+    itermonomials, monomial_count,
+    monomial_mul, monomial_div,
+    monomial_gcd, monomial_lcm,
+    monomial_max, monomial_min,
+    monomial_divides, monomial_pow,
+    Monomial,
+)
+
+from sympy.polys.polyerrors import ExactQuotientFailed
+
+from sympy.abc import a, b, c, x, y, z
+from sympy.core import S, symbols
+from sympy.testing.pytest import raises
+
+def test_monomials():
+
+    # total_degree tests
+    assert set(itermonomials([], 0)) == {S.One}
+    assert set(itermonomials([], 1)) == {S.One}
+    assert set(itermonomials([], 2)) == {S.One}
+
+    assert set(itermonomials([], 0, 0)) == {S.One}
+    assert set(itermonomials([], 1, 0)) == {S.One}
+    assert set(itermonomials([], 2, 0)) == {S.One}
+
+    raises(StopIteration, lambda: next(itermonomials([], 0, 1)))
+    raises(StopIteration, lambda: next(itermonomials([], 0, 2)))
+    raises(StopIteration, lambda: next(itermonomials([], 0, 3)))
+
+    assert set(itermonomials([], 0, 1)) == set()
+    assert set(itermonomials([], 0, 2)) == set()
+    assert set(itermonomials([], 0, 3)) == set()
+
+    raises(ValueError, lambda: set(itermonomials([], -1)))
+    raises(ValueError, lambda: set(itermonomials([x], -1)))
+    raises(ValueError, lambda: set(itermonomials([x, y], -1)))
+
+    assert set(itermonomials([x], 0)) == {S.One}
+    assert set(itermonomials([x], 1)) == {S.One, x}
+    assert set(itermonomials([x], 2)) == {S.One, x, x**2}
+    assert set(itermonomials([x], 3)) == {S.One, x, x**2, x**3}
+
+    assert set(itermonomials([x, y], 0)) == {S.One}
+    assert set(itermonomials([x, y], 1)) == {S.One, x, y}
+    assert set(itermonomials([x, y], 2)) == {S.One, x, y, x**2, y**2, x*y}
+    assert set(itermonomials([x, y], 3)) == \
+            {S.One, x, y, x**2, x**3, y**2, y**3, x*y, x*y**2, y*x**2}
+
+    i, j, k = symbols('i j k', commutative=False)
+    assert set(itermonomials([i, j, k], 0)) == {S.One}
+    assert set(itermonomials([i, j, k], 1)) == {S.One, i, j, k}
+    assert set(itermonomials([i, j, k], 2)) == \
+           {S.One, i, j, k, i**2, j**2, k**2, i*j, i*k, j*i, j*k, k*i, k*j}
+
+    assert set(itermonomials([i, j, k], 3)) == \
+            {S.One, i, j, k, i**2, j**2, k**2, i*j, i*k, j*i, j*k, k*i, k*j,
+                    i**3, j**3, k**3,
+                    i**2 * j, i**2 * k, j * i**2, k * i**2,
+                    j**2 * i, j**2 * k, i * j**2, k * j**2,
+                    k**2 * i, k**2 * j, i * k**2, j * k**2,
+                    i*j*i, i*k*i, j*i*j, j*k*j, k*i*k, k*j*k,
+                    i*j*k, i*k*j, j*i*k, j*k*i, k*i*j, k*j*i,
+            }
+
+    assert set(itermonomials([x, i, j], 0)) == {S.One}
+    assert set(itermonomials([x, i, j], 1)) == {S.One, x, i, j}
+    assert set(itermonomials([x, i, j], 2)) == {S.One, x, i, j, x*i, x*j, i*j, j*i, x**2, i**2, j**2}
+    assert set(itermonomials([x, i, j], 3)) == \
+            {S.One, x, i, j, x*i, x*j, i*j, j*i, x**2, i**2, j**2,
+                            x**3, i**3, j**3,
+                            x**2 * i, x**2 * j,
+                            x * i**2, j * i**2, i**2 * j, i*j*i,
+                            x * j**2, i * j**2, j**2 * i, j*i*j,
+                            x * i * j, x * j * i
+            }
+
+    # degree_list tests
+    assert set(itermonomials([], [])) == {S.One}
+
+    raises(ValueError, lambda: set(itermonomials([], [0])))
+    raises(ValueError, lambda: set(itermonomials([], [1])))
+    raises(ValueError, lambda: set(itermonomials([], [2])))
+
+    raises(ValueError, lambda: set(itermonomials([x], [1], [])))
+    raises(ValueError, lambda: set(itermonomials([x], [1, 2], [])))
+    raises(ValueError, lambda: set(itermonomials([x], [1, 2, 3], [])))
+
+    raises(ValueError, lambda: set(itermonomials([x], [], [1])))
+    raises(ValueError, lambda: set(itermonomials([x], [], [1, 2])))
+    raises(ValueError, lambda: set(itermonomials([x], [], [1, 2, 3])))
+
+    raises(ValueError, lambda: set(itermonomials([x, y], [1, 2], [1, 2, 3])))
+    raises(ValueError, lambda: set(itermonomials([x, y, z], [1, 2, 3], [0, 1])))
+
+    raises(ValueError, lambda: set(itermonomials([x], [1], [-1])))
+    raises(ValueError, lambda: set(itermonomials([x, y], [1, 2], [1, -1])))
+
+    raises(ValueError, lambda: set(itermonomials([], [], 1)))
+    raises(ValueError, lambda: set(itermonomials([], [], 2)))
+    raises(ValueError, lambda: set(itermonomials([], [], 3)))
+
+    raises(ValueError, lambda: set(itermonomials([x, y], [0, 1], [1, 2])))
+    raises(ValueError, lambda: set(itermonomials([x, y, z], [0, 0, 3], [0, 1, 2])))
+
+    assert set(itermonomials([x], [0])) == {S.One}
+    assert set(itermonomials([x], [1])) == {S.One, x}
+    assert set(itermonomials([x], [2])) == {S.One, x, x**2}
+    assert set(itermonomials([x], [3])) == {S.One, x, x**2, x**3}
+
+    assert set(itermonomials([x], [3], [1])) == {x, x**3, x**2}
+    assert set(itermonomials([x], [3], [2])) == {x**3, x**2}
+
+    assert set(itermonomials([x, y], 3, 3)) == {x**3, x**2*y, x*y**2, y**3}
+    assert set(itermonomials([x, y], 3, 2)) == {x**2, x*y, y**2, x**3, x**2*y, x*y**2, y**3}
+
+    assert set(itermonomials([x, y], [0, 0])) == {S.One}
+    assert set(itermonomials([x, y], [0, 1])) == {S.One, y}
+    assert set(itermonomials([x, y], [0, 2])) == {S.One, y, y**2}
+    assert set(itermonomials([x, y], [0, 2], [0, 1])) == {y, y**2}
+    assert set(itermonomials([x, y], [0, 2], [0, 2])) == {y**2}
+
+    assert set(itermonomials([x, y], [1, 0])) == {S.One, x}
+    assert set(itermonomials([x, y], [1, 1])) == {S.One, x, y, x*y}
+    assert set(itermonomials([x, y], [1, 2])) == {S.One, x, y, x*y, y**2, x*y**2}
+    assert set(itermonomials([x, y], [1, 2], [1, 1])) == {x*y, x*y**2}
+    assert set(itermonomials([x, y], [1, 2], [1, 2])) == {x*y**2}
+
+    assert set(itermonomials([x, y], [2, 0])) == {S.One, x, x**2}
+    assert set(itermonomials([x, y], [2, 1])) == {S.One, x, y, x*y, x**2, x**2*y}
+    assert set(itermonomials([x, y], [2, 2])) == \
+            {S.One, y**2, x*y**2, x, x*y, x**2, x**2*y**2, y, x**2*y}
+
+    i, j, k = symbols('i j k', commutative=False)
+    assert set(itermonomials([i, j, k], 2, 2)) == \
+            {k*i, i**2, i*j, j*k, j*i, k**2, j**2, k*j, i*k}
+    assert set(itermonomials([i, j, k], 3, 2)) == \
+            {j*k**2, i*k**2, k*i*j, k*i**2, k**2, j*k*j, k*j**2, i*k*i, i*j,
+                    j**2*k, i**2*j, j*i*k, j**3, i**3, k*j*i, j*k*i, j*i,
+                    k**2*j, j*i**2, k*j, k*j*k, i*j*i, j*i*j, i*j**2, j**2,
+                    k*i*k, i**2, j*k, i*k, i*k*j, k**3, i**2*k, j**2*i, k**2*i,
+                    i*j*k, k*i
+            }
+    assert set(itermonomials([i, j, k], [0, 0, 0])) == {S.One}
+    assert set(itermonomials([i, j, k], [0, 0, 1])) == {1, k}
+    assert set(itermonomials([i, j, k], [0, 1, 0])) == {1, j}
+    assert set(itermonomials([i, j, k], [1, 0, 0])) == {i, 1}
+    assert set(itermonomials([i, j, k], [0, 0, 2])) == {k**2, 1, k}
+    assert set(itermonomials([i, j, k], [0, 2, 0])) == {1, j, j**2}
+    assert set(itermonomials([i, j, k], [2, 0, 0])) == {i, 1, i**2}
+    assert set(itermonomials([i, j, k], [1, 1, 1])) == {1, k, j, j*k, i*k, i, i*j, i*j*k}
+    assert set(itermonomials([i, j, k], [2, 2, 2])) == \
+            {1, k, i**2*k**2, j*k, j**2, i, i*k, j*k**2, i*j**2*k**2,
+                    i**2*j, i**2*j**2, k**2, j**2*k, i*j**2*k,
+                    j**2*k**2, i*j, i**2*k, i**2*j**2*k, j, i**2*j*k,
+                    i*j**2, i*k**2, i*j*k, i**2*j**2*k**2, i*j*k**2, i**2, i**2*j*k**2
+            }
+
+    assert set(itermonomials([x, j, k], [0, 0, 0])) == {S.One}
+    assert set(itermonomials([x, j, k], [0, 0, 1])) == {1, k}
+    assert set(itermonomials([x, j, k], [0, 1, 0])) == {1, j}
+    assert set(itermonomials([x, j, k], [1, 0, 0])) == {x, 1}
+    assert set(itermonomials([x, j, k], [0, 0, 2])) == {k**2, 1, k}
+    assert set(itermonomials([x, j, k], [0, 2, 0])) == {1, j, j**2}
+    assert set(itermonomials([x, j, k], [2, 0, 0])) == {x, 1, x**2}
+    assert set(itermonomials([x, j, k], [1, 1, 1])) == {1, k, j, j*k, x*k, x, x*j, x*j*k}
+    assert set(itermonomials([x, j, k], [2, 2, 2])) == \
+            {1, k, x**2*k**2, j*k, j**2, x, x*k, j*k**2, x*j**2*k**2,
+                    x**2*j, x**2*j**2, k**2, j**2*k, x*j**2*k,
+                    j**2*k**2, x*j, x**2*k, x**2*j**2*k, j, x**2*j*k,
+                    x*j**2, x*k**2, x*j*k, x**2*j**2*k**2, x*j*k**2, x**2, x**2*j*k**2
+            }
+
+def test_monomial_count():
+    assert monomial_count(2, 2) == 6
+    assert monomial_count(2, 3) == 10
+
+def test_monomial_mul():
+    assert monomial_mul((3, 4, 1), (1, 2, 0)) == (4, 6, 1)
+
+def test_monomial_div():
+    assert monomial_div((3, 4, 1), (1, 2, 0)) == (2, 2, 1)
+
+def test_monomial_gcd():
+    assert monomial_gcd((3, 4, 1), (1, 2, 0)) == (1, 2, 0)
+
+def test_monomial_lcm():
+    assert monomial_lcm((3, 4, 1), (1, 2, 0)) == (3, 4, 1)
+
+def test_monomial_max():
+    assert monomial_max((3, 4, 5), (0, 5, 1), (6, 3, 9)) == (6, 5, 9)
+
+def test_monomial_pow():
+    assert monomial_pow((1, 2, 3), 3) == (3, 6, 9)
+
+def test_monomial_min():
+    assert monomial_min((3, 4, 5), (0, 5, 1), (6, 3, 9)) == (0, 3, 1)
+
+def test_monomial_divides():
+    assert monomial_divides((1, 2, 3), (4, 5, 6)) is True
+    assert monomial_divides((1, 2, 3), (0, 5, 6)) is False
+
+def test_Monomial():
+    m = Monomial((3, 4, 1), (x, y, z))
+    n = Monomial((1, 2, 0), (x, y, z))
+
+    assert m.as_expr() == x**3*y**4*z
+    assert n.as_expr() == x**1*y**2
+
+    assert m.as_expr(a, b, c) == a**3*b**4*c
+    assert n.as_expr(a, b, c) == a**1*b**2
+
+    assert m.exponents == (3, 4, 1)
+    assert m.gens == (x, y, z)
+
+    assert n.exponents == (1, 2, 0)
+    assert n.gens == (x, y, z)
+
+    assert m == (3, 4, 1)
+    assert n != (3, 4, 1)
+    assert m != (1, 2, 0)
+    assert n == (1, 2, 0)
+    assert (m == 1) is False
+
+    assert m[0] == m[-3] == 3
+    assert m[1] == m[-2] == 4
+    assert m[2] == m[-1] == 1
+
+    assert n[0] == n[-3] == 1
+    assert n[1] == n[-2] == 2
+    assert n[2] == n[-1] == 0
+
+    assert m[:2] == (3, 4)
+    assert n[:2] == (1, 2)
+
+    assert m*n == Monomial((4, 6, 1))
+    assert m/n == Monomial((2, 2, 1))
+
+    assert m*(1, 2, 0) == Monomial((4, 6, 1))
+    assert m/(1, 2, 0) == Monomial((2, 2, 1))
+
+    assert m.gcd(n) == Monomial((1, 2, 0))
+    assert m.lcm(n) == Monomial((3, 4, 1))
+
+    assert m.gcd((1, 2, 0)) == Monomial((1, 2, 0))
+    assert m.lcm((1, 2, 0)) == Monomial((3, 4, 1))
+
+    assert m**0 == Monomial((0, 0, 0))
+    assert m**1 == m
+    assert m**2 == Monomial((6, 8, 2))
+    assert m**3 == Monomial((9, 12, 3))
+    _a = Monomial((0, 0, 0))
+    for n in range(10):
+        assert _a == m**n
+        _a *= m
+
+    raises(ExactQuotientFailed, lambda: m/Monomial((5, 2, 0)))
+
+    mm = Monomial((1, 2, 3))
+    raises(ValueError, lambda: mm.as_expr())
+    assert str(mm) == 'Monomial((1, 2, 3))'
+    assert str(m) == 'x**3*y**4*z**1'
+    raises(NotImplementedError, lambda: m*1)
+    raises(NotImplementedError, lambda: m/1)
+    raises(ValueError, lambda: m**-1)
+    raises(TypeError, lambda: m.gcd(3))
+    raises(TypeError, lambda: m.lcm(3))

miniconda3/envs/ladir/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]])

miniconda3/envs/ladir/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])

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_orthopolys.py

@@ -0,0 +1,175 @@
+"""Tests for efficient functions for generating orthogonal polynomials. """
+
+from sympy.core.numbers import Rational as Q
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.polys.polytools import Poly
+from sympy.testing.pytest import raises
+
+from sympy.polys.orthopolys import (
+    jacobi_poly,
+    gegenbauer_poly,
+    chebyshevt_poly,
+    chebyshevu_poly,
+    hermite_poly,
+    hermite_prob_poly,
+    legendre_poly,
+    laguerre_poly,
+    spherical_bessel_fn,
+)
+
+from sympy.abc import x, a, b
+
+
+def test_jacobi_poly():
+    raises(ValueError, lambda: jacobi_poly(-1, a, b, x))
+
+    assert jacobi_poly(1, a, b, x, polys=True) == Poly(
+        (a/2 + b/2 + 1)*x + a/2 - b/2, x, domain='ZZ(a,b)')
+
+    assert jacobi_poly(0, a, b, x) == 1
+    assert jacobi_poly(1, a, b, x) == a/2 - b/2 + x*(a/2 + b/2 + 1)
+    assert jacobi_poly(2, a, b, x) == (a**2/8 - a*b/4 - a/8 + b**2/8 - b/8 +
+                                       x**2*(a**2/8 + a*b/4 + a*Q(7, 8) + b**2/8 +
+                                             b*Q(7, 8) + Q(3, 2)) + x*(a**2/4 +
+                                            a*Q(3, 4) - b**2/4 - b*Q(3, 4)) - S.Half)
+
+    assert jacobi_poly(1, a, b, polys=True) == Poly(
+        (a/2 + b/2 + 1)*x + a/2 - b/2, x, domain='ZZ(a,b)')
+
+
+def test_gegenbauer_poly():
+    raises(ValueError, lambda: gegenbauer_poly(-1, a, x))
+
+    assert gegenbauer_poly(
+        1, a, x, polys=True) == Poly(2*a*x, x, domain='ZZ(a)')
+
+    assert gegenbauer_poly(0, a, x) == 1
+    assert gegenbauer_poly(1, a, x) == 2*a*x
+    assert gegenbauer_poly(2, a, x) == -a + x**2*(2*a**2 + 2*a)
+    assert gegenbauer_poly(
+        3, a, x) == x**3*(4*a**3/3 + 4*a**2 + a*Q(8, 3)) + x*(-2*a**2 - 2*a)
+
+    assert gegenbauer_poly(1, S.Half).dummy_eq(x)
+    assert gegenbauer_poly(1, a, polys=True) == Poly(2*a*x, x, domain='ZZ(a)')
+
+
+def test_chebyshevt_poly():
+    raises(ValueError, lambda: chebyshevt_poly(-1, x))
+
+    assert chebyshevt_poly(1, x, polys=True) == Poly(x)
+
+    assert chebyshevt_poly(0, x) == 1
+    assert chebyshevt_poly(1, x) == x
+    assert chebyshevt_poly(2, x) == 2*x**2 - 1
+    assert chebyshevt_poly(3, x) == 4*x**3 - 3*x
+    assert chebyshevt_poly(4, x) == 8*x**4 - 8*x**2 + 1
+    assert chebyshevt_poly(5, x) == 16*x**5 - 20*x**3 + 5*x
+    assert chebyshevt_poly(6, x) == 32*x**6 - 48*x**4 + 18*x**2 - 1
+    assert chebyshevt_poly(75, x) == (2*chebyshevt_poly(37, x)*chebyshevt_poly(38, x) - x).expand()
+    assert chebyshevt_poly(100, x) == (2*chebyshevt_poly(50, x)**2 - 1).expand()
+
+    assert chebyshevt_poly(1).dummy_eq(x)
+    assert chebyshevt_poly(1, polys=True) == Poly(x)
+
+
+def test_chebyshevu_poly():
+    raises(ValueError, lambda: chebyshevu_poly(-1, x))
+
+    assert chebyshevu_poly(1, x, polys=True) == Poly(2*x)
+
+    assert chebyshevu_poly(0, x) == 1
+    assert chebyshevu_poly(1, x) == 2*x
+    assert chebyshevu_poly(2, x) == 4*x**2 - 1
+    assert chebyshevu_poly(3, x) == 8*x**3 - 4*x
+    assert chebyshevu_poly(4, x) == 16*x**4 - 12*x**2 + 1
+    assert chebyshevu_poly(5, x) == 32*x**5 - 32*x**3 + 6*x
+    assert chebyshevu_poly(6, x) == 64*x**6 - 80*x**4 + 24*x**2 - 1
+
+    assert chebyshevu_poly(1).dummy_eq(2*x)
+    assert chebyshevu_poly(1, polys=True) == Poly(2*x)
+
+
+def test_hermite_poly():
+    raises(ValueError, lambda: hermite_poly(-1, x))
+
+    assert hermite_poly(1, x, polys=True) == Poly(2*x)
+
+    assert hermite_poly(0, x) == 1
+    assert hermite_poly(1, x) == 2*x
+    assert hermite_poly(2, x) == 4*x**2 - 2
+    assert hermite_poly(3, x) == 8*x**3 - 12*x
+    assert hermite_poly(4, x) == 16*x**4 - 48*x**2 + 12
+    assert hermite_poly(5, x) == 32*x**5 - 160*x**3 + 120*x
+    assert hermite_poly(6, x) == 64*x**6 - 480*x**4 + 720*x**2 - 120
+
+    assert hermite_poly(1).dummy_eq(2*x)
+    assert hermite_poly(1, polys=True) == Poly(2*x)
+
+
+def test_hermite_prob_poly():
+    raises(ValueError, lambda: hermite_prob_poly(-1, x))
+
+    assert hermite_prob_poly(1, x, polys=True) == Poly(x)
+
+    assert hermite_prob_poly(0, x) == 1
+    assert hermite_prob_poly(1, x) == x
+    assert hermite_prob_poly(2, x) == x**2 - 1
+    assert hermite_prob_poly(3, x) == x**3 - 3*x
+    assert hermite_prob_poly(4, x) == x**4 - 6*x**2 + 3
+    assert hermite_prob_poly(5, x) == x**5 - 10*x**3 + 15*x
+    assert hermite_prob_poly(6, x) == x**6 - 15*x**4 + 45*x**2 - 15
+
+    assert hermite_prob_poly(1).dummy_eq(x)
+    assert hermite_prob_poly(1, polys=True) == Poly(x)
+
+
+def test_legendre_poly():
+    raises(ValueError, lambda: legendre_poly(-1, x))
+
+    assert legendre_poly(1, x, polys=True) == Poly(x, domain='QQ')
+
+    assert legendre_poly(0, x) == 1
+    assert legendre_poly(1, x) == x
+    assert legendre_poly(2, x) == Q(3, 2)*x**2 - Q(1, 2)
+    assert legendre_poly(3, x) == Q(5, 2)*x**3 - Q(3, 2)*x
+    assert legendre_poly(4, x) == Q(35, 8)*x**4 - Q(30, 8)*x**2 + Q(3, 8)
+    assert legendre_poly(5, x) == Q(63, 8)*x**5 - Q(70, 8)*x**3 + Q(15, 8)*x
+    assert legendre_poly(6, x) == Q(
+        231, 16)*x**6 - Q(315, 16)*x**4 + Q(105, 16)*x**2 - Q(5, 16)
+
+    assert legendre_poly(1).dummy_eq(x)
+    assert legendre_poly(1, polys=True) == Poly(x)
+
+
+def test_laguerre_poly():
+    raises(ValueError, lambda: laguerre_poly(-1, x))
+
+    assert laguerre_poly(1, x, polys=True) == Poly(-x + 1, domain='QQ')
+
+    assert laguerre_poly(0, x) == 1
+    assert laguerre_poly(1, x) == -x + 1
+    assert laguerre_poly(2, x) == Q(1, 2)*x**2 - Q(4, 2)*x + 1
+    assert laguerre_poly(3, x) == -Q(1, 6)*x**3 + Q(9, 6)*x**2 - Q(18, 6)*x + 1
+    assert laguerre_poly(4, x) == Q(
+        1, 24)*x**4 - Q(16, 24)*x**3 + Q(72, 24)*x**2 - Q(96, 24)*x + 1
+    assert laguerre_poly(5, x) == -Q(1, 120)*x**5 + Q(25, 120)*x**4 - Q(
+        200, 120)*x**3 + Q(600, 120)*x**2 - Q(600, 120)*x + 1
+    assert laguerre_poly(6, x) == Q(1, 720)*x**6 - Q(36, 720)*x**5 + Q(450, 720)*x**4 - Q(2400, 720)*x**3 + Q(5400, 720)*x**2 - Q(4320, 720)*x + 1
+
+    assert laguerre_poly(0, x, a) == 1
+    assert laguerre_poly(1, x, a) == -x + a + 1
+    assert laguerre_poly(2, x, a) == x**2/2 + (-a - 2)*x + a**2/2 + a*Q(3, 2) + 1
+    assert laguerre_poly(3, x, a) == -x**3/6 + (a/2 + Q(
+        3)/2)*x**2 + (-a**2/2 - a*Q(5, 2) - 3)*x + a**3/6 + a**2 + a*Q(11, 6) + 1
+
+    assert laguerre_poly(1).dummy_eq(-x + 1)
+    assert laguerre_poly(1, polys=True) == Poly(-x + 1)
+
+
+def test_spherical_bessel_fn():
+    x, z = symbols("x z")
+    assert spherical_bessel_fn(1, z) == 1/z**2
+    assert spherical_bessel_fn(2, z) == -1/z + 3/z**3
+    assert spherical_bessel_fn(3, z) == -6/z**2 + 15/z**4
+    assert spherical_bessel_fn(4, z) == 1/z - 45/z**3 + 105/z**5

miniconda3/envs/ladir/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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_polyclasses.py

@@ -0,0 +1,601 @@
+"""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
+
+
+def test_zero_poly():
+    from sympy import Symbol
+    x = Symbol('x')
+
+    R_old = ZZ.old_poly_ring(x)
+    zero_poly_old = R_old(0)
+    cont_old, prim_old = zero_poly_old.primitive()
+
+    assert cont_old == 0
+    assert prim_old == zero_poly_old
+    assert prim_old.is_primitive is False

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_polyfuncs.py

@@ -0,0 +1,126 @@
+"""Tests for high-level polynomials manipulation functions. """
+
+from sympy.polys.polyfuncs import (
+    symmetrize, horner, interpolate, rational_interpolate, viete,
+)
+
+from sympy.polys.polyerrors import (
+    MultivariatePolynomialError,
+)
+
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.testing.pytest import raises
+
+from sympy.abc import a, b, c, d, e, x, y, z
+
+
+def test_symmetrize():
+    assert symmetrize(0, x, y, z) == (0, 0)
+    assert symmetrize(1, x, y, z) == (1, 0)
+
+    s1 = x + y + z
+    s2 = x*y + x*z + y*z
+
+    assert symmetrize(1) == (1, 0)
+    assert symmetrize(1, formal=True) == (1, 0, [])
+
+    assert symmetrize(x) == (x, 0)
+    assert symmetrize(x + 1) == (x + 1, 0)
+
+    assert symmetrize(x, x, y) == (x + y, -y)
+    assert symmetrize(x + 1, x, y) == (x + y + 1, -y)
+
+    assert symmetrize(x, x, y, z) == (s1, -y - z)
+    assert symmetrize(x + 1, x, y, z) == (s1 + 1, -y - z)
+
+    assert symmetrize(x**2, x, y, z) == (s1**2 - 2*s2, -y**2 - z**2)
+
+    assert symmetrize(x**2 + y**2) == (-2*x*y + (x + y)**2, 0)
+    assert symmetrize(x**2 - y**2) == (-2*x*y + (x + y)**2, -2*y**2)
+
+    assert symmetrize(x**3 + y**2 + a*x**2 + b*y**3, x, y) == \
+        (-3*x*y*(x + y) - 2*a*x*y + a*(x + y)**2 + (x + y)**3,
+         y**2*(1 - a) + y**3*(b - 1))
+
+    U = [u0, u1, u2] = symbols('u:3')
+
+    assert symmetrize(x + 1, x, y, z, formal=True, symbols=U) == \
+        (u0 + 1, -y - z, [(u0, x + y + z), (u1, x*y + x*z + y*z), (u2, x*y*z)])
+
+    assert symmetrize([1, 2, 3]) == [(1, 0), (2, 0), (3, 0)]
+    assert symmetrize([1, 2, 3], formal=True) == ([(1, 0), (2, 0), (3, 0)], [])
+
+    assert symmetrize([x + y, x - y]) == [(x + y, 0), (x + y, -2*y)]
+
+
+def test_horner():
+    assert horner(0) == 0
+    assert horner(1) == 1
+    assert horner(x) == x
+
+    assert horner(x + 1) == x + 1
+    assert horner(x**2 + 1) == x**2 + 1
+    assert horner(x**2 + x) == (x + 1)*x
+    assert horner(x**2 + x + 1) == (x + 1)*x + 1
+
+    assert horner(
+        9*x**4 + 8*x**3 + 7*x**2 + 6*x + 5) == (((9*x + 8)*x + 7)*x + 6)*x + 5
+    assert horner(
+        a*x**4 + b*x**3 + c*x**2 + d*x + e) == (((a*x + b)*x + c)*x + d)*x + e
+
+    assert horner(4*x**2*y**2 + 2*x**2*y + 2*x*y**2 + x*y, wrt=x) == ((
+        4*y + 2)*x*y + (2*y + 1)*y)*x
+    assert horner(4*x**2*y**2 + 2*x**2*y + 2*x*y**2 + x*y, wrt=y) == ((
+        4*x + 2)*y*x + (2*x + 1)*x)*y
+
+
+def test_interpolate():
+    assert interpolate([1, 4, 9, 16], x) == x**2
+    assert interpolate([1, 4, 9, 25], x) == S(3)*x**3/2 - S(8)*x**2 + S(33)*x/2 - 9
+    assert interpolate([(1, 1), (2, 4), (3, 9)], x) == x**2
+    assert interpolate([(1, 2), (2, 5), (3, 10)], x) == 1 + x**2
+    assert interpolate({1: 2, 2: 5, 3: 10}, x) == 1 + x**2
+    assert interpolate({5: 2, 7: 5, 8: 10, 9: 13}, x) == \
+        -S(13)*x**3/24 + S(12)*x**2 - S(2003)*x/24 + 187
+    assert interpolate([(1, 3), (0, 6), (2, 5), (5, 7), (-2, 4)], x) == \
+        S(-61)*x**4/280 + S(247)*x**3/210 + S(139)*x**2/280 - S(1871)*x/420 + 6
+    assert interpolate((9, 4, 9), 3) == 9
+    assert interpolate((1, 9, 16), 1) is S.One
+    assert interpolate(((x, 1), (2, 3)), x) is S.One
+    assert interpolate({x: 1, 2: 3}, x) is S.One
+    assert interpolate(((2, x), (1, 3)), x) == x**2 - 4*x + 6
+
+
+def test_rational_interpolate():
+    x, y = symbols('x,y')
+    xdata = [1, 2, 3, 4, 5, 6]
+    ydata1 = [120, 150, 200, 255, 312, 370]
+    ydata2 = [-210, -35, 105, 231, 350, 465]
+    assert rational_interpolate(list(zip(xdata, ydata1)), 2) == (
+      (60*x**2 + 60)/x )
+    assert rational_interpolate(list(zip(xdata, ydata1)), 3) == (
+      (60*x**2 + 60)/x )
+    assert rational_interpolate(list(zip(xdata, ydata2)), 2, X=y) == (
+      (105*y**2 - 525)/(y + 1) )
+    xdata = list(range(1,11))
+    ydata = [-1923885361858460, -5212158811973685, -9838050145867125,
+      -15662936261217245, -22469424125057910, -30073793365223685,
+      -38332297297028735, -47132954289530109, -56387719094026320,
+      -66026548943876885]
+    assert rational_interpolate(list(zip(xdata, ydata)), 5) == (
+      (-12986226192544605*x**4 +
+      8657484128363070*x**3 - 30301194449270745*x**2 + 4328742064181535*x
+      - 4328742064181535)/(x**3 + 9*x**2 - 3*x + 11))
+
+
+def test_viete():
+    r1, r2 = symbols('r1, r2')
+
+    assert viete(
+        a*x**2 + b*x + c, [r1, r2], x) == [(r1 + r2, -b/a), (r1*r2, c/a)]
+
+    raises(ValueError, lambda: viete(1, [], x))
+    raises(ValueError, lambda: viete(x**2 + 1, [r1]))
+
+    raises(MultivariatePolynomialError, lambda: viete(x + y, [r1]))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_polymatrix.py

@@ -0,0 +1,185 @@
+from sympy.testing.pytest import raises
+
+from sympy.polys.polymatrix import PolyMatrix
+from sympy.polys import Poly
+
+from sympy.core.singleton import S
+from sympy.matrices.dense import Matrix
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+
+from sympy.abc import x, y
+
+
+def _test_polymatrix():
+    pm1 = PolyMatrix([[Poly(x**2, x), Poly(-x, x)], [Poly(x**3, x), Poly(-1 + x, x)]])
+    v1 = PolyMatrix([[1, 0], [-1, 0]], ring='ZZ[x]')
+    m1 = PolyMatrix([[1, 0], [-1, 0]], ring='ZZ[x]')
+    A = PolyMatrix([[Poly(x**2 + x, x), Poly(0, x)], \
+                    [Poly(x**3 - x + 1, x), Poly(0, x)]])
+    B = PolyMatrix([[Poly(x**2, x), Poly(-x, x)], [Poly(-x**2, x), Poly(x, x)]])
+    assert A.ring == ZZ[x]
+    assert isinstance(pm1*v1, PolyMatrix)
+    assert pm1*v1 == A
+    assert pm1*m1 == A
+    assert v1*pm1 == B
+
+    pm2 = PolyMatrix([[Poly(x**2, x, domain='QQ'), Poly(0, x, domain='QQ'), Poly(-x**2, x, domain='QQ'), \
+                    Poly(x**3, x, domain='QQ'), Poly(0, x, domain='QQ'), Poly(-x**3, x, domain='QQ')]])
+    assert pm2.ring == QQ[x]
+    v2 = PolyMatrix([1, 0, 0, 0, 0, 0], ring='ZZ[x]')
+    m2 = PolyMatrix([1, 0, 0, 0, 0, 0], ring='ZZ[x]')
+    C = PolyMatrix([[Poly(x**2, x, domain='QQ')]])
+    assert pm2*v2 == C
+    assert pm2*m2 == C
+
+    pm3 = PolyMatrix([[Poly(x**2, x), S.One]], ring='ZZ[x]')
+    v3 = S.Half*pm3
+    assert v3 == PolyMatrix([[Poly(S.Half*x**2, x, domain='QQ'), S.Half]], ring='QQ[x]')
+    assert pm3*S.Half == v3
+    assert v3.ring == QQ[x]
+
+    pm4 = PolyMatrix([[Poly(x**2, x, domain='ZZ'), Poly(-x**2, x, domain='ZZ')]])
+    v4 = PolyMatrix([1, -1], ring='ZZ[x]')
+    assert pm4*v4 == PolyMatrix([[Poly(2*x**2, x, domain='ZZ')]])
+
+    assert len(PolyMatrix(ring=ZZ[x])) == 0
+    assert PolyMatrix([1, 0, 0, 1], x)/(-1) == PolyMatrix([-1, 0, 0, -1], x)
+
+
+def test_polymatrix_constructor():
+    M1 = PolyMatrix([[x, y]], ring=QQ[x,y])
+    assert M1.ring == QQ[x,y]
+    assert M1.domain == QQ
+    assert M1.gens == (x, y)
+    assert M1.shape == (1, 2)
+    assert M1.rows == 1
+    assert M1.cols == 2
+    assert len(M1) == 2
+    assert list(M1) == [Poly(x, (x, y), domain=QQ), Poly(y, (x, y), domain=QQ)]
+
+    M2 = PolyMatrix([[x, y]], ring=QQ[x][y])
+    assert M2.ring == QQ[x][y]
+    assert M2.domain == QQ[x]
+    assert M2.gens == (y,)
+    assert M2.shape == (1, 2)
+    assert M2.rows == 1
+    assert M2.cols == 2
+    assert len(M2) == 2
+    assert list(M2) == [Poly(x, (y,), domain=QQ[x]), Poly(y, (y,), domain=QQ[x])]
+
+    assert PolyMatrix([[x, y]], y) == PolyMatrix([[x, y]], ring=ZZ.frac_field(x)[y])
+    assert PolyMatrix([[x, y]], ring='ZZ[x,y]') == PolyMatrix([[x, y]], ring=ZZ[x,y])
+
+    assert PolyMatrix([[x, y]], (x, y)) == PolyMatrix([[x, y]], ring=QQ[x,y])
+    assert PolyMatrix([[x, y]], x, y) == PolyMatrix([[x, y]], ring=QQ[x,y])
+    assert PolyMatrix([x, y]) == PolyMatrix([[x], [y]], ring=QQ[x,y])
+    assert PolyMatrix(1, 2, [x, y]) == PolyMatrix([[x, y]], ring=QQ[x,y])
+    assert PolyMatrix(1, 2, lambda i,j: [x,y][j]) == PolyMatrix([[x, y]], ring=QQ[x,y])
+    assert PolyMatrix(0, 2, [], x, y).shape == (0, 2)
+    assert PolyMatrix(2, 0, [], x, y).shape == (2, 0)
+    assert PolyMatrix([[], []], x, y).shape == (2, 0)
+    assert PolyMatrix(ring=QQ[x,y]) == PolyMatrix(0, 0, [], ring=QQ[x,y]) == PolyMatrix([], ring=QQ[x,y])
+    raises(TypeError, lambda: PolyMatrix())
+    raises(TypeError, lambda: PolyMatrix(1))
+
+    assert PolyMatrix([Poly(x), Poly(y)]) == PolyMatrix([[x], [y]], ring=ZZ[x,y])
+
+    # XXX: Maybe a bug in parallel_poly_from_expr (x lost from gens and domain):
+    assert PolyMatrix([Poly(y, x), 1]) == PolyMatrix([[y], [1]], ring=QQ[y])
+
+
+def test_polymatrix_eq():
+    assert (PolyMatrix([x]) == PolyMatrix([x])) is True
+    assert (PolyMatrix([y]) == PolyMatrix([x])) is False
+    assert (PolyMatrix([x]) != PolyMatrix([x])) is False
+    assert (PolyMatrix([y]) != PolyMatrix([x])) is True
+
+    assert PolyMatrix([[x, y]]) != PolyMatrix([x, y]) == PolyMatrix([[x], [y]])
+
+    assert PolyMatrix([x], ring=QQ[x]) != PolyMatrix([x], ring=ZZ[x])
+
+    assert PolyMatrix([x]) != Matrix([x])
+    assert PolyMatrix([x]).to_Matrix() == Matrix([x])
+
+    assert PolyMatrix([1], x) == PolyMatrix([1], x)
+    assert PolyMatrix([1], x) != PolyMatrix([1], y)
+
+
+def test_polymatrix_from_Matrix():
+    assert PolyMatrix.from_Matrix(Matrix([1, 2]), x) == PolyMatrix([1, 2], x, ring=QQ[x])
+    assert PolyMatrix.from_Matrix(Matrix([1]), ring=QQ[x]) == PolyMatrix([1], x)
+    pmx = PolyMatrix([1, 2], x)
+    pmy = PolyMatrix([1, 2], y)
+    assert pmx != pmy
+    assert pmx.set_gens(y) == pmy
+
+
+def test_polymatrix_repr():
+    assert repr(PolyMatrix([[1, 2]], x)) == 'PolyMatrix([[1, 2]], ring=QQ[x])'
+    assert repr(PolyMatrix(0, 2, [], x)) == 'PolyMatrix(0, 2, [], ring=QQ[x])'
+
+
+def test_polymatrix_getitem():
+    M = PolyMatrix([[1, 2], [3, 4]], x)
+    assert M[:, :] == M
+    assert M[0, :] == PolyMatrix([[1, 2]], x)
+    assert M[:, 0] == PolyMatrix([1, 3], x)
+    assert M[0, 0] == Poly(1, x, domain=QQ)
+    assert M[0] == Poly(1, x, domain=QQ)
+    assert M[:2] == [Poly(1, x, domain=QQ), Poly(2, x, domain=QQ)]
+
+
+def test_polymatrix_arithmetic():
+    M = PolyMatrix([[1, 2], [3, 4]], x)
+    assert M + M == PolyMatrix([[2, 4], [6, 8]], x)
+    assert M - M == PolyMatrix([[0, 0], [0, 0]], x)
+    assert -M == PolyMatrix([[-1, -2], [-3, -4]], x)
+    raises(TypeError, lambda: M + 1)
+    raises(TypeError, lambda: M - 1)
+    raises(TypeError, lambda: 1 + M)
+    raises(TypeError, lambda: 1 - M)
+
+    assert M * M == PolyMatrix([[7, 10], [15, 22]], x)
+    assert 2 * M == PolyMatrix([[2, 4], [6, 8]], x)
+    assert M * 2 == PolyMatrix([[2, 4], [6, 8]], x)
+    assert S(2) * M == PolyMatrix([[2, 4], [6, 8]], x)
+    assert M * S(2) == PolyMatrix([[2, 4], [6, 8]], x)
+    raises(TypeError, lambda: [] * M)
+    raises(TypeError, lambda: M * [])
+    M2 = PolyMatrix([[1, 2]], ring=ZZ[x])
+    assert S.Half * M2 == PolyMatrix([[S.Half, 1]], ring=QQ[x])
+    assert M2 * S.Half == PolyMatrix([[S.Half, 1]], ring=QQ[x])
+
+    assert M / 2 == PolyMatrix([[S(1)/2, 1], [S(3)/2, 2]], x)
+    assert M / Poly(2, x) == PolyMatrix([[S(1)/2, 1], [S(3)/2, 2]], x)
+    raises(TypeError, lambda: M / [])
+
+
+def test_polymatrix_manipulations():
+    M1 = PolyMatrix([[1, 2], [3, 4]], x)
+    assert M1.transpose() == PolyMatrix([[1, 3], [2, 4]], x)
+    M2 = PolyMatrix([[5, 6], [7, 8]], x)
+    assert M1.row_join(M2) == PolyMatrix([[1, 2, 5, 6], [3, 4, 7, 8]], x)
+    assert M1.col_join(M2) == PolyMatrix([[1, 2], [3, 4], [5, 6], [7, 8]], x)
+    assert M1.applyfunc(lambda e: 2*e) == PolyMatrix([[2, 4], [6, 8]], x)
+
+
+def test_polymatrix_ones_zeros():
+    assert PolyMatrix.zeros(1, 2, x) == PolyMatrix([[0, 0]], x)
+    assert PolyMatrix.eye(2, x) == PolyMatrix([[1, 0], [0, 1]], x)
+
+
+def test_polymatrix_rref():
+    M = PolyMatrix([[1, 2], [3, 4]], x)
+    assert M.rref() == (PolyMatrix.eye(2, x), (0, 1))
+    raises(ValueError, lambda: PolyMatrix([1, 2], ring=ZZ[x]).rref())
+    raises(ValueError, lambda: PolyMatrix([1, x], ring=QQ[x]).rref())
+
+
+def test_polymatrix_nullspace():
+    M = PolyMatrix([[1, 2], [3, 6]], x)
+    assert M.nullspace() == [PolyMatrix([-2, 1], x)]
+    raises(ValueError, lambda: PolyMatrix([1, 2], ring=ZZ[x]).nullspace())
+    raises(ValueError, lambda: PolyMatrix([1, x], ring=QQ[x]).nullspace())
+    assert M.rank() == 1

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_polyoptions.py

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

miniconda3/envs/ladir/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}

miniconda3/envs/ladir/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))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_puiseux.py

@@ -0,0 +1,204 @@
+#
+# Tests for PuiseuxRing and PuiseuxPoly
+#
+
+from sympy.testing.pytest import raises
+
+from sympy import ZZ, QQ, ring
+from sympy.polys.puiseux import PuiseuxRing, PuiseuxPoly, puiseux_ring
+
+from sympy.abc import x, y
+
+
+def test_puiseux_ring():
+    R, px = puiseux_ring('x', QQ)
+    R2, px2 = puiseux_ring([x], QQ)
+    assert isinstance(R, PuiseuxRing)
+    assert isinstance(px, PuiseuxPoly)
+    assert R == R2
+    assert px == px2
+    assert R == PuiseuxRing('x', QQ)
+    assert R == PuiseuxRing([x], QQ)
+    assert R != PuiseuxRing('y', QQ)
+    assert R != PuiseuxRing('x', ZZ)
+    assert R != PuiseuxRing('x, y', QQ)
+    assert R != QQ
+    assert str(R) == 'PuiseuxRing((x,), QQ)'
+
+
+def test_puiseux_ring_attributes():
+    R1, px1, py1 = ring('x, y', QQ)
+    R2, px2, py2 = puiseux_ring('x, y', QQ)
+    assert R2.domain == QQ
+    assert R2.symbols == (x, y)
+    assert R2.gens == (px2, py2)
+    assert R2.ngens == 2
+    assert R2.poly_ring == R1
+    assert R2.zero == PuiseuxPoly(R1.zero, R2)
+    assert R2.one == PuiseuxPoly(R1.one, R2)
+    assert R2.zero_monom == R1.zero_monom == (0, 0) # type: ignore
+    assert R2.monomial_mul((1, 2), (3, 4)) == (4, 6)
+
+
+def test_puiseux_ring_methods():
+    R1, px1, py1 = ring('x, y', QQ)
+    R2, px2, py2 = puiseux_ring('x, y', QQ)
+    assert R2({(1, 2): 3}) == 3*px2*py2**2
+    assert R2(px1) == px2
+    assert R2(1) == R2.one
+    assert R2(QQ(1,2)) == QQ(1,2)*R2.one
+    assert R2.from_poly(px1) == px2
+    assert R2.from_poly(px1) != py2
+    assert R2.from_dict({(1, 2): QQ(3)}) == 3*px2*py2**2
+    assert R2.from_dict({(QQ(1,2), 2): QQ(3)}) == 3*px2**QQ(1,2)*py2**2
+    assert R2.from_int(3) == 3*R2.one
+    assert R2.domain_new(3) == QQ(3)
+    assert QQ.of_type(R2.domain_new(3))
+    assert R2.ground_new(3) == 3*R2.one
+    assert isinstance(R2.ground_new(3), PuiseuxPoly)
+    assert R2.index(px2) == 0
+    assert R2.index(py2) == 1
+
+
+def test_puiseux_poly():
+    R1, px1 = ring('x', QQ)
+    R2, px2 = puiseux_ring('x', QQ)
+    assert PuiseuxPoly(px1, R2) == px2
+    assert px2.ring == R2
+    assert px2.as_expr() == px1.as_expr() == x
+    assert px1 != px2
+    assert R2.one == px2**0 == 1
+    assert px2 == px1
+    assert px2 != 2.0
+    assert px2**QQ(1,2) != px1
+
+
+def test_puiseux_poly_normalization():
+    R, x = puiseux_ring('x', QQ)
+    assert (x**2 + 1) / x == x + 1/x == R({(1,): 1, (-1,): 1})
+    assert (x**QQ(1,6))**2 == x**QQ(1,3) == R({(QQ(1,3),): 1})
+    assert (x**QQ(1,6))**(-2) == x**(-QQ(1,3)) == R({(-QQ(1,3),): 1})
+    assert (x**QQ(1,6))**QQ(1,2) == x**QQ(1,12) == R({(QQ(1,12),): 1})
+    assert (x**QQ(1,6))**6 == x == R({(1,): 1})
+    assert x**QQ(1,6) * x**QQ(1,3) == x**QQ(1,2) == R({(QQ(1,2),): 1})
+    assert 1/x * x**2 == x == R({(1,): 1})
+    assert 1/x**QQ(1,3) * x**QQ(1,3) == 1 == R({(0,): 1})
+
+
+def test_puiseux_poly_monoms():
+    R, x = puiseux_ring('x', QQ)
+    assert x.monoms() == [(1,)]
+    assert list(x) == [(1,)]
+    assert (x**2 + 1).monoms() == [(2,), (0,)]
+    assert R({(1,): 1, (-1,): 1}).monoms() == [(1,), (-1,)]
+    assert R({(QQ(1,3),): 1}).monoms() == [(QQ(1,3),)]
+    assert R({(-QQ(1,3),): 1}).monoms() == [(-QQ(1,3),)]
+    p = x**QQ(1,6)
+    assert p[(QQ(1,6),)] == 1
+    raises(KeyError, lambda: p[(1,)])
+    assert p.to_dict() == {(QQ(1,6),): 1}
+    assert R(p.to_dict()) == p
+    assert PuiseuxPoly.from_dict({(QQ(1,6),): 1}, R) == p
+
+
+def test_puiseux_poly_repr():
+    R, x = puiseux_ring('x', QQ)
+    assert repr(x) == 'x'
+    assert repr(x**QQ(1,2)) == 'x**(1/2)'
+    assert repr(1/x) == 'x**(-1)'
+    assert repr(2*x**2 + 1) == '1 + 2*x**2'
+    assert repr(R.one) == '1'
+    assert repr(2*R.one) == '2'
+
+
+def test_puiseux_poly_unify():
+    R, x = puiseux_ring('x', QQ)
+    assert 1/x + x == x + 1/x == R({(1,): 1, (-1,): 1})
+    assert repr(1/x + x) == 'x**(-1) + x'
+    assert 1/x + 1/x == 2/x == R({(-1,): 2})
+    assert repr(1/x + 1/x) == '2*x**(-1)'
+    assert x**QQ(1,2) + x**QQ(1,2) == 2*x**QQ(1,2) == R({(QQ(1,2),): 2})
+    assert repr(x**QQ(1,2) + x**QQ(1,2)) == '2*x**(1/2)'
+    assert x**QQ(1,2) + x**QQ(1,3) == R({(QQ(1,2),): 1, (QQ(1,3),): 1})
+    assert repr(x**QQ(1,2) + x**QQ(1,3)) == 'x**(1/3) + x**(1/2)'
+    assert x + x**QQ(1,2) == R({(1,): 1, (QQ(1,2),): 1})
+    assert repr(x + x**QQ(1,2)) == 'x**(1/2) + x'
+    assert 1/x**QQ(1,2) + 1/x**QQ(1,3) == R({(-QQ(1,2),): 1, (-QQ(1,3),): 1})
+    assert repr(1/x**QQ(1,2) + 1/x**QQ(1,3)) == 'x**(-1/2) + x**(-1/3)'
+    assert 1/x + x**QQ(1,2) == x**QQ(1,2) + 1/x == R({(-1,): 1, (QQ(1,2),): 1})
+    assert repr(1/x + x**QQ(1,2)) == 'x**(-1) + x**(1/2)'
+
+
+def test_puiseux_poly_arit():
+    R, x = puiseux_ring('x', QQ)
+    R2, y = puiseux_ring('y', QQ)
+    p = x**2 + 1
+    assert +p == p
+    assert -p == -1 - x**2
+    assert p + p == 2*p == 2*x**2 + 2
+    assert p + 1 == 1 + p == x**2 + 2
+    assert p + QQ(1,2) == QQ(1,2) + p == x**2 + QQ(3,2)
+    assert p - p == 0
+    assert p - 1 == -1 + p == x**2
+    assert p - QQ(1,2) == -QQ(1,2) + p == x**2 + QQ(1,2)
+    assert 1 - p == -p + 1 == -x**2
+    assert QQ(1,2) - p == -p + QQ(1,2) == -x**2 - QQ(1,2)
+    assert p * p == x**4 + 2*x**2 + 1
+    assert p * 1 == 1 * p == p
+    assert 2 * p == p * 2 == 2*x**2 + 2
+    assert p * QQ(1,2) == QQ(1,2) * p == QQ(1,2)*x**2 + QQ(1,2)
+    assert x**QQ(1,2) * x**QQ(1,2) == x
+    raises(ValueError, lambda: x + y)
+    raises(ValueError, lambda: x - y)
+    raises(ValueError, lambda: x * y)
+    raises(TypeError, lambda: x + None)
+    raises(TypeError, lambda: x - None)
+    raises(TypeError, lambda: x * None)
+    raises(TypeError, lambda: None + x)
+    raises(TypeError, lambda: None - x)
+    raises(TypeError, lambda: None * x)
+
+
+def test_puiseux_poly_div():
+    R, x = puiseux_ring('x', QQ)
+    R2, y = puiseux_ring('y', QQ)
+    p = x**2 - 1
+    assert p / 1 == p
+    assert p / QQ(1,2) == 2*p == 2*x**2 - 2
+    assert p / x == x - 1/x == R({(1,): 1, (-1,): -1})
+    assert 2 / x == 2*x**-1 == R({(-1,): 2})
+    assert QQ(1,2) / x == QQ(1,2)*x**-1 == 1/(2*x) == 1/x/2 == R({(-1,): QQ(1,2)})
+    raises(ZeroDivisionError, lambda: p / 0)
+    raises(ValueError, lambda: (x + 1) / (x + 2))
+    raises(ValueError, lambda: (x + 1) / (x + 1))
+    raises(ValueError, lambda: x / y)
+    raises(TypeError, lambda: x / None)
+    raises(TypeError, lambda: None / x)
+
+
+def test_puiseux_poly_pow():
+    R, x = puiseux_ring('x', QQ)
+    Rz, xz = puiseux_ring('x', ZZ)
+    assert x**0 == 1 == R({(0,): 1})
+    assert x**1 == x == R({(1,): 1})
+    assert x**2 == x*x == R({(2,): 1})
+    assert x**QQ(1,2) == R({(QQ(1,2),): 1})
+    assert x**-1 == 1/x == R({(-1,): 1})
+    assert x**-QQ(1,2) == 1/x**QQ(1,2) == R({(-QQ(1,2),): 1})
+    assert (2*x)**-1 == 1/(2*x) == QQ(1,2)/x == QQ(1,2)*x**-1 == R({(-1,): QQ(1,2)})
+    assert 2/x**2 == 2*x**-2 == R({(-2,): 2})
+    assert 2/xz**2 == 2*xz**-2 == Rz({(-2,): 2})
+    raises(TypeError, lambda: x**None)
+    raises(ValueError, lambda: (x + 1)**-1)
+    raises(ValueError, lambda: (x + 1)**QQ(1,2))
+    raises(ValueError, lambda: (2*x)**QQ(1,2))
+    raises(ValueError, lambda: (2*xz)**-1)
+
+
+def test_puiseux_poly_diff():
+    R, x, y = puiseux_ring('x, y', QQ)
+    assert (x**2 + 1).diff(x) == 2*x
+    assert (x**2 + 1).diff(y) == 0
+    assert (x**2 + y**2).diff(x) == 2*x
+    assert (x**QQ(1,2) + y**QQ(1,2)).diff(x) == QQ(1,2)*x**-QQ(1,2)
+    assert ((x*y)**QQ(1,2)).diff(x) == QQ(1,2)*y**QQ(1,2)*x**-QQ(1,2)

miniconda3/envs/ladir/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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_rationaltools.py

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

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_ring_series.py

@@ -0,0 +1,831 @@
+from sympy.polys.domains import ZZ, QQ, EX, RR
+from sympy.polys.rings import ring
+from sympy.polys.puiseux import puiseux_ring
+from sympy.polys.ring_series import (_invert_monoms, rs_integrate,
+    rs_trunc, rs_mul, rs_square, rs_pow, _has_constant_term, rs_hadamard_exp,
+    rs_series_from_list, rs_exp, rs_log, rs_newton, rs_series_inversion,
+    rs_compose_add, rs_asin, _atan, rs_atan, _atanh, rs_atanh, rs_asinh, rs_tan,
+    rs_cot, rs_sin, rs_cos, rs_cos_sin, rs_sinh, rs_cosh, rs_cosh_sinh, rs_tanh,
+    _tan1, rs_fun, rs_nth_root, rs_LambertW, rs_series_reversion, rs_is_puiseux,
+    rs_series)
+from sympy.testing.pytest import raises, slow
+from sympy.core.symbol import symbols
+from sympy.functions import (sin, cos, exp, tan, cot, sinh, cosh, atan, atanh,
+    asinh, tanh, log, sqrt)
+from sympy.core.numbers import Rational, pi
+from sympy.core import expand, S
+
+def is_close(a, b):
+    tol = 10**(-10)
+    assert abs(a - b) < tol
+
+
+def test_ring_series1():
+    R, x = ring('x', QQ)
+    p = x**4 + 2*x**3 + 3*x + 4
+    assert _invert_monoms(p) == 4*x**4 + 3*x**3 + 2*x + 1
+    assert rs_hadamard_exp(p) == x**4/24 + x**3/3 + 3*x + 4
+    R, x = ring('x', QQ)
+    p = x**4 + 2*x**3 + 3*x + 4
+    assert rs_integrate(p, x) == x**5/5 + x**4/2 + 3*x**2/2 + 4*x
+    R, x, y = ring('x, y', QQ)
+    p = x**2*y**2 + x + 1
+    assert rs_integrate(p, x) == x**3*y**2/3 + x**2/2 + x
+    assert rs_integrate(p, y) == x**2*y**3/3 + x*y + y
+
+
+def test_trunc():
+    R, x, y, t = ring('x, y, t', QQ)
+    p = (y + t*x)**4
+    p1 = rs_trunc(p, x, 3)
+    assert p1 == y**4 + 4*y**3*t*x + 6*y**2*t**2*x**2
+
+
+def test_mul_trunc():
+    R, x, y, t = ring('x, y, t', QQ)
+    p = 1 + t*x + t*y
+    for i in range(2):
+        p = rs_mul(p, p, t, 3)
+
+    assert p == 6*x**2*t**2 + 12*x*y*t**2 + 6*y**2*t**2 + 4*x*t + 4*y*t + 1
+    p = 1 + t*x + t*y + t**2*x*y
+    p1 = rs_mul(p, p, t, 2)
+    assert p1 == 1 + 2*t*x + 2*t*y
+    R1, z = ring('z', QQ)
+    raises(ValueError, lambda: rs_mul(p, z, x, 2))
+
+    p1 = 2 + 2*x + 3*x**2
+    p2 = 3 + x**2
+    assert rs_mul(p1, p2, x, 4) == 2*x**3 + 11*x**2 + 6*x + 6
+
+
+def test_square_trunc():
+    R, x, y, t = ring('x, y, t', QQ)
+    p = (1 + t*x + t*y)*2
+    p1 = rs_mul(p, p, x, 3)
+    p2 = rs_square(p, x, 3)
+    assert p1 == p2
+    p = 1 + x + x**2 + x**3
+    assert rs_square(p, x, 4) == 4*x**3 + 3*x**2 + 2*x + 1
+
+
+def test_pow_trunc():
+    R, x, y, z = ring('x, y, z', QQ)
+    p0 = y + x*z
+    p = p0**16
+    for xx in (x, y, z):
+        p1 = rs_trunc(p, xx, 8)
+        p2 = rs_pow(p0, 16, xx, 8)
+        assert p1 == p2
+
+    p = 1 + x
+    p1 = rs_pow(p, 3, x, 2)
+    assert p1 == 1 + 3*x
+    assert rs_pow(p, 0, x, 2) == 1
+    assert rs_pow(p, -2, x, 2) == 1 - 2*x
+    p = x + y
+    assert rs_pow(p, 3, y, 3) == x**3 + 3*x**2*y + 3*x*y**2
+    assert rs_pow(1 + x, Rational(2, 3), x, 4) == 4*x**3/81 - x**2/9 + x*Rational(2, 3) + 1
+
+
+def test_has_constant_term():
+    R, x, y, z = ring('x, y, z', QQ)
+    p = y + x*z
+    assert _has_constant_term(p, x)
+    p = x + x**4
+    assert not _has_constant_term(p, x)
+    p = 1 + x + x**4
+    assert _has_constant_term(p, x)
+    p = x + y + x*z
+
+
+def test_inversion():
+    R, x = ring('x', QQ)
+    p = 2 + x + 2*x**2
+    n = 5
+    p1 = rs_series_inversion(p, x, n)
+    assert rs_trunc(p*p1, x, n) == 1
+    R, x, y = ring('x, y', QQ)
+    p = 2 + x + 2*x**2 + y*x + x**2*y
+    p1 = rs_series_inversion(p, x, n)
+    assert rs_trunc(p*p1, x, n) == 1
+
+    R, x, y = ring('x, y', QQ)
+    p = 1 + x + y
+    raises(NotImplementedError, lambda: rs_series_inversion(p, x, 4))
+    p = R.zero
+    raises(ZeroDivisionError, lambda: rs_series_inversion(p, x, 3))
+
+    R, x = ring('x', ZZ)
+    p = 2 + x
+    raises(ValueError, lambda: rs_series_inversion(p, x, 3))
+
+
+def test_series_reversion():
+    R, x, y = ring('x, y', QQ)
+
+    p = rs_tan(x, x, 10)
+    assert rs_series_reversion(p, x, 8, y) == rs_atan(y, y, 8)
+
+    p = rs_sin(x, x, 10)
+    assert rs_series_reversion(p, x, 8, y) == 5*y**7/112 + 3*y**5/40 + \
+        y**3/6 + y
+
+
+def test_series_from_list():
+    R, x = ring('x', QQ)
+    p = 1 + 2*x + x**2 + 3*x**3
+    c = [1, 2, 0, 4, 4]
+    r = rs_series_from_list(p, c, x, 5)
+    pc = R.from_list(list(reversed(c)))
+    r1 = rs_trunc(pc.compose(x, p), x, 5)
+    assert r == r1
+    R, x, y = ring('x, y', QQ)
+    c = [1, 3, 5, 7]
+    p1 = rs_series_from_list(x + y, c, x, 3, concur=0)
+    p2 = rs_trunc((1 + 3*(x+y) + 5*(x+y)**2 + 7*(x+y)**3), x, 3)
+    assert p1 == p2
+
+    R, x = ring('x', QQ)
+    h = 25
+    p = rs_exp(x, x, h) - 1
+    p1 = rs_series_from_list(p, c, x, h)
+    p2 = 0
+    for i, cx in enumerate(c):
+        p2 += cx*rs_pow(p, i, x, h)
+    assert p1 == p2
+
+
+def test_log():
+    R, x = ring('x', QQ)
+    p = 1 + x
+    assert rs_log(p, x, 4) == x - x**2/2 + x**3/3
+    p = 1 + x +2*x**2/3
+    p1 = rs_log(p, x, 9)
+    assert p1 == -17*x**8/648 + 13*x**7/189 - 11*x**6/162 - x**5/45 + \
+      7*x**4/36 - x**3/3 + x**2/6 + x
+    p2 = rs_series_inversion(p, x, 9)
+    p3 = rs_log(p2, x, 9)
+    assert p3 == -p1
+
+    R, x, y = ring('x, y', QQ)
+    p = 1 + x + 2*y*x**2
+    p1 = rs_log(p, x, 6)
+    assert p1 == (4*x**5*y**2 - 2*x**5*y - 2*x**4*y**2 + x**5/5 + 2*x**4*y -
+                  x**4/4 - 2*x**3*y + x**3/3 + 2*x**2*y - x**2/2 + x)
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', EX)
+    assert rs_log(x + a, x, 5) == -EX(1/(4*a**4))*x**4 + EX(1/(3*a**3))*x**3 \
+        - EX(1/(2*a**2))*x**2 + EX(1/a)*x + EX(log(a))
+    assert rs_log(x + x**2*y + a, x, 4) == -EX(a**(-2))*x**3*y + \
+        EX(1/(3*a**3))*x**3 + EX(1/a)*x**2*y - EX(1/(2*a**2))*x**2 + \
+        EX(1/a)*x + EX(log(a))
+
+    p = x + x**2 + 3
+    assert rs_log(p, x, 10).compose(x, 5) == EX(log(3) + Rational(19281291595, 9920232))
+
+
+def test_exp():
+    R, x = ring('x', QQ)
+    p = x + x**4
+    for h in [10, 30]:
+        q = rs_series_inversion(1 + p, x, h) - 1
+        p1 = rs_exp(q, x, h)
+        q1 = rs_log(p1, x, h)
+        assert q1 == q
+    p1 = rs_exp(p, x, 30)
+    assert p1.coeff(x**29) == QQ(74274246775059676726972369, 353670479749588078181744640000)
+    prec = 21
+    p = rs_log(1 + x, x, prec)
+    p1 = rs_exp(p, x, prec)
+    assert p1 == x + 1
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[exp(a), a])
+    assert rs_exp(x + a, x, 5) == exp(a)*x**4/24 + exp(a)*x**3/6 + \
+        exp(a)*x**2/2 + exp(a)*x + exp(a)
+    assert rs_exp(x + x**2*y + a, x, 5) == exp(a)*x**4*y**2/2 + \
+            exp(a)*x**4*y/2 + exp(a)*x**4/24 + exp(a)*x**3*y + \
+            exp(a)*x**3/6 + exp(a)*x**2*y + exp(a)*x**2/2 + exp(a)*x + exp(a)
+
+    R, x, y = ring('x, y', EX)
+    assert rs_exp(x + a, x, 5) ==  EX(exp(a)/24)*x**4 + EX(exp(a)/6)*x**3 + \
+        EX(exp(a)/2)*x**2 + EX(exp(a))*x + EX(exp(a))
+    assert rs_exp(x + x**2*y + a, x, 5) == EX(exp(a)/2)*x**4*y**2 + \
+        EX(exp(a)/2)*x**4*y + EX(exp(a)/24)*x**4 + EX(exp(a))*x**3*y + \
+        EX(exp(a)/6)*x**3 + EX(exp(a))*x**2*y + EX(exp(a)/2)*x**2 + \
+        EX(exp(a))*x + EX(exp(a))
+
+
+def test_newton():
+    R, x = ring('x', QQ)
+    p = x**2 - 2
+    r = rs_newton(p, x, 4)
+    assert r == 8*x**4 + 4*x**2 + 2
+
+
+def test_compose_add():
+    R, x = ring('x', QQ)
+    p1 = x**3 - 1
+    p2 = x**2 - 2
+    assert rs_compose_add(p1, p2) == x**6 - 6*x**4 - 2*x**3 + 12*x**2 - 12*x - 7
+
+
+def test_fun():
+    R, x, y = ring('x, y', QQ)
+    p = x*y + x**2*y**3 + x**5*y
+    assert rs_fun(p, rs_tan, x, 10) == rs_tan(p, x, 10)
+    assert rs_fun(p, _tan1, x, 10) == _tan1(p, x, 10)
+
+
+def test_nth_root():
+    R, x, y = puiseux_ring('x, y', QQ)
+    assert rs_nth_root(1 + x**2*y, 4, x, 10) == -77*x**8*y**4/2048 + \
+        7*x**6*y**3/128 - 3*x**4*y**2/32 + x**2*y/4 + 1
+    assert rs_nth_root(1 + x*y + x**2*y**3, 3, x, 5) == -x**4*y**6/9 + \
+        5*x**4*y**5/27 - 10*x**4*y**4/243 - 2*x**3*y**4/9 + 5*x**3*y**3/81 + \
+        x**2*y**3/3 - x**2*y**2/9 + x*y/3 + 1
+    assert rs_nth_root(8*x, 3, x, 3) == 2*x**QQ(1, 3)
+    assert rs_nth_root(8*x + x**2 + x**3, 3, x, 3) == x**QQ(4,3)/12 + 2*x**QQ(1,3)
+    r = rs_nth_root(8*x + x**2*y + x**3, 3, x, 4)
+    assert r == -x**QQ(7,3)*y**2/288 + x**QQ(7,3)/12 + x**QQ(4,3)*y/12 + 2*x**QQ(1,3)
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = puiseux_ring('x, y', EX)
+    assert rs_nth_root(x + EX(a), 3, x, 4) == EX(5/(81*a**QQ(8, 3)))*x**3 - \
+        EX(1/(9*a**QQ(5, 3)))*x**2 + EX(1/(3*a**QQ(2, 3)))*x + EX(a**QQ(1, 3))
+    assert rs_nth_root(x**QQ(2, 3) + x**2*y + 5, 2, x, 3) == -EX(sqrt(5)/100)*\
+        x**QQ(8, 3)*y - EX(sqrt(5)/16000)*x**QQ(8, 3) + EX(sqrt(5)/10)*x**2*y + \
+        EX(sqrt(5)/2000)*x**2 - EX(sqrt(5)/200)*x**QQ(4, 3) + \
+        EX(sqrt(5)/10)*x**QQ(2, 3) + EX(sqrt(5))
+
+
+def test_atan():
+    R, x, y = ring('x, y', QQ)
+    assert rs_atan(x, x, 9) == -x**7/7 + x**5/5 - x**3/3 + x
+    assert rs_atan(x*y + x**2*y**3, x, 9) == 2*x**8*y**11 - x**8*y**9 + \
+        2*x**7*y**9 - x**7*y**7/7 - x**6*y**9/3 + x**6*y**7 - x**5*y**7 + \
+        x**5*y**5/5 - x**4*y**5 - x**3*y**3/3 + x**2*y**3 + x*y
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', EX)
+    assert rs_atan(x + a, x, 5) == -EX((a**3 - a)/(a**8 + 4*a**6 + 6*a**4 + \
+        4*a**2 + 1))*x**4 + EX((3*a**2 - 1)/(3*a**6 + 9*a**4 + \
+        9*a**2 + 3))*x**3 - EX(a/(a**4 + 2*a**2 + 1))*x**2 + \
+        EX(1/(a**2 + 1))*x + EX(atan(a))
+    assert rs_atan(x + x**2*y + a, x, 4) == -EX(2*a/(a**4 + 2*a**2 + 1)) \
+        *x**3*y + EX((3*a**2 - 1)/(3*a**6 + 9*a**4 + 9*a**2 + 3))*x**3 + \
+        EX(1/(a**2 + 1))*x**2*y - EX(a/(a**4 + 2*a**2 + 1))*x**2 + EX(1/(a**2 \
+        + 1))*x + EX(atan(a))
+
+    # Test for _atan faster for small and univariate series
+    R, x = ring('x', QQ)
+    p = x**2 + 2*x
+    assert _atan(p, x, 5) == rs_atan(p, x, 5)
+
+    R, x = ring('x', EX)
+    p = x**2 + 2*x
+    assert _atan(p, x, 9) == rs_atan(p, x, 9)
+
+
+def test_asin():
+    R, x, y = ring('x, y', QQ)
+    assert rs_asin(x + x*y, x, 5) == x**3*y**3/6 + x**3*y**2/2 + x**3*y/2 + \
+        x**3/6 + x*y + x
+    assert rs_asin(x*y + x**2*y**3, x, 6) == x**5*y**7/2 + 3*x**5*y**5/40 + \
+        x**4*y**5/2 + x**3*y**3/6 + x**2*y**3 + x*y
+
+
+def test_tan():
+    R, x, y = ring('x, y', QQ)
+    assert rs_tan(x, x, 9) == x + x**3/3 + QQ(2,15)*x**5 + QQ(17,315)*x**7
+    assert rs_tan(x*y + x**2*y**3, x, 9) == 4*x**8*y**11/3 + 17*x**8*y**9/45 + \
+        4*x**7*y**9/3 + 17*x**7*y**7/315 + x**6*y**9/3 + 2*x**6*y**7/3 + \
+        x**5*y**7 + 2*x**5*y**5/15 + x**4*y**5 + x**3*y**3/3 + x**2*y**3 + x*y
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[tan(a), a])
+    assert rs_tan(x + a, x, 5) == (tan(a)**5 + 5*tan(a)**3/3 +
+        2*tan(a)/3)*x**4 + (tan(a)**4 + 4*tan(a)**2/3 + Rational(1, 3))*x**3 + \
+        (tan(a)**3 + tan(a))*x**2 + (tan(a)**2 + 1)*x + tan(a)
+    assert rs_tan(x + x**2*y + a, x, 4) == (2*tan(a)**3 + 2*tan(a))*x**3*y + \
+        (tan(a)**4 + Rational(4, 3)*tan(a)**2 + Rational(1, 3))*x**3 + (tan(a)**2 + 1)*x**2*y + \
+        (tan(a)**3 + tan(a))*x**2 + (tan(a)**2 + 1)*x + tan(a)
+
+    R, x, y = ring('x, y', EX)
+    assert rs_tan(x + a, x, 5) == EX(tan(a)**5 + 5*tan(a)**3/3 +
+        2*tan(a)/3)*x**4 + EX(tan(a)**4 + 4*tan(a)**2/3 + EX(1)/3)*x**3 + \
+        EX(tan(a)**3 + tan(a))*x**2 + EX(tan(a)**2 + 1)*x + EX(tan(a))
+    assert rs_tan(x + x**2*y + a, x, 4) == EX(2*tan(a)**3 +
+        2*tan(a))*x**3*y + EX(tan(a)**4 + 4*tan(a)**2/3 + EX(1)/3)*x**3 + \
+        EX(tan(a)**2 + 1)*x**2*y + EX(tan(a)**3 + tan(a))*x**2 + \
+        EX(tan(a)**2 + 1)*x + EX(tan(a))
+
+    p = x + x**2 + 5
+    assert rs_atan(p, x, 10).compose(x, 10) == EX(atan(5) + S(67701870330562640) / \
+        668083460499)
+
+
+def test_cot():
+    R, x, y = puiseux_ring('x, y', QQ)
+    assert rs_cot(x**6 + x**7, x, 8) == x**(-6) - x**(-5) + x**(-4) - \
+        x**(-3) + x**(-2) - x**(-1) + 1 - x + x**2 - x**3 + x**4 - x**5 + \
+        2*x**6/3 - 4*x**7/3
+    assert rs_cot(x + x**2*y, x, 5) == -x**4*y**5 - x**4*y/15 + x**3*y**4 - \
+        x**3/45 - x**2*y**3 - x**2*y/3 + x*y**2 - x/3 - y + x**(-1)
+
+
+def test_sin():
+    R, x, y = ring('x, y', QQ)
+    assert rs_sin(x, x, 9) == x - x**3/6 + x**5/120 - x**7/5040
+    assert rs_sin(x*y + x**2*y**3, x, 9) == x**8*y**11/12 - \
+        x**8*y**9/720 + x**7*y**9/12 - x**7*y**7/5040 - x**6*y**9/6 + \
+        x**6*y**7/24 - x**5*y**7/2 + x**5*y**5/120 - x**4*y**5/2 - \
+        x**3*y**3/6 + x**2*y**3 + x*y
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[sin(a), cos(a), a])
+    assert rs_sin(x + a, x, 5) == sin(a)*x**4/24 - cos(a)*x**3/6 - \
+        sin(a)*x**2/2 + cos(a)*x + sin(a)
+    assert rs_sin(x + x**2*y + a, x, 5) == -sin(a)*x**4*y**2/2 - \
+        cos(a)*x**4*y/2 + sin(a)*x**4/24 - sin(a)*x**3*y - cos(a)*x**3/6 + \
+        cos(a)*x**2*y - sin(a)*x**2/2 + cos(a)*x + sin(a)
+
+    R, x, y = ring('x, y', EX)
+    assert rs_sin(x + a, x, 5) == EX(sin(a)/24)*x**4 - EX(cos(a)/6)*x**3 - \
+        EX(sin(a)/2)*x**2 + EX(cos(a))*x + EX(sin(a))
+    assert rs_sin(x + x**2*y + a, x, 5) == -EX(sin(a)/2)*x**4*y**2 - \
+        EX(cos(a)/2)*x**4*y + EX(sin(a)/24)*x**4 - EX(sin(a))*x**3*y - \
+        EX(cos(a)/6)*x**3 + EX(cos(a))*x**2*y - EX(sin(a)/2)*x**2 + \
+        EX(cos(a))*x + EX(sin(a))
+
+
+def test_cos():
+    R, x, y = ring('x, y', QQ)
+    assert rs_cos(x, x, 9) == 1 - x**2/2 + x**4/24 - x**6/720 + x**8/40320
+    assert rs_cos(x*y + x**2*y**3, x, 9) == x**8*y**12/24 - \
+        x**8*y**10/48 + x**8*y**8/40320 + x**7*y**10/6 - \
+        x**7*y**8/120 + x**6*y**8/4 - x**6*y**6/720 + x**5*y**6/6 - \
+        x**4*y**6/2 + x**4*y**4/24 - x**3*y**4 - x**2*y**2/2 + 1
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[sin(a), cos(a), a])
+    assert rs_cos(x + a, x, 5) == cos(a)*x**4/24 + sin(a)*x**3/6 - \
+        cos(a)*x**2/2 - sin(a)*x + cos(a)
+    assert rs_cos(x + x**2*y + a, x, 5) == -cos(a)*x**4*y**2/2 + \
+        sin(a)*x**4*y/2 + cos(a)*x**4/24 - cos(a)*x**3*y + sin(a)*x**3/6 - \
+        sin(a)*x**2*y - cos(a)*x**2/2 - sin(a)*x + cos(a)
+
+    R, x, y = ring('x, y', EX)
+    assert rs_cos(x + a, x, 5) == EX(cos(a)/24)*x**4 + EX(sin(a)/6)*x**3 - \
+        EX(cos(a)/2)*x**2 - EX(sin(a))*x + EX(cos(a))
+    assert rs_cos(x + x**2*y + a, x, 5) == -EX(cos(a)/2)*x**4*y**2 + \
+        EX(sin(a)/2)*x**4*y + EX(cos(a)/24)*x**4 - EX(cos(a))*x**3*y + \
+        EX(sin(a)/6)*x**3 - EX(sin(a))*x**2*y - EX(cos(a)/2)*x**2 - \
+        EX(sin(a))*x + EX(cos(a))
+
+
+def test_cos_sin():
+    R, x, y = ring('x, y', QQ)
+    c, s = rs_cos_sin(x, x, 9)
+    assert c == rs_cos(x, x, 9)
+    assert s == rs_sin(x, x, 9)
+    c, s = rs_cos_sin(x + x*y, x, 5)
+    assert c == rs_cos(x + x*y, x, 5)
+    assert s == rs_sin(x + x*y, x, 5)
+
+    # constant term in series
+    c, s = rs_cos_sin(1 + x + x**2, x, 5)
+    assert c == rs_cos(1 + x + x**2, x, 5)
+    assert s == rs_sin(1 + x + x**2, x, 5)
+
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[sin(a), cos(a), a])
+    c, s = rs_cos_sin(x + a, x, 5)
+    assert c == rs_cos(x + a, x, 5)
+    assert s == rs_sin(x + a, x, 5)
+
+    R, x, y = ring('x, y', EX)
+    c, s = rs_cos_sin(x + a, x, 5)
+    assert c == rs_cos(x + a, x, 5)
+    assert s == rs_sin(x + a, x, 5)
+
+
+def test_atanh():
+    R, x, y = ring('x, y', QQ)
+    assert rs_atanh(x, x, 9) == x + x**3/3 + x**5/5 + x**7/7
+    assert rs_atanh(x*y + x**2*y**3, x, 9) == 2*x**8*y**11 + x**8*y**9 + \
+        2*x**7*y**9 + x**7*y**7/7 + x**6*y**9/3 + x**6*y**7 + x**5*y**7 + \
+        x**5*y**5/5 + x**4*y**5 + x**3*y**3/3 + x**2*y**3 + x*y
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', EX)
+    assert rs_atanh(x + a, x, 5) == EX((a**3 + a)/(a**8 - 4*a**6 + 6*a**4 - \
+        4*a**2 + 1))*x**4 - EX((3*a**2 + 1)/(3*a**6 - 9*a**4 + \
+        9*a**2 - 3))*x**3 + EX(a/(a**4 - 2*a**2 + 1))*x**2 - EX(1/(a**2 - \
+        1))*x + EX(atanh(a))
+    assert rs_atanh(x + x**2*y + a, x, 4) == EX(2*a/(a**4 - 2*a**2 + \
+        1))*x**3*y - EX((3*a**2 + 1)/(3*a**6 - 9*a**4 + 9*a**2 - 3))*x**3 - \
+        EX(1/(a**2 - 1))*x**2*y + EX(a/(a**4 - 2*a**2 + 1))*x**2 - \
+        EX(1/(a**2 - 1))*x + EX(atanh(a))
+
+    p = x + x**2 + 5
+    assert rs_atanh(p, x, 10).compose(x, 10) == EX(Rational(-733442653682135, 5079158784) \
+        + atanh(5))
+
+    # Test for _atanh faster for small and univariate series
+    R,x  = ring('x', QQ)
+    p = x**2 + 2*x
+    assert _atanh(p, x, 5) == rs_atanh(p, x, 5)
+
+    R,x = ring('x', EX)
+    p = x**2 + 2*x
+    assert _atanh(p, x, 9) == rs_atanh(p, x, 9)
+
+
+def test_asinh():
+    R, x, y = ring('x, y', QQ)
+    assert rs_asinh(x, x, 9) == -5/112*x**7 + 3/40*x**5 - 1/6*x**3 + x
+    assert rs_asinh(x*y + x**2*y**3, x, 9) == 3/4*x**8*y**11 - 5/16*x**8*y**9 + \
+        3/4*x**7*y**9 - 5/112*x**7*y**7 - 1/6*x**6*y**9 + 3/8*x**6*y**7 - 1/2*x \
+        **5*y**7 + 3/40*x**5*y**5 - 1/2*x**4*y**5 - 1/6*x**3*y**3 + x**2*y**3 + x*y
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', EX)
+    assert rs_asinh(x + a, x, 3) == -EX(a/(2*a**2*sqrt(a**2 + 1) + 2*sqrt(a**2 + 1))) \
+        *x**2 + EX(1/sqrt(a**2 + 1))*x + EX(asinh(a))
+    assert rs_asinh(x + x**2*y + a, x, 3) == EX(1/sqrt(a**2 + 1))*x**2*y - EX(a/(2*a**2 \
+        *sqrt(a**2 + 1) + 2*sqrt(a**2 + 1)))*x**2 + EX(1/sqrt(a**2 + 1))*x + EX(asinh(a))
+
+    p = x + x ** 2 + 5
+    assert rs_asinh(p, x, 10).compose(x, 10) == EX(asinh(5) + 4643789843094995*sqrt(26)/\
+        205564141692)
+
+
+def test_sinh():
+    R, x, y = ring('x, y', QQ)
+    assert rs_sinh(x, x, 9) == x + x**3/6 + x**5/120 + x**7/5040
+    assert rs_sinh(x*y + x**2*y**3, x, 9) == x**8*y**11/12 + \
+        x**8*y**9/720 + x**7*y**9/12 + x**7*y**7/5040 + x**6*y**9/6 + \
+        x**6*y**7/24 + x**5*y**7/2 + x**5*y**5/120 + x**4*y**5/2 + \
+        x**3*y**3/6 + x**2*y**3 + x*y
+
+    # constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[sinh(a), cosh(a), a])
+    assert rs_sinh(x + a, x, 5) == 1/24*x**4*(sinh(a)) + 1/6*x**3*(cosh(a)) + 1/\
+        2*x**2*(sinh(a)) + x*(cosh(a)) + (sinh(a))
+    assert rs_sinh(x + x**2*y + a, x, 5) == 1/2*(sinh(a))*x**4*y**2 + 1/2*(cosh(a))\
+        *x**4*y + 1/24*(sinh(a))*x**4 + (sinh(a))*x**3*y + 1/6*(cosh(a))*x**3 + \
+        (cosh(a))*x**2*y + 1/2*(sinh(a))*x**2 + (cosh(a))*x + (sinh(a))
+
+    R, x, y = ring('x, y', EX)
+    assert rs_sinh(x + a, x, 5) == EX(sinh(a)/24)*x**4 + EX(cosh(a)/6)*x**3 + \
+        EX(sinh(a)/2)*x**2 + EX(cosh(a))*x + EX(sinh(a))
+    assert rs_sinh(x + x**2*y + a, x, 5) == EX(sinh(a)/2)*x**4*y**2 + EX(cosh(a)/\
+        2)*x**4*y + EX(sinh(a)/24)*x**4 + EX(sinh(a))*x**3*y + EX(cosh(a)/6)*x**3 \
+        + EX(cosh(a))*x**2*y + EX(sinh(a)/2)*x**2 + EX(cosh(a))*x + EX(sinh(a))
+
+
+def test_cosh():
+    R, x, y = ring('x, y', QQ)
+    assert rs_cosh(x, x, 9) == 1 + x**2/2 + x**4/24 + x**6/720 + x**8/40320
+    assert rs_cosh(x*y + x**2*y**3, x, 9) == x**8*y**12/24 + \
+        x**8*y**10/48 + x**8*y**8/40320 + x**7*y**10/6 + \
+        x**7*y**8/120 + x**6*y**8/4 + x**6*y**6/720 + x**5*y**6/6 + \
+        x**4*y**6/2 + x**4*y**4/24 + x**3*y**4 + x**2*y**2/2 + 1
+
+    # constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[sinh(a), cosh(a), a])
+    assert rs_cosh(x + a, x, 5) == 1/24*(cosh(a))*x**4 + 1/6*(sinh(a))*x**3 + \
+        1/2*(cosh(a))*x**2 + (sinh(a))*x + (cosh(a))
+    assert rs_cosh(x + x**2*y + a, x, 5) == 1/2*(cosh(a))*x**4*y**2 + 1/2*(sinh(a))\
+        *x**4*y + 1/24*(cosh(a))*x**4 + (cosh(a))*x**3*y + 1/6*(sinh(a))*x**3 + \
+        (sinh(a))*x**2*y + 1/2*(cosh(a))*x**2 + (sinh(a))*x + (cosh(a))
+    R, x, y = ring('x, y', EX)
+    assert rs_cosh(x + a, x, 5) == EX(cosh(a)/24)*x**4 + EX(sinh(a)/6)*x**3 + \
+        EX(cosh(a)/2)*x**2 + EX(sinh(a))*x + EX(cosh(a))
+    assert rs_cosh(x + x**2*y + a, x, 5) == EX(cosh(a)/2)*x**4*y**2 + EX(sinh(a)/\
+        2)*x**4*y + EX(cosh(a)/24)*x**4 + EX(cosh(a))*x**3*y + EX(sinh(a)/6)*x**3 \
+        + EX(sinh(a))*x**2*y + EX(cosh(a)/2)*x**2 + EX(sinh(a))*x + EX(cosh(a))
+
+
+def test_cosh_sinh():
+    R, x, y = ring('x, y', QQ)
+    ch, sh = rs_cosh_sinh(x, x, 9)
+    assert ch == rs_cosh(x, x, 9)
+    assert sh == rs_sinh(x, x, 9)
+    ch, sh = rs_cosh_sinh(x + x*y, x, 5)
+    assert ch == rs_cosh(x + x*y, x, 5)
+    assert sh == rs_sinh(x + x*y, x, 5)
+
+    # constant term in series
+    c, s = rs_cosh_sinh(1 + x + x**2, x, 5)
+    assert c == rs_cosh(1 + x + x**2, x, 5)
+    assert s == rs_sinh(1 + x + x**2, x, 5)
+
+    a = symbols('a')
+    R, x, y = ring('x, y', QQ[sinh(a), cosh(a), a])
+    ch, sh = rs_cosh_sinh(x + a, x, 5)
+    assert ch == rs_cosh(x + a, x, 5)
+    assert sh == rs_sinh(x + a, x, 5)
+    R, x, y = ring('x, y', EX)
+    ch, sh = rs_cosh_sinh(x + a, x, 5)
+    assert ch == rs_cosh(x + a, x, 5)
+    assert sh == rs_sinh(x + a, x, 5)
+
+
+def test_tanh():
+    R, x, y = ring('x, y', QQ)
+    assert rs_tanh(x, x, 9) == x - QQ(1,3)*x**3 + QQ(2,15)*x**5 - QQ(17,315)*x**7
+    assert rs_tanh(x*y + x**2*y**3, x, 9) == 4*x**8*y**11/3 - \
+        17*x**8*y**9/45 + 4*x**7*y**9/3 - 17*x**7*y**7/315 - x**6*y**9/3 + \
+        2*x**6*y**7/3 - x**5*y**7 + 2*x**5*y**5/15 - x**4*y**5 - \
+        x**3*y**3/3 + x**2*y**3 + x*y
+
+    # Constant term in series
+    a = symbols('a')
+    R, x, y = ring('x, y', EX)
+    assert rs_tanh(x + a, x, 5) == EX(tanh(a)**5 - 5*tanh(a)**3/3 +
+        2*tanh(a)/3)*x**4 + EX(-tanh(a)**4 + 4*tanh(a)**2/3 - QQ(1, 3))*x**3 + \
+        EX(tanh(a)**3 - tanh(a))*x**2 + EX(-tanh(a)**2 + 1)*x + EX(tanh(a))
+
+    p = rs_tanh(x + x**2*y + a, x, 4)
+    assert (p.compose(x, 10)).compose(y, 5) == EX(-1000*tanh(a)**4 + \
+        10100*tanh(a)**3 + 2470*tanh(a)**2/3 - 10099*tanh(a) + QQ(530, 3))
+
+
+def test_RR():
+    rs_funcs = [rs_sin, rs_cos, rs_tan, rs_cot, rs_atan, rs_tanh]
+    sympy_funcs = [sin, cos, tan, cot, atan, tanh]
+    R, x, y = ring('x, y', RR)
+    a = symbols('a')
+    for rs_func, sympy_func in zip(rs_funcs, sympy_funcs):
+        p = rs_func(2 + x, x, 5).compose(x, 5)
+        q = sympy_func(2 + a).series(a, 0, 5).removeO()
+        is_close(p.as_expr(), q.subs(a, 5).n())
+
+    p = rs_nth_root(2 + x, 5, x, 5).compose(x, 5)
+    q = ((2 + a)**QQ(1, 5)).series(a, 0, 5).removeO()
+    is_close(p.as_expr(), q.subs(a, 5).n())
+
+
+def test_is_regular():
+    R, x, y = puiseux_ring('x, y', QQ)
+    p = 1 + 2*x + x**2 + 3*x**3
+    assert not rs_is_puiseux(p, x)
+
+    p = x + x**QQ(1,5)*y
+    assert rs_is_puiseux(p, x)
+    assert not rs_is_puiseux(p, y)
+
+    p = x + x**2*y**QQ(1,5)*y
+    assert not rs_is_puiseux(p, x)
+
+
+def test_puiseux():
+    R, x, y = puiseux_ring('x, y', QQ)
+    p = x**QQ(2,5) + x**QQ(2,3) + x
+
+    r = rs_series_inversion(p, x, 1)
+    r1 = -x**QQ(14,15) + x**QQ(4,5) - 3*x**QQ(11,15) + x**QQ(2,3) + \
+        2*x**QQ(7,15) - x**QQ(2,5) - x**QQ(1,5) + x**QQ(2,15) - x**QQ(-2,15) \
+        + x**QQ(-2,5)
+    assert r == r1
+
+    r = rs_nth_root(1 + p, 3, x, 1)
+    assert r == -x**QQ(4,5)/9 + x**QQ(2,3)/3 + x**QQ(2,5)/3 + 1
+
+    r = rs_log(1 + p, x, 1)
+    assert r == -x**QQ(4,5)/2 + x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_LambertW(p, x, 1)
+    assert r == -x**QQ(4,5) + x**QQ(2,3) + x**QQ(2,5)
+
+    p1 = x + x**QQ(1,5)*y
+    r = rs_exp(p1, x, 1)
+    assert r == x**QQ(4,5)*y**4/24 + x**QQ(3,5)*y**3/6 + x**QQ(2,5)*y**2/2 + \
+        x**QQ(1,5)*y + 1
+
+    r = rs_atan(p, x, 2)
+    assert r ==  -x**QQ(9,5) - x**QQ(26,15) - x**QQ(22,15) - x**QQ(6,5)/3 + \
+        x + x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_atan(p1, x, 2)
+    assert r ==  x**QQ(9,5)*y**9/9 + x**QQ(9,5)*y**4 - x**QQ(7,5)*y**7/7 - \
+        x**QQ(7,5)*y**2 + x*y**5/5 + x - x**QQ(3,5)*y**3/3 + x**QQ(1,5)*y
+
+    r = rs_tan(p, x, 2)
+    assert r == x**QQ(2,5) + x**QQ(2,3) + x + QQ(1,3)*x**QQ(6,5) + x**QQ(22,15)\
+        + x**QQ(26,15) + x**QQ(9,5)
+
+    r = rs_sin(p, x, 2)
+    assert r == x**QQ(2,5) + x**QQ(2,3) + x - QQ(1,6)*x**QQ(6,5) - QQ(1,2)*x**\
+        QQ(22,15) - QQ(1,2)*x**QQ(26,15) - QQ(1,2)*x**QQ(9,5)
+
+    r = rs_cos(p, x, 2)
+    assert r == 1 - QQ(1,2)*x**QQ(4,5) - x**QQ(16,15) - QQ(1,2)*x**QQ(4,3) - \
+        x**QQ(7,5) + QQ(1,24)*x**QQ(8,5) - x**QQ(5,3) + QQ(1,6)*x**QQ(28,15)
+
+    r = rs_asin(p, x, 2)
+    assert r == x**QQ(9,5)/2 + x**QQ(26,15)/2 + x**QQ(22,15)/2 + \
+        x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_cot(p, x, 1)
+    assert r == -x**QQ(14,15) + x**QQ(4,5) - 3*x**QQ(11,15) + \
+        2*x**QQ(2,3)/3 + 2*x**QQ(7,15) - 4*x**QQ(2,5)/3 - x**QQ(1,5) + \
+        x**QQ(2,15) - x**QQ(-2,15) + x**QQ(-2,5)
+
+    r = rs_cos_sin(p, x, 2)
+    assert r[0] == x**QQ(28,15)/6 - x**QQ(5,3) + x**QQ(8,5)/24 - x**QQ(7,5) - \
+        x**QQ(4,3)/2 - x**QQ(16,15) - x**QQ(4,5)/2 + 1
+    assert r[1] == -x**QQ(9,5)/2 - x**QQ(26,15)/2 - x**QQ(22,15)/2 - \
+        x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_atanh(p, x, 2)
+    assert r == x**QQ(9,5) + x**QQ(26,15) + x**QQ(22,15) + x**QQ(6,5)/3 + x + \
+        x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_asinh(p, x, 2)
+    assert r == x**QQ(2,5) + x**QQ(2,3) + x - QQ(1,6)*x**QQ(6,5) - QQ(1,2)*x**\
+        QQ(22,15) - QQ(1,2)*x**QQ(26,15) - QQ(1,2)*x**QQ(9,5)
+
+    r = rs_cosh(p, x, 2)
+    assert r == x**QQ(28,15)/6 + x**QQ(5,3) + x**QQ(8,5)/24 + x**QQ(7,5) + \
+        x**QQ(4,3)/2 + x**QQ(16,15) + x**QQ(4,5)/2 + 1
+
+    r = rs_sinh(p, x, 2)
+    assert r == x**QQ(9,5)/2 + x**QQ(26,15)/2 + x**QQ(22,15)/2 + \
+        x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_cosh_sinh(p, x, 2)
+    assert r[0] == x**QQ(28,15)/6 + x**QQ(5,3) + x**QQ(8,5)/24 + x**QQ(7,5) + \
+        x**QQ(4,3)/2 + x**QQ(16,15) + x**QQ(4,5)/2 + 1
+    assert r[1] == x**QQ(9,5)/2 + x**QQ(26,15)/2 + x**QQ(22,15)/2 + \
+        x**QQ(6,5)/6 + x + x**QQ(2,3) + x**QQ(2,5)
+
+    r = rs_tanh(p, x, 2)
+    assert r == -x**QQ(9,5) - x**QQ(26,15) - x**QQ(22,15) - x**QQ(6,5)/3 + \
+        x + x**QQ(2,3) + x**QQ(2,5)
+
+
+def test_puiseux_algebraic(): # https://github.com/sympy/sympy/issues/24395
+
+    K = QQ.algebraic_field(sqrt(2))
+    sqrt2 = K.from_sympy(sqrt(2))
+    x, y = symbols('x, y')
+    R, xr, yr = puiseux_ring([x, y], K)
+    p = (1+sqrt2)*xr**QQ(1,2) + (1-sqrt2)*yr**QQ(2,3)
+
+    assert p.to_dict() == {(QQ(1,2),QQ(0)):1+sqrt2, (QQ(0),QQ(2,3)):1-sqrt2}
+    assert p.as_expr() == (1 + sqrt(2))*x**(S(1)/2) + (1 - sqrt(2))*y**(S(2)/3)
+
+
+def test1():
+    R, x = puiseux_ring('x', QQ)
+    r = rs_sin(x, x, 15)*x**(-5)
+    assert r == x**8/6227020800 - x**6/39916800 + x**4/362880 - x**2/5040 + \
+        QQ(1,120) - x**-2/6 + x**-4
+
+    p = rs_sin(x, x, 10)
+    r = rs_nth_root(p, 2, x, 10)
+    assert  r == -67*x**QQ(17,2)/29030400 - x**QQ(13,2)/24192 + \
+        x**QQ(9,2)/1440 - x**QQ(5,2)/12 + x**QQ(1,2)
+
+    p = rs_sin(x, x, 10)
+    r = rs_nth_root(p, 7, x, 10)
+    r = rs_pow(r, 5, x, 10)
+    assert r == -97*x**QQ(61,7)/124467840 - x**QQ(47,7)/16464 + \
+        11*x**QQ(33,7)/3528 - 5*x**QQ(19,7)/42 + x**QQ(5,7)
+
+    r = rs_exp(x**QQ(1,2), x, 10)
+    assert r == x**QQ(19,2)/121645100408832000 + x**9/6402373705728000 + \
+        x**QQ(17,2)/355687428096000 + x**8/20922789888000 + \
+        x**QQ(15,2)/1307674368000 + x**7/87178291200 + \
+        x**QQ(13,2)/6227020800 + x**6/479001600 + x**QQ(11,2)/39916800 + \
+        x**5/3628800 + x**QQ(9,2)/362880 + x**4/40320 + x**QQ(7,2)/5040 + \
+        x**3/720 + x**QQ(5,2)/120 + x**2/24 + x**QQ(3,2)/6 + x/2 + \
+        x**QQ(1,2) + 1
+
+
+def test_puiseux2():
+    R, y = ring('y', QQ)
+    S, x = puiseux_ring('x', R.to_domain())
+
+    p = x + x**QQ(1,5)*y
+    r = rs_atan(p, x, 3)
+    assert r == (y**13/13 + y**8 + 2*y**3)*x**QQ(13,5) - (y**11/11 + y**6 +
+        y)*x**QQ(11,5) + (y**9/9 + y**4)*x**QQ(9,5) - (y**7/7 +
+        y**2)*x**QQ(7,5) + (y**5/5 + 1)*x - y**3*x**QQ(3,5)/3 + y*x**QQ(1,5)
+
+
+@slow
+def test_rs_series():
+    x, a, b, c = symbols('x, a, b, c')
+
+    assert rs_series(a, a, 5).as_expr() == a
+    assert rs_series(sin(a), a, 5).as_expr() == (sin(a).series(a, 0,
+        5)).removeO()
+    assert rs_series(sin(a) + cos(a), a, 5).as_expr() == ((sin(a) +
+        cos(a)).series(a, 0, 5)).removeO()
+    assert rs_series(sin(a)*cos(a), a, 5).as_expr() == ((sin(a)*
+        cos(a)).series(a, 0, 5)).removeO()
+
+    p = (sin(a) - a)*(cos(a**2) + a**4/2)
+    assert expand(rs_series(p, a, 10).as_expr()) == expand(p.series(a, 0,
+        10).removeO())
+
+    p = sin(a**2/2 + a/3) + cos(a/5)*sin(a/2)**3
+    assert expand(rs_series(p, a, 5).as_expr()) == expand(p.series(a, 0,
+        5).removeO())
+
+    p = sin(x**2 + a)*(cos(x**3 - 1) - a - a**2)
+    assert expand(rs_series(p, a, 5).as_expr()) == expand(p.series(a, 0,
+        5).removeO())
+
+    p = sin(a**2 - a/3 + 2)**5*exp(a**3 - a/2)
+    assert expand(rs_series(p, a, 10).as_expr()) == expand(p.series(a, 0,
+        10).removeO())
+
+    p = sin(a + b + c)
+    assert expand(rs_series(p, a, 5).as_expr()) == expand(p.series(a, 0,
+        5).removeO())
+
+    p = tan(sin(a**2 + 4) + b + c)
+    assert expand(rs_series(p, a, 6).as_expr()) == expand(p.series(a, 0,
+        6).removeO())
+
+    p = a**QQ(2,5) + a**QQ(2,3) + a
+
+    r = rs_series(tan(p), a, 2)
+    assert r.as_expr() == a**QQ(9,5) + a**QQ(26,15) + a**QQ(22,15) + a**QQ(6,5)/3 + \
+        a + a**QQ(2,3) + a**QQ(2,5)
+
+    r = rs_series(exp(p), a, 1)
+    assert r.as_expr() == a**QQ(4,5)/2 + a**QQ(2,3) + a**QQ(2,5) + 1
+
+    r = rs_series(sin(p), a, 2)
+    assert r.as_expr() == -a**QQ(9,5)/2 - a**QQ(26,15)/2 - a**QQ(22,15)/2 - \
+        a**QQ(6,5)/6 + a + a**QQ(2,3) + a**QQ(2,5)
+
+    r = rs_series(cos(p), a, 2)
+    assert r.as_expr() == a**QQ(28,15)/6 - a**QQ(5,3) + a**QQ(8,5)/24 - a**QQ(7,5) - \
+        a**QQ(4,3)/2 - a**QQ(16,15) - a**QQ(4,5)/2 + 1
+
+    assert rs_series(sin(a)/7, a, 5).as_expr() == (sin(a)/7).series(a, 0,
+            5).removeO()
+
+
+def test_rs_series_ConstantInExpr():
+    x, a = symbols('x a')
+    assert rs_series(log(1 + x), x, 5).as_expr() == -x**4/4 + x**3/3 - \
+            x**2/2 + x
+    assert rs_series(log(1 + 4*x), x, 5).as_expr() == -64*x**4 + 64*x**3/3 - \
+            8*x**2 + 4*x
+    assert rs_series(log(1 + x + x**2), x, 10).as_expr() == -2*x**9/9 + \
+            x**8/8 + x**7/7 - x**6/3 + x**5/5 + x**4/4 - 2*x**3/3 + x**2/2 + x
+    assert rs_series(log(1 + x*a**2), x, 7).as_expr() == -x**6*a**12/6 + \
+            x**5*a**10/5 - x**4*a**8/4 + x**3*a**6/3 - x**2*a**4/2 + x*a**2
+
+    assert rs_series(atan(1 + x), x, 9).as_expr() == -x**7/112 + x**6/48 - x**5/40 \
+            + x**3/12 - x**2/4 + x/2 + pi/4
+    assert rs_series(atan(1 + x + x**2),x, 9).as_expr() == -15*x**7/112 - x**6/48 + \
+            9*x**5/40 - 5*x**3/12 + x**2/4 + x/2 + pi/4
+    assert rs_series(atan(1 + x * a), x, 9).as_expr() == -a**7*x**7/112 + a**6*x**6/48 \
+            - a**5*x**5/40 + a**3*x**3/12 - a**2*x**2/4 + a*x/2 + pi/4
+
+    assert rs_series(tanh(1 + x), x, 5).as_expr() == -5*x**4*tanh(1)**3/3 + x**4* \
+            tanh(1)**5 + 2*x**4*tanh(1)/3 - x**3*tanh(1)**4 - x**3/3 + 4*x**3*tanh(1) \
+           **2/3 - x**2*tanh(1) + x**2*tanh(1)**3 - x*tanh(1)**2 + x + tanh(1)
+    assert rs_series(tanh(1 + x * a), x, 3).as_expr() == -a**2*x**2*tanh(1) + a**2*x** \
+            2*tanh(1)**3 - a*x*tanh(1)**2 + a*x + tanh(1)
+
+    assert rs_series(sinh(1 + x), x, 5).as_expr() == x**4*sinh(1)/24 + x**3*cosh(1)/6 + \
+            x**2*sinh(1)/2 + x*cosh(1) + sinh(1)
+    assert rs_series(sinh(1 + x * a), x, 5).as_expr() == a**4*x**4*sinh(1)/24 + \
+            a**3*x**3*cosh(1)/6 + a**2*x**2*sinh(1)/2 + a*x*cosh(1) + sinh(1)
+
+    assert rs_series(cosh(1 + x), x, 5).as_expr() == x**4*cosh(1)/24 + x**3*sinh(1)/6 + \
+            x**2*cosh(1)/2 + x*sinh(1) + cosh(1)
+    assert rs_series(cosh(1 + x * a), x, 5).as_expr() == a**4*x**4*cosh(1)/24 + \
+            a**3*x**3*sinh(1)/6 + a**2*x**2*cosh(1)/2 + a*x*sinh(1) + cosh(1)
+
+
+def test_issue():
+    # https://github.com/sympy/sympy/issues/10191
+    # https://github.com/sympy/sympy/issues/19543
+
+    a, b = symbols('a b')
+    assert rs_series(sin(a**QQ(3,7))*exp(a + b**QQ(6,7)), a,2).as_expr() == \
+        a**QQ(10,7)*exp(b**QQ(6,7)) - a**QQ(9,7)*exp(b**QQ(6,7))/6 + a**QQ(3,7)*exp(b**QQ(6,7))

miniconda3/envs/ladir/lib/python3.10/site-packages/sympy/polys/tests/test_rings.py

@@ -0,0 +1,1591 @@
+"""Test sparse polynomials. """
+
+from functools import reduce
+from operator import add, mul
+
+from sympy.polys.rings import ring, xring, sring, PolyRing, PolyElement
+from sympy.polys.fields import field, FracField
+from sympy.polys.densebasic import ninf
+from sympy.polys.domains import ZZ, QQ, RR, FF, EX
+from sympy.polys.orderings import lex, grlex
+from sympy.polys.polyerrors import GeneratorsError, \
+    ExactQuotientFailed, MultivariatePolynomialError, CoercionFailed
+
+from sympy.testing.pytest import raises
+from sympy.core import Symbol, symbols
+from sympy.core.singleton import S
+from sympy.core.numbers import pi
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+
+def test_PolyRing___init__():
+    x, y, z, t = map(Symbol, "xyzt")
+
+    assert len(PolyRing("x,y,z", ZZ, lex).gens) == 3
+    assert len(PolyRing(x, ZZ, lex).gens) == 1
+    assert len(PolyRing(("x", "y", "z"), ZZ, lex).gens) == 3
+    assert len(PolyRing((x, y, z), ZZ, lex).gens) == 3
+    assert len(PolyRing("", ZZ, lex).gens) == 0
+    assert len(PolyRing([], ZZ, lex).gens) == 0
+
+    raises(GeneratorsError, lambda: PolyRing(0, ZZ, lex))
+
+    assert PolyRing("x", ZZ[t], lex).domain == ZZ[t]
+    assert PolyRing("x", 'ZZ[t]', lex).domain == ZZ[t]
+    assert PolyRing("x", PolyRing("t", ZZ, lex), lex).domain == ZZ[t]
+
+    raises(GeneratorsError, lambda: PolyRing("x", PolyRing("x", ZZ, lex), lex))
+
+    _lex = Symbol("lex")
+    assert PolyRing("x", ZZ, lex).order == lex
+    assert PolyRing("x", ZZ, _lex).order == lex
+    assert PolyRing("x", ZZ, 'lex').order == lex
+
+    R1 = PolyRing("x,y", ZZ, lex)
+    R2 = PolyRing("x,y", ZZ, lex)
+    R3 = PolyRing("x,y,z", ZZ, lex)
+
+    assert R1.x == R1.gens[0]
+    assert R1.y == R1.gens[1]
+    assert R1.x == R2.x
+    assert R1.y == R2.y
+    assert R1.x != R3.x
+    assert R1.y != R3.y
+
+def test_PolyRing___hash__():
+    R, x, y, z = ring("x,y,z", QQ)
+    assert hash(R)
+
+def test_PolyRing___eq__():
+    assert ring("x,y,z", QQ)[0] == ring("x,y,z", QQ)[0]
+    assert ring("x,y,z", QQ)[0] != ring("x,y,z", ZZ)[0]
+    assert ring("x,y,z", ZZ)[0] != ring("x,y,z", QQ)[0]
+    assert ring("x,y,z", QQ)[0] != ring("x,y", QQ)[0]
+    assert ring("x,y", QQ)[0] != ring("x,y,z", QQ)[0]
+
+def test_PolyRing_ring_new():
+    R, x, y, z = ring("x,y,z", QQ)
+
+    assert R.ring_new(7) == R(7)
+    assert R.ring_new(7*x*y*z) == 7*x*y*z
+
+    f = x**2 + 2*x*y + 3*x + 4*z**2 + 5*z + 6
+
+    assert R.ring_new([[[1]], [[2], [3]], [[4, 5, 6]]]) == f
+    assert R.ring_new({(2, 0, 0): 1, (1, 1, 0): 2, (1, 0, 0): 3, (0, 0, 2): 4, (0, 0, 1): 5, (0, 0, 0): 6}) == f
+    assert R.ring_new([((2, 0, 0), 1), ((1, 1, 0), 2), ((1, 0, 0), 3), ((0, 0, 2), 4), ((0, 0, 1), 5), ((0, 0, 0), 6)]) == f
+
+    R, = ring("", QQ)
+    assert R.ring_new([((), 7)]) == R(7)
+
+def test_PolyRing_drop():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R.drop(x) == PolyRing("y,z", ZZ, lex)
+    assert R.drop(y) == PolyRing("x,z", ZZ, lex)
+    assert R.drop(z) == PolyRing("x,y", ZZ, lex)
+
+    assert R.drop(0) == PolyRing("y,z", ZZ, lex)
+    assert R.drop(0).drop(0) == PolyRing("z", ZZ, lex)
+    assert R.drop(0).drop(0).drop(0) == ZZ
+
+    assert R.drop(1) == PolyRing("x,z", ZZ, lex)
+
+    assert R.drop(2) == PolyRing("x,y", ZZ, lex)
+    assert R.drop(2).drop(1) == PolyRing("x", ZZ, lex)
+    assert R.drop(2).drop(1).drop(0) == ZZ
+
+    raises(ValueError, lambda: R.drop(3))
+    raises(ValueError, lambda: R.drop(x).drop(y))
+
+def test_PolyRing___getitem__():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R[0:] == PolyRing("x,y,z", ZZ, lex)
+    assert R[1:] == PolyRing("y,z", ZZ, lex)
+    assert R[2:] == PolyRing("z", ZZ, lex)
+    assert R[3:] == ZZ
+
+def test_PolyRing_is_():
+    R = PolyRing("x", QQ, lex)
+
+    assert R.is_univariate is True
+    assert R.is_multivariate is False
+
+    R = PolyRing("x,y,z", QQ, lex)
+
+    assert R.is_univariate is False
+    assert R.is_multivariate is True
+
+    R = PolyRing("", QQ, lex)
+
+    assert R.is_univariate is False
+    assert R.is_multivariate is False
+
+def test_PolyRing_add():
+    R, x = ring("x", ZZ)
+    F = [ x**2 + 2*i + 3 for i in range(4) ]
+
+    assert R.add(F) == reduce(add, F) == 4*x**2 + 24
+
+    R, = ring("", ZZ)
+
+    assert R.add([2, 5, 7]) == 14
+
+def test_PolyRing_mul():
+    R, x = ring("x", ZZ)
+    F = [ x**2 + 2*i + 3 for i in range(4) ]
+
+    assert R.mul(F) == reduce(mul, F) == x**8 + 24*x**6 + 206*x**4 + 744*x**2 + 945
+
+    R, = ring("", ZZ)
+
+    assert R.mul([2, 3, 5]) == 30
+
+def test_PolyRing_symmetric_poly():
+    R, x, y, z, t = ring("x,y,z,t", ZZ)
+
+    raises(ValueError, lambda: R.symmetric_poly(-1))
+    raises(ValueError, lambda: R.symmetric_poly(5))
+
+    assert R.symmetric_poly(0) == R.one
+    assert R.symmetric_poly(1) == x + y + z + t
+    assert R.symmetric_poly(2) == x*y + x*z + x*t + y*z + y*t + z*t
+    assert R.symmetric_poly(3) == x*y*z + x*y*t + x*z*t + y*z*t
+    assert R.symmetric_poly(4) == x*y*z*t
+
+def test_sring():
+    x, y, z, t = symbols("x,y,z,t")
+
+    R = PolyRing("x,y,z", ZZ, lex)
+    assert sring(x + 2*y + 3*z) == (R, R.x + 2*R.y + 3*R.z)
+
+    R = PolyRing("x,y,z", QQ, lex)
+    assert sring(x + 2*y + z/3) == (R, R.x + 2*R.y + R.z/3)
+    assert sring([x, 2*y, z/3]) == (R, [R.x, 2*R.y, R.z/3])
+
+    Rt = PolyRing("t", ZZ, lex)
+    R = PolyRing("x,y,z", Rt, lex)
+    assert sring(x + 2*t*y + 3*t**2*z, x, y, z) == (R, R.x + 2*Rt.t*R.y + 3*Rt.t**2*R.z)
+
+    Rt = PolyRing("t", QQ, lex)
+    R = PolyRing("x,y,z", Rt, lex)
+    assert sring(x + t*y/2 + t**2*z/3, x, y, z) == (R, R.x + Rt.t*R.y/2 + Rt.t**2*R.z/3)
+
+    Rt = FracField("t", ZZ, lex)
+    R = PolyRing("x,y,z", Rt, lex)
+    assert sring(x + 2*y/t + t**2*z/3, x, y, z) == (R, R.x + 2*R.y/Rt.t + Rt.t**2*R.z/3)
+
+    r = sqrt(2) - sqrt(3)
+    R, a = sring(r, extension=True)
+    assert R.domain == QQ.algebraic_field(sqrt(2) + sqrt(3))
+    assert R.gens == ()
+    assert a == R.domain.from_sympy(r)
+
+def test_PolyElement___hash__():
+    R, x, y, z = ring("x,y,z", QQ)
+    assert hash(x*y*z)
+
+def test_PolyElement___eq__():
+    R, x, y = ring("x,y", ZZ, lex)
+
+    assert ((x*y + 5*x*y) == 6) == False
+    assert ((x*y + 5*x*y) == 6*x*y) == True
+    assert (6 == (x*y + 5*x*y)) == False
+    assert (6*x*y == (x*y + 5*x*y)) == True
+
+    assert ((x*y - x*y) == 0) == True
+    assert (0 == (x*y - x*y)) == True
+
+    assert ((x*y - x*y) == 1) == False
+    assert (1 == (x*y - x*y)) == False
+
+    assert ((x*y - x*y) == 1) == False
+    assert (1 == (x*y - x*y)) == False
+
+    assert ((x*y + 5*x*y) != 6) == True
+    assert ((x*y + 5*x*y) != 6*x*y) == False
+    assert (6 != (x*y + 5*x*y)) == True
+    assert (6*x*y != (x*y + 5*x*y)) == False
+
+    assert ((x*y - x*y) != 0) == False
+    assert (0 != (x*y - x*y)) == False
+
+    assert ((x*y - x*y) != 1) == True
+    assert (1 != (x*y - x*y)) == True
+
+    assert R.one == QQ(1, 1) == R.one
+    assert R.one == 1 == R.one
+
+    Rt, t = ring("t", ZZ)
+    R, x, y = ring("x,y", Rt)
+
+    assert (t**3*x/x == t**3) == True
+    assert (t**3*x/x == t**4) == False
+
+def test_PolyElement__lt_le_gt_ge__():
+    R, x, y = ring("x,y", ZZ)
+
+    assert R(1) < x < x**2 < x**3
+    assert R(1) <= x <= x**2 <= x**3
+
+    assert x**3 > x**2 > x > R(1)
+    assert x**3 >= x**2 >= x >= R(1)
+
+def test_PolyElement__str__():
+    x, y = symbols('x, y')
+
+    for dom in [ZZ, QQ, ZZ[x], ZZ[x,y], ZZ[x][y]]:
+        R, t = ring('t', dom)
+        assert str(2*t**2 + 1) == '2*t**2 + 1'
+
+    for dom in [EX, EX[x]]:
+        R, t = ring('t', dom)
+        assert str(2*t**2 + 1) == 'EX(2)*t**2 + EX(1)'
+
+def test_PolyElement_copy():
+    R, x, y, z = ring("x,y,z", ZZ)
+
+    f = x*y + 3*z
+    g = f.copy()
+
+    assert f == g
+    g[(1, 1, 1)] = 7
+    assert f != g
+
+def test_PolyElement_as_expr():
+    R, x, y, z = ring("x,y,z", ZZ)
+    f = 3*x**2*y - x*y*z + 7*z**3 + 1
+
+    X, Y, Z = R.symbols
+    g = 3*X**2*Y - X*Y*Z + 7*Z**3 + 1
+
+    assert f != g
+    assert f.as_expr() == g
+
+    U, V, W = symbols("u,v,w")
+    g = 3*U**2*V - U*V*W + 7*W**3 + 1
+
+    assert f != g
+    assert f.as_expr(U, V, W) == g
+
+    raises(ValueError, lambda: f.as_expr(X))
+
+    R, = ring("", ZZ)
+    assert R(3).as_expr() == 3
+
+def test_PolyElement_from_expr():
+    x, y, z = symbols("x,y,z")
+    R, X, Y, Z = ring((x, y, z), ZZ)
+
+    f = R.from_expr(1)
+    assert f == 1 and R.is_element(f)
+
+    f = R.from_expr(x)
+    assert f == X and R.is_element(f)
+
+    f = R.from_expr(x*y*z)
+    assert f == X*Y*Z and R.is_element(f)
+
+    f = R.from_expr(x*y*z + x*y + x)
+    assert f == X*Y*Z + X*Y + X and R.is_element(f)
+
+    f = R.from_expr(x**3*y*z + x**2*y**7 + 1)
+    assert f == X**3*Y*Z + X**2*Y**7 + 1 and R.is_element(f)
+
+    r, F = sring([exp(2)])
+    f = r.from_expr(exp(2))
+    assert f == F[0] and r.is_element(f)
+
+    raises(ValueError, lambda: R.from_expr(1/x))
+    raises(ValueError, lambda: R.from_expr(2**x))
+    raises(ValueError, lambda: R.from_expr(7*x + sqrt(2)))
+
+    R, = ring("", ZZ)
+    f = R.from_expr(1)
+    assert f == 1 and R.is_element(f)
+
+def test_PolyElement_degree():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert ninf == float('-inf')
+
+    assert R(0).degree() is ninf
+    assert R(1).degree() == 0
+    assert (x + 1).degree() == 1
+    assert (2*y**3 + z).degree() == 0
+    assert (x*y**3 + z).degree() == 1
+    assert (x**5*y**3 + z).degree() == 5
+
+    assert R(0).degree(x) is ninf
+    assert R(1).degree(x) == 0
+    assert (x + 1).degree(x) == 1
+    assert (2*y**3 + z).degree(x) == 0
+    assert (x*y**3 + z).degree(x) == 1
+    assert (7*x**5*y**3 + z).degree(x) == 5
+
+    assert R(0).degree(y) is ninf
+    assert R(1).degree(y) == 0
+    assert (x + 1).degree(y) == 0
+    assert (2*y**3 + z).degree(y) == 3
+    assert (x*y**3 + z).degree(y) == 3
+    assert (7*x**5*y**3 + z).degree(y) == 3
+
+    assert R(0).degree(z) is ninf
+    assert R(1).degree(z) == 0
+    assert (x + 1).degree(z) == 0
+    assert (2*y**3 + z).degree(z) == 1
+    assert (x*y**3 + z).degree(z) == 1
+    assert (7*x**5*y**3 + z).degree(z) == 1
+
+    R, = ring("", ZZ)
+    assert R(0).degree() is ninf
+    assert R(1).degree() == 0
+
+def test_PolyElement_tail_degree():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R(0).tail_degree() is ninf
+    assert R(1).tail_degree() == 0
+    assert (x + 1).tail_degree() == 0
+    assert (2*y**3 + x**3*z).tail_degree() == 0
+    assert (x*y**3 + x**3*z).tail_degree() == 1
+    assert (x**5*y**3 + x**3*z).tail_degree() == 3
+
+    assert R(0).tail_degree(x) is ninf
+    assert R(1).tail_degree(x) == 0
+    assert (x + 1).tail_degree(x) == 0
+    assert (2*y**3 + x**3*z).tail_degree(x) == 0
+    assert (x*y**3 + x**3*z).tail_degree(x) == 1
+    assert (7*x**5*y**3 + x**3*z).tail_degree(x) == 3
+
+    assert R(0).tail_degree(y) is ninf
+    assert R(1).tail_degree(y) == 0
+    assert (x + 1).tail_degree(y) == 0
+    assert (2*y**3 + x**3*z).tail_degree(y) == 0
+    assert (x*y**3 + x**3*z).tail_degree(y) == 0
+    assert (7*x**5*y**3 + x**3*z).tail_degree(y) == 0
+
+    assert R(0).tail_degree(z) is ninf
+    assert R(1).tail_degree(z) == 0
+    assert (x + 1).tail_degree(z) == 0
+    assert (2*y**3 + x**3*z).tail_degree(z) == 0
+    assert (x*y**3 + x**3*z).tail_degree(z) == 0
+    assert (7*x**5*y**3 + x**3*z).tail_degree(z) == 0
+
+    R, = ring("", ZZ)
+    assert R(0).tail_degree() is ninf
+    assert R(1).tail_degree() == 0
+
+def test_PolyElement_degrees():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R(0).degrees() == (ninf, ninf, ninf)
+    assert R(1).degrees() == (0, 0, 0)
+    assert (x**2*y + x**3*z**2).degrees() == (3, 1, 2)
+
+def test_PolyElement_tail_degrees():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R(0).tail_degrees() == (ninf, ninf, ninf)
+    assert R(1).tail_degrees() == (0, 0, 0)
+    assert (x**2*y + x**3*z**2).tail_degrees() == (2, 0, 0)
+
+def test_PolyElement_coeff():
+    R, x, y, z = ring("x,y,z", ZZ, lex)
+    f = 3*x**2*y - x*y*z + 7*z**3 + 23
+
+    assert f.coeff(1) == 23
+    raises(ValueError, lambda: f.coeff(3))
+
+    assert f.coeff(x) == 0
+    assert f.coeff(y) == 0
+    assert f.coeff(z) == 0
+
+    assert f.coeff(x**2*y) == 3
+    assert f.coeff(x*y*z) == -1
+    assert f.coeff(z**3) == 7
+
+    raises(ValueError, lambda: f.coeff(3*x**2*y))
+    raises(ValueError, lambda: f.coeff(-x*y*z))
+    raises(ValueError, lambda: f.coeff(7*z**3))
+
+    R, = ring("", ZZ)
+    assert R(3).coeff(1) == 3
+
+def test_PolyElement_LC():
+    R, x, y = ring("x,y", QQ, lex)
+    assert R(0).LC == QQ(0)
+    assert (QQ(1,2)*x).LC == QQ(1, 2)
+    assert (QQ(1,4)*x*y + QQ(1,2)*x).LC == QQ(1, 4)
+
+def test_PolyElement_LM():
+    R, x, y = ring("x,y", QQ, lex)
+    assert R(0).LM == (0, 0)
+    assert (QQ(1,2)*x).LM == (1, 0)
+    assert (QQ(1,4)*x*y + QQ(1,2)*x).LM == (1, 1)
+
+def test_PolyElement_LT():
+    R, x, y = ring("x,y", QQ, lex)
+    assert R(0).LT == ((0, 0), QQ(0))
+    assert (QQ(1,2)*x).LT == ((1, 0), QQ(1, 2))
+    assert (QQ(1,4)*x*y + QQ(1,2)*x).LT == ((1, 1), QQ(1, 4))
+
+    R, = ring("", ZZ)
+    assert R(0).LT == ((), 0)
+    assert R(1).LT == ((), 1)
+
+def test_PolyElement_leading_monom():
+    R, x, y = ring("x,y", QQ, lex)
+    assert R(0).leading_monom() == 0
+    assert (QQ(1,2)*x).leading_monom() == x
+    assert (QQ(1,4)*x*y + QQ(1,2)*x).leading_monom() == x*y
+
+def test_PolyElement_leading_term():
+    R, x, y = ring("x,y", QQ, lex)
+    assert R(0).leading_term() == 0
+    assert (QQ(1,2)*x).leading_term() == QQ(1,2)*x
+    assert (QQ(1,4)*x*y + QQ(1,2)*x).leading_term() == QQ(1,4)*x*y
+
+def test_PolyElement_terms():
+    R, x,y,z = ring("x,y,z", QQ)
+    terms = (x**2/3 + y**3/4 + z**4/5).terms()
+    assert terms == [((2,0,0), QQ(1,3)), ((0,3,0), QQ(1,4)), ((0,0,4), QQ(1,5))]
+
+    R, x,y = ring("x,y", ZZ, lex)
+    f = x*y**7 + 2*x**2*y**3
+
+    assert f.terms() == f.terms(lex) == f.terms('lex') == [((2, 3), 2), ((1, 7), 1)]
+    assert f.terms(grlex) == f.terms('grlex') == [((1, 7), 1), ((2, 3), 2)]
+
+    R, x,y = ring("x,y", ZZ, grlex)
+    f = x*y**7 + 2*x**2*y**3
+
+    assert f.terms() == f.terms(grlex) == f.terms('grlex') == [((1, 7), 1), ((2, 3), 2)]
+    assert f.terms(lex) == f.terms('lex') == [((2, 3), 2), ((1, 7), 1)]
+
+    R, = ring("", ZZ)
+    assert R(3).terms() == [((), 3)]
+
+def test_PolyElement_monoms():
+    R, x,y,z = ring("x,y,z", QQ)
+    monoms = (x**2/3 + y**3/4 + z**4/5).monoms()
+    assert monoms == [(2,0,0), (0,3,0), (0,0,4)]
+
+    R, x,y = ring("x,y", ZZ, lex)
+    f = x*y**7 + 2*x**2*y**3
+
+    assert f.monoms() == f.monoms(lex) == f.monoms('lex') == [(2, 3), (1, 7)]
+    assert f.monoms(grlex) == f.monoms('grlex') == [(1, 7), (2, 3)]
+
+    R, x,y = ring("x,y", ZZ, grlex)
+    f = x*y**7 + 2*x**2*y**3
+
+    assert f.monoms() == f.monoms(grlex) == f.monoms('grlex') == [(1, 7), (2, 3)]
+    assert f.monoms(lex) == f.monoms('lex') == [(2, 3), (1, 7)]
+
+def test_PolyElement_coeffs():
+    R, x,y,z = ring("x,y,z", QQ)
+    coeffs = (x**2/3 + y**3/4 + z**4/5).coeffs()
+    assert coeffs == [QQ(1,3), QQ(1,4), QQ(1,5)]
+
+    R, x,y = ring("x,y", ZZ, lex)
+    f = x*y**7 + 2*x**2*y**3
+
+    assert f.coeffs() == f.coeffs(lex) == f.coeffs('lex') == [2, 1]
+    assert f.coeffs(grlex) == f.coeffs('grlex') == [1, 2]
+
+    R, x,y = ring("x,y", ZZ, grlex)
+    f = x*y**7 + 2*x**2*y**3
+
+    assert f.coeffs() == f.coeffs(grlex) == f.coeffs('grlex') == [1, 2]
+    assert f.coeffs(lex) == f.coeffs('lex') == [2, 1]
+
+def test_PolyElement___add__():
+    Rt, t = ring("t", ZZ)
+    Ruv, u,v = ring("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Ruv)
+
+    assert dict(x + 3*y) == {(1, 0, 0): 1, (0, 1, 0): 3}
+
+    assert dict(u + x) == dict(x + u) == {(1, 0, 0): 1, (0, 0, 0): u}
+    assert dict(u + x*y) == dict(x*y + u) == {(1, 1, 0): 1, (0, 0, 0): u}
+    assert dict(u + x*y + z) == dict(x*y + z + u) == {(1, 1, 0): 1, (0, 0, 1): 1, (0, 0, 0): u}
+
+    assert dict(u*x + x) == dict(x + u*x) == {(1, 0, 0): u + 1}
+    assert dict(u*x + x*y) == dict(x*y + u*x) == {(1, 1, 0): 1, (1, 0, 0): u}
+    assert dict(u*x + x*y + z) == dict(x*y + z + u*x) == {(1, 1, 0): 1, (0, 0, 1): 1, (1, 0, 0): u}
+
+    raises(TypeError, lambda: t + x)
+    raises(TypeError, lambda: x + t)
+    raises(TypeError, lambda: t + u)
+    raises(TypeError, lambda: u + t)
+
+    Fuv, u,v = field("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Fuv)
+
+    assert dict(u + x) == dict(x + u) == {(1, 0, 0): 1, (0, 0, 0): u}
+
+    Rxyz, x,y,z = ring("x,y,z", EX)
+
+    assert dict(EX(pi) + x*y*z) == dict(x*y*z + EX(pi)) == {(1, 1, 1): EX(1), (0, 0, 0): EX(pi)}
+
+def test_PolyElement___sub__():
+    Rt, t = ring("t", ZZ)
+    Ruv, u,v = ring("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Ruv)
+
+    assert dict(x - 3*y) == {(1, 0, 0): 1, (0, 1, 0): -3}
+
+    assert dict(-u + x) == dict(x - u) == {(1, 0, 0): 1, (0, 0, 0): -u}
+    assert dict(-u + x*y) == dict(x*y - u) == {(1, 1, 0): 1, (0, 0, 0): -u}
+    assert dict(-u + x*y + z) == dict(x*y + z - u) == {(1, 1, 0): 1, (0, 0, 1): 1, (0, 0, 0): -u}
+
+    assert dict(-u*x + x) == dict(x - u*x) == {(1, 0, 0): -u + 1}
+    assert dict(-u*x + x*y) == dict(x*y - u*x) == {(1, 1, 0): 1, (1, 0, 0): -u}
+    assert dict(-u*x + x*y + z) == dict(x*y + z - u*x) == {(1, 1, 0): 1, (0, 0, 1): 1, (1, 0, 0): -u}
+
+    raises(TypeError, lambda: t - x)
+    raises(TypeError, lambda: x - t)
+    raises(TypeError, lambda: t - u)
+    raises(TypeError, lambda: u - t)
+
+    Fuv, u,v = field("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Fuv)
+
+    assert dict(-u + x) == dict(x - u) == {(1, 0, 0): 1, (0, 0, 0): -u}
+
+    Rxyz, x,y,z = ring("x,y,z", EX)
+
+    assert dict(-EX(pi) + x*y*z) == dict(x*y*z - EX(pi)) == {(1, 1, 1): EX(1), (0, 0, 0): -EX(pi)}
+
+def test_PolyElement___mul__():
+    Rt, t = ring("t", ZZ)
+    Ruv, u,v = ring("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Ruv)
+
+    assert dict(u*x) == dict(x*u) == {(1, 0, 0): u}
+
+    assert dict(2*u*x + z) == dict(x*2*u + z) == {(1, 0, 0): 2*u, (0, 0, 1): 1}
+    assert dict(u*2*x + z) == dict(2*x*u + z) == {(1, 0, 0): 2*u, (0, 0, 1): 1}
+    assert dict(2*u*x + z) == dict(x*2*u + z) == {(1, 0, 0): 2*u, (0, 0, 1): 1}
+    assert dict(u*x*2 + z) == dict(x*u*2 + z) == {(1, 0, 0): 2*u, (0, 0, 1): 1}
+
+    assert dict(2*u*x*y + z) == dict(x*y*2*u + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+    assert dict(u*2*x*y + z) == dict(2*x*y*u + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+    assert dict(2*u*x*y + z) == dict(x*y*2*u + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+    assert dict(u*x*y*2 + z) == dict(x*y*u*2 + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+
+    assert dict(2*u*y*x + z) == dict(y*x*2*u + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+    assert dict(u*2*y*x + z) == dict(2*y*x*u + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+    assert dict(2*u*y*x + z) == dict(y*x*2*u + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+    assert dict(u*y*x*2 + z) == dict(y*x*u*2 + z) == {(1, 1, 0): 2*u, (0, 0, 1): 1}
+
+    assert dict(3*u*(x + y) + z) == dict((x + y)*3*u + z) == {(1, 0, 0): 3*u, (0, 1, 0): 3*u, (0, 0, 1): 1}
+
+    raises(TypeError, lambda: t*x + z)
+    raises(TypeError, lambda: x*t + z)
+    raises(TypeError, lambda: t*u + z)
+    raises(TypeError, lambda: u*t + z)
+
+    Fuv, u,v = field("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Fuv)
+
+    assert dict(u*x) == dict(x*u) == {(1, 0, 0): u}
+
+    Rxyz, x,y,z = ring("x,y,z", EX)
+
+    assert dict(EX(pi)*x*y*z) == dict(x*y*z*EX(pi)) == {(1, 1, 1): EX(pi)}
+
+def test_PolyElement___truediv__():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert (2*x**2 - 4)/2 == x**2 - 2
+    assert (2*x**2 - 3)/2 == x**2
+
+    assert (x**2 - 1).quo(x) == x
+    assert (x**2 - x).quo(x) == x - 1
+
+    raises(ExactQuotientFailed, lambda: (x**2 - 1)/x)
+    assert (x**2 - x)/x == x - 1
+    raises(ExactQuotientFailed, lambda: (x**2 - 1)/(2*x))
+
+    assert (x**2 - 1).quo(2*x) == 0
+    assert (x**2 - x)/(x - 1) == (x**2 - x).quo(x - 1) == x
+
+
+    R, x,y,z = ring("x,y,z", ZZ)
+    assert len((x**2/3 + y**3/4 + z**4/5).terms()) == 0
+
+    R, x,y,z = ring("x,y,z", QQ)
+    assert len((x**2/3 + y**3/4 + z**4/5).terms()) == 3
+
+    Rt, t = ring("t", ZZ)
+    Ruv, u,v = ring("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Ruv)
+
+    assert dict((u**2*x + u)/u) == {(1, 0, 0): u, (0, 0, 0): 1}
+    raises(ExactQuotientFailed, lambda: u/(u**2*x + u))
+
+    raises(TypeError, lambda: t/x)
+    raises(TypeError, lambda: x/t)
+    raises(TypeError, lambda: t/u)
+    raises(TypeError, lambda: u/t)
+
+    R, x = ring("x", ZZ)
+    f, g = x**2 + 2*x + 3, R(0)
+
+    raises(ZeroDivisionError, lambda: f.div(g))
+    raises(ZeroDivisionError, lambda: divmod(f, g))
+    raises(ZeroDivisionError, lambda: f.rem(g))
+    raises(ZeroDivisionError, lambda: f % g)
+    raises(ZeroDivisionError, lambda: f.quo(g))
+    raises(ZeroDivisionError, lambda: f / g)
+    raises(ZeroDivisionError, lambda: f.exquo(g))
+
+    R, x, y = ring("x,y", ZZ)
+    f, g = x*y + 2*x + 3, R(0)
+
+    raises(ZeroDivisionError, lambda: f.div(g))
+    raises(ZeroDivisionError, lambda: divmod(f, g))
+    raises(ZeroDivisionError, lambda: f.rem(g))
+    raises(ZeroDivisionError, lambda: f % g)
+    raises(ZeroDivisionError, lambda: f.quo(g))
+    raises(ZeroDivisionError, lambda: f / g)
+    raises(ZeroDivisionError, lambda: f.exquo(g))
+
+    R, x = ring("x", ZZ)
+
+    f, g = x**2 + 1, 2*x - 4
+    q, r = R(0), x**2 + 1
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = 3*x**3 + x**2 + x + 5, 5*x**2 - 3*x + 1
+    q, r = R(0), f
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = 5*x**4 + 4*x**3 + 3*x**2 + 2*x + 1, x**2 + 2*x + 3
+    q, r = 5*x**2 - 6*x, 20*x + 1
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = 5*x**5 + 4*x**4 + 3*x**3 + 2*x**2 + x, x**4 + 2*x**3 + 9
+    q, r = 5*x - 6, 15*x**3 + 2*x**2 - 44*x + 54
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    R, x = ring("x", QQ)
+
+    f, g = x**2 + 1, 2*x - 4
+    q, r = x/2 + 1, R(5)
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = 3*x**3 + x**2 + x + 5, 5*x**2 - 3*x + 1
+    q, r = QQ(3, 5)*x + QQ(14, 25), QQ(52, 25)*x + QQ(111, 25)
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    R, x,y = ring("x,y", ZZ)
+
+    f, g = x**2 - y**2, x - y
+    q, r = x + y, R(0)
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    assert f.exquo(g) == f / g == q
+
+    f, g = x**2 + y**2, x - y
+    q, r = x + y, 2*y**2
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = x**2 + y**2, -x + y
+    q, r = -x - y, 2*y**2
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = x**2 + y**2, 2*x - 2*y
+    q, r = R(0), f
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    R, x,y = ring("x,y", QQ)
+
+    f, g = x**2 - y**2, x - y
+    q, r = x + y, R(0)
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    assert f.exquo(g) == f / g == q
+
+    f, g = x**2 + y**2, x - y
+    q, r = x + y, 2*y**2
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = x**2 + y**2, -x + y
+    q, r = -x - y, 2*y**2
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+    f, g = x**2 + y**2, 2*x - 2*y
+    q, r = x/2 + y/2, 2*y**2
+
+    assert f.div(g) == divmod(f, g) == (q, r)
+    assert f.rem(g) == f % g == r
+    assert f.quo(g) == q
+    raises(ExactQuotientFailed, lambda: f / g)
+    raises(ExactQuotientFailed, lambda: f.exquo(g))
+
+def test_PolyElement___pow__():
+    R, x = ring("x", ZZ, grlex)
+    f = 2*x + 3
+
+    assert f**0 == 1
+    assert f**1 == f
+    raises(ValueError, lambda: f**(-1))
+
+    assert f**2 == f._pow_generic(2) == f._pow_multinomial(2) == 4*x**2 + 12*x + 9
+    assert f**3 == f._pow_generic(3) == f._pow_multinomial(3) == 8*x**3 + 36*x**2 + 54*x + 27
+    assert f**4 == f._pow_generic(4) == f._pow_multinomial(4) == 16*x**4 + 96*x**3 + 216*x**2 + 216*x + 81
+    assert f**5 == f._pow_generic(5) == f._pow_multinomial(5) == 32*x**5 + 240*x**4 + 720*x**3 + 1080*x**2 + 810*x + 243
+
+    R, x,y,z = ring("x,y,z", ZZ, grlex)
+    f = x**3*y - 2*x*y**2 - 3*z + 1
+    g = x**6*y**2 - 4*x**4*y**3 - 6*x**3*y*z + 2*x**3*y + 4*x**2*y**4 + 12*x*y**2*z - 4*x*y**2 + 9*z**2 - 6*z + 1
+
+    assert f**2 == f._pow_generic(2) == f._pow_multinomial(2) == g
+
+    R, t = ring("t", ZZ)
+    f = -11200*t**4 - 2604*t**2 + 49
+    g = 15735193600000000*t**16 + 14633730048000000*t**14 + 4828147466240000*t**12 \
+      + 598976863027200*t**10 + 3130812416256*t**8 - 2620523775744*t**6 \
+      + 92413760096*t**4 - 1225431984*t**2 + 5764801
+
+    assert f**4 == f._pow_generic(4) == f._pow_multinomial(4) == g
+
+def test_PolyElement_div():
+    R, x = ring("x", ZZ, grlex)
+
+    f = x**3 - 12*x**2 - 42
+    g = x - 3
+
+    q = x**2 - 9*x - 27
+    r = -123
+
+    assert f.div([g]) == ([q], r)
+
+    R, x = ring("x", ZZ, grlex)
+    f = x**2 + 2*x + 2
+    assert f.div([R(1)]) == ([f], 0)
+
+    R, x = ring("x", QQ, grlex)
+    f = x**2 + 2*x + 2
+    assert f.div([R(2)]) == ([QQ(1,2)*x**2 + x + 1], 0)
+
+    R, x,y = ring("x,y", ZZ, grlex)
+    f = 4*x**2*y - 2*x*y + 4*x - 2*y + 8
+
+    assert f.div([R(2)]) == ([2*x**2*y - x*y + 2*x - y + 4], 0)
+    assert f.div([2*y]) == ([2*x**2 - x - 1], 4*x + 8)
+
+    f = x - 1
+    g = y - 1
+
+    assert f.div([g]) == ([0], f)
+
+    f = x*y**2 + 1
+    G = [x*y + 1, y + 1]
+
+    Q = [y, -1]
+    r = 2
+
+    assert f.div(G) == (Q, r)
+
+    f = x**2*y + x*y**2 + y**2
+    G = [x*y - 1, y**2 - 1]
+
+    Q = [x + y, 1]
+    r = x + y + 1
+
+    assert f.div(G) == (Q, r)
+
+    G = [y**2 - 1, x*y - 1]
+
+    Q = [x + 1, x]
+    r = 2*x + 1
+
+    assert f.div(G) == (Q, r)
+
+    R, = ring("", ZZ)
+    assert R(3).div(R(2)) == (0, 3)
+
+    R, = ring("", QQ)
+    assert R(3).div(R(2)) == (QQ(3, 2), 0)
+
+def test_PolyElement_rem():
+    R, x = ring("x", ZZ, grlex)
+
+    f = x**3 - 12*x**2 - 42
+    g = x - 3
+    r = -123
+
+    assert f.rem([g]) == f.div([g])[1] == r
+
+    R, x,y = ring("x,y", ZZ, grlex)
+
+    f = 4*x**2*y - 2*x*y + 4*x - 2*y + 8
+
+    assert f.rem([R(2)]) == f.div([R(2)])[1] == 0
+    assert f.rem([2*y]) == f.div([2*y])[1] == 4*x + 8
+
+    f = x - 1
+    g = y - 1
+
+    assert f.rem([g]) == f.div([g])[1] == f
+
+    f = x*y**2 + 1
+    G = [x*y + 1, y + 1]
+    r = 2
+
+    assert f.rem(G) == f.div(G)[1] == r
+
+    f = x**2*y + x*y**2 + y**2
+    G = [x*y - 1, y**2 - 1]
+    r = x + y + 1
+
+    assert f.rem(G) == f.div(G)[1] == r
+
+    G = [y**2 - 1, x*y - 1]
+    r = 2*x + 1
+
+    assert f.rem(G) == f.div(G)[1] == r
+
+def test_PolyElement_deflate():
+    R, x = ring("x", ZZ)
+
+    assert (2*x**2).deflate(x**4 + 4*x**2 + 1) == ((2,), [2*x, x**2 + 4*x + 1])
+
+    R, x,y = ring("x,y", ZZ)
+
+    assert R(0).deflate(R(0)) == ((1, 1), [0, 0])
+    assert R(1).deflate(R(0)) == ((1, 1), [1, 0])
+    assert R(1).deflate(R(2)) == ((1, 1), [1, 2])
+    assert R(1).deflate(2*y) == ((1, 1), [1, 2*y])
+    assert (2*y).deflate(2*y) == ((1, 1), [2*y, 2*y])
+    assert R(2).deflate(2*y**2) == ((1, 2), [2, 2*y])
+    assert (2*y**2).deflate(2*y**2) == ((1, 2), [2*y, 2*y])
+
+    f = x**4*y**2 + x**2*y + 1
+    g = x**2*y**3 + x**2*y + 1
+
+    assert f.deflate(g) == ((2, 1), [x**2*y**2 + x*y + 1, x*y**3 + x*y + 1])
+
+def test_PolyElement_clear_denoms():
+    R, x,y = ring("x,y", QQ)
+
+    assert R(1).clear_denoms() == (ZZ(1), 1)
+    assert R(7).clear_denoms() == (ZZ(1), 7)
+
+    assert R(QQ(7,3)).clear_denoms() == (3, 7)
+    assert R(QQ(7,3)).clear_denoms() == (3, 7)
+
+    assert (3*x**2 + x).clear_denoms() == (1, 3*x**2 + x)
+    assert (x**2 + QQ(1,2)*x).clear_denoms() == (2, 2*x**2 + x)
+
+    rQQ, x,t = ring("x,t", QQ, lex)
+    rZZ, X,T = ring("x,t", ZZ, lex)
+
+    F = [x - QQ(17824537287975195925064602467992950991718052713078834557692023531499318507213727406844943097,413954288007559433755329699713866804710749652268151059918115348815925474842910720000)*t**7
+           - QQ(4882321164854282623427463828745855894130208215961904469205260756604820743234704900167747753,12936071500236232304854053116058337647210926633379720622441104650497671088840960000)*t**6
+           - QQ(36398103304520066098365558157422127347455927422509913596393052633155821154626830576085097433,25872143000472464609708106232116675294421853266759441244882209300995342177681920000)*t**5
+           - QQ(168108082231614049052707339295479262031324376786405372698857619250210703675982492356828810819,58212321751063045371843239022262519412449169850208742800984970927239519899784320000)*t**4
+           - QQ(5694176899498574510667890423110567593477487855183144378347226247962949388653159751849449037,1617008937529529038106756639507292205901365829172465077805138081312208886105120000)*t**3
+           - QQ(154482622347268833757819824809033388503591365487934245386958884099214649755244381307907779,60637835157357338929003373981523457721301218593967440417692678049207833228942000)*t**2
+           - QQ(2452813096069528207645703151222478123259511586701148682951852876484544822947007791153163,2425513406294293557160134959260938308852048743758697616707707121968313329157680)*t
+           - QQ(34305265428126440542854669008203683099323146152358231964773310260498715579162112959703,202126117191191129763344579938411525737670728646558134725642260164026110763140),
+         t**8 + QQ(693749860237914515552,67859264524169150569)*t**7
+              + QQ(27761407182086143225024,610733380717522355121)*t**6
+              + QQ(7785127652157884044288,67859264524169150569)*t**5
+              + QQ(36567075214771261409792,203577793572507451707)*t**4
+              + QQ(36336335165196147384320,203577793572507451707)*t**3
+              + QQ(7452455676042754048000,67859264524169150569)*t**2
+              + QQ(2593331082514399232000,67859264524169150569)*t
+              + QQ(390399197427343360000,67859264524169150569)]
+
+    G = [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]
+
+    assert [ f.clear_denoms()[1].set_ring(rZZ) for f in F ] == G
+
+def test_PolyElement_cofactors():
+    R, x, y = ring("x,y", ZZ)
+
+    f, g = R(0), R(0)
+    assert f.cofactors(g) == (0, 0, 0)
+
+    f, g = R(2), R(0)
+    assert f.cofactors(g) == (2, 1, 0)
+
+    f, g = R(-2), R(0)
+    assert f.cofactors(g) == (2, -1, 0)
+
+    f, g = R(0), R(-2)
+    assert f.cofactors(g) == (2, 0, -1)
+
+    f, g = R(0), 2*x + 4
+    assert f.cofactors(g) == (2*x + 4, 0, 1)
+
+    f, g = 2*x + 4, R(0)
+    assert f.cofactors(g) == (2*x + 4, 1, 0)
+
+    f, g = R(2), R(2)
+    assert f.cofactors(g) == (2, 1, 1)
+
+    f, g = R(-2), R(2)
+    assert f.cofactors(g) == (2, -1, 1)
+
+    f, g = R(2), R(-2)
+    assert f.cofactors(g) == (2, 1, -1)
+
+    f, g = R(-2), R(-2)
+    assert f.cofactors(g) == (2, -1, -1)
+
+    f, g = x**2 + 2*x + 1, R(1)
+    assert f.cofactors(g) == (1, x**2 + 2*x + 1, 1)
+
+    f, g = x**2 + 2*x + 1, R(2)
+    assert f.cofactors(g) == (1, x**2 + 2*x + 1, 2)
+
+    f, g = 2*x**2 + 4*x + 2, R(2)
+    assert f.cofactors(g) == (2, x**2 + 2*x + 1, 1)
+
+    f, g = R(2), 2*x**2 + 4*x + 2
+    assert f.cofactors(g) == (2, 1, x**2 + 2*x + 1)
+
+    f, g = 2*x**2 + 4*x + 2, x + 1
+    assert f.cofactors(g) == (x + 1, 2*x + 2, 1)
+
+    f, g = x + 1, 2*x**2 + 4*x + 2
+    assert f.cofactors(g) == (x + 1, 1, 2*x + 2)
+
+    R, x, y, z, t = ring("x,y,z,t", ZZ)
+
+    f, g = t**2 + 2*t + 1, 2*t + 2
+    assert f.cofactors(g) == (t + 1, t + 1, 2)
+
+    f, g = z**2*t**2 + 2*z**2*t + z**2 + z*t + z, t**2 + 2*t + 1
+    h, cff, cfg = t + 1, z**2*t + z**2 + z, t + 1
+
+    assert f.cofactors(g) == (h, cff, cfg)
+    assert g.cofactors(f) == (h, cfg, cff)
+
+    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 f.cofactors(g) == (h, g, QQ(1,2))
+    assert g.cofactors(f) == (h, QQ(1,2), g)
+
+    R, x, y = ring("x,y", RR)
+
+    f = 2.1*x*y**2 - 2.1*x*y + 2.1*x
+    g = 2.1*x**3
+    h = 1.0*x
+
+    assert f.cofactors(g) == (h, f/h, g/h)
+    assert g.cofactors(f) == (h, g/h, f/h)
+
+def test_PolyElement_gcd():
+    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)
+
+    assert f.gcd(g) == x + 1
+
+def test_PolyElement_cancel():
+    R, x, y = ring("x,y", ZZ)
+
+    f = 2*x**3 + 4*x**2 + 2*x
+    g = 3*x**2 + 3*x
+    F = 2*x + 2
+    G = 3
+
+    assert f.cancel(g) == (F, G)
+
+    assert (-f).cancel(g) == (-F, G)
+    assert f.cancel(-g) == (-F, G)
+
+    R, x, y = ring("x,y", QQ)
+
+    f = QQ(1,2)*x**3 + x**2 + QQ(1,2)*x
+    g = QQ(1,3)*x**2 + QQ(1,3)*x
+    F = 3*x + 3
+    G = 2
+
+    assert f.cancel(g) == (F, G)
+
+    assert (-f).cancel(g) == (-F, G)
+    assert f.cancel(-g) == (-F, G)
+
+    Fx, x = field("x", ZZ)
+    Rt, t = ring("t", Fx)
+
+    f = (-x**2 - 4)/4*t
+    g = t**2 + (x**2 + 2)/2
+
+    assert f.cancel(g) == ((-x**2 - 4)*t, 4*t**2 + 2*x**2 + 4)
+
+def test_PolyElement_max_norm():
+    R, x, y = ring("x,y", ZZ)
+
+    assert R(0).max_norm() == 0
+    assert R(1).max_norm() == 1
+
+    assert (x**3 + 4*x**2 + 2*x + 3).max_norm() == 4
+
+def test_PolyElement_l1_norm():
+    R, x, y = ring("x,y", ZZ)
+
+    assert R(0).l1_norm() == 0
+    assert R(1).l1_norm() == 1
+
+    assert (x**3 + 4*x**2 + 2*x + 3).l1_norm() == 10
+
+def test_PolyElement_diff():
+    R, X = xring("x:11", QQ)
+
+    f = QQ(288,5)*X[0]**8*X[1]**6*X[4]**3*X[10]**2 + 8*X[0]**2*X[2]**3*X[4]**3 +2*X[0]**2 - 2*X[1]**2
+
+    assert f.diff(X[0]) == QQ(2304,5)*X[0]**7*X[1]**6*X[4]**3*X[10]**2 + 16*X[0]*X[2]**3*X[4]**3 + 4*X[0]
+    assert f.diff(X[4]) == QQ(864,5)*X[0]**8*X[1]**6*X[4]**2*X[10]**2 + 24*X[0]**2*X[2]**3*X[4]**2
+    assert f.diff(X[10]) == QQ(576,5)*X[0]**8*X[1]**6*X[4]**3*X[10]
+
+def test_PolyElement___call__():
+    R, x = ring("x", ZZ)
+    f = 3*x + 1
+
+    assert f(0) == 1
+    assert f(1) == 4
+
+    raises(ValueError, lambda: f())
+    raises(ValueError, lambda: f(0, 1))
+
+    raises(CoercionFailed, lambda: f(QQ(1,7)))
+
+    R, x,y = ring("x,y", ZZ)
+    f = 3*x + y**2 + 1
+
+    assert f(0, 0) == 1
+    assert f(1, 7) == 53
+
+    Ry = R.drop(x)
+
+    assert f(0) == Ry.y**2 + 1
+    assert f(1) == Ry.y**2 + 4
+
+    raises(ValueError, lambda: f())
+    raises(ValueError, lambda: f(0, 1, 2))
+
+    raises(CoercionFailed, lambda: f(1, QQ(1,7)))
+    raises(CoercionFailed, lambda: f(QQ(1,7), 1))
+    raises(CoercionFailed, lambda: f(QQ(1,7), QQ(1,7)))
+
+def test_PolyElement_evaluate():
+    R, x = ring("x", ZZ)
+    f = x**3 + 4*x**2 + 2*x + 3
+
+    r = f.evaluate(x, 0)
+    assert r == 3 and not isinstance(r, PolyElement)
+
+    raises(CoercionFailed, lambda: f.evaluate(x, QQ(1,7)))
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    f = (x*y)**3 + 4*(x*y)**2 + 2*x*y + 3
+
+    r = f.evaluate(x, 0)
+    assert r == 3 and R.drop(x).is_element(r)
+    r = f.evaluate([(x, 0), (y, 0)])
+    assert r == 3 and R.drop(x, y).is_element(r)
+    r = f.evaluate(y, 0)
+    assert r == 3 and R.drop(y).is_element(r)
+    r = f.evaluate([(y, 0), (x, 0)])
+    assert r == 3 and R.drop(y, x).is_element(r)
+
+    r = f.evaluate([(x, 0), (y, 0), (z, 0)])
+    assert r == 3 and not isinstance(r, PolyElement)
+
+    raises(CoercionFailed, lambda: f.evaluate([(x, 1), (y, QQ(1,7))]))
+    raises(CoercionFailed, lambda: f.evaluate([(x, QQ(1,7)), (y, 1)]))
+    raises(CoercionFailed, lambda: f.evaluate([(x, QQ(1,7)), (y, QQ(1,7))]))
+
+def test_PolyElement_subs():
+    R, x = ring("x", ZZ)
+    f = x**3 + 4*x**2 + 2*x + 3
+
+    r = f.subs(x, 0)
+    assert r == 3 and R.is_element(r)
+
+    raises(CoercionFailed, lambda: f.subs(x, QQ(1,7)))
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    f = x**3 + 4*x**2 + 2*x + 3
+
+    r = f.subs(x, 0)
+    assert r == 3 and R.is_element(r)
+    r = f.subs([(x, 0), (y, 0)])
+    assert r == 3 and R.is_element(r)
+
+    raises(CoercionFailed, lambda: f.subs([(x, 1), (y, QQ(1,7))]))
+    raises(CoercionFailed, lambda: f.subs([(x, QQ(1,7)), (y, 1)]))
+    raises(CoercionFailed, lambda: f.subs([(x, QQ(1,7)), (y, QQ(1,7))]))
+
+def test_PolyElement_symmetrize():
+    R, x, y = ring("x,y", ZZ)
+
+    # Homogeneous, symmetric
+    f = x**2 + y**2
+    sym, rem, m = f.symmetrize()
+    assert rem == 0
+    assert sym.compose(m) + rem == f
+
+    # Homogeneous, asymmetric
+    f = x**2 - y**2
+    sym, rem, m = f.symmetrize()
+    assert rem != 0
+    assert sym.compose(m) + rem == f
+
+    # Inhomogeneous, symmetric
+    f = x*y + 7
+    sym, rem, m = f.symmetrize()
+    assert rem == 0
+    assert sym.compose(m) + rem == f
+
+    # Inhomogeneous, asymmetric
+    f = y + 7
+    sym, rem, m = f.symmetrize()
+    assert rem != 0
+    assert sym.compose(m) + rem == f
+
+    # Constant
+    f = R.from_expr(3)
+    sym, rem, m = f.symmetrize()
+    assert rem == 0
+    assert sym.compose(m) + rem == f
+
+    # Constant constructed from sring
+    R, f = sring(3)
+    sym, rem, m = f.symmetrize()
+    assert rem == 0
+    assert sym.compose(m) + rem == f
+
+def test_PolyElement_compose():
+    R, x = ring("x", ZZ)
+    f = x**3 + 4*x**2 + 2*x + 3
+
+    r = f.compose(x, 0)
+    assert r == 3 and R.is_element(r)
+
+    assert f.compose(x, x) == f
+    assert f.compose(x, x**2) == x**6 + 4*x**4 + 2*x**2 + 3
+
+    raises(CoercionFailed, lambda: f.compose(x, QQ(1,7)))
+
+    R, x, y, z = ring("x,y,z", ZZ)
+    f = x**3 + 4*x**2 + 2*x + 3
+
+    r = f.compose(x, 0)
+    assert r == 3 and R.is_element(r)
+    r = f.compose([(x, 0), (y, 0)])
+    assert r == 3 and R.is_element(r)
+
+    r = (x**3 + 4*x**2 + 2*x*y*z + 3).compose(x, y*z**2 - 1)
+    q = (y*z**2 - 1)**3 + 4*(y*z**2 - 1)**2 + 2*(y*z**2 - 1)*y*z + 3
+    assert r == q and R.is_element(r)
+
+def test_PolyElement_is_():
+    R, x,y,z = ring("x,y,z", QQ)
+
+    assert (x - x).is_generator == False
+    assert (x - x).is_ground == True
+    assert (x - x).is_monomial == True
+    assert (x - x).is_term == True
+
+    assert (x - x + 1).is_generator == False
+    assert (x - x + 1).is_ground == True
+    assert (x - x + 1).is_monomial == True
+    assert (x - x + 1).is_term == True
+
+    assert x.is_generator == True
+    assert x.is_ground == False
+    assert x.is_monomial == True
+    assert x.is_term == True
+
+    assert (x*y).is_generator == False
+    assert (x*y).is_ground == False
+    assert (x*y).is_monomial == True
+    assert (x*y).is_term == True
+
+    assert (3*x).is_generator == False
+    assert (3*x).is_ground == False
+    assert (3*x).is_monomial == False
+    assert (3*x).is_term == True
+
+    assert (3*x + 1).is_generator == False
+    assert (3*x + 1).is_ground == False
+    assert (3*x + 1).is_monomial == False
+    assert (3*x + 1).is_term == False
+
+    assert R(0).is_zero is True
+    assert R(1).is_zero is False
+
+    assert R(0).is_one is False
+    assert R(1).is_one is True
+
+    assert (x - 1).is_monic is True
+    assert (2*x - 1).is_monic is False
+
+    assert (3*x + 2).is_primitive is True
+    assert (4*x + 2).is_primitive is False
+
+    assert (x + y + z + 1).is_linear is True
+    assert (x*y*z + 1).is_linear is False
+
+    assert (x*y + z + 1).is_quadratic is True
+    assert (x*y*z + 1).is_quadratic is False
+
+    assert (x - 1).is_squarefree is True
+    assert ((x - 1)**2).is_squarefree is False
+
+    assert (x**2 + x + 1).is_irreducible is True
+    assert (x**2 + 2*x + 1).is_irreducible is False
+
+    _, t = ring("t", FF(11))
+
+    assert (7*t + 3).is_irreducible is True
+    assert (7*t**2 + 3*t + 1).is_irreducible is False
+
+    _, u = ring("u", ZZ)
+    f = u**16 + u**14 - u**10 - u**8 - u**6 + u**2
+
+    assert f.is_cyclotomic is False
+    assert (f + 1).is_cyclotomic is True
+
+    raises(MultivariatePolynomialError, lambda: x.is_cyclotomic)
+
+    R, = ring("", ZZ)
+    assert R(4).is_squarefree is True
+    assert R(6).is_irreducible is True
+
+def test_PolyElement_drop():
+    R, x,y,z = ring("x,y,z", ZZ)
+
+    assert R(1).drop(0).ring == PolyRing("y,z", ZZ, lex)
+    assert R(1).drop(0).drop(0).ring == PolyRing("z", ZZ, lex)
+    assert R.is_element(R(1).drop(0).drop(0).drop(0)) is False
+
+    raises(ValueError, lambda: z.drop(0).drop(0).drop(0))
+    raises(ValueError, lambda: x.drop(0))
+
+def test_PolyElement_coeff_wrt():
+    R, x, y, z = ring("x, y, z", ZZ)
+
+    p = 4*x**3 + 5*y**2 + 6*y**2*z + 7
+    assert p.coeff_wrt(1, 2) == 6*z + 5 # using generator index
+    assert p.coeff_wrt(x, 3) == 4 # using generator
+
+    p = 2*x**4 + 3*x*y**2*z + 10*y**2 + 10*x*z**2
+    assert p.coeff_wrt(x, 1) == 3*y**2*z + 10*z**2
+    assert p.coeff_wrt(y, 2) == 3*x*z + 10
+
+    p = 4*x**2 + 2*x*y + 5
+    assert p.coeff_wrt(z, 1) == R(0)
+    assert p.coeff_wrt(y, 2) == R(0)
+
+def test_PolyElement_prem():
+    R, x, y = ring("x, y", ZZ)
+
+    f, g = x**2 + x*y, 2*x + 2
+    assert f.prem(g) == -4*y + 4 # first generator is chosen by default if it is not given
+
+    f, g = x**2 + 1, 2*x - 4
+    assert f.prem(g) == f.prem(g, x) == 20
+    assert f.prem(g, 1) == R(0)
+
+    f, g = x*y + 2*x + 1, x + y
+    assert f.prem(g) == -y**2 - 2*y + 1
+    assert f.prem(g, 1) == f.prem(g, y) == -x**2 + 2*x + 1
+
+    raises(ZeroDivisionError, lambda: f.prem(R(0)))
+
+def test_PolyElement_pdiv():
+    R, x, y = ring("x,y", ZZ)
+
+    f, g = x**4 + 5*x**3 + 7*x**2, 2*x**2 + 3
+    assert f.pdiv(g) == f.pdiv(g, x) == (4*x**2 + 20*x + 22, -60*x - 66)
+
+    f, g = x**2 - y**2, x - y
+    assert f.pdiv(g) == f.pdiv(g, 0) == (x + y, 0)
+
+    f, g = x*y + 2*x + 1, x + y
+    assert f.pdiv(g) == (y + 2, -y**2 - 2*y + 1)
+    assert f.pdiv(g, y) == f.pdiv(g, 1) == (x + 1, -x**2 + 2*x + 1)
+
+    assert R(0).pdiv(g) == (0, 0)
+    raises(ZeroDivisionError, lambda: f.prem(R(0)))
+
+def test_PolyElement_pquo():
+    R, x, y = ring("x, y", ZZ)
+
+    f, g = x**4 - 4*x**2*y + 4*y**2, x**2 - 2*y
+    assert f.pquo(g) == f.pquo(g, x) == x**2 - 2*y
+    assert f.pquo(g, y) == 4*x**2 - 8*y + 4
+
+    f, g = x**4 - y**4, x**2 - y**2
+    assert f.pquo(g) == f.pquo(g, 0) == x**2 + y**2
+
+def test_PolyElement_pexquo():
+    R, x, y = ring("x, y", ZZ)
+
+    f, g = x**2 - y**2, x - y
+    assert f.pexquo(g) == f.pexquo(g, x) == x + y
+    assert f.pexquo(g, y) == f.pexquo(g, 1) == x + y + 1
+
+    f, g = x**2 + 3*x + 6, x + 2
+    raises(ExactQuotientFailed, lambda: f.pexquo(g))
+
+def test_PolyElement_gcdex():
+    _, x = ring("x", QQ)
+
+    f, g = 2*x, x**2 - 16
+    s, t, h = x/32, -QQ(1, 16), 1
+
+    assert f.half_gcdex(g) == (s, h)
+    assert f.gcdex(g) == (s, t, h)
+
+def test_PolyElement_subresultants():
+    R, x, y = ring("x, y", ZZ)
+
+    f, g = x**2*y + x*y, x + y # degree(f, x) > degree(g, x)
+    h = y**3 - y**2
+    assert f.subresultants(g) == [f, g, h] # first generator is chosen default
+
+    # generator index or generator is given
+    assert f.subresultants(g, 0) ==  f.subresultants(g, x) == [f, g, h]
+
+    assert f.subresultants(g, y) == [x**2*y + x*y, x + y, x**3 + x**2]
+
+    f, g = 2*x - y, x**2 + 2*y + x # degree(f, x) < degree(g, x)
+    assert f.subresultants(g) == [x**2 + x + 2*y, 2*x - y, y**2 + 10*y]
+
+    f, g = R(0), y**3 - y**2 # f = 0
+    assert f.subresultants(g) == [y**3 - y**2, 1]
+
+    f, g = x**2*y + x*y, R(0) # g = 0
+    assert f.subresultants(g) == [x**2*y + x*y, 1]
+
+    f, g = R(0), R(0) # f = 0 and g = 0
+    assert f.subresultants(g) == [0, 0]
+
+    f, g = x**2 + x, x**2 + x # f and g are same polynomial
+    assert f.subresultants(g) == [x**2 + x, x**2 + x]
+
+def test_PolyElement_resultant():
+    _, x = ring("x", ZZ)
+    f, g, h = x**2 - 2*x + 1, x**2 - 1, 0
+
+    assert f.resultant(g) == h
+
+def test_PolyElement_discriminant():
+    _, x = ring("x", ZZ)
+    f, g = x**3 + 3*x**2 + 9*x - 13, -11664
+
+    assert f.discriminant() == g
+
+    F, a, b, c = ring("a,b,c", ZZ)
+    _, x = ring("x", F)
+
+    f, g = a*x**2 + b*x + c, b**2 - 4*a*c
+
+    assert f.discriminant() == g
+
+def test_PolyElement_decompose():
+    _, x = ring("x", ZZ)
+
+    f = x**12 + 20*x**10 + 150*x**8 + 500*x**6 + 625*x**4 - 2*x**3 - 10*x + 9
+    g = x**4 - 2*x + 9
+    h = x**3 + 5*x
+
+    assert g.compose(x, h) == f
+    assert f.decompose() == [g, h]
+
+def test_PolyElement_shift():
+    _, x = ring("x", ZZ)
+    assert (x**2 - 2*x + 1).shift(2) == x**2 + 2*x + 1
+    assert (x**2 - 2*x + 1).shift_list([2]) == x**2 + 2*x + 1
+
+    R, x, y = ring("x, y", ZZ)
+    assert (x*y).shift_list([1, 2]) == (x+1)*(y+2)
+
+    raises(MultivariatePolynomialError, lambda: (x*y).shift(1))
+
+def test_PolyElement_sturm():
+    F, t = field("t", ZZ)
+    _, x = ring("x", F)
+
+    f = 1024/(15625*t**8)*x**5 - 4096/(625*t**8)*x**4 + 32/(15625*t**4)*x**3 - 128/(625*t**4)*x**2 + F(1)/62500*x - F(1)/625
+
+    assert f.sturm() == [
+        x**3 - 100*x**2 + t**4/64*x - 25*t**4/16,
+        3*x**2 - 200*x + t**4/64,
+        (-t**4/96 + F(20000)/9)*x + 25*t**4/18,
+        (-9*t**12 - 11520000*t**8 - 3686400000000*t**4)/(576*t**8 - 245760000*t**4 + 26214400000000),
+    ]
+
+def test_PolyElement_gff_list():
+    _, x = ring("x", ZZ)
+
+    f = x**5 + 2*x**4 - x**3 - 2*x**2
+    assert f.gff_list() == [(x, 1), (x + 2, 4)]
+
+    f = x*(x - 1)**3*(x - 2)**2*(x - 4)**2*(x - 5)
+    assert f.gff_list() == [(x**2 - 5*x + 4, 1), (x**2 - 5*x + 4, 2), (x, 3)]
+
+def test_PolyElement_norm():
+    k = QQ
+    K = QQ.algebraic_field(sqrt(2))
+    sqrt2 = K.unit
+    _, X, Y = ring("x,y", k)
+    _, x, y = ring("x,y", K)
+
+    assert (x*y + sqrt2).norm() == X**2*Y**2 - 2
+
+def test_PolyElement_sqf_norm():
+    R, x = ring("x", QQ.algebraic_field(sqrt(3)))
+    X = R.to_ground().x
+
+    assert (x**2 - 2).sqf_norm() == ([1], x**2 - 2*sqrt(3)*x + 1, X**4 - 10*X**2 + 1)
+
+    R, x = ring("x", QQ.algebraic_field(sqrt(2)))
+    X = R.to_ground().x
+
+    assert (x**2 - 3).sqf_norm() == ([1], x**2 - 2*sqrt(2)*x - 1, X**4 - 10*X**2 + 1)
+
+def test_PolyElement_sqf_list():
+    _, x = ring("x", ZZ)
+
+    f = x**5 - x**3 - x**2 + 1
+    g = x**3 + 2*x**2 + 2*x + 1
+    h = x - 1
+    p = x**4 + x**3 - x - 1
+
+    assert f.sqf_part() == p
+    assert f.sqf_list() == (1, [(g, 1), (h, 2)])
+
+def test_issue_18894():
+    items = [S(3)/16 + sqrt(3*sqrt(3) + 10)/8, S(1)/8 + 3*sqrt(3)/16, S(1)/8 + 3*sqrt(3)/16, -S(3)/16 + sqrt(3*sqrt(3) + 10)/8]
+    R, a = sring(items, extension=True)
+    assert R.domain == QQ.algebraic_field(sqrt(3)+sqrt(3*sqrt(3)+10))
+    assert R.gens == ()
+    result = []
+    for item in items:
+        result.append(R.domain.from_sympy(item))
+    assert a == result
+
+def test_PolyElement_factor_list():
+    _, x = ring("x", ZZ)
+
+    f = x**5 - x**3 - x**2 + 1
+
+    u = x + 1
+    v = x - 1
+    w = x**2 + x + 1
+
+    assert f.factor_list() == (1, [(u, 1), (v, 2), (w, 1)])
+
+
+def test_issue_21410():
+    R, x = ring('x', FF(2))
+    p = x**6 + x**5 + x**4 + x**3 + 1
+    assert p._pow_multinomial(4) == x**24 + x**20 + x**16 + x**12 + 1
+
+
+def test_zero_polynomial_primitive():
+
+    x = symbols('x')
+
+    R = ZZ[x]
+    zero_poly = R(0)
+    cont, prim = zero_poly.primitive()
+    assert cont == 0
+    assert prim == zero_poly
+    assert prim.is_primitive is False