Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/concrete/__init__.py

@@ -0,0 +1,8 @@
+from .products import product, Product
+from .summations import summation, Sum
+
+__all__ = [
+    'product', 'Product',
+
+    'summation', 'Sum',
+]

env-llmeval/lib/python3.10/site-packages/sympy/concrete/delta.py

@@ -0,0 +1,331 @@
+"""
+This module implements sums and products containing the Kronecker Delta function.
+
+References
+==========
+
+.. [1] https://mathworld.wolfram.com/KroneckerDelta.html
+
+"""
+from .products import product
+from .summations import Sum, summation
+from sympy.core import Add, Mul, S, Dummy
+from sympy.core.cache import cacheit
+from sympy.core.sorting import default_sort_key
+from sympy.functions import KroneckerDelta, Piecewise, piecewise_fold
+from sympy.polys.polytools import factor
+from sympy.sets.sets import Interval
+from sympy.solvers.solvers import solve
+
+
+@cacheit
+def _expand_delta(expr, index):
+    """
+    Expand the first Add containing a simple KroneckerDelta.
+    """
+    if not expr.is_Mul:
+        return expr
+    delta = None
+    func = Add
+    terms = [S.One]
+    for h in expr.args:
+        if delta is None and h.is_Add and _has_simple_delta(h, index):
+            delta = True
+            func = h.func
+            terms = [terms[0]*t for t in h.args]
+        else:
+            terms = [t*h for t in terms]
+    return func(*terms)
+
+
+@cacheit
+def _extract_delta(expr, index):
+    """
+    Extract a simple KroneckerDelta from the expression.
+
+    Explanation
+    ===========
+
+    Returns the tuple ``(delta, newexpr)`` where:
+
+      - ``delta`` is a simple KroneckerDelta expression if one was found,
+        or ``None`` if no simple KroneckerDelta expression was found.
+
+      - ``newexpr`` is a Mul containing the remaining terms; ``expr`` is
+        returned unchanged if no simple KroneckerDelta expression was found.
+
+    Examples
+    ========
+
+    >>> from sympy import KroneckerDelta
+    >>> from sympy.concrete.delta import _extract_delta
+    >>> from sympy.abc import x, y, i, j, k
+    >>> _extract_delta(4*x*y*KroneckerDelta(i, j), i)
+    (KroneckerDelta(i, j), 4*x*y)
+    >>> _extract_delta(4*x*y*KroneckerDelta(i, j), k)
+    (None, 4*x*y*KroneckerDelta(i, j))
+
+    See Also
+    ========
+
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    deltaproduct
+    deltasummation
+    """
+    if not _has_simple_delta(expr, index):
+        return (None, expr)
+    if isinstance(expr, KroneckerDelta):
+        return (expr, S.One)
+    if not expr.is_Mul:
+        raise ValueError("Incorrect expr")
+    delta = None
+    terms = []
+
+    for arg in expr.args:
+        if delta is None and _is_simple_delta(arg, index):
+            delta = arg
+        else:
+            terms.append(arg)
+    return (delta, expr.func(*terms))
+
+
+@cacheit
+def _has_simple_delta(expr, index):
+    """
+    Returns True if ``expr`` is an expression that contains a KroneckerDelta
+    that is simple in the index ``index``, meaning that this KroneckerDelta
+    is nonzero for a single value of the index ``index``.
+    """
+    if expr.has(KroneckerDelta):
+        if _is_simple_delta(expr, index):
+            return True
+        if expr.is_Add or expr.is_Mul:
+            for arg in expr.args:
+                if _has_simple_delta(arg, index):
+                    return True
+    return False
+
+
+@cacheit
+def _is_simple_delta(delta, index):
+    """
+    Returns True if ``delta`` is a KroneckerDelta and is nonzero for a single
+    value of the index ``index``.
+    """
+    if isinstance(delta, KroneckerDelta) and delta.has(index):
+        p = (delta.args[0] - delta.args[1]).as_poly(index)
+        if p:
+            return p.degree() == 1
+    return False
+
+
+@cacheit
+def _remove_multiple_delta(expr):
+    """
+    Evaluate products of KroneckerDelta's.
+    """
+    if expr.is_Add:
+        return expr.func(*list(map(_remove_multiple_delta, expr.args)))
+    if not expr.is_Mul:
+        return expr
+    eqs = []
+    newargs = []
+    for arg in expr.args:
+        if isinstance(arg, KroneckerDelta):
+            eqs.append(arg.args[0] - arg.args[1])
+        else:
+            newargs.append(arg)
+    if not eqs:
+        return expr
+    solns = solve(eqs, dict=True)
+    if len(solns) == 0:
+        return S.Zero
+    elif len(solns) == 1:
+        for key in solns[0].keys():
+            newargs.append(KroneckerDelta(key, solns[0][key]))
+        expr2 = expr.func(*newargs)
+        if expr != expr2:
+            return _remove_multiple_delta(expr2)
+    return expr
+
+
+@cacheit
+def _simplify_delta(expr):
+    """
+    Rewrite a KroneckerDelta's indices in its simplest form.
+    """
+    if isinstance(expr, KroneckerDelta):
+        try:
+            slns = solve(expr.args[0] - expr.args[1], dict=True)
+            if slns and len(slns) == 1:
+                return Mul(*[KroneckerDelta(*(key, value))
+                            for key, value in slns[0].items()])
+        except NotImplementedError:
+            pass
+    return expr
+
+
+@cacheit
+def deltaproduct(f, limit):
+    """
+    Handle products containing a KroneckerDelta.
+
+    See Also
+    ========
+
+    deltasummation
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    sympy.concrete.products.product
+    """
+    if ((limit[2] - limit[1]) < 0) == True:
+        return S.One
+
+    if not f.has(KroneckerDelta):
+        return product(f, limit)
+
+    if f.is_Add:
+        # Identify the term in the Add that has a simple KroneckerDelta
+        delta = None
+        terms = []
+        for arg in sorted(f.args, key=default_sort_key):
+            if delta is None and _has_simple_delta(arg, limit[0]):
+                delta = arg
+            else:
+                terms.append(arg)
+        newexpr = f.func(*terms)
+        k = Dummy("kprime", integer=True)
+        if isinstance(limit[1], int) and isinstance(limit[2], int):
+            result = deltaproduct(newexpr, limit) + sum([
+                deltaproduct(newexpr, (limit[0], limit[1], ik - 1)) *
+                delta.subs(limit[0], ik) *
+                deltaproduct(newexpr, (limit[0], ik + 1, limit[2])) for ik in range(int(limit[1]), int(limit[2] + 1))]
+            )
+        else:
+            result = deltaproduct(newexpr, limit) + deltasummation(
+                deltaproduct(newexpr, (limit[0], limit[1], k - 1)) *
+                delta.subs(limit[0], k) *
+                deltaproduct(newexpr, (limit[0], k + 1, limit[2])),
+                (k, limit[1], limit[2]),
+                no_piecewise=_has_simple_delta(newexpr, limit[0])
+            )
+        return _remove_multiple_delta(result)
+
+    delta, _ = _extract_delta(f, limit[0])
+
+    if not delta:
+        g = _expand_delta(f, limit[0])
+        if f != g:
+            try:
+                return factor(deltaproduct(g, limit))
+            except AssertionError:
+                return deltaproduct(g, limit)
+        return product(f, limit)
+
+    return _remove_multiple_delta(f.subs(limit[0], limit[1])*KroneckerDelta(limit[2], limit[1])) + \
+        S.One*_simplify_delta(KroneckerDelta(limit[2], limit[1] - 1))
+
+
+@cacheit
+def deltasummation(f, limit, no_piecewise=False):
+    """
+    Handle summations containing a KroneckerDelta.
+
+    Explanation
+    ===========
+
+    The idea for summation is the following:
+
+    - If we are dealing with a KroneckerDelta expression, i.e. KroneckerDelta(g(x), j),
+      we try to simplify it.
+
+      If we could simplify it, then we sum the resulting expression.
+      We already know we can sum a simplified expression, because only
+      simple KroneckerDelta expressions are involved.
+
+      If we could not simplify it, there are two cases:
+
+      1) The expression is a simple expression: we return the summation,
+         taking care if we are dealing with a Derivative or with a proper
+         KroneckerDelta.
+
+      2) The expression is not simple (i.e. KroneckerDelta(cos(x))): we can do
+         nothing at all.
+
+    - If the expr is a multiplication expr having a KroneckerDelta term:
+
+      First we expand it.
+
+      If the expansion did work, then we try to sum the expansion.
+
+      If not, we try to extract a simple KroneckerDelta term, then we have two
+      cases:
+
+      1) We have a simple KroneckerDelta term, so we return the summation.
+
+      2) We did not have a simple term, but we do have an expression with
+         simplified KroneckerDelta terms, so we sum this expression.
+
+    Examples
+    ========
+
+    >>> from sympy import oo, symbols
+    >>> from sympy.abc import k
+    >>> i, j = symbols('i, j', integer=True, finite=True)
+    >>> from sympy.concrete.delta import deltasummation
+    >>> from sympy import KroneckerDelta
+    >>> deltasummation(KroneckerDelta(i, k), (k, -oo, oo))
+    1
+    >>> deltasummation(KroneckerDelta(i, k), (k, 0, oo))
+    Piecewise((1, i >= 0), (0, True))
+    >>> deltasummation(KroneckerDelta(i, k), (k, 1, 3))
+    Piecewise((1, (i >= 1) & (i <= 3)), (0, True))
+    >>> deltasummation(k*KroneckerDelta(i, j)*KroneckerDelta(j, k), (k, -oo, oo))
+    j*KroneckerDelta(i, j)
+    >>> deltasummation(j*KroneckerDelta(i, j), (j, -oo, oo))
+    i
+    >>> deltasummation(i*KroneckerDelta(i, j), (i, -oo, oo))
+    j
+
+    See Also
+    ========
+
+    deltaproduct
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    sympy.concrete.sums.summation
+    """
+    if ((limit[2] - limit[1]) < 0) == True:
+        return S.Zero
+
+    if not f.has(KroneckerDelta):
+        return summation(f, limit)
+
+    x = limit[0]
+
+    g = _expand_delta(f, x)
+    if g.is_Add:
+        return piecewise_fold(
+            g.func(*[deltasummation(h, limit, no_piecewise) for h in g.args]))
+
+    # try to extract a simple KroneckerDelta term
+    delta, expr = _extract_delta(g, x)
+
+    if (delta is not None) and (delta.delta_range is not None):
+        dinf, dsup = delta.delta_range
+        if (limit[1] - dinf <= 0) == True and (limit[2] - dsup >= 0) == True:
+            no_piecewise = True
+
+    if not delta:
+        return summation(f, limit)
+
+    solns = solve(delta.args[0] - delta.args[1], x)
+    if len(solns) == 0:
+        return S.Zero
+    elif len(solns) != 1:
+        return Sum(f, limit)
+    value = solns[0]
+    if no_piecewise:
+        return expr.subs(x, value)
+    return Piecewise(
+        (expr.subs(x, value), Interval(*limit[1:3]).as_relational(value)),
+        (S.Zero, True)
+    )

env-llmeval/lib/python3.10/site-packages/sympy/concrete/expr_with_intlimits.py

@@ -0,0 +1,354 @@
+from sympy.concrete.expr_with_limits import ExprWithLimits
+from sympy.core.singleton import S
+from sympy.core.relational import Eq
+
+class ReorderError(NotImplementedError):
+    """
+    Exception raised when trying to reorder dependent limits.
+    """
+    def __init__(self, expr, msg):
+        super().__init__(
+            "%s could not be reordered: %s." % (expr, msg))
+
+class ExprWithIntLimits(ExprWithLimits):
+    """
+    Superclass for Product and Sum.
+
+    See Also
+    ========
+
+    sympy.concrete.expr_with_limits.ExprWithLimits
+    sympy.concrete.products.Product
+    sympy.concrete.summations.Sum
+    """
+    __slots__ = ()
+
+    def change_index(self, var, trafo, newvar=None):
+        r"""
+        Change index of a Sum or Product.
+
+        Perform a linear transformation `x \mapsto a x + b` on the index variable
+        `x`. For `a` the only values allowed are `\pm 1`. A new variable to be used
+        after the change of index can also be specified.
+
+        Explanation
+        ===========
+
+        ``change_index(expr, var, trafo, newvar=None)`` where ``var`` specifies the
+        index variable `x` to transform. The transformation ``trafo`` must be linear
+        and given in terms of ``var``. If the optional argument ``newvar`` is
+        provided then ``var`` gets replaced by ``newvar`` in the final expression.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Product, simplify
+        >>> from sympy.abc import x, y, a, b, c, d, u, v, i, j, k, l
+
+        >>> S = Sum(x, (x, a, b))
+        >>> S.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, x + 1, y)
+        >>> Sn
+        Sum(y - 1, (y, a + 1, b + 1))
+        >>> Sn.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, -x, y)
+        >>> Sn
+        Sum(-y, (y, -b, -a))
+        >>> Sn.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, x+u)
+        >>> Sn
+        Sum(-u + x, (x, a + u, b + u))
+        >>> Sn.doit()
+        -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
+        >>> simplify(Sn.doit())
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, -x - u, y)
+        >>> Sn
+        Sum(-u - y, (y, -b - u, -a - u))
+        >>> Sn.doit()
+        -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
+        >>> simplify(Sn.doit())
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> P = Product(i*j**2, (i, a, b), (j, c, d))
+        >>> P
+        Product(i*j**2, (i, a, b), (j, c, d))
+        >>> P2 = P.change_index(i, i+3, k)
+        >>> P2
+        Product(j**2*(k - 3), (k, a + 3, b + 3), (j, c, d))
+        >>> P3 = P2.change_index(j, -j, l)
+        >>> P3
+        Product(l**2*(k - 3), (k, a + 3, b + 3), (l, -d, -c))
+
+        When dealing with symbols only, we can make a
+        general linear transformation:
+
+        >>> Sn = S.change_index(x, u*x+v, y)
+        >>> Sn
+        Sum((-v + y)/u, (y, b*u + v, a*u + v))
+        >>> Sn.doit()
+        -v*(a*u - b*u + 1)/u + (a**2*u**2/2 + a*u*v + a*u/2 - b**2*u**2/2 - b*u*v + b*u/2 + v)/u
+        >>> simplify(Sn.doit())
+        a**2*u/2 + a/2 - b**2*u/2 + b/2
+
+        However, the last result can be inconsistent with usual
+        summation where the index increment is always 1. This is
+        obvious as we get back the original value only for ``u``
+        equal +1 or -1.
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index,
+        reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder,
+        sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        if newvar is None:
+            newvar = var
+
+        limits = []
+        for limit in self.limits:
+            if limit[0] == var:
+                p = trafo.as_poly(var)
+                if p.degree() != 1:
+                    raise ValueError("Index transformation is not linear")
+                alpha = p.coeff_monomial(var)
+                beta = p.coeff_monomial(S.One)
+                if alpha.is_number:
+                    if alpha == S.One:
+                        limits.append((newvar, alpha*limit[1] + beta, alpha*limit[2] + beta))
+                    elif alpha == S.NegativeOne:
+                        limits.append((newvar, alpha*limit[2] + beta, alpha*limit[1] + beta))
+                    else:
+                        raise ValueError("Linear transformation results in non-linear summation stepsize")
+                else:
+                    # Note that the case of alpha being symbolic can give issues if alpha < 0.
+                    limits.append((newvar, alpha*limit[2] + beta, alpha*limit[1] + beta))
+            else:
+                limits.append(limit)
+
+        function = self.function.subs(var, (var - beta)/alpha)
+        function = function.subs(var, newvar)
+
+        return self.func(function, *limits)
+
+
+    def index(expr, x):
+        """
+        Return the index of a dummy variable in the list of limits.
+
+        Explanation
+        ===========
+
+        ``index(expr, x)``  returns the index of the dummy variable ``x`` in the
+        limits of ``expr``. Note that we start counting with 0 at the inner-most
+        limits tuple.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> from sympy import Sum, Product
+        >>> Sum(x*y, (x, a, b), (y, c, d)).index(x)
+        0
+        >>> Sum(x*y, (x, a, b), (y, c, d)).index(y)
+        1
+        >>> Product(x*y, (x, a, b), (y, c, d)).index(x)
+        0
+        >>> Product(x*y, (x, a, b), (y, c, d)).index(y)
+        1
+
+        See Also
+        ========
+
+        reorder_limit, reorder, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        variables = [limit[0] for limit in expr.limits]
+
+        if variables.count(x) != 1:
+            raise ValueError(expr, "Number of instances of variable not equal to one")
+        else:
+            return variables.index(x)
+
+    def reorder(expr, *arg):
+        """
+        Reorder limits in a expression containing a Sum or a Product.
+
+        Explanation
+        ===========
+
+        ``expr.reorder(*arg)`` reorders the limits in the expression ``expr``
+        according to the list of tuples given by ``arg``. These tuples can
+        contain numerical indices or index variable names or involve both.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Product
+        >>> from sympy.abc import x, y, z, a, b, c, d, e, f
+
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((x, y))
+        Sum(x*y, (y, c, d), (x, a, b))
+
+        >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder((x, y), (x, z), (y, z))
+        Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+
+        >>> P = Product(x*y*z, (x, a, b), (y, c, d), (z, e, f))
+        >>> P.reorder((x, y), (x, z), (y, z))
+        Product(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+
+        We can also select the index variables by counting them, starting
+        with the inner-most one:
+
+        >>> Sum(x**2, (x, a, b), (x, c, d)).reorder((0, 1))
+        Sum(x**2, (x, c, d), (x, a, b))
+
+        And of course we can mix both schemes:
+
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x))
+        Sum(x*y, (y, c, d), (x, a, b))
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, 0))
+        Sum(x*y, (y, c, d), (x, a, b))
+
+        See Also
+        ========
+
+        reorder_limit, index, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        new_expr = expr
+
+        for r in arg:
+            if len(r) != 2:
+                raise ValueError(r, "Invalid number of arguments")
+
+            index1 = r[0]
+            index2 = r[1]
+
+            if not isinstance(r[0], int):
+                index1 = expr.index(r[0])
+            if not isinstance(r[1], int):
+                index2 = expr.index(r[1])
+
+            new_expr = new_expr.reorder_limit(index1, index2)
+
+        return new_expr
+
+
+    def reorder_limit(expr, x, y):
+        """
+        Interchange two limit tuples of a Sum or Product expression.
+
+        Explanation
+        ===========
+
+        ``expr.reorder_limit(x, y)`` interchanges two limit tuples. The
+        arguments ``x`` and ``y`` are integers corresponding to the index
+        variables of the two limits which are to be interchanged. The
+        expression ``expr`` has to be either a Sum or a Product.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z, a, b, c, d, e, f
+        >>> from sympy import Sum, Product
+
+        >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
+        Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+        >>> Sum(x**2, (x, a, b), (x, c, d)).reorder_limit(1, 0)
+        Sum(x**2, (x, c, d), (x, a, b))
+
+        >>> Product(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
+        Product(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+
+        See Also
+        ========
+
+        index, reorder, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        var = {limit[0] for limit in expr.limits}
+        limit_x = expr.limits[x]
+        limit_y = expr.limits[y]
+
+        if (len(set(limit_x[1].free_symbols).intersection(var)) == 0 and
+            len(set(limit_x[2].free_symbols).intersection(var)) == 0 and
+            len(set(limit_y[1].free_symbols).intersection(var)) == 0 and
+            len(set(limit_y[2].free_symbols).intersection(var)) == 0):
+
+            limits = []
+            for i, limit in enumerate(expr.limits):
+                if i == x:
+                    limits.append(limit_y)
+                elif i == y:
+                    limits.append(limit_x)
+                else:
+                    limits.append(limit)
+
+            return type(expr)(expr.function, *limits)
+        else:
+            raise ReorderError(expr, "could not interchange the two limits specified")
+
+    @property
+    def has_empty_sequence(self):
+        """
+        Returns True if the Sum or Product is computed for an empty sequence.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Product, Symbol
+        >>> m = Symbol('m')
+        >>> Sum(m, (m, 1, 0)).has_empty_sequence
+        True
+
+        >>> Sum(m, (m, 1, 1)).has_empty_sequence
+        False
+
+        >>> M = Symbol('M', integer=True, positive=True)
+        >>> Product(m, (m, 1, M)).has_empty_sequence
+        False
+
+        >>> Product(m, (m, 2, M)).has_empty_sequence
+
+        >>> Product(m, (m, M + 1, M)).has_empty_sequence
+        True
+
+        >>> N = Symbol('N', integer=True, positive=True)
+        >>> Sum(m, (m, N, M)).has_empty_sequence
+
+        >>> N = Symbol('N', integer=True, negative=True)
+        >>> Sum(m, (m, N, M)).has_empty_sequence
+        False
+
+        See Also
+        ========
+
+        has_reversed_limits
+        has_finite_limits
+
+        """
+        ret_None = False
+        for lim in self.limits:
+            dif = lim[1] - lim[2]
+            eq = Eq(dif, 1)
+            if eq == True:
+                return True
+            elif eq == False:
+                continue
+            else:
+                ret_None = True
+
+        if ret_None:
+            return None
+        return False

env-llmeval/lib/python3.10/site-packages/sympy/concrete/expr_with_limits.py

@@ -0,0 +1,603 @@
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import AppliedUndef, UndefinedFunction
+from sympy.core.mul import Mul
+from sympy.core.relational import Equality, Relational
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import (piecewise_fold,
+    Piecewise)
+from sympy.logic.boolalg import BooleanFunction
+from sympy.matrices.matrices import MatrixBase
+from sympy.sets.sets import Interval, Set
+from sympy.sets.fancysets import Range
+from sympy.tensor.indexed import Idx
+from sympy.utilities import flatten
+from sympy.utilities.iterables import sift, is_sequence
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+
+def _common_new(cls, function, *symbols, discrete, **assumptions):
+    """Return either a special return value or the tuple,
+    (function, limits, orientation). This code is common to
+    both ExprWithLimits and AddWithLimits."""
+    function = sympify(function)
+
+    if isinstance(function, Equality):
+        # This transforms e.g. Integral(Eq(x, y)) to Eq(Integral(x), Integral(y))
+        # but that is only valid for definite integrals.
+        limits, orientation = _process_limits(*symbols, discrete=discrete)
+        if not (limits and all(len(limit) == 3 for limit in limits)):
+            sympy_deprecation_warning(
+                """
+                Creating a indefinite integral with an Eq() argument is
+                deprecated.
+
+                This is because indefinite integrals do not preserve equality
+                due to the arbitrary constants. If you want an equality of
+                indefinite integrals, use Eq(Integral(a, x), Integral(b, x))
+                explicitly.
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-indefinite-integral-eq",
+                stacklevel=5,
+            )
+
+        lhs = function.lhs
+        rhs = function.rhs
+        return Equality(cls(lhs, *symbols, **assumptions), \
+                        cls(rhs, *symbols, **assumptions))
+
+    if function is S.NaN:
+        return S.NaN
+
+    if symbols:
+        limits, orientation = _process_limits(*symbols, discrete=discrete)
+        for i, li in enumerate(limits):
+            if len(li) == 4:
+                function = function.subs(li[0], li[-1])
+                limits[i] = Tuple(*li[:-1])
+    else:
+        # symbol not provided -- we can still try to compute a general form
+        free = function.free_symbols
+        if len(free) != 1:
+            raise ValueError(
+                "specify dummy variables for %s" % function)
+        limits, orientation = [Tuple(s) for s in free], 1
+
+    # denest any nested calls
+    while cls == type(function):
+        limits = list(function.limits) + limits
+        function = function.function
+
+    # Any embedded piecewise functions need to be brought out to the
+    # top level. We only fold Piecewise that contain the integration
+    # variable.
+    reps = {}
+    symbols_of_integration = {i[0] for i in limits}
+    for p in function.atoms(Piecewise):
+        if not p.has(*symbols_of_integration):
+            reps[p] = Dummy()
+    # mask off those that don't
+    function = function.xreplace(reps)
+    # do the fold
+    function = piecewise_fold(function)
+    # remove the masking
+    function = function.xreplace({v: k for k, v in reps.items()})
+
+    return function, limits, orientation
+
+
+def _process_limits(*symbols, discrete=None):
+    """Process the list of symbols and convert them to canonical limits,
+    storing them as Tuple(symbol, lower, upper). The orientation of
+    the function is also returned when the upper limit is missing
+    so (x, 1, None) becomes (x, None, 1) and the orientation is changed.
+    In the case that a limit is specified as (symbol, Range), a list of
+    length 4 may be returned if a change of variables is needed; the
+    expression that should replace the symbol in the expression is
+    the fourth element in the list.
+    """
+    limits = []
+    orientation = 1
+    if discrete is None:
+        err_msg = 'discrete must be True or False'
+    elif discrete:
+        err_msg = 'use Range, not Interval or Relational'
+    else:
+        err_msg = 'use Interval or Relational, not Range'
+    for V in symbols:
+        if isinstance(V, (Relational, BooleanFunction)):
+            if discrete:
+                raise TypeError(err_msg)
+            variable = V.atoms(Symbol).pop()
+            V = (variable, V.as_set())
+        elif isinstance(V, Symbol) or getattr(V, '_diff_wrt', False):
+            if isinstance(V, Idx):
+                if V.lower is None or V.upper is None:
+                    limits.append(Tuple(V))
+                else:
+                    limits.append(Tuple(V, V.lower, V.upper))
+            else:
+                limits.append(Tuple(V))
+            continue
+        if is_sequence(V) and not isinstance(V, Set):
+            if len(V) == 2 and isinstance(V[1], Set):
+                V = list(V)
+                if isinstance(V[1], Interval):  # includes Reals
+                    if discrete:
+                        raise TypeError(err_msg)
+                    V[1:] = V[1].inf, V[1].sup
+                elif isinstance(V[1], Range):
+                    if not discrete:
+                        raise TypeError(err_msg)
+                    lo = V[1].inf
+                    hi = V[1].sup
+                    dx = abs(V[1].step)  # direction doesn't matter
+                    if dx == 1:
+                        V[1:] = [lo, hi]
+                    else:
+                        if lo is not S.NegativeInfinity:
+                            V = [V[0]] + [0, (hi - lo)//dx, dx*V[0] + lo]
+                        else:
+                            V = [V[0]] + [0, S.Infinity, -dx*V[0] + hi]
+                else:
+                    # more complicated sets would require splitting, e.g.
+                    # Union(Interval(1, 3), interval(6,10))
+                    raise NotImplementedError(
+                        'expecting Range' if discrete else
+                        'Relational or single Interval' )
+            V = sympify(flatten(V))  # list of sympified elements/None
+            if isinstance(V[0], (Symbol, Idx)) or getattr(V[0], '_diff_wrt', False):
+                newsymbol = V[0]
+                if len(V) == 3:
+                    # general case
+                    if V[2] is None and V[1] is not None:
+                        orientation *= -1
+                    V = [newsymbol] + [i for i in V[1:] if i is not None]
+
+                lenV = len(V)
+                if not isinstance(newsymbol, Idx) or lenV == 3:
+                    if lenV == 4:
+                        limits.append(Tuple(*V))
+                        continue
+                    if lenV == 3:
+                        if isinstance(newsymbol, Idx):
+                            # Idx represents an integer which may have
+                            # specified values it can take on; if it is
+                            # given such a value, an error is raised here
+                            # if the summation would try to give it a larger
+                            # or smaller value than permitted. None and Symbolic
+                            # values will not raise an error.
+                            lo, hi = newsymbol.lower, newsymbol.upper
+                            try:
+                                if lo is not None and not bool(V[1] >= lo):
+                                    raise ValueError("Summation will set Idx value too low.")
+                            except TypeError:
+                                pass
+                            try:
+                                if hi is not None and not bool(V[2] <= hi):
+                                    raise ValueError("Summation will set Idx value too high.")
+                            except TypeError:
+                                pass
+                        limits.append(Tuple(*V))
+                        continue
+                    if lenV == 1 or (lenV == 2 and V[1] is None):
+                        limits.append(Tuple(newsymbol))
+                        continue
+                    elif lenV == 2:
+                        limits.append(Tuple(newsymbol, V[1]))
+                        continue
+
+        raise ValueError('Invalid limits given: %s' % str(symbols))
+
+    return limits, orientation
+
+
+class ExprWithLimits(Expr):
+    __slots__ = ('is_commutative',)
+
+    def __new__(cls, function, *symbols, **assumptions):
+        from sympy.concrete.products import Product
+        pre = _common_new(cls, function, *symbols,
+            discrete=issubclass(cls, Product), **assumptions)
+        if isinstance(pre, tuple):
+            function, limits, _ = pre
+        else:
+            return pre
+
+        # limits must have upper and lower bounds; the indefinite form
+        # is not supported. This restriction does not apply to AddWithLimits
+        if any(len(l) != 3 or None in l for l in limits):
+            raise ValueError('ExprWithLimits requires values for lower and upper bounds.')
+
+        obj = Expr.__new__(cls, **assumptions)
+        arglist = [function]
+        arglist.extend(limits)
+        obj._args = tuple(arglist)
+        obj.is_commutative = function.is_commutative  # limits already checked
+
+        return obj
+
+    @property
+    def function(self):
+        """Return the function applied across limits.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x
+        >>> Integral(x**2, (x,)).function
+        x**2
+
+        See Also
+        ========
+
+        limits, variables, free_symbols
+        """
+        return self._args[0]
+
+    @property
+    def kind(self):
+        return self.function.kind
+
+    @property
+    def limits(self):
+        """Return the limits of expression.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, i
+        >>> Integral(x**i, (i, 1, 3)).limits
+        ((i, 1, 3),)
+
+        See Also
+        ========
+
+        function, variables, free_symbols
+        """
+        return self._args[1:]
+
+    @property
+    def variables(self):
+        """Return a list of the limit variables.
+
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, i
+        >>> Sum(x**i, (i, 1, 3)).variables
+        [i]
+
+        See Also
+        ========
+
+        function, limits, free_symbols
+        as_dummy : Rename dummy variables
+        sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable
+        """
+        return [l[0] for l in self.limits]
+
+    @property
+    def bound_symbols(self):
+        """Return only variables that are dummy variables.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, i, j, k
+        >>> Integral(x**i, (i, 1, 3), (j, 2), k).bound_symbols
+        [i, j]
+
+        See Also
+        ========
+
+        function, limits, free_symbols
+        as_dummy : Rename dummy variables
+        sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable
+        """
+        return [l[0] for l in self.limits if len(l) != 1]
+
+    @property
+    def free_symbols(self):
+        """
+        This method returns the symbols in the object, excluding those
+        that take on a specific value (i.e. the dummy symbols).
+
+        Examples
+        ========
+
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, y
+        >>> Sum(x, (x, y, 1)).free_symbols
+        {y}
+        """
+        # don't test for any special values -- nominal free symbols
+        # should be returned, e.g. don't return set() if the
+        # function is zero -- treat it like an unevaluated expression.
+        function, limits = self.function, self.limits
+        # mask off non-symbol integration variables that have
+        # more than themself as a free symbol
+        reps = {i[0]: i[0] if i[0].free_symbols == {i[0]} else Dummy()
+            for i in self.limits}
+        function = function.xreplace(reps)
+        isyms = function.free_symbols
+        for xab in limits:
+            v = reps[xab[0]]
+            if len(xab) == 1:
+                isyms.add(v)
+                continue
+            # take out the target symbol
+            if v in isyms:
+                isyms.remove(v)
+            # add in the new symbols
+            for i in xab[1:]:
+                isyms.update(i.free_symbols)
+        reps = {v: k for k, v in reps.items()}
+        return {reps.get(_, _) for _ in isyms}
+
+    @property
+    def is_number(self):
+        """Return True if the Sum has no free symbols, else False."""
+        return not self.free_symbols
+
+    def _eval_interval(self, x, a, b):
+        limits = [(i if i[0] != x else (x, a, b)) for i in self.limits]
+        integrand = self.function
+        return self.func(integrand, *limits)
+
+    def _eval_subs(self, old, new):
+        """
+        Perform substitutions over non-dummy variables
+        of an expression with limits.  Also, can be used
+        to specify point-evaluation of an abstract antiderivative.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, oo
+        >>> from sympy.abc import s, n
+        >>> Sum(1/n**s, (n, 1, oo)).subs(s, 2)
+        Sum(n**(-2), (n, 1, oo))
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, a
+        >>> Integral(a*x**2, x).subs(x, 4)
+        Integral(a*x**2, (x, 4))
+
+        See Also
+        ========
+
+        variables : Lists the integration variables
+        transform : Perform mapping on the dummy variable for integrals
+        change_index : Perform mapping on the sum and product dummy variables
+
+        """
+        func, limits = self.function, list(self.limits)
+
+        # If one of the expressions we are replacing is used as a func index
+        # one of two things happens.
+        #   - the old variable first appears as a free variable
+        #     so we perform all free substitutions before it becomes
+        #     a func index.
+        #   - the old variable first appears as a func index, in
+        #     which case we ignore.  See change_index.
+
+        # Reorder limits to match standard mathematical practice for scoping
+        limits.reverse()
+
+        if not isinstance(old, Symbol) or \
+                old.free_symbols.intersection(self.free_symbols):
+            sub_into_func = True
+            for i, xab in enumerate(limits):
+                if 1 == len(xab) and old == xab[0]:
+                    if new._diff_wrt:
+                        xab = (new,)
+                    else:
+                        xab = (old, old)
+                limits[i] = Tuple(xab[0], *[l._subs(old, new) for l in xab[1:]])
+                if len(xab[0].free_symbols.intersection(old.free_symbols)) != 0:
+                    sub_into_func = False
+                    break
+            if isinstance(old, (AppliedUndef, UndefinedFunction)):
+                sy2 = set(self.variables).intersection(set(new.atoms(Symbol)))
+                sy1 = set(self.variables).intersection(set(old.args))
+                if not sy2.issubset(sy1):
+                    raise ValueError(
+                        "substitution cannot create dummy dependencies")
+                sub_into_func = True
+            if sub_into_func:
+                func = func.subs(old, new)
+        else:
+            # old is a Symbol and a dummy variable of some limit
+            for i, xab in enumerate(limits):
+                if len(xab) == 3:
+                    limits[i] = Tuple(xab[0], *[l._subs(old, new) for l in xab[1:]])
+                    if old == xab[0]:
+                        break
+        # simplify redundant limits (x, x)  to (x, )
+        for i, xab in enumerate(limits):
+            if len(xab) == 2 and (xab[0] - xab[1]).is_zero:
+                limits[i] = Tuple(xab[0], )
+
+        # Reorder limits back to representation-form
+        limits.reverse()
+
+        return self.func(func, *limits)
+
+    @property
+    def has_finite_limits(self):
+        """
+        Returns True if the limits are known to be finite, either by the
+        explicit bounds, assumptions on the bounds, or assumptions on the
+        variables.  False if known to be infinite, based on the bounds.
+        None if not enough information is available to determine.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Integral, Product, oo, Symbol
+        >>> x = Symbol('x')
+        >>> Sum(x, (x, 1, 8)).has_finite_limits
+        True
+
+        >>> Integral(x, (x, 1, oo)).has_finite_limits
+        False
+
+        >>> M = Symbol('M')
+        >>> Sum(x, (x, 1, M)).has_finite_limits
+
+        >>> N = Symbol('N', integer=True)
+        >>> Product(x, (x, 1, N)).has_finite_limits
+        True
+
+        See Also
+        ========
+
+        has_reversed_limits
+
+        """
+
+        ret_None = False
+        for lim in self.limits:
+            if len(lim) == 3:
+                if any(l.is_infinite for l in lim[1:]):
+                    # Any of the bounds are +/-oo
+                    return False
+                elif any(l.is_infinite is None for l in lim[1:]):
+                    # Maybe there are assumptions on the variable?
+                    if lim[0].is_infinite is None:
+                        ret_None = True
+            else:
+                if lim[0].is_infinite is None:
+                    ret_None = True
+
+        if ret_None:
+            return None
+        return True
+
+    @property
+    def has_reversed_limits(self):
+        """
+        Returns True if the limits are known to be in reversed order, either
+        by the explicit bounds, assumptions on the bounds, or assumptions on the
+        variables.  False if known to be in normal order, based on the bounds.
+        None if not enough information is available to determine.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Integral, Product, oo, Symbol
+        >>> x = Symbol('x')
+        >>> Sum(x, (x, 8, 1)).has_reversed_limits
+        True
+
+        >>> Sum(x, (x, 1, oo)).has_reversed_limits
+        False
+
+        >>> M = Symbol('M')
+        >>> Integral(x, (x, 1, M)).has_reversed_limits
+
+        >>> N = Symbol('N', integer=True, positive=True)
+        >>> Sum(x, (x, 1, N)).has_reversed_limits
+        False
+
+        >>> Product(x, (x, 2, N)).has_reversed_limits
+
+        >>> Product(x, (x, 2, N)).subs(N, N + 2).has_reversed_limits
+        False
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.has_empty_sequence
+
+        """
+        ret_None = False
+        for lim in self.limits:
+            if len(lim) == 3:
+                var, a, b = lim
+                dif = b - a
+                if dif.is_extended_negative:
+                    return True
+                elif dif.is_extended_nonnegative:
+                    continue
+                else:
+                    ret_None = True
+            else:
+                return None
+        if ret_None:
+            return None
+        return False
+
+
+class AddWithLimits(ExprWithLimits):
+    r"""Represents unevaluated oriented additions.
+        Parent class for Integral and Sum.
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, function, *symbols, **assumptions):
+        from sympy.concrete.summations import Sum
+        pre = _common_new(cls, function, *symbols,
+            discrete=issubclass(cls, Sum), **assumptions)
+        if isinstance(pre, tuple):
+            function, limits, orientation = pre
+        else:
+            return pre
+
+        obj = Expr.__new__(cls, **assumptions)
+        arglist = [orientation*function]  # orientation not used in ExprWithLimits
+        arglist.extend(limits)
+        obj._args = tuple(arglist)
+        obj.is_commutative = function.is_commutative  # limits already checked
+
+        return obj
+
+    def _eval_adjoint(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.adjoint(), *self.limits)
+        return None
+
+    def _eval_conjugate(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.conjugate(), *self.limits)
+        return None
+
+    def _eval_transpose(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.transpose(), *self.limits)
+        return None
+
+    def _eval_factor(self, **hints):
+        if 1 == len(self.limits):
+            summand = self.function.factor(**hints)
+            if summand.is_Mul:
+                out = sift(summand.args, lambda w: w.is_commutative \
+                    and not set(self.variables) & w.free_symbols)
+                return Mul(*out[True])*self.func(Mul(*out[False]), \
+                    *self.limits)
+        else:
+            summand = self.func(self.function, *self.limits[0:-1]).factor()
+            if not summand.has(self.variables[-1]):
+                return self.func(1, [self.limits[-1]]).doit()*summand
+            elif isinstance(summand, Mul):
+                return self.func(summand, self.limits[-1]).factor()
+        return self
+
+    def _eval_expand_basic(self, **hints):
+        summand = self.function.expand(**hints)
+        force = hints.get('force', False)
+        if (summand.is_Add and (force or summand.is_commutative and
+                 self.has_finite_limits is not False)):
+            return Add(*[self.func(i, *self.limits) for i in summand.args])
+        elif isinstance(summand, MatrixBase):
+            return summand.applyfunc(lambda x: self.func(x, *self.limits))
+        elif summand != self.function:
+            return self.func(summand, *self.limits)
+        return self

env-llmeval/lib/python3.10/site-packages/sympy/concrete/gosper.py

@@ -0,0 +1,227 @@
+"""Gosper's algorithm for hypergeometric summation. """
+
+from sympy.core import S, Dummy, symbols
+from sympy.polys import Poly, parallel_poly_from_expr, factor
+from sympy.utilities.iterables import is_sequence
+
+
+def gosper_normal(f, g, n, polys=True):
+    r"""
+    Compute the Gosper's normal form of ``f`` and ``g``.
+
+    Explanation
+    ===========
+
+    Given relatively prime univariate polynomials ``f`` and ``g``,
+    rewrite their quotient to a normal form defined as follows:
+
+    .. math::
+        \frac{f(n)}{g(n)} = Z \cdot \frac{A(n) C(n+1)}{B(n) C(n)}
+
+    where ``Z`` is an arbitrary constant and ``A``, ``B``, ``C`` are
+    monic polynomials in ``n`` with the following properties:
+
+    1. `\gcd(A(n), B(n+h)) = 1 \forall h \in \mathbb{N}`
+    2. `\gcd(B(n), C(n+1)) = 1`
+    3. `\gcd(A(n), C(n)) = 1`
+
+    This normal form, or rational factorization in other words, is a
+    crucial step in Gosper's algorithm and in solving of difference
+    equations. It can be also used to decide if two hypergeometric
+    terms are similar or not.
+
+    This procedure will return a tuple containing elements of this
+    factorization in the form ``(Z*A, B, C)``.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.gosper import gosper_normal
+    >>> from sympy.abc import n
+
+    >>> gosper_normal(4*n+5, 2*(4*n+1)*(2*n+3), n, polys=False)
+    (1/4, n + 3/2, n + 1/4)
+
+    """
+    (p, q), opt = parallel_poly_from_expr(
+        (f, g), n, field=True, extension=True)
+
+    a, A = p.LC(), p.monic()
+    b, B = q.LC(), q.monic()
+
+    C, Z = A.one, a/b
+    h = Dummy('h')
+
+    D = Poly(n + h, n, h, domain=opt.domain)
+
+    R = A.resultant(B.compose(D))
+    roots = set(R.ground_roots().keys())
+
+    for r in set(roots):
+        if not r.is_Integer or r < 0:
+            roots.remove(r)
+
+    for i in sorted(roots):
+        d = A.gcd(B.shift(+i))
+
+        A = A.quo(d)
+        B = B.quo(d.shift(-i))
+
+        for j in range(1, i + 1):
+            C *= d.shift(-j)
+
+    A = A.mul_ground(Z)
+
+    if not polys:
+        A = A.as_expr()
+        B = B.as_expr()
+        C = C.as_expr()
+
+    return A, B, C
+
+
+def gosper_term(f, n):
+    r"""
+    Compute Gosper's hypergeometric term for ``f``.
+
+    Explanation
+    ===========
+
+    Suppose ``f`` is a hypergeometric term such that:
+
+    .. math::
+        s_n = \sum_{k=0}^{n-1} f_k
+
+    and `f_k` does not depend on `n`. Returns a hypergeometric
+    term `g_n` such that `g_{n+1} - g_n = f_n`.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.gosper import gosper_term
+    >>> from sympy import factorial
+    >>> from sympy.abc import n
+
+    >>> gosper_term((4*n + 1)*factorial(n)/factorial(2*n + 1), n)
+    (-n - 1/2)/(n + 1/4)
+
+    """
+    from sympy.simplify import hypersimp
+    r = hypersimp(f, n)
+
+    if r is None:
+        return None    # 'f' is *not* a hypergeometric term
+
+    p, q = r.as_numer_denom()
+
+    A, B, C = gosper_normal(p, q, n)
+    B = B.shift(-1)
+
+    N = S(A.degree())
+    M = S(B.degree())
+    K = S(C.degree())
+
+    if (N != M) or (A.LC() != B.LC()):
+        D = {K - max(N, M)}
+    elif not N:
+        D = {K - N + 1, S.Zero}
+    else:
+        D = {K - N + 1, (B.nth(N - 1) - A.nth(N - 1))/A.LC()}
+
+    for d in set(D):
+        if not d.is_Integer or d < 0:
+            D.remove(d)
+
+    if not D:
+        return None    # 'f(n)' is *not* Gosper-summable
+
+    d = max(D)
+
+    coeffs = symbols('c:%s' % (d + 1), cls=Dummy)
+    domain = A.get_domain().inject(*coeffs)
+
+    x = Poly(coeffs, n, domain=domain)
+    H = A*x.shift(1) - B*x - C
+
+    from sympy.solvers.solvers import solve
+    solution = solve(H.coeffs(), coeffs)
+
+    if solution is None:
+        return None    # 'f(n)' is *not* Gosper-summable
+
+    x = x.as_expr().subs(solution)
+
+    for coeff in coeffs:
+        if coeff not in solution:
+            x = x.subs(coeff, 0)
+
+    if x.is_zero:
+        return None    # 'f(n)' is *not* Gosper-summable
+    else:
+        return B.as_expr()*x/C.as_expr()
+
+
+def gosper_sum(f, k):
+    r"""
+    Gosper's hypergeometric summation algorithm.
+
+    Explanation
+    ===========
+
+    Given a hypergeometric term ``f`` such that:
+
+    .. math ::
+        s_n = \sum_{k=0}^{n-1} f_k
+
+    and `f(n)` does not depend on `n`, returns `g_{n} - g(0)` where
+    `g_{n+1} - g_n = f_n`, or ``None`` if `s_n` cannot be expressed
+    in closed form as a sum of hypergeometric terms.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.gosper import gosper_sum
+    >>> from sympy import factorial
+    >>> from sympy.abc import n, k
+
+    >>> f = (4*k + 1)*factorial(k)/factorial(2*k + 1)
+    >>> gosper_sum(f, (k, 0, n))
+    (-factorial(n) + 2*factorial(2*n + 1))/factorial(2*n + 1)
+    >>> _.subs(n, 2) == sum(f.subs(k, i) for i in [0, 1, 2])
+    True
+    >>> gosper_sum(f, (k, 3, n))
+    (-60*factorial(n) + factorial(2*n + 1))/(60*factorial(2*n + 1))
+    >>> _.subs(n, 5) == sum(f.subs(k, i) for i in [3, 4, 5])
+    True
+
+    References
+    ==========
+
+    .. [1] Marko Petkovsek, Herbert S. Wilf, Doron Zeilberger, A = B,
+           AK Peters, Ltd., Wellesley, MA, USA, 1997, pp. 73--100
+
+    """
+    indefinite = False
+
+    if is_sequence(k):
+        k, a, b = k
+    else:
+        indefinite = True
+
+    g = gosper_term(f, k)
+
+    if g is None:
+        return None
+
+    if indefinite:
+        result = f*g
+    else:
+        result = (f*(g + 1)).subs(k, b) - (f*g).subs(k, a)
+
+        if result is S.NaN:
+            try:
+                result = (f*(g + 1)).limit(k, b) - (f*g).limit(k, a)
+            except NotImplementedError:
+                result = None
+
+    return factor(result)

env-llmeval/lib/python3.10/site-packages/sympy/concrete/guess.py

@@ -0,0 +1,473 @@
+"""Various algorithms for helping identifying numbers and sequences."""
+
+
+from sympy.concrete.products import (Product, product)
+from sympy.core import Function, S
+from sympy.core.add import Add
+from sympy.core.numbers import Integer, Rational
+from sympy.core.symbol import Symbol, symbols
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.integrals.integrals import integrate
+from sympy.polys.polyfuncs import rational_interpolate as rinterp
+from sympy.polys.polytools import lcm
+from sympy.simplify.radsimp import denom
+from sympy.utilities import public
+
+
+@public
+def find_simple_recurrence_vector(l):
+    """
+    This function is used internally by other functions from the
+    sympy.concrete.guess module. While most users may want to rather use the
+    function find_simple_recurrence when looking for recurrence relations
+    among rational numbers, the current function may still be useful when
+    some post-processing has to be done.
+
+    Explanation
+    ===========
+
+    The function returns a vector of length n when a recurrence relation of
+    order n is detected in the sequence of rational numbers v.
+
+    If the returned vector has a length 1, then the returned value is always
+    the list [0], which means that no relation has been found.
+
+    While the functions is intended to be used with rational numbers, it should
+    work for other kinds of real numbers except for some cases involving
+    quadratic numbers; for that reason it should be used with some caution when
+    the argument is not a list of rational numbers.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import find_simple_recurrence_vector
+    >>> from sympy import fibonacci
+    >>> find_simple_recurrence_vector([fibonacci(k) for k in range(12)])
+    [1, -1, -1]
+
+    See Also
+    ========
+
+    See the function sympy.concrete.guess.find_simple_recurrence which is more
+    user-friendly.
+
+    """
+    q1 = [0]
+    q2 = [1]
+    b, z = 0, len(l) >> 1
+    while len(q2) <= z:
+        while l[b]==0:
+            b += 1
+            if b == len(l):
+                c = 1
+                for x in q2:
+                    c = lcm(c, denom(x))
+                if q2[0]*c < 0: c = -c
+                for k in range(len(q2)):
+                    q2[k] = int(q2[k]*c)
+                return q2
+        a = S.One/l[b]
+        m = [a]
+        for k in range(b+1, len(l)):
+            m.append(-sum(l[j+1]*m[b-j-1] for j in range(b, k))*a)
+        l, m = m, [0] * max(len(q2), b+len(q1))
+        for k, q in enumerate(q2):
+            m[k] = a*q
+        for k, q in enumerate(q1):
+            m[k+b] += q
+        while m[-1]==0: m.pop() # because trailing zeros can occur
+        q1, q2, b = q2, m, 1
+    return [0]
+
+@public
+def find_simple_recurrence(v, A=Function('a'), N=Symbol('n')):
+    """
+    Detects and returns a recurrence relation from a sequence of several integer
+    (or rational) terms. The name of the function in the returned expression is
+    'a' by default; the main variable is 'n' by default. The smallest index in
+    the returned expression is always n (and never n-1, n-2, etc.).
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import find_simple_recurrence
+    >>> from sympy import fibonacci
+    >>> find_simple_recurrence([fibonacci(k) for k in range(12)])
+    -a(n) - a(n + 1) + a(n + 2)
+
+    >>> from sympy import Function, Symbol
+    >>> a = [1, 1, 1]
+    >>> for k in range(15): a.append(5*a[-1]-3*a[-2]+8*a[-3])
+    >>> find_simple_recurrence(a, A=Function('f'), N=Symbol('i'))
+    -8*f(i) + 3*f(i + 1) - 5*f(i + 2) + f(i + 3)
+
+    """
+    p = find_simple_recurrence_vector(v)
+    n = len(p)
+    if n <= 1: return S.Zero
+
+    return Add(*[A(N+n-1-k)*p[k] for k in range(n)])
+
+
+@public
+def rationalize(x, maxcoeff=10000):
+    """
+    Helps identifying a rational number from a float (or mpmath.mpf) value by
+    using a continued fraction. The algorithm stops as soon as a large partial
+    quotient is detected (greater than 10000 by default).
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import rationalize
+    >>> from mpmath import cos, pi
+    >>> rationalize(cos(pi/3))
+    1/2
+
+    >>> from mpmath import mpf
+    >>> rationalize(mpf("0.333333333333333"))
+    1/3
+
+    While the function is rather intended to help 'identifying' rational
+    values, it may be used in some cases for approximating real numbers.
+    (Though other functions may be more relevant in that case.)
+
+    >>> rationalize(pi, maxcoeff = 250)
+    355/113
+
+    See Also
+    ========
+
+    Several other methods can approximate a real number as a rational, like:
+
+      * fractions.Fraction.from_decimal
+      * fractions.Fraction.from_float
+      * mpmath.identify
+      * mpmath.pslq by using the following syntax: mpmath.pslq([x, 1])
+      * mpmath.findpoly by using the following syntax: mpmath.findpoly(x, 1)
+      * sympy.simplify.nsimplify (which is a more general function)
+
+    The main difference between the current function and all these variants is
+    that control focuses on magnitude of partial quotients here rather than on
+    global precision of the approximation. If the real is "known to be" a
+    rational number, the current function should be able to detect it correctly
+    with the default settings even when denominator is great (unless its
+    expansion contains unusually big partial quotients) which may occur
+    when studying sequences of increasing numbers. If the user cares more
+    on getting simple fractions, other methods may be more convenient.
+
+    """
+    p0, p1 = 0, 1
+    q0, q1 = 1, 0
+    a = floor(x)
+    while a < maxcoeff or q1==0:
+        p = a*p1 + p0
+        q = a*q1 + q0
+        p0, p1 = p1, p
+        q0, q1 = q1, q
+        if x==a: break
+        x = 1/(x-a)
+        a = floor(x)
+    return sympify(p) / q
+
+
+@public
+def guess_generating_function_rational(v, X=Symbol('x')):
+    """
+    Tries to "guess" a rational generating function for a sequence of rational
+    numbers v.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import guess_generating_function_rational
+    >>> from sympy import fibonacci
+    >>> l = [fibonacci(k) for k in range(5,15)]
+    >>> guess_generating_function_rational(l)
+    (3*x + 5)/(-x**2 - x + 1)
+
+    See Also
+    ========
+
+    sympy.series.approximants
+    mpmath.pade
+
+    """
+    #   a) compute the denominator as q
+    q = find_simple_recurrence_vector(v)
+    n = len(q)
+    if n <= 1: return None
+    #   b) compute the numerator as p
+    p = [sum(v[i-k]*q[k] for k in range(min(i+1, n)))
+            for i in range(len(v)>>1)]
+    return (sum(p[k]*X**k for k in range(len(p)))
+            / sum(q[k]*X**k for k in range(n)))
+
+
+@public
+def guess_generating_function(v, X=Symbol('x'), types=['all'], maxsqrtn=2):
+    """
+    Tries to "guess" a generating function for a sequence of rational numbers v.
+    Only a few patterns are implemented yet.
+
+    Explanation
+    ===========
+
+    The function returns a dictionary where keys are the name of a given type of
+    generating function. Six types are currently implemented:
+
+         type  |  formal definition
+        -------+----------------------------------------------------------------
+        ogf    | f(x) = Sum(            a_k * x^k       ,  k: 0..infinity )
+        egf    | f(x) = Sum(            a_k * x^k / k!  ,  k: 0..infinity )
+        lgf    | f(x) = Sum( (-1)^(k+1) a_k * x^k / k   ,  k: 1..infinity )
+               |        (with initial index being hold as 1 rather than 0)
+        hlgf   | f(x) = Sum(            a_k * x^k / k   ,  k: 1..infinity )
+               |        (with initial index being hold as 1 rather than 0)
+        lgdogf | f(x) = derivate( log(Sum( a_k * x^k, k: 0..infinity )), x)
+        lgdegf | f(x) = derivate( log(Sum( a_k * x^k / k!, k: 0..infinity )), x)
+
+    In order to spare time, the user can select only some types of generating
+    functions (default being ['all']). While forgetting to use a list in the
+    case of a single type may seem to work most of the time as in: types='ogf'
+    this (convenient) syntax may lead to unexpected extra results in some cases.
+
+    Discarding a type when calling the function does not mean that the type will
+    not be present in the returned dictionary; it only means that no extra
+    computation will be performed for that type, but the function may still add
+    it in the result when it can be easily converted from another type.
+
+    Two generating functions (lgdogf and lgdegf) are not even computed if the
+    initial term of the sequence is 0; it may be useful in that case to try
+    again after having removed the leading zeros.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import guess_generating_function as ggf
+    >>> ggf([k+1 for k in range(12)], types=['ogf', 'lgf', 'hlgf'])
+    {'hlgf': 1/(1 - x), 'lgf': 1/(x + 1), 'ogf': 1/(x**2 - 2*x + 1)}
+
+    >>> from sympy import sympify
+    >>> l = sympify("[3/2, 11/2, 0, -121/2, -363/2, 121]")
+    >>> ggf(l)
+    {'ogf': (x + 3/2)/(11*x**2 - 3*x + 1)}
+
+    >>> from sympy import fibonacci
+    >>> ggf([fibonacci(k) for k in range(5, 15)], types=['ogf'])
+    {'ogf': (3*x + 5)/(-x**2 - x + 1)}
+
+    >>> from sympy import factorial
+    >>> ggf([factorial(k) for k in range(12)], types=['ogf', 'egf', 'lgf'])
+    {'egf': 1/(1 - x)}
+
+    >>> ggf([k+1 for k in range(12)], types=['egf'])
+    {'egf': (x + 1)*exp(x), 'lgdegf': (x + 2)/(x + 1)}
+
+    N-th root of a rational function can also be detected (below is an example
+    coming from the sequence A108626 from https://oeis.org).
+    The greatest n-th root to be tested is specified as maxsqrtn (default 2).
+
+    >>> ggf([1, 2, 5, 14, 41, 124, 383, 1200, 3799, 12122, 38919])['ogf']
+    sqrt(1/(x**4 + 2*x**2 - 4*x + 1))
+
+    References
+    ==========
+
+    .. [1] "Concrete Mathematics", R.L. Graham, D.E. Knuth, O. Patashnik
+    .. [2] https://oeis.org/wiki/Generating_functions
+
+    """
+    # List of all types of all g.f. known by the algorithm
+    if 'all' in types:
+        types = ('ogf', 'egf', 'lgf', 'hlgf', 'lgdogf', 'lgdegf')
+
+    result = {}
+
+    # Ordinary Generating Function (ogf)
+    if 'ogf' in types:
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(v) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*v[i] for i in range(n+1)) for n in range(len(v))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['ogf'] = g**Rational(1, d+1)
+                break
+
+    # Exponential Generating Function (egf)
+    if 'egf' in types:
+        # Transform sequence (division by factorial)
+        w, f = [], S.One
+        for i, k in enumerate(v):
+            f *= i if i else 1
+            w.append(k/f)
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['egf'] = g**Rational(1, d+1)
+                break
+
+    # Logarithmic Generating Function (lgf)
+    if 'lgf' in types:
+        # Transform sequence (multiplication by (-1)^(n+1) / n)
+        w, f = [], S.NegativeOne
+        for i, k in enumerate(v):
+            f = -f
+            w.append(f*k/Integer(i+1))
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['lgf'] = g**Rational(1, d+1)
+                break
+
+    # Hyperbolic logarithmic Generating Function (hlgf)
+    if 'hlgf' in types:
+        # Transform sequence (division by n+1)
+        w = []
+        for i, k in enumerate(v):
+            w.append(k/Integer(i+1))
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['hlgf'] = g**Rational(1, d+1)
+                break
+
+    # Logarithmic derivative of ordinary generating Function (lgdogf)
+    if v[0] != 0 and ('lgdogf' in types
+                       or ('ogf' in types and 'ogf' not in result)):
+        # Transform sequence by computing f'(x)/f(x)
+        # because log(f(x)) = integrate( f'(x)/f(x) )
+        a, w = sympify(v[0]), []
+        for n in range(len(v)-1):
+            w.append(
+               (v[n+1]*(n+1) - sum(w[-i-1]*v[i+1] for i in range(n)))/a)
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['lgdogf'] = g**Rational(1, d+1)
+                if 'ogf' not in result:
+                    result['ogf'] = exp(integrate(result['lgdogf'], X))
+                break
+
+    # Logarithmic derivative of exponential generating Function (lgdegf)
+    if v[0] != 0 and ('lgdegf' in types
+                       or ('egf' in types and 'egf' not in result)):
+        # Transform sequence / step 1 (division by factorial)
+        z, f = [], S.One
+        for i, k in enumerate(v):
+            f *= i if i else 1
+            z.append(k/f)
+        # Transform sequence / step 2 by computing f'(x)/f(x)
+        # because log(f(x)) = integrate( f'(x)/f(x) )
+        a, w = z[0], []
+        for n in range(len(z)-1):
+            w.append(
+               (z[n+1]*(n+1) - sum(w[-i-1]*z[i+1] for i in range(n)))/a)
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['lgdegf'] = g**Rational(1, d+1)
+                if 'egf' not in result:
+                    result['egf'] = exp(integrate(result['lgdegf'], X))
+                break
+
+    return result
+
+
+@public
+def guess(l, all=False, evaluate=True, niter=2, variables=None):
+    """
+    This function is adapted from the Rate.m package for Mathematica
+    written by Christian Krattenthaler.
+    It tries to guess a formula from a given sequence of rational numbers.
+
+    Explanation
+    ===========
+
+    In order to speed up the process, the 'all' variable is set to False by
+    default, stopping the computation as some results are returned during an
+    iteration; the variable can be set to True if more iterations are needed
+    (other formulas may be found; however they may be equivalent to the first
+    ones).
+
+    Another option is the 'evaluate' variable (default is True); setting it
+    to False will leave the involved products unevaluated.
+
+    By default, the number of iterations is set to 2 but a greater value (up
+    to len(l)-1) can be specified with the optional 'niter' variable.
+    More and more convoluted results are found when the order of the
+    iteration gets higher:
+
+      * first iteration returns polynomial or rational functions;
+      * second iteration returns products of rising factorials and their
+        inverses;
+      * third iteration returns products of products of rising factorials
+        and their inverses;
+      * etc.
+
+    The returned formulas contain symbols i0, i1, i2, ... where the main
+    variables is i0 (and auxiliary variables are i1, i2, ...). A list of
+    other symbols can be provided in the 'variables' option; the length of
+    the least should be the value of 'niter' (more is acceptable but only
+    the first symbols will be used); in this case, the main variable will be
+    the first symbol in the list.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import guess
+    >>> guess([1,2,6,24,120], evaluate=False)
+    [Product(i1 + 1, (i1, 1, i0 - 1))]
+
+    >>> from sympy import symbols
+    >>> r = guess([1,2,7,42,429,7436,218348,10850216], niter=4)
+    >>> i0 = symbols("i0")
+    >>> [r[0].subs(i0,n).doit() for n in range(1,10)]
+    [1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460]
+    """
+    if any(a==0 for a in l[:-1]):
+        return []
+    N = len(l)
+    niter = min(N-1, niter)
+    myprod = product if evaluate else Product
+    g = []
+    res = []
+    if variables is None:
+        symb = symbols('i:'+str(niter))
+    else:
+        symb = variables
+    for k, s in enumerate(symb):
+        g.append(l)
+        n, r = len(l), []
+        for i in range(n-2-1, -1, -1):
+            ri = rinterp(enumerate(g[k][:-1], start=1), i, X=s)
+            if ((denom(ri).subs({s:n}) != 0)
+                    and (ri.subs({s:n}) - g[k][-1] == 0)
+                    and ri not in r):
+              r.append(ri)
+        if r:
+            for i in range(k-1, -1, -1):
+                r = [g[i][0]
+                      * myprod(v, (symb[i+1], 1, symb[i]-1)) for v in r]
+            if not all: return r
+            res += r
+        l = [Rational(l[i+1], l[i]) for i in range(N-k-1)]
+    return res

env-llmeval/lib/python3.10/site-packages/sympy/concrete/products.py

@@ -0,0 +1,610 @@
+from typing import Tuple as tTuple
+
+from .expr_with_intlimits import ExprWithIntLimits
+from .summations import Sum, summation, _dummy_with_inherited_properties_concrete
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Derivative
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol
+from sympy.functions.combinatorial.factorials import RisingFactorial
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.polys import quo, roots
+
+
+class Product(ExprWithIntLimits):
+    r"""
+    Represents unevaluated products.
+
+    Explanation
+    ===========
+
+    ``Product`` represents a finite or infinite product, with the first
+    argument being the general form of terms in the series, and the second
+    argument being ``(dummy_variable, start, end)``, with ``dummy_variable``
+    taking all integer values from ``start`` through ``end``. In accordance
+    with long-standing mathematical convention, the end term is included in
+    the product.
+
+    Finite products
+    ===============
+
+    For finite products (and products with symbolic limits assumed to be finite)
+    we follow the analogue of the summation convention described by Karr [1],
+    especially definition 3 of section 1.4. The product:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i)
+
+    has *the obvious meaning* for `m < n`, namely:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = f(m) f(m+1) \cdot \ldots \cdot f(n-2) f(n-1)
+
+    with the upper limit value `f(n)` excluded. The product over an empty set is
+    one if and only if `m = n`:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = 1  \quad \mathrm{for} \quad  m = n
+
+    Finally, for all other products over empty sets we assume the following
+    definition:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = \frac{1}{\prod_{n \leq i < m} f(i)}  \quad \mathrm{for} \quad  m > n
+
+    It is important to note that above we define all products with the upper
+    limit being exclusive. This is in contrast to the usual mathematical notation,
+    but does not affect the product convention. Indeed we have:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = \prod_{i = m}^{n - 1} f(i)
+
+    where the difference in notation is intentional to emphasize the meaning,
+    with limits typeset on the top being inclusive.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, i, k, m, n, x
+    >>> from sympy import Product, oo
+    >>> Product(k, (k, 1, m))
+    Product(k, (k, 1, m))
+    >>> Product(k, (k, 1, m)).doit()
+    factorial(m)
+    >>> Product(k**2,(k, 1, m))
+    Product(k**2, (k, 1, m))
+    >>> Product(k**2,(k, 1, m)).doit()
+    factorial(m)**2
+
+    Wallis' product for pi:
+
+    >>> W = Product(2*i/(2*i-1) * 2*i/(2*i+1), (i, 1, oo))
+    >>> W
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo))
+
+    Direct computation currently fails:
+
+    >>> W.doit()
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo))
+
+    But we can approach the infinite product by a limit of finite products:
+
+    >>> from sympy import limit
+    >>> W2 = Product(2*i/(2*i-1)*2*i/(2*i+1), (i, 1, n))
+    >>> W2
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, n))
+    >>> W2e = W2.doit()
+    >>> W2e
+    4**n*factorial(n)**2/(2**(2*n)*RisingFactorial(1/2, n)*RisingFactorial(3/2, n))
+    >>> limit(W2e, n, oo)
+    pi/2
+
+    By the same formula we can compute sin(pi/2):
+
+    >>> from sympy import combsimp, pi, gamma, simplify
+    >>> P = pi * x * Product(1 - x**2/k**2, (k, 1, n))
+    >>> P = P.subs(x, pi/2)
+    >>> P
+    pi**2*Product(1 - pi**2/(4*k**2), (k, 1, n))/2
+    >>> Pe = P.doit()
+    >>> Pe
+    pi**2*RisingFactorial(1 - pi/2, n)*RisingFactorial(1 + pi/2, n)/(2*factorial(n)**2)
+    >>> limit(Pe, n, oo).gammasimp()
+    sin(pi**2/2)
+    >>> Pe.rewrite(gamma)
+    (-1)**n*pi**2*gamma(pi/2)*gamma(n + 1 + pi/2)/(2*gamma(1 + pi/2)*gamma(-n + pi/2)*gamma(n + 1)**2)
+
+    Products with the lower limit being larger than the upper one:
+
+    >>> Product(1/i, (i, 6, 1)).doit()
+    120
+    >>> Product(i, (i, 2, 5)).doit()
+    120
+
+    The empty product:
+
+    >>> Product(i, (i, n, n-1)).doit()
+    1
+
+    An example showing that the symbolic result of a product is still
+    valid for seemingly nonsensical values of the limits. Then the Karr
+    convention allows us to give a perfectly valid interpretation to
+    those products by interchanging the limits according to the above rules:
+
+    >>> P = Product(2, (i, 10, n)).doit()
+    >>> P
+    2**(n - 9)
+    >>> P.subs(n, 5)
+    1/16
+    >>> Product(2, (i, 10, 5)).doit()
+    1/16
+    >>> 1/Product(2, (i, 6, 9)).doit()
+    1/16
+
+    An explicit example of the Karr summation convention applied to products:
+
+    >>> P1 = Product(x, (i, a, b)).doit()
+    >>> P1
+    x**(-a + b + 1)
+    >>> P2 = Product(x, (i, b+1, a-1)).doit()
+    >>> P2
+    x**(a - b - 1)
+    >>> simplify(P1 * P2)
+    1
+
+    And another one:
+
+    >>> P1 = Product(i, (i, b, a)).doit()
+    >>> P1
+    RisingFactorial(b, a - b + 1)
+    >>> P2 = Product(i, (i, a+1, b-1)).doit()
+    >>> P2
+    RisingFactorial(a + 1, -a + b - 1)
+    >>> P1 * P2
+    RisingFactorial(b, a - b + 1)*RisingFactorial(a + 1, -a + b - 1)
+    >>> combsimp(P1 * P2)
+    1
+
+    See Also
+    ========
+
+    Sum, summation
+    product
+
+    References
+    ==========
+
+    .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+           Volume 28 Issue 2, April 1981, Pages 305-350
+           https://dl.acm.org/doi/10.1145/322248.322255
+    .. [2] https://en.wikipedia.org/wiki/Multiplication#Capital_Pi_notation
+    .. [3] https://en.wikipedia.org/wiki/Empty_product
+    """
+
+    __slots__ = ()
+
+    limits: tTuple[tTuple[Symbol, Expr, Expr]]
+
+    def __new__(cls, function, *symbols, **assumptions):
+        obj = ExprWithIntLimits.__new__(cls, function, *symbols, **assumptions)
+        return obj
+
+    def _eval_rewrite_as_Sum(self, *args, **kwargs):
+        return exp(Sum(log(self.function), *self.limits))
+
+    @property
+    def term(self):
+        return self._args[0]
+    function = term
+
+    def _eval_is_zero(self):
+        if self.has_empty_sequence:
+            return False
+
+        z = self.term.is_zero
+        if z is True:
+            return True
+        if self.has_finite_limits:
+            # A Product is zero only if its term is zero assuming finite limits.
+            return z
+
+    def _eval_is_extended_real(self):
+        if self.has_empty_sequence:
+            return True
+
+        return self.function.is_extended_real
+
+    def _eval_is_positive(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_positive and self.has_finite_limits:
+            return True
+
+    def _eval_is_nonnegative(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_nonnegative and self.has_finite_limits:
+            return True
+
+    def _eval_is_extended_nonnegative(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_extended_nonnegative:
+            return True
+
+    def _eval_is_extended_nonpositive(self):
+        if self.has_empty_sequence:
+            return True
+
+    def _eval_is_finite(self):
+        if self.has_finite_limits and self.function.is_finite:
+            return True
+
+    def doit(self, **hints):
+        # first make sure any definite limits have product
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            d = _dummy_with_inherited_properties_concrete(xab)
+            if d:
+                reps[xab[0]] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            else:
+                did = did.xreplace(undo)
+            return did
+
+        from sympy.simplify.powsimp import powsimp
+        f = self.function
+        for index, limit in enumerate(self.limits):
+            i, a, b = limit
+            dif = b - a
+            if dif.is_integer and dif.is_negative:
+                a, b = b + 1, a - 1
+                f = 1 / f
+
+            g = self._eval_product(f, (i, a, b))
+            if g in (None, S.NaN):
+                return self.func(powsimp(f), *self.limits[index:])
+            else:
+                f = g
+
+        if hints.get('deep', True):
+            return f.doit(**hints)
+        else:
+            return powsimp(f)
+
+    def _eval_adjoint(self):
+        if self.is_commutative:
+            return self.func(self.function.adjoint(), *self.limits)
+        return None
+
+    def _eval_conjugate(self):
+        return self.func(self.function.conjugate(), *self.limits)
+
+    def _eval_product(self, term, limits):
+
+        (k, a, n) = limits
+
+        if k not in term.free_symbols:
+            if (term - 1).is_zero:
+                return S.One
+            return term**(n - a + 1)
+
+        if a == n:
+            return term.subs(k, a)
+
+        from .delta import deltaproduct, _has_simple_delta
+        if term.has(KroneckerDelta) and _has_simple_delta(term, limits[0]):
+            return deltaproduct(term, limits)
+
+        dif = n - a
+        definite = dif.is_Integer
+        if definite and (dif < 100):
+            return self._eval_product_direct(term, limits)
+
+        elif term.is_polynomial(k):
+            poly = term.as_poly(k)
+
+            A = B = Q = S.One
+
+            all_roots = roots(poly)
+
+            M = 0
+            for r, m in all_roots.items():
+                M += m
+                A *= RisingFactorial(a - r, n - a + 1)**m
+                Q *= (n - r)**m
+
+            if M < poly.degree():
+                arg = quo(poly, Q.as_poly(k))
+                B = self.func(arg, (k, a, n)).doit()
+
+            return poly.LC()**(n - a + 1) * A * B
+
+        elif term.is_Add:
+            factored = factor_terms(term, fraction=True)
+            if factored.is_Mul:
+                return self._eval_product(factored, (k, a, n))
+
+        elif term.is_Mul:
+            # Factor in part without the summation variable and part with
+            without_k, with_k = term.as_coeff_mul(k)
+
+            if len(with_k) >= 2:
+                # More than one term including k, so still a multiplication
+                exclude, include = [], []
+                for t in with_k:
+                    p = self._eval_product(t, (k, a, n))
+
+                    if p is not None:
+                        exclude.append(p)
+                    else:
+                        include.append(t)
+
+                if not exclude:
+                    return None
+                else:
+                    arg = term._new_rawargs(*include)
+                    A = Mul(*exclude)
+                    B = self.func(arg, (k, a, n)).doit()
+                    return without_k**(n - a + 1)*A * B
+            else:
+                # Just a single term
+                p = self._eval_product(with_k[0], (k, a, n))
+                if p is None:
+                    p = self.func(with_k[0], (k, a, n)).doit()
+                return without_k**(n - a + 1)*p
+
+
+        elif term.is_Pow:
+            if not term.base.has(k):
+                s = summation(term.exp, (k, a, n))
+
+                return term.base**s
+            elif not term.exp.has(k):
+                p = self._eval_product(term.base, (k, a, n))
+
+                if p is not None:
+                    return p**term.exp
+
+        elif isinstance(term, Product):
+            evaluated = term.doit()
+            f = self._eval_product(evaluated, limits)
+            if f is None:
+                return self.func(evaluated, limits)
+            else:
+                return f
+
+        if definite:
+            return self._eval_product_direct(term, limits)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import product_simplify
+        rv = product_simplify(self, **kwargs)
+        return rv.doit() if kwargs['doit'] else rv
+
+    def _eval_transpose(self):
+        if self.is_commutative:
+            return self.func(self.function.transpose(), *self.limits)
+        return None
+
+    def _eval_product_direct(self, term, limits):
+        (k, a, n) = limits
+        return Mul(*[term.subs(k, a + i) for i in range(n - a + 1)])
+
+    def _eval_derivative(self, x):
+        if isinstance(x, Symbol) and x not in self.free_symbols:
+            return S.Zero
+        f, limits = self.function, list(self.limits)
+        limit = limits.pop(-1)
+        if limits:
+            f = self.func(f, *limits)
+        i, a, b = limit
+        if x in a.free_symbols or x in b.free_symbols:
+            return None
+        h = Dummy()
+        rv = Sum( Product(f, (i, a, h - 1)) * Product(f, (i, h + 1, b)) * Derivative(f, x, evaluate=True).subs(i, h), (h, a, b))
+        return rv
+
+    def is_convergent(self):
+        r"""
+        See docs of :obj:`.Sum.is_convergent()` for explanation of convergence
+        in SymPy.
+
+        Explanation
+        ===========
+
+        The infinite product:
+
+        .. math::
+
+            \prod_{1 \leq i < \infty} f(i)
+
+        is defined by the sequence of partial products:
+
+        .. math::
+
+            \prod_{i=1}^{n} f(i) = f(1) f(2) \cdots f(n)
+
+        as n increases without bound. The product converges to a non-zero
+        value if and only if the sum:
+
+        .. math::
+
+            \sum_{1 \leq i < \infty} \log{f(n)}
+
+        converges.
+
+        Examples
+        ========
+
+        >>> from sympy import Product, Symbol, cos, pi, exp, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Product(n/(n + 1), (n, 1, oo)).is_convergent()
+        False
+        >>> Product(1/n**2, (n, 1, oo)).is_convergent()
+        False
+        >>> Product(cos(pi/n), (n, 1, oo)).is_convergent()
+        True
+        >>> Product(exp(-n**2), (n, 1, oo)).is_convergent()
+        False
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Infinite_product
+        """
+        sequence_term = self.function
+        log_sum = log(sequence_term)
+        lim = self.limits
+        try:
+            is_conv = Sum(log_sum, *lim).is_convergent()
+        except NotImplementedError:
+            if Sum(sequence_term - 1, *lim).is_absolutely_convergent() is S.true:
+                return S.true
+            raise NotImplementedError("The algorithm to find the product convergence of %s "
+                                        "is not yet implemented" % (sequence_term))
+        return is_conv
+
+    def reverse_order(expr, *indices):
+        """
+        Reverse the order of a limit in a Product.
+
+        Explanation
+        ===========
+
+        ``reverse_order(expr, *indices)`` reverses some limits in the expression
+        ``expr`` which can be either a ``Sum`` or a ``Product``. The selectors in
+        the argument ``indices`` specify some indices whose limits get reversed.
+        These selectors are either variable names or numerical indices counted
+        starting from the inner-most limit tuple.
+
+        Examples
+        ========
+
+        >>> from sympy import gamma, Product, simplify, Sum
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> P = Product(x, (x, a, b))
+        >>> Pr = P.reverse_order(x)
+        >>> Pr
+        Product(1/x, (x, b + 1, a - 1))
+        >>> Pr = Pr.doit()
+        >>> Pr
+        1/RisingFactorial(b + 1, a - b - 1)
+        >>> simplify(Pr.rewrite(gamma))
+        Piecewise((gamma(b + 1)/gamma(a), b > -1), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
+        >>> P = P.doit()
+        >>> P
+        RisingFactorial(a, -a + b + 1)
+        >>> simplify(P.rewrite(gamma))
+        Piecewise((gamma(b + 1)/gamma(a), a > 0), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
+
+        While one should prefer variable names when specifying which limits
+        to reverse, the index counting notation comes in handy in case there
+        are several symbols with the same name.
+
+        >>> S = Sum(x*y, (x, a, b), (y, c, d))
+        >>> S
+        Sum(x*y, (x, a, b), (y, c, d))
+        >>> S0 = S.reverse_order(0)
+        >>> S0
+        Sum(-x*y, (x, b + 1, a - 1), (y, c, d))
+        >>> S1 = S0.reverse_order(1)
+        >>> S1
+        Sum(x*y, (x, b + 1, a - 1), (y, d + 1, c - 1))
+
+        Of course we can mix both notations:
+
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index,
+        reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder
+
+        References
+        ==========
+
+        .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+               Volume 28 Issue 2, April 1981, Pages 305-350
+               https://dl.acm.org/doi/10.1145/322248.322255
+
+        """
+        l_indices = list(indices)
+
+        for i, indx in enumerate(l_indices):
+            if not isinstance(indx, int):
+                l_indices[i] = expr.index(indx)
+
+        e = 1
+        limits = []
+        for i, limit in enumerate(expr.limits):
+            l = limit
+            if i in l_indices:
+                e = -e
+                l = (limit[0], limit[2] + 1, limit[1] - 1)
+            limits.append(l)
+
+        return Product(expr.function ** e, *limits)
+
+
+def product(*args, **kwargs):
+    r"""
+    Compute the product.
+
+    Explanation
+    ===========
+
+    The notation for symbols is similar to the notation used in Sum or
+    Integral. product(f, (i, a, b)) computes the product of f with
+    respect to i from a to b, i.e.,
+
+    ::
+
+                                     b
+                                   _____
+        product(f(n), (i, a, b)) = |   | f(n)
+                                   |   |
+                                   i = a
+
+    If it cannot compute the product, it returns an unevaluated Product object.
+    Repeated products can be computed by introducing additional symbols tuples::
+
+    Examples
+    ========
+
+    >>> from sympy import product, symbols
+    >>> i, n, m, k = symbols('i n m k', integer=True)
+
+    >>> product(i, (i, 1, k))
+    factorial(k)
+    >>> product(m, (i, 1, k))
+    m**k
+    >>> product(i, (i, 1, k), (k, 1, n))
+    Product(factorial(k), (k, 1, n))
+
+    """
+
+    prod = Product(*args, **kwargs)
+
+    if isinstance(prod, Product):
+        return prod.doit(deep=False)
+    else:
+        return prod

env-llmeval/lib/python3.10/site-packages/sympy/concrete/summations.py

@@ -0,0 +1,1646 @@
+from typing import Tuple as tTuple
+
+from sympy.calculus.singularities import is_decreasing
+from sympy.calculus.accumulationbounds import AccumulationBounds
+from .expr_with_intlimits import ExprWithIntLimits
+from .expr_with_limits import AddWithLimits
+from .gosper import gosper_sum
+from sympy.core.expr import Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.function import Derivative, expand
+from sympy.core.mul import Mul
+from sympy.core.numbers import Float, _illegal
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, Wild, Symbol, symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cot, csc
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And
+from sympy.polys.partfrac import apart
+from sympy.polys.polyerrors import PolynomialError, PolificationFailed
+from sympy.polys.polytools import parallel_poly_from_expr, Poly, factor
+from sympy.polys.rationaltools import together
+from sympy.series.limitseq import limit_seq
+from sympy.series.order import O
+from sympy.series.residues import residue
+from sympy.sets.sets import FiniteSet, Interval
+from sympy.utilities.iterables import sift
+import itertools
+
+
+class Sum(AddWithLimits, ExprWithIntLimits):
+    r"""
+    Represents unevaluated summation.
+
+    Explanation
+    ===========
+
+    ``Sum`` represents a finite or infinite series, with the first argument
+    being the general form of terms in the series, and the second argument
+    being ``(dummy_variable, start, end)``, with ``dummy_variable`` taking
+    all integer values from ``start`` through ``end``. In accordance with
+    long-standing mathematical convention, the end term is included in the
+    summation.
+
+    Finite sums
+    ===========
+
+    For finite sums (and sums with symbolic limits assumed to be finite) we
+    follow the summation convention described by Karr [1], especially
+    definition 3 of section 1.4. The sum:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i)
+
+    has *the obvious meaning* for `m < n`, namely:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = f(m) + f(m+1) + \ldots + f(n-2) + f(n-1)
+
+    with the upper limit value `f(n)` excluded. The sum over an empty set is
+    zero if and only if `m = n`:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = 0  \quad \mathrm{for} \quad  m = n
+
+    Finally, for all other sums over empty sets we assume the following
+    definition:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = - \sum_{n \leq i < m} f(i)  \quad \mathrm{for} \quad  m > n
+
+    It is important to note that Karr defines all sums with the upper
+    limit being exclusive. This is in contrast to the usual mathematical notation,
+    but does not affect the summation convention. Indeed we have:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = \sum_{i = m}^{n - 1} f(i)
+
+    where the difference in notation is intentional to emphasize the meaning,
+    with limits typeset on the top being inclusive.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import i, k, m, n, x
+    >>> from sympy import Sum, factorial, oo, IndexedBase, Function
+    >>> Sum(k, (k, 1, m))
+    Sum(k, (k, 1, m))
+    >>> Sum(k, (k, 1, m)).doit()
+    m**2/2 + m/2
+    >>> Sum(k**2, (k, 1, m))
+    Sum(k**2, (k, 1, m))
+    >>> Sum(k**2, (k, 1, m)).doit()
+    m**3/3 + m**2/2 + m/6
+    >>> Sum(x**k, (k, 0, oo))
+    Sum(x**k, (k, 0, oo))
+    >>> Sum(x**k, (k, 0, oo)).doit()
+    Piecewise((1/(1 - x), Abs(x) < 1), (Sum(x**k, (k, 0, oo)), True))
+    >>> Sum(x**k/factorial(k), (k, 0, oo)).doit()
+    exp(x)
+
+    Here are examples to do summation with symbolic indices.  You
+    can use either Function of IndexedBase classes:
+
+    >>> f = Function('f')
+    >>> Sum(f(n), (n, 0, 3)).doit()
+    f(0) + f(1) + f(2) + f(3)
+    >>> Sum(f(n), (n, 0, oo)).doit()
+    Sum(f(n), (n, 0, oo))
+    >>> f = IndexedBase('f')
+    >>> Sum(f[n]**2, (n, 0, 3)).doit()
+    f[0]**2 + f[1]**2 + f[2]**2 + f[3]**2
+
+    An example showing that the symbolic result of a summation is still
+    valid for seemingly nonsensical values of the limits. Then the Karr
+    convention allows us to give a perfectly valid interpretation to
+    those sums by interchanging the limits according to the above rules:
+
+    >>> S = Sum(i, (i, 1, n)).doit()
+    >>> S
+    n**2/2 + n/2
+    >>> S.subs(n, -4)
+    6
+    >>> Sum(i, (i, 1, -4)).doit()
+    6
+    >>> Sum(-i, (i, -3, 0)).doit()
+    6
+
+    An explicit example of the Karr summation convention:
+
+    >>> S1 = Sum(i**2, (i, m, m+n-1)).doit()
+    >>> S1
+    m**2*n + m*n**2 - m*n + n**3/3 - n**2/2 + n/6
+    >>> S2 = Sum(i**2, (i, m+n, m-1)).doit()
+    >>> S2
+    -m**2*n - m*n**2 + m*n - n**3/3 + n**2/2 - n/6
+    >>> S1 + S2
+    0
+    >>> S3 = Sum(i, (i, m, m-1)).doit()
+    >>> S3
+    0
+
+    See Also
+    ========
+
+    summation
+    Product, sympy.concrete.products.product
+
+    References
+    ==========
+
+    .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+           Volume 28 Issue 2, April 1981, Pages 305-350
+           https://dl.acm.org/doi/10.1145/322248.322255
+    .. [2] https://en.wikipedia.org/wiki/Summation#Capital-sigma_notation
+    .. [3] https://en.wikipedia.org/wiki/Empty_sum
+    """
+
+    __slots__ = ()
+
+    limits: tTuple[tTuple[Symbol, Expr, Expr]]
+
+    def __new__(cls, function, *symbols, **assumptions):
+        obj = AddWithLimits.__new__(cls, function, *symbols, **assumptions)
+        if not hasattr(obj, 'limits'):
+            return obj
+        if any(len(l) != 3 or None in l for l in obj.limits):
+            raise ValueError('Sum requires values for lower and upper bounds.')
+
+        return obj
+
+    def _eval_is_zero(self):
+        # a Sum is only zero if its function is zero or if all terms
+        # cancel out. This only answers whether the summand is zero; if
+        # not then None is returned since we don't analyze whether all
+        # terms cancel out.
+        if self.function.is_zero or self.has_empty_sequence:
+            return True
+
+    def _eval_is_extended_real(self):
+        if self.has_empty_sequence:
+            return True
+        return self.function.is_extended_real
+
+    def _eval_is_positive(self):
+        if self.has_finite_limits and self.has_reversed_limits is False:
+            return self.function.is_positive
+
+    def _eval_is_negative(self):
+        if self.has_finite_limits and self.has_reversed_limits is False:
+            return self.function.is_negative
+
+    def _eval_is_finite(self):
+        if self.has_finite_limits and self.function.is_finite:
+            return True
+
+    def doit(self, **hints):
+        if hints.get('deep', True):
+            f = self.function.doit(**hints)
+        else:
+            f = self.function
+
+        # first make sure any definite limits have summation
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            d = _dummy_with_inherited_properties_concrete(xab)
+            if d:
+                reps[xab[0]] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            elif did is not None:
+                did = did.xreplace(undo)
+            else:
+                did = self
+            return did
+
+
+        if self.function.is_Matrix:
+            expanded = self.expand()
+            if self != expanded:
+                return expanded.doit()
+            return _eval_matrix_sum(self)
+
+        for n, limit in enumerate(self.limits):
+            i, a, b = limit
+            dif = b - a
+            if dif == -1:
+                # Any summation over an empty set is zero
+                return S.Zero
+            if dif.is_integer and dif.is_negative:
+                a, b = b + 1, a - 1
+                f = -f
+
+            newf = eval_sum(f, (i, a, b))
+            if newf is None:
+                if f == self.function:
+                    zeta_function = self.eval_zeta_function(f, (i, a, b))
+                    if zeta_function is not None:
+                        return zeta_function
+                    return self
+                else:
+                    return self.func(f, *self.limits[n:])
+            f = newf
+
+        if hints.get('deep', True):
+            # eval_sum could return partially unevaluated
+            # result with Piecewise.  In this case we won't
+            # doit() recursively.
+            if not isinstance(f, Piecewise):
+                return f.doit(**hints)
+
+        return f
+
+    def eval_zeta_function(self, f, limits):
+        """
+        Check whether the function matches with the zeta function.
+
+        If it matches, then return a `Piecewise` expression because
+        zeta function does not converge unless `s > 1` and `q > 0`
+        """
+        i, a, b = limits
+        w, y, z = Wild('w', exclude=[i]), Wild('y', exclude=[i]), Wild('z', exclude=[i])
+        result = f.match((w * i + y) ** (-z))
+        if result is not None and b is S.Infinity:
+            coeff = 1 / result[w] ** result[z]
+            s = result[z]
+            q = result[y] / result[w] + a
+            return Piecewise((coeff * zeta(s, q), And(q > 0, s > 1)), (self, True))
+
+    def _eval_derivative(self, x):
+        """
+        Differentiate wrt x as long as x is not in the free symbols of any of
+        the upper or lower limits.
+
+        Explanation
+        ===========
+
+        Sum(a*b*x, (x, 1, a)) can be differentiated wrt x or b but not `a`
+        since the value of the sum is discontinuous in `a`. In a case
+        involving a limit variable, the unevaluated derivative is returned.
+        """
+
+        # diff already confirmed that x is in the free symbols of self, but we
+        # don't want to differentiate wrt any free symbol in the upper or lower
+        # limits
+        # XXX remove this test for free_symbols when the default _eval_derivative is in
+        if isinstance(x, Symbol) and x not in self.free_symbols:
+            return S.Zero
+
+        # get limits and the function
+        f, limits = self.function, list(self.limits)
+
+        limit = limits.pop(-1)
+
+        if limits:  # f is the argument to a Sum
+            f = self.func(f, *limits)
+
+        _, a, b = limit
+        if x in a.free_symbols or x in b.free_symbols:
+            return None
+        df = Derivative(f, x, evaluate=True)
+        rv = self.func(df, limit)
+        return rv
+
+    def _eval_difference_delta(self, n, step):
+        k, _, upper = self.args[-1]
+        new_upper = upper.subs(n, n + step)
+
+        if len(self.args) == 2:
+            f = self.args[0]
+        else:
+            f = self.func(*self.args[:-1])
+
+        return Sum(f, (k, upper + 1, new_upper)).doit()
+
+    def _eval_simplify(self, **kwargs):
+
+        function = self.function
+
+        if kwargs.get('deep', True):
+            function = function.simplify(**kwargs)
+
+        # split the function into adds
+        terms = Add.make_args(expand(function))
+        s_t = [] # Sum Terms
+        o_t = [] # Other Terms
+
+        for term in terms:
+            if term.has(Sum):
+                # if there is an embedded sum here
+                # it is of the form x * (Sum(whatever))
+                # hence we make a Mul out of it, and simplify all interior sum terms
+                subterms = Mul.make_args(expand(term))
+                out_terms = []
+                for subterm in subterms:
+                    # go through each term
+                    if isinstance(subterm, Sum):
+                        # if it's a sum, simplify it
+                        out_terms.append(subterm._eval_simplify(**kwargs))
+                    else:
+                        # otherwise, add it as is
+                        out_terms.append(subterm)
+
+                # turn it back into a Mul
+                s_t.append(Mul(*out_terms))
+            else:
+                o_t.append(term)
+
+        # next try to combine any interior sums for further simplification
+        from sympy.simplify.simplify import factor_sum, sum_combine
+        result = Add(sum_combine(s_t), *o_t)
+
+        return factor_sum(result, limits=self.limits)
+
+    def is_convergent(self):
+        r"""
+        Checks for the convergence of a Sum.
+
+        Explanation
+        ===========
+
+        We divide the study of convergence of infinite sums and products in
+        two parts.
+
+        First Part:
+        One part is the question whether all the terms are well defined, i.e.,
+        they are finite in a sum and also non-zero in a product. Zero
+        is the analogy of (minus) infinity in products as
+        :math:`e^{-\infty} = 0`.
+
+        Second Part:
+        The second part is the question of convergence after infinities,
+        and zeros in products, have been omitted assuming that their number
+        is finite. This means that we only consider the tail of the sum or
+        product, starting from some point after which all terms are well
+        defined.
+
+        For example, in a sum of the form:
+
+        .. math::
+
+            \sum_{1 \leq i < \infty} \frac{1}{n^2 + an + b}
+
+        where a and b are numbers. The routine will return true, even if there
+        are infinities in the term sequence (at most two). An analogous
+        product would be:
+
+        .. math::
+
+            \prod_{1 \leq i < \infty} e^{\frac{1}{n^2 + an + b}}
+
+        This is how convergence is interpreted. It is concerned with what
+        happens at the limit. Finding the bad terms is another independent
+        matter.
+
+        Note: It is responsibility of user to see that the sum or product
+        is well defined.
+
+        There are various tests employed to check the convergence like
+        divergence test, root test, integral test, alternating series test,
+        comparison tests, Dirichlet tests. It returns true if Sum is convergent
+        and false if divergent and NotImplementedError if it cannot be checked.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Convergence_tests
+
+        Examples
+        ========
+
+        >>> from sympy import factorial, S, Sum, Symbol, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Sum(n/(n - 1), (n, 4, 7)).is_convergent()
+        True
+        >>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent()
+        False
+        >>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent()
+        False
+        >>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent()
+        True
+
+        See Also
+        ========
+
+        Sum.is_absolutely_convergent
+        sympy.concrete.products.Product.is_convergent
+        """
+        p, q, r = symbols('p q r', cls=Wild)
+
+        sym = self.limits[0][0]
+        lower_limit = self.limits[0][1]
+        upper_limit = self.limits[0][2]
+        sequence_term = self.function.simplify()
+
+        if len(sequence_term.free_symbols) > 1:
+            raise NotImplementedError("convergence checking for more than one symbol "
+                                      "containing series is not handled")
+
+        if lower_limit.is_finite and upper_limit.is_finite:
+            return S.true
+
+        # transform sym -> -sym and swap the upper_limit = S.Infinity
+        # and lower_limit = - upper_limit
+        if lower_limit is S.NegativeInfinity:
+            if upper_limit is S.Infinity:
+                return Sum(sequence_term, (sym, 0, S.Infinity)).is_convergent() and \
+                        Sum(sequence_term, (sym, S.NegativeInfinity, 0)).is_convergent()
+            from sympy.simplify.simplify import simplify
+            sequence_term = simplify(sequence_term.xreplace({sym: -sym}))
+            lower_limit = -upper_limit
+            upper_limit = S.Infinity
+
+        sym_ = Dummy(sym.name, integer=True, positive=True)
+        sequence_term = sequence_term.xreplace({sym: sym_})
+        sym = sym_
+
+        interval = Interval(lower_limit, upper_limit)
+
+        # Piecewise function handle
+        if sequence_term.is_Piecewise:
+            for func, cond in sequence_term.args:
+                # see if it represents something going to oo
+                if cond == True or cond.as_set().sup is S.Infinity:
+                    s = Sum(func, (sym, lower_limit, upper_limit))
+                    return s.is_convergent()
+            return S.true
+
+        ###  -------- Divergence test ----------- ###
+        try:
+           lim_val = limit_seq(sequence_term, sym)
+           if lim_val is not None and lim_val.is_zero is False:
+               return S.false
+        except NotImplementedError:
+            pass
+
+        try:
+            lim_val_abs = limit_seq(abs(sequence_term), sym)
+            if lim_val_abs is not None and lim_val_abs.is_zero is False:
+                return S.false
+        except NotImplementedError:
+            pass
+
+        order = O(sequence_term, (sym, S.Infinity))
+
+        ### --------- p-series test (1/n**p) ---------- ###
+        p_series_test = order.expr.match(sym**p)
+        if p_series_test is not None:
+            if p_series_test[p] < -1:
+                return S.true
+            if p_series_test[p] >= -1:
+                return S.false
+
+        ### ------------- comparison test ------------- ###
+        # 1/(n**p*log(n)**q*log(log(n))**r) comparison
+        n_log_test = (order.expr.match(1/(sym**p*log(1/sym)**q*log(-log(1/sym))**r)) or
+                      order.expr.match(1/(sym**p*(-log(1/sym))**q*log(-log(1/sym))**r)))
+        if n_log_test is not None:
+            if (n_log_test[p] > 1 or
+                (n_log_test[p] == 1 and n_log_test[q] > 1) or
+                (n_log_test[p] == n_log_test[q] == 1 and n_log_test[r] > 1)):
+                    return S.true
+            return S.false
+
+        ### ------------- Limit comparison test -----------###
+        # (1/n) comparison
+        try:
+            lim_comp = limit_seq(sym*sequence_term, sym)
+            if lim_comp is not None and lim_comp.is_number and lim_comp > 0:
+                return S.false
+        except NotImplementedError:
+            pass
+
+        ### ----------- ratio test ---------------- ###
+        next_sequence_term = sequence_term.xreplace({sym: sym + 1})
+        from sympy.simplify.combsimp import combsimp
+        from sympy.simplify.powsimp import powsimp
+        ratio = combsimp(powsimp(next_sequence_term/sequence_term))
+        try:
+            lim_ratio = limit_seq(ratio, sym)
+            if lim_ratio is not None and lim_ratio.is_number:
+                if abs(lim_ratio) > 1:
+                    return S.false
+                if abs(lim_ratio) < 1:
+                    return S.true
+        except NotImplementedError:
+            lim_ratio = None
+
+        ### ---------- Raabe's test -------------- ###
+        if lim_ratio == 1:  # ratio test inconclusive
+            test_val = sym*(sequence_term/
+                         sequence_term.subs(sym, sym + 1) - 1)
+            test_val = test_val.gammasimp()
+            try:
+                lim_val = limit_seq(test_val, sym)
+                if lim_val is not None and lim_val.is_number:
+                    if lim_val > 1:
+                        return S.true
+                    if lim_val < 1:
+                        return S.false
+            except NotImplementedError:
+                pass
+
+        ### ----------- root test ---------------- ###
+        # lim = Limit(abs(sequence_term)**(1/sym), sym, S.Infinity)
+        try:
+            lim_evaluated = limit_seq(abs(sequence_term)**(1/sym), sym)
+            if lim_evaluated is not None and lim_evaluated.is_number:
+                if lim_evaluated < 1:
+                    return S.true
+                if lim_evaluated > 1:
+                    return S.false
+        except NotImplementedError:
+            pass
+
+        ### ------------- alternating series test ----------- ###
+        dict_val = sequence_term.match(S.NegativeOne**(sym + p)*q)
+        if not dict_val[p].has(sym) and is_decreasing(dict_val[q], interval):
+            return S.true
+
+        ### ------------- integral test -------------- ###
+        check_interval = None
+        from sympy.solvers.solveset import solveset
+        maxima = solveset(sequence_term.diff(sym), sym, interval)
+        if not maxima:
+            check_interval = interval
+        elif isinstance(maxima, FiniteSet) and maxima.sup.is_number:
+            check_interval = Interval(maxima.sup, interval.sup)
+        if (check_interval is not None and
+            (is_decreasing(sequence_term, check_interval) or
+            is_decreasing(-sequence_term, check_interval))):
+                integral_val = Integral(
+                    sequence_term, (sym, lower_limit, upper_limit))
+                try:
+                    integral_val_evaluated = integral_val.doit()
+                    if integral_val_evaluated.is_number:
+                        return S(integral_val_evaluated.is_finite)
+                except NotImplementedError:
+                    pass
+
+        ### ----- Dirichlet and bounded times convergent tests ----- ###
+        # TODO
+        #
+        # Dirichlet_test
+        # https://en.wikipedia.org/wiki/Dirichlet%27s_test
+        #
+        # Bounded times convergent test
+        # It is based on comparison theorems for series.
+        # In particular, if the general term of a series can
+        # be written as a product of two terms a_n and b_n
+        # and if a_n is bounded and if Sum(b_n) is absolutely
+        # convergent, then the original series Sum(a_n * b_n)
+        # is absolutely convergent and so convergent.
+        #
+        # The following code can grows like 2**n where n is the
+        # number of args in order.expr
+        # Possibly combined with the potentially slow checks
+        # inside the loop, could make this test extremely slow
+        # for larger summation expressions.
+
+        if order.expr.is_Mul:
+            args = order.expr.args
+            argset = set(args)
+
+            ### -------------- Dirichlet tests -------------- ###
+            m = Dummy('m', integer=True)
+            def _dirichlet_test(g_n):
+                try:
+                    ing_val = limit_seq(Sum(g_n, (sym, interval.inf, m)).doit(), m)
+                    if ing_val is not None and ing_val.is_finite:
+                        return S.true
+                except NotImplementedError:
+                    pass
+
+            ### -------- bounded times convergent test ---------###
+            def _bounded_convergent_test(g1_n, g2_n):
+                try:
+                    lim_val = limit_seq(g1_n, sym)
+                    if lim_val is not None and (lim_val.is_finite or (
+                        isinstance(lim_val, AccumulationBounds)
+                        and (lim_val.max - lim_val.min).is_finite)):
+                            if Sum(g2_n, (sym, lower_limit, upper_limit)).is_absolutely_convergent():
+                                return S.true
+                except NotImplementedError:
+                    pass
+
+            for n in range(1, len(argset)):
+                for a_tuple in itertools.combinations(args, n):
+                    b_set = argset - set(a_tuple)
+                    a_n = Mul(*a_tuple)
+                    b_n = Mul(*b_set)
+
+                    if is_decreasing(a_n, interval):
+                        dirich = _dirichlet_test(b_n)
+                        if dirich is not None:
+                            return dirich
+
+                    bc_test = _bounded_convergent_test(a_n, b_n)
+                    if bc_test is not None:
+                        return bc_test
+
+        _sym = self.limits[0][0]
+        sequence_term = sequence_term.xreplace({sym: _sym})
+        raise NotImplementedError("The algorithm to find the Sum convergence of %s "
+                                  "is not yet implemented" % (sequence_term))
+
+    def is_absolutely_convergent(self):
+        """
+        Checks for the absolute convergence of an infinite series.
+
+        Same as checking convergence of absolute value of sequence_term of
+        an infinite series.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Absolute_convergence
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Symbol, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent()
+        False
+        >>> Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent()
+        True
+
+        See Also
+        ========
+
+        Sum.is_convergent
+        """
+        return Sum(abs(self.function), self.limits).is_convergent()
+
+    def euler_maclaurin(self, m=0, n=0, eps=0, eval_integral=True):
+        """
+        Return an Euler-Maclaurin approximation of self, where m is the
+        number of leading terms to sum directly and n is the number of
+        terms in the tail.
+
+        With m = n = 0, this is simply the corresponding integral
+        plus a first-order endpoint correction.
+
+        Returns (s, e) where s is the Euler-Maclaurin approximation
+        and e is the estimated error (taken to be the magnitude of
+        the first omitted term in the tail):
+
+            >>> from sympy.abc import k, a, b
+            >>> from sympy import Sum
+            >>> Sum(1/k, (k, 2, 5)).doit().evalf()
+            1.28333333333333
+            >>> s, e = Sum(1/k, (k, 2, 5)).euler_maclaurin()
+            >>> s
+            -log(2) + 7/20 + log(5)
+            >>> from sympy import sstr
+            >>> print(sstr((s.evalf(), e.evalf()), full_prec=True))
+            (1.26629073187415, 0.0175000000000000)
+
+        The endpoints may be symbolic:
+
+            >>> s, e = Sum(1/k, (k, a, b)).euler_maclaurin()
+            >>> s
+            -log(a) + log(b) + 1/(2*b) + 1/(2*a)
+            >>> e
+            Abs(1/(12*b**2) - 1/(12*a**2))
+
+        If the function is a polynomial of degree at most 2n+1, the
+        Euler-Maclaurin formula becomes exact (and e = 0 is returned):
+
+            >>> Sum(k, (k, 2, b)).euler_maclaurin()
+            (b**2/2 + b/2 - 1, 0)
+            >>> Sum(k, (k, 2, b)).doit()
+            b**2/2 + b/2 - 1
+
+        With a nonzero eps specified, the summation is ended
+        as soon as the remainder term is less than the epsilon.
+        """
+        m = int(m)
+        n = int(n)
+        f = self.function
+        if len(self.limits) != 1:
+            raise ValueError("More than 1 limit")
+        i, a, b = self.limits[0]
+        if (a > b) == True:
+            if a - b == 1:
+                return S.Zero, S.Zero
+            a, b = b + 1, a - 1
+            f = -f
+        s = S.Zero
+        if m:
+            if b.is_Integer and a.is_Integer:
+                m = min(m, b - a + 1)
+            if not eps or f.is_polynomial(i):
+                s = Add(*[f.subs(i, a + k) for k in range(m)])
+            else:
+                term = f.subs(i, a)
+                if term:
+                    test = abs(term.evalf(3)) < eps
+                    if test == True:
+                        return s, abs(term)
+                    elif not (test == False):
+                        # a symbolic Relational class, can't go further
+                        return term, S.Zero
+                s = term
+                for k in range(1, m):
+                    term = f.subs(i, a + k)
+                    if abs(term.evalf(3)) < eps and term != 0:
+                        return s, abs(term)
+                    s += term
+            if b - a + 1 == m:
+                return s, S.Zero
+            a += m
+        x = Dummy('x')
+        I = Integral(f.subs(i, x), (x, a, b))
+        if eval_integral:
+            I = I.doit()
+        s += I
+
+        def fpoint(expr):
+            if b is S.Infinity:
+                return expr.subs(i, a), 0
+            return expr.subs(i, a), expr.subs(i, b)
+        fa, fb = fpoint(f)
+        iterm = (fa + fb)/2
+        g = f.diff(i)
+        for k in range(1, n + 2):
+            ga, gb = fpoint(g)
+            term = bernoulli(2*k)/factorial(2*k)*(gb - ga)
+            if k > n:
+                break
+            if eps and term:
+                term_evalf = term.evalf(3)
+                if term_evalf is S.NaN:
+                    return S.NaN, S.NaN
+                if abs(term_evalf) < eps:
+                    break
+            s += term
+            g = g.diff(i, 2, simplify=False)
+        return s + iterm, abs(term)
+
+
+    def reverse_order(self, *indices):
+        """
+        Reverse the order of a limit in a Sum.
+
+        Explanation
+        ===========
+
+        ``reverse_order(self, *indices)`` reverses some limits in the expression
+        ``self`` which can be either a ``Sum`` or a ``Product``. The selectors in
+        the argument ``indices`` specify some indices whose limits get reversed.
+        These selectors are either variable names or numerical indices counted
+        starting from the inner-most limit tuple.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, y, a, b, c, d
+
+        >>> Sum(x, (x, 0, 3)).reverse_order(x)
+        Sum(-x, (x, 4, -1))
+        >>> Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(x, y)
+        Sum(x*y, (x, 6, 0), (y, 7, -1))
+        >>> Sum(x, (x, a, b)).reverse_order(x)
+        Sum(-x, (x, b + 1, a - 1))
+        >>> Sum(x, (x, a, b)).reverse_order(0)
+        Sum(-x, (x, b + 1, a - 1))
+
+        While one should prefer variable names when specifying which limits
+        to reverse, the index counting notation comes in handy in case there
+        are several symbols with the same name.
+
+        >>> S = Sum(x**2, (x, a, b), (x, c, d))
+        >>> S
+        Sum(x**2, (x, a, b), (x, c, d))
+        >>> S0 = S.reverse_order(0)
+        >>> S0
+        Sum(-x**2, (x, b + 1, a - 1), (x, c, d))
+        >>> S1 = S0.reverse_order(1)
+        >>> S1
+        Sum(x**2, (x, b + 1, a - 1), (x, d + 1, c - 1))
+
+        Of course we can mix both notations:
+
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder
+
+        References
+        ==========
+
+        .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+               Volume 28 Issue 2, April 1981, Pages 305-350
+               https://dl.acm.org/doi/10.1145/322248.322255
+        """
+        l_indices = list(indices)
+
+        for i, indx in enumerate(l_indices):
+            if not isinstance(indx, int):
+                l_indices[i] = self.index(indx)
+
+        e = 1
+        limits = []
+        for i, limit in enumerate(self.limits):
+            l = limit
+            if i in l_indices:
+                e = -e
+                l = (limit[0], limit[2] + 1, limit[1] - 1)
+            limits.append(l)
+
+        return Sum(e * self.function, *limits)
+
+    def _eval_rewrite_as_Product(self, *args, **kwargs):
+        from sympy.concrete.products import Product
+        if self.function.is_extended_real:
+            return log(Product(exp(self.function), *self.limits))
+
+
+def summation(f, *symbols, **kwargs):
+    r"""
+    Compute the summation of f with respect to symbols.
+
+    Explanation
+    ===========
+
+    The notation for symbols is similar to the notation used in Integral.
+    summation(f, (i, a, b)) computes the sum of f with respect to i from a to b,
+    i.e.,
+
+    ::
+
+                                    b
+                                  ____
+                                  \   `
+        summation(f, (i, a, b)) =  )    f
+                                  /___,
+                                  i = a
+
+    If it cannot compute the sum, it returns an unevaluated Sum object.
+    Repeated sums can be computed by introducing additional symbols tuples::
+
+    Examples
+    ========
+
+    >>> from sympy import summation, oo, symbols, log
+    >>> i, n, m = symbols('i n m', integer=True)
+
+    >>> summation(2*i - 1, (i, 1, n))
+    n**2
+    >>> summation(1/2**i, (i, 0, oo))
+    2
+    >>> summation(1/log(n)**n, (n, 2, oo))
+    Sum(log(n)**(-n), (n, 2, oo))
+    >>> summation(i, (i, 0, n), (n, 0, m))
+    m**3/6 + m**2/2 + m/3
+
+    >>> from sympy.abc import x
+    >>> from sympy import factorial
+    >>> summation(x**n/factorial(n), (n, 0, oo))
+    exp(x)
+
+    See Also
+    ========
+
+    Sum
+    Product, sympy.concrete.products.product
+
+    """
+    return Sum(f, *symbols, **kwargs).doit(deep=False)
+
+
+def telescopic_direct(L, R, n, limits):
+    """
+    Returns the direct summation of the terms of a telescopic sum
+
+    Explanation
+    ===========
+
+    L is the term with lower index
+    R is the term with higher index
+    n difference between the indexes of L and R
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.summations import telescopic_direct
+    >>> from sympy.abc import k, a, b
+    >>> telescopic_direct(1/k, -1/(k+2), 2, (k, a, b))
+    -1/(b + 2) - 1/(b + 1) + 1/(a + 1) + 1/a
+
+    """
+    (i, a, b) = limits
+    return Add(*[L.subs(i, a + m) + R.subs(i, b - m) for m in range(n)])
+
+
+def telescopic(L, R, limits):
+    '''
+    Tries to perform the summation using the telescopic property.
+
+    Return None if not possible.
+    '''
+    (i, a, b) = limits
+    if L.is_Add or R.is_Add:
+        return None
+
+    # We want to solve(L.subs(i, i + m) + R, m)
+    # First we try a simple match since this does things that
+    # solve doesn't do, e.g. solve(cos(k+m)-cos(k), m) gives
+    # a more complicated solution than m == 0.
+
+    k = Wild("k")
+    sol = (-R).match(L.subs(i, i + k))
+    s = None
+    if sol and k in sol:
+        s = sol[k]
+        if not (s.is_Integer and L.subs(i, i + s) + R == 0):
+            # invalid match or match didn't work
+            s = None
+
+    # But there are things that match doesn't do that solve
+    # can do, e.g. determine that 1/(x + m) = 1/(1 - x) when m = 1
+
+    if s is None:
+        m = Dummy('m')
+        try:
+            from sympy.solvers.solvers import solve
+            sol = solve(L.subs(i, i + m) + R, m) or []
+        except NotImplementedError:
+            return None
+        sol = [si for si in sol if si.is_Integer and
+               (L.subs(i, i + si) + R).expand().is_zero]
+        if len(sol) != 1:
+            return None
+        s = sol[0]
+
+    if s < 0:
+        return telescopic_direct(R, L, abs(s), (i, a, b))
+    elif s > 0:
+        return telescopic_direct(L, R, s, (i, a, b))
+
+
+def eval_sum(f, limits):
+    (i, a, b) = limits
+    if f.is_zero:
+        return S.Zero
+    if i not in f.free_symbols:
+        return f*(b - a + 1)
+    if a == b:
+        return f.subs(i, a)
+    if isinstance(f, Piecewise):
+        if not any(i in arg.args[1].free_symbols for arg in f.args):
+            # Piecewise conditions do not depend on the dummy summation variable,
+            # therefore we can fold:     Sum(Piecewise((e, c), ...), limits)
+            #                        --> Piecewise((Sum(e, limits), c), ...)
+            newargs = []
+            for arg in f.args:
+                newexpr = eval_sum(arg.expr, limits)
+                if newexpr is None:
+                    return None
+                newargs.append((newexpr, arg.cond))
+            return f.func(*newargs)
+
+    if f.has(KroneckerDelta):
+        from .delta import deltasummation, _has_simple_delta
+        f = f.replace(
+            lambda x: isinstance(x, Sum),
+            lambda x: x.factor()
+        )
+        if _has_simple_delta(f, limits[0]):
+            return deltasummation(f, limits)
+
+    dif = b - a
+    definite = dif.is_Integer
+    # Doing it directly may be faster if there are very few terms.
+    if definite and (dif < 100):
+        return eval_sum_direct(f, (i, a, b))
+    if isinstance(f, Piecewise):
+        return None
+    # Try to do it symbolically. Even when the number of terms is
+    # known, this can save time when b-a is big.
+    value = eval_sum_symbolic(f.expand(), (i, a, b))
+    if value is not None:
+        return value
+    # Do it directly
+    if definite:
+        return eval_sum_direct(f, (i, a, b))
+
+
+def eval_sum_direct(expr, limits):
+    """
+    Evaluate expression directly, but perform some simple checks first
+    to possibly result in a smaller expression and faster execution.
+    """
+    (i, a, b) = limits
+
+    dif = b - a
+    # Linearity
+    if expr.is_Mul:
+        # Try factor out everything not including i
+        without_i, with_i = expr.as_independent(i)
+        if without_i != 1:
+            s = eval_sum_direct(with_i, (i, a, b))
+            if s:
+                r = without_i*s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = expr.as_two_terms()
+
+            if not L.has(i):
+                sR = eval_sum_direct(R, (i, a, b))
+                if sR:
+                    return L*sR
+
+            if not R.has(i):
+                sL = eval_sum_direct(L, (i, a, b))
+                if sL:
+                    return sL*R
+
+    # do this whether its an Add or Mul
+    # e.g. apart(1/(25*i**2 + 45*i + 14)) and
+    # apart(1/((5*i + 2)*(5*i + 7))) ->
+    # -1/(5*(5*i + 7)) + 1/(5*(5*i + 2))
+    try:
+        expr = apart(expr, i)  # see if it becomes an Add
+    except PolynomialError:
+        pass
+
+    if expr.is_Add:
+        # Try factor out everything not including i
+        without_i, with_i = expr.as_independent(i)
+        if without_i != 0:
+            s = eval_sum_direct(with_i, (i, a, b))
+            if s:
+                r = without_i*(dif + 1) + s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = expr.as_two_terms()
+            lsum = eval_sum_direct(L, (i, a, b))
+            rsum = eval_sum_direct(R, (i, a, b))
+
+            if None not in (lsum, rsum):
+                r = lsum + rsum
+                if r is not S.NaN:
+                    return r
+
+    return Add(*[expr.subs(i, a + j) for j in range(dif + 1)])
+
+
+def eval_sum_symbolic(f, limits):
+    f_orig = f
+    (i, a, b) = limits
+    if not f.has(i):
+        return f*(b - a + 1)
+
+    # Linearity
+    if f.is_Mul:
+        # Try factor out everything not including i
+        without_i, with_i = f.as_independent(i)
+        if without_i != 1:
+            s = eval_sum_symbolic(with_i, (i, a, b))
+            if s:
+                r = without_i*s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = f.as_two_terms()
+
+            if not L.has(i):
+                sR = eval_sum_symbolic(R, (i, a, b))
+                if sR:
+                    return L*sR
+
+            if not R.has(i):
+                sL = eval_sum_symbolic(L, (i, a, b))
+                if sL:
+                    return sL*R
+
+    # do this whether its an Add or Mul
+    # e.g. apart(1/(25*i**2 + 45*i + 14)) and
+    # apart(1/((5*i + 2)*(5*i + 7))) ->
+    # -1/(5*(5*i + 7)) + 1/(5*(5*i + 2))
+    try:
+        f = apart(f, i)
+    except PolynomialError:
+        pass
+
+    if f.is_Add:
+        L, R = f.as_two_terms()
+        lrsum = telescopic(L, R, (i, a, b))
+
+        if lrsum:
+            return lrsum
+
+        # Try factor out everything not including i
+        without_i, with_i = f.as_independent(i)
+        if without_i != 0:
+            s = eval_sum_symbolic(with_i, (i, a, b))
+            if s:
+                r = without_i*(b - a + 1) + s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            lsum = eval_sum_symbolic(L, (i, a, b))
+            rsum = eval_sum_symbolic(R, (i, a, b))
+
+            if None not in (lsum, rsum):
+                r = lsum + rsum
+                if r is not S.NaN:
+                    return r
+
+
+    # Polynomial terms with Faulhaber's formula
+    n = Wild('n')
+    result = f.match(i**n)
+
+    if result is not None:
+        n = result[n]
+
+        if n.is_Integer:
+            if n >= 0:
+                if (b is S.Infinity and a is not S.NegativeInfinity) or \
+                   (a is S.NegativeInfinity and b is not S.Infinity):
+                    return S.Infinity
+                return ((bernoulli(n + 1, b + 1) - bernoulli(n + 1, a))/(n + 1)).expand()
+            elif a.is_Integer and a >= 1:
+                if n == -1:
+                    return harmonic(b) - harmonic(a - 1)
+                else:
+                    return harmonic(b, abs(n)) - harmonic(a - 1, abs(n))
+
+    if not (a.has(S.Infinity, S.NegativeInfinity) or
+            b.has(S.Infinity, S.NegativeInfinity)):
+        # Geometric terms
+        c1 = Wild('c1', exclude=[i])
+        c2 = Wild('c2', exclude=[i])
+        c3 = Wild('c3', exclude=[i])
+        wexp = Wild('wexp')
+
+        # Here we first attempt powsimp on f for easier matching with the
+        # exponential pattern, and attempt expansion on the exponent for easier
+        # matching with the linear pattern.
+        e = f.powsimp().match(c1 ** wexp)
+        if e is not None:
+            e_exp = e.pop(wexp).expand().match(c2*i + c3)
+            if e_exp is not None:
+                e.update(e_exp)
+
+                p = (c1**c3).subs(e)
+                q = (c1**c2).subs(e)
+                r = p*(q**a - q**(b + 1))/(1 - q)
+                l = p*(b - a + 1)
+                return Piecewise((l, Eq(q, S.One)), (r, True))
+
+        r = gosper_sum(f, (i, a, b))
+
+        if isinstance(r, (Mul,Add)):
+            from sympy.simplify.radsimp import denom
+            from sympy.solvers.solvers import solve
+            non_limit = r.free_symbols - Tuple(*limits[1:]).free_symbols
+            den = denom(together(r))
+            den_sym = non_limit & den.free_symbols
+            args = []
+            for v in ordered(den_sym):
+                try:
+                    s = solve(den, v)
+                    m = Eq(v, s[0]) if s else S.false
+                    if m != False:
+                        args.append((Sum(f_orig.subs(*m.args), limits).doit(), m))
+                    break
+                except NotImplementedError:
+                    continue
+
+            args.append((r, True))
+            return Piecewise(*args)
+
+        if r not in (None, S.NaN):
+            return r
+
+    h = eval_sum_hyper(f_orig, (i, a, b))
+    if h is not None:
+        return h
+
+    r = eval_sum_residue(f_orig, (i, a, b))
+    if r is not None:
+        return r
+
+    factored = f_orig.factor()
+    if factored != f_orig:
+        return eval_sum_symbolic(factored, (i, a, b))
+
+
+def _eval_sum_hyper(f, i, a):
+    """ Returns (res, cond). Sums from a to oo. """
+    if a != 0:
+        return _eval_sum_hyper(f.subs(i, i + a), i, 0)
+
+    if f.subs(i, 0) == 0:
+        from sympy.simplify.simplify import simplify
+        if simplify(f.subs(i, Dummy('i', integer=True, positive=True))) == 0:
+            return S.Zero, True
+        return _eval_sum_hyper(f.subs(i, i + 1), i, 0)
+
+    from sympy.simplify.simplify import hypersimp
+    hs = hypersimp(f, i)
+    if hs is None:
+        return None
+
+    if isinstance(hs, Float):
+        from sympy.simplify.simplify import nsimplify
+        hs = nsimplify(hs)
+
+    from sympy.simplify.combsimp import combsimp
+    from sympy.simplify.hyperexpand import hyperexpand
+    from sympy.simplify.radsimp import fraction
+    numer, denom = fraction(factor(hs))
+    top, topl = numer.as_coeff_mul(i)
+    bot, botl = denom.as_coeff_mul(i)
+    ab = [top, bot]
+    factors = [topl, botl]
+    params = [[], []]
+    for k in range(2):
+        for fac in factors[k]:
+            mul = 1
+            if fac.is_Pow:
+                mul = fac.exp
+                fac = fac.base
+                if not mul.is_Integer:
+                    return None
+            p = Poly(fac, i)
+            if p.degree() != 1:
+                return None
+            m, n = p.all_coeffs()
+            ab[k] *= m**mul
+            params[k] += [n/m]*mul
+
+    # Add "1" to numerator parameters, to account for implicit n! in
+    # hypergeometric series.
+    ap = params[0] + [1]
+    bq = params[1]
+    x = ab[0]/ab[1]
+    h = hyper(ap, bq, x)
+    f = combsimp(f)
+    return f.subs(i, 0)*hyperexpand(h), h.convergence_statement
+
+
+def eval_sum_hyper(f, i_a_b):
+    i, a, b = i_a_b
+
+    if f.is_hypergeometric(i) is False:
+        return
+
+    if (b - a).is_Integer:
+        # We are never going to do better than doing the sum in the obvious way
+        return None
+
+    old_sum = Sum(f, (i, a, b))
+
+    if b != S.Infinity:
+        if a is S.NegativeInfinity:
+            res = _eval_sum_hyper(f.subs(i, -i), i, -b)
+            if res is not None:
+                return Piecewise(res, (old_sum, True))
+        else:
+            n_illegal = lambda x: sum(x.count(_) for _ in _illegal)
+            had = n_illegal(f)
+            # check that no extra illegals are introduced
+            res1 = _eval_sum_hyper(f, i, a)
+            if res1 is None or n_illegal(res1) > had:
+                return
+            res2 = _eval_sum_hyper(f, i, b + 1)
+            if res2 is None or n_illegal(res2) > had:
+                return
+            (res1, cond1), (res2, cond2) = res1, res2
+            cond = And(cond1, cond2)
+            if cond == False:
+                return None
+            return Piecewise((res1 - res2, cond), (old_sum, True))
+
+    if a is S.NegativeInfinity:
+        res1 = _eval_sum_hyper(f.subs(i, -i), i, 1)
+        res2 = _eval_sum_hyper(f, i, 0)
+        if res1 is None or res2 is None:
+            return None
+        res1, cond1 = res1
+        res2, cond2 = res2
+        cond = And(cond1, cond2)
+        if cond == False or cond.as_set() == S.EmptySet:
+            return None
+        return Piecewise((res1 + res2, cond), (old_sum, True))
+
+    # Now b == oo, a != -oo
+    res = _eval_sum_hyper(f, i, a)
+    if res is not None:
+        r, c = res
+        if c == False:
+            if r.is_number:
+                f = f.subs(i, Dummy('i', integer=True, positive=True) + a)
+                if f.is_positive or f.is_zero:
+                    return S.Infinity
+                elif f.is_negative:
+                    return S.NegativeInfinity
+            return None
+        return Piecewise(res, (old_sum, True))
+
+
+def eval_sum_residue(f, i_a_b):
+    r"""Compute the infinite summation with residues
+
+    Notes
+    =====
+
+    If $f(n), g(n)$ are polynomials with $\deg(g(n)) - \deg(f(n)) \ge 2$,
+    some infinite summations can be computed by the following residue
+    evaluations.
+
+    .. math::
+        \sum_{n=-\infty, g(n) \ne 0}^{\infty} \frac{f(n)}{g(n)} =
+        -\pi \sum_{\alpha|g(\alpha)=0}
+        \text{Res}(\cot(\pi x) \frac{f(x)}{g(x)}, \alpha)
+
+    .. math::
+        \sum_{n=-\infty, g(n) \ne 0}^{\infty} (-1)^n \frac{f(n)}{g(n)} =
+        -\pi \sum_{\alpha|g(\alpha)=0}
+        \text{Res}(\csc(\pi x) \frac{f(x)}{g(x)}, \alpha)
+
+    Examples
+    ========
+
+    >>> from sympy import Sum, oo, Symbol
+    >>> x = Symbol('x')
+
+    Doubly infinite series of rational functions.
+
+    >>> Sum(1 / (x**2 + 1), (x, -oo, oo)).doit()
+    pi/tanh(pi)
+
+    Doubly infinite alternating series of rational functions.
+
+    >>> Sum((-1)**x / (x**2 + 1), (x, -oo, oo)).doit()
+    pi/sinh(pi)
+
+    Infinite series of even rational functions.
+
+    >>> Sum(1 / (x**2 + 1), (x, 0, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+
+    Infinite series of alternating even rational functions.
+
+    >>> Sum((-1)**x / (x**2 + 1), (x, 0, oo)).doit()
+    pi/(2*sinh(pi)) + 1/2
+
+    This also have heuristics to transform arbitrarily shifted summand or
+    arbitrarily shifted summation range to the canonical problem the
+    formula can handle.
+
+    >>> Sum(1 / (x**2 + 2*x + 2), (x, -1, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 4*x + 5), (x, -2, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 1), (x, 1, oo)).doit()
+    -1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 1), (x, 2, oo)).doit()
+    -1 + pi/(2*tanh(pi))
+
+    References
+    ==========
+
+    .. [#] http://www.supermath.info/InfiniteSeriesandtheResidueTheorem.pdf
+
+    .. [#] Asmar N.H., Grafakos L. (2018) Residue Theory.
+           In: Complex Analysis with Applications.
+           Undergraduate Texts in Mathematics. Springer, Cham.
+           https://doi.org/10.1007/978-3-319-94063-2_5
+    """
+    i, a, b = i_a_b
+
+    def is_even_function(numer, denom):
+        """Test if the rational function is an even function"""
+        numer_even = all(i % 2 == 0 for (i,) in numer.monoms())
+        denom_even = all(i % 2 == 0 for (i,) in denom.monoms())
+        numer_odd = all(i % 2 == 1 for (i,) in numer.monoms())
+        denom_odd = all(i % 2 == 1 for (i,) in denom.monoms())
+        return (numer_even and denom_even) or (numer_odd and denom_odd)
+
+    def match_rational(f, i):
+        numer, denom = f.as_numer_denom()
+        try:
+            (numer, denom), opt = parallel_poly_from_expr((numer, denom), i)
+        except (PolificationFailed, PolynomialError):
+            return None
+        return numer, denom
+
+    def get_poles(denom):
+        roots = denom.sqf_part().all_roots()
+        roots = sift(roots, lambda x: x.is_integer)
+        if None in roots:
+            return None
+        int_roots, nonint_roots = roots[True], roots[False]
+        return int_roots, nonint_roots
+
+    def get_shift(denom):
+        n = denom.degree(i)
+        a = denom.coeff_monomial(i**n)
+        b = denom.coeff_monomial(i**(n-1))
+        shift = - b / a / n
+        return shift
+
+    #Need a dummy symbol with no assumptions set for get_residue_factor
+    z = Dummy('z')
+
+    def get_residue_factor(numer, denom, alternating):
+        residue_factor = (numer.as_expr() / denom.as_expr()).subs(i, z)
+        if not alternating:
+            residue_factor *= cot(S.Pi * z)
+        else:
+            residue_factor *= csc(S.Pi * z)
+        return residue_factor
+
+    # We don't know how to deal with symbolic constants in summand
+    if f.free_symbols - {i}:
+        return None
+
+    if not (a.is_Integer or a in (S.Infinity, S.NegativeInfinity)):
+        return None
+    if not (b.is_Integer or b in (S.Infinity, S.NegativeInfinity)):
+        return None
+
+    # Quick exit heuristic for the sums which doesn't have infinite range
+    if a != S.NegativeInfinity and b != S.Infinity:
+        return None
+
+    match = match_rational(f, i)
+    if match:
+        alternating = False
+        numer, denom = match
+    else:
+        match = match_rational(f / S.NegativeOne**i, i)
+        if match:
+            alternating = True
+            numer, denom = match
+        else:
+            return None
+
+    if denom.degree(i) - numer.degree(i) < 2:
+        return None
+
+    if (a, b) == (S.NegativeInfinity, S.Infinity):
+        poles = get_poles(denom)
+        if poles is None:
+            return None
+        int_roots, nonint_roots = poles
+
+        if int_roots:
+            return None
+
+        residue_factor = get_residue_factor(numer, denom, alternating)
+        residues = [residue(residue_factor, z, root) for root in nonint_roots]
+        return -S.Pi * sum(residues)
+
+    if not (a.is_finite and b is S.Infinity):
+        return None
+
+    if not is_even_function(numer, denom):
+        # Try shifting summation and check if the summand can be made
+        # and even function from the origin.
+        # Sum(f(n), (n, a, b)) => Sum(f(n + s), (n, a - s, b - s))
+        shift = get_shift(denom)
+
+        if not shift.is_Integer:
+            return None
+        if shift == 0:
+            return None
+
+        numer = numer.shift(shift)
+        denom = denom.shift(shift)
+
+        if not is_even_function(numer, denom):
+            return None
+
+        if alternating:
+            f = S.NegativeOne**i * (S.NegativeOne**shift * numer.as_expr() / denom.as_expr())
+        else:
+            f = numer.as_expr() / denom.as_expr()
+        return eval_sum_residue(f, (i, a-shift, b-shift))
+
+    poles = get_poles(denom)
+    if poles is None:
+        return None
+    int_roots, nonint_roots = poles
+
+    if int_roots:
+        int_roots = [int(root) for root in int_roots]
+        int_roots_max = max(int_roots)
+        int_roots_min = min(int_roots)
+        # Integer valued poles must be next to each other
+        # and also symmetric from origin (Because the function is even)
+        if not len(int_roots) == int_roots_max - int_roots_min + 1:
+            return None
+
+        # Check whether the summation indices contain poles
+        if a <= max(int_roots):
+            return None
+
+    residue_factor = get_residue_factor(numer, denom, alternating)
+    residues = [residue(residue_factor, z, root) for root in int_roots + nonint_roots]
+    full_sum = -S.Pi * sum(residues)
+
+    if not int_roots:
+        # Compute Sum(f, (i, 0, oo)) by adding a extraneous evaluation
+        # at the origin.
+        half_sum = (full_sum + f.xreplace({i: 0})) / 2
+
+        # Add and subtract extraneous evaluations
+        extraneous_neg = [f.xreplace({i: i0}) for i0 in range(int(a), 0)]
+        extraneous_pos = [f.xreplace({i: i0}) for i0 in range(0, int(a))]
+        result = half_sum + sum(extraneous_neg) - sum(extraneous_pos)
+
+        return result
+
+    # Compute Sum(f, (i, min(poles) + 1, oo))
+    half_sum = full_sum / 2
+
+    # Subtract extraneous evaluations
+    extraneous = [f.xreplace({i: i0}) for i0 in range(max(int_roots) + 1, int(a))]
+    result = half_sum - sum(extraneous)
+
+    return result
+
+
+def _eval_matrix_sum(expression):
+    f = expression.function
+    for n, limit in enumerate(expression.limits):
+        i, a, b = limit
+        dif = b - a
+        if dif.is_Integer:
+            if (dif < 0) == True:
+                a, b = b + 1, a - 1
+                f = -f
+
+            newf = eval_sum_direct(f, (i, a, b))
+            if newf is not None:
+                return newf.doit()
+
+
+def _dummy_with_inherited_properties_concrete(limits):
+    """
+    Return a Dummy symbol that inherits as many assumptions as possible
+    from the provided symbol and limits.
+
+    If the symbol already has all True assumption shared by the limits
+    then return None.
+    """
+    x, a, b = limits
+    l = [a, b]
+
+    assumptions_to_consider = ['extended_nonnegative', 'nonnegative',
+                               'extended_nonpositive', 'nonpositive',
+                               'extended_positive', 'positive',
+                               'extended_negative', 'negative',
+                               'integer', 'rational', 'finite',
+                               'zero', 'real', 'extended_real']
+
+    assumptions_to_keep = {}
+    assumptions_to_add = {}
+    for assum in assumptions_to_consider:
+        assum_true = x._assumptions.get(assum, None)
+        if assum_true:
+            assumptions_to_keep[assum] = True
+        elif all(getattr(i, 'is_' + assum) for i in l):
+            assumptions_to_add[assum] = True
+    if assumptions_to_add:
+        assumptions_to_keep.update(assumptions_to_add)
+        return Dummy('d', **assumptions_to_keep)

env-llmeval/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])]

env-llmeval/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

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

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

env-llmeval/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))

env-llmeval/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)

env-llmeval/lib/python3.10/site-packages/sympy/polys/numberfields/tests/test_subfield.py

@@ -0,0 +1,304 @@
+"""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.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]

env-llmeval/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.rep[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))

env-llmeval/lib/python3.10/site-packages/sympy/utilities/__init__.py

@@ -0,0 +1,30 @@
+"""This module contains some general purpose utilities that are used across
+SymPy.
+"""
+from .iterables import (flatten, group, take, subsets,
+    variations, numbered_symbols, cartes, capture, dict_merge,
+    prefixes, postfixes, sift, topological_sort, unflatten,
+    has_dups, has_variety, reshape, rotations)
+
+from .misc import filldedent
+
+from .lambdify import lambdify
+
+from .decorator import threaded, xthreaded, public, memoize_property
+
+from .timeutils import timed
+
+__all__ = [
+    'flatten', 'group', 'take', 'subsets', 'variations', 'numbered_symbols',
+    'cartes', 'capture', 'dict_merge', 'prefixes', 'postfixes', 'sift',
+    'topological_sort', 'unflatten', 'has_dups', 'has_variety', 'reshape',
+    'rotations',
+
+    'filldedent',
+
+    'lambdify',
+
+    'threaded', 'xthreaded', 'public', 'memoize_property',
+
+    'timed',
+]