Add files using upload-large-folder tool

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

@@ -0,0 +1,100 @@
+"""Core module. Provides the basic operations needed in sympy.
+"""
+
+from .sympify import sympify, SympifyError
+from .cache import cacheit
+from .assumptions import assumptions, check_assumptions, failing_assumptions, common_assumptions
+from .basic import Basic, Atom
+from .singleton import S
+from .expr import Expr, AtomicExpr, UnevaluatedExpr
+from .symbol import Symbol, Wild, Dummy, symbols, var
+from .numbers import Number, Float, Rational, Integer, NumberSymbol, \
+    RealNumber, igcd, ilcm, seterr, E, I, nan, oo, pi, zoo, \
+    AlgebraicNumber, comp, mod_inverse
+from .power import Pow, integer_nthroot, integer_log
+from .mul import Mul, prod
+from .add import Add
+from .mod import Mod
+from .relational import ( Rel, Eq, Ne, Lt, Le, Gt, Ge,
+    Equality, GreaterThan, LessThan, Unequality, StrictGreaterThan,
+    StrictLessThan )
+from .multidimensional import vectorize
+from .function import Lambda, WildFunction, Derivative, diff, FunctionClass, \
+    Function, Subs, expand, PoleError, count_ops, \
+    expand_mul, expand_log, expand_func, \
+    expand_trig, expand_complex, expand_multinomial, nfloat, \
+    expand_power_base, expand_power_exp, arity
+from .evalf import PrecisionExhausted, N
+from .containers import Tuple, Dict
+from .exprtools import gcd_terms, factor_terms, factor_nc
+from .parameters import evaluate
+from .kind import UndefinedKind, NumberKind, BooleanKind
+from .traversal import preorder_traversal, bottom_up, use, postorder_traversal
+from .sorting import default_sort_key, ordered
+
+# expose singletons
+Catalan = S.Catalan
+EulerGamma = S.EulerGamma
+GoldenRatio = S.GoldenRatio
+TribonacciConstant = S.TribonacciConstant
+
+__all__ = [
+    'sympify', 'SympifyError',
+
+    'cacheit',
+
+    'assumptions', 'check_assumptions', 'failing_assumptions',
+    'common_assumptions',
+
+    'Basic', 'Atom',
+
+    'S',
+
+    'Expr', 'AtomicExpr', 'UnevaluatedExpr',
+
+    'Symbol', 'Wild', 'Dummy', 'symbols', 'var',
+
+    'Number', 'Float', 'Rational', 'Integer', 'NumberSymbol', 'RealNumber',
+    'igcd', 'ilcm', 'seterr', 'E', 'I', 'nan', 'oo', 'pi', 'zoo',
+    'AlgebraicNumber', 'comp', 'mod_inverse',
+
+    'Pow', 'integer_nthroot', 'integer_log',
+
+    'Mul', 'prod',
+
+    'Add',
+
+    'Mod',
+
+    'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge', 'Equality', 'GreaterThan',
+    'LessThan', 'Unequality', 'StrictGreaterThan', 'StrictLessThan',
+
+    'vectorize',
+
+    'Lambda', 'WildFunction', 'Derivative', 'diff', 'FunctionClass',
+    'Function', 'Subs', 'expand', 'PoleError', 'count_ops', 'expand_mul',
+    'expand_log', 'expand_func', 'expand_trig', 'expand_complex',
+    'expand_multinomial', 'nfloat', 'expand_power_base', 'expand_power_exp',
+    'arity',
+
+    'PrecisionExhausted', 'N',
+
+    'evalf', # The module?
+
+    'Tuple', 'Dict',
+
+    'gcd_terms', 'factor_terms', 'factor_nc',
+
+    'evaluate',
+
+    'Catalan',
+    'EulerGamma',
+    'GoldenRatio',
+    'TribonacciConstant',
+
+    'UndefinedKind', 'NumberKind', 'BooleanKind',
+
+    'preorder_traversal', 'bottom_up', 'use', 'postorder_traversal',
+
+    'default_sort_key', 'ordered',
+]

llmeval-env/lib/python3.10/site-packages/sympy/core/_print_helpers.py

@@ -0,0 +1,65 @@
+"""
+Base class to provide str and repr hooks that `init_printing` can overwrite.
+
+This is exposed publicly in the `printing.defaults` module,
+but cannot be defined there without causing circular imports.
+"""
+
+class Printable:
+    """
+    The default implementation of printing for SymPy classes.
+
+    This implements a hack that allows us to print elements of built-in
+    Python containers in a readable way. Natively Python uses ``repr()``
+    even if ``str()`` was explicitly requested. Mix in this trait into
+    a class to get proper default printing.
+
+    This also adds support for LaTeX printing in jupyter notebooks.
+    """
+
+    # Since this class is used as a mixin we set empty slots. That means that
+    # instances of any subclasses that use slots will not need to have a
+    # __dict__.
+    __slots__ = ()
+
+    # Note, we always use the default ordering (lex) in __str__ and __repr__,
+    # regardless of the global setting. See issue 5487.
+    def __str__(self):
+        from sympy.printing.str import sstr
+        return sstr(self, order=None)
+
+    __repr__ = __str__
+
+    def _repr_disabled(self):
+        """
+        No-op repr function used to disable jupyter display hooks.
+
+        When :func:`sympy.init_printing` is used to disable certain display
+        formats, this function is copied into the appropriate ``_repr_*_``
+        attributes.
+
+        While we could just set the attributes to `None``, doing it this way
+        allows derived classes to call `super()`.
+        """
+        return None
+
+    # We don't implement _repr_png_ here because it would add a large amount of
+    # data to any notebook containing SymPy expressions, without adding
+    # anything useful to the notebook. It can still enabled manually, e.g.,
+    # for the qtconsole, with init_printing().
+    _repr_png_ = _repr_disabled
+
+    _repr_svg_ = _repr_disabled
+
+    def _repr_latex_(self):
+        """
+        IPython/Jupyter LaTeX printing
+
+        To change the behavior of this (e.g., pass in some settings to LaTeX),
+        use init_printing(). init_printing() will also enable LaTeX printing
+        for built in numeric types like ints and container types that contain
+        SymPy objects, like lists and dictionaries of expressions.
+        """
+        from sympy.printing.latex import latex
+        s = latex(self, mode='plain')
+        return "$\\displaystyle %s$" % s

llmeval-env/lib/python3.10/site-packages/sympy/core/add.py

@@ -0,0 +1,1287 @@
+from typing import Tuple as tTuple
+from collections import defaultdict
+from functools import cmp_to_key, reduce
+from operator import attrgetter
+from .basic import Basic
+from .parameters import global_parameters
+from .logic import _fuzzy_group, fuzzy_or, fuzzy_not
+from .singleton import S
+from .operations import AssocOp, AssocOpDispatcher
+from .cache import cacheit
+from .numbers import ilcm, igcd, equal_valued
+from .expr import Expr
+from .kind import UndefinedKind
+from sympy.utilities.iterables import is_sequence, sift
+
+# Key for sorting commutative args in canonical order
+_args_sortkey = cmp_to_key(Basic.compare)
+
+
+def _could_extract_minus_sign(expr):
+    # assume expr is Add-like
+    # We choose the one with less arguments with minus signs
+    negative_args = sum(1 for i in expr.args
+        if i.could_extract_minus_sign())
+    positive_args = len(expr.args) - negative_args
+    if positive_args > negative_args:
+        return False
+    elif positive_args < negative_args:
+        return True
+    # choose based on .sort_key() to prefer
+    # x - 1 instead of 1 - x and
+    # 3 - sqrt(2) instead of -3 + sqrt(2)
+    return bool(expr.sort_key() < (-expr).sort_key())
+
+
+def _addsort(args):
+    # in-place sorting of args
+    args.sort(key=_args_sortkey)
+
+
+def _unevaluated_Add(*args):
+    """Return a well-formed unevaluated Add: Numbers are collected and
+    put in slot 0 and args are sorted. Use this when args have changed
+    but you still want to return an unevaluated Add.
+
+    Examples
+    ========
+
+    >>> from sympy.core.add import _unevaluated_Add as uAdd
+    >>> from sympy import S, Add
+    >>> from sympy.abc import x, y
+    >>> a = uAdd(*[S(1.0), x, S(2)])
+    >>> a.args[0]
+    3.00000000000000
+    >>> a.args[1]
+    x
+
+    Beyond the Number being in slot 0, there is no other assurance of
+    order for the arguments since they are hash sorted. So, for testing
+    purposes, output produced by this in some other function can only
+    be tested against the output of this function or as one of several
+    options:
+
+    >>> opts = (Add(x, y, evaluate=False), Add(y, x, evaluate=False))
+    >>> a = uAdd(x, y)
+    >>> assert a in opts and a == uAdd(x, y)
+    >>> uAdd(x + 1, x + 2)
+    x + x + 3
+    """
+    args = list(args)
+    newargs = []
+    co = S.Zero
+    while args:
+        a = args.pop()
+        if a.is_Add:
+            # this will keep nesting from building up
+            # so that x + (x + 1) -> x + x + 1 (3 args)
+            args.extend(a.args)
+        elif a.is_Number:
+            co += a
+        else:
+            newargs.append(a)
+    _addsort(newargs)
+    if co:
+        newargs.insert(0, co)
+    return Add._from_args(newargs)
+
+
+class Add(Expr, AssocOp):
+    """
+    Expression representing addition operation for algebraic group.
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Every argument of ``Add()`` must be ``Expr``. Infix operator ``+``
+    on most scalar objects in SymPy calls this class.
+
+    Another use of ``Add()`` is to represent the structure of abstract
+    addition so that its arguments can be substituted to return different
+    class. Refer to examples section for this.
+
+    ``Add()`` evaluates the argument unless ``evaluate=False`` is passed.
+    The evaluation logic includes:
+
+    1. Flattening
+        ``Add(x, Add(y, z))`` -> ``Add(x, y, z)``
+
+    2. Identity removing
+        ``Add(x, 0, y)`` -> ``Add(x, y)``
+
+    3. Coefficient collecting by ``.as_coeff_Mul()``
+        ``Add(x, 2*x)`` -> ``Mul(3, x)``
+
+    4. Term sorting
+        ``Add(y, x, 2)`` -> ``Add(2, x, y)``
+
+    If no argument is passed, identity element 0 is returned. If single
+    element is passed, that element is returned.
+
+    Note that ``Add(*args)`` is more efficient than ``sum(args)`` because
+    it flattens the arguments. ``sum(a, b, c, ...)`` recursively adds the
+    arguments as ``a + (b + (c + ...))``, which has quadratic complexity.
+    On the other hand, ``Add(a, b, c, d)`` does not assume nested
+    structure, making the complexity linear.
+
+    Since addition is group operation, every argument should have the
+    same :obj:`sympy.core.kind.Kind()`.
+
+    Examples
+    ========
+
+    >>> from sympy import Add, I
+    >>> from sympy.abc import x, y
+    >>> Add(x, 1)
+    x + 1
+    >>> Add(x, x)
+    2*x
+    >>> 2*x**2 + 3*x + I*y + 2*y + 2*x/5 + 1.0*y + 1
+    2*x**2 + 17*x/5 + 3.0*y + I*y + 1
+
+    If ``evaluate=False`` is passed, result is not evaluated.
+
+    >>> Add(1, 2, evaluate=False)
+    1 + 2
+    >>> Add(x, x, evaluate=False)
+    x + x
+
+    ``Add()`` also represents the general structure of addition operation.
+
+    >>> from sympy import MatrixSymbol
+    >>> A,B = MatrixSymbol('A', 2,2), MatrixSymbol('B', 2,2)
+    >>> expr = Add(x,y).subs({x:A, y:B})
+    >>> expr
+    A + B
+    >>> type(expr)
+    <class 'sympy.matrices.expressions.matadd.MatAdd'>
+
+    Note that the printers do not display in args order.
+
+    >>> Add(x, 1)
+    x + 1
+    >>> Add(x, 1).args
+    (1, x)
+
+    See Also
+    ========
+
+    MatAdd
+
+    """
+
+    __slots__ = ()
+
+    args: tTuple[Expr, ...]
+
+    is_Add = True
+
+    _args_type = Expr
+
+    @classmethod
+    def flatten(cls, seq):
+        """
+        Takes the sequence "seq" of nested Adds and returns a flatten list.
+
+        Returns: (commutative_part, noncommutative_part, order_symbols)
+
+        Applies associativity, all terms are commutable with respect to
+        addition.
+
+        NB: the removal of 0 is already handled by AssocOp.__new__
+
+        See Also
+        ========
+
+        sympy.core.mul.Mul.flatten
+
+        """
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.matrices.expressions import MatrixExpr
+        from sympy.tensor.tensor import TensExpr
+        rv = None
+        if len(seq) == 2:
+            a, b = seq
+            if b.is_Rational:
+                a, b = b, a
+            if a.is_Rational:
+                if b.is_Mul:
+                    rv = [a, b], [], None
+            if rv:
+                if all(s.is_commutative for s in rv[0]):
+                    return rv
+                return [], rv[0], None
+
+        terms = {}      # term -> coeff
+                        # e.g. x**2 -> 5   for ... + 5*x**2 + ...
+
+        coeff = S.Zero  # coefficient (Number or zoo) to always be in slot 0
+                        # e.g. 3 + ...
+        order_factors = []
+
+        extra = []
+
+        for o in seq:
+
+            # O(x)
+            if o.is_Order:
+                if o.expr.is_zero:
+                    continue
+                for o1 in order_factors:
+                    if o1.contains(o):
+                        o = None
+                        break
+                if o is None:
+                    continue
+                order_factors = [o] + [
+                    o1 for o1 in order_factors if not o.contains(o1)]
+                continue
+
+            # 3 or NaN
+            elif o.is_Number:
+                if (o is S.NaN or coeff is S.ComplexInfinity and
+                        o.is_finite is False) and not extra:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+                if coeff.is_Number or isinstance(coeff, AccumBounds):
+                    coeff += o
+                    if coeff is S.NaN and not extra:
+                        # we know for sure the result will be nan
+                        return [S.NaN], [], None
+                continue
+
+            elif isinstance(o, AccumBounds):
+                coeff = o.__add__(coeff)
+                continue
+
+            elif isinstance(o, MatrixExpr):
+                # can't add 0 to Matrix so make sure coeff is not 0
+                extra.append(o)
+                continue
+
+            elif isinstance(o, TensExpr):
+                coeff = o.__add__(coeff) if coeff else o
+                continue
+
+            elif o is S.ComplexInfinity:
+                if coeff.is_finite is False and not extra:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+                coeff = S.ComplexInfinity
+                continue
+
+            # Add([...])
+            elif o.is_Add:
+                # NB: here we assume Add is always commutative
+                seq.extend(o.args)  # TODO zerocopy?
+                continue
+
+            # Mul([...])
+            elif o.is_Mul:
+                c, s = o.as_coeff_Mul()
+
+            # check for unevaluated Pow, e.g. 2**3 or 2**(-1/2)
+            elif o.is_Pow:
+                b, e = o.as_base_exp()
+                if b.is_Number and (e.is_Integer or
+                                   (e.is_Rational and e.is_negative)):
+                    seq.append(b**e)
+                    continue
+                c, s = S.One, o
+
+            else:
+                # everything else
+                c = S.One
+                s = o
+
+            # now we have:
+            # o = c*s, where
+            #
+            # c is a Number
+            # s is an expression with number factor extracted
+            # let's collect terms with the same s, so e.g.
+            # 2*x**2 + 3*x**2  ->  5*x**2
+            if s in terms:
+                terms[s] += c
+                if terms[s] is S.NaN and not extra:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+            else:
+                terms[s] = c
+
+        # now let's construct new args:
+        # [2*x**2, x**3, 7*x**4, pi, ...]
+        newseq = []
+        noncommutative = False
+        for s, c in terms.items():
+            # 0*s
+            if c.is_zero:
+                continue
+            # 1*s
+            elif c is S.One:
+                newseq.append(s)
+            # c*s
+            else:
+                if s.is_Mul:
+                    # Mul, already keeps its arguments in perfect order.
+                    # so we can simply put c in slot0 and go the fast way.
+                    cs = s._new_rawargs(*((c,) + s.args))
+                    newseq.append(cs)
+                elif s.is_Add:
+                    # we just re-create the unevaluated Mul
+                    newseq.append(Mul(c, s, evaluate=False))
+                else:
+                    # alternatively we have to call all Mul's machinery (slow)
+                    newseq.append(Mul(c, s))
+
+            noncommutative = noncommutative or not s.is_commutative
+
+        # oo, -oo
+        if coeff is S.Infinity:
+            newseq = [f for f in newseq if not (f.is_extended_nonnegative or f.is_real)]
+
+        elif coeff is S.NegativeInfinity:
+            newseq = [f for f in newseq if not (f.is_extended_nonpositive or f.is_real)]
+
+        if coeff is S.ComplexInfinity:
+            # zoo might be
+            #   infinite_real + finite_im
+            #   finite_real + infinite_im
+            #   infinite_real + infinite_im
+            # addition of a finite real or imaginary number won't be able to
+            # change the zoo nature; adding an infinite qualtity would result
+            # in a NaN condition if it had sign opposite of the infinite
+            # portion of zoo, e.g., infinite_real - infinite_real.
+            newseq = [c for c in newseq if not (c.is_finite and
+                                                c.is_extended_real is not None)]
+
+        # process O(x)
+        if order_factors:
+            newseq2 = []
+            for t in newseq:
+                for o in order_factors:
+                    # x + O(x) -> O(x)
+                    if o.contains(t):
+                        t = None
+                        break
+                # x + O(x**2) -> x + O(x**2)
+                if t is not None:
+                    newseq2.append(t)
+            newseq = newseq2 + order_factors
+            # 1 + O(1) -> O(1)
+            for o in order_factors:
+                if o.contains(coeff):
+                    coeff = S.Zero
+                    break
+
+        # order args canonically
+        _addsort(newseq)
+
+        # current code expects coeff to be first
+        if coeff is not S.Zero:
+            newseq.insert(0, coeff)
+
+        if extra:
+            newseq += extra
+            noncommutative = True
+
+        # we are done
+        if noncommutative:
+            return [], newseq, None
+        else:
+            return newseq, [], None
+
+    @classmethod
+    def class_key(cls):
+        return 3, 1, cls.__name__
+
+    @property
+    def kind(self):
+        k = attrgetter('kind')
+        kinds = map(k, self.args)
+        kinds = frozenset(kinds)
+        if len(kinds) != 1:
+            # Since addition is group operator, kind must be same.
+            # We know that this is unexpected signature, so return this.
+            result = UndefinedKind
+        else:
+            result, = kinds
+        return result
+
+    def could_extract_minus_sign(self):
+        return _could_extract_minus_sign(self)
+
+    @cacheit
+    def as_coeff_add(self, *deps):
+        """
+        Returns a tuple (coeff, args) where self is treated as an Add and coeff
+        is the Number term and args is a tuple of all other terms.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (7 + 3*x).as_coeff_add()
+        (7, (3*x,))
+        >>> (7*x).as_coeff_add()
+        (0, (7*x,))
+        """
+        if deps:
+            l1, l2 = sift(self.args, lambda x: x.has_free(*deps), binary=True)
+            return self._new_rawargs(*l2), tuple(l1)
+        coeff, notrat = self.args[0].as_coeff_add()
+        if coeff is not S.Zero:
+            return coeff, notrat + self.args[1:]
+        return S.Zero, self.args
+
+    def as_coeff_Add(self, rational=False, deps=None):
+        """
+        Efficiently extract the coefficient of a summation.
+        """
+        coeff, args = self.args[0], self.args[1:]
+
+        if coeff.is_Number and not rational or coeff.is_Rational:
+            return coeff, self._new_rawargs(*args)
+        return S.Zero, self
+
+    # Note, we intentionally do not implement Add.as_coeff_mul().  Rather, we
+    # let Expr.as_coeff_mul() just always return (S.One, self) for an Add.  See
+    # issue 5524.
+
+    def _eval_power(self, e):
+        from .evalf import pure_complex
+        from .relational import is_eq
+        if len(self.args) == 2 and any(_.is_infinite for _ in self.args):
+            if e.is_zero is False and is_eq(e, S.One) is False:
+                # looking for literal a + I*b
+                a, b = self.args
+                if a.coeff(S.ImaginaryUnit):
+                    a, b = b, a
+                ico = b.coeff(S.ImaginaryUnit)
+                if ico and ico.is_extended_real and a.is_extended_real:
+                    if e.is_extended_negative:
+                        return S.Zero
+                    if e.is_extended_positive:
+                        return S.ComplexInfinity
+            return
+        if e.is_Rational and self.is_number:
+            ri = pure_complex(self)
+            if ri:
+                r, i = ri
+                if e.q == 2:
+                    from sympy.functions.elementary.miscellaneous import sqrt
+                    D = sqrt(r**2 + i**2)
+                    if D.is_Rational:
+                        from .exprtools import factor_terms
+                        from sympy.functions.elementary.complexes import sign
+                        from .function import expand_multinomial
+                        # (r, i, D) is a Pythagorean triple
+                        root = sqrt(factor_terms((D - r)/2))**e.p
+                        return root*expand_multinomial((
+                            # principle value
+                            (D + r)/abs(i) + sign(i)*S.ImaginaryUnit)**e.p)
+                elif e == -1:
+                    return _unevaluated_Mul(
+                        r - i*S.ImaginaryUnit,
+                        1/(r**2 + i**2))
+        elif e.is_Number and abs(e) != 1:
+            # handle the Float case: (2.0 + 4*x)**e -> 4**e*(0.5 + x)**e
+            c, m = zip(*[i.as_coeff_Mul() for i in self.args])
+            if any(i.is_Float for i in c):  # XXX should this always be done?
+                big = -1
+                for i in c:
+                    if abs(i) >= big:
+                        big = abs(i)
+                if big > 0 and not equal_valued(big, 1):
+                    from sympy.functions.elementary.complexes import sign
+                    bigs = (big, -big)
+                    c = [sign(i) if i in bigs else i/big for i in c]
+                    addpow = Add(*[c*m for c, m in zip(c, m)])**e
+                    return big**e*addpow
+
+    @cacheit
+    def _eval_derivative(self, s):
+        return self.func(*[a.diff(s) for a in self.args])
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        terms = [t.nseries(x, n=n, logx=logx, cdir=cdir) for t in self.args]
+        return self.func(*terms)
+
+    def _matches_simple(self, expr, repl_dict):
+        # handle (w+3).matches('x+5') -> {w: x+2}
+        coeff, terms = self.as_coeff_add()
+        if len(terms) == 1:
+            return terms[0].matches(expr - coeff, repl_dict)
+        return
+
+    def matches(self, expr, repl_dict=None, old=False):
+        return self._matches_commutative(expr, repl_dict, old)
+
+    @staticmethod
+    def _combine_inverse(lhs, rhs):
+        """
+        Returns lhs - rhs, but treats oo like a symbol so oo - oo
+        returns 0, instead of a nan.
+        """
+        from sympy.simplify.simplify import signsimp
+        inf = (S.Infinity, S.NegativeInfinity)
+        if lhs.has(*inf) or rhs.has(*inf):
+            from .symbol import Dummy
+            oo = Dummy('oo')
+            reps = {
+                S.Infinity: oo,
+                S.NegativeInfinity: -oo}
+            ireps = {v: k for k, v in reps.items()}
+            eq = lhs.xreplace(reps) - rhs.xreplace(reps)
+            if eq.has(oo):
+                eq = eq.replace(
+                    lambda x: x.is_Pow and x.base is oo,
+                    lambda x: x.base)
+            rv = eq.xreplace(ireps)
+        else:
+            rv = lhs - rhs
+        srv = signsimp(rv)
+        return srv if srv.is_Number else rv
+
+    @cacheit
+    def as_two_terms(self):
+        """Return head and tail of self.
+
+        This is the most efficient way to get the head and tail of an
+        expression.
+
+        - if you want only the head, use self.args[0];
+        - if you want to process the arguments of the tail then use
+          self.as_coef_add() which gives the head and a tuple containing
+          the arguments of the tail when treated as an Add.
+        - if you want the coefficient when self is treated as a Mul
+          then use self.as_coeff_mul()[0]
+
+        >>> from sympy.abc import x, y
+        >>> (3*x - 2*y + 5).as_two_terms()
+        (5, 3*x - 2*y)
+        """
+        return self.args[0], self._new_rawargs(*self.args[1:])
+
+    def as_numer_denom(self):
+        """
+        Decomposes an expression to its numerator part and its
+        denominator part.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> (x*y/z).as_numer_denom()
+        (x*y, z)
+        >>> (x*(y + 1)/y**7).as_numer_denom()
+        (x*(y + 1), y**7)
+
+        See Also
+        ========
+
+        sympy.core.expr.Expr.as_numer_denom
+        """
+        # clear rational denominator
+        content, expr = self.primitive()
+        if not isinstance(expr, Add):
+            return Mul(content, expr, evaluate=False).as_numer_denom()
+        ncon, dcon = content.as_numer_denom()
+
+        # collect numerators and denominators of the terms
+        nd = defaultdict(list)
+        for f in expr.args:
+            ni, di = f.as_numer_denom()
+            nd[di].append(ni)
+
+        # check for quick exit
+        if len(nd) == 1:
+            d, n = nd.popitem()
+            return self.func(
+                *[_keep_coeff(ncon, ni) for ni in n]), _keep_coeff(dcon, d)
+
+        # sum up the terms having a common denominator
+        for d, n in nd.items():
+            if len(n) == 1:
+                nd[d] = n[0]
+            else:
+                nd[d] = self.func(*n)
+
+        # assemble single numerator and denominator
+        denoms, numers = [list(i) for i in zip(*iter(nd.items()))]
+        n, d = self.func(*[Mul(*(denoms[:i] + [numers[i]] + denoms[i + 1:]))
+                   for i in range(len(numers))]), Mul(*denoms)
+
+        return _keep_coeff(ncon, n), _keep_coeff(dcon, d)
+
+    def _eval_is_polynomial(self, syms):
+        return all(term._eval_is_polynomial(syms) for term in self.args)
+
+    def _eval_is_rational_function(self, syms):
+        return all(term._eval_is_rational_function(syms) for term in self.args)
+
+    def _eval_is_meromorphic(self, x, a):
+        return _fuzzy_group((arg.is_meromorphic(x, a) for arg in self.args),
+                            quick_exit=True)
+
+    def _eval_is_algebraic_expr(self, syms):
+        return all(term._eval_is_algebraic_expr(syms) for term in self.args)
+
+    # assumption methods
+    _eval_is_real = lambda self: _fuzzy_group(
+        (a.is_real for a in self.args), quick_exit=True)
+    _eval_is_extended_real = lambda self: _fuzzy_group(
+        (a.is_extended_real for a in self.args), quick_exit=True)
+    _eval_is_complex = lambda self: _fuzzy_group(
+        (a.is_complex for a in self.args), quick_exit=True)
+    _eval_is_antihermitian = lambda self: _fuzzy_group(
+        (a.is_antihermitian for a in self.args), quick_exit=True)
+    _eval_is_finite = lambda self: _fuzzy_group(
+        (a.is_finite for a in self.args), quick_exit=True)
+    _eval_is_hermitian = lambda self: _fuzzy_group(
+        (a.is_hermitian for a in self.args), quick_exit=True)
+    _eval_is_integer = lambda self: _fuzzy_group(
+        (a.is_integer for a in self.args), quick_exit=True)
+    _eval_is_rational = lambda self: _fuzzy_group(
+        (a.is_rational for a in self.args), quick_exit=True)
+    _eval_is_algebraic = lambda self: _fuzzy_group(
+        (a.is_algebraic for a in self.args), quick_exit=True)
+    _eval_is_commutative = lambda self: _fuzzy_group(
+        a.is_commutative for a in self.args)
+
+    def _eval_is_infinite(self):
+        sawinf = False
+        for a in self.args:
+            ainf = a.is_infinite
+            if ainf is None:
+                return None
+            elif ainf is True:
+                # infinite+infinite might not be infinite
+                if sawinf is True:
+                    return None
+                sawinf = True
+        return sawinf
+
+    def _eval_is_imaginary(self):
+        nz = []
+        im_I = []
+        for a in self.args:
+            if a.is_extended_real:
+                if a.is_zero:
+                    pass
+                elif a.is_zero is False:
+                    nz.append(a)
+                else:
+                    return
+            elif a.is_imaginary:
+                im_I.append(a*S.ImaginaryUnit)
+            elif a.is_Mul and S.ImaginaryUnit in a.args:
+                coeff, ai = a.as_coeff_mul(S.ImaginaryUnit)
+                if ai == (S.ImaginaryUnit,) and coeff.is_extended_real:
+                    im_I.append(-coeff)
+                else:
+                    return
+            else:
+                return
+        b = self.func(*nz)
+        if b != self:
+            if b.is_zero:
+                return fuzzy_not(self.func(*im_I).is_zero)
+            elif b.is_zero is False:
+                return False
+
+    def _eval_is_zero(self):
+        if self.is_commutative is False:
+            # issue 10528: there is no way to know if a nc symbol
+            # is zero or not
+            return
+        nz = []
+        z = 0
+        im_or_z = False
+        im = 0
+        for a in self.args:
+            if a.is_extended_real:
+                if a.is_zero:
+                    z += 1
+                elif a.is_zero is False:
+                    nz.append(a)
+                else:
+                    return
+            elif a.is_imaginary:
+                im += 1
+            elif a.is_Mul and S.ImaginaryUnit in a.args:
+                coeff, ai = a.as_coeff_mul(S.ImaginaryUnit)
+                if ai == (S.ImaginaryUnit,) and coeff.is_extended_real:
+                    im_or_z = True
+                else:
+                    return
+            else:
+                return
+        if z == len(self.args):
+            return True
+        if len(nz) in [0, len(self.args)]:
+            return None
+        b = self.func(*nz)
+        if b.is_zero:
+            if not im_or_z:
+                if im == 0:
+                    return True
+                elif im == 1:
+                    return False
+        if b.is_zero is False:
+            return False
+
+    def _eval_is_odd(self):
+        l = [f for f in self.args if not (f.is_even is True)]
+        if not l:
+            return False
+        if l[0].is_odd:
+            return self._new_rawargs(*l[1:]).is_even
+
+    def _eval_is_irrational(self):
+        for t in self.args:
+            a = t.is_irrational
+            if a:
+                others = list(self.args)
+                others.remove(t)
+                if all(x.is_rational is True for x in others):
+                    return True
+                return None
+            if a is None:
+                return
+        return False
+
+    def _all_nonneg_or_nonppos(self):
+        nn = np = 0
+        for a in self.args:
+            if a.is_nonnegative:
+                if np:
+                    return False
+                nn = 1
+            elif a.is_nonpositive:
+                if nn:
+                    return False
+                np = 1
+            else:
+                break
+        else:
+            return True
+
+    def _eval_is_extended_positive(self):
+        if self.is_number:
+            return super()._eval_is_extended_positive()
+        c, a = self.as_coeff_Add()
+        if not c.is_zero:
+            from .exprtools import _monotonic_sign
+            v = _monotonic_sign(a)
+            if v is not None:
+                s = v + c
+                if s != self and s.is_extended_positive and a.is_extended_nonnegative:
+                    return True
+                if len(self.free_symbols) == 1:
+                    v = _monotonic_sign(self)
+                    if v is not None and v != self and v.is_extended_positive:
+                        return True
+        pos = nonneg = nonpos = unknown_sign = False
+        saw_INF = set()
+        args = [a for a in self.args if not a.is_zero]
+        if not args:
+            return False
+        for a in args:
+            ispos = a.is_extended_positive
+            infinite = a.is_infinite
+            if infinite:
+                saw_INF.add(fuzzy_or((ispos, a.is_extended_nonnegative)))
+                if True in saw_INF and False in saw_INF:
+                    return
+            if ispos:
+                pos = True
+                continue
+            elif a.is_extended_nonnegative:
+                nonneg = True
+                continue
+            elif a.is_extended_nonpositive:
+                nonpos = True
+                continue
+
+            if infinite is None:
+                return
+            unknown_sign = True
+
+        if saw_INF:
+            if len(saw_INF) > 1:
+                return
+            return saw_INF.pop()
+        elif unknown_sign:
+            return
+        elif not nonpos and not nonneg and pos:
+            return True
+        elif not nonpos and pos:
+            return True
+        elif not pos and not nonneg:
+            return False
+
+    def _eval_is_extended_nonnegative(self):
+        if not self.is_number:
+            c, a = self.as_coeff_Add()
+            if not c.is_zero and a.is_extended_nonnegative:
+                from .exprtools import _monotonic_sign
+                v = _monotonic_sign(a)
+                if v is not None:
+                    s = v + c
+                    if s != self and s.is_extended_nonnegative:
+                        return True
+                    if len(self.free_symbols) == 1:
+                        v = _monotonic_sign(self)
+                        if v is not None and v != self and v.is_extended_nonnegative:
+                            return True
+
+    def _eval_is_extended_nonpositive(self):
+        if not self.is_number:
+            c, a = self.as_coeff_Add()
+            if not c.is_zero and a.is_extended_nonpositive:
+                from .exprtools import _monotonic_sign
+                v = _monotonic_sign(a)
+                if v is not None:
+                    s = v + c
+                    if s != self and s.is_extended_nonpositive:
+                        return True
+                    if len(self.free_symbols) == 1:
+                        v = _monotonic_sign(self)
+                        if v is not None and v != self and v.is_extended_nonpositive:
+                            return True
+
+    def _eval_is_extended_negative(self):
+        if self.is_number:
+            return super()._eval_is_extended_negative()
+        c, a = self.as_coeff_Add()
+        if not c.is_zero:
+            from .exprtools import _monotonic_sign
+            v = _monotonic_sign(a)
+            if v is not None:
+                s = v + c
+                if s != self and s.is_extended_negative and a.is_extended_nonpositive:
+                    return True
+                if len(self.free_symbols) == 1:
+                    v = _monotonic_sign(self)
+                    if v is not None and v != self and v.is_extended_negative:
+                        return True
+        neg = nonpos = nonneg = unknown_sign = False
+        saw_INF = set()
+        args = [a for a in self.args if not a.is_zero]
+        if not args:
+            return False
+        for a in args:
+            isneg = a.is_extended_negative
+            infinite = a.is_infinite
+            if infinite:
+                saw_INF.add(fuzzy_or((isneg, a.is_extended_nonpositive)))
+                if True in saw_INF and False in saw_INF:
+                    return
+            if isneg:
+                neg = True
+                continue
+            elif a.is_extended_nonpositive:
+                nonpos = True
+                continue
+            elif a.is_extended_nonnegative:
+                nonneg = True
+                continue
+
+            if infinite is None:
+                return
+            unknown_sign = True
+
+        if saw_INF:
+            if len(saw_INF) > 1:
+                return
+            return saw_INF.pop()
+        elif unknown_sign:
+            return
+        elif not nonneg and not nonpos and neg:
+            return True
+        elif not nonneg and neg:
+            return True
+        elif not neg and not nonpos:
+            return False
+
+    def _eval_subs(self, old, new):
+        if not old.is_Add:
+            if old is S.Infinity and -old in self.args:
+                # foo - oo is foo + (-oo) internally
+                return self.xreplace({-old: -new})
+            return None
+
+        coeff_self, terms_self = self.as_coeff_Add()
+        coeff_old, terms_old = old.as_coeff_Add()
+
+        if coeff_self.is_Rational and coeff_old.is_Rational:
+            if terms_self == terms_old:   # (2 + a).subs( 3 + a, y) -> -1 + y
+                return self.func(new, coeff_self, -coeff_old)
+            if terms_self == -terms_old:  # (2 + a).subs(-3 - a, y) -> -1 - y
+                return self.func(-new, coeff_self, coeff_old)
+
+        if coeff_self.is_Rational and coeff_old.is_Rational \
+                or coeff_self == coeff_old:
+            args_old, args_self = self.func.make_args(
+                terms_old), self.func.make_args(terms_self)
+            if len(args_old) < len(args_self):  # (a+b+c).subs(b+c,x) -> a+x
+                self_set = set(args_self)
+                old_set = set(args_old)
+
+                if old_set < self_set:
+                    ret_set = self_set - old_set
+                    return self.func(new, coeff_self, -coeff_old,
+                               *[s._subs(old, new) for s in ret_set])
+
+                args_old = self.func.make_args(
+                    -terms_old)     # (a+b+c+d).subs(-b-c,x) -> a-x+d
+                old_set = set(args_old)
+                if old_set < self_set:
+                    ret_set = self_set - old_set
+                    return self.func(-new, coeff_self, coeff_old,
+                               *[s._subs(old, new) for s in ret_set])
+
+    def removeO(self):
+        args = [a for a in self.args if not a.is_Order]
+        return self._new_rawargs(*args)
+
+    def getO(self):
+        args = [a for a in self.args if a.is_Order]
+        if args:
+            return self._new_rawargs(*args)
+
+    @cacheit
+    def extract_leading_order(self, symbols, point=None):
+        """
+        Returns the leading term and its order.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (x + 1 + 1/x**5).extract_leading_order(x)
+        ((x**(-5), O(x**(-5))),)
+        >>> (1 + x).extract_leading_order(x)
+        ((1, O(1)),)
+        >>> (x + x**2).extract_leading_order(x)
+        ((x, O(x)),)
+
+        """
+        from sympy.series.order import Order
+        lst = []
+        symbols = list(symbols if is_sequence(symbols) else [symbols])
+        if not point:
+            point = [0]*len(symbols)
+        seq = [(f, Order(f, *zip(symbols, point))) for f in self.args]
+        for ef, of in seq:
+            for e, o in lst:
+                if o.contains(of) and o != of:
+                    of = None
+                    break
+            if of is None:
+                continue
+            new_lst = [(ef, of)]
+            for e, o in lst:
+                if of.contains(o) and o != of:
+                    continue
+                new_lst.append((e, o))
+            lst = new_lst
+        return tuple(lst)
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Return a tuple representing a complex number.
+
+        Examples
+        ========
+
+        >>> from sympy import I
+        >>> (7 + 9*I).as_real_imag()
+        (7, 9)
+        >>> ((1 + I)/(1 - I)).as_real_imag()
+        (0, 1)
+        >>> ((1 + 2*I)*(1 + 3*I)).as_real_imag()
+        (-5, 5)
+        """
+        sargs = self.args
+        re_part, im_part = [], []
+        for term in sargs:
+            re, im = term.as_real_imag(deep=deep)
+            re_part.append(re)
+            im_part.append(im)
+        return (self.func(*re_part), self.func(*im_part))
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.core.symbol import Dummy, Symbol
+        from sympy.series.order import Order
+        from sympy.functions.elementary.exponential import log
+        from sympy.functions.elementary.piecewise import Piecewise, piecewise_fold
+        from .function import expand_mul
+
+        o = self.getO()
+        if o is None:
+            o = Order(0)
+        old = self.removeO()
+
+        if old.has(Piecewise):
+            old = piecewise_fold(old)
+
+        # This expansion is the last part of expand_log. expand_log also calls
+        # expand_mul with factor=True, which would be more expensive
+        if any(isinstance(a, log) for a in self.args):
+            logflags = {"deep": True, "log": True, "mul": False, "power_exp": False,
+                "power_base": False, "multinomial": False, "basic": False, "force": False,
+                "factor": False}
+            old = old.expand(**logflags)
+        expr = expand_mul(old)
+
+        if not expr.is_Add:
+            return expr.as_leading_term(x, logx=logx, cdir=cdir)
+
+        infinite = [t for t in expr.args if t.is_infinite]
+
+        _logx = Dummy('logx') if logx is None else logx
+        leading_terms = [t.as_leading_term(x, logx=_logx, cdir=cdir) for t in expr.args]
+
+        min, new_expr = Order(0), 0
+
+        try:
+            for term in leading_terms:
+                order = Order(term, x)
+                if not min or order not in min:
+                    min = order
+                    new_expr = term
+                elif min in order:
+                    new_expr += term
+
+        except TypeError:
+            return expr
+
+        if logx is None:
+            new_expr = new_expr.subs(_logx, log(x))
+
+        is_zero = new_expr.is_zero
+        if is_zero is None:
+            new_expr = new_expr.trigsimp().cancel()
+            is_zero = new_expr.is_zero
+        if is_zero is True:
+            # simple leading term analysis gave us cancelled terms but we have to send
+            # back a term, so compute the leading term (via series)
+            try:
+                n0 = min.getn()
+            except NotImplementedError:
+                n0 = S.One
+            if n0.has(Symbol):
+                n0 = S.One
+            res = Order(1)
+            incr = S.One
+            while res.is_Order:
+                res = old._eval_nseries(x, n=n0+incr, logx=logx, cdir=cdir).cancel().powsimp().trigsimp()
+                incr *= 2
+            return res.as_leading_term(x, logx=logx, cdir=cdir)
+
+        elif new_expr is S.NaN:
+            return old.func._from_args(infinite) + o
+
+        else:
+            return new_expr
+
+    def _eval_adjoint(self):
+        return self.func(*[t.adjoint() for t in self.args])
+
+    def _eval_conjugate(self):
+        return self.func(*[t.conjugate() for t in self.args])
+
+    def _eval_transpose(self):
+        return self.func(*[t.transpose() for t in self.args])
+
+    def primitive(self):
+        """
+        Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.
+
+        ``R`` is collected only from the leading coefficient of each term.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+
+        >>> (2*x + 4*y).primitive()
+        (2, x + 2*y)
+
+        >>> (2*x/3 + 4*y/9).primitive()
+        (2/9, 3*x + 2*y)
+
+        >>> (2*x/3 + 4.2*y).primitive()
+        (1/3, 2*x + 12.6*y)
+
+        No subprocessing of term factors is performed:
+
+        >>> ((2 + 2*x)*x + 2).primitive()
+        (1, x*(2*x + 2) + 2)
+
+        Recursive processing can be done with the ``as_content_primitive()``
+        method:
+
+        >>> ((2 + 2*x)*x + 2).as_content_primitive()
+        (2, x*(x + 1) + 1)
+
+        See also: primitive() function in polytools.py
+
+        """
+
+        terms = []
+        inf = False
+        for a in self.args:
+            c, m = a.as_coeff_Mul()
+            if not c.is_Rational:
+                c = S.One
+                m = a
+            inf = inf or m is S.ComplexInfinity
+            terms.append((c.p, c.q, m))
+
+        if not inf:
+            ngcd = reduce(igcd, [t[0] for t in terms], 0)
+            dlcm = reduce(ilcm, [t[1] for t in terms], 1)
+        else:
+            ngcd = reduce(igcd, [t[0] for t in terms if t[1]], 0)
+            dlcm = reduce(ilcm, [t[1] for t in terms if t[1]], 1)
+
+        if ngcd == dlcm == 1:
+            return S.One, self
+        if not inf:
+            for i, (p, q, term) in enumerate(terms):
+                terms[i] = _keep_coeff(Rational((p//ngcd)*(dlcm//q)), term)
+        else:
+            for i, (p, q, term) in enumerate(terms):
+                if q:
+                    terms[i] = _keep_coeff(Rational((p//ngcd)*(dlcm//q)), term)
+                else:
+                    terms[i] = _keep_coeff(Rational(p, q), term)
+
+        # we don't need a complete re-flattening since no new terms will join
+        # so we just use the same sort as is used in Add.flatten. When the
+        # coefficient changes, the ordering of terms may change, e.g.
+        #     (3*x, 6*y) -> (2*y, x)
+        #
+        # We do need to make sure that term[0] stays in position 0, however.
+        #
+        if terms[0].is_Number or terms[0] is S.ComplexInfinity:
+            c = terms.pop(0)
+        else:
+            c = None
+        _addsort(terms)
+        if c:
+            terms.insert(0, c)
+        return Rational(ngcd, dlcm), self._new_rawargs(*terms)
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """Return the tuple (R, self/R) where R is the positive Rational
+        extracted from self. If radical is True (default is False) then
+        common radicals will be removed and included as a factor of the
+        primitive expression.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> (3 + 3*sqrt(2)).as_content_primitive()
+        (3, 1 + sqrt(2))
+
+        Radical content can also be factored out of the primitive:
+
+        >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
+        (2, sqrt(2)*(1 + 2*sqrt(5)))
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+        con, prim = self.func(*[_keep_coeff(*a.as_content_primitive(
+            radical=radical, clear=clear)) for a in self.args]).primitive()
+        if not clear and not con.is_Integer and prim.is_Add:
+            con, d = con.as_numer_denom()
+            _p = prim/d
+            if any(a.as_coeff_Mul()[0].is_Integer for a in _p.args):
+                prim = _p
+            else:
+                con /= d
+        if radical and prim.is_Add:
+            # look for common radicals that can be removed
+            args = prim.args
+            rads = []
+            common_q = None
+            for m in args:
+                term_rads = defaultdict(list)
+                for ai in Mul.make_args(m):
+                    if ai.is_Pow:
+                        b, e = ai.as_base_exp()
+                        if e.is_Rational and b.is_Integer:
+                            term_rads[e.q].append(abs(int(b))**e.p)
+                if not term_rads:
+                    break
+                if common_q is None:
+                    common_q = set(term_rads.keys())
+                else:
+                    common_q = common_q & set(term_rads.keys())
+                    if not common_q:
+                        break
+                rads.append(term_rads)
+            else:
+                # process rads
+                # keep only those in common_q
+                for r in rads:
+                    for q in list(r.keys()):
+                        if q not in common_q:
+                            r.pop(q)
+                    for q in r:
+                        r[q] = Mul(*r[q])
+                # find the gcd of bases for each q
+                G = []
+                for q in common_q:
+                    g = reduce(igcd, [r[q] for r in rads], 0)
+                    if g != 1:
+                        G.append(g**Rational(1, q))
+                if G:
+                    G = Mul(*G)
+                    args = [ai/G for ai in args]
+                    prim = G*prim.func(*args)
+
+        return con, prim
+
+    @property
+    def _sorted_args(self):
+        from .sorting import default_sort_key
+        return tuple(sorted(self.args, key=default_sort_key))
+
+    def _eval_difference_delta(self, n, step):
+        from sympy.series.limitseq import difference_delta as dd
+        return self.func(*[dd(a, n, step) for a in self.args])
+
+    @property
+    def _mpc_(self):
+        """
+        Convert self to an mpmath mpc if possible
+        """
+        from .numbers import Float
+        re_part, rest = self.as_coeff_Add()
+        im_part, imag_unit = rest.as_coeff_Mul()
+        if not imag_unit == S.ImaginaryUnit:
+            # ValueError may seem more reasonable but since it's a @property,
+            # we need to use AttributeError to keep from confusing things like
+            # hasattr.
+            raise AttributeError("Cannot convert Add to mpc. Must be of the form Number + Number*I")
+
+        return (Float(re_part)._mpf_, Float(im_part)._mpf_)
+
+    def __neg__(self):
+        if not global_parameters.distribute:
+            return super().__neg__()
+        return Mul(S.NegativeOne, self)
+
+add = AssocOpDispatcher('add')
+
+from .mul import Mul, _keep_coeff, _unevaluated_Mul
+from .numbers import Rational

llmeval-env/lib/python3.10/site-packages/sympy/core/alphabets.py

@@ -0,0 +1,4 @@
+greeks = ('alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta',
+                    'eta', 'theta', 'iota', 'kappa', 'lambda', 'mu', 'nu',
+                    'xi', 'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon',
+                    'phi', 'chi', 'psi', 'omega')

llmeval-env/lib/python3.10/site-packages/sympy/core/backend.py

@@ -0,0 +1,84 @@
+import os
+USE_SYMENGINE = os.getenv('USE_SYMENGINE', '0')
+USE_SYMENGINE = USE_SYMENGINE.lower() in ('1', 't', 'true')  # type: ignore
+
+if USE_SYMENGINE:
+    from symengine import (Symbol, Integer, sympify, S,
+        SympifyError, exp, log, gamma, sqrt, I, E, pi, Matrix,
+        sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, acsc, asec,
+        sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth,
+        lambdify, symarray, diff, zeros, eye, diag, ones,
+        expand, Function, symbols, var, Add, Mul, Derivative,
+        ImmutableMatrix, MatrixBase, Rational, Basic)
+    from symengine.lib.symengine_wrapper import gcd as igcd
+    from symengine import AppliedUndef
+else:
+    from sympy.core.add import Add
+    from sympy.core.basic import Basic
+    from sympy.core.function import (diff, Function, AppliedUndef,
+        expand, Derivative)
+    from sympy.core.mul import Mul
+    from sympy.core.numbers import igcd, pi, I, Integer, Rational, E
+    from sympy.core.singleton import S
+    from sympy.core.symbol import Symbol, var, symbols
+    from sympy.core.sympify import SympifyError, sympify
+    from sympy.functions.elementary.exponential import log, exp
+    from sympy.functions.elementary.hyperbolic import (coth, sinh,
+        acosh, acoth, tanh, asinh, atanh, cosh)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (csc,
+        asec, cos, atan, sec, acot, asin, tan, sin, cot, acsc, acos)
+    from sympy.functions.special.gamma_functions import gamma
+    from sympy.matrices.dense import (eye, zeros, diag, Matrix,
+        ones, symarray)
+    from sympy.matrices.immutable import ImmutableMatrix
+    from sympy.matrices.matrices import MatrixBase
+    from sympy.utilities.lambdify import lambdify
+
+
+#
+# XXX: Handling of immutable and mutable matrices in SymEngine is inconsistent
+# with SymPy's matrix classes in at least SymEngine version 0.7.0. Until that
+# is fixed the function below is needed for consistent behaviour when
+# attempting to simplify a matrix.
+#
+# Expected behaviour of a SymPy mutable/immutable matrix .simplify() method:
+#
+#   Matrix.simplify() : works in place, returns None
+#   ImmutableMatrix.simplify() : returns a simplified copy
+#
+# In SymEngine both mutable and immutable matrices simplify in place and return
+# None. This is inconsistent with the matrix being "immutable" and also the
+# returned None leads to problems in the mechanics module.
+#
+# The simplify function should not be used because simplify(M) sympifies the
+# matrix M and the SymEngine matrices all sympify to SymPy matrices. If we want
+# to work with SymEngine matrices then we need to use their .simplify() method
+# but that method does not work correctly with immutable matrices.
+#
+# The _simplify_matrix function can be removed when the SymEngine bug is fixed.
+# Since this should be a temporary problem we do not make this function part of
+# the public API.
+#
+#   SymEngine issue: https://github.com/symengine/symengine.py/issues/363
+#
+
+def _simplify_matrix(M):
+    """Return a simplified copy of the matrix M"""
+    assert isinstance(M, (Matrix, ImmutableMatrix))
+    Mnew = M.as_mutable() # makes a copy if mutable
+    Mnew.simplify()
+    if isinstance(M, ImmutableMatrix):
+        Mnew = Mnew.as_immutable()
+    return Mnew
+
+
+__all__ = [
+    'Symbol', 'Integer', 'sympify', 'S', 'SympifyError', 'exp', 'log',
+    'gamma', 'sqrt', 'I', 'E', 'pi', 'Matrix', 'sin', 'cos', 'tan', 'cot',
+    'csc', 'sec', 'asin', 'acos', 'atan', 'acot', 'acsc', 'asec', 'sinh',
+    'cosh', 'tanh', 'coth', 'asinh', 'acosh', 'atanh', 'acoth', 'lambdify',
+    'symarray', 'diff', 'zeros', 'eye', 'diag', 'ones', 'expand', 'Function',
+    'symbols', 'var', 'Add', 'Mul', 'Derivative', 'ImmutableMatrix',
+    'MatrixBase', 'Rational', 'Basic', 'igcd', 'AppliedUndef',
+]

llmeval-env/lib/python3.10/site-packages/sympy/core/cache.py

@@ -0,0 +1,210 @@
+""" Caching facility for SymPy """
+from importlib import import_module
+from typing import Callable
+
+class _cache(list):
+    """ List of cached functions """
+
+    def print_cache(self):
+        """print cache info"""
+
+        for item in self:
+            name = item.__name__
+            myfunc = item
+            while hasattr(myfunc, '__wrapped__'):
+                if hasattr(myfunc, 'cache_info'):
+                    info = myfunc.cache_info()
+                    break
+                else:
+                    myfunc = myfunc.__wrapped__
+            else:
+                info = None
+
+            print(name, info)
+
+    def clear_cache(self):
+        """clear cache content"""
+        for item in self:
+            myfunc = item
+            while hasattr(myfunc, '__wrapped__'):
+                if hasattr(myfunc, 'cache_clear'):
+                    myfunc.cache_clear()
+                    break
+                else:
+                    myfunc = myfunc.__wrapped__
+
+
+# global cache registry:
+CACHE = _cache()
+# make clear and print methods available
+print_cache = CACHE.print_cache
+clear_cache = CACHE.clear_cache
+
+from functools import lru_cache, wraps
+
+def __cacheit(maxsize):
+    """caching decorator.
+
+        important: the result of cached function must be *immutable*
+
+
+        Examples
+        ========
+
+        >>> from sympy import cacheit
+        >>> @cacheit
+        ... def f(a, b):
+        ...    return a+b
+
+        >>> @cacheit
+        ... def f(a, b): # noqa: F811
+        ...    return [a, b] # <-- WRONG, returns mutable object
+
+        to force cacheit to check returned results mutability and consistency,
+        set environment variable SYMPY_USE_CACHE to 'debug'
+    """
+    def func_wrapper(func):
+        cfunc = lru_cache(maxsize, typed=True)(func)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                retval = cfunc(*args, **kwargs)
+            except TypeError as e:
+                if not e.args or not e.args[0].startswith('unhashable type:'):
+                    raise
+                retval = func(*args, **kwargs)
+            return retval
+
+        wrapper.cache_info = cfunc.cache_info
+        wrapper.cache_clear = cfunc.cache_clear
+
+        CACHE.append(wrapper)
+        return wrapper
+
+    return func_wrapper
+########################################
+
+
+def __cacheit_nocache(func):
+    return func
+
+
+def __cacheit_debug(maxsize):
+    """cacheit + code to check cache consistency"""
+    def func_wrapper(func):
+        cfunc = __cacheit(maxsize)(func)
+
+        @wraps(func)
+        def wrapper(*args, **kw_args):
+            # always call function itself and compare it with cached version
+            r1 = func(*args, **kw_args)
+            r2 = cfunc(*args, **kw_args)
+
+            # try to see if the result is immutable
+            #
+            # this works because:
+            #
+            # hash([1,2,3])         -> raise TypeError
+            # hash({'a':1, 'b':2})  -> raise TypeError
+            # hash((1,[2,3]))       -> raise TypeError
+            #
+            # hash((1,2,3))         -> just computes the hash
+            hash(r1), hash(r2)
+
+            # also see if returned values are the same
+            if r1 != r2:
+                raise RuntimeError("Returned values are not the same")
+            return r1
+        return wrapper
+    return func_wrapper
+
+
+def _getenv(key, default=None):
+    from os import getenv
+    return getenv(key, default)
+
+# SYMPY_USE_CACHE=yes/no/debug
+USE_CACHE = _getenv('SYMPY_USE_CACHE', 'yes').lower()
+# SYMPY_CACHE_SIZE=some_integer/None
+# special cases :
+#  SYMPY_CACHE_SIZE=0    -> No caching
+#  SYMPY_CACHE_SIZE=None -> Unbounded caching
+scs = _getenv('SYMPY_CACHE_SIZE', '1000')
+if scs.lower() == 'none':
+    SYMPY_CACHE_SIZE = None
+else:
+    try:
+        SYMPY_CACHE_SIZE = int(scs)
+    except ValueError:
+        raise RuntimeError(
+            'SYMPY_CACHE_SIZE must be a valid integer or None. ' + \
+            'Got: %s' % SYMPY_CACHE_SIZE)
+
+if USE_CACHE == 'no':
+    cacheit = __cacheit_nocache
+elif USE_CACHE == 'yes':
+    cacheit = __cacheit(SYMPY_CACHE_SIZE)
+elif USE_CACHE == 'debug':
+    cacheit = __cacheit_debug(SYMPY_CACHE_SIZE)   # a lot slower
+else:
+    raise RuntimeError(
+        'unrecognized value for SYMPY_USE_CACHE: %s' % USE_CACHE)
+
+
+def cached_property(func):
+    '''Decorator to cache property method'''
+    attrname = '__' + func.__name__
+    _cached_property_sentinel = object()
+    def propfunc(self):
+        val = getattr(self, attrname, _cached_property_sentinel)
+        if val is _cached_property_sentinel:
+            val = func(self)
+            setattr(self, attrname, val)
+        return val
+    return property(propfunc)
+
+
+def lazy_function(module : str, name : str) -> Callable:
+    """Create a lazy proxy for a function in a module.
+
+    The module containing the function is not imported until the function is used.
+
+    """
+    func = None
+
+    def _get_function():
+        nonlocal func
+        if func is None:
+            func = getattr(import_module(module), name)
+        return func
+
+    # The metaclass is needed so that help() shows the docstring
+    class LazyFunctionMeta(type):
+        @property
+        def __doc__(self):
+            docstring = _get_function().__doc__
+            docstring += f"\n\nNote: this is a {self.__class__.__name__} wrapper of '{module}.{name}'"
+            return docstring
+
+    class LazyFunction(metaclass=LazyFunctionMeta):
+        def __call__(self, *args, **kwargs):
+            # inline get of function for performance gh-23832
+            nonlocal func
+            if func is None:
+                func = getattr(import_module(module), name)
+            return func(*args, **kwargs)
+
+        @property
+        def __doc__(self):
+            docstring = _get_function().__doc__
+            docstring += f"\n\nNote: this is a {self.__class__.__name__} wrapper of '{module}.{name}'"
+            return docstring
+
+        def __str__(self):
+            return _get_function().__str__()
+
+        def __repr__(self):
+            return f"<{__class__.__name__} object at 0x{id(self):x}>: wrapping '{module}.{name}'"
+
+    return LazyFunction()

llmeval-env/lib/python3.10/site-packages/sympy/core/compatibility.py

@@ -0,0 +1,35 @@
+"""
+.. deprecated:: 1.10
+
+   ``sympy.core.compatibility`` is deprecated. See
+   :ref:`sympy-core-compatibility`.
+
+Reimplementations of constructs introduced in later versions of Python than
+we support. Also some functions that are needed SymPy-wide and are located
+here for easy import.
+
+"""
+
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning("""
+The sympy.core.compatibility submodule is deprecated.
+
+This module was only ever intended for internal use. Some of the functions
+that were in this module are available from the top-level SymPy namespace,
+i.e.,
+
+    from sympy import ordered, default_sort_key
+
+The remaining were only intended for internal SymPy use and should not be used
+by user code.
+""",
+                          deprecated_since_version="1.10",
+                          active_deprecations_target="deprecated-sympy-core-compatibility",
+                          )
+
+
+from .sorting import ordered, _nodes, default_sort_key # noqa:F401
+from sympy.utilities.misc import as_int as _as_int # noqa:F401
+from sympy.utilities.iterables import iterable, is_sequence, NotIterable # noqa:F401

llmeval-env/lib/python3.10/site-packages/sympy/core/containers.py

@@ -0,0 +1,410 @@
+"""Module for SymPy containers
+
+    (SymPy objects that store other SymPy objects)
+
+    The containers implemented in this module are subclassed to Basic.
+    They are supposed to work seamlessly within the SymPy framework.
+"""
+
+from collections import OrderedDict
+from collections.abc import MutableSet
+from typing import Any, Callable
+
+from .basic import Basic
+from .sorting import default_sort_key, ordered
+from .sympify import _sympify, sympify, _sympy_converter, SympifyError
+from sympy.core.kind import Kind
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+class Tuple(Basic):
+    """
+    Wrapper around the builtin tuple object.
+
+    Explanation
+    ===========
+
+    The Tuple is a subclass of Basic, so that it works well in the
+    SymPy framework.  The wrapped tuple is available as self.args, but
+    you can also access elements or slices with [:] syntax.
+
+    Parameters
+    ==========
+
+    sympify : bool
+        If ``False``, ``sympify`` is not called on ``args``. This
+        can be used for speedups for very large tuples where the
+        elements are known to already be SymPy objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Tuple, symbols
+    >>> a, b, c, d = symbols('a b c d')
+    >>> Tuple(a, b, c)[1:]
+    (b, c)
+    >>> Tuple(a, b, c).subs(a, d)
+    (d, b, c)
+
+    """
+
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get('sympify', True):
+            args = (sympify(arg) for arg in args)
+        obj = Basic.__new__(cls, *args)
+        return obj
+
+    def __getitem__(self, i):
+        if isinstance(i, slice):
+            indices = i.indices(len(self))
+            return Tuple(*(self.args[j] for j in range(*indices)))
+        return self.args[i]
+
+    def __len__(self):
+        return len(self.args)
+
+    def __contains__(self, item):
+        return item in self.args
+
+    def __iter__(self):
+        return iter(self.args)
+
+    def __add__(self, other):
+        if isinstance(other, Tuple):
+            return Tuple(*(self.args + other.args))
+        elif isinstance(other, tuple):
+            return Tuple(*(self.args + other))
+        else:
+            return NotImplemented
+
+    def __radd__(self, other):
+        if isinstance(other, Tuple):
+            return Tuple(*(other.args + self.args))
+        elif isinstance(other, tuple):
+            return Tuple(*(other + self.args))
+        else:
+            return NotImplemented
+
+    def __mul__(self, other):
+        try:
+            n = as_int(other)
+        except ValueError:
+            raise TypeError("Can't multiply sequence by non-integer of type '%s'" % type(other))
+        return self.func(*(self.args*n))
+
+    __rmul__ = __mul__
+
+    def __eq__(self, other):
+        if isinstance(other, Basic):
+            return super().__eq__(other)
+        return self.args == other
+
+    def __ne__(self, other):
+        if isinstance(other, Basic):
+            return super().__ne__(other)
+        return self.args != other
+
+    def __hash__(self):
+        return hash(self.args)
+
+    def _to_mpmath(self, prec):
+        return tuple(a._to_mpmath(prec) for a in self.args)
+
+    def __lt__(self, other):
+        return _sympify(self.args < other.args)
+
+    def __le__(self, other):
+        return _sympify(self.args <= other.args)
+
+    # XXX: Basic defines count() as something different, so we can't
+    # redefine it here. Originally this lead to cse() test failure.
+    def tuple_count(self, value) -> int:
+        """Return number of occurrences of value."""
+        return self.args.count(value)
+
+    def index(self, value, start=None, stop=None):
+        """Searches and returns the first index of the value."""
+        # XXX: One would expect:
+        #
+        # return self.args.index(value, start, stop)
+        #
+        # here. Any trouble with that? Yes:
+        #
+        # >>> (1,).index(1, None, None)
+        # Traceback (most recent call last):
+        #   File "<stdin>", line 1, in <module>
+        # TypeError: slice indices must be integers or None or have an __index__ method
+        #
+        # See: http://bugs.python.org/issue13340
+
+        if start is None and stop is None:
+            return self.args.index(value)
+        elif stop is None:
+            return self.args.index(value, start)
+        else:
+            return self.args.index(value, start, stop)
+
+    @property
+    def kind(self):
+        """
+        The kind of a Tuple instance.
+
+        The kind of a Tuple is always of :class:`TupleKind` but
+        parametrised by the number of elements and the kind of each element.
+
+        Examples
+        ========
+
+        >>> from sympy import Tuple, Matrix
+        >>> Tuple(1, 2).kind
+        TupleKind(NumberKind, NumberKind)
+        >>> Tuple(Matrix([1, 2]), 1).kind
+        TupleKind(MatrixKind(NumberKind), NumberKind)
+        >>> Tuple(1, 2).kind.element_kind
+        (NumberKind, NumberKind)
+
+        See Also
+        ========
+
+        sympy.matrices.common.MatrixKind
+        sympy.core.kind.NumberKind
+        """
+        return TupleKind(*(i.kind for i in self.args))
+
+_sympy_converter[tuple] = lambda tup: Tuple(*tup)
+
+
+
+
+
+def tuple_wrapper(method):
+    """
+    Decorator that converts any tuple in the function arguments into a Tuple.
+
+    Explanation
+    ===========
+
+    The motivation for this is to provide simple user interfaces.  The user can
+    call a function with regular tuples in the argument, and the wrapper will
+    convert them to Tuples before handing them to the function.
+
+    Explanation
+    ===========
+
+    >>> from sympy.core.containers import tuple_wrapper
+    >>> def f(*args):
+    ...    return args
+    >>> g = tuple_wrapper(f)
+
+    The decorated function g sees only the Tuple argument:
+
+    >>> g(0, (1, 2), 3)
+    (0, (1, 2), 3)
+
+    """
+    def wrap_tuples(*args, **kw_args):
+        newargs = []
+        for arg in args:
+            if isinstance(arg, tuple):
+                newargs.append(Tuple(*arg))
+            else:
+                newargs.append(arg)
+        return method(*newargs, **kw_args)
+    return wrap_tuples
+
+
+class Dict(Basic):
+    """
+    Wrapper around the builtin dict object.
+
+    Explanation
+    ===========
+
+    The Dict is a subclass of Basic, so that it works well in the
+    SymPy framework.  Because it is immutable, it may be included
+    in sets, but its values must all be given at instantiation and
+    cannot be changed afterwards.  Otherwise it behaves identically
+    to the Python dict.
+
+    Examples
+    ========
+
+    >>> from sympy import Dict, Symbol
+
+    >>> D = Dict({1: 'one', 2: 'two'})
+    >>> for key in D:
+    ...    if key == 1:
+    ...        print('%s %s' % (key, D[key]))
+    1 one
+
+    The args are sympified so the 1 and 2 are Integers and the values
+    are Symbols. Queries automatically sympify args so the following work:
+
+    >>> 1 in D
+    True
+    >>> D.has(Symbol('one')) # searches keys and values
+    True
+    >>> 'one' in D # not in the keys
+    False
+    >>> D[1]
+    one
+
+    """
+
+    def __new__(cls, *args):
+        if len(args) == 1 and isinstance(args[0], (dict, Dict)):
+            items = [Tuple(k, v) for k, v in args[0].items()]
+        elif iterable(args) and all(len(arg) == 2 for arg in args):
+            items = [Tuple(k, v) for k, v in args]
+        else:
+            raise TypeError('Pass Dict args as Dict((k1, v1), ...) or Dict({k1: v1, ...})')
+        elements = frozenset(items)
+        obj = Basic.__new__(cls, *ordered(items))
+        obj.elements = elements
+        obj._dict = dict(items)  # In case Tuple decides it wants to sympify
+        return obj
+
+    def __getitem__(self, key):
+        """x.__getitem__(y) <==> x[y]"""
+        try:
+            key = _sympify(key)
+        except SympifyError:
+            raise KeyError(key)
+
+        return self._dict[key]
+
+    def __setitem__(self, key, value):
+        raise NotImplementedError("SymPy Dicts are Immutable")
+
+    def items(self):
+        '''Returns a set-like object providing a view on dict's items.
+        '''
+        return self._dict.items()
+
+    def keys(self):
+        '''Returns the list of the dict's keys.'''
+        return self._dict.keys()
+
+    def values(self):
+        '''Returns the list of the dict's values.'''
+        return self._dict.values()
+
+    def __iter__(self):
+        '''x.__iter__() <==> iter(x)'''
+        return iter(self._dict)
+
+    def __len__(self):
+        '''x.__len__() <==> len(x)'''
+        return self._dict.__len__()
+
+    def get(self, key, default=None):
+        '''Returns the value for key if the key is in the dictionary.'''
+        try:
+            key = _sympify(key)
+        except SympifyError:
+            return default
+        return self._dict.get(key, default)
+
+    def __contains__(self, key):
+        '''D.__contains__(k) -> True if D has a key k, else False'''
+        try:
+            key = _sympify(key)
+        except SympifyError:
+            return False
+        return key in self._dict
+
+    def __lt__(self, other):
+        return _sympify(self.args < other.args)
+
+    @property
+    def _sorted_args(self):
+        return tuple(sorted(self.args, key=default_sort_key))
+
+    def __eq__(self, other):
+        if isinstance(other, dict):
+            return self == Dict(other)
+        return super().__eq__(other)
+
+    __hash__ : Callable[[Basic], Any] = Basic.__hash__
+
+# this handles dict, defaultdict, OrderedDict
+_sympy_converter[dict] = lambda d: Dict(*d.items())
+
+class OrderedSet(MutableSet):
+    def __init__(self, iterable=None):
+        if iterable:
+            self.map = OrderedDict((item, None) for item in iterable)
+        else:
+            self.map = OrderedDict()
+
+    def __len__(self):
+        return len(self.map)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def add(self, key):
+        self.map[key] = None
+
+    def discard(self, key):
+        self.map.pop(key)
+
+    def pop(self, last=True):
+        return self.map.popitem(last=last)[0]
+
+    def __iter__(self):
+        yield from self.map.keys()
+
+    def __repr__(self):
+        if not self.map:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, list(self.map.keys()))
+
+    def intersection(self, other):
+        return self.__class__([val for val in self if val in other])
+
+    def difference(self, other):
+        return self.__class__([val for val in self if val not in other])
+
+    def update(self, iterable):
+        for val in iterable:
+            self.add(val)
+
+class TupleKind(Kind):
+    """
+    TupleKind is a subclass of Kind, which is used to define Kind of ``Tuple``.
+
+    Parameters of TupleKind will be kinds of all the arguments in Tuples, for
+    example
+
+    Parameters
+    ==========
+
+    args : tuple(element_kind)
+       element_kind is kind of element.
+       args is tuple of kinds of element
+
+    Examples
+    ========
+
+    >>> from sympy import Tuple
+    >>> Tuple(1, 2).kind
+    TupleKind(NumberKind, NumberKind)
+    >>> Tuple(1, 2).kind.element_kind
+    (NumberKind, NumberKind)
+
+    See Also
+    ========
+
+    sympy.core.kind.NumberKind
+    MatrixKind
+    sympy.sets.sets.SetKind
+    """
+    def __new__(cls, *args):
+        obj = super().__new__(cls, *args)
+        obj.element_kind = args
+        return obj
+
+    def __repr__(self):
+        return "TupleKind{}".format(self.element_kind)

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

@@ -0,0 +1,63 @@
+""" The core's core. """
+from __future__ import annotations
+
+
+# used for canonical ordering of symbolic sequences
+# via __cmp__ method:
+# FIXME this is *so* irrelevant and outdated!
+ordering_of_classes = [
+    # singleton numbers
+    'Zero', 'One', 'Half', 'Infinity', 'NaN', 'NegativeOne', 'NegativeInfinity',
+    # numbers
+    'Integer', 'Rational', 'Float',
+    # singleton symbols
+    'Exp1', 'Pi', 'ImaginaryUnit',
+    # symbols
+    'Symbol', 'Wild', 'Temporary',
+    # arithmetic operations
+    'Pow', 'Mul', 'Add',
+    # function values
+    'Derivative', 'Integral',
+    # defined singleton functions
+    'Abs', 'Sign', 'Sqrt',
+    'Floor', 'Ceiling',
+    'Re', 'Im', 'Arg',
+    'Conjugate',
+    'Exp', 'Log',
+    'Sin', 'Cos', 'Tan', 'Cot', 'ASin', 'ACos', 'ATan', 'ACot',
+    'Sinh', 'Cosh', 'Tanh', 'Coth', 'ASinh', 'ACosh', 'ATanh', 'ACoth',
+    'RisingFactorial', 'FallingFactorial',
+    'factorial', 'binomial',
+    'Gamma', 'LowerGamma', 'UpperGamma', 'PolyGamma',
+    'Erf',
+    # special polynomials
+    'Chebyshev', 'Chebyshev2',
+    # undefined functions
+    'Function', 'WildFunction',
+    # anonymous functions
+    'Lambda',
+    # Landau O symbol
+    'Order',
+    # relational operations
+    'Equality', 'Unequality', 'StrictGreaterThan', 'StrictLessThan',
+    'GreaterThan', 'LessThan',
+]
+
+
+class Registry:
+    """
+    Base class for registry objects.
+
+    Registries map a name to an object using attribute notation. Registry
+    classes behave singletonically: all their instances share the same state,
+    which is stored in the class object.
+
+    All subclasses should set `__slots__ = ()`.
+    """
+    __slots__ = ()
+
+    def __setattr__(self, name, obj):
+        setattr(self.__class__, name, obj)
+
+    def __delattr__(self, name):
+        delattr(self.__class__, name)

llmeval-env/lib/python3.10/site-packages/sympy/core/coreerrors.py

@@ -0,0 +1,9 @@
+"""Definitions of common exceptions for :mod:`sympy.core` module. """
+
+
+class BaseCoreError(Exception):
+    """Base class for core related exceptions. """
+
+
+class NonCommutativeExpression(BaseCoreError):
+    """Raised when expression didn't have commutative property. """

llmeval-env/lib/python3.10/site-packages/sympy/core/decorators.py

@@ -0,0 +1,238 @@
+"""
+SymPy core decorators.
+
+The purpose of this module is to expose decorators without any other
+dependencies, so that they can be easily imported anywhere in sympy/core.
+"""
+
+from functools import wraps
+from .sympify import SympifyError, sympify
+
+
+def _sympifyit(arg, retval=None):
+    """
+    decorator to smartly _sympify function arguments
+
+    Explanation
+    ===========
+
+    @_sympifyit('other', NotImplemented)
+    def add(self, other):
+        ...
+
+    In add, other can be thought of as already being a SymPy object.
+
+    If it is not, the code is likely to catch an exception, then other will
+    be explicitly _sympified, and the whole code restarted.
+
+    if _sympify(arg) fails, NotImplemented will be returned
+
+    See also
+    ========
+
+    __sympifyit
+    """
+    def deco(func):
+        return __sympifyit(func, arg, retval)
+
+    return deco
+
+
+def __sympifyit(func, arg, retval=None):
+    """Decorator to _sympify `arg` argument for function `func`.
+
+       Do not use directly -- use _sympifyit instead.
+    """
+
+    # we support f(a,b) only
+    if not func.__code__.co_argcount:
+        raise LookupError("func not found")
+    # only b is _sympified
+    assert func.__code__.co_varnames[1] == arg
+    if retval is None:
+        @wraps(func)
+        def __sympifyit_wrapper(a, b):
+            return func(a, sympify(b, strict=True))
+
+    else:
+        @wraps(func)
+        def __sympifyit_wrapper(a, b):
+            try:
+                # If an external class has _op_priority, it knows how to deal
+                # with SymPy objects. Otherwise, it must be converted.
+                if not hasattr(b, '_op_priority'):
+                    b = sympify(b, strict=True)
+                return func(a, b)
+            except SympifyError:
+                return retval
+
+    return __sympifyit_wrapper
+
+
+def call_highest_priority(method_name):
+    """A decorator for binary special methods to handle _op_priority.
+
+    Explanation
+    ===========
+
+    Binary special methods in Expr and its subclasses use a special attribute
+    '_op_priority' to determine whose special method will be called to
+    handle the operation. In general, the object having the highest value of
+    '_op_priority' will handle the operation. Expr and subclasses that define
+    custom binary special methods (__mul__, etc.) should decorate those
+    methods with this decorator to add the priority logic.
+
+    The ``method_name`` argument is the name of the method of the other class
+    that will be called.  Use this decorator in the following manner::
+
+        # Call other.__rmul__ if other._op_priority > self._op_priority
+        @call_highest_priority('__rmul__')
+        def __mul__(self, other):
+            ...
+
+        # Call other.__mul__ if other._op_priority > self._op_priority
+        @call_highest_priority('__mul__')
+        def __rmul__(self, other):
+        ...
+    """
+    def priority_decorator(func):
+        @wraps(func)
+        def binary_op_wrapper(self, other):
+            if hasattr(other, '_op_priority'):
+                if other._op_priority > self._op_priority:
+                    f = getattr(other, method_name, None)
+                    if f is not None:
+                        return f(self)
+            return func(self, other)
+        return binary_op_wrapper
+    return priority_decorator
+
+
+def sympify_method_args(cls):
+    '''Decorator for a class with methods that sympify arguments.
+
+    Explanation
+    ===========
+
+    The sympify_method_args decorator is to be used with the sympify_return
+    decorator for automatic sympification of method arguments. This is
+    intended for the common idiom of writing a class like :
+
+    Examples
+    ========
+
+    >>> from sympy import Basic, SympifyError, S
+    >>> from sympy.core.sympify import _sympify
+
+    >>> class MyTuple(Basic):
+    ...     def __add__(self, other):
+    ...         try:
+    ...             other = _sympify(other)
+    ...         except SympifyError:
+    ...             return NotImplemented
+    ...         if not isinstance(other, MyTuple):
+    ...             return NotImplemented
+    ...         return MyTuple(*(self.args + other.args))
+
+    >>> MyTuple(S(1), S(2)) + MyTuple(S(3), S(4))
+    MyTuple(1, 2, 3, 4)
+
+    In the above it is important that we return NotImplemented when other is
+    not sympifiable and also when the sympified result is not of the expected
+    type. This allows the MyTuple class to be used cooperatively with other
+    classes that overload __add__ and want to do something else in combination
+    with instance of Tuple.
+
+    Using this decorator the above can be written as
+
+    >>> from sympy.core.decorators import sympify_method_args, sympify_return
+
+    >>> @sympify_method_args
+    ... class MyTuple(Basic):
+    ...     @sympify_return([('other', 'MyTuple')], NotImplemented)
+    ...     def __add__(self, other):
+    ...          return MyTuple(*(self.args + other.args))
+
+    >>> MyTuple(S(1), S(2)) + MyTuple(S(3), S(4))
+    MyTuple(1, 2, 3, 4)
+
+    The idea here is that the decorators take care of the boiler-plate code
+    for making this happen in each method that potentially needs to accept
+    unsympified arguments. Then the body of e.g. the __add__ method can be
+    written without needing to worry about calling _sympify or checking the
+    type of the resulting object.
+
+    The parameters for sympify_return are a list of tuples of the form
+    (parameter_name, expected_type) and the value to return (e.g.
+    NotImplemented). The expected_type parameter can be a type e.g. Tuple or a
+    string 'Tuple'. Using a string is useful for specifying a Type within its
+    class body (as in the above example).
+
+    Notes: Currently sympify_return only works for methods that take a single
+    argument (not including self). Specifying an expected_type as a string
+    only works for the class in which the method is defined.
+    '''
+    # Extract the wrapped methods from each of the wrapper objects created by
+    # the sympify_return decorator. Doing this here allows us to provide the
+    # cls argument which is used for forward string referencing.
+    for attrname, obj in cls.__dict__.items():
+        if isinstance(obj, _SympifyWrapper):
+            setattr(cls, attrname, obj.make_wrapped(cls))
+    return cls
+
+
+def sympify_return(*args):
+    '''Function/method decorator to sympify arguments automatically
+
+    See the docstring of sympify_method_args for explanation.
+    '''
+    # Store a wrapper object for the decorated method
+    def wrapper(func):
+        return _SympifyWrapper(func, args)
+    return wrapper
+
+
+class _SympifyWrapper:
+    '''Internal class used by sympify_return and sympify_method_args'''
+
+    def __init__(self, func, args):
+        self.func = func
+        self.args = args
+
+    def make_wrapped(self, cls):
+        func = self.func
+        parameters, retval = self.args
+
+        # XXX: Handle more than one parameter?
+        [(parameter, expectedcls)] = parameters
+
+        # Handle forward references to the current class using strings
+        if expectedcls == cls.__name__:
+            expectedcls = cls
+
+        # Raise RuntimeError since this is a failure at import time and should
+        # not be recoverable.
+        nargs = func.__code__.co_argcount
+        # we support f(a, b) only
+        if nargs != 2:
+            raise RuntimeError('sympify_return can only be used with 2 argument functions')
+        # only b is _sympified
+        if func.__code__.co_varnames[1] != parameter:
+            raise RuntimeError('parameter name mismatch "%s" in %s' %
+                    (parameter, func.__name__))
+
+        @wraps(func)
+        def _func(self, other):
+            # XXX: The check for _op_priority here should be removed. It is
+            # needed to stop mutable matrices from being sympified to
+            # immutable matrices which breaks things in quantum...
+            if not hasattr(other, '_op_priority'):
+                try:
+                    other = sympify(other, strict=True)
+                except SympifyError:
+                    return retval
+            if not isinstance(other, expectedcls):
+                return retval
+            return func(self, other)
+
+        return _func

llmeval-env/lib/python3.10/site-packages/sympy/core/logic.py

@@ -0,0 +1,427 @@
+"""Logic expressions handling
+
+NOTE
+----
+
+at present this is mainly needed for facts.py, feel free however to improve
+this stuff for general purpose.
+"""
+
+from __future__ import annotations
+from typing import Optional
+
+# Type of a fuzzy bool
+FuzzyBool = Optional[bool]
+
+
+def _torf(args):
+    """Return True if all args are True, False if they
+    are all False, else None.
+
+    >>> from sympy.core.logic import _torf
+    >>> _torf((True, True))
+    True
+    >>> _torf((False, False))
+    False
+    >>> _torf((True, False))
+    """
+    sawT = sawF = False
+    for a in args:
+        if a is True:
+            if sawF:
+                return
+            sawT = True
+        elif a is False:
+            if sawT:
+                return
+            sawF = True
+        else:
+            return
+    return sawT
+
+
+def _fuzzy_group(args, quick_exit=False):
+    """Return True if all args are True, None if there is any None else False
+    unless ``quick_exit`` is True (then return None as soon as a second False
+    is seen.
+
+     ``_fuzzy_group`` is like ``fuzzy_and`` except that it is more
+    conservative in returning a False, waiting to make sure that all
+    arguments are True or False and returning None if any arguments are
+    None. It also has the capability of permiting only a single False and
+    returning None if more than one is seen. For example, the presence of a
+    single transcendental amongst rationals would indicate that the group is
+    no longer rational; but a second transcendental in the group would make the
+    determination impossible.
+
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import _fuzzy_group
+
+    By default, multiple Falses mean the group is broken:
+
+    >>> _fuzzy_group([False, False, True])
+    False
+
+    If multiple Falses mean the group status is unknown then set
+    `quick_exit` to True so None can be returned when the 2nd False is seen:
+
+    >>> _fuzzy_group([False, False, True], quick_exit=True)
+
+    But if only a single False is seen then the group is known to
+    be broken:
+
+    >>> _fuzzy_group([False, True, True], quick_exit=True)
+    False
+
+    """
+    saw_other = False
+    for a in args:
+        if a is True:
+            continue
+        if a is None:
+            return
+        if quick_exit and saw_other:
+            return
+        saw_other = True
+    return not saw_other
+
+
+def fuzzy_bool(x):
+    """Return True, False or None according to x.
+
+    Whereas bool(x) returns True or False, fuzzy_bool allows
+    for the None value and non-false values (which become None), too.
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import fuzzy_bool
+    >>> from sympy.abc import x
+    >>> fuzzy_bool(x), fuzzy_bool(None)
+    (None, None)
+    >>> bool(x), bool(None)
+    (True, False)
+
+    """
+    if x is None:
+        return None
+    if x in (True, False):
+        return bool(x)
+
+
+def fuzzy_and(args):
+    """Return True (all True), False (any False) or None.
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import fuzzy_and
+    >>> from sympy import Dummy
+
+    If you had a list of objects to test the commutivity of
+    and you want the fuzzy_and logic applied, passing an
+    iterator will allow the commutativity to only be computed
+    as many times as necessary. With this list, False can be
+    returned after analyzing the first symbol:
+
+    >>> syms = [Dummy(commutative=False), Dummy()]
+    >>> fuzzy_and(s.is_commutative for s in syms)
+    False
+
+    That False would require less work than if a list of pre-computed
+    items was sent:
+
+    >>> fuzzy_and([s.is_commutative for s in syms])
+    False
+    """
+
+    rv = True
+    for ai in args:
+        ai = fuzzy_bool(ai)
+        if ai is False:
+            return False
+        if rv:  # this will stop updating if a None is ever trapped
+            rv = ai
+    return rv
+
+
+def fuzzy_not(v):
+    """
+    Not in fuzzy logic
+
+    Return None if `v` is None else `not v`.
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import fuzzy_not
+    >>> fuzzy_not(True)
+    False
+    >>> fuzzy_not(None)
+    >>> fuzzy_not(False)
+    True
+
+    """
+    if v is None:
+        return v
+    else:
+        return not v
+
+
+def fuzzy_or(args):
+    """
+    Or in fuzzy logic. Returns True (any True), False (all False), or None
+
+    See the docstrings of fuzzy_and and fuzzy_not for more info.  fuzzy_or is
+    related to the two by the standard De Morgan's law.
+
+    >>> from sympy.core.logic import fuzzy_or
+    >>> fuzzy_or([True, False])
+    True
+    >>> fuzzy_or([True, None])
+    True
+    >>> fuzzy_or([False, False])
+    False
+    >>> print(fuzzy_or([False, None]))
+    None
+
+    """
+    rv = False
+    for ai in args:
+        ai = fuzzy_bool(ai)
+        if ai is True:
+            return True
+        if rv is False:  # this will stop updating if a None is ever trapped
+            rv = ai
+    return rv
+
+
+def fuzzy_xor(args):
+    """Return None if any element of args is not True or False, else
+    True (if there are an odd number of True elements), else False."""
+    t = f = 0
+    for a in args:
+        ai = fuzzy_bool(a)
+        if ai:
+            t += 1
+        elif ai is False:
+            f += 1
+        else:
+            return
+    return t % 2 == 1
+
+
+def fuzzy_nand(args):
+    """Return False if all args are True, True if they are all False,
+    else None."""
+    return fuzzy_not(fuzzy_and(args))
+
+
+class Logic:
+    """Logical expression"""
+    # {} 'op' -> LogicClass
+    op_2class: dict[str, type[Logic]] = {}
+
+    def __new__(cls, *args):
+        obj = object.__new__(cls)
+        obj.args = args
+        return obj
+
+    def __getnewargs__(self):
+        return self.args
+
+    def __hash__(self):
+        return hash((type(self).__name__,) + tuple(self.args))
+
+    def __eq__(a, b):
+        if not isinstance(b, type(a)):
+            return False
+        else:
+            return a.args == b.args
+
+    def __ne__(a, b):
+        if not isinstance(b, type(a)):
+            return True
+        else:
+            return a.args != b.args
+
+    def __lt__(self, other):
+        if self.__cmp__(other) == -1:
+            return True
+        return False
+
+    def __cmp__(self, other):
+        if type(self) is not type(other):
+            a = str(type(self))
+            b = str(type(other))
+        else:
+            a = self.args
+            b = other.args
+        return (a > b) - (a < b)
+
+    def __str__(self):
+        return '%s(%s)' % (self.__class__.__name__,
+                           ', '.join(str(a) for a in self.args))
+
+    __repr__ = __str__
+
+    @staticmethod
+    def fromstring(text):
+        """Logic from string with space around & and | but none after !.
+
+           e.g.
+
+           !a & b | c
+        """
+        lexpr = None  # current logical expression
+        schedop = None  # scheduled operation
+        for term in text.split():
+            # operation symbol
+            if term in '&|':
+                if schedop is not None:
+                    raise ValueError(
+                        'double op forbidden: "%s %s"' % (term, schedop))
+                if lexpr is None:
+                    raise ValueError(
+                        '%s cannot be in the beginning of expression' % term)
+                schedop = term
+                continue
+            if '&' in term or '|' in term:
+                raise ValueError('& and | must have space around them')
+            if term[0] == '!':
+                if len(term) == 1:
+                    raise ValueError('do not include space after "!"')
+                term = Not(term[1:])
+
+            # already scheduled operation, e.g. '&'
+            if schedop:
+                lexpr = Logic.op_2class[schedop](lexpr, term)
+                schedop = None
+                continue
+
+            # this should be atom
+            if lexpr is not None:
+                raise ValueError(
+                    'missing op between "%s" and "%s"' % (lexpr, term))
+
+            lexpr = term
+
+        # let's check that we ended up in correct state
+        if schedop is not None:
+            raise ValueError('premature end-of-expression in "%s"' % text)
+        if lexpr is None:
+            raise ValueError('"%s" is empty' % text)
+
+        # everything looks good now
+        return lexpr
+
+
+class AndOr_Base(Logic):
+
+    def __new__(cls, *args):
+        bargs = []
+        for a in args:
+            if a == cls.op_x_notx:
+                return a
+            elif a == (not cls.op_x_notx):
+                continue    # skip this argument
+            bargs.append(a)
+
+        args = sorted(set(cls.flatten(bargs)), key=hash)
+
+        for a in args:
+            if Not(a) in args:
+                return cls.op_x_notx
+
+        if len(args) == 1:
+            return args.pop()
+        elif len(args) == 0:
+            return not cls.op_x_notx
+
+        return Logic.__new__(cls, *args)
+
+    @classmethod
+    def flatten(cls, args):
+        # quick-n-dirty flattening for And and Or
+        args_queue = list(args)
+        res = []
+
+        while True:
+            try:
+                arg = args_queue.pop(0)
+            except IndexError:
+                break
+            if isinstance(arg, Logic):
+                if isinstance(arg, cls):
+                    args_queue.extend(arg.args)
+                    continue
+            res.append(arg)
+
+        args = tuple(res)
+        return args
+
+
+class And(AndOr_Base):
+    op_x_notx = False
+
+    def _eval_propagate_not(self):
+        # !(a&b&c ...) == !a | !b | !c ...
+        return Or(*[Not(a) for a in self.args])
+
+    # (a|b|...) & c == (a&c) | (b&c) | ...
+    def expand(self):
+
+        # first locate Or
+        for i, arg in enumerate(self.args):
+            if isinstance(arg, Or):
+                arest = self.args[:i] + self.args[i + 1:]
+
+                orterms = [And(*(arest + (a,))) for a in arg.args]
+                for j in range(len(orterms)):
+                    if isinstance(orterms[j], Logic):
+                        orterms[j] = orterms[j].expand()
+
+                res = Or(*orterms)
+                return res
+
+        return self
+
+
+class Or(AndOr_Base):
+    op_x_notx = True
+
+    def _eval_propagate_not(self):
+        # !(a|b|c ...) == !a & !b & !c ...
+        return And(*[Not(a) for a in self.args])
+
+
+class Not(Logic):
+
+    def __new__(cls, arg):
+        if isinstance(arg, str):
+            return Logic.__new__(cls, arg)
+
+        elif isinstance(arg, bool):
+            return not arg
+        elif isinstance(arg, Not):
+            return arg.args[0]
+
+        elif isinstance(arg, Logic):
+            # XXX this is a hack to expand right from the beginning
+            arg = arg._eval_propagate_not()
+            return arg
+
+        else:
+            raise ValueError('Not: unknown argument %r' % (arg,))
+
+    @property
+    def arg(self):
+        return self.args[0]
+
+
+Logic.op_2class['&'] = And
+Logic.op_2class['|'] = Or
+Logic.op_2class['!'] = Not

llmeval-env/lib/python3.10/site-packages/sympy/core/mod.py

@@ -0,0 +1,238 @@
+from .add import Add
+from .exprtools import gcd_terms
+from .function import Function
+from .kind import NumberKind
+from .logic import fuzzy_and, fuzzy_not
+from .mul import Mul
+from .numbers import equal_valued
+from .singleton import S
+
+
+class Mod(Function):
+    """Represents a modulo operation on symbolic expressions.
+
+    Parameters
+    ==========
+
+    p : Expr
+        Dividend.
+
+    q : Expr
+        Divisor.
+
+    Notes
+    =====
+
+    The convention used is the same as Python's: the remainder always has the
+    same sign as the divisor.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> x**2 % y
+    Mod(x**2, y)
+    >>> _.subs({x: 5, y: 6})
+    1
+
+    """
+
+    kind = NumberKind
+
+    @classmethod
+    def eval(cls, p, q):
+        def number_eval(p, q):
+            """Try to return p % q if both are numbers or +/-p is known
+            to be less than or equal q.
+            """
+
+            if q.is_zero:
+                raise ZeroDivisionError("Modulo by zero")
+            if p is S.NaN or q is S.NaN or p.is_finite is False or q.is_finite is False:
+                return S.NaN
+            if p is S.Zero or p in (q, -q) or (p.is_integer and q == 1):
+                return S.Zero
+
+            if q.is_Number:
+                if p.is_Number:
+                    return p%q
+                if q == 2:
+                    if p.is_even:
+                        return S.Zero
+                    elif p.is_odd:
+                        return S.One
+
+            if hasattr(p, '_eval_Mod'):
+                rv = getattr(p, '_eval_Mod')(q)
+                if rv is not None:
+                    return rv
+
+            # by ratio
+            r = p/q
+            if r.is_integer:
+                return S.Zero
+            try:
+                d = int(r)
+            except TypeError:
+                pass
+            else:
+                if isinstance(d, int):
+                    rv = p - d*q
+                    if (rv*q < 0) == True:
+                        rv += q
+                    return rv
+
+            # by difference
+            # -2|q| < p < 2|q|
+            d = abs(p)
+            for _ in range(2):
+                d -= abs(q)
+                if d.is_negative:
+                    if q.is_positive:
+                        if p.is_positive:
+                            return d + q
+                        elif p.is_negative:
+                            return -d
+                    elif q.is_negative:
+                        if p.is_positive:
+                            return d
+                        elif p.is_negative:
+                            return -d + q
+                    break
+
+        rv = number_eval(p, q)
+        if rv is not None:
+            return rv
+
+        # denest
+        if isinstance(p, cls):
+            qinner = p.args[1]
+            if qinner % q == 0:
+                return cls(p.args[0], q)
+            elif (qinner*(q - qinner)).is_nonnegative:
+                # |qinner| < |q| and have same sign
+                return p
+        elif isinstance(-p, cls):
+            qinner = (-p).args[1]
+            if qinner % q == 0:
+                return cls(-(-p).args[0], q)
+            elif (qinner*(q + qinner)).is_nonpositive:
+                # |qinner| < |q| and have different sign
+                return p
+        elif isinstance(p, Add):
+            # separating into modulus and non modulus
+            both_l = non_mod_l, mod_l = [], []
+            for arg in p.args:
+                both_l[isinstance(arg, cls)].append(arg)
+            # if q same for all
+            if mod_l and all(inner.args[1] == q for inner in mod_l):
+                net = Add(*non_mod_l) + Add(*[i.args[0] for i in mod_l])
+                return cls(net, q)
+
+        elif isinstance(p, Mul):
+            # separating into modulus and non modulus
+            both_l = non_mod_l, mod_l = [], []
+            for arg in p.args:
+                both_l[isinstance(arg, cls)].append(arg)
+
+            if mod_l and all(inner.args[1] == q for inner in mod_l) and all(t.is_integer for t in p.args) and q.is_integer:
+                # finding distributive term
+                non_mod_l = [cls(x, q) for x in non_mod_l]
+                mod = []
+                non_mod = []
+                for j in non_mod_l:
+                    if isinstance(j, cls):
+                        mod.append(j.args[0])
+                    else:
+                        non_mod.append(j)
+                prod_mod = Mul(*mod)
+                prod_non_mod = Mul(*non_mod)
+                prod_mod1 = Mul(*[i.args[0] for i in mod_l])
+                net = prod_mod1*prod_mod
+                return prod_non_mod*cls(net, q)
+
+            if q.is_Integer and q is not S.One:
+                non_mod_l = [i % q if i.is_Integer and (i % q is not S.Zero) else i for
+                             i in non_mod_l]
+
+            p = Mul(*(non_mod_l + mod_l))
+
+        # XXX other possibilities?
+
+        from sympy.polys.polyerrors import PolynomialError
+        from sympy.polys.polytools import gcd
+
+        # extract gcd; any further simplification should be done by the user
+        try:
+            G = gcd(p, q)
+            if not equal_valued(G, 1):
+                p, q = [gcd_terms(i/G, clear=False, fraction=False)
+                        for i in (p, q)]
+        except PolynomialError:  # issue 21373
+            G = S.One
+        pwas, qwas = p, q
+
+        # simplify terms
+        # (x + y + 2) % x -> Mod(y + 2, x)
+        if p.is_Add:
+            args = []
+            for i in p.args:
+                a = cls(i, q)
+                if a.count(cls) > i.count(cls):
+                    args.append(i)
+                else:
+                    args.append(a)
+            if args != list(p.args):
+                p = Add(*args)
+
+        else:
+            # handle coefficients if they are not Rational
+            # since those are not handled by factor_terms
+            # e.g. Mod(.6*x, .3*y) -> 0.3*Mod(2*x, y)
+            cp, p = p.as_coeff_Mul()
+            cq, q = q.as_coeff_Mul()
+            ok = False
+            if not cp.is_Rational or not cq.is_Rational:
+                r = cp % cq
+                if equal_valued(r, 0):
+                    G *= cq
+                    p *= int(cp/cq)
+                    ok = True
+            if not ok:
+                p = cp*p
+                q = cq*q
+
+        # simple -1 extraction
+        if p.could_extract_minus_sign() and q.could_extract_minus_sign():
+            G, p, q = [-i for i in (G, p, q)]
+
+        # check again to see if p and q can now be handled as numbers
+        rv = number_eval(p, q)
+        if rv is not None:
+            return rv*G
+
+        # put 1.0 from G on inside
+        if G.is_Float and equal_valued(G, 1):
+            p *= G
+            return cls(p, q, evaluate=False)
+        elif G.is_Mul and G.args[0].is_Float and equal_valued(G.args[0], 1):
+            p = G.args[0]*p
+            G = Mul._from_args(G.args[1:])
+        return G*cls(p, q, evaluate=(p, q) != (pwas, qwas))
+
+    def _eval_is_integer(self):
+        p, q = self.args
+        if fuzzy_and([p.is_integer, q.is_integer, fuzzy_not(q.is_zero)]):
+            return True
+
+    def _eval_is_nonnegative(self):
+        if self.args[1].is_positive:
+            return True
+
+    def _eval_is_nonpositive(self):
+        if self.args[1].is_negative:
+            return True
+
+    def _eval_rewrite_as_floor(self, a, b, **kwargs):
+        from sympy.functions.elementary.integers import floor
+        return a - b*floor(a/b)

llmeval-env/lib/python3.10/site-packages/sympy/core/multidimensional.py

@@ -0,0 +1,131 @@
+"""
+Provides functionality for multidimensional usage of scalar-functions.
+
+Read the vectorize docstring for more details.
+"""
+
+from functools import wraps
+
+
+def apply_on_element(f, args, kwargs, n):
+    """
+    Returns a structure with the same dimension as the specified argument,
+    where each basic element is replaced by the function f applied on it. All
+    other arguments stay the same.
+    """
+    # Get the specified argument.
+    if isinstance(n, int):
+        structure = args[n]
+        is_arg = True
+    elif isinstance(n, str):
+        structure = kwargs[n]
+        is_arg = False
+
+    # Define reduced function that is only dependent on the specified argument.
+    def f_reduced(x):
+        if hasattr(x, "__iter__"):
+            return list(map(f_reduced, x))
+        else:
+            if is_arg:
+                args[n] = x
+            else:
+                kwargs[n] = x
+            return f(*args, **kwargs)
+
+    # f_reduced will call itself recursively so that in the end f is applied to
+    # all basic elements.
+    return list(map(f_reduced, structure))
+
+
+def iter_copy(structure):
+    """
+    Returns a copy of an iterable object (also copying all embedded iterables).
+    """
+    return [iter_copy(i) if hasattr(i, "__iter__") else i for i in structure]
+
+
+def structure_copy(structure):
+    """
+    Returns a copy of the given structure (numpy-array, list, iterable, ..).
+    """
+    if hasattr(structure, "copy"):
+        return structure.copy()
+    return iter_copy(structure)
+
+
+class vectorize:
+    """
+    Generalizes a function taking scalars to accept multidimensional arguments.
+
+    Examples
+    ========
+
+    >>> from sympy import vectorize, diff, sin, symbols, Function
+    >>> x, y, z = symbols('x y z')
+    >>> f, g, h = list(map(Function, 'fgh'))
+
+    >>> @vectorize(0)
+    ... def vsin(x):
+    ...     return sin(x)
+
+    >>> vsin([1, x, y])
+    [sin(1), sin(x), sin(y)]
+
+    >>> @vectorize(0, 1)
+    ... def vdiff(f, y):
+    ...     return diff(f, y)
+
+    >>> vdiff([f(x, y, z), g(x, y, z), h(x, y, z)], [x, y, z])
+    [[Derivative(f(x, y, z), x), Derivative(f(x, y, z), y), Derivative(f(x, y, z), z)], [Derivative(g(x, y, z), x), Derivative(g(x, y, z), y), Derivative(g(x, y, z), z)], [Derivative(h(x, y, z), x), Derivative(h(x, y, z), y), Derivative(h(x, y, z), z)]]
+    """
+    def __init__(self, *mdargs):
+        """
+        The given numbers and strings characterize the arguments that will be
+        treated as data structures, where the decorated function will be applied
+        to every single element.
+        If no argument is given, everything is treated multidimensional.
+        """
+        for a in mdargs:
+            if not isinstance(a, (int, str)):
+                raise TypeError("a is of invalid type")
+        self.mdargs = mdargs
+
+    def __call__(self, f):
+        """
+        Returns a wrapper for the one-dimensional function that can handle
+        multidimensional arguments.
+        """
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            # Get arguments that should be treated multidimensional
+            if self.mdargs:
+                mdargs = self.mdargs
+            else:
+                mdargs = range(len(args)) + kwargs.keys()
+
+            arglength = len(args)
+
+            for n in mdargs:
+                if isinstance(n, int):
+                    if n >= arglength:
+                        continue
+                    entry = args[n]
+                    is_arg = True
+                elif isinstance(n, str):
+                    try:
+                        entry = kwargs[n]
+                    except KeyError:
+                        continue
+                    is_arg = False
+                if hasattr(entry, "__iter__"):
+                    # Create now a copy of the given array and manipulate then
+                    # the entries directly.
+                    if is_arg:
+                        args = list(args)
+                        args[n] = structure_copy(entry)
+                    else:
+                        kwargs[n] = structure_copy(entry)
+                    result = apply_on_element(wrapper, args, kwargs, n)
+                    return result
+            return f(*args, **kwargs)
+        return wrapper

llmeval-env/lib/python3.10/site-packages/sympy/core/operations.py

@@ -0,0 +1,722 @@
+from __future__ import annotations
+from operator import attrgetter
+from collections import defaultdict
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from .sympify import _sympify as _sympify_, sympify
+from .basic import Basic
+from .cache import cacheit
+from .sorting import ordered
+from .logic import fuzzy_and
+from .parameters import global_parameters
+from sympy.utilities.iterables import sift
+from sympy.multipledispatch.dispatcher import (Dispatcher,
+    ambiguity_register_error_ignore_dup,
+    str_signature, RaiseNotImplementedError)
+
+
+class AssocOp(Basic):
+    """ Associative operations, can separate noncommutative and
+    commutative parts.
+
+    (a op b) op c == a op (b op c) == a op b op c.
+
+    Base class for Add and Mul.
+
+    This is an abstract base class, concrete derived classes must define
+    the attribute `identity`.
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Parameters
+    ==========
+
+    *args :
+        Arguments which are operated
+
+    evaluate : bool, optional
+        Evaluate the operation. If not passed, refer to ``global_parameters.evaluate``.
+    """
+
+    # for performance reason, we don't let is_commutative go to assumptions,
+    # and keep it right here
+    __slots__: tuple[str, ...] = ('is_commutative',)
+
+    _args_type: type[Basic] | None = None
+
+    @cacheit
+    def __new__(cls, *args, evaluate=None, _sympify=True):
+        # Allow faster processing by passing ``_sympify=False``, if all arguments
+        # are already sympified.
+        if _sympify:
+            args = list(map(_sympify_, args))
+
+        # Disallow non-Expr args in Add/Mul
+        typ = cls._args_type
+        if typ is not None:
+            from .relational import Relational
+            if any(isinstance(arg, Relational) for arg in args):
+                raise TypeError("Relational cannot be used in %s" % cls.__name__)
+
+            # This should raise TypeError once deprecation period is over:
+            for arg in args:
+                if not isinstance(arg, typ):
+                    sympy_deprecation_warning(
+                        f"""
+
+Using non-Expr arguments in {cls.__name__} is deprecated (in this case, one of
+the arguments has type {type(arg).__name__!r}).
+
+If you really did intend to use a multiplication or addition operation with
+this object, use the * or + operator instead.
+
+                        """,
+                        deprecated_since_version="1.7",
+                        active_deprecations_target="non-expr-args-deprecated",
+                        stacklevel=4,
+                    )
+
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+        if not evaluate:
+            obj = cls._from_args(args)
+            obj = cls._exec_constructor_postprocessors(obj)
+            return obj
+
+        args = [a for a in args if a is not cls.identity]
+
+        if len(args) == 0:
+            return cls.identity
+        if len(args) == 1:
+            return args[0]
+
+        c_part, nc_part, order_symbols = cls.flatten(args)
+        is_commutative = not nc_part
+        obj = cls._from_args(c_part + nc_part, is_commutative)
+        obj = cls._exec_constructor_postprocessors(obj)
+
+        if order_symbols is not None:
+            from sympy.series.order import Order
+            return Order(obj, *order_symbols)
+        return obj
+
+    @classmethod
+    def _from_args(cls, args, is_commutative=None):
+        """Create new instance with already-processed args.
+        If the args are not in canonical order, then a non-canonical
+        result will be returned, so use with caution. The order of
+        args may change if the sign of the args is changed."""
+        if len(args) == 0:
+            return cls.identity
+        elif len(args) == 1:
+            return args[0]
+
+        obj = super().__new__(cls, *args)
+        if is_commutative is None:
+            is_commutative = fuzzy_and(a.is_commutative for a in args)
+        obj.is_commutative = is_commutative
+        return obj
+
+    def _new_rawargs(self, *args, reeval=True, **kwargs):
+        """Create new instance of own class with args exactly as provided by
+        caller but returning the self class identity if args is empty.
+
+        Examples
+        ========
+
+           This is handy when we want to optimize things, e.g.
+
+               >>> from sympy import Mul, S
+               >>> from sympy.abc import x, y
+               >>> e = Mul(3, x, y)
+               >>> e.args
+               (3, x, y)
+               >>> Mul(*e.args[1:])
+               x*y
+               >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
+               x*y
+
+           Note: use this with caution. There is no checking of arguments at
+           all. This is best used when you are rebuilding an Add or Mul after
+           simply removing one or more args. If, for example, modifications,
+           result in extra 1s being inserted they will show up in the result:
+
+               >>> m = (x*y)._new_rawargs(S.One, x); m
+               1*x
+               >>> m == x
+               False
+               >>> m.is_Mul
+               True
+
+           Another issue to be aware of is that the commutativity of the result
+           is based on the commutativity of self. If you are rebuilding the
+           terms that came from a commutative object then there will be no
+           problem, but if self was non-commutative then what you are
+           rebuilding may now be commutative.
+
+           Although this routine tries to do as little as possible with the
+           input, getting the commutativity right is important, so this level
+           of safety is enforced: commutativity will always be recomputed if
+           self is non-commutative and kwarg `reeval=False` has not been
+           passed.
+        """
+        if reeval and self.is_commutative is False:
+            is_commutative = None
+        else:
+            is_commutative = self.is_commutative
+        return self._from_args(args, is_commutative)
+
+    @classmethod
+    def flatten(cls, seq):
+        """Return seq so that none of the elements are of type `cls`. This is
+        the vanilla routine that will be used if a class derived from AssocOp
+        does not define its own flatten routine."""
+        # apply associativity, no commutativity property is used
+        new_seq = []
+        while seq:
+            o = seq.pop()
+            if o.__class__ is cls:  # classes must match exactly
+                seq.extend(o.args)
+            else:
+                new_seq.append(o)
+        new_seq.reverse()
+
+        # c_part, nc_part, order_symbols
+        return [], new_seq, None
+
+    def _matches_commutative(self, expr, repl_dict=None, old=False):
+        """
+        Matches Add/Mul "pattern" to an expression "expr".
+
+        repl_dict ... a dictionary of (wild: expression) pairs, that get
+                      returned with the results
+
+        This function is the main workhorse for Add/Mul.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Wild, sin
+        >>> a = Wild("a")
+        >>> b = Wild("b")
+        >>> c = Wild("c")
+        >>> x, y, z = symbols("x y z")
+        >>> (a+sin(b)*c)._matches_commutative(x+sin(y)*z)
+        {a_: x, b_: y, c_: z}
+
+        In the example above, "a+sin(b)*c" is the pattern, and "x+sin(y)*z" is
+        the expression.
+
+        The repl_dict contains parts that were already matched. For example
+        here:
+
+        >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z, repl_dict={a: x})
+        {a_: x, b_: y, c_: z}
+
+        the only function of the repl_dict is to return it in the
+        result, e.g. if you omit it:
+
+        >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z)
+        {b_: y, c_: z}
+
+        the "a: x" is not returned in the result, but otherwise it is
+        equivalent.
+
+        """
+        from .function import _coeff_isneg
+        # make sure expr is Expr if pattern is Expr
+        from .expr import Expr
+        if isinstance(self, Expr) and not isinstance(expr, Expr):
+            return None
+
+        if repl_dict is None:
+            repl_dict = {}
+
+        # handle simple patterns
+        if self == expr:
+            return repl_dict
+
+        d = self._matches_simple(expr, repl_dict)
+        if d is not None:
+            return d
+
+        # eliminate exact part from pattern: (2+a+w1+w2).matches(expr) -> (w1+w2).matches(expr-a-2)
+        from .function import WildFunction
+        from .symbol import Wild
+        wild_part, exact_part = sift(self.args, lambda p:
+            p.has(Wild, WildFunction) and not expr.has(p),
+            binary=True)
+        if not exact_part:
+            wild_part = list(ordered(wild_part))
+            if self.is_Add:
+                # in addition to normal ordered keys, impose
+                # sorting on Muls with leading Number to put
+                # them in order
+                wild_part = sorted(wild_part, key=lambda x:
+                    x.args[0] if x.is_Mul and x.args[0].is_Number else
+                    0)
+        else:
+            exact = self._new_rawargs(*exact_part)
+            free = expr.free_symbols
+            if free and (exact.free_symbols - free):
+                # there are symbols in the exact part that are not
+                # in the expr; but if there are no free symbols, let
+                # the matching continue
+                return None
+            newexpr = self._combine_inverse(expr, exact)
+            if not old and (expr.is_Add or expr.is_Mul):
+                check = newexpr
+                if _coeff_isneg(check):
+                    check = -check
+                if check.count_ops() > expr.count_ops():
+                    return None
+            newpattern = self._new_rawargs(*wild_part)
+            return newpattern.matches(newexpr, repl_dict)
+
+        # now to real work ;)
+        i = 0
+        saw = set()
+        while expr not in saw:
+            saw.add(expr)
+            args = tuple(ordered(self.make_args(expr)))
+            if self.is_Add and expr.is_Add:
+                # in addition to normal ordered keys, impose
+                # sorting on Muls with leading Number to put
+                # them in order
+                args = tuple(sorted(args, key=lambda x:
+                    x.args[0] if x.is_Mul and x.args[0].is_Number else
+                    0))
+            expr_list = (self.identity,) + args
+            for last_op in reversed(expr_list):
+                for w in reversed(wild_part):
+                    d1 = w.matches(last_op, repl_dict)
+                    if d1 is not None:
+                        d2 = self.xreplace(d1).matches(expr, d1)
+                        if d2 is not None:
+                            return d2
+
+            if i == 0:
+                if self.is_Mul:
+                    # make e**i look like Mul
+                    if expr.is_Pow and expr.exp.is_Integer:
+                        from .mul import Mul
+                        if expr.exp > 0:
+                            expr = Mul(*[expr.base, expr.base**(expr.exp - 1)], evaluate=False)
+                        else:
+                            expr = Mul(*[1/expr.base, expr.base**(expr.exp + 1)], evaluate=False)
+                        i += 1
+                        continue
+
+                elif self.is_Add:
+                    # make i*e look like Add
+                    c, e = expr.as_coeff_Mul()
+                    if abs(c) > 1:
+                        from .add import Add
+                        if c > 0:
+                            expr = Add(*[e, (c - 1)*e], evaluate=False)
+                        else:
+                            expr = Add(*[-e, (c + 1)*e], evaluate=False)
+                        i += 1
+                        continue
+
+                    # try collection on non-Wild symbols
+                    from sympy.simplify.radsimp import collect
+                    was = expr
+                    did = set()
+                    for w in reversed(wild_part):
+                        c, w = w.as_coeff_mul(Wild)
+                        free = c.free_symbols - did
+                        if free:
+                            did.update(free)
+                            expr = collect(expr, free)
+                    if expr != was:
+                        i += 0
+                        continue
+
+                break  # if we didn't continue, there is nothing more to do
+
+        return
+
+    def _has_matcher(self):
+        """Helper for .has() that checks for containment of
+        subexpressions within an expr by using sets of args
+        of similar nodes, e.g. x + 1 in x + y + 1 checks
+        to see that {x, 1} & {x, y, 1} == {x, 1}
+        """
+        def _ncsplit(expr):
+            # this is not the same as args_cnc because here
+            # we don't assume expr is a Mul -- hence deal with args --
+            # and always return a set.
+            cpart, ncpart = sift(expr.args,
+                lambda arg: arg.is_commutative is True, binary=True)
+            return set(cpart), ncpart
+
+        c, nc = _ncsplit(self)
+        cls = self.__class__
+
+        def is_in(expr):
+            if isinstance(expr, cls):
+                if expr == self:
+                    return True
+                _c, _nc = _ncsplit(expr)
+                if (c & _c) == c:
+                    if not nc:
+                        return True
+                    elif len(nc) <= len(_nc):
+                        for i in range(len(_nc) - len(nc) + 1):
+                            if _nc[i:i + len(nc)] == nc:
+                                return True
+            return False
+        return is_in
+
+    def _eval_evalf(self, prec):
+        """
+        Evaluate the parts of self that are numbers; if the whole thing
+        was a number with no functions it would have been evaluated, but
+        it wasn't so we must judiciously extract the numbers and reconstruct
+        the object. This is *not* simply replacing numbers with evaluated
+        numbers. Numbers should be handled in the largest pure-number
+        expression as possible. So the code below separates ``self`` into
+        number and non-number parts and evaluates the number parts and
+        walks the args of the non-number part recursively (doing the same
+        thing).
+        """
+        from .add import Add
+        from .mul import Mul
+        from .symbol import Symbol
+        from .function import AppliedUndef
+        if isinstance(self, (Mul, Add)):
+            x, tail = self.as_independent(Symbol, AppliedUndef)
+            # if x is an AssocOp Function then the _evalf below will
+            # call _eval_evalf (here) so we must break the recursion
+            if not (tail is self.identity or
+                    isinstance(x, AssocOp) and x.is_Function or
+                    x is self.identity and isinstance(tail, AssocOp)):
+                # here, we have a number so we just call to _evalf with prec;
+                # prec is not the same as n, it is the binary precision so
+                # that's why we don't call to evalf.
+                x = x._evalf(prec) if x is not self.identity else self.identity
+                args = []
+                tail_args = tuple(self.func.make_args(tail))
+                for a in tail_args:
+                    # here we call to _eval_evalf since we don't know what we
+                    # are dealing with and all other _eval_evalf routines should
+                    # be doing the same thing (i.e. taking binary prec and
+                    # finding the evalf-able args)
+                    newa = a._eval_evalf(prec)
+                    if newa is None:
+                        args.append(a)
+                    else:
+                        args.append(newa)
+                return self.func(x, *args)
+
+        # this is the same as above, but there were no pure-number args to
+        # deal with
+        args = []
+        for a in self.args:
+            newa = a._eval_evalf(prec)
+            if newa is None:
+                args.append(a)
+            else:
+                args.append(newa)
+        return self.func(*args)
+
+    @classmethod
+    def make_args(cls, expr):
+        """
+        Return a sequence of elements `args` such that cls(*args) == expr
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Mul, Add
+        >>> x, y = map(Symbol, 'xy')
+
+        >>> Mul.make_args(x*y)
+        (x, y)
+        >>> Add.make_args(x*y)
+        (x*y,)
+        >>> set(Add.make_args(x*y + y)) == set([y, x*y])
+        True
+
+        """
+        if isinstance(expr, cls):
+            return expr.args
+        else:
+            return (sympify(expr),)
+
+    def doit(self, **hints):
+        if hints.get('deep', True):
+            terms = [term.doit(**hints) for term in self.args]
+        else:
+            terms = self.args
+        return self.func(*terms, evaluate=True)
+
+class ShortCircuit(Exception):
+    pass
+
+
+class LatticeOp(AssocOp):
+    """
+    Join/meet operations of an algebraic lattice[1].
+
+    Explanation
+    ===========
+
+    These binary operations are associative (op(op(a, b), c) = op(a, op(b, c))),
+    commutative (op(a, b) = op(b, a)) and idempotent (op(a, a) = op(a) = a).
+    Common examples are AND, OR, Union, Intersection, max or min. They have an
+    identity element (op(identity, a) = a) and an absorbing element
+    conventionally called zero (op(zero, a) = zero).
+
+    This is an abstract base class, concrete derived classes must declare
+    attributes zero and identity. All defining properties are then respected.
+
+    Examples
+    ========
+
+    >>> from sympy import Integer
+    >>> from sympy.core.operations import LatticeOp
+    >>> class my_join(LatticeOp):
+    ...     zero = Integer(0)
+    ...     identity = Integer(1)
+    >>> my_join(2, 3) == my_join(3, 2)
+    True
+    >>> my_join(2, my_join(3, 4)) == my_join(2, 3, 4)
+    True
+    >>> my_join(0, 1, 4, 2, 3, 4)
+    0
+    >>> my_join(1, 2)
+    2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lattice_%28order%29
+    """
+
+    is_commutative = True
+
+    def __new__(cls, *args, **options):
+        args = (_sympify_(arg) for arg in args)
+
+        try:
+            # /!\ args is a generator and _new_args_filter
+            # must be careful to handle as such; this
+            # is done so short-circuiting can be done
+            # without having to sympify all values
+            _args = frozenset(cls._new_args_filter(args))
+        except ShortCircuit:
+            return sympify(cls.zero)
+        if not _args:
+            return sympify(cls.identity)
+        elif len(_args) == 1:
+            return set(_args).pop()
+        else:
+            # XXX in almost every other case for __new__, *_args is
+            # passed along, but the expectation here is for _args
+            obj = super(AssocOp, cls).__new__(cls, *ordered(_args))
+            obj._argset = _args
+            return obj
+
+    @classmethod
+    def _new_args_filter(cls, arg_sequence, call_cls=None):
+        """Generator filtering args"""
+        ncls = call_cls or cls
+        for arg in arg_sequence:
+            if arg == ncls.zero:
+                raise ShortCircuit(arg)
+            elif arg == ncls.identity:
+                continue
+            elif arg.func == ncls:
+                yield from arg.args
+            else:
+                yield arg
+
+    @classmethod
+    def make_args(cls, expr):
+        """
+        Return a set of args such that cls(*arg_set) == expr.
+        """
+        if isinstance(expr, cls):
+            return expr._argset
+        else:
+            return frozenset([sympify(expr)])
+
+    @staticmethod
+    def _compare_pretty(a, b):
+        return (str(a) > str(b)) - (str(a) < str(b))
+
+
+class AssocOpDispatcher:
+    """
+    Handler dispatcher for associative operators
+
+    .. notes::
+       This approach is experimental, and can be replaced or deleted in the future.
+       See https://github.com/sympy/sympy/pull/19463.
+
+    Explanation
+    ===========
+
+    If arguments of different types are passed, the classes which handle the operation for each type
+    are collected. Then, a class which performs the operation is selected by recursive binary dispatching.
+    Dispatching relation can be registered by ``register_handlerclass`` method.
+
+    Priority registration is unordered. You cannot make ``A*B`` and ``B*A`` refer to
+    different handler classes. All logic dealing with the order of arguments must be implemented
+    in the handler class.
+
+    Examples
+    ========
+
+    >>> from sympy import Add, Expr, Symbol
+    >>> from sympy.core.add import add
+
+    >>> class NewExpr(Expr):
+    ...     @property
+    ...     def _add_handler(self):
+    ...         return NewAdd
+    >>> class NewAdd(NewExpr, Add):
+    ...     pass
+    >>> add.register_handlerclass((Add, NewAdd), NewAdd)
+
+    >>> a, b = Symbol('a'), NewExpr()
+    >>> add(a, b) == NewAdd(a, b)
+    True
+
+    """
+    def __init__(self, name, doc=None):
+        self.name = name
+        self.doc = doc
+        self.handlerattr = "_%s_handler" % name
+        self._handlergetter = attrgetter(self.handlerattr)
+        self._dispatcher = Dispatcher(name)
+
+    def __repr__(self):
+        return "<dispatched %s>" % self.name
+
+    def register_handlerclass(self, classes, typ, on_ambiguity=ambiguity_register_error_ignore_dup):
+        """
+        Register the handler class for two classes, in both straight and reversed order.
+
+        Paramteters
+        ===========
+
+        classes : tuple of two types
+            Classes who are compared with each other.
+
+        typ:
+            Class which is registered to represent *cls1* and *cls2*.
+            Handler method of *self* must be implemented in this class.
+        """
+        if not len(classes) == 2:
+            raise RuntimeError(
+                "Only binary dispatch is supported, but got %s types: <%s>." % (
+                len(classes), str_signature(classes)
+            ))
+        if len(set(classes)) == 1:
+            raise RuntimeError(
+                "Duplicate types <%s> cannot be dispatched." % str_signature(classes)
+            )
+        self._dispatcher.add(tuple(classes), typ, on_ambiguity=on_ambiguity)
+        self._dispatcher.add(tuple(reversed(classes)), typ, on_ambiguity=on_ambiguity)
+
+    @cacheit
+    def __call__(self, *args, _sympify=True, **kwargs):
+        """
+        Parameters
+        ==========
+
+        *args :
+            Arguments which are operated
+        """
+        if _sympify:
+            args = tuple(map(_sympify_, args))
+        handlers = frozenset(map(self._handlergetter, args))
+
+        # no need to sympify again
+        return self.dispatch(handlers)(*args, _sympify=False, **kwargs)
+
+    @cacheit
+    def dispatch(self, handlers):
+        """
+        Select the handler class, and return its handler method.
+        """
+
+        # Quick exit for the case where all handlers are same
+        if len(handlers) == 1:
+            h, = handlers
+            if not isinstance(h, type):
+                raise RuntimeError("Handler {!r} is not a type.".format(h))
+            return h
+
+        # Recursively select with registered binary priority
+        for i, typ in enumerate(handlers):
+
+            if not isinstance(typ, type):
+                raise RuntimeError("Handler {!r} is not a type.".format(typ))
+
+            if i == 0:
+                handler = typ
+            else:
+                prev_handler = handler
+                handler = self._dispatcher.dispatch(prev_handler, typ)
+
+                if not isinstance(handler, type):
+                    raise RuntimeError(
+                        "Dispatcher for {!r} and {!r} must return a type, but got {!r}".format(
+                        prev_handler, typ, handler
+                    ))
+
+        # return handler class
+        return handler
+
+    @property
+    def __doc__(self):
+        docs = [
+            "Multiply dispatched associative operator: %s" % self.name,
+            "Note that support for this is experimental, see the docs for :class:`AssocOpDispatcher` for details"
+        ]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        s = "Registered handler classes\n"
+        s += '=' * len(s)
+        docs.append(s)
+
+        amb_sigs = []
+
+        typ_sigs = defaultdict(list)
+        for sigs in self._dispatcher.ordering[::-1]:
+            key = self._dispatcher.funcs[sigs]
+            typ_sigs[key].append(sigs)
+
+        for typ, sigs in typ_sigs.items():
+
+            sigs_str = ', '.join('<%s>' % str_signature(sig) for sig in sigs)
+
+            if isinstance(typ, RaiseNotImplementedError):
+                amb_sigs.append(sigs_str)
+                continue
+
+            s = 'Inputs: %s\n' % sigs_str
+            s += '-' * len(s) + '\n'
+            s += typ.__name__
+            docs.append(s)
+
+        if amb_sigs:
+            s = "Ambiguous handler classes\n"
+            s += '=' * len(s)
+            docs.append(s)
+
+            s = '\n'.join(amb_sigs)
+            docs.append(s)
+
+        return '\n\n'.join(docs)

llmeval-env/lib/python3.10/site-packages/sympy/core/power.py

@@ -0,0 +1,2004 @@
+from __future__ import annotations
+from typing import Callable
+from math import log as _log, sqrt as _sqrt
+from itertools import product
+
+from .sympify import _sympify
+from .cache import cacheit
+from .singleton import S
+from .expr import Expr
+from .evalf import PrecisionExhausted
+from .function import (expand_complex, expand_multinomial,
+    expand_mul, _mexpand, PoleError)
+from .logic import fuzzy_bool, fuzzy_not, fuzzy_and, fuzzy_or
+from .parameters import global_parameters
+from .relational import is_gt, is_lt
+from .kind import NumberKind, UndefinedKind
+from sympy.external.gmpy import HAS_GMPY, gmpy
+from sympy.utilities.iterables import sift
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.misc import as_int
+from sympy.multipledispatch import Dispatcher
+
+from mpmath.libmp import sqrtrem as mpmath_sqrtrem
+
+
+
+def isqrt(n):
+    """Return the largest integer less than or equal to sqrt(n)."""
+    if n < 0:
+        raise ValueError("n must be nonnegative")
+    n = int(n)
+
+    # Fast path: with IEEE 754 binary64 floats and a correctly-rounded
+    # math.sqrt, int(math.sqrt(n)) works for any integer n satisfying 0 <= n <
+    # 4503599761588224 = 2**52 + 2**27. But Python doesn't guarantee either
+    # IEEE 754 format floats *or* correct rounding of math.sqrt, so check the
+    # answer and fall back to the slow method if necessary.
+    if n < 4503599761588224:
+        s = int(_sqrt(n))
+        if 0 <= n - s*s <= 2*s:
+            return s
+
+    return integer_nthroot(n, 2)[0]
+
+
+def integer_nthroot(y, n):
+    """
+    Return a tuple containing x = floor(y**(1/n))
+    and a boolean indicating whether the result is exact (that is,
+    whether x**n == y).
+
+    Examples
+    ========
+
+    >>> from sympy import integer_nthroot
+    >>> integer_nthroot(16, 2)
+    (4, True)
+    >>> integer_nthroot(26, 2)
+    (5, False)
+
+    To simply determine if a number is a perfect square, the is_square
+    function should be used:
+
+    >>> from sympy.ntheory.primetest import is_square
+    >>> is_square(26)
+    False
+
+    See Also
+    ========
+    sympy.ntheory.primetest.is_square
+    integer_log
+    """
+    y, n = as_int(y), as_int(n)
+    if y < 0:
+        raise ValueError("y must be nonnegative")
+    if n < 1:
+        raise ValueError("n must be positive")
+    if HAS_GMPY and n < 2**63:
+        # Currently it works only for n < 2**63, else it produces TypeError
+        # sympy issue: https://github.com/sympy/sympy/issues/18374
+        # gmpy2 issue: https://github.com/aleaxit/gmpy/issues/257
+        if HAS_GMPY >= 2:
+            x, t = gmpy.iroot(y, n)
+        else:
+            x, t = gmpy.root(y, n)
+        return as_int(x), bool(t)
+    return _integer_nthroot_python(y, n)
+
+def _integer_nthroot_python(y, n):
+    if y in (0, 1):
+        return y, True
+    if n == 1:
+        return y, True
+    if n == 2:
+        x, rem = mpmath_sqrtrem(y)
+        return int(x), not rem
+    if n >= y.bit_length():
+        return 1, False
+    # Get initial estimate for Newton's method. Care must be taken to
+    # avoid overflow
+    try:
+        guess = int(y**(1./n) + 0.5)
+    except OverflowError:
+        exp = _log(y, 2)/n
+        if exp > 53:
+            shift = int(exp - 53)
+            guess = int(2.0**(exp - shift) + 1) << shift
+        else:
+            guess = int(2.0**exp)
+    if guess > 2**50:
+        # Newton iteration
+        xprev, x = -1, guess
+        while 1:
+            t = x**(n - 1)
+            xprev, x = x, ((n - 1)*x + y//t)//n
+            if abs(x - xprev) < 2:
+                break
+    else:
+        x = guess
+    # Compensate
+    t = x**n
+    while t < y:
+        x += 1
+        t = x**n
+    while t > y:
+        x -= 1
+        t = x**n
+    return int(x), t == y  # int converts long to int if possible
+
+
+def integer_log(y, x):
+    r"""
+    Returns ``(e, bool)`` where e is the largest nonnegative integer
+    such that :math:`|y| \geq |x^e|` and ``bool`` is True if $y = x^e$.
+
+    Examples
+    ========
+
+    >>> from sympy import integer_log
+    >>> integer_log(125, 5)
+    (3, True)
+    >>> integer_log(17, 9)
+    (1, False)
+    >>> integer_log(4, -2)
+    (2, True)
+    >>> integer_log(-125,-5)
+    (3, True)
+
+    See Also
+    ========
+    integer_nthroot
+    sympy.ntheory.primetest.is_square
+    sympy.ntheory.factor_.multiplicity
+    sympy.ntheory.factor_.perfect_power
+    """
+    if x == 1:
+        raise ValueError('x cannot take value as 1')
+    if y == 0:
+        raise ValueError('y cannot take value as 0')
+
+    if x in (-2, 2):
+        x = int(x)
+        y = as_int(y)
+        e = y.bit_length() - 1
+        return e, x**e == y
+    if x < 0:
+        n, b = integer_log(y if y > 0 else -y, -x)
+        return n, b and bool(n % 2 if y < 0 else not n % 2)
+
+    x = as_int(x)
+    y = as_int(y)
+    r = e = 0
+    while y >= x:
+        d = x
+        m = 1
+        while y >= d:
+            y, rem = divmod(y, d)
+            r = r or rem
+            e += m
+            if y > d:
+                d *= d
+                m *= 2
+    return e, r == 0 and y == 1
+
+
+class Pow(Expr):
+    """
+    Defines the expression x**y as "x raised to a power y"
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Singleton definitions involving (0, 1, -1, oo, -oo, I, -I):
+
+    +--------------+---------+-----------------------------------------------+
+    | expr         | value   | reason                                        |
+    +==============+=========+===============================================+
+    | z**0         | 1       | Although arguments over 0**0 exist, see [2].  |
+    +--------------+---------+-----------------------------------------------+
+    | z**1         | z       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | (-oo)**(-1)  | 0       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | (-1)**-1     | -1      |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | S.Zero**-1   | zoo     | This is not strictly true, as 0**-1 may be    |
+    |              |         | undefined, but is convenient in some contexts |
+    |              |         | where the base is assumed to be positive.     |
+    +--------------+---------+-----------------------------------------------+
+    | 1**-1        | 1       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**-1       | 0       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | 0**oo        | 0       | Because for all complex numbers z near        |
+    |              |         | 0, z**oo -> 0.                                |
+    +--------------+---------+-----------------------------------------------+
+    | 0**-oo       | zoo     | This is not strictly true, as 0**oo may be    |
+    |              |         | oscillating between positive and negative     |
+    |              |         | values or rotating in the complex plane.      |
+    |              |         | It is convenient, however, when the base      |
+    |              |         | is positive.                                  |
+    +--------------+---------+-----------------------------------------------+
+    | 1**oo        | nan     | Because there are various cases where         |
+    | 1**-oo       |         | lim(x(t),t)=1, lim(y(t),t)=oo (or -oo),       |
+    |              |         | but lim( x(t)**y(t), t) != 1.  See [3].       |
+    +--------------+---------+-----------------------------------------------+
+    | b**zoo       | nan     | Because b**z has no limit as z -> zoo         |
+    +--------------+---------+-----------------------------------------------+
+    | (-1)**oo     | nan     | Because of oscillations in the limit.         |
+    | (-1)**(-oo)  |         |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**oo       | oo      |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**-oo      | 0       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | (-oo)**oo    | nan     |                                               |
+    | (-oo)**-oo   |         |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**I        | nan     | oo**e could probably be best thought of as    |
+    | (-oo)**I     |         | the limit of x**e for real x as x tends to    |
+    |              |         | oo. If e is I, then the limit does not exist  |
+    |              |         | and nan is used to indicate that.             |
+    +--------------+---------+-----------------------------------------------+
+    | oo**(1+I)    | zoo     | If the real part of e is positive, then the   |
+    | (-oo)**(1+I) |         | limit of abs(x**e) is oo. So the limit value  |
+    |              |         | is zoo.                                       |
+    +--------------+---------+-----------------------------------------------+
+    | oo**(-1+I)   | 0       | If the real part of e is negative, then the   |
+    | -oo**(-1+I)  |         | limit is 0.                                   |
+    +--------------+---------+-----------------------------------------------+
+
+    Because symbolic computations are more flexible than floating point
+    calculations and we prefer to never return an incorrect answer,
+    we choose not to conform to all IEEE 754 conventions.  This helps
+    us avoid extra test-case code in the calculation of limits.
+
+    See Also
+    ========
+
+    sympy.core.numbers.Infinity
+    sympy.core.numbers.NegativeInfinity
+    sympy.core.numbers.NaN
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Exponentiation
+    .. [2] https://en.wikipedia.org/wiki/Zero_to_the_power_of_zero
+    .. [3] https://en.wikipedia.org/wiki/Indeterminate_forms
+
+    """
+    is_Pow = True
+
+    __slots__ = ('is_commutative',)
+
+    args: tuple[Expr, Expr]
+    _args: tuple[Expr, Expr]
+
+    @cacheit
+    def __new__(cls, b, e, evaluate=None):
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+
+        b = _sympify(b)
+        e = _sympify(e)
+
+        # XXX: This can be removed when non-Expr args are disallowed rather
+        # than deprecated.
+        from .relational import Relational
+        if isinstance(b, Relational) or isinstance(e, Relational):
+            raise TypeError('Relational cannot be used in Pow')
+
+        # XXX: This should raise TypeError once deprecation period is over:
+        for arg in [b, e]:
+            if not isinstance(arg, Expr):
+                sympy_deprecation_warning(
+                    f"""
+    Using non-Expr arguments in Pow is deprecated (in this case, one of the
+    arguments is of type {type(arg).__name__!r}).
+
+    If you really did intend to construct a power with this base, use the **
+    operator instead.""",
+                    deprecated_since_version="1.7",
+                    active_deprecations_target="non-expr-args-deprecated",
+                    stacklevel=4,
+                )
+
+        if evaluate:
+            if e is S.ComplexInfinity:
+                return S.NaN
+            if e is S.Infinity:
+                if is_gt(b, S.One):
+                    return S.Infinity
+                if is_gt(b, S.NegativeOne) and is_lt(b, S.One):
+                    return S.Zero
+                if is_lt(b, S.NegativeOne):
+                    if b.is_finite:
+                        return S.ComplexInfinity
+                    if b.is_finite is False:
+                        return S.NaN
+            if e is S.Zero:
+                return S.One
+            elif e is S.One:
+                return b
+            elif e == -1 and not b:
+                return S.ComplexInfinity
+            elif e.__class__.__name__ == "AccumulationBounds":
+                if b == S.Exp1:
+                    from sympy.calculus.accumulationbounds import AccumBounds
+                    return AccumBounds(Pow(b, e.min), Pow(b, e.max))
+            # autosimplification if base is a number and exp odd/even
+            # if base is Number then the base will end up positive; we
+            # do not do this with arbitrary expressions since symbolic
+            # cancellation might occur as in (x - 1)/(1 - x) -> -1. If
+            # we returned Piecewise((-1, Ne(x, 1))) for such cases then
+            # we could do this...but we don't
+            elif (e.is_Symbol and e.is_integer or e.is_Integer
+                    ) and (b.is_number and b.is_Mul or b.is_Number
+                    ) and b.could_extract_minus_sign():
+                if e.is_even:
+                    b = -b
+                elif e.is_odd:
+                    return -Pow(-b, e)
+            if S.NaN in (b, e):  # XXX S.NaN**x -> S.NaN under assumption that x != 0
+                return S.NaN
+            elif b is S.One:
+                if abs(e).is_infinite:
+                    return S.NaN
+                return S.One
+            else:
+                # recognize base as E
+                from sympy.functions.elementary.exponential import exp_polar
+                if not e.is_Atom and b is not S.Exp1 and not isinstance(b, exp_polar):
+                    from .exprtools import factor_terms
+                    from sympy.functions.elementary.exponential import log
+                    from sympy.simplify.radsimp import fraction
+                    c, ex = factor_terms(e, sign=False).as_coeff_Mul()
+                    num, den = fraction(ex)
+                    if isinstance(den, log) and den.args[0] == b:
+                        return S.Exp1**(c*num)
+                    elif den.is_Add:
+                        from sympy.functions.elementary.complexes import sign, im
+                        s = sign(im(b))
+                        if s.is_Number and s and den == \
+                                log(-factor_terms(b, sign=False)) + s*S.ImaginaryUnit*S.Pi:
+                            return S.Exp1**(c*num)
+
+                obj = b._eval_power(e)
+                if obj is not None:
+                    return obj
+        obj = Expr.__new__(cls, b, e)
+        obj = cls._exec_constructor_postprocessors(obj)
+        if not isinstance(obj, Pow):
+            return obj
+        obj.is_commutative = (b.is_commutative and e.is_commutative)
+        return obj
+
+    def inverse(self, argindex=1):
+        if self.base == S.Exp1:
+            from sympy.functions.elementary.exponential import log
+            return log
+        return None
+
+    @property
+    def base(self) -> Expr:
+        return self._args[0]
+
+    @property
+    def exp(self) -> Expr:
+        return self._args[1]
+
+    @property
+    def kind(self):
+        if self.exp.kind is NumberKind:
+            return self.base.kind
+        else:
+            return UndefinedKind
+
+    @classmethod
+    def class_key(cls):
+        return 3, 2, cls.__name__
+
+    def _eval_refine(self, assumptions):
+        from sympy.assumptions.ask import ask, Q
+        b, e = self.as_base_exp()
+        if ask(Q.integer(e), assumptions) and b.could_extract_minus_sign():
+            if ask(Q.even(e), assumptions):
+                return Pow(-b, e)
+            elif ask(Q.odd(e), assumptions):
+                return -Pow(-b, e)
+
+    def _eval_power(self, other):
+        b, e = self.as_base_exp()
+        if b is S.NaN:
+            return (b**e)**other  # let __new__ handle it
+
+        s = None
+        if other.is_integer:
+            s = 1
+        elif b.is_polar:  # e.g. exp_polar, besselj, var('p', polar=True)...
+            s = 1
+        elif e.is_extended_real is not None:
+            from sympy.functions.elementary.complexes import arg, im, re, sign
+            from sympy.functions.elementary.exponential import exp, log
+            from sympy.functions.elementary.integers import floor
+            # helper functions ===========================
+            def _half(e):
+                """Return True if the exponent has a literal 2 as the
+                denominator, else None."""
+                if getattr(e, 'q', None) == 2:
+                    return True
+                n, d = e.as_numer_denom()
+                if n.is_integer and d == 2:
+                    return True
+            def _n2(e):
+                """Return ``e`` evaluated to a Number with 2 significant
+                digits, else None."""
+                try:
+                    rv = e.evalf(2, strict=True)
+                    if rv.is_Number:
+                        return rv
+                except PrecisionExhausted:
+                    pass
+            # ===================================================
+            if e.is_extended_real:
+                # we need _half(other) with constant floor or
+                # floor(S.Half - e*arg(b)/2/pi) == 0
+
+
+                # handle -1 as special case
+                if e == -1:
+                    # floor arg. is 1/2 + arg(b)/2/pi
+                    if _half(other):
+                        if b.is_negative is True:
+                            return S.NegativeOne**other*Pow(-b, e*other)
+                        elif b.is_negative is False:  # XXX ok if im(b) != 0?
+                            return Pow(b, -other)
+                elif e.is_even:
+                    if b.is_extended_real:
+                        b = abs(b)
+                    if b.is_imaginary:
+                        b = abs(im(b))*S.ImaginaryUnit
+
+                if (abs(e) < 1) == True or e == 1:
+                    s = 1  # floor = 0
+                elif b.is_extended_nonnegative:
+                    s = 1  # floor = 0
+                elif re(b).is_extended_nonnegative and (abs(e) < 2) == True:
+                    s = 1  # floor = 0
+                elif _half(other):
+                    s = exp(2*S.Pi*S.ImaginaryUnit*other*floor(
+                        S.Half - e*arg(b)/(2*S.Pi)))
+                    if s.is_extended_real and _n2(sign(s) - s) == 0:
+                        s = sign(s)
+                    else:
+                        s = None
+            else:
+                # e.is_extended_real is False requires:
+                #     _half(other) with constant floor or
+                #     floor(S.Half - im(e*log(b))/2/pi) == 0
+                try:
+                    s = exp(2*S.ImaginaryUnit*S.Pi*other*
+                        floor(S.Half - im(e*log(b))/2/S.Pi))
+                    # be careful to test that s is -1 or 1 b/c sign(I) == I:
+                    # so check that s is real
+                    if s.is_extended_real and _n2(sign(s) - s) == 0:
+                        s = sign(s)
+                    else:
+                        s = None
+                except PrecisionExhausted:
+                    s = None
+
+        if s is not None:
+            return s*Pow(b, e*other)
+
+    def _eval_Mod(self, q):
+        r"""A dispatched function to compute `b^e \bmod q`, dispatched
+        by ``Mod``.
+
+        Notes
+        =====
+
+        Algorithms:
+
+        1. For unevaluated integer power, use built-in ``pow`` function
+        with 3 arguments, if powers are not too large wrt base.
+
+        2. For very large powers, use totient reduction if $e \ge \log(m)$.
+        Bound on m, is for safe factorization memory wise i.e. $m^{1/4}$.
+        For pollard-rho to be faster than built-in pow $\log(e) > m^{1/4}$
+        check is added.
+
+        3. For any unevaluated power found in `b` or `e`, the step 2
+        will be recursed down to the base and the exponent
+        such that the $b \bmod q$ becomes the new base and
+        $\phi(q) + e \bmod \phi(q)$ becomes the new exponent, and then
+        the computation for the reduced expression can be done.
+        """
+
+        base, exp = self.base, self.exp
+
+        if exp.is_integer and exp.is_positive:
+            if q.is_integer and base % q == 0:
+                return S.Zero
+
+            from sympy.ntheory.factor_ import totient
+
+            if base.is_Integer and exp.is_Integer and q.is_Integer:
+                b, e, m = int(base), int(exp), int(q)
+                mb = m.bit_length()
+                if mb <= 80 and e >= mb and e.bit_length()**4 >= m:
+                    phi = int(totient(m))
+                    return Integer(pow(b, phi + e%phi, m))
+                return Integer(pow(b, e, m))
+
+            from .mod import Mod
+
+            if isinstance(base, Pow) and base.is_integer and base.is_number:
+                base = Mod(base, q)
+                return Mod(Pow(base, exp, evaluate=False), q)
+
+            if isinstance(exp, Pow) and exp.is_integer and exp.is_number:
+                bit_length = int(q).bit_length()
+                # XXX Mod-Pow actually attempts to do a hanging evaluation
+                # if this dispatched function returns None.
+                # May need some fixes in the dispatcher itself.
+                if bit_length <= 80:
+                    phi = totient(q)
+                    exp = phi + Mod(exp, phi)
+                    return Mod(Pow(base, exp, evaluate=False), q)
+
+    def _eval_is_even(self):
+        if self.exp.is_integer and self.exp.is_positive:
+            return self.base.is_even
+
+    def _eval_is_negative(self):
+        ext_neg = Pow._eval_is_extended_negative(self)
+        if ext_neg is True:
+            return self.is_finite
+        return ext_neg
+
+    def _eval_is_extended_positive(self):
+        if self.base == self.exp:
+            if self.base.is_extended_nonnegative:
+                return True
+        elif self.base.is_positive:
+            if self.exp.is_real:
+                return True
+        elif self.base.is_extended_negative:
+            if self.exp.is_even:
+                return True
+            if self.exp.is_odd:
+                return False
+        elif self.base.is_zero:
+            if self.exp.is_extended_real:
+                return self.exp.is_zero
+        elif self.base.is_extended_nonpositive:
+            if self.exp.is_odd:
+                return False
+        elif self.base.is_imaginary:
+            if self.exp.is_integer:
+                m = self.exp % 4
+                if m.is_zero:
+                    return True
+                if m.is_integer and m.is_zero is False:
+                    return False
+            if self.exp.is_imaginary:
+                from sympy.functions.elementary.exponential import log
+                return log(self.base).is_imaginary
+
+    def _eval_is_extended_negative(self):
+        if self.exp is S.Half:
+            if self.base.is_complex or self.base.is_extended_real:
+                return False
+        if self.base.is_extended_negative:
+            if self.exp.is_odd and self.base.is_finite:
+                return True
+            if self.exp.is_even:
+                return False
+        elif self.base.is_extended_positive:
+            if self.exp.is_extended_real:
+                return False
+        elif self.base.is_zero:
+            if self.exp.is_extended_real:
+                return False
+        elif self.base.is_extended_nonnegative:
+            if self.exp.is_extended_nonnegative:
+                return False
+        elif self.base.is_extended_nonpositive:
+            if self.exp.is_even:
+                return False
+        elif self.base.is_extended_real:
+            if self.exp.is_even:
+                return False
+
+    def _eval_is_zero(self):
+        if self.base.is_zero:
+            if self.exp.is_extended_positive:
+                return True
+            elif self.exp.is_extended_nonpositive:
+                return False
+        elif self.base == S.Exp1:
+            return self.exp is S.NegativeInfinity
+        elif self.base.is_zero is False:
+            if self.base.is_finite and self.exp.is_finite:
+                return False
+            elif self.exp.is_negative:
+                return self.base.is_infinite
+            elif self.exp.is_nonnegative:
+                return False
+            elif self.exp.is_infinite and self.exp.is_extended_real:
+                if (1 - abs(self.base)).is_extended_positive:
+                    return self.exp.is_extended_positive
+                elif (1 - abs(self.base)).is_extended_negative:
+                    return self.exp.is_extended_negative
+        elif self.base.is_finite and self.exp.is_negative:
+            # when self.base.is_zero is None
+            return False
+
+    def _eval_is_integer(self):
+        b, e = self.args
+        if b.is_rational:
+            if b.is_integer is False and e.is_positive:
+                return False  # rat**nonneg
+        if b.is_integer and e.is_integer:
+            if b is S.NegativeOne:
+                return True
+            if e.is_nonnegative or e.is_positive:
+                return True
+        if b.is_integer and e.is_negative and (e.is_finite or e.is_integer):
+            if fuzzy_not((b - 1).is_zero) and fuzzy_not((b + 1).is_zero):
+                return False
+        if b.is_Number and e.is_Number:
+            check = self.func(*self.args)
+            return check.is_Integer
+        if e.is_negative and b.is_positive and (b - 1).is_positive:
+            return False
+        if e.is_negative and b.is_negative and (b + 1).is_negative:
+            return False
+
+    def _eval_is_extended_real(self):
+        if self.base is S.Exp1:
+            if self.exp.is_extended_real:
+                return True
+            elif self.exp.is_imaginary:
+                return (2*S.ImaginaryUnit*self.exp/S.Pi).is_even
+
+        from sympy.functions.elementary.exponential import log, exp
+        real_b = self.base.is_extended_real
+        if real_b is None:
+            if self.base.func == exp and self.base.exp.is_imaginary:
+                return self.exp.is_imaginary
+            if self.base.func == Pow and self.base.base is S.Exp1 and self.base.exp.is_imaginary:
+                return self.exp.is_imaginary
+            return
+        real_e = self.exp.is_extended_real
+        if real_e is None:
+            return
+        if real_b and real_e:
+            if self.base.is_extended_positive:
+                return True
+            elif self.base.is_extended_nonnegative and self.exp.is_extended_nonnegative:
+                return True
+            elif self.exp.is_integer and self.base.is_extended_nonzero:
+                return True
+            elif self.exp.is_integer and self.exp.is_nonnegative:
+                return True
+            elif self.base.is_extended_negative:
+                if self.exp.is_Rational:
+                    return False
+        if real_e and self.exp.is_extended_negative and self.base.is_zero is False:
+            return Pow(self.base, -self.exp).is_extended_real
+        im_b = self.base.is_imaginary
+        im_e = self.exp.is_imaginary
+        if im_b:
+            if self.exp.is_integer:
+                if self.exp.is_even:
+                    return True
+                elif self.exp.is_odd:
+                    return False
+            elif im_e and log(self.base).is_imaginary:
+                return True
+            elif self.exp.is_Add:
+                c, a = self.exp.as_coeff_Add()
+                if c and c.is_Integer:
+                    return Mul(
+                        self.base**c, self.base**a, evaluate=False).is_extended_real
+            elif self.base in (-S.ImaginaryUnit, S.ImaginaryUnit):
+                if (self.exp/2).is_integer is False:
+                    return False
+        if real_b and im_e:
+            if self.base is S.NegativeOne:
+                return True
+            c = self.exp.coeff(S.ImaginaryUnit)
+            if c:
+                if self.base.is_rational and c.is_rational:
+                    if self.base.is_nonzero and (self.base - 1).is_nonzero and c.is_nonzero:
+                        return False
+                ok = (c*log(self.base)/S.Pi).is_integer
+                if ok is not None:
+                    return ok
+
+        if real_b is False and real_e: # we already know it's not imag
+            from sympy.functions.elementary.complexes import arg
+            i = arg(self.base)*self.exp/S.Pi
+            if i.is_complex: # finite
+                return i.is_integer
+
+    def _eval_is_complex(self):
+
+        if self.base == S.Exp1:
+            return fuzzy_or([self.exp.is_complex, self.exp.is_extended_negative])
+
+        if all(a.is_complex for a in self.args) and self._eval_is_finite():
+            return True
+
+    def _eval_is_imaginary(self):
+        if self.base.is_commutative is False:
+            return False
+
+        if self.base.is_imaginary:
+            if self.exp.is_integer:
+                odd = self.exp.is_odd
+                if odd is not None:
+                    return odd
+                return
+
+        if self.base == S.Exp1:
+            f = 2 * self.exp / (S.Pi*S.ImaginaryUnit)
+            # exp(pi*integer) = 1 or -1, so not imaginary
+            if f.is_even:
+                return False
+            # exp(pi*integer + pi/2) = I or -I, so it is imaginary
+            if f.is_odd:
+                return True
+            return None
+
+        if self.exp.is_imaginary:
+            from sympy.functions.elementary.exponential import log
+            imlog = log(self.base).is_imaginary
+            if imlog is not None:
+                return False  # I**i -> real; (2*I)**i -> complex ==> not imaginary
+
+        if self.base.is_extended_real and self.exp.is_extended_real:
+            if self.base.is_positive:
+                return False
+            else:
+                rat = self.exp.is_rational
+                if not rat:
+                    return rat
+                if self.exp.is_integer:
+                    return False
+                else:
+                    half = (2*self.exp).is_integer
+                    if half:
+                        return self.base.is_negative
+                    return half
+
+        if self.base.is_extended_real is False:  # we already know it's not imag
+            from sympy.functions.elementary.complexes import arg
+            i = arg(self.base)*self.exp/S.Pi
+            isodd = (2*i).is_odd
+            if isodd is not None:
+                return isodd
+
+    def _eval_is_odd(self):
+        if self.exp.is_integer:
+            if self.exp.is_positive:
+                return self.base.is_odd
+            elif self.exp.is_nonnegative and self.base.is_odd:
+                return True
+            elif self.base is S.NegativeOne:
+                return True
+
+    def _eval_is_finite(self):
+        if self.exp.is_negative:
+            if self.base.is_zero:
+                return False
+            if self.base.is_infinite or self.base.is_nonzero:
+                return True
+        c1 = self.base.is_finite
+        if c1 is None:
+            return
+        c2 = self.exp.is_finite
+        if c2 is None:
+            return
+        if c1 and c2:
+            if self.exp.is_nonnegative or fuzzy_not(self.base.is_zero):
+                return True
+
+    def _eval_is_prime(self):
+        '''
+        An integer raised to the n(>=2)-th power cannot be a prime.
+        '''
+        if self.base.is_integer and self.exp.is_integer and (self.exp - 1).is_positive:
+            return False
+
+    def _eval_is_composite(self):
+        """
+        A power is composite if both base and exponent are greater than 1
+        """
+        if (self.base.is_integer and self.exp.is_integer and
+            ((self.base - 1).is_positive and (self.exp - 1).is_positive or
+            (self.base + 1).is_negative and self.exp.is_positive and self.exp.is_even)):
+            return True
+
+    def _eval_is_polar(self):
+        return self.base.is_polar
+
+    def _eval_subs(self, old, new):
+        from sympy.calculus.accumulationbounds import AccumBounds
+
+        if isinstance(self.exp, AccumBounds):
+            b = self.base.subs(old, new)
+            e = self.exp.subs(old, new)
+            if isinstance(e, AccumBounds):
+                return e.__rpow__(b)
+            return self.func(b, e)
+
+        from sympy.functions.elementary.exponential import exp, log
+
+        def _check(ct1, ct2, old):
+            """Return (bool, pow, remainder_pow) where, if bool is True, then the
+            exponent of Pow `old` will combine with `pow` so the substitution
+            is valid, otherwise bool will be False.
+
+            For noncommutative objects, `pow` will be an integer, and a factor
+            `Pow(old.base, remainder_pow)` needs to be included. If there is
+            no such factor, None is returned. For commutative objects,
+            remainder_pow is always None.
+
+            cti are the coefficient and terms of an exponent of self or old
+            In this _eval_subs routine a change like (b**(2*x)).subs(b**x, y)
+            will give y**2 since (b**x)**2 == b**(2*x); if that equality does
+            not hold then the substitution should not occur so `bool` will be
+            False.
+
+            """
+            coeff1, terms1 = ct1
+            coeff2, terms2 = ct2
+            if terms1 == terms2:
+                if old.is_commutative:
+                    # Allow fractional powers for commutative objects
+                    pow = coeff1/coeff2
+                    try:
+                        as_int(pow, strict=False)
+                        combines = True
+                    except ValueError:
+                        b, e = old.as_base_exp()
+                        # These conditions ensure that (b**e)**f == b**(e*f) for any f
+                        combines = b.is_positive and e.is_real or b.is_nonnegative and e.is_nonnegative
+
+                    return combines, pow, None
+                else:
+                    # With noncommutative symbols, substitute only integer powers
+                    if not isinstance(terms1, tuple):
+                        terms1 = (terms1,)
+                    if not all(term.is_integer for term in terms1):
+                        return False, None, None
+
+                    try:
+                        # Round pow toward zero
+                        pow, remainder = divmod(as_int(coeff1), as_int(coeff2))
+                        if pow < 0 and remainder != 0:
+                            pow += 1
+                            remainder -= as_int(coeff2)
+
+                        if remainder == 0:
+                            remainder_pow = None
+                        else:
+                            remainder_pow = Mul(remainder, *terms1)
+
+                        return True, pow, remainder_pow
+                    except ValueError:
+                        # Can't substitute
+                        pass
+
+            return False, None, None
+
+        if old == self.base or (old == exp and self.base == S.Exp1):
+            if new.is_Function and isinstance(new, Callable):
+                return new(self.exp._subs(old, new))
+            else:
+                return new**self.exp._subs(old, new)
+
+        # issue 10829: (4**x - 3*y + 2).subs(2**x, y) -> y**2 - 3*y + 2
+        if isinstance(old, self.func) and self.exp == old.exp:
+            l = log(self.base, old.base)
+            if l.is_Number:
+                return Pow(new, l)
+
+        if isinstance(old, self.func) and self.base == old.base:
+            if self.exp.is_Add is False:
+                ct1 = self.exp.as_independent(Symbol, as_Add=False)
+                ct2 = old.exp.as_independent(Symbol, as_Add=False)
+                ok, pow, remainder_pow = _check(ct1, ct2, old)
+                if ok:
+                    # issue 5180: (x**(6*y)).subs(x**(3*y),z)->z**2
+                    result = self.func(new, pow)
+                    if remainder_pow is not None:
+                        result = Mul(result, Pow(old.base, remainder_pow))
+                    return result
+            else:  # b**(6*x + a).subs(b**(3*x), y) -> y**2 * b**a
+                # exp(exp(x) + exp(x**2)).subs(exp(exp(x)), w) -> w * exp(exp(x**2))
+                oarg = old.exp
+                new_l = []
+                o_al = []
+                ct2 = oarg.as_coeff_mul()
+                for a in self.exp.args:
+                    newa = a._subs(old, new)
+                    ct1 = newa.as_coeff_mul()
+                    ok, pow, remainder_pow = _check(ct1, ct2, old)
+                    if ok:
+                        new_l.append(new**pow)
+                        if remainder_pow is not None:
+                            o_al.append(remainder_pow)
+                        continue
+                    elif not old.is_commutative and not newa.is_integer:
+                        # If any term in the exponent is non-integer,
+                        # we do not do any substitutions in the noncommutative case
+                        return
+                    o_al.append(newa)
+                if new_l:
+                    expo = Add(*o_al)
+                    new_l.append(Pow(self.base, expo, evaluate=False) if expo != 1 else self.base)
+                    return Mul(*new_l)
+
+        if (isinstance(old, exp) or (old.is_Pow and old.base is S.Exp1)) and self.exp.is_extended_real and self.base.is_positive:
+            ct1 = old.exp.as_independent(Symbol, as_Add=False)
+            ct2 = (self.exp*log(self.base)).as_independent(
+                Symbol, as_Add=False)
+            ok, pow, remainder_pow = _check(ct1, ct2, old)
+            if ok:
+                result = self.func(new, pow)  # (2**x).subs(exp(x*log(2)), z) -> z
+                if remainder_pow is not None:
+                    result = Mul(result, Pow(old.base, remainder_pow))
+                return result
+
+    def as_base_exp(self):
+        """Return base and exp of self.
+
+        Explanation
+        ===========
+
+        If base a Rational less than 1, then return 1/Rational, -exp.
+        If this extra processing is not needed, the base and exp
+        properties will give the raw arguments.
+
+        Examples
+        ========
+
+        >>> from sympy import Pow, S
+        >>> p = Pow(S.Half, 2, evaluate=False)
+        >>> p.as_base_exp()
+        (2, -2)
+        >>> p.args
+        (1/2, 2)
+        >>> p.base, p.exp
+        (1/2, 2)
+
+        """
+
+        b, e = self.args
+        if b.is_Rational and b.p < b.q and b.p > 0:
+            return 1/b, -e
+        return b, e
+
+    def _eval_adjoint(self):
+        from sympy.functions.elementary.complexes import adjoint
+        i, p = self.exp.is_integer, self.base.is_positive
+        if i:
+            return adjoint(self.base)**self.exp
+        if p:
+            return self.base**adjoint(self.exp)
+        if i is False and p is False:
+            expanded = expand_complex(self)
+            if expanded != self:
+                return adjoint(expanded)
+
+    def _eval_conjugate(self):
+        from sympy.functions.elementary.complexes import conjugate as c
+        i, p = self.exp.is_integer, self.base.is_positive
+        if i:
+            return c(self.base)**self.exp
+        if p:
+            return self.base**c(self.exp)
+        if i is False and p is False:
+            expanded = expand_complex(self)
+            if expanded != self:
+                return c(expanded)
+        if self.is_extended_real:
+            return self
+
+    def _eval_transpose(self):
+        from sympy.functions.elementary.complexes import transpose
+        if self.base == S.Exp1:
+            return self.func(S.Exp1, self.exp.transpose())
+        i, p = self.exp.is_integer, (self.base.is_complex or self.base.is_infinite)
+        if p:
+            return self.base**self.exp
+        if i:
+            return transpose(self.base)**self.exp
+        if i is False and p is False:
+            expanded = expand_complex(self)
+            if expanded != self:
+                return transpose(expanded)
+
+    def _eval_expand_power_exp(self, **hints):
+        """a**(n + m) -> a**n*a**m"""
+        b = self.base
+        e = self.exp
+        if b == S.Exp1:
+            from sympy.concrete.summations import Sum
+            if isinstance(e, Sum) and e.is_commutative:
+                from sympy.concrete.products import Product
+                return Product(self.func(b, e.function), *e.limits)
+        if e.is_Add and (hints.get('force', False) or
+                b.is_zero is False or e._all_nonneg_or_nonppos()):
+            if e.is_commutative:
+                return Mul(*[self.func(b, x) for x in e.args])
+            if b.is_commutative:
+                c, nc = sift(e.args, lambda x: x.is_commutative, binary=True)
+                if c:
+                    return Mul(*[self.func(b, x) for x in c]
+                        )*b**Add._from_args(nc)
+        return self
+
+    def _eval_expand_power_base(self, **hints):
+        """(a*b)**n -> a**n * b**n"""
+        force = hints.get('force', False)
+
+        b = self.base
+        e = self.exp
+        if not b.is_Mul:
+            return self
+
+        cargs, nc = b.args_cnc(split_1=False)
+
+        # expand each term - this is top-level-only
+        # expansion but we have to watch out for things
+        # that don't have an _eval_expand method
+        if nc:
+            nc = [i._eval_expand_power_base(**hints)
+                if hasattr(i, '_eval_expand_power_base') else i
+                for i in nc]
+
+            if e.is_Integer:
+                if e.is_positive:
+                    rv = Mul(*nc*e)
+                else:
+                    rv = Mul(*[i**-1 for i in nc[::-1]]*-e)
+                if cargs:
+                    rv *= Mul(*cargs)**e
+                return rv
+
+            if not cargs:
+                return self.func(Mul(*nc), e, evaluate=False)
+
+            nc = [Mul(*nc)]
+
+        # sift the commutative bases
+        other, maybe_real = sift(cargs, lambda x: x.is_extended_real is False,
+            binary=True)
+        def pred(x):
+            if x is S.ImaginaryUnit:
+                return S.ImaginaryUnit
+            polar = x.is_polar
+            if polar:
+                return True
+            if polar is None:
+                return fuzzy_bool(x.is_extended_nonnegative)
+        sifted = sift(maybe_real, pred)
+        nonneg = sifted[True]
+        other += sifted[None]
+        neg = sifted[False]
+        imag = sifted[S.ImaginaryUnit]
+        if imag:
+            I = S.ImaginaryUnit
+            i = len(imag) % 4
+            if i == 0:
+                pass
+            elif i == 1:
+                other.append(I)
+            elif i == 2:
+                if neg:
+                    nonn = -neg.pop()
+                    if nonn is not S.One:
+                        nonneg.append(nonn)
+                else:
+                    neg.append(S.NegativeOne)
+            else:
+                if neg:
+                    nonn = -neg.pop()
+                    if nonn is not S.One:
+                        nonneg.append(nonn)
+                else:
+                    neg.append(S.NegativeOne)
+                other.append(I)
+            del imag
+
+        # bring out the bases that can be separated from the base
+
+        if force or e.is_integer:
+            # treat all commutatives the same and put nc in other
+            cargs = nonneg + neg + other
+            other = nc
+        else:
+            # this is just like what is happening automatically, except
+            # that now we are doing it for an arbitrary exponent for which
+            # no automatic expansion is done
+
+            assert not e.is_Integer
+
+            # handle negatives by making them all positive and putting
+            # the residual -1 in other
+            if len(neg) > 1:
+                o = S.One
+                if not other and neg[0].is_Number:
+                    o *= neg.pop(0)
+                if len(neg) % 2:
+                    o = -o
+                for n in neg:
+                    nonneg.append(-n)
+                if o is not S.One:
+                    other.append(o)
+            elif neg and other:
+                if neg[0].is_Number and neg[0] is not S.NegativeOne:
+                    other.append(S.NegativeOne)
+                    nonneg.append(-neg[0])
+                else:
+                    other.extend(neg)
+            else:
+                other.extend(neg)
+            del neg
+
+            cargs = nonneg
+            other += nc
+
+        rv = S.One
+        if cargs:
+            if e.is_Rational:
+                npow, cargs = sift(cargs, lambda x: x.is_Pow and
+                    x.exp.is_Rational and x.base.is_number,
+                    binary=True)
+                rv = Mul(*[self.func(b.func(*b.args), e) for b in npow])
+            rv *= Mul(*[self.func(b, e, evaluate=False) for b in cargs])
+        if other:
+            rv *= self.func(Mul(*other), e, evaluate=False)
+        return rv
+
+    def _eval_expand_multinomial(self, **hints):
+        """(a + b + ..)**n -> a**n + n*a**(n-1)*b + .., n is nonzero integer"""
+
+        base, exp = self.args
+        result = self
+
+        if exp.is_Rational and exp.p > 0 and base.is_Add:
+            if not exp.is_Integer:
+                n = Integer(exp.p // exp.q)
+
+                if not n:
+                    return result
+                else:
+                    radical, result = self.func(base, exp - n), []
+
+                    expanded_base_n = self.func(base, n)
+                    if expanded_base_n.is_Pow:
+                        expanded_base_n = \
+                            expanded_base_n._eval_expand_multinomial()
+                    for term in Add.make_args(expanded_base_n):
+                        result.append(term*radical)
+
+                    return Add(*result)
+
+            n = int(exp)
+
+            if base.is_commutative:
+                order_terms, other_terms = [], []
+
+                for b in base.args:
+                    if b.is_Order:
+                        order_terms.append(b)
+                    else:
+                        other_terms.append(b)
+
+                if order_terms:
+                    # (f(x) + O(x^n))^m -> f(x)^m + m*f(x)^{m-1} *O(x^n)
+                    f = Add(*other_terms)
+                    o = Add(*order_terms)
+
+                    if n == 2:
+                        return expand_multinomial(f**n, deep=False) + n*f*o
+                    else:
+                        g = expand_multinomial(f**(n - 1), deep=False)
+                        return expand_mul(f*g, deep=False) + n*g*o
+
+                if base.is_number:
+                    # Efficiently expand expressions of the form (a + b*I)**n
+                    # where 'a' and 'b' are real numbers and 'n' is integer.
+                    a, b = base.as_real_imag()
+
+                    if a.is_Rational and b.is_Rational:
+                        if not a.is_Integer:
+                            if not b.is_Integer:
+                                k = self.func(a.q * b.q, n)
+                                a, b = a.p*b.q, a.q*b.p
+                            else:
+                                k = self.func(a.q, n)
+                                a, b = a.p, a.q*b
+                        elif not b.is_Integer:
+                            k = self.func(b.q, n)
+                            a, b = a*b.q, b.p
+                        else:
+                            k = 1
+
+                        a, b, c, d = int(a), int(b), 1, 0
+
+                        while n:
+                            if n & 1:
+                                c, d = a*c - b*d, b*c + a*d
+                                n -= 1
+                            a, b = a*a - b*b, 2*a*b
+                            n //= 2
+
+                        I = S.ImaginaryUnit
+
+                        if k == 1:
+                            return c + I*d
+                        else:
+                            return Integer(c)/k + I*d/k
+
+                p = other_terms
+                # (x + y)**3 -> x**3 + 3*x**2*y + 3*x*y**2 + y**3
+                # in this particular example:
+                # p = [x,y]; n = 3
+                # so now it's easy to get the correct result -- we get the
+                # coefficients first:
+                from sympy.ntheory.multinomial import multinomial_coefficients
+                from sympy.polys.polyutils import basic_from_dict
+                expansion_dict = multinomial_coefficients(len(p), n)
+                # in our example: {(3, 0): 1, (1, 2): 3, (0, 3): 1, (2, 1): 3}
+                # and now construct the expression.
+                return basic_from_dict(expansion_dict, *p)
+            else:
+                if n == 2:
+                    return Add(*[f*g for f in base.args for g in base.args])
+                else:
+                    multi = (base**(n - 1))._eval_expand_multinomial()
+                    if multi.is_Add:
+                        return Add(*[f*g for f in base.args
+                            for g in multi.args])
+                    else:
+                        # XXX can this ever happen if base was an Add?
+                        return Add(*[f*multi for f in base.args])
+        elif (exp.is_Rational and exp.p < 0 and base.is_Add and
+                abs(exp.p) > exp.q):
+            return 1 / self.func(base, -exp)._eval_expand_multinomial()
+        elif exp.is_Add and base.is_Number and (hints.get('force', False) or
+                base.is_zero is False or exp._all_nonneg_or_nonppos()):
+            #  a + b      a  b
+            #  n      --> n  n, where n, a, b are Numbers
+            # XXX should be in expand_power_exp?
+            coeff, tail = [], []
+            for term in exp.args:
+                if term.is_Number:
+                    coeff.append(self.func(base, term))
+                else:
+                    tail.append(term)
+            return Mul(*(coeff + [self.func(base, Add._from_args(tail))]))
+        else:
+            return result
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.exp.is_Integer:
+            from sympy.polys.polytools import poly
+
+            exp = self.exp
+            re_e, im_e = self.base.as_real_imag(deep=deep)
+            if not im_e:
+                return self, S.Zero
+            a, b = symbols('a b', cls=Dummy)
+            if exp >= 0:
+                if re_e.is_Number and im_e.is_Number:
+                    # We can be more efficient in this case
+                    expr = expand_multinomial(self.base**exp)
+                    if expr != self:
+                        return expr.as_real_imag()
+
+                expr = poly(
+                    (a + b)**exp)  # a = re, b = im; expr = (a + b*I)**exp
+            else:
+                mag = re_e**2 + im_e**2
+                re_e, im_e = re_e/mag, -im_e/mag
+                if re_e.is_Number and im_e.is_Number:
+                    # We can be more efficient in this case
+                    expr = expand_multinomial((re_e + im_e*S.ImaginaryUnit)**-exp)
+                    if expr != self:
+                        return expr.as_real_imag()
+
+                expr = poly((a + b)**-exp)
+
+            # Terms with even b powers will be real
+            r = [i for i in expr.terms() if not i[0][1] % 2]
+            re_part = Add(*[cc*a**aa*b**bb for (aa, bb), cc in r])
+            # Terms with odd b powers will be imaginary
+            r = [i for i in expr.terms() if i[0][1] % 4 == 1]
+            im_part1 = Add(*[cc*a**aa*b**bb for (aa, bb), cc in r])
+            r = [i for i in expr.terms() if i[0][1] % 4 == 3]
+            im_part3 = Add(*[cc*a**aa*b**bb for (aa, bb), cc in r])
+
+            return (re_part.subs({a: re_e, b: S.ImaginaryUnit*im_e}),
+            im_part1.subs({a: re_e, b: im_e}) + im_part3.subs({a: re_e, b: -im_e}))
+
+        from sympy.functions.elementary.trigonometric import atan2, cos, sin
+
+        if self.exp.is_Rational:
+            re_e, im_e = self.base.as_real_imag(deep=deep)
+
+            if im_e.is_zero and self.exp is S.Half:
+                if re_e.is_extended_nonnegative:
+                    return self, S.Zero
+                if re_e.is_extended_nonpositive:
+                    return S.Zero, (-self.base)**self.exp
+
+            # XXX: This is not totally correct since for x**(p/q) with
+            #      x being imaginary there are actually q roots, but
+            #      only a single one is returned from here.
+            r = self.func(self.func(re_e, 2) + self.func(im_e, 2), S.Half)
+
+            t = atan2(im_e, re_e)
+
+            rp, tp = self.func(r, self.exp), t*self.exp
+
+            return rp*cos(tp), rp*sin(tp)
+        elif self.base is S.Exp1:
+            from sympy.functions.elementary.exponential import exp
+            re_e, im_e = self.exp.as_real_imag()
+            if deep:
+                re_e = re_e.expand(deep, **hints)
+                im_e = im_e.expand(deep, **hints)
+            c, s = cos(im_e), sin(im_e)
+            return exp(re_e)*c, exp(re_e)*s
+        else:
+            from sympy.functions.elementary.complexes import im, re
+            if deep:
+                hints['complex'] = False
+
+                expanded = self.expand(deep, **hints)
+                if hints.get('ignore') == expanded:
+                    return None
+                else:
+                    return (re(expanded), im(expanded))
+            else:
+                return re(self), im(self)
+
+    def _eval_derivative(self, s):
+        from sympy.functions.elementary.exponential import log
+        dbase = self.base.diff(s)
+        dexp = self.exp.diff(s)
+        return self * (dexp * log(self.base) + dbase * self.exp/self.base)
+
+    def _eval_evalf(self, prec):
+        base, exp = self.as_base_exp()
+        if base == S.Exp1:
+            # Use mpmath function associated to class "exp":
+            from sympy.functions.elementary.exponential import exp as exp_function
+            return exp_function(self.exp, evaluate=False)._eval_evalf(prec)
+        base = base._evalf(prec)
+        if not exp.is_Integer:
+            exp = exp._evalf(prec)
+        if exp.is_negative and base.is_number and base.is_extended_real is False:
+            base = base.conjugate() / (base * base.conjugate())._evalf(prec)
+            exp = -exp
+            return self.func(base, exp).expand()
+        return self.func(base, exp)
+
+    def _eval_is_polynomial(self, syms):
+        if self.exp.has(*syms):
+            return False
+
+        if self.base.has(*syms):
+            return bool(self.base._eval_is_polynomial(syms) and
+                self.exp.is_Integer and (self.exp >= 0))
+        else:
+            return True
+
+    def _eval_is_rational(self):
+        # The evaluation of self.func below can be very expensive in the case
+        # of integer**integer if the exponent is large.  We should try to exit
+        # before that if possible:
+        if (self.exp.is_integer and self.base.is_rational
+                and fuzzy_not(fuzzy_and([self.exp.is_negative, self.base.is_zero]))):
+            return True
+        p = self.func(*self.as_base_exp())  # in case it's unevaluated
+        if not p.is_Pow:
+            return p.is_rational
+        b, e = p.as_base_exp()
+        if e.is_Rational and b.is_Rational:
+            # we didn't check that e is not an Integer
+            # because Rational**Integer autosimplifies
+            return False
+        if e.is_integer:
+            if b.is_rational:
+                if fuzzy_not(b.is_zero) or e.is_nonnegative:
+                    return True
+                if b == e:  # always rational, even for 0**0
+                    return True
+            elif b.is_irrational:
+                return e.is_zero
+        if b is S.Exp1:
+            if e.is_rational and e.is_nonzero:
+                return False
+
+    def _eval_is_algebraic(self):
+        def _is_one(expr):
+            try:
+                return (expr - 1).is_zero
+            except ValueError:
+                # when the operation is not allowed
+                return False
+
+        if self.base.is_zero or _is_one(self.base):
+            return True
+        elif self.base is S.Exp1:
+            s = self.func(*self.args)
+            if s.func == self.func:
+                if self.exp.is_nonzero:
+                    if self.exp.is_algebraic:
+                        return False
+                    elif (self.exp/S.Pi).is_rational:
+                        return False
+                    elif (self.exp/(S.ImaginaryUnit*S.Pi)).is_rational:
+                        return True
+            else:
+                return s.is_algebraic
+        elif self.exp.is_rational:
+            if self.base.is_algebraic is False:
+                return self.exp.is_zero
+            if self.base.is_zero is False:
+                if self.exp.is_nonzero:
+                    return self.base.is_algebraic
+                elif self.base.is_algebraic:
+                    return True
+            if self.exp.is_positive:
+                return self.base.is_algebraic
+        elif self.base.is_algebraic and self.exp.is_algebraic:
+            if ((fuzzy_not(self.base.is_zero)
+                and fuzzy_not(_is_one(self.base)))
+                or self.base.is_integer is False
+                or self.base.is_irrational):
+                return self.exp.is_rational
+
+    def _eval_is_rational_function(self, syms):
+        if self.exp.has(*syms):
+            return False
+
+        if self.base.has(*syms):
+            return self.base._eval_is_rational_function(syms) and \
+                self.exp.is_Integer
+        else:
+            return True
+
+    def _eval_is_meromorphic(self, x, a):
+        # f**g is meromorphic if g is an integer and f is meromorphic.
+        # E**(log(f)*g) is meromorphic if log(f)*g is meromorphic
+        # and finite.
+        base_merom = self.base._eval_is_meromorphic(x, a)
+        exp_integer = self.exp.is_Integer
+        if exp_integer:
+            return base_merom
+
+        exp_merom = self.exp._eval_is_meromorphic(x, a)
+        if base_merom is False:
+            # f**g = E**(log(f)*g) may be meromorphic if the
+            # singularities of log(f) and g cancel each other,
+            # for example, if g = 1/log(f). Hence,
+            return False if exp_merom else None
+        elif base_merom is None:
+            return None
+
+        b = self.base.subs(x, a)
+        # b is extended complex as base is meromorphic.
+        # log(base) is finite and meromorphic when b != 0, zoo.
+        b_zero = b.is_zero
+        if b_zero:
+            log_defined = False
+        else:
+            log_defined = fuzzy_and((b.is_finite, fuzzy_not(b_zero)))
+
+        if log_defined is False: # zero or pole of base
+            return exp_integer  # False or None
+        elif log_defined is None:
+            return None
+
+        if not exp_merom:
+            return exp_merom  # False or None
+
+        return self.exp.subs(x, a).is_finite
+
+    def _eval_is_algebraic_expr(self, syms):
+        if self.exp.has(*syms):
+            return False
+
+        if self.base.has(*syms):
+            return self.base._eval_is_algebraic_expr(syms) and \
+                self.exp.is_Rational
+        else:
+            return True
+
+    def _eval_rewrite_as_exp(self, base, expo, **kwargs):
+        from sympy.functions.elementary.exponential import exp, log
+
+        if base.is_zero or base.has(exp) or expo.has(exp):
+            return base**expo
+
+        if base.has(Symbol):
+            # delay evaluation if expo is non symbolic
+            # (as exp(x*log(5)) automatically reduces to x**5)
+            if global_parameters.exp_is_pow:
+                return Pow(S.Exp1, log(base)*expo, evaluate=expo.has(Symbol))
+            else:
+                return exp(log(base)*expo, evaluate=expo.has(Symbol))
+
+        else:
+            from sympy.functions.elementary.complexes import arg, Abs
+            return exp((log(Abs(base)) + S.ImaginaryUnit*arg(base))*expo)
+
+    def as_numer_denom(self):
+        if not self.is_commutative:
+            return self, S.One
+        base, exp = self.as_base_exp()
+        n, d = base.as_numer_denom()
+        # this should be the same as ExpBase.as_numer_denom wrt
+        # exponent handling
+        neg_exp = exp.is_negative
+        if exp.is_Mul and not neg_exp and not exp.is_positive:
+            neg_exp = exp.could_extract_minus_sign()
+        int_exp = exp.is_integer
+        # the denominator cannot be separated from the numerator if
+        # its sign is unknown unless the exponent is an integer, e.g.
+        # sqrt(a/b) != sqrt(a)/sqrt(b) when a=1 and b=-1. But if the
+        # denominator is negative the numerator and denominator can
+        # be negated and the denominator (now positive) separated.
+        if not (d.is_extended_real or int_exp):
+            n = base
+            d = S.One
+        dnonpos = d.is_nonpositive
+        if dnonpos:
+            n, d = -n, -d
+        elif dnonpos is None and not int_exp:
+            n = base
+            d = S.One
+        if neg_exp:
+            n, d = d, n
+            exp = -exp
+        if exp.is_infinite:
+            if n is S.One and d is not S.One:
+                return n, self.func(d, exp)
+            if n is not S.One and d is S.One:
+                return self.func(n, exp), d
+        return self.func(n, exp), self.func(d, exp)
+
+    def matches(self, expr, repl_dict=None, old=False):
+        expr = _sympify(expr)
+        if repl_dict is None:
+            repl_dict = {}
+
+        # special case, pattern = 1 and expr.exp can match to 0
+        if expr is S.One:
+            d = self.exp.matches(S.Zero, repl_dict)
+            if d is not None:
+                return d
+
+        # make sure the expression to be matched is an Expr
+        if not isinstance(expr, Expr):
+            return None
+
+        b, e = expr.as_base_exp()
+
+        # special case number
+        sb, se = self.as_base_exp()
+        if sb.is_Symbol and se.is_Integer and expr:
+            if e.is_rational:
+                return sb.matches(b**(e/se), repl_dict)
+            return sb.matches(expr**(1/se), repl_dict)
+
+        d = repl_dict.copy()
+        d = self.base.matches(b, d)
+        if d is None:
+            return None
+
+        d = self.exp.xreplace(d).matches(e, d)
+        if d is None:
+            return Expr.matches(self, expr, repl_dict)
+        return d
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE! This function is an important part of the gruntz algorithm
+        #       for computing limits. It has to return a generalized power
+        #       series with coefficients in C(log, log(x)). In more detail:
+        # It has to return an expression
+        #     c_0*x**e_0 + c_1*x**e_1 + ... (finitely many terms)
+        # where e_i are numbers (not necessarily integers) and c_i are
+        # expressions involving only numbers, the log function, and log(x).
+        # The series expansion of b**e is computed as follows:
+        # 1) We express b as f*(1 + g) where f is the leading term of b.
+        #    g has order O(x**d) where d is strictly positive.
+        # 2) Then b**e = (f**e)*((1 + g)**e).
+        #    (1 + g)**e is computed using binomial series.
+        from sympy.functions.elementary.exponential import exp, log
+        from sympy.series.limits import limit
+        from sympy.series.order import Order
+        from sympy.core.sympify import sympify
+        if self.base is S.Exp1:
+            e_series = self.exp.nseries(x, n=n, logx=logx)
+            if e_series.is_Order:
+                return 1 + e_series
+            e0 = limit(e_series.removeO(), x, 0)
+            if e0 is S.NegativeInfinity:
+                return Order(x**n, x)
+            if e0 is S.Infinity:
+                return self
+            t = e_series - e0
+            exp_series = term = exp(e0)
+            # series of exp(e0 + t) in t
+            for i in range(1, n):
+                term *= t/i
+                term = term.nseries(x, n=n, logx=logx)
+                exp_series += term
+            exp_series += Order(t**n, x)
+            from sympy.simplify.powsimp import powsimp
+            return powsimp(exp_series, deep=True, combine='exp')
+        from sympy.simplify.powsimp import powdenest
+        from .numbers import _illegal
+        self = powdenest(self, force=True).trigsimp()
+        b, e = self.as_base_exp()
+
+        if e.has(*_illegal):
+            raise PoleError()
+
+        if e.has(x):
+            return exp(e*log(b))._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+        if logx is not None and b.has(log):
+            from .symbol import Wild
+            c, ex = symbols('c, ex', cls=Wild, exclude=[x])
+            b = b.replace(log(c*x**ex), log(c) + ex*logx)
+            self = b**e
+
+        b = b.removeO()
+        try:
+            from sympy.functions.special.gamma_functions import polygamma
+            if b.has(polygamma, S.EulerGamma) and logx is not None:
+                raise ValueError()
+            _, m = b.leadterm(x)
+        except (ValueError, NotImplementedError, PoleError):
+            b = b._eval_nseries(x, n=max(2, n), logx=logx, cdir=cdir).removeO()
+            if b.has(S.NaN, S.ComplexInfinity):
+                raise NotImplementedError()
+            _, m = b.leadterm(x)
+
+        if e.has(log):
+            from sympy.simplify.simplify import logcombine
+            e = logcombine(e).cancel()
+
+        if not (m.is_zero or e.is_number and e.is_real):
+            if self == self._eval_as_leading_term(x, logx=logx, cdir=cdir):
+                res = exp(e*log(b))._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+                if res == exp(e*log(b)):
+                    return self
+                return res
+
+        f = b.as_leading_term(x, logx=logx)
+        g = (b/f - S.One).cancel(expand=False)
+        if not m.is_number:
+            raise NotImplementedError()
+        maxpow = n - m*e
+        if maxpow.has(Symbol):
+            maxpow = sympify(n)
+
+        if maxpow.is_negative:
+            return Order(x**(m*e), x)
+
+        if g.is_zero:
+            r = f**e
+            if r != self:
+                r += Order(x**n, x)
+            return r
+
+        def coeff_exp(term, x):
+            coeff, exp = S.One, S.Zero
+            for factor in Mul.make_args(term):
+                if factor.has(x):
+                    base, exp = factor.as_base_exp()
+                    if base != x:
+                        try:
+                            return term.leadterm(x)
+                        except ValueError:
+                            return term, S.Zero
+                else:
+                    coeff *= factor
+            return coeff, exp
+
+        def mul(d1, d2):
+            res = {}
+            for e1, e2 in product(d1, d2):
+                ex = e1 + e2
+                if ex < maxpow:
+                    res[ex] = res.get(ex, S.Zero) + d1[e1]*d2[e2]
+            return res
+
+        try:
+            c, d = g.leadterm(x, logx=logx)
+        except (ValueError, NotImplementedError):
+            if limit(g/x**maxpow, x, 0) == 0:
+                # g has higher order zero
+                return f**e + e*f**e*g  # first term of binomial series
+            else:
+                raise NotImplementedError()
+        if c.is_Float and d == S.Zero:
+            # Convert floats like 0.5 to exact SymPy numbers like S.Half, to
+            # prevent rounding errors which can induce wrong values of d leading
+            # to a NotImplementedError being returned from the block below.
+            from sympy.simplify.simplify import nsimplify
+            _, d = nsimplify(g).leadterm(x, logx=logx)
+        if not d.is_positive:
+            g = g.simplify()
+            if g.is_zero:
+                return f**e
+            _, d = g.leadterm(x, logx=logx)
+            if not d.is_positive:
+                g = ((b - f)/f).expand()
+                _, d = g.leadterm(x, logx=logx)
+                if not d.is_positive:
+                    raise NotImplementedError()
+
+        from sympy.functions.elementary.integers import ceiling
+        gpoly = g._eval_nseries(x, n=ceiling(maxpow), logx=logx, cdir=cdir).removeO()
+        gterms = {}
+
+        for term in Add.make_args(gpoly):
+            co1, e1 = coeff_exp(term, x)
+            gterms[e1] = gterms.get(e1, S.Zero) + co1
+
+        k = S.One
+        terms = {S.Zero: S.One}
+        tk = gterms
+
+        from sympy.functions.combinatorial.factorials import factorial, ff
+
+        while (k*d - maxpow).is_negative:
+            coeff = ff(e, k)/factorial(k)
+            for ex in tk:
+                terms[ex] = terms.get(ex, S.Zero) + coeff*tk[ex]
+            tk = mul(tk, gterms)
+            k += S.One
+
+        from sympy.functions.elementary.complexes import im
+
+        if not e.is_integer and m.is_zero and f.is_negative:
+            ndir = (b - f).dir(x, cdir)
+            if im(ndir).is_negative:
+                inco, inex = coeff_exp(f**e*(-1)**(-2*e), x)
+            elif im(ndir).is_zero:
+                inco, inex = coeff_exp(exp(e*log(b)).as_leading_term(x, logx=logx, cdir=cdir), x)
+            else:
+                inco, inex = coeff_exp(f**e, x)
+        else:
+            inco, inex = coeff_exp(f**e, x)
+        res = S.Zero
+
+        for e1 in terms:
+            ex = e1 + inex
+            res += terms[e1]*inco*x**(ex)
+
+        if not (e.is_integer and e.is_positive and (e*d - n).is_nonpositive and
+                res == _mexpand(self)):
+            try:
+                res += Order(x**n, x)
+            except NotImplementedError:
+                return exp(e*log(b))._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.functions.elementary.exponential import exp, log
+        e = self.exp
+        b = self.base
+        if self.base is S.Exp1:
+            arg = e.as_leading_term(x, logx=logx)
+            arg0 = arg.subs(x, 0)
+            if arg0 is S.NaN:
+                arg0 = arg.limit(x, 0)
+            if arg0.is_infinite is False:
+                return S.Exp1**arg0
+            raise PoleError("Cannot expand %s around 0" % (self))
+        elif e.has(x):
+            lt = exp(e * log(b))
+            return lt.as_leading_term(x, logx=logx, cdir=cdir)
+        else:
+            from sympy.functions.elementary.complexes import im
+            try:
+                f = b.as_leading_term(x, logx=logx, cdir=cdir)
+            except PoleError:
+                return self
+            if not e.is_integer and f.is_negative and not f.has(x):
+                ndir = (b - f).dir(x, cdir)
+                if im(ndir).is_negative:
+                    # Normally, f**e would evaluate to exp(e*log(f)) but on branch cuts
+                    # an other value is expected through the following computation
+                    # exp(e*(log(f) - 2*pi*I)) == f**e*exp(-2*e*pi*I) == f**e*(-1)**(-2*e).
+                    return self.func(f, e) * (-1)**(-2*e)
+                elif im(ndir).is_zero:
+                    log_leadterm = log(b)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+                    if log_leadterm.is_infinite is False:
+                        return exp(e*log_leadterm)
+            return self.func(f, e)
+
+    @cacheit
+    def _taylor_term(self, n, x, *previous_terms): # of (1 + x)**e
+        from sympy.functions.combinatorial.factorials import binomial
+        return binomial(self.exp, n) * self.func(x, n)
+
+    def taylor_term(self, n, x, *previous_terms):
+        if self.base is not S.Exp1:
+            return super().taylor_term(n, x, *previous_terms)
+        if n < 0:
+            return S.Zero
+        if n == 0:
+            return S.One
+        from .sympify import sympify
+        x = sympify(x)
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return p * x / n
+        from sympy.functions.combinatorial.factorials import factorial
+        return x**n/factorial(n)
+
+    def _eval_rewrite_as_sin(self, base, exp):
+        if self.base is S.Exp1:
+            from sympy.functions.elementary.trigonometric import sin
+            return sin(S.ImaginaryUnit*self.exp + S.Pi/2) - S.ImaginaryUnit*sin(S.ImaginaryUnit*self.exp)
+
+    def _eval_rewrite_as_cos(self, base, exp):
+        if self.base is S.Exp1:
+            from sympy.functions.elementary.trigonometric import cos
+            return cos(S.ImaginaryUnit*self.exp) + S.ImaginaryUnit*cos(S.ImaginaryUnit*self.exp + S.Pi/2)
+
+    def _eval_rewrite_as_tanh(self, base, exp):
+        if self.base is S.Exp1:
+            from sympy.functions.elementary.hyperbolic import tanh
+            return (1 + tanh(self.exp/2))/(1 - tanh(self.exp/2))
+
+    def _eval_rewrite_as_sqrt(self, base, exp, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin, cos
+        if base is not S.Exp1:
+            return None
+        if exp.is_Mul:
+            coeff = exp.coeff(S.Pi * S.ImaginaryUnit)
+            if coeff and coeff.is_number:
+                cosine, sine = cos(S.Pi*coeff), sin(S.Pi*coeff)
+                if not isinstance(cosine, cos) and not isinstance (sine, sin):
+                    return cosine + S.ImaginaryUnit*sine
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """Return the tuple (R, self/R) where R is the positive Rational
+        extracted from self.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> sqrt(4 + 4*sqrt(2)).as_content_primitive()
+        (2, sqrt(1 + sqrt(2)))
+        >>> sqrt(3 + 3*sqrt(2)).as_content_primitive()
+        (1, sqrt(3)*sqrt(1 + sqrt(2)))
+
+        >>> from sympy import expand_power_base, powsimp, Mul
+        >>> from sympy.abc import x, y
+
+        >>> ((2*x + 2)**2).as_content_primitive()
+        (4, (x + 1)**2)
+        >>> (4**((1 + y)/2)).as_content_primitive()
+        (2, 4**(y/2))
+        >>> (3**((1 + y)/2)).as_content_primitive()
+        (1, 3**((y + 1)/2))
+        >>> (3**((5 + y)/2)).as_content_primitive()
+        (9, 3**((y + 1)/2))
+        >>> eq = 3**(2 + 2*x)
+        >>> powsimp(eq) == eq
+        True
+        >>> eq.as_content_primitive()
+        (9, 3**(2*x))
+        >>> powsimp(Mul(*_))
+        3**(2*x + 2)
+
+        >>> eq = (2 + 2*x)**y
+        >>> s = expand_power_base(eq); s.is_Mul, s
+        (False, (2*x + 2)**y)
+        >>> eq.as_content_primitive()
+        (1, (2*(x + 1))**y)
+        >>> s = expand_power_base(_[1]); s.is_Mul, s
+        (True, 2**y*(x + 1)**y)
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+
+        b, e = self.as_base_exp()
+        b = _keep_coeff(*b.as_content_primitive(radical=radical, clear=clear))
+        ce, pe = e.as_content_primitive(radical=radical, clear=clear)
+        if b.is_Rational:
+            #e
+            #= ce*pe
+            #= ce*(h + t)
+            #= ce*h + ce*t
+            #=> self
+            #= b**(ce*h)*b**(ce*t)
+            #= b**(cehp/cehq)*b**(ce*t)
+            #= b**(iceh + r/cehq)*b**(ce*t)
+            #= b**(iceh)*b**(r/cehq)*b**(ce*t)
+            #= b**(iceh)*b**(ce*t + r/cehq)
+            h, t = pe.as_coeff_Add()
+            if h.is_Rational and b != S.Zero:
+                ceh = ce*h
+                c = self.func(b, ceh)
+                r = S.Zero
+                if not c.is_Rational:
+                    iceh, r = divmod(ceh.p, ceh.q)
+                    c = self.func(b, iceh)
+                return c, self.func(b, _keep_coeff(ce, t + r/ce/ceh.q))
+        e = _keep_coeff(ce, pe)
+        # b**e = (h*t)**e = h**e*t**e = c*m*t**e
+        if e.is_Rational and b.is_Mul:
+            h, t = b.as_content_primitive(radical=radical, clear=clear)  # h is positive
+            c, m = self.func(h, e).as_coeff_Mul()  # so c is positive
+            m, me = m.as_base_exp()
+            if m is S.One or me == e:  # probably always true
+                # return the following, not return c, m*Pow(t, e)
+                # which would change Pow into Mul; we let SymPy
+                # decide what to do by using the unevaluated Mul, e.g
+                # should it stay as sqrt(2 + 2*sqrt(5)) or become
+                # sqrt(2)*sqrt(1 + sqrt(5))
+                return c, self.func(_keep_coeff(m, t), e)
+        return S.One, self.func(b, e)
+
+    def is_constant(self, *wrt, **flags):
+        expr = self
+        if flags.get('simplify', True):
+            expr = expr.simplify()
+        b, e = expr.as_base_exp()
+        bz = b.equals(0)
+        if bz:  # recalculate with assumptions in case it's unevaluated
+            new = b**e
+            if new != expr:
+                return new.is_constant()
+        econ = e.is_constant(*wrt)
+        bcon = b.is_constant(*wrt)
+        if bcon:
+            if econ:
+                return True
+            bz = b.equals(0)
+            if bz is False:
+                return False
+        elif bcon is None:
+            return None
+
+        return e.equals(0)
+
+    def _eval_difference_delta(self, n, step):
+        b, e = self.args
+        if e.has(n) and not b.has(n):
+            new_e = e.subs(n, n + step)
+            return (b**(new_e - e) - 1) * self
+
+power = Dispatcher('power')
+power.add((object, object), Pow)
+
+from .add import Add
+from .numbers import Integer
+from .mul import Mul, _keep_coeff
+from .symbol import Symbol, Dummy, symbols

llmeval-env/lib/python3.10/site-packages/sympy/core/random.py

@@ -0,0 +1,227 @@
+"""
+When you need to use random numbers in SymPy library code, import from here
+so there is only one generator working for SymPy. Imports from here should
+behave the same as if they were being imported from Python's random module.
+But only the routines currently used in SymPy are included here. To use others
+import ``rng`` and access the method directly. For example, to capture the
+current state of the generator use ``rng.getstate()``.
+
+There is intentionally no Random to import from here. If you want
+to control the state of the generator, import ``seed`` and call it
+with or without an argument to set the state.
+
+Examples
+========
+
+>>> from sympy.core.random import random, seed
+>>> assert random() < 1
+>>> seed(1); a = random()
+>>> b = random()
+>>> seed(1); c = random()
+>>> assert a == c
+>>> assert a != b  # remote possibility this will fail
+
+"""
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import as_int
+
+import random as _random
+rng = _random.Random()
+
+choice = rng.choice
+random = rng.random
+randint = rng.randint
+randrange = rng.randrange
+sample = rng.sample
+# seed = rng.seed
+shuffle = rng.shuffle
+uniform = rng.uniform
+
+_assumptions_rng = _random.Random()
+_assumptions_shuffle = _assumptions_rng.shuffle
+
+
+def seed(a=None, version=2):
+    rng.seed(a=a, version=version)
+    _assumptions_rng.seed(a=a, version=version)
+
+
+def random_complex_number(a=2, b=-1, c=3, d=1, rational=False, tolerance=None):
+    """
+    Return a random complex number.
+
+    To reduce chance of hitting branch cuts or anything, we guarantee
+    b <= Im z <= d, a <= Re z <= c
+
+    When rational is True, a rational approximation to a random number
+    is obtained within specified tolerance, if any.
+    """
+    from sympy.core.numbers import I
+    from sympy.simplify.simplify import nsimplify
+    A, B = uniform(a, c), uniform(b, d)
+    if not rational:
+        return A + I*B
+    return (nsimplify(A, rational=True, tolerance=tolerance) +
+        I*nsimplify(B, rational=True, tolerance=tolerance))
+
+
+def verify_numerically(f, g, z=None, tol=1.0e-6, a=2, b=-1, c=3, d=1):
+    """
+    Test numerically that f and g agree when evaluated in the argument z.
+
+    If z is None, all symbols will be tested. This routine does not test
+    whether there are Floats present with precision higher than 15 digits
+    so if there are, your results may not be what you expect due to round-
+    off errors.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, cos
+    >>> from sympy.abc import x
+    >>> from sympy.core.random import verify_numerically as tn
+    >>> tn(sin(x)**2 + cos(x)**2, 1, x)
+    True
+    """
+    from sympy.core.symbol import Symbol
+    from sympy.core.sympify import sympify
+    from sympy.core.numbers import comp
+    f, g = (sympify(i) for i in (f, g))
+    if z is None:
+        z = f.free_symbols | g.free_symbols
+    elif isinstance(z, Symbol):
+        z = [z]
+    reps = list(zip(z, [random_complex_number(a, b, c, d) for _ in z]))
+    z1 = f.subs(reps).n()
+    z2 = g.subs(reps).n()
+    return comp(z1, z2, tol)
+
+
+def test_derivative_numerically(f, z, tol=1.0e-6, a=2, b=-1, c=3, d=1):
+    """
+    Test numerically that the symbolically computed derivative of f
+    with respect to z is correct.
+
+    This routine does not test whether there are Floats present with
+    precision higher than 15 digits so if there are, your results may
+    not be what you expect due to round-off errors.
+
+    Examples
+    ========
+
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> from sympy.core.random import test_derivative_numerically as td
+    >>> td(sin(x), x)
+    True
+    """
+    from sympy.core.numbers import comp
+    from sympy.core.function import Derivative
+    z0 = random_complex_number(a, b, c, d)
+    f1 = f.diff(z).subs(z, z0)
+    f2 = Derivative(f, z).doit_numerically(z0)
+    return comp(f1.n(), f2.n(), tol)
+
+
+def _randrange(seed=None):
+    """Return a randrange generator.
+
+    ``seed`` can be
+
+    * None - return randomly seeded generator
+    * int - return a generator seeded with the int
+    * list - the values to be returned will be taken from the list
+      in the order given; the provided list is not modified.
+
+    Examples
+    ========
+
+    >>> from sympy.core.random import _randrange
+    >>> rr = _randrange()
+    >>> rr(1000) # doctest: +SKIP
+    999
+    >>> rr = _randrange(3)
+    >>> rr(1000) # doctest: +SKIP
+    238
+    >>> rr = _randrange([0, 5, 1, 3, 4])
+    >>> rr(3), rr(3)
+    (0, 1)
+    """
+    if seed is None:
+        return randrange
+    elif isinstance(seed, int):
+        rng.seed(seed)
+        return randrange
+    elif is_sequence(seed):
+        seed = list(seed)  # make a copy
+        seed.reverse()
+
+        def give(a, b=None, seq=seed):
+            if b is None:
+                a, b = 0, a
+            a, b = as_int(a), as_int(b)
+            w = b - a
+            if w < 1:
+                raise ValueError('_randrange got empty range')
+            try:
+                x = seq.pop()
+            except IndexError:
+                raise ValueError('_randrange sequence was too short')
+            if a <= x < b:
+                return x
+            else:
+                return give(a, b, seq)
+        return give
+    else:
+        raise ValueError('_randrange got an unexpected seed')
+
+
+def _randint(seed=None):
+    """Return a randint generator.
+
+    ``seed`` can be
+
+    * None - return randomly seeded generator
+    * int - return a generator seeded with the int
+    * list - the values to be returned will be taken from the list
+      in the order given; the provided list is not modified.
+
+    Examples
+    ========
+
+    >>> from sympy.core.random import _randint
+    >>> ri = _randint()
+    >>> ri(1, 1000) # doctest: +SKIP
+    999
+    >>> ri = _randint(3)
+    >>> ri(1, 1000) # doctest: +SKIP
+    238
+    >>> ri = _randint([0, 5, 1, 2, 4])
+    >>> ri(1, 3), ri(1, 3)
+    (1, 2)
+    """
+    if seed is None:
+        return randint
+    elif isinstance(seed, int):
+        rng.seed(seed)
+        return randint
+    elif is_sequence(seed):
+        seed = list(seed)  # make a copy
+        seed.reverse()
+
+        def give(a, b, seq=seed):
+            a, b = as_int(a), as_int(b)
+            w = b - a
+            if w < 0:
+                raise ValueError('_randint got empty range')
+            try:
+                x = seq.pop()
+            except IndexError:
+                raise ValueError('_randint sequence was too short')
+            if a <= x <= b:
+                return x
+            else:
+                return give(a, b, seq)
+        return give
+    else:
+        raise ValueError('_randint got an unexpected seed')

llmeval-env/lib/python3.10/site-packages/sympy/core/relational.py

@@ -0,0 +1,1587 @@
+from __future__ import annotations
+
+from .basic import Atom, Basic
+from .sorting import ordered
+from .evalf import EvalfMixin
+from .function import AppliedUndef
+from .singleton import S
+from .sympify import _sympify, SympifyError
+from .parameters import global_parameters
+from .logic import fuzzy_bool, fuzzy_xor, fuzzy_and, fuzzy_not
+from sympy.logic.boolalg import Boolean, BooleanAtom
+from sympy.utilities.iterables import sift
+from sympy.utilities.misc import filldedent
+
+__all__ = (
+    'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge',
+    'Relational', 'Equality', 'Unequality', 'StrictLessThan', 'LessThan',
+    'StrictGreaterThan', 'GreaterThan',
+)
+
+from .expr import Expr
+from sympy.multipledispatch import dispatch
+from .containers import Tuple
+from .symbol import Symbol
+
+
+def _nontrivBool(side):
+    return isinstance(side, Boolean) and \
+           not isinstance(side, Atom)
+
+
+# Note, see issue 4986.  Ideally, we wouldn't want to subclass both Boolean
+# and Expr.
+# from .. import Expr
+
+
+def _canonical(cond):
+    # return a condition in which all relationals are canonical
+    reps = {r: r.canonical for r in cond.atoms(Relational)}
+    return cond.xreplace(reps)
+    # XXX: AttributeError was being caught here but it wasn't triggered by any of
+    # the tests so I've removed it...
+
+
+def _canonical_coeff(rel):
+    # return -2*x + 1 < 0 as x > 1/2
+    # XXX make this part of Relational.canonical?
+    rel = rel.canonical
+    if not rel.is_Relational or rel.rhs.is_Boolean:
+        return rel  # Eq(x, True)
+    b, l = rel.lhs.as_coeff_Add(rational=True)
+    m, lhs = l.as_coeff_Mul(rational=True)
+    rhs = (rel.rhs - b)/m
+    if m < 0:
+        return rel.reversed.func(lhs, rhs)
+    return rel.func(lhs, rhs)
+
+
+class Relational(Boolean, EvalfMixin):
+    """Base class for all relation types.
+
+    Explanation
+    ===========
+
+    Subclasses of Relational should generally be instantiated directly, but
+    Relational can be instantiated with a valid ``rop`` value to dispatch to
+    the appropriate subclass.
+
+    Parameters
+    ==========
+
+    rop : str or None
+        Indicates what subclass to instantiate.  Valid values can be found
+        in the keys of Relational.ValidRelationOperator.
+
+    Examples
+    ========
+
+    >>> from sympy import Rel
+    >>> from sympy.abc import x, y
+    >>> Rel(y, x + x**2, '==')
+    Eq(y, x**2 + x)
+
+    A relation's type can be defined upon creation using ``rop``.
+    The relation type of an existing expression can be obtained
+    using its ``rel_op`` property.
+    Here is a table of all the relation types, along with their
+    ``rop`` and ``rel_op`` values:
+
+    +---------------------+----------------------------+------------+
+    |Relation             |``rop``                     |``rel_op``  |
+    +=====================+============================+============+
+    |``Equality``         |``==`` or ``eq`` or ``None``|``==``      |
+    +---------------------+----------------------------+------------+
+    |``Unequality``       |``!=`` or ``ne``            |``!=``      |
+    +---------------------+----------------------------+------------+
+    |``GreaterThan``      |``>=`` or ``ge``            |``>=``      |
+    +---------------------+----------------------------+------------+
+    |``LessThan``         |``<=`` or ``le``            |``<=``      |
+    +---------------------+----------------------------+------------+
+    |``StrictGreaterThan``|``>`` or ``gt``             |``>``       |
+    +---------------------+----------------------------+------------+
+    |``StrictLessThan``   |``<`` or ``lt``             |``<``       |
+    +---------------------+----------------------------+------------+
+
+    For example, setting ``rop`` to ``==`` produces an
+    ``Equality`` relation, ``Eq()``.
+    So does setting ``rop`` to ``eq``, or leaving ``rop`` unspecified.
+    That is, the first three ``Rel()`` below all produce the same result.
+    Using a ``rop`` from a different row in the table produces a
+    different relation type.
+    For example, the fourth ``Rel()`` below using ``lt`` for ``rop``
+    produces a ``StrictLessThan`` inequality:
+
+    >>> from sympy import Rel
+    >>> from sympy.abc import x, y
+    >>> Rel(y, x + x**2, '==')
+        Eq(y, x**2 + x)
+    >>> Rel(y, x + x**2, 'eq')
+        Eq(y, x**2 + x)
+    >>> Rel(y, x + x**2)
+        Eq(y, x**2 + x)
+    >>> Rel(y, x + x**2, 'lt')
+        y < x**2 + x
+
+    To obtain the relation type of an existing expression,
+    get its ``rel_op`` property.
+    For example, ``rel_op`` is ``==`` for the ``Equality`` relation above,
+    and ``<`` for the strict less than inequality above:
+
+    >>> from sympy import Rel
+    >>> from sympy.abc import x, y
+    >>> my_equality = Rel(y, x + x**2, '==')
+    >>> my_equality.rel_op
+        '=='
+    >>> my_inequality = Rel(y, x + x**2, 'lt')
+    >>> my_inequality.rel_op
+        '<'
+
+    """
+    __slots__ = ()
+
+    ValidRelationOperator: dict[str | None, type[Relational]] = {}
+
+    is_Relational = True
+
+    # ValidRelationOperator - Defined below, because the necessary classes
+    #   have not yet been defined
+
+    def __new__(cls, lhs, rhs, rop=None, **assumptions):
+        # If called by a subclass, do nothing special and pass on to Basic.
+        if cls is not Relational:
+            return Basic.__new__(cls, lhs, rhs, **assumptions)
+
+        # XXX: Why do this? There should be a separate function to make a
+        # particular subclass of Relational from a string.
+        #
+        # If called directly with an operator, look up the subclass
+        # corresponding to that operator and delegate to it
+        cls = cls.ValidRelationOperator.get(rop, None)
+        if cls is None:
+            raise ValueError("Invalid relational operator symbol: %r" % rop)
+
+        if not issubclass(cls, (Eq, Ne)):
+            # validate that Booleans are not being used in a relational
+            # other than Eq/Ne;
+            # Note: Symbol is a subclass of Boolean but is considered
+            # acceptable here.
+            if any(map(_nontrivBool, (lhs, rhs))):
+                raise TypeError(filldedent('''
+                    A Boolean argument can only be used in
+                    Eq and Ne; all other relationals expect
+                    real expressions.
+                '''))
+
+        return cls(lhs, rhs, **assumptions)
+
+    @property
+    def lhs(self):
+        """The left-hand side of the relation."""
+        return self._args[0]
+
+    @property
+    def rhs(self):
+        """The right-hand side of the relation."""
+        return self._args[1]
+
+    @property
+    def reversed(self):
+        """Return the relationship with sides reversed.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x, 1)
+        Eq(x, 1)
+        >>> _.reversed
+        Eq(1, x)
+        >>> x < 1
+        x < 1
+        >>> _.reversed
+        1 > x
+        """
+        ops = {Eq: Eq, Gt: Lt, Ge: Le, Lt: Gt, Le: Ge, Ne: Ne}
+        a, b = self.args
+        return Relational.__new__(ops.get(self.func, self.func), b, a)
+
+    @property
+    def reversedsign(self):
+        """Return the relationship with signs reversed.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x, 1)
+        Eq(x, 1)
+        >>> _.reversedsign
+        Eq(-x, -1)
+        >>> x < 1
+        x < 1
+        >>> _.reversedsign
+        -x > -1
+        """
+        a, b = self.args
+        if not (isinstance(a, BooleanAtom) or isinstance(b, BooleanAtom)):
+            ops = {Eq: Eq, Gt: Lt, Ge: Le, Lt: Gt, Le: Ge, Ne: Ne}
+            return Relational.__new__(ops.get(self.func, self.func), -a, -b)
+        else:
+            return self
+
+    @property
+    def negated(self):
+        """Return the negated relationship.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x, 1)
+        Eq(x, 1)
+        >>> _.negated
+        Ne(x, 1)
+        >>> x < 1
+        x < 1
+        >>> _.negated
+        x >= 1
+
+        Notes
+        =====
+
+        This works more or less identical to ``~``/``Not``. The difference is
+        that ``negated`` returns the relationship even if ``evaluate=False``.
+        Hence, this is useful in code when checking for e.g. negated relations
+        to existing ones as it will not be affected by the `evaluate` flag.
+
+        """
+        ops = {Eq: Ne, Ge: Lt, Gt: Le, Le: Gt, Lt: Ge, Ne: Eq}
+        # If there ever will be new Relational subclasses, the following line
+        # will work until it is properly sorted out
+        # return ops.get(self.func, lambda a, b, evaluate=False: ~(self.func(a,
+        #      b, evaluate=evaluate)))(*self.args, evaluate=False)
+        return Relational.__new__(ops.get(self.func), *self.args)
+
+    @property
+    def weak(self):
+        """return the non-strict version of the inequality or self
+
+        EXAMPLES
+        ========
+
+        >>> from sympy.abc import x
+        >>> (x < 1).weak
+        x <= 1
+        >>> _.weak
+        x <= 1
+        """
+        return self
+
+    @property
+    def strict(self):
+        """return the strict version of the inequality or self
+
+        EXAMPLES
+        ========
+
+        >>> from sympy.abc import x
+        >>> (x <= 1).strict
+        x < 1
+        >>> _.strict
+        x < 1
+        """
+        return self
+
+    def _eval_evalf(self, prec):
+        return self.func(*[s._evalf(prec) for s in self.args])
+
+    @property
+    def canonical(self):
+        """Return a canonical form of the relational by putting a
+        number on the rhs, canonically removing a sign or else
+        ordering the args canonically. No other simplification is
+        attempted.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> x < 2
+        x < 2
+        >>> _.reversed.canonical
+        x < 2
+        >>> (-y < x).canonical
+        x > -y
+        >>> (-y > x).canonical
+        x < -y
+        >>> (-y < -x).canonical
+        x < y
+
+        The canonicalization is recursively applied:
+
+        >>> from sympy import Eq
+        >>> Eq(x < y, y > x).canonical
+        True
+        """
+        args = tuple([i.canonical if isinstance(i, Relational) else i for i in self.args])
+        if args != self.args:
+            r = self.func(*args)
+            if not isinstance(r, Relational):
+                return r
+        else:
+            r = self
+        if r.rhs.is_number:
+            if r.rhs.is_Number and r.lhs.is_Number and r.lhs > r.rhs:
+                r = r.reversed
+        elif r.lhs.is_number:
+            r = r.reversed
+        elif tuple(ordered(args)) != args:
+            r = r.reversed
+
+        LHS_CEMS = getattr(r.lhs, 'could_extract_minus_sign', None)
+        RHS_CEMS = getattr(r.rhs, 'could_extract_minus_sign', None)
+
+        if isinstance(r.lhs, BooleanAtom) or isinstance(r.rhs, BooleanAtom):
+            return r
+
+        # Check if first value has negative sign
+        if LHS_CEMS and LHS_CEMS():
+            return r.reversedsign
+        elif not r.rhs.is_number and RHS_CEMS and RHS_CEMS():
+            # Right hand side has a minus, but not lhs.
+            # How does the expression with reversed signs behave?
+            # This is so that expressions of the type
+            # Eq(x, -y) and Eq(-x, y)
+            # have the same canonical representation
+            expr1, _ = ordered([r.lhs, -r.rhs])
+            if expr1 != r.lhs:
+                return r.reversed.reversedsign
+
+        return r
+
+    def equals(self, other, failing_expression=False):
+        """Return True if the sides of the relationship are mathematically
+        identical and the type of relationship is the same.
+        If failing_expression is True, return the expression whose truth value
+        was unknown."""
+        if isinstance(other, Relational):
+            if other in (self, self.reversed):
+                return True
+            a, b = self, other
+            if a.func in (Eq, Ne) or b.func in (Eq, Ne):
+                if a.func != b.func:
+                    return False
+                left, right = [i.equals(j,
+                                        failing_expression=failing_expression)
+                               for i, j in zip(a.args, b.args)]
+                if left is True:
+                    return right
+                if right is True:
+                    return left
+                lr, rl = [i.equals(j, failing_expression=failing_expression)
+                          for i, j in zip(a.args, b.reversed.args)]
+                if lr is True:
+                    return rl
+                if rl is True:
+                    return lr
+                e = (left, right, lr, rl)
+                if all(i is False for i in e):
+                    return False
+                for i in e:
+                    if i not in (True, False):
+                        return i
+            else:
+                if b.func != a.func:
+                    b = b.reversed
+                if a.func != b.func:
+                    return False
+                left = a.lhs.equals(b.lhs,
+                                    failing_expression=failing_expression)
+                if left is False:
+                    return False
+                right = a.rhs.equals(b.rhs,
+                                     failing_expression=failing_expression)
+                if right is False:
+                    return False
+                if left is True:
+                    return right
+                return left
+
+    def _eval_simplify(self, **kwargs):
+        from .add import Add
+        from .expr import Expr
+        r = self
+        r = r.func(*[i.simplify(**kwargs) for i in r.args])
+        if r.is_Relational:
+            if not isinstance(r.lhs, Expr) or not isinstance(r.rhs, Expr):
+                return r
+            dif = r.lhs - r.rhs
+            # replace dif with a valid Number that will
+            # allow a definitive comparison with 0
+            v = None
+            if dif.is_comparable:
+                v = dif.n(2)
+            elif dif.equals(0):  # XXX this is expensive
+                v = S.Zero
+            if v is not None:
+                r = r.func._eval_relation(v, S.Zero)
+            r = r.canonical
+            # If there is only one symbol in the expression,
+            # try to write it on a simplified form
+            free = list(filter(lambda x: x.is_real is not False, r.free_symbols))
+            if len(free) == 1:
+                try:
+                    from sympy.solvers.solveset import linear_coeffs
+                    x = free.pop()
+                    dif = r.lhs - r.rhs
+                    m, b = linear_coeffs(dif, x)
+                    if m.is_zero is False:
+                        if m.is_negative:
+                            # Dividing with a negative number, so change order of arguments
+                            # canonical will put the symbol back on the lhs later
+                            r = r.func(-b / m, x)
+                        else:
+                            r = r.func(x, -b / m)
+                    else:
+                        r = r.func(b, S.Zero)
+                except ValueError:
+                    # maybe not a linear function, try polynomial
+                    from sympy.polys.polyerrors import PolynomialError
+                    from sympy.polys.polytools import gcd, Poly, poly
+                    try:
+                        p = poly(dif, x)
+                        c = p.all_coeffs()
+                        constant = c[-1]
+                        c[-1] = 0
+                        scale = gcd(c)
+                        c = [ctmp / scale for ctmp in c]
+                        r = r.func(Poly.from_list(c, x).as_expr(), -constant / scale)
+                    except PolynomialError:
+                        pass
+            elif len(free) >= 2:
+                try:
+                    from sympy.solvers.solveset import linear_coeffs
+                    from sympy.polys.polytools import gcd
+                    free = list(ordered(free))
+                    dif = r.lhs - r.rhs
+                    m = linear_coeffs(dif, *free)
+                    constant = m[-1]
+                    del m[-1]
+                    scale = gcd(m)
+                    m = [mtmp / scale for mtmp in m]
+                    nzm = list(filter(lambda f: f[0] != 0, list(zip(m, free))))
+                    if scale.is_zero is False:
+                        if constant != 0:
+                            # lhs: expression, rhs: constant
+                            newexpr = Add(*[i * j for i, j in nzm])
+                            r = r.func(newexpr, -constant / scale)
+                        else:
+                            # keep first term on lhs
+                            lhsterm = nzm[0][0] * nzm[0][1]
+                            del nzm[0]
+                            newexpr = Add(*[i * j for i, j in nzm])
+                            r = r.func(lhsterm, -newexpr)
+
+                    else:
+                        r = r.func(constant, S.Zero)
+                except ValueError:
+                    pass
+        # Did we get a simplified result?
+        r = r.canonical
+        measure = kwargs['measure']
+        if measure(r) < kwargs['ratio'] * measure(self):
+            return r
+        else:
+            return self
+
+    def _eval_trigsimp(self, **opts):
+        from sympy.simplify.trigsimp import trigsimp
+        return self.func(trigsimp(self.lhs, **opts), trigsimp(self.rhs, **opts))
+
+    def expand(self, **kwargs):
+        args = (arg.expand(**kwargs) for arg in self.args)
+        return self.func(*args)
+
+    def __bool__(self):
+        raise TypeError("cannot determine truth value of Relational")
+
+    def _eval_as_set(self):
+        # self is univariate and periodicity(self, x) in (0, None)
+        from sympy.solvers.inequalities import solve_univariate_inequality
+        from sympy.sets.conditionset import ConditionSet
+        syms = self.free_symbols
+        assert len(syms) == 1
+        x = syms.pop()
+        try:
+            xset = solve_univariate_inequality(self, x, relational=False)
+        except NotImplementedError:
+            # solve_univariate_inequality raises NotImplementedError for
+            # unsolvable equations/inequalities.
+            xset = ConditionSet(x, self, S.Reals)
+        return xset
+
+    @property
+    def binary_symbols(self):
+        # override where necessary
+        return set()
+
+
+Rel = Relational
+
+
+class Equality(Relational):
+    """
+    An equal relation between two objects.
+
+    Explanation
+    ===========
+
+    Represents that two objects are equal.  If they can be easily shown
+    to be definitively equal (or unequal), this will reduce to True (or
+    False).  Otherwise, the relation is maintained as an unevaluated
+    Equality object.  Use the ``simplify`` function on this object for
+    more nontrivial evaluation of the equality relation.
+
+    As usual, the keyword argument ``evaluate=False`` can be used to
+    prevent any evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import Eq, simplify, exp, cos
+    >>> from sympy.abc import x, y
+    >>> Eq(y, x + x**2)
+    Eq(y, x**2 + x)
+    >>> Eq(2, 5)
+    False
+    >>> Eq(2, 5, evaluate=False)
+    Eq(2, 5)
+    >>> _.doit()
+    False
+    >>> Eq(exp(x), exp(x).rewrite(cos))
+    Eq(exp(x), sinh(x) + cosh(x))
+    >>> simplify(_)
+    True
+
+    See Also
+    ========
+
+    sympy.logic.boolalg.Equivalent : for representing equality between two
+        boolean expressions
+
+    Notes
+    =====
+
+    Python treats 1 and True (and 0 and False) as being equal; SymPy
+    does not. And integer will always compare as unequal to a Boolean:
+
+    >>> Eq(True, 1), True == 1
+    (False, True)
+
+    This class is not the same as the == operator.  The == operator tests
+    for exact structural equality between two expressions; this class
+    compares expressions mathematically.
+
+    If either object defines an ``_eval_Eq`` method, it can be used in place of
+    the default algorithm.  If ``lhs._eval_Eq(rhs)`` or ``rhs._eval_Eq(lhs)``
+    returns anything other than None, that return value will be substituted for
+    the Equality.  If None is returned by ``_eval_Eq``, an Equality object will
+    be created as usual.
+
+    Since this object is already an expression, it does not respond to
+    the method ``as_expr`` if one tries to create `x - y` from ``Eq(x, y)``.
+    This can be done with the ``rewrite(Add)`` method.
+
+    .. deprecated:: 1.5
+
+       ``Eq(expr)`` with a single argument is a shorthand for ``Eq(expr, 0)``,
+       but this behavior is deprecated and will be removed in a future version
+       of SymPy.
+
+    """
+    rel_op = '=='
+
+    __slots__ = ()
+
+    is_Equality = True
+
+    def __new__(cls, lhs, rhs, **options):
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        lhs = _sympify(lhs)
+        rhs = _sympify(rhs)
+        if evaluate:
+            val = is_eq(lhs, rhs)
+            if val is None:
+                return cls(lhs, rhs, evaluate=False)
+            else:
+                return _sympify(val)
+
+        return Relational.__new__(cls, lhs, rhs)
+
+    @classmethod
+    def _eval_relation(cls, lhs, rhs):
+        return _sympify(lhs == rhs)
+
+    def _eval_rewrite_as_Add(self, *args, **kwargs):
+        """
+        return Eq(L, R) as L - R. To control the evaluation of
+        the result set pass `evaluate=True` to give L - R;
+        if `evaluate=None` then terms in L and R will not cancel
+        but they will be listed in canonical order; otherwise
+        non-canonical args will be returned. If one side is 0, the
+        non-zero side will be returned.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq, Add
+        >>> from sympy.abc import b, x
+        >>> eq = Eq(x + b, x - b)
+        >>> eq.rewrite(Add)
+        2*b
+        >>> eq.rewrite(Add, evaluate=None).args
+        (b, b, x, -x)
+        >>> eq.rewrite(Add, evaluate=False).args
+        (b, x, b, -x)
+        """
+        from .add import _unevaluated_Add, Add
+        L, R = args
+        if L == 0:
+            return R
+        if R == 0:
+            return L
+        evaluate = kwargs.get('evaluate', True)
+        if evaluate:
+            # allow cancellation of args
+            return L - R
+        args = Add.make_args(L) + Add.make_args(-R)
+        if evaluate is None:
+            # no cancellation, but canonical
+            return _unevaluated_Add(*args)
+        # no cancellation, not canonical
+        return Add._from_args(args)
+
+    @property
+    def binary_symbols(self):
+        if S.true in self.args or S.false in self.args:
+            if self.lhs.is_Symbol:
+                return {self.lhs}
+            elif self.rhs.is_Symbol:
+                return {self.rhs}
+        return set()
+
+    def _eval_simplify(self, **kwargs):
+        # standard simplify
+        e = super()._eval_simplify(**kwargs)
+        if not isinstance(e, Equality):
+            return e
+        from .expr import Expr
+        if not isinstance(e.lhs, Expr) or not isinstance(e.rhs, Expr):
+            return e
+        free = self.free_symbols
+        if len(free) == 1:
+            try:
+                from .add import Add
+                from sympy.solvers.solveset import linear_coeffs
+                x = free.pop()
+                m, b = linear_coeffs(
+                    e.rewrite(Add, evaluate=False), x)
+                if m.is_zero is False:
+                    enew = e.func(x, -b / m)
+                else:
+                    enew = e.func(m * x, -b)
+                measure = kwargs['measure']
+                if measure(enew) <= kwargs['ratio'] * measure(e):
+                    e = enew
+            except ValueError:
+                pass
+        return e.canonical
+
+    def integrate(self, *args, **kwargs):
+        """See the integrate function in sympy.integrals"""
+        from sympy.integrals.integrals import integrate
+        return integrate(self, *args, **kwargs)
+
+    def as_poly(self, *gens, **kwargs):
+        '''Returns lhs-rhs as a Poly
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x**2, 1).as_poly(x)
+        Poly(x**2 - 1, x, domain='ZZ')
+        '''
+        return (self.lhs - self.rhs).as_poly(*gens, **kwargs)
+
+
+Eq = Equality
+
+
+class Unequality(Relational):
+    """An unequal relation between two objects.
+
+    Explanation
+    ===========
+
+    Represents that two objects are not equal.  If they can be shown to be
+    definitively equal, this will reduce to False; if definitively unequal,
+    this will reduce to True.  Otherwise, the relation is maintained as an
+    Unequality object.
+
+    Examples
+    ========
+
+    >>> from sympy import Ne
+    >>> from sympy.abc import x, y
+    >>> Ne(y, x+x**2)
+    Ne(y, x**2 + x)
+
+    See Also
+    ========
+    Equality
+
+    Notes
+    =====
+    This class is not the same as the != operator.  The != operator tests
+    for exact structural equality between two expressions; this class
+    compares expressions mathematically.
+
+    This class is effectively the inverse of Equality.  As such, it uses the
+    same algorithms, including any available `_eval_Eq` methods.
+
+    """
+    rel_op = '!='
+
+    __slots__ = ()
+
+    def __new__(cls, lhs, rhs, **options):
+        lhs = _sympify(lhs)
+        rhs = _sympify(rhs)
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        if evaluate:
+            val = is_neq(lhs, rhs)
+            if val is None:
+                return cls(lhs, rhs, evaluate=False)
+            else:
+                return _sympify(val)
+
+        return Relational.__new__(cls, lhs, rhs, **options)
+
+    @classmethod
+    def _eval_relation(cls, lhs, rhs):
+        return _sympify(lhs != rhs)
+
+    @property
+    def binary_symbols(self):
+        if S.true in self.args or S.false in self.args:
+            if self.lhs.is_Symbol:
+                return {self.lhs}
+            elif self.rhs.is_Symbol:
+                return {self.rhs}
+        return set()
+
+    def _eval_simplify(self, **kwargs):
+        # simplify as an equality
+        eq = Equality(*self.args)._eval_simplify(**kwargs)
+        if isinstance(eq, Equality):
+            # send back Ne with the new args
+            return self.func(*eq.args)
+        return eq.negated  # result of Ne is the negated Eq
+
+
+Ne = Unequality
+
+
+class _Inequality(Relational):
+    """Internal base class for all *Than types.
+
+    Each subclass must implement _eval_relation to provide the method for
+    comparing two real numbers.
+
+    """
+    __slots__ = ()
+
+    def __new__(cls, lhs, rhs, **options):
+
+        try:
+            lhs = _sympify(lhs)
+            rhs = _sympify(rhs)
+        except SympifyError:
+            return NotImplemented
+
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        if evaluate:
+            for me in (lhs, rhs):
+                if me.is_extended_real is False:
+                    raise TypeError("Invalid comparison of non-real %s" % me)
+                if me is S.NaN:
+                    raise TypeError("Invalid NaN comparison")
+            # First we invoke the appropriate inequality method of `lhs`
+            # (e.g., `lhs.__lt__`).  That method will try to reduce to
+            # boolean or raise an exception.  It may keep calling
+            # superclasses until it reaches `Expr` (e.g., `Expr.__lt__`).
+            # In some cases, `Expr` will just invoke us again (if neither it
+            # nor a subclass was able to reduce to boolean or raise an
+            # exception).  In that case, it must call us with
+            # `evaluate=False` to prevent infinite recursion.
+            return cls._eval_relation(lhs, rhs, **options)
+
+        # make a "non-evaluated" Expr for the inequality
+        return Relational.__new__(cls, lhs, rhs, **options)
+
+    @classmethod
+    def _eval_relation(cls, lhs, rhs, **options):
+        val = cls._eval_fuzzy_relation(lhs, rhs)
+        if val is None:
+            return cls(lhs, rhs, evaluate=False)
+        else:
+            return _sympify(val)
+
+
+class _Greater(_Inequality):
+    """Not intended for general use
+
+    _Greater is only used so that GreaterThan and StrictGreaterThan may
+    subclass it for the .gts and .lts properties.
+
+    """
+    __slots__ = ()
+
+    @property
+    def gts(self):
+        return self._args[0]
+
+    @property
+    def lts(self):
+        return self._args[1]
+
+
+class _Less(_Inequality):
+    """Not intended for general use.
+
+    _Less is only used so that LessThan and StrictLessThan may subclass it for
+    the .gts and .lts properties.
+
+    """
+    __slots__ = ()
+
+    @property
+    def gts(self):
+        return self._args[1]
+
+    @property
+    def lts(self):
+        return self._args[0]
+
+
+class GreaterThan(_Greater):
+    r"""Class representations of inequalities.
+
+    Explanation
+    ===========
+
+    The ``*Than`` classes represent inequal relationships, where the left-hand
+    side is generally bigger or smaller than the right-hand side.  For example,
+    the GreaterThan class represents an inequal relationship where the
+    left-hand side is at least as big as the right side, if not bigger.  In
+    mathematical notation:
+
+    lhs $\ge$ rhs
+
+    In total, there are four ``*Than`` classes, to represent the four
+    inequalities:
+
+    +-----------------+--------+
+    |Class Name       | Symbol |
+    +=================+========+
+    |GreaterThan      | ``>=`` |
+    +-----------------+--------+
+    |LessThan         | ``<=`` |
+    +-----------------+--------+
+    |StrictGreaterThan| ``>``  |
+    +-----------------+--------+
+    |StrictLessThan   | ``<``  |
+    +-----------------+--------+
+
+    All classes take two arguments, lhs and rhs.
+
+    +----------------------------+-----------------+
+    |Signature Example           | Math Equivalent |
+    +============================+=================+
+    |GreaterThan(lhs, rhs)       |   lhs $\ge$ rhs |
+    +----------------------------+-----------------+
+    |LessThan(lhs, rhs)          |   lhs $\le$ rhs |
+    +----------------------------+-----------------+
+    |StrictGreaterThan(lhs, rhs) |   lhs $>$ rhs   |
+    +----------------------------+-----------------+
+    |StrictLessThan(lhs, rhs)    |   lhs $<$ rhs   |
+    +----------------------------+-----------------+
+
+    In addition to the normal .lhs and .rhs of Relations, ``*Than`` inequality
+    objects also have the .lts and .gts properties, which represent the "less
+    than side" and "greater than side" of the operator.  Use of .lts and .gts
+    in an algorithm rather than .lhs and .rhs as an assumption of inequality
+    direction will make more explicit the intent of a certain section of code,
+    and will make it similarly more robust to client code changes:
+
+    >>> from sympy import GreaterThan, StrictGreaterThan
+    >>> from sympy import LessThan, StrictLessThan
+    >>> from sympy import And, Ge, Gt, Le, Lt, Rel, S
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.core.relational import Relational
+
+    >>> e = GreaterThan(x, 1)
+    >>> e
+    x >= 1
+    >>> '%s >= %s is the same as %s <= %s' % (e.gts, e.lts, e.lts, e.gts)
+    'x >= 1 is the same as 1 <= x'
+
+    Examples
+    ========
+
+    One generally does not instantiate these classes directly, but uses various
+    convenience methods:
+
+    >>> for f in [Ge, Gt, Le, Lt]:  # convenience wrappers
+    ...     print(f(x, 2))
+    x >= 2
+    x > 2
+    x <= 2
+    x < 2
+
+    Another option is to use the Python inequality operators (``>=``, ``>``,
+    ``<=``, ``<``) directly.  Their main advantage over the ``Ge``, ``Gt``,
+    ``Le``, and ``Lt`` counterparts, is that one can write a more
+    "mathematical looking" statement rather than littering the math with
+    oddball function calls.  However there are certain (minor) caveats of
+    which to be aware (search for 'gotcha', below).
+
+    >>> x >= 2
+    x >= 2
+    >>> _ == Ge(x, 2)
+    True
+
+    However, it is also perfectly valid to instantiate a ``*Than`` class less
+    succinctly and less conveniently:
+
+    >>> Rel(x, 1, ">")
+    x > 1
+    >>> Relational(x, 1, ">")
+    x > 1
+
+    >>> StrictGreaterThan(x, 1)
+    x > 1
+    >>> GreaterThan(x, 1)
+    x >= 1
+    >>> LessThan(x, 1)
+    x <= 1
+    >>> StrictLessThan(x, 1)
+    x < 1
+
+    Notes
+    =====
+
+    There are a couple of "gotchas" to be aware of when using Python's
+    operators.
+
+    The first is that what your write is not always what you get:
+
+        >>> 1 < x
+        x > 1
+
+        Due to the order that Python parses a statement, it may
+        not immediately find two objects comparable.  When ``1 < x``
+        is evaluated, Python recognizes that the number 1 is a native
+        number and that x is *not*.  Because a native Python number does
+        not know how to compare itself with a SymPy object
+        Python will try the reflective operation, ``x > 1`` and that is the
+        form that gets evaluated, hence returned.
+
+        If the order of the statement is important (for visual output to
+        the console, perhaps), one can work around this annoyance in a
+        couple ways:
+
+        (1) "sympify" the literal before comparison
+
+        >>> S(1) < x
+        1 < x
+
+        (2) use one of the wrappers or less succinct methods described
+        above
+
+        >>> Lt(1, x)
+        1 < x
+        >>> Relational(1, x, "<")
+        1 < x
+
+    The second gotcha involves writing equality tests between relationals
+    when one or both sides of the test involve a literal relational:
+
+        >>> e = x < 1; e
+        x < 1
+        >>> e == e  # neither side is a literal
+        True
+        >>> e == x < 1  # expecting True, too
+        False
+        >>> e != x < 1  # expecting False
+        x < 1
+        >>> x < 1 != x < 1  # expecting False or the same thing as before
+        Traceback (most recent call last):
+        ...
+        TypeError: cannot determine truth value of Relational
+
+        The solution for this case is to wrap literal relationals in
+        parentheses:
+
+        >>> e == (x < 1)
+        True
+        >>> e != (x < 1)
+        False
+        >>> (x < 1) != (x < 1)
+        False
+
+    The third gotcha involves chained inequalities not involving
+    ``==`` or ``!=``. Occasionally, one may be tempted to write:
+
+        >>> e = x < y < z
+        Traceback (most recent call last):
+        ...
+        TypeError: symbolic boolean expression has no truth value.
+
+        Due to an implementation detail or decision of Python [1]_,
+        there is no way for SymPy to create a chained inequality with
+        that syntax so one must use And:
+
+        >>> e = And(x < y, y < z)
+        >>> type( e )
+        And
+        >>> e
+        (x < y) & (y < z)
+
+        Although this can also be done with the '&' operator, it cannot
+        be done with the 'and' operarator:
+
+        >>> (x < y) & (y < z)
+        (x < y) & (y < z)
+        >>> (x < y) and (y < z)
+        Traceback (most recent call last):
+        ...
+        TypeError: cannot determine truth value of Relational
+
+    .. [1] This implementation detail is that Python provides no reliable
+       method to determine that a chained inequality is being built.
+       Chained comparison operators are evaluated pairwise, using "and"
+       logic (see
+       https://docs.python.org/3/reference/expressions.html#not-in). This
+       is done in an efficient way, so that each object being compared
+       is only evaluated once and the comparison can short-circuit. For
+       example, ``1 > 2 > 3`` is evaluated by Python as ``(1 > 2) and (2
+       > 3)``. The ``and`` operator coerces each side into a bool,
+       returning the object itself when it short-circuits. The bool of
+       the --Than operators will raise TypeError on purpose, because
+       SymPy cannot determine the mathematical ordering of symbolic
+       expressions. Thus, if we were to compute ``x > y > z``, with
+       ``x``, ``y``, and ``z`` being Symbols, Python converts the
+       statement (roughly) into these steps:
+
+        (1) x > y > z
+        (2) (x > y) and (y > z)
+        (3) (GreaterThanObject) and (y > z)
+        (4) (GreaterThanObject.__bool__()) and (y > z)
+        (5) TypeError
+
+       Because of the ``and`` added at step 2, the statement gets turned into a
+       weak ternary statement, and the first object's ``__bool__`` method will
+       raise TypeError.  Thus, creating a chained inequality is not possible.
+
+           In Python, there is no way to override the ``and`` operator, or to
+           control how it short circuits, so it is impossible to make something
+           like ``x > y > z`` work.  There was a PEP to change this,
+           :pep:`335`, but it was officially closed in March, 2012.
+
+    """
+    __slots__ = ()
+
+    rel_op = '>='
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_ge(lhs, rhs)
+
+    @property
+    def strict(self):
+        return Gt(*self.args)
+
+Ge = GreaterThan
+
+
+class LessThan(_Less):
+    __doc__ = GreaterThan.__doc__
+    __slots__ = ()
+
+    rel_op = '<='
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_le(lhs, rhs)
+
+    @property
+    def strict(self):
+        return Lt(*self.args)
+
+Le = LessThan
+
+
+class StrictGreaterThan(_Greater):
+    __doc__ = GreaterThan.__doc__
+    __slots__ = ()
+
+    rel_op = '>'
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_gt(lhs, rhs)
+
+    @property
+    def weak(self):
+        return Ge(*self.args)
+
+
+Gt = StrictGreaterThan
+
+
+class StrictLessThan(_Less):
+    __doc__ = GreaterThan.__doc__
+    __slots__ = ()
+
+    rel_op = '<'
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_lt(lhs, rhs)
+
+    @property
+    def weak(self):
+        return Le(*self.args)
+
+Lt = StrictLessThan
+
+# A class-specific (not object-specific) data item used for a minor speedup.
+# It is defined here, rather than directly in the class, because the classes
+# that it references have not been defined until now (e.g. StrictLessThan).
+Relational.ValidRelationOperator = {
+    None: Equality,
+    '==': Equality,
+    'eq': Equality,
+    '!=': Unequality,
+    '<>': Unequality,
+    'ne': Unequality,
+    '>=': GreaterThan,
+    'ge': GreaterThan,
+    '<=': LessThan,
+    'le': LessThan,
+    '>': StrictGreaterThan,
+    'gt': StrictGreaterThan,
+    '<': StrictLessThan,
+    'lt': StrictLessThan,
+}
+
+
+def _n2(a, b):
+    """Return (a - b).evalf(2) if a and b are comparable, else None.
+    This should only be used when a and b are already sympified.
+    """
+    # /!\ it is very important (see issue 8245) not to
+    # use a re-evaluated number in the calculation of dif
+    if a.is_comparable and b.is_comparable:
+        dif = (a - b).evalf(2)
+        if dif.is_comparable:
+            return dif
+
+
+@dispatch(Expr, Expr)
+def _eval_is_ge(lhs, rhs):
+    return None
+
+
+@dispatch(Basic, Basic)
+def _eval_is_eq(lhs, rhs):
+    return None
+
+
+@dispatch(Tuple, Expr) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    return False
+
+
+@dispatch(Tuple, AppliedUndef) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    return None
+
+
+@dispatch(Tuple, Symbol) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    return None
+
+
+@dispatch(Tuple, Tuple) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    if len(lhs) != len(rhs):
+        return False
+
+    return fuzzy_and(fuzzy_bool(is_eq(s, o)) for s, o in zip(lhs, rhs))
+
+
+def is_lt(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs is strictly less than rhs.
+
+    See the docstring for :func:`~.is_ge` for more.
+    """
+    return fuzzy_not(is_ge(lhs, rhs, assumptions))
+
+
+def is_gt(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs is strictly greater than rhs.
+
+    See the docstring for :func:`~.is_ge` for more.
+    """
+    return fuzzy_not(is_le(lhs, rhs, assumptions))
+
+
+def is_le(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs is less than or equal to rhs.
+
+    See the docstring for :func:`~.is_ge` for more.
+    """
+    return is_ge(rhs, lhs, assumptions)
+
+
+def is_ge(lhs, rhs, assumptions=None):
+    """
+    Fuzzy bool for *lhs* is greater than or equal to *rhs*.
+
+    Parameters
+    ==========
+
+    lhs : Expr
+        The left-hand side of the expression, must be sympified,
+        and an instance of expression. Throws an exception if
+        lhs is not an instance of expression.
+
+    rhs : Expr
+        The right-hand side of the expression, must be sympified
+        and an instance of expression. Throws an exception if
+        lhs is not an instance of expression.
+
+    assumptions: Boolean, optional
+        Assumptions taken to evaluate the inequality.
+
+    Returns
+    =======
+
+    ``True`` if *lhs* is greater than or equal to *rhs*, ``False`` if *lhs*
+    is less than *rhs*, and ``None`` if the comparison between *lhs* and
+    *rhs* is indeterminate.
+
+    Explanation
+    ===========
+
+    This function is intended to give a relatively fast determination and
+    deliberately does not attempt slow calculations that might help in
+    obtaining a determination of True or False in more difficult cases.
+
+    The four comparison functions ``is_le``, ``is_lt``, ``is_ge``, and ``is_gt`` are
+    each implemented in terms of ``is_ge`` in the following way:
+
+    is_ge(x, y) := is_ge(x, y)
+    is_le(x, y) := is_ge(y, x)
+    is_lt(x, y) := fuzzy_not(is_ge(x, y))
+    is_gt(x, y) := fuzzy_not(is_ge(y, x))
+
+    Therefore, supporting new type with this function will ensure behavior for
+    other three functions as well.
+
+    To maintain these equivalences in fuzzy logic it is important that in cases where
+    either x or y is non-real all comparisons will give None.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Q
+    >>> from sympy.core.relational import is_ge, is_le, is_gt, is_lt
+    >>> from sympy.abc import x
+    >>> is_ge(S(2), S(0))
+    True
+    >>> is_ge(S(0), S(2))
+    False
+    >>> is_le(S(0), S(2))
+    True
+    >>> is_gt(S(0), S(2))
+    False
+    >>> is_lt(S(2), S(0))
+    False
+
+    Assumptions can be passed to evaluate the quality which is otherwise
+    indeterminate.
+
+    >>> print(is_ge(x, S(0)))
+    None
+    >>> is_ge(x, S(0), assumptions=Q.positive(x))
+    True
+
+    New types can be supported by dispatching to ``_eval_is_ge``.
+
+    >>> from sympy import Expr, sympify
+    >>> from sympy.multipledispatch import dispatch
+    >>> class MyExpr(Expr):
+    ...     def __new__(cls, arg):
+    ...         return super().__new__(cls, sympify(arg))
+    ...     @property
+    ...     def value(self):
+    ...         return self.args[0]
+    >>> @dispatch(MyExpr, MyExpr)
+    ... def _eval_is_ge(a, b):
+    ...     return is_ge(a.value, b.value)
+    >>> a = MyExpr(1)
+    >>> b = MyExpr(2)
+    >>> is_ge(b, a)
+    True
+    >>> is_le(a, b)
+    True
+    """
+    from sympy.assumptions.wrapper import AssumptionsWrapper, is_extended_nonnegative
+
+    if not (isinstance(lhs, Expr) and isinstance(rhs, Expr)):
+        raise TypeError("Can only compare inequalities with Expr")
+
+    retval = _eval_is_ge(lhs, rhs)
+
+    if retval is not None:
+        return retval
+    else:
+        n2 = _n2(lhs, rhs)
+        if n2 is not None:
+            # use float comparison for infinity.
+            # otherwise get stuck in infinite recursion
+            if n2 in (S.Infinity, S.NegativeInfinity):
+                n2 = float(n2)
+            return n2 >= 0
+
+        _lhs = AssumptionsWrapper(lhs, assumptions)
+        _rhs = AssumptionsWrapper(rhs, assumptions)
+        if _lhs.is_extended_real and _rhs.is_extended_real:
+            if (_lhs.is_infinite and _lhs.is_extended_positive) or (_rhs.is_infinite and _rhs.is_extended_negative):
+                return True
+            diff = lhs - rhs
+            if diff is not S.NaN:
+                rv = is_extended_nonnegative(diff, assumptions)
+                if rv is not None:
+                    return rv
+
+
+def is_neq(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs does not equal rhs.
+
+    See the docstring for :func:`~.is_eq` for more.
+    """
+    return fuzzy_not(is_eq(lhs, rhs, assumptions))
+
+
+def is_eq(lhs, rhs, assumptions=None):
+    """
+    Fuzzy bool representing mathematical equality between *lhs* and *rhs*.
+
+    Parameters
+    ==========
+
+    lhs : Expr
+        The left-hand side of the expression, must be sympified.
+
+    rhs : Expr
+        The right-hand side of the expression, must be sympified.
+
+    assumptions: Boolean, optional
+        Assumptions taken to evaluate the equality.
+
+    Returns
+    =======
+
+    ``True`` if *lhs* is equal to *rhs*, ``False`` is *lhs* is not equal to *rhs*,
+    and ``None`` if the comparison between *lhs* and *rhs* is indeterminate.
+
+    Explanation
+    ===========
+
+    This function is intended to give a relatively fast determination and
+    deliberately does not attempt slow calculations that might help in
+    obtaining a determination of True or False in more difficult cases.
+
+    :func:`~.is_neq` calls this function to return its value, so supporting
+    new type with this function will ensure correct behavior for ``is_neq``
+    as well.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, S
+    >>> from sympy.core.relational import is_eq, is_neq
+    >>> from sympy.abc import x
+    >>> is_eq(S(0), S(0))
+    True
+    >>> is_neq(S(0), S(0))
+    False
+    >>> is_eq(S(0), S(2))
+    False
+    >>> is_neq(S(0), S(2))
+    True
+
+    Assumptions can be passed to evaluate the equality which is otherwise
+    indeterminate.
+
+    >>> print(is_eq(x, S(0)))
+    None
+    >>> is_eq(x, S(0), assumptions=Q.zero(x))
+    True
+
+    New types can be supported by dispatching to ``_eval_is_eq``.
+
+    >>> from sympy import Basic, sympify
+    >>> from sympy.multipledispatch import dispatch
+    >>> class MyBasic(Basic):
+    ...     def __new__(cls, arg):
+    ...         return Basic.__new__(cls, sympify(arg))
+    ...     @property
+    ...     def value(self):
+    ...         return self.args[0]
+    ...
+    >>> @dispatch(MyBasic, MyBasic)
+    ... def _eval_is_eq(a, b):
+    ...     return is_eq(a.value, b.value)
+    ...
+    >>> a = MyBasic(1)
+    >>> b = MyBasic(1)
+    >>> is_eq(a, b)
+    True
+    >>> is_neq(a, b)
+    False
+
+    """
+    # here, _eval_Eq is only called for backwards compatibility
+    # new code should use is_eq with multiple dispatch as
+    # outlined in the docstring
+    for side1, side2 in (lhs, rhs), (rhs, lhs):
+        eval_func = getattr(side1, '_eval_Eq', None)
+        if eval_func is not None:
+            retval = eval_func(side2)
+            if retval is not None:
+                return retval
+
+    retval = _eval_is_eq(lhs, rhs)
+    if retval is not None:
+        return retval
+
+    if dispatch(type(lhs), type(rhs)) != dispatch(type(rhs), type(lhs)):
+        retval = _eval_is_eq(rhs, lhs)
+        if retval is not None:
+            return retval
+
+    # retval is still None, so go through the equality logic
+    # If expressions have the same structure, they must be equal.
+    if lhs == rhs:
+        return True  # e.g. True == True
+    elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
+        return False  # True != False
+    elif not (lhs.is_Symbol or rhs.is_Symbol) and (
+        isinstance(lhs, Boolean) !=
+        isinstance(rhs, Boolean)):
+        return False  # only Booleans can equal Booleans
+
+    from sympy.assumptions.wrapper import (AssumptionsWrapper,
+        is_infinite, is_extended_real)
+    from .add import Add
+
+    _lhs = AssumptionsWrapper(lhs, assumptions)
+    _rhs = AssumptionsWrapper(rhs, assumptions)
+
+    if _lhs.is_infinite or _rhs.is_infinite:
+        if fuzzy_xor([_lhs.is_infinite, _rhs.is_infinite]):
+            return False
+        if fuzzy_xor([_lhs.is_extended_real, _rhs.is_extended_real]):
+            return False
+        if fuzzy_and([_lhs.is_extended_real, _rhs.is_extended_real]):
+            return fuzzy_xor([_lhs.is_extended_positive, fuzzy_not(_rhs.is_extended_positive)])
+
+        # Try to split real/imaginary parts and equate them
+        I = S.ImaginaryUnit
+
+        def split_real_imag(expr):
+            real_imag = lambda t: (
+                'real' if is_extended_real(t, assumptions) else
+                'imag' if is_extended_real(I*t, assumptions) else None)
+            return sift(Add.make_args(expr), real_imag)
+
+        lhs_ri = split_real_imag(lhs)
+        if not lhs_ri[None]:
+            rhs_ri = split_real_imag(rhs)
+            if not rhs_ri[None]:
+                eq_real = is_eq(Add(*lhs_ri['real']), Add(*rhs_ri['real']), assumptions)
+                eq_imag = is_eq(I * Add(*lhs_ri['imag']), I * Add(*rhs_ri['imag']), assumptions)
+                return fuzzy_and(map(fuzzy_bool, [eq_real, eq_imag]))
+
+        from sympy.functions.elementary.complexes import arg
+        # Compare e.g. zoo with 1+I*oo by comparing args
+        arglhs = arg(lhs)
+        argrhs = arg(rhs)
+        # Guard against Eq(nan, nan) -> False
+        if not (arglhs == S.NaN and argrhs == S.NaN):
+            return fuzzy_bool(is_eq(arglhs, argrhs, assumptions))
+
+    if all(isinstance(i, Expr) for i in (lhs, rhs)):
+        # see if the difference evaluates
+        dif = lhs - rhs
+        _dif = AssumptionsWrapper(dif, assumptions)
+        z = _dif.is_zero
+        if z is not None:
+            if z is False and _dif.is_commutative:  # issue 10728
+                return False
+            if z:
+                return True
+
+        n2 = _n2(lhs, rhs)
+        if n2 is not None:
+            return _sympify(n2 == 0)
+
+        # see if the ratio evaluates
+        n, d = dif.as_numer_denom()
+        rv = None
+        _n = AssumptionsWrapper(n, assumptions)
+        _d = AssumptionsWrapper(d, assumptions)
+        if _n.is_zero:
+            rv = _d.is_nonzero
+        elif _n.is_finite:
+            if _d.is_infinite:
+                rv = True
+            elif _n.is_zero is False:
+                rv = _d.is_infinite
+                if rv is None:
+                    # if the condition that makes the denominator
+                    # infinite does not make the original expression
+                    # True then False can be returned
+                    from sympy.simplify.simplify import clear_coefficients
+                    l, r = clear_coefficients(d, S.Infinity)
+                    args = [_.subs(l, r) for _ in (lhs, rhs)]
+                    if args != [lhs, rhs]:
+                        rv = fuzzy_bool(is_eq(*args, assumptions))
+                        if rv is True:
+                            rv = None
+        elif any(is_infinite(a, assumptions) for a in Add.make_args(n)):
+            # (inf or nan)/x != 0
+            rv = False
+        if rv is not None:
+            return rv

llmeval-env/lib/python3.10/site-packages/sympy/core/rules.py

@@ -0,0 +1,66 @@
+"""
+Replacement rules.
+"""
+
+class Transform:
+    """
+    Immutable mapping that can be used as a generic transformation rule.
+
+    Parameters
+    ==========
+
+    transform : callable
+        Computes the value corresponding to any key.
+
+    filter : callable, optional
+        If supplied, specifies which objects are in the mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.core.rules import Transform
+    >>> from sympy.abc import x
+
+    This Transform will return, as a value, one more than the key:
+
+    >>> add1 = Transform(lambda x: x + 1)
+    >>> add1[1]
+    2
+    >>> add1[x]
+    x + 1
+
+    By default, all values are considered to be in the dictionary. If a filter
+    is supplied, only the objects for which it returns True are considered as
+    being in the dictionary:
+
+    >>> add1_odd = Transform(lambda x: x + 1, lambda x: x%2 == 1)
+    >>> 2 in add1_odd
+    False
+    >>> add1_odd.get(2, 0)
+    0
+    >>> 3 in add1_odd
+    True
+    >>> add1_odd[3]
+    4
+    >>> add1_odd.get(3, 0)
+    4
+    """
+
+    def __init__(self, transform, filter=lambda x: True):
+        self._transform = transform
+        self._filter = filter
+
+    def __contains__(self, item):
+        return self._filter(item)
+
+    def __getitem__(self, key):
+        if self._filter(key):
+            return self._transform(key)
+        else:
+            raise KeyError(key)
+
+    def get(self, item, default=None):
+        if item in self:
+            return self[item]
+        else:
+            return default

llmeval-env/lib/python3.10/site-packages/sympy/core/singleton.py

@@ -0,0 +1,174 @@
+"""Singleton mechanism"""
+
+
+from .core import Registry
+from .sympify import sympify
+
+
+class SingletonRegistry(Registry):
+    """
+    The registry for the singleton classes (accessible as ``S``).
+
+    Explanation
+    ===========
+
+    This class serves as two separate things.
+
+    The first thing it is is the ``SingletonRegistry``. Several classes in
+    SymPy appear so often that they are singletonized, that is, using some
+    metaprogramming they are made so that they can only be instantiated once
+    (see the :class:`sympy.core.singleton.Singleton` class for details). For
+    instance, every time you create ``Integer(0)``, this will return the same
+    instance, :class:`sympy.core.numbers.Zero`. All singleton instances are
+    attributes of the ``S`` object, so ``Integer(0)`` can also be accessed as
+    ``S.Zero``.
+
+    Singletonization offers two advantages: it saves memory, and it allows
+    fast comparison. It saves memory because no matter how many times the
+    singletonized objects appear in expressions in memory, they all point to
+    the same single instance in memory. The fast comparison comes from the
+    fact that you can use ``is`` to compare exact instances in Python
+    (usually, you need to use ``==`` to compare things). ``is`` compares
+    objects by memory address, and is very fast.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Integer
+    >>> a = Integer(0)
+    >>> a is S.Zero
+    True
+
+    For the most part, the fact that certain objects are singletonized is an
+    implementation detail that users should not need to worry about. In SymPy
+    library code, ``is`` comparison is often used for performance purposes
+    The primary advantage of ``S`` for end users is the convenient access to
+    certain instances that are otherwise difficult to type, like ``S.Half``
+    (instead of ``Rational(1, 2)``).
+
+    When using ``is`` comparison, make sure the argument is sympified. For
+    instance,
+
+    >>> x = 0
+    >>> x is S.Zero
+    False
+
+    This problem is not an issue when using ``==``, which is recommended for
+    most use-cases:
+
+    >>> 0 == S.Zero
+    True
+
+    The second thing ``S`` is is a shortcut for
+    :func:`sympy.core.sympify.sympify`. :func:`sympy.core.sympify.sympify` is
+    the function that converts Python objects such as ``int(1)`` into SymPy
+    objects such as ``Integer(1)``. It also converts the string form of an
+    expression into a SymPy expression, like ``sympify("x**2")`` ->
+    ``Symbol("x")**2``. ``S(1)`` is the same thing as ``sympify(1)``
+    (basically, ``S.__call__`` has been defined to call ``sympify``).
+
+    This is for convenience, since ``S`` is a single letter. It's mostly
+    useful for defining rational numbers. Consider an expression like ``x +
+    1/2``. If you enter this directly in Python, it will evaluate the ``1/2``
+    and give ``0.5``, because both arguments are ints (see also
+    :ref:`tutorial-gotchas-final-notes`). However, in SymPy, you usually want
+    the quotient of two integers to give an exact rational number. The way
+    Python's evaluation works, at least one side of an operator needs to be a
+    SymPy object for the SymPy evaluation to take over. You could write this
+    as ``x + Rational(1, 2)``, but this is a lot more typing. A shorter
+    version is ``x + S(1)/2``. Since ``S(1)`` returns ``Integer(1)``, the
+    division will return a ``Rational`` type, since it will call
+    ``Integer.__truediv__``, which knows how to return a ``Rational``.
+
+    """
+    __slots__ = ()
+
+    # Also allow things like S(5)
+    __call__ = staticmethod(sympify)
+
+    def __init__(self):
+        self._classes_to_install = {}
+        # Dict of classes that have been registered, but that have not have been
+        # installed as an attribute of this SingletonRegistry.
+        # Installation automatically happens at the first attempt to access the
+        # attribute.
+        # The purpose of this is to allow registration during class
+        # initialization during import, but not trigger object creation until
+        # actual use (which should not happen until after all imports are
+        # finished).
+
+    def register(self, cls):
+        # Make sure a duplicate class overwrites the old one
+        if hasattr(self, cls.__name__):
+            delattr(self, cls.__name__)
+        self._classes_to_install[cls.__name__] = cls
+
+    def __getattr__(self, name):
+        """Python calls __getattr__ if no attribute of that name was installed
+        yet.
+
+        Explanation
+        ===========
+
+        This __getattr__ checks whether a class with the requested name was
+        already registered but not installed; if no, raises an AttributeError.
+        Otherwise, retrieves the class, calculates its singleton value, installs
+        it as an attribute of the given name, and unregisters the class."""
+        if name not in self._classes_to_install:
+            raise AttributeError(
+                "Attribute '%s' was not installed on SymPy registry %s" % (
+                name, self))
+        class_to_install = self._classes_to_install[name]
+        value_to_install = class_to_install()
+        self.__setattr__(name, value_to_install)
+        del self._classes_to_install[name]
+        return value_to_install
+
+    def __repr__(self):
+        return "S"
+
+S = SingletonRegistry()
+
+
+class Singleton(type):
+    """
+    Metaclass for singleton classes.
+
+    Explanation
+    ===========
+
+    A singleton class has only one instance which is returned every time the
+    class is instantiated. Additionally, this instance can be accessed through
+    the global registry object ``S`` as ``S.<class_name>``.
+
+    Examples
+    ========
+
+        >>> from sympy import S, Basic
+        >>> from sympy.core.singleton import Singleton
+        >>> class MySingleton(Basic, metaclass=Singleton):
+        ...     pass
+        >>> Basic() is Basic()
+        False
+        >>> MySingleton() is MySingleton()
+        True
+        >>> S.MySingleton is MySingleton()
+        True
+
+    Notes
+    =====
+
+    Instance creation is delayed until the first time the value is accessed.
+    (SymPy versions before 1.0 would create the instance during class
+    creation time, which would be prone to import cycles.)
+    """
+    def __init__(cls, *args, **kwargs):
+        cls._instance = obj = Basic.__new__(cls)
+        cls.__new__ = lambda cls: obj
+        cls.__getnewargs__ = lambda obj: ()
+        cls.__getstate__ = lambda obj: None
+        S.register(cls)
+
+
+# Delayed to avoid cyclic import
+from .basic import Basic

llmeval-env/lib/python3.10/site-packages/sympy/core/sorting.py

@@ -0,0 +1,309 @@
+from collections import defaultdict
+
+from .sympify import sympify, SympifyError
+from sympy.utilities.iterables import iterable, uniq
+
+
+__all__ = ['default_sort_key', 'ordered']
+
+
+def default_sort_key(item, order=None):
+    """Return a key that can be used for sorting.
+
+    The key has the structure:
+
+    (class_key, (len(args), args), exponent.sort_key(), coefficient)
+
+    This key is supplied by the sort_key routine of Basic objects when
+    ``item`` is a Basic object or an object (other than a string) that
+    sympifies to a Basic object. Otherwise, this function produces the
+    key.
+
+    The ``order`` argument is passed along to the sort_key routine and is
+    used to determine how the terms *within* an expression are ordered.
+    (See examples below) ``order`` options are: 'lex', 'grlex', 'grevlex',
+    and reversed values of the same (e.g. 'rev-lex'). The default order
+    value is None (which translates to 'lex').
+
+    Examples
+    ========
+
+    >>> from sympy import S, I, default_sort_key, sin, cos, sqrt
+    >>> from sympy.core.function import UndefinedFunction
+    >>> from sympy.abc import x
+
+    The following are equivalent ways of getting the key for an object:
+
+    >>> x.sort_key() == default_sort_key(x)
+    True
+
+    Here are some examples of the key that is produced:
+
+    >>> default_sort_key(UndefinedFunction('f'))
+    ((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'),
+        (0, ()), (), 1), 1)
+    >>> default_sort_key('1')
+    ((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
+    >>> default_sort_key(S.One)
+    ((1, 0, 'Number'), (0, ()), (), 1)
+    >>> default_sort_key(2)
+    ((1, 0, 'Number'), (0, ()), (), 2)
+
+    While sort_key is a method only defined for SymPy objects,
+    default_sort_key will accept anything as an argument so it is
+    more robust as a sorting key. For the following, using key=
+    lambda i: i.sort_key() would fail because 2 does not have a sort_key
+    method; that's why default_sort_key is used. Note, that it also
+    handles sympification of non-string items likes ints:
+
+    >>> a = [2, I, -I]
+    >>> sorted(a, key=default_sort_key)
+    [2, -I, I]
+
+    The returned key can be used anywhere that a key can be specified for
+    a function, e.g. sort, min, max, etc...:
+
+    >>> a.sort(key=default_sort_key); a[0]
+    2
+    >>> min(a, key=default_sort_key)
+    2
+
+    Notes
+    =====
+
+    The key returned is useful for getting items into a canonical order
+    that will be the same across platforms. It is not directly useful for
+    sorting lists of expressions:
+
+    >>> a, b = x, 1/x
+
+    Since ``a`` has only 1 term, its value of sort_key is unaffected by
+    ``order``:
+
+    >>> a.sort_key() == a.sort_key('rev-lex')
+    True
+
+    If ``a`` and ``b`` are combined then the key will differ because there
+    are terms that can be ordered:
+
+    >>> eq = a + b
+    >>> eq.sort_key() == eq.sort_key('rev-lex')
+    False
+    >>> eq.as_ordered_terms()
+    [x, 1/x]
+    >>> eq.as_ordered_terms('rev-lex')
+    [1/x, x]
+
+    But since the keys for each of these terms are independent of ``order``'s
+    value, they do not sort differently when they appear separately in a list:
+
+    >>> sorted(eq.args, key=default_sort_key)
+    [1/x, x]
+    >>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex'))
+    [1/x, x]
+
+    The order of terms obtained when using these keys is the order that would
+    be obtained if those terms were *factors* in a product.
+
+    Although it is useful for quickly putting expressions in canonical order,
+    it does not sort expressions based on their complexity defined by the
+    number of operations, power of variables and others:
+
+    >>> sorted([sin(x)*cos(x), sin(x)], key=default_sort_key)
+    [sin(x)*cos(x), sin(x)]
+    >>> sorted([x, x**2, sqrt(x), x**3], key=default_sort_key)
+    [sqrt(x), x, x**2, x**3]
+
+    See Also
+    ========
+
+    ordered, sympy.core.expr.Expr.as_ordered_factors, sympy.core.expr.Expr.as_ordered_terms
+
+    """
+    from .basic import Basic
+    from .singleton import S
+
+    if isinstance(item, Basic):
+        return item.sort_key(order=order)
+
+    if iterable(item, exclude=str):
+        if isinstance(item, dict):
+            args = item.items()
+            unordered = True
+        elif isinstance(item, set):
+            args = item
+            unordered = True
+        else:
+            # e.g. tuple, list
+            args = list(item)
+            unordered = False
+
+        args = [default_sort_key(arg, order=order) for arg in args]
+
+        if unordered:
+            # e.g. dict, set
+            args = sorted(args)
+
+        cls_index, args = 10, (len(args), tuple(args))
+    else:
+        if not isinstance(item, str):
+            try:
+                item = sympify(item, strict=True)
+            except SympifyError:
+                # e.g. lambda x: x
+                pass
+            else:
+                if isinstance(item, Basic):
+                    # e.g int -> Integer
+                    return default_sort_key(item)
+                # e.g. UndefinedFunction
+
+        # e.g. str
+        cls_index, args = 0, (1, (str(item),))
+
+    return (cls_index, 0, item.__class__.__name__
+            ), args, S.One.sort_key(), S.One
+
+
+def _node_count(e):
+    # this not only counts nodes, it affirms that the
+    # args are Basic (i.e. have an args property). If
+    # some object has a non-Basic arg, it needs to be
+    # fixed since it is intended that all Basic args
+    # are of Basic type (though this is not easy to enforce).
+    if e.is_Float:
+        return 0.5
+    return 1 + sum(map(_node_count, e.args))
+
+
+def _nodes(e):
+    """
+    A helper for ordered() which returns the node count of ``e`` which
+    for Basic objects is the number of Basic nodes in the expression tree
+    but for other objects is 1 (unless the object is an iterable or dict
+    for which the sum of nodes is returned).
+    """
+    from .basic import Basic
+    from .function import Derivative
+
+    if isinstance(e, Basic):
+        if isinstance(e, Derivative):
+            return _nodes(e.expr) + sum(i[1] if i[1].is_Number else
+                _nodes(i[1]) for i in e.variable_count)
+        return _node_count(e)
+    elif iterable(e):
+        return 1 + sum(_nodes(ei) for ei in e)
+    elif isinstance(e, dict):
+        return 1 + sum(_nodes(k) + _nodes(v) for k, v in e.items())
+    else:
+        return 1
+
+
+def ordered(seq, keys=None, default=True, warn=False):
+    """Return an iterator of the seq where keys are used to break ties in
+    a conservative fashion: if, after applying a key, there are no ties
+    then no other keys will be computed.
+
+    Two default keys will be applied if 1) keys are not provided or 2) the
+    given keys do not resolve all ties (but only if ``default`` is True). The
+    two keys are ``_nodes`` (which places smaller expressions before large) and
+    ``default_sort_key`` which (if the ``sort_key`` for an object is defined
+    properly) should resolve any ties.
+
+    If ``warn`` is True then an error will be raised if there were no
+    keys remaining to break ties. This can be used if it was expected that
+    there should be no ties between items that are not identical.
+
+    Examples
+    ========
+
+    >>> from sympy import ordered, count_ops
+    >>> from sympy.abc import x, y
+
+    The count_ops is not sufficient to break ties in this list and the first
+    two items appear in their original order (i.e. the sorting is stable):
+
+    >>> list(ordered([y + 2, x + 2, x**2 + y + 3],
+    ...    count_ops, default=False, warn=False))
+    ...
+    [y + 2, x + 2, x**2 + y + 3]
+
+    The default_sort_key allows the tie to be broken:
+
+    >>> list(ordered([y + 2, x + 2, x**2 + y + 3]))
+    ...
+    [x + 2, y + 2, x**2 + y + 3]
+
+    Here, sequences are sorted by length, then sum:
+
+    >>> seq, keys = [[[1, 2, 1], [0, 3, 1], [1, 1, 3], [2], [1]], [
+    ...    lambda x: len(x),
+    ...    lambda x: sum(x)]]
+    ...
+    >>> list(ordered(seq, keys, default=False, warn=False))
+    [[1], [2], [1, 2, 1], [0, 3, 1], [1, 1, 3]]
+
+    If ``warn`` is True, an error will be raised if there were not
+    enough keys to break ties:
+
+    >>> list(ordered(seq, keys, default=False, warn=True))
+    Traceback (most recent call last):
+    ...
+    ValueError: not enough keys to break ties
+
+
+    Notes
+    =====
+
+    The decorated sort is one of the fastest ways to sort a sequence for
+    which special item comparison is desired: the sequence is decorated,
+    sorted on the basis of the decoration (e.g. making all letters lower
+    case) and then undecorated. If one wants to break ties for items that
+    have the same decorated value, a second key can be used. But if the
+    second key is expensive to compute then it is inefficient to decorate
+    all items with both keys: only those items having identical first key
+    values need to be decorated. This function applies keys successively
+    only when needed to break ties. By yielding an iterator, use of the
+    tie-breaker is delayed as long as possible.
+
+    This function is best used in cases when use of the first key is
+    expected to be a good hashing function; if there are no unique hashes
+    from application of a key, then that key should not have been used. The
+    exception, however, is that even if there are many collisions, if the
+    first group is small and one does not need to process all items in the
+    list then time will not be wasted sorting what one was not interested
+    in. For example, if one were looking for the minimum in a list and
+    there were several criteria used to define the sort order, then this
+    function would be good at returning that quickly if the first group
+    of candidates is small relative to the number of items being processed.
+
+    """
+
+    d = defaultdict(list)
+    if keys:
+        if isinstance(keys, (list, tuple)):
+            keys = list(keys)
+            f = keys.pop(0)
+        else:
+            f = keys
+            keys = []
+        for a in seq:
+            d[f(a)].append(a)
+    else:
+        if not default:
+            raise ValueError('if default=False then keys must be provided')
+        d[None].extend(seq)
+
+    for k, value in sorted(d.items()):
+        if len(value) > 1:
+            if keys:
+                value = ordered(value, keys, default, warn)
+            elif default:
+                value = ordered(value, (_nodes, default_sort_key,),
+                               default=False, warn=warn)
+            elif warn:
+                u = list(uniq(value))
+                if len(u) > 1:
+                    raise ValueError(
+                        'not enough keys to break ties: %s' % u)
+        yield from value

llmeval-env/lib/python3.10/site-packages/sympy/core/symbol.py

@@ -0,0 +1,945 @@
+from __future__ import annotations
+
+from .assumptions import StdFactKB, _assume_defined
+from .basic import Basic, Atom
+from .cache import cacheit
+from .containers import Tuple
+from .expr import Expr, AtomicExpr
+from .function import AppliedUndef, FunctionClass
+from .kind import NumberKind, UndefinedKind
+from .logic import fuzzy_bool
+from .singleton import S
+from .sorting import ordered
+from .sympify import sympify
+from sympy.logic.boolalg import Boolean
+from sympy.utilities.iterables import sift, is_sequence
+from sympy.utilities.misc import filldedent
+
+import string
+import re as _re
+import random
+from itertools import product
+from typing import Any
+
+
+class Str(Atom):
+    """
+    Represents string in SymPy.
+
+    Explanation
+    ===========
+
+    Previously, ``Symbol`` was used where string is needed in ``args`` of SymPy
+    objects, e.g. denoting the name of the instance. However, since ``Symbol``
+    represents mathematical scalar, this class should be used instead.
+
+    """
+    __slots__ = ('name',)
+
+    def __new__(cls, name, **kwargs):
+        if not isinstance(name, str):
+            raise TypeError("name should be a string, not %s" % repr(type(name)))
+        obj = Expr.__new__(cls, **kwargs)
+        obj.name = name
+        return obj
+
+    def __getnewargs__(self):
+        return (self.name,)
+
+    def _hashable_content(self):
+        return (self.name,)
+
+
+def _filter_assumptions(kwargs):
+    """Split the given dict into assumptions and non-assumptions.
+    Keys are taken as assumptions if they correspond to an
+    entry in ``_assume_defined``.
+    """
+    assumptions, nonassumptions = map(dict, sift(kwargs.items(),
+        lambda i: i[0] in _assume_defined,
+        binary=True))
+    Symbol._sanitize(assumptions)
+    return assumptions, nonassumptions
+
+def _symbol(s, matching_symbol=None, **assumptions):
+    """Return s if s is a Symbol, else if s is a string, return either
+    the matching_symbol if the names are the same or else a new symbol
+    with the same assumptions as the matching symbol (or the
+    assumptions as provided).
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.core.symbol import _symbol
+    >>> _symbol('y')
+    y
+    >>> _.is_real is None
+    True
+    >>> _symbol('y', real=True).is_real
+    True
+
+    >>> x = Symbol('x')
+    >>> _symbol(x, real=True)
+    x
+    >>> _.is_real is None  # ignore attribute if s is a Symbol
+    True
+
+    Below, the variable sym has the name 'foo':
+
+    >>> sym = Symbol('foo', real=True)
+
+    Since 'x' is not the same as sym's name, a new symbol is created:
+
+    >>> _symbol('x', sym).name
+    'x'
+
+    It will acquire any assumptions give:
+
+    >>> _symbol('x', sym, real=False).is_real
+    False
+
+    Since 'foo' is the same as sym's name, sym is returned
+
+    >>> _symbol('foo', sym)
+    foo
+
+    Any assumptions given are ignored:
+
+    >>> _symbol('foo', sym, real=False).is_real
+    True
+
+    NB: the symbol here may not be the same as a symbol with the same
+    name defined elsewhere as a result of different assumptions.
+
+    See Also
+    ========
+
+    sympy.core.symbol.Symbol
+
+    """
+    if isinstance(s, str):
+        if matching_symbol and matching_symbol.name == s:
+            return matching_symbol
+        return Symbol(s, **assumptions)
+    elif isinstance(s, Symbol):
+        return s
+    else:
+        raise ValueError('symbol must be string for symbol name or Symbol')
+
+def uniquely_named_symbol(xname, exprs=(), compare=str, modify=None, **assumptions):
+    """
+    Return a symbol whose name is derivated from *xname* but is unique
+    from any other symbols in *exprs*.
+
+    *xname* and symbol names in *exprs* are passed to *compare* to be
+    converted to comparable forms. If ``compare(xname)`` is not unique,
+    it is recursively passed to *modify* until unique name is acquired.
+
+    Parameters
+    ==========
+
+    xname : str or Symbol
+        Base name for the new symbol.
+
+    exprs : Expr or iterable of Expr
+        Expressions whose symbols are compared to *xname*.
+
+    compare : function
+        Unary function which transforms *xname* and symbol names from
+        *exprs* to comparable form.
+
+    modify : function
+        Unary function which modifies the string. Default is appending
+        the number, or increasing the number if exists.
+
+    Examples
+    ========
+
+    By default, a number is appended to *xname* to generate unique name.
+    If the number already exists, it is recursively increased.
+
+    >>> from sympy.core.symbol import uniquely_named_symbol, Symbol
+    >>> uniquely_named_symbol('x', Symbol('x'))
+    x0
+    >>> uniquely_named_symbol('x', (Symbol('x'), Symbol('x0')))
+    x1
+    >>> uniquely_named_symbol('x0', (Symbol('x1'), Symbol('x0')))
+    x2
+
+    Name generation can be controlled by passing *modify* parameter.
+
+    >>> from sympy.abc import x
+    >>> uniquely_named_symbol('x', x, modify=lambda s: 2*s)
+    xx
+
+    """
+    def numbered_string_incr(s, start=0):
+        if not s:
+            return str(start)
+        i = len(s) - 1
+        while i != -1:
+            if not s[i].isdigit():
+                break
+            i -= 1
+        n = str(int(s[i + 1:] or start - 1) + 1)
+        return s[:i + 1] + n
+
+    default = None
+    if is_sequence(xname):
+        xname, default = xname
+    x = compare(xname)
+    if not exprs:
+        return _symbol(x, default, **assumptions)
+    if not is_sequence(exprs):
+        exprs = [exprs]
+    names = set().union(
+        [i.name for e in exprs for i in e.atoms(Symbol)] +
+        [i.func.name for e in exprs for i in e.atoms(AppliedUndef)])
+    if modify is None:
+        modify = numbered_string_incr
+    while any(x == compare(s) for s in names):
+        x = modify(x)
+    return _symbol(x, default, **assumptions)
+_uniquely_named_symbol = uniquely_named_symbol
+
+class Symbol(AtomicExpr, Boolean):
+    """
+    Assumptions:
+       commutative = True
+
+    You can override the default assumptions in the constructor.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> A,B = symbols('A,B', commutative = False)
+    >>> bool(A*B != B*A)
+    True
+    >>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative
+    True
+
+    """
+
+    is_comparable = False
+
+    __slots__ = ('name', '_assumptions_orig', '_assumptions0')
+
+    name: str
+
+    is_Symbol = True
+    is_symbol = True
+
+    @property
+    def kind(self):
+        if self.is_commutative:
+            return NumberKind
+        return UndefinedKind
+
+    @property
+    def _diff_wrt(self):
+        """Allow derivatives wrt Symbols.
+
+        Examples
+        ========
+
+            >>> from sympy import Symbol
+            >>> x = Symbol('x')
+            >>> x._diff_wrt
+            True
+        """
+        return True
+
+    @staticmethod
+    def _sanitize(assumptions, obj=None):
+        """Remove None, convert values to bool, check commutativity *in place*.
+        """
+
+        # be strict about commutativity: cannot be None
+        is_commutative = fuzzy_bool(assumptions.get('commutative', True))
+        if is_commutative is None:
+            whose = '%s ' % obj.__name__ if obj else ''
+            raise ValueError(
+                '%scommutativity must be True or False.' % whose)
+
+        # sanitize other assumptions so 1 -> True and 0 -> False
+        for key in list(assumptions.keys()):
+            v = assumptions[key]
+            if v is None:
+                assumptions.pop(key)
+                continue
+            assumptions[key] = bool(v)
+
+    def _merge(self, assumptions):
+        base = self.assumptions0
+        for k in set(assumptions) & set(base):
+            if assumptions[k] != base[k]:
+                raise ValueError(filldedent('''
+                    non-matching assumptions for %s: existing value
+                    is %s and new value is %s''' % (
+                    k, base[k], assumptions[k])))
+        base.update(assumptions)
+        return base
+
+    def __new__(cls, name, **assumptions):
+        """Symbols are identified by name and assumptions::
+
+        >>> from sympy import Symbol
+        >>> Symbol("x") == Symbol("x")
+        True
+        >>> Symbol("x", real=True) == Symbol("x", real=False)
+        False
+
+        """
+        cls._sanitize(assumptions, cls)
+        return Symbol.__xnew_cached_(cls, name, **assumptions)
+
+    @staticmethod
+    def __xnew__(cls, name, **assumptions):  # never cached (e.g. dummy)
+        if not isinstance(name, str):
+            raise TypeError("name should be a string, not %s" % repr(type(name)))
+
+        # This is retained purely so that srepr can include commutative=True if
+        # that was explicitly specified but not if it was not. Ideally srepr
+        # should not distinguish these cases because the symbols otherwise
+        # compare equal and are considered equivalent.
+        #
+        # See https://github.com/sympy/sympy/issues/8873
+        #
+        assumptions_orig = assumptions.copy()
+
+        # The only assumption that is assumed by default is comutative=True:
+        assumptions.setdefault('commutative', True)
+
+        assumptions_kb = StdFactKB(assumptions)
+        assumptions0 = dict(assumptions_kb)
+
+        obj = Expr.__new__(cls)
+        obj.name = name
+
+        obj._assumptions = assumptions_kb
+        obj._assumptions_orig = assumptions_orig
+        obj._assumptions0 = assumptions0
+
+        # The three assumptions dicts are all a little different:
+        #
+        #   >>> from sympy import Symbol
+        #   >>> x = Symbol('x', finite=True)
+        #   >>> x.is_positive  # query an assumption
+        #   >>> x._assumptions
+        #   {'finite': True, 'infinite': False, 'commutative': True, 'positive': None}
+        #   >>> x._assumptions0
+        #   {'finite': True, 'infinite': False, 'commutative': True}
+        #   >>> x._assumptions_orig
+        #   {'finite': True}
+        #
+        # Two symbols with the same name are equal if their _assumptions0 are
+        # the same. Arguably it should be _assumptions_orig that is being
+        # compared because that is more transparent to the user (it is
+        # what was passed to the constructor modulo changes made by _sanitize).
+
+        return obj
+
+    @staticmethod
+    @cacheit
+    def __xnew_cached_(cls, name, **assumptions):  # symbols are always cached
+        return Symbol.__xnew__(cls, name, **assumptions)
+
+    def __getnewargs_ex__(self):
+        return ((self.name,), self._assumptions_orig)
+
+    # NOTE: __setstate__ is not needed for pickles created by __getnewargs_ex__
+    # but was used before Symbol was changed to use __getnewargs_ex__ in v1.9.
+    # Pickles created in previous SymPy versions will still need __setstate__
+    # so that they can be unpickled in SymPy > v1.9.
+
+    def __setstate__(self, state):
+        for name, value in state.items():
+            setattr(self, name, value)
+
+    def _hashable_content(self):
+        # Note: user-specified assumptions not hashed, just derived ones
+        return (self.name,) + tuple(sorted(self.assumptions0.items()))
+
+    def _eval_subs(self, old, new):
+        if old.is_Pow:
+            from sympy.core.power import Pow
+            return Pow(self, S.One, evaluate=False)._eval_subs(old, new)
+
+    def _eval_refine(self, assumptions):
+        return self
+
+    @property
+    def assumptions0(self):
+        return self._assumptions0.copy()
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (1, (self.name,)), S.One.sort_key(), S.One
+
+    def as_dummy(self):
+        # only put commutativity in explicitly if it is False
+        return Dummy(self.name) if self.is_commutative is not False \
+            else Dummy(self.name, commutative=self.is_commutative)
+
+    def as_real_imag(self, deep=True, **hints):
+        if hints.get('ignore') == self:
+            return None
+        else:
+            from sympy.functions.elementary.complexes import im, re
+            return (re(self), im(self))
+
+    def is_constant(self, *wrt, **flags):
+        if not wrt:
+            return False
+        return self not in wrt
+
+    @property
+    def free_symbols(self):
+        return {self}
+
+    binary_symbols = free_symbols  # in this case, not always
+
+    def as_set(self):
+        return S.UniversalSet
+
+
+class Dummy(Symbol):
+    """Dummy symbols are each unique, even if they have the same name:
+
+    Examples
+    ========
+
+    >>> from sympy import Dummy
+    >>> Dummy("x") == Dummy("x")
+    False
+
+    If a name is not supplied then a string value of an internal count will be
+    used. This is useful when a temporary variable is needed and the name
+    of the variable used in the expression is not important.
+
+    >>> Dummy() #doctest: +SKIP
+    _Dummy_10
+
+    """
+
+    # In the rare event that a Dummy object needs to be recreated, both the
+    # `name` and `dummy_index` should be passed.  This is used by `srepr` for
+    # example:
+    # >>> d1 = Dummy()
+    # >>> d2 = eval(srepr(d1))
+    # >>> d2 == d1
+    # True
+    #
+    # If a new session is started between `srepr` and `eval`, there is a very
+    # small chance that `d2` will be equal to a previously-created Dummy.
+
+    _count = 0
+    _prng = random.Random()
+    _base_dummy_index = _prng.randint(10**6, 9*10**6)
+
+    __slots__ = ('dummy_index',)
+
+    is_Dummy = True
+
+    def __new__(cls, name=None, dummy_index=None, **assumptions):
+        if dummy_index is not None:
+            assert name is not None, "If you specify a dummy_index, you must also provide a name"
+
+        if name is None:
+            name = "Dummy_" + str(Dummy._count)
+
+        if dummy_index is None:
+            dummy_index = Dummy._base_dummy_index + Dummy._count
+            Dummy._count += 1
+
+        cls._sanitize(assumptions, cls)
+        obj = Symbol.__xnew__(cls, name, **assumptions)
+
+        obj.dummy_index = dummy_index
+
+        return obj
+
+    def __getnewargs_ex__(self):
+        return ((self.name, self.dummy_index), self._assumptions_orig)
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (
+            2, (self.name, self.dummy_index)), S.One.sort_key(), S.One
+
+    def _hashable_content(self):
+        return Symbol._hashable_content(self) + (self.dummy_index,)
+
+
+class Wild(Symbol):
+    """
+    A Wild symbol matches anything, or anything
+    without whatever is explicitly excluded.
+
+    Parameters
+    ==========
+
+    name : str
+        Name of the Wild instance.
+
+    exclude : iterable, optional
+        Instances in ``exclude`` will not be matched.
+
+    properties : iterable of functions, optional
+        Functions, each taking an expressions as input
+        and returns a ``bool``. All functions in ``properties``
+        need to return ``True`` in order for the Wild instance
+        to match the expression.
+
+    Examples
+    ========
+
+    >>> from sympy import Wild, WildFunction, cos, pi
+    >>> from sympy.abc import x, y, z
+    >>> a = Wild('a')
+    >>> x.match(a)
+    {a_: x}
+    >>> pi.match(a)
+    {a_: pi}
+    >>> (3*x**2).match(a*x)
+    {a_: 3*x}
+    >>> cos(x).match(a)
+    {a_: cos(x)}
+    >>> b = Wild('b', exclude=[x])
+    >>> (3*x**2).match(b*x)
+    >>> b.match(a)
+    {a_: b_}
+    >>> A = WildFunction('A')
+    >>> A.match(a)
+    {a_: A_}
+
+    Tips
+    ====
+
+    When using Wild, be sure to use the exclude
+    keyword to make the pattern more precise.
+    Without the exclude pattern, you may get matches
+    that are technically correct, but not what you
+    wanted. For example, using the above without
+    exclude:
+
+    >>> from sympy import symbols
+    >>> a, b = symbols('a b', cls=Wild)
+    >>> (2 + 3*y).match(a*x + b*y)
+    {a_: 2/x, b_: 3}
+
+    This is technically correct, because
+    (2/x)*x + 3*y == 2 + 3*y, but you probably
+    wanted it to not match at all. The issue is that
+    you really did not want a and b to include x and y,
+    and the exclude parameter lets you specify exactly
+    this.  With the exclude parameter, the pattern will
+    not match.
+
+    >>> a = Wild('a', exclude=[x, y])
+    >>> b = Wild('b', exclude=[x, y])
+    >>> (2 + 3*y).match(a*x + b*y)
+
+    Exclude also helps remove ambiguity from matches.
+
+    >>> E = 2*x**3*y*z
+    >>> a, b = symbols('a b', cls=Wild)
+    >>> E.match(a*b)
+    {a_: 2*y*z, b_: x**3}
+    >>> a = Wild('a', exclude=[x, y])
+    >>> E.match(a*b)
+    {a_: z, b_: 2*x**3*y}
+    >>> a = Wild('a', exclude=[x, y, z])
+    >>> E.match(a*b)
+    {a_: 2, b_: x**3*y*z}
+
+    Wild also accepts a ``properties`` parameter:
+
+    >>> a = Wild('a', properties=[lambda k: k.is_Integer])
+    >>> E.match(a*b)
+    {a_: 2, b_: x**3*y*z}
+
+    """
+    is_Wild = True
+
+    __slots__ = ('exclude', 'properties')
+
+    def __new__(cls, name, exclude=(), properties=(), **assumptions):
+        exclude = tuple([sympify(x) for x in exclude])
+        properties = tuple(properties)
+        cls._sanitize(assumptions, cls)
+        return Wild.__xnew__(cls, name, exclude, properties, **assumptions)
+
+    def __getnewargs__(self):
+        return (self.name, self.exclude, self.properties)
+
+    @staticmethod
+    @cacheit
+    def __xnew__(cls, name, exclude, properties, **assumptions):
+        obj = Symbol.__xnew__(cls, name, **assumptions)
+        obj.exclude = exclude
+        obj.properties = properties
+        return obj
+
+    def _hashable_content(self):
+        return super()._hashable_content() + (self.exclude, self.properties)
+
+    # TODO add check against another Wild
+    def matches(self, expr, repl_dict=None, old=False):
+        if any(expr.has(x) for x in self.exclude):
+            return None
+        if not all(f(expr) for f in self.properties):
+            return None
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+        repl_dict[self] = expr
+        return repl_dict
+
+
+_range = _re.compile('([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z])')
+
+
+def symbols(names, *, cls=Symbol, **args) -> Any:
+    r"""
+    Transform strings into instances of :class:`Symbol` class.
+
+    :func:`symbols` function returns a sequence of symbols with names taken
+    from ``names`` argument, which can be a comma or whitespace delimited
+    string, or a sequence of strings::
+
+        >>> from sympy import symbols, Function
+
+        >>> x, y, z = symbols('x,y,z')
+        >>> a, b, c = symbols('a b c')
+
+    The type of output is dependent on the properties of input arguments::
+
+        >>> symbols('x')
+        x
+        >>> symbols('x,')
+        (x,)
+        >>> symbols('x,y')
+        (x, y)
+        >>> symbols(('a', 'b', 'c'))
+        (a, b, c)
+        >>> symbols(['a', 'b', 'c'])
+        [a, b, c]
+        >>> symbols({'a', 'b', 'c'})
+        {a, b, c}
+
+    If an iterable container is needed for a single symbol, set the ``seq``
+    argument to ``True`` or terminate the symbol name with a comma::
+
+        >>> symbols('x', seq=True)
+        (x,)
+
+    To reduce typing, range syntax is supported to create indexed symbols.
+    Ranges are indicated by a colon and the type of range is determined by
+    the character to the right of the colon. If the character is a digit
+    then all contiguous digits to the left are taken as the nonnegative
+    starting value (or 0 if there is no digit left of the colon) and all
+    contiguous digits to the right are taken as 1 greater than the ending
+    value::
+
+        >>> symbols('x:10')
+        (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
+
+        >>> symbols('x5:10')
+        (x5, x6, x7, x8, x9)
+        >>> symbols('x5(:2)')
+        (x50, x51)
+
+        >>> symbols('x5:10,y:5')
+        (x5, x6, x7, x8, x9, y0, y1, y2, y3, y4)
+
+        >>> symbols(('x5:10', 'y:5'))
+        ((x5, x6, x7, x8, x9), (y0, y1, y2, y3, y4))
+
+    If the character to the right of the colon is a letter, then the single
+    letter to the left (or 'a' if there is none) is taken as the start
+    and all characters in the lexicographic range *through* the letter to
+    the right are used as the range::
+
+        >>> symbols('x:z')
+        (x, y, z)
+        >>> symbols('x:c')  # null range
+        ()
+        >>> symbols('x(:c)')
+        (xa, xb, xc)
+
+        >>> symbols(':c')
+        (a, b, c)
+
+        >>> symbols('a:d, x:z')
+        (a, b, c, d, x, y, z)
+
+        >>> symbols(('a:d', 'x:z'))
+        ((a, b, c, d), (x, y, z))
+
+    Multiple ranges are supported; contiguous numerical ranges should be
+    separated by parentheses to disambiguate the ending number of one
+    range from the starting number of the next::
+
+        >>> symbols('x:2(1:3)')
+        (x01, x02, x11, x12)
+        >>> symbols(':3:2')  # parsing is from left to right
+        (00, 01, 10, 11, 20, 21)
+
+    Only one pair of parentheses surrounding ranges are removed, so to
+    include parentheses around ranges, double them. And to include spaces,
+    commas, or colons, escape them with a backslash::
+
+        >>> symbols('x((a:b))')
+        (x(a), x(b))
+        >>> symbols(r'x(:1\,:2)')  # or r'x((:1)\,(:2))'
+        (x(0,0), x(0,1))
+
+    All newly created symbols have assumptions set according to ``args``::
+
+        >>> a = symbols('a', integer=True)
+        >>> a.is_integer
+        True
+
+        >>> x, y, z = symbols('x,y,z', real=True)
+        >>> x.is_real and y.is_real and z.is_real
+        True
+
+    Despite its name, :func:`symbols` can create symbol-like objects like
+    instances of Function or Wild classes. To achieve this, set ``cls``
+    keyword argument to the desired type::
+
+        >>> symbols('f,g,h', cls=Function)
+        (f, g, h)
+
+        >>> type(_[0])
+        <class 'sympy.core.function.UndefinedFunction'>
+
+    """
+    result = []
+
+    if isinstance(names, str):
+        marker = 0
+        splitters = r'\,', r'\:', r'\ '
+        literals: list[tuple[str, str]] = []
+        for splitter in splitters:
+            if splitter in names:
+                while chr(marker) in names:
+                    marker += 1
+                lit_char = chr(marker)
+                marker += 1
+                names = names.replace(splitter, lit_char)
+                literals.append((lit_char, splitter[1:]))
+        def literal(s):
+            if literals:
+                for c, l in literals:
+                    s = s.replace(c, l)
+            return s
+
+        names = names.strip()
+        as_seq = names.endswith(',')
+        if as_seq:
+            names = names[:-1].rstrip()
+        if not names:
+            raise ValueError('no symbols given')
+
+        # split on commas
+        names = [n.strip() for n in names.split(',')]
+        if not all(n for n in names):
+            raise ValueError('missing symbol between commas')
+        # split on spaces
+        for i in range(len(names) - 1, -1, -1):
+            names[i: i + 1] = names[i].split()
+
+        seq = args.pop('seq', as_seq)
+
+        for name in names:
+            if not name:
+                raise ValueError('missing symbol')
+
+            if ':' not in name:
+                symbol = cls(literal(name), **args)
+                result.append(symbol)
+                continue
+
+            split: list[str] = _range.split(name)
+            split_list: list[list[str]] = []
+            # remove 1 layer of bounding parentheses around ranges
+            for i in range(len(split) - 1):
+                if i and ':' in split[i] and split[i] != ':' and \
+                        split[i - 1].endswith('(') and \
+                        split[i + 1].startswith(')'):
+                    split[i - 1] = split[i - 1][:-1]
+                    split[i + 1] = split[i + 1][1:]
+            for s in split:
+                if ':' in s:
+                    if s.endswith(':'):
+                        raise ValueError('missing end range')
+                    a, b = s.split(':')
+                    if b[-1] in string.digits:
+                        a_i = 0 if not a else int(a)
+                        b_i = int(b)
+                        split_list.append([str(c) for c in range(a_i, b_i)])
+                    else:
+                        a = a or 'a'
+                        split_list.append([string.ascii_letters[c] for c in range(
+                            string.ascii_letters.index(a),
+                            string.ascii_letters.index(b) + 1)])  # inclusive
+                    if not split_list[-1]:
+                        break
+                else:
+                    split_list.append([s])
+            else:
+                seq = True
+                if len(split_list) == 1:
+                    names = split_list[0]
+                else:
+                    names = [''.join(s) for s in product(*split_list)]
+                if literals:
+                    result.extend([cls(literal(s), **args) for s in names])
+                else:
+                    result.extend([cls(s, **args) for s in names])
+
+        if not seq and len(result) <= 1:
+            if not result:
+                return ()
+            return result[0]
+
+        return tuple(result)
+    else:
+        for name in names:
+            result.append(symbols(name, cls=cls, **args))
+
+        return type(names)(result)
+
+
+def var(names, **args):
+    """
+    Create symbols and inject them into the global namespace.
+
+    Explanation
+    ===========
+
+    This calls :func:`symbols` with the same arguments and puts the results
+    into the *global* namespace. It's recommended not to use :func:`var` in
+    library code, where :func:`symbols` has to be used::
+
+    Examples
+    ========
+
+    >>> from sympy import var
+
+    >>> var('x')
+    x
+    >>> x # noqa: F821
+    x
+
+    >>> var('a,ab,abc')
+    (a, ab, abc)
+    >>> abc # noqa: F821
+    abc
+
+    >>> var('x,y', real=True)
+    (x, y)
+    >>> x.is_real and y.is_real # noqa: F821
+    True
+
+    See :func:`symbols` documentation for more details on what kinds of
+    arguments can be passed to :func:`var`.
+
+    """
+    def traverse(symbols, frame):
+        """Recursively inject symbols to the global namespace. """
+        for symbol in symbols:
+            if isinstance(symbol, Basic):
+                frame.f_globals[symbol.name] = symbol
+            elif isinstance(symbol, FunctionClass):
+                frame.f_globals[symbol.__name__] = symbol
+            else:
+                traverse(symbol, frame)
+
+    from inspect import currentframe
+    frame = currentframe().f_back
+
+    try:
+        syms = symbols(names, **args)
+
+        if syms is not None:
+            if isinstance(syms, Basic):
+                frame.f_globals[syms.name] = syms
+            elif isinstance(syms, FunctionClass):
+                frame.f_globals[syms.__name__] = syms
+            else:
+                traverse(syms, frame)
+    finally:
+        del frame  # break cyclic dependencies as stated in inspect docs
+
+    return syms
+
+def disambiguate(*iter):
+    """
+    Return a Tuple containing the passed expressions with symbols
+    that appear the same when printed replaced with numerically
+    subscripted symbols, and all Dummy symbols replaced with Symbols.
+
+    Parameters
+    ==========
+
+    iter: list of symbols or expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.core.symbol import disambiguate
+    >>> from sympy import Dummy, Symbol, Tuple
+    >>> from sympy.abc import y
+
+    >>> tup = Symbol('_x'), Dummy('x'), Dummy('x')
+    >>> disambiguate(*tup)
+    (x_2, x, x_1)
+
+    >>> eqs = Tuple(Symbol('x')/y, Dummy('x')/y)
+    >>> disambiguate(*eqs)
+    (x_1/y, x/y)
+
+    >>> ix = Symbol('x', integer=True)
+    >>> vx = Symbol('x')
+    >>> disambiguate(vx + ix)
+    (x + x_1,)
+
+    To make your own mapping of symbols to use, pass only the free symbols
+    of the expressions and create a dictionary:
+
+    >>> free = eqs.free_symbols
+    >>> mapping = dict(zip(free, disambiguate(*free)))
+    >>> eqs.xreplace(mapping)
+    (x_1/y, x/y)
+
+    """
+    new_iter = Tuple(*iter)
+    key = lambda x:tuple(sorted(x.assumptions0.items()))
+    syms = ordered(new_iter.free_symbols, keys=key)
+    mapping = {}
+    for s in syms:
+        mapping.setdefault(str(s).lstrip('_'), []).append(s)
+    reps = {}
+    for k in mapping:
+        # the first or only symbol doesn't get subscripted but make
+        # sure that it's a Symbol, not a Dummy
+        mapk0 = Symbol("%s" % (k), **mapping[k][0].assumptions0)
+        if mapping[k][0] != mapk0:
+            reps[mapping[k][0]] = mapk0
+        # the others get subscripts (and are made into Symbols)
+        skip = 0
+        for i in range(1, len(mapping[k])):
+            while True:
+                name = "%s_%i" % (k, i + skip)
+                if name not in mapping:
+                    break
+                skip += 1
+            ki = mapping[k][i]
+            reps[ki] = Symbol(name, **ki.assumptions0)
+    return new_iter.xreplace(reps)

llmeval-env/lib/python3.10/site-packages/sympy/core/sympify.py

@@ -0,0 +1,634 @@
+"""sympify -- convert objects SymPy internal format"""
+
+from __future__ import annotations
+from typing import Any, Callable
+
+from inspect import getmro
+import string
+from sympy.core.random import choice
+
+from .parameters import global_parameters
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable
+
+
+class SympifyError(ValueError):
+    def __init__(self, expr, base_exc=None):
+        self.expr = expr
+        self.base_exc = base_exc
+
+    def __str__(self):
+        if self.base_exc is None:
+            return "SympifyError: %r" % (self.expr,)
+
+        return ("Sympify of expression '%s' failed, because of exception being "
+            "raised:\n%s: %s" % (self.expr, self.base_exc.__class__.__name__,
+            str(self.base_exc)))
+
+
+converter: dict[type[Any], Callable[[Any], Basic]] = {}
+
+#holds the conversions defined in SymPy itself, i.e. non-user defined conversions
+_sympy_converter: dict[type[Any], Callable[[Any], Basic]] = {}
+
+#alias for clearer use in the library
+_external_converter = converter
+
+class CantSympify:
+    """
+    Mix in this trait to a class to disallow sympification of its instances.
+
+    Examples
+    ========
+
+    >>> from sympy import sympify
+    >>> from sympy.core.sympify import CantSympify
+
+    >>> class Something(dict):
+    ...     pass
+    ...
+    >>> sympify(Something())
+    {}
+
+    >>> class Something(dict, CantSympify):
+    ...     pass
+    ...
+    >>> sympify(Something())
+    Traceback (most recent call last):
+    ...
+    SympifyError: SympifyError: {}
+
+    """
+
+    __slots__ = ()
+
+
+def _is_numpy_instance(a):
+    """
+    Checks if an object is an instance of a type from the numpy module.
+    """
+    # This check avoids unnecessarily importing NumPy.  We check the whole
+    # __mro__ in case any base type is a numpy type.
+    return any(type_.__module__ == 'numpy'
+               for type_ in type(a).__mro__)
+
+
+def _convert_numpy_types(a, **sympify_args):
+    """
+    Converts a numpy datatype input to an appropriate SymPy type.
+    """
+    import numpy as np
+    if not isinstance(a, np.floating):
+        if np.iscomplex(a):
+            return _sympy_converter[complex](a.item())
+        else:
+            return sympify(a.item(), **sympify_args)
+    else:
+        try:
+            from .numbers import Float
+            prec = np.finfo(a).nmant + 1
+            # E.g. double precision means prec=53 but nmant=52
+            # Leading bit of mantissa is always 1, so is not stored
+            a = str(list(np.reshape(np.asarray(a),
+                                    (1, np.size(a)))[0]))[1:-1]
+            return Float(a, precision=prec)
+        except NotImplementedError:
+            raise SympifyError('Translation for numpy float : %s '
+                               'is not implemented' % a)
+
+
+def sympify(a, locals=None, convert_xor=True, strict=False, rational=False,
+        evaluate=None):
+    """
+    Converts an arbitrary expression to a type that can be used inside SymPy.
+
+    Explanation
+    ===========
+
+    It will convert Python ints into instances of :class:`~.Integer`, floats
+    into instances of :class:`~.Float`, etc. It is also able to coerce
+    symbolic expressions which inherit from :class:`~.Basic`. This can be
+    useful in cooperation with SAGE.
+
+    .. warning::
+        Note that this function uses ``eval``, and thus shouldn't be used on
+        unsanitized input.
+
+    If the argument is already a type that SymPy understands, it will do
+    nothing but return that value. This can be used at the beginning of a
+    function to ensure you are working with the correct type.
+
+    Examples
+    ========
+
+    >>> from sympy import sympify
+
+    >>> sympify(2).is_integer
+    True
+    >>> sympify(2).is_real
+    True
+
+    >>> sympify(2.0).is_real
+    True
+    >>> sympify("2.0").is_real
+    True
+    >>> sympify("2e-45").is_real
+    True
+
+    If the expression could not be converted, a SympifyError is raised.
+
+    >>> sympify("x***2")
+    Traceback (most recent call last):
+    ...
+    SympifyError: SympifyError: "could not parse 'x***2'"
+
+    Locals
+    ------
+
+    The sympification happens with access to everything that is loaded
+    by ``from sympy import *``; anything used in a string that is not
+    defined by that import will be converted to a symbol. In the following,
+    the ``bitcount`` function is treated as a symbol and the ``O`` is
+    interpreted as the :class:`~.Order` object (used with series) and it raises
+    an error when used improperly:
+
+    >>> s = 'bitcount(42)'
+    >>> sympify(s)
+    bitcount(42)
+    >>> sympify("O(x)")
+    O(x)
+    >>> sympify("O + 1")
+    Traceback (most recent call last):
+    ...
+    TypeError: unbound method...
+
+    In order to have ``bitcount`` be recognized it can be imported into a
+    namespace dictionary and passed as locals:
+
+    >>> ns = {}
+    >>> exec('from sympy.core.evalf import bitcount', ns)
+    >>> sympify(s, locals=ns)
+    6
+
+    In order to have the ``O`` interpreted as a Symbol, identify it as such
+    in the namespace dictionary. This can be done in a variety of ways; all
+    three of the following are possibilities:
+
+    >>> from sympy import Symbol
+    >>> ns["O"] = Symbol("O")  # method 1
+    >>> exec('from sympy.abc import O', ns)  # method 2
+    >>> ns.update(dict(O=Symbol("O")))  # method 3
+    >>> sympify("O + 1", locals=ns)
+    O + 1
+
+    If you want *all* single-letter and Greek-letter variables to be symbols
+    then you can use the clashing-symbols dictionaries that have been defined
+    there as private variables: ``_clash1`` (single-letter variables),
+    ``_clash2`` (the multi-letter Greek names) or ``_clash`` (both single and
+    multi-letter names that are defined in ``abc``).
+
+    >>> from sympy.abc import _clash1
+    >>> set(_clash1)  # if this fails, see issue #23903
+    {'E', 'I', 'N', 'O', 'Q', 'S'}
+    >>> sympify('I & Q', _clash1)
+    I & Q
+
+    Strict
+    ------
+
+    If the option ``strict`` is set to ``True``, only the types for which an
+    explicit conversion has been defined are converted. In the other
+    cases, a SympifyError is raised.
+
+    >>> print(sympify(None))
+    None
+    >>> sympify(None, strict=True)
+    Traceback (most recent call last):
+    ...
+    SympifyError: SympifyError: None
+
+    .. deprecated:: 1.6
+
+       ``sympify(obj)`` automatically falls back to ``str(obj)`` when all
+       other conversion methods fail, but this is deprecated. ``strict=True``
+       will disable this deprecated behavior. See
+       :ref:`deprecated-sympify-string-fallback`.
+
+    Evaluation
+    ----------
+
+    If the option ``evaluate`` is set to ``False``, then arithmetic and
+    operators will be converted into their SymPy equivalents and the
+    ``evaluate=False`` option will be added. Nested ``Add`` or ``Mul`` will
+    be denested first. This is done via an AST transformation that replaces
+    operators with their SymPy equivalents, so if an operand redefines any
+    of those operations, the redefined operators will not be used. If
+    argument a is not a string, the mathematical expression is evaluated
+    before being passed to sympify, so adding ``evaluate=False`` will still
+    return the evaluated result of expression.
+
+    >>> sympify('2**2 / 3 + 5')
+    19/3
+    >>> sympify('2**2 / 3 + 5', evaluate=False)
+    2**2/3 + 5
+    >>> sympify('4/2+7', evaluate=True)
+    9
+    >>> sympify('4/2+7', evaluate=False)
+    4/2 + 7
+    >>> sympify(4/2+7, evaluate=False)
+    9.00000000000000
+
+    Extending
+    ---------
+
+    To extend ``sympify`` to convert custom objects (not derived from ``Basic``),
+    just define a ``_sympy_`` method to your class. You can do that even to
+    classes that you do not own by subclassing or adding the method at runtime.
+
+    >>> from sympy import Matrix
+    >>> class MyList1(object):
+    ...     def __iter__(self):
+    ...         yield 1
+    ...         yield 2
+    ...         return
+    ...     def __getitem__(self, i): return list(self)[i]
+    ...     def _sympy_(self): return Matrix(self)
+    >>> sympify(MyList1())
+    Matrix([
+    [1],
+    [2]])
+
+    If you do not have control over the class definition you could also use the
+    ``converter`` global dictionary. The key is the class and the value is a
+    function that takes a single argument and returns the desired SymPy
+    object, e.g. ``converter[MyList] = lambda x: Matrix(x)``.
+
+    >>> class MyList2(object):   # XXX Do not do this if you control the class!
+    ...     def __iter__(self):  #     Use _sympy_!
+    ...         yield 1
+    ...         yield 2
+    ...         return
+    ...     def __getitem__(self, i): return list(self)[i]
+    >>> from sympy.core.sympify import converter
+    >>> converter[MyList2] = lambda x: Matrix(x)
+    >>> sympify(MyList2())
+    Matrix([
+    [1],
+    [2]])
+
+    Notes
+    =====
+
+    The keywords ``rational`` and ``convert_xor`` are only used
+    when the input is a string.
+
+    convert_xor
+    -----------
+
+    >>> sympify('x^y',convert_xor=True)
+    x**y
+    >>> sympify('x^y',convert_xor=False)
+    x ^ y
+
+    rational
+    --------
+
+    >>> sympify('0.1',rational=False)
+    0.1
+    >>> sympify('0.1',rational=True)
+    1/10
+
+    Sometimes autosimplification during sympification results in expressions
+    that are very different in structure than what was entered. Until such
+    autosimplification is no longer done, the ``kernS`` function might be of
+    some use. In the example below you can see how an expression reduces to
+    $-1$ by autosimplification, but does not do so when ``kernS`` is used.
+
+    >>> from sympy.core.sympify import kernS
+    >>> from sympy.abc import x
+    >>> -2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) - 1
+    -1
+    >>> s = '-2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) - 1'
+    >>> sympify(s)
+    -1
+    >>> kernS(s)
+    -2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) - 1
+
+    Parameters
+    ==========
+
+    a :
+        - any object defined in SymPy
+        - standard numeric Python types: ``int``, ``long``, ``float``, ``Decimal``
+        - strings (like ``"0.09"``, ``"2e-19"`` or ``'sin(x)'``)
+        - booleans, including ``None`` (will leave ``None`` unchanged)
+        - dicts, lists, sets or tuples containing any of the above
+
+    convert_xor : bool, optional
+        If true, treats ``^`` as exponentiation.
+        If False, treats ``^`` as XOR itself.
+        Used only when input is a string.
+
+    locals : any object defined in SymPy, optional
+        In order to have strings be recognized it can be imported
+        into a namespace dictionary and passed as locals.
+
+    strict : bool, optional
+        If the option strict is set to ``True``, only the types for which
+        an explicit conversion has been defined are converted. In the
+        other cases, a SympifyError is raised.
+
+    rational : bool, optional
+        If ``True``, converts floats into :class:`~.Rational`.
+        If ``False``, it lets floats remain as it is.
+        Used only when input is a string.
+
+    evaluate : bool, optional
+        If False, then arithmetic and operators will be converted into
+        their SymPy equivalents. If True the expression will be evaluated
+        and the result will be returned.
+
+    """
+    # XXX: If a is a Basic subclass rather than instance (e.g. sin rather than
+    # sin(x)) then a.__sympy__ will be the property. Only on the instance will
+    # a.__sympy__ give the *value* of the property (True). Since sympify(sin)
+    # was used for a long time we allow it to pass. However if strict=True as
+    # is the case in internal calls to _sympify then we only allow
+    # is_sympy=True.
+    #
+    # https://github.com/sympy/sympy/issues/20124
+    is_sympy = getattr(a, '__sympy__', None)
+    if is_sympy is True:
+        return a
+    elif is_sympy is not None:
+        if not strict:
+            return a
+        else:
+            raise SympifyError(a)
+
+    if isinstance(a, CantSympify):
+        raise SympifyError(a)
+
+    cls = getattr(a, "__class__", None)
+
+    #Check if there exists a converter for any of the types in the mro
+    for superclass in getmro(cls):
+        #First check for user defined converters
+        conv = _external_converter.get(superclass)
+        if conv is None:
+            #if none exists, check for SymPy defined converters
+            conv = _sympy_converter.get(superclass)
+        if conv is not None:
+            return conv(a)
+
+    if cls is type(None):
+        if strict:
+            raise SympifyError(a)
+        else:
+            return a
+
+    if evaluate is None:
+        evaluate = global_parameters.evaluate
+
+    # Support for basic numpy datatypes
+    if _is_numpy_instance(a):
+        import numpy as np
+        if np.isscalar(a):
+            return _convert_numpy_types(a, locals=locals,
+                convert_xor=convert_xor, strict=strict, rational=rational,
+                evaluate=evaluate)
+
+    _sympy_ = getattr(a, "_sympy_", None)
+    if _sympy_ is not None:
+        try:
+            return a._sympy_()
+        # XXX: Catches AttributeError: 'SymPyConverter' object has no
+        # attribute 'tuple'
+        # This is probably a bug somewhere but for now we catch it here.
+        except AttributeError:
+            pass
+
+    if not strict:
+        # Put numpy array conversion _before_ float/int, see
+        # <https://github.com/sympy/sympy/issues/13924>.
+        flat = getattr(a, "flat", None)
+        if flat is not None:
+            shape = getattr(a, "shape", None)
+            if shape is not None:
+                from sympy.tensor.array import Array
+                return Array(a.flat, a.shape)  # works with e.g. NumPy arrays
+
+    if not isinstance(a, str):
+        if _is_numpy_instance(a):
+            import numpy as np
+            assert not isinstance(a, np.number)
+            if isinstance(a, np.ndarray):
+                # Scalar arrays (those with zero dimensions) have sympify
+                # called on the scalar element.
+                if a.ndim == 0:
+                    try:
+                        return sympify(a.item(),
+                                       locals=locals,
+                                       convert_xor=convert_xor,
+                                       strict=strict,
+                                       rational=rational,
+                                       evaluate=evaluate)
+                    except SympifyError:
+                        pass
+        else:
+            # float and int can coerce size-one numpy arrays to their lone
+            # element.  See issue https://github.com/numpy/numpy/issues/10404.
+            for coerce in (float, int):
+                try:
+                    return sympify(coerce(a))
+                except (TypeError, ValueError, AttributeError, SympifyError):
+                    continue
+
+    if strict:
+        raise SympifyError(a)
+
+    if iterable(a):
+        try:
+            return type(a)([sympify(x, locals=locals, convert_xor=convert_xor,
+                rational=rational, evaluate=evaluate) for x in a])
+        except TypeError:
+            # Not all iterables are rebuildable with their type.
+            pass
+
+    if not isinstance(a, str):
+        try:
+            a = str(a)
+        except Exception as exc:
+            raise SympifyError(a, exc)
+        sympy_deprecation_warning(
+            f"""
+The string fallback in sympify() is deprecated.
+
+To explicitly convert the string form of an object, use
+sympify(str(obj)). To add define sympify behavior on custom
+objects, use sympy.core.sympify.converter or define obj._sympy_
+(see the sympify() docstring).
+
+sympify() performed the string fallback resulting in the following string:
+
+{a!r}
+            """,
+            deprecated_since_version='1.6',
+            active_deprecations_target="deprecated-sympify-string-fallback",
+        )
+
+    from sympy.parsing.sympy_parser import (parse_expr, TokenError,
+                                            standard_transformations)
+    from sympy.parsing.sympy_parser import convert_xor as t_convert_xor
+    from sympy.parsing.sympy_parser import rationalize as t_rationalize
+
+    transformations = standard_transformations
+
+    if rational:
+        transformations += (t_rationalize,)
+    if convert_xor:
+        transformations += (t_convert_xor,)
+
+    try:
+        a = a.replace('\n', '')
+        expr = parse_expr(a, local_dict=locals, transformations=transformations, evaluate=evaluate)
+    except (TokenError, SyntaxError) as exc:
+        raise SympifyError('could not parse %r' % a, exc)
+
+    return expr
+
+
+def _sympify(a):
+    """
+    Short version of :func:`~.sympify` for internal usage for ``__add__`` and
+    ``__eq__`` methods where it is ok to allow some things (like Python
+    integers and floats) in the expression. This excludes things (like strings)
+    that are unwise to allow into such an expression.
+
+    >>> from sympy import Integer
+    >>> Integer(1) == 1
+    True
+
+    >>> Integer(1) == '1'
+    False
+
+    >>> from sympy.abc import x
+    >>> x + 1
+    x + 1
+
+    >>> x + '1'
+    Traceback (most recent call last):
+    ...
+    TypeError: unsupported operand type(s) for +: 'Symbol' and 'str'
+
+    see: sympify
+
+    """
+    return sympify(a, strict=True)
+
+
+def kernS(s):
+    """Use a hack to try keep autosimplification from distributing a
+    a number into an Add; this modification does not
+    prevent the 2-arg Mul from becoming an Add, however.
+
+    Examples
+    ========
+
+    >>> from sympy.core.sympify import kernS
+    >>> from sympy.abc import x, y
+
+    The 2-arg Mul distributes a number (or minus sign) across the terms
+    of an expression, but kernS will prevent that:
+
+    >>> 2*(x + y), -(x + 1)
+    (2*x + 2*y, -x - 1)
+    >>> kernS('2*(x + y)')
+    2*(x + y)
+    >>> kernS('-(x + 1)')
+    -(x + 1)
+
+    If use of the hack fails, the un-hacked string will be passed to sympify...
+    and you get what you get.
+
+    XXX This hack should not be necessary once issue 4596 has been resolved.
+    """
+    hit = False
+    quoted = '"' in s or "'" in s
+    if '(' in s and not quoted:
+        if s.count('(') != s.count(")"):
+            raise SympifyError('unmatched left parenthesis')
+
+        # strip all space from s
+        s = ''.join(s.split())
+        olds = s
+        # now use space to represent a symbol that
+        # will
+        # step 1. turn potential 2-arg Muls into 3-arg versions
+        # 1a. *( -> * *(
+        s = s.replace('*(', '* *(')
+        # 1b. close up exponentials
+        s = s.replace('** *', '**')
+        # 2. handle the implied multiplication of a negated
+        # parenthesized expression in two steps
+        # 2a:  -(...)  -->  -( *(...)
+        target = '-( *('
+        s = s.replace('-(', target)
+        # 2b: double the matching closing parenthesis
+        # -( *(...)  -->  -( *(...))
+        i = nest = 0
+        assert target.endswith('(')  # assumption below
+        while True:
+            j = s.find(target, i)
+            if j == -1:
+                break
+            j += len(target) - 1
+            for j in range(j, len(s)):
+                if s[j] == "(":
+                    nest += 1
+                elif s[j] == ")":
+                    nest -= 1
+                if nest == 0:
+                    break
+            s = s[:j] + ")" + s[j:]
+            i = j + 2  # the first char after 2nd )
+        if ' ' in s:
+            # get a unique kern
+            kern = '_'
+            while kern in s:
+                kern += choice(string.ascii_letters + string.digits)
+            s = s.replace(' ', kern)
+            hit = kern in s
+        else:
+            hit = False
+
+    for i in range(2):
+        try:
+            expr = sympify(s)
+            break
+        except TypeError:  # the kern might cause unknown errors...
+            if hit:
+                s = olds  # maybe it didn't like the kern; use un-kerned s
+                hit = False
+                continue
+            expr = sympify(s)  # let original error raise
+
+    if not hit:
+        return expr
+
+    from .symbol import Symbol
+    rep = {Symbol(kern): 1}
+    def _clear(expr):
+        if isinstance(expr, (list, tuple, set)):
+            return type(expr)([_clear(e) for e in expr])
+        if hasattr(expr, 'subs'):
+            return expr.subs(rep, hack2=True)
+        return expr
+    expr = _clear(expr)
+    # hope that kern is not there anymore
+    return expr
+
+
+# Avoid circular import
+from .basic import Basic

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_arit.py

@@ -0,0 +1,2463 @@
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Integer, Rational, comp, nan,
+    oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import (Max, sqrt)
+from sympy.functions.elementary.trigonometric import (atan, cos, sin)
+from sympy.polys.polytools import Poly
+from sympy.sets.sets import FiniteSet
+
+from sympy.core.parameters import distribute, evaluate
+from sympy.core.expr import unchanged
+from sympy.utilities.iterables import permutations
+from sympy.testing.pytest import XFAIL, raises, warns
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+from sympy.core.random import verify_numerically
+from sympy.functions.elementary.trigonometric import asin
+
+from itertools import product
+
+a, c, x, y, z = symbols('a,c,x,y,z')
+b = Symbol("b", positive=True)
+
+
+def same_and_same_prec(a, b):
+    # stricter matching for Floats
+    return a == b and a._prec == b._prec
+
+
+def test_bug1():
+    assert re(x) != x
+    x.series(x, 0, 1)
+    assert re(x) != x
+
+
+def test_Symbol():
+    e = a*b
+    assert e == a*b
+    assert a*b*b == a*b**2
+    assert a*b*b + c == c + a*b**2
+    assert a*b*b - c == -c + a*b**2
+
+    x = Symbol('x', complex=True, real=False)
+    assert x.is_imaginary is None  # could be I or 1 + I
+    x = Symbol('x', complex=True, imaginary=False)
+    assert x.is_real is None  # could be 1 or 1 + I
+    x = Symbol('x', real=True)
+    assert x.is_complex
+    x = Symbol('x', imaginary=True)
+    assert x.is_complex
+    x = Symbol('x', real=False, imaginary=False)
+    assert x.is_complex is None  # might be a non-number
+
+
+def test_arit0():
+    p = Rational(5)
+    e = a*b
+    assert e == a*b
+    e = a*b + b*a
+    assert e == 2*a*b
+    e = a*b + b*a + a*b + p*b*a
+    assert e == 8*a*b
+    e = a*b + b*a + a*b + p*b*a + a
+    assert e == a + 8*a*b
+    e = a + a
+    assert e == 2*a
+    e = a + b + a
+    assert e == b + 2*a
+    e = a + b*b + a + b*b
+    assert e == 2*a + 2*b**2
+    e = a + Rational(2) + b*b + a + b*b + p
+    assert e == 7 + 2*a + 2*b**2
+    e = (a + b*b + a + b*b)*p
+    assert e == 5*(2*a + 2*b**2)
+    e = (a*b*c + c*b*a + b*a*c)*p
+    assert e == 15*a*b*c
+    e = (a*b*c + c*b*a + b*a*c)*p - Rational(15)*a*b*c
+    assert e == Rational(0)
+    e = Rational(50)*(a - a)
+    assert e == Rational(0)
+    e = b*a - b - a*b + b
+    assert e == Rational(0)
+    e = a*b + c**p
+    assert e == a*b + c**5
+    e = a/b
+    assert e == a*b**(-1)
+    e = a*2*2
+    assert e == 4*a
+    e = 2 + a*2/2
+    assert e == 2 + a
+    e = 2 - a - 2
+    assert e == -a
+    e = 2*a*2
+    assert e == 4*a
+    e = 2/a/2
+    assert e == a**(-1)
+    e = 2**a**2
+    assert e == 2**(a**2)
+    e = -(1 + a)
+    assert e == -1 - a
+    e = S.Half*(1 + a)
+    assert e == S.Half + a/2
+
+
+def test_div():
+    e = a/b
+    assert e == a*b**(-1)
+    e = a/b + c/2
+    assert e == a*b**(-1) + Rational(1)/2*c
+    e = (1 - b)/(b - 1)
+    assert e == (1 + -b)*((-1) + b)**(-1)
+
+
+def test_pow_arit():
+    n1 = Rational(1)
+    n2 = Rational(2)
+    n5 = Rational(5)
+    e = a*a
+    assert e == a**2
+    e = a*a*a
+    assert e == a**3
+    e = a*a*a*a**Rational(6)
+    assert e == a**9
+    e = a*a*a*a**Rational(6) - a**Rational(9)
+    assert e == Rational(0)
+    e = a**(b - b)
+    assert e == Rational(1)
+    e = (a + Rational(1) - a)**b
+    assert e == Rational(1)
+
+    e = (a + b + c)**n2
+    assert e == (a + b + c)**2
+    assert e.expand() == 2*b*c + 2*a*c + 2*a*b + a**2 + c**2 + b**2
+
+    e = (a + b)**n2
+    assert e == (a + b)**2
+    assert e.expand() == 2*a*b + a**2 + b**2
+
+    e = (a + b)**(n1/n2)
+    assert e == sqrt(a + b)
+    assert e.expand() == sqrt(a + b)
+
+    n = n5**(n1/n2)
+    assert n == sqrt(5)
+    e = n*a*b - n*b*a
+    assert e == Rational(0)
+    e = n*a*b + n*b*a
+    assert e == 2*a*b*sqrt(5)
+    assert e.diff(a) == 2*b*sqrt(5)
+    assert e.diff(a) == 2*b*sqrt(5)
+    e = a/b**2
+    assert e == a*b**(-2)
+
+    assert sqrt(2*(1 + sqrt(2))) == (2*(1 + 2**S.Half))**S.Half
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    assert ((x*y)**3).expand() == y**3 * x**3
+    assert ((x*y)**-3).expand() == y**-3 * x**-3
+
+    assert (x**5*(3*x)**(3)).expand() == 27 * x**8
+    assert (x**5*(-3*x)**(3)).expand() == -27 * x**8
+    assert (x**5*(3*x)**(-3)).expand() == x**2 * Rational(1, 27)
+    assert (x**5*(-3*x)**(-3)).expand() == x**2 * Rational(-1, 27)
+
+    # expand_power_exp
+    _x = Symbol('x', zero=False)
+    _y = Symbol('y', zero=False)
+    assert (_x**(y**(x + exp(x + y)) + z)).expand(deep=False) == \
+        _x**z*_x**(y**(x + exp(x + y)))
+    assert (_x**(_y**(x + exp(x + y)) + z)).expand() == \
+        _x**z*_x**(_y**x*_y**(exp(x)*exp(y)))
+
+    n = Symbol('n', even=False)
+    k = Symbol('k', even=True)
+    o = Symbol('o', odd=True)
+
+    assert unchanged(Pow, -1, x)
+    assert unchanged(Pow, -1, n)
+    assert (-2)**k == 2**k
+    assert (-1)**k == 1
+    assert (-1)**o == -1
+
+
+def test_pow2():
+    # x**(2*y) is always (x**y)**2 but is only (x**2)**y if
+    #                                  x.is_positive or y.is_integer
+    # let x = 1 to see why the following are not true.
+    assert (-x)**Rational(2, 3) != x**Rational(2, 3)
+    assert (-x)**Rational(5, 7) != -x**Rational(5, 7)
+    assert ((-x)**2)**Rational(1, 3) != ((-x)**Rational(1, 3))**2
+    assert sqrt(x**2) != x
+
+
+def test_pow3():
+    assert sqrt(2)**3 == 2 * sqrt(2)
+    assert sqrt(2)**3 == sqrt(8)
+
+
+def test_mod_pow():
+    for s, t, u, v in [(4, 13, 497, 445), (4, -3, 497, 365),
+            (3.2, 2.1, 1.9, 0.1031015682350942), (S(3)/2, 5, S(5)/6, S(3)/32)]:
+        assert pow(S(s), t, u) == v
+        assert pow(S(s), S(t), u) == v
+        assert pow(S(s), t, S(u)) == v
+        assert pow(S(s), S(t), S(u)) == v
+    assert pow(S(2), S(10000000000), S(3)) == 1
+    assert pow(x, y, z) == x**y%z
+    raises(TypeError, lambda: pow(S(4), "13", 497))
+    raises(TypeError, lambda: pow(S(4), 13, "497"))
+
+
+def test_pow_E():
+    assert 2**(y/log(2)) == S.Exp1**y
+    assert 2**(y/log(2)/3) == S.Exp1**(y/3)
+    assert 3**(1/log(-3)) != S.Exp1
+    assert (3 + 2*I)**(1/(log(-3 - 2*I) + I*pi)) == S.Exp1
+    assert (4 + 2*I)**(1/(log(-4 - 2*I) + I*pi)) == S.Exp1
+    assert (3 + 2*I)**(1/(log(-3 - 2*I, 3)/2 + I*pi/log(3)/2)) == 9
+    assert (3 + 2*I)**(1/(log(3 + 2*I, 3)/2)) == 9
+    # every time tests are run they will affirm with a different random
+    # value that this identity holds
+    while 1:
+        b = x._random()
+        r, i = b.as_real_imag()
+        if i:
+            break
+    assert verify_numerically(b**(1/(log(-b) + sign(i)*I*pi).n()), S.Exp1)
+
+
+def test_pow_issue_3516():
+    assert 4**Rational(1, 4) == sqrt(2)
+
+
+def test_pow_im():
+    for m in (-2, -1, 2):
+        for d in (3, 4, 5):
+            b = m*I
+            for i in range(1, 4*d + 1):
+                e = Rational(i, d)
+                assert (b**e - b.n()**e.n()).n(2, chop=1e-10) == 0
+
+    e = Rational(7, 3)
+    assert (2*x*I)**e == 4*2**Rational(1, 3)*(I*x)**e  # same as Wolfram Alpha
+    im = symbols('im', imaginary=True)
+    assert (2*im*I)**e == 4*2**Rational(1, 3)*(I*im)**e
+
+    args = [I, I, I, I, 2]
+    e = Rational(1, 3)
+    ans = 2**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args = [I, I, I, 2]
+    e = Rational(1, 3)
+    ans = 2**e*(-I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-3)
+    ans = (6*I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-1)
+    ans = (-6*I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+
+    args = [I, I, 2]
+    e = Rational(1, 3)
+    ans = (-2)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-3)
+    ans = (6)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-1)
+    ans = (-6)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    assert Mul(Pow(-1, Rational(3, 2), evaluate=False), I, I) == I
+    assert Mul(I*Pow(I, S.Half, evaluate=False)) == sqrt(I)*I
+
+
+def test_real_mul():
+    assert Float(0) * pi * x == 0
+    assert set((Float(1) * pi * x).args) == {Float(1), pi, x}
+
+
+def test_ncmul():
+    A = Symbol("A", commutative=False)
+    B = Symbol("B", commutative=False)
+    C = Symbol("C", commutative=False)
+    assert A*B != B*A
+    assert A*B*C != C*B*A
+    assert A*b*B*3*C == 3*b*A*B*C
+    assert A*b*B*3*C != 3*b*B*A*C
+    assert A*b*B*3*C == 3*A*B*C*b
+
+    assert A + B == B + A
+    assert (A + B)*C != C*(A + B)
+
+    assert C*(A + B)*C != C*C*(A + B)
+
+    assert A*A == A**2
+    assert (A + B)*(A + B) == (A + B)**2
+
+    assert A**-1 * A == 1
+    assert A/A == 1
+    assert A/(A**2) == 1/A
+
+    assert A/(1 + A) == A/(1 + A)
+
+    assert set((A + B + 2*(A + B)).args) == \
+        {A, B, 2*(A + B)}
+
+
+def test_mul_add_identity():
+    m = Mul(1, 2)
+    assert isinstance(m, Rational) and m.p == 2 and m.q == 1
+    m = Mul(1, 2, evaluate=False)
+    assert isinstance(m, Mul) and m.args == (1, 2)
+    m = Mul(0, 1)
+    assert m is S.Zero
+    m = Mul(0, 1, evaluate=False)
+    assert isinstance(m, Mul) and m.args == (0, 1)
+    m = Add(0, 1)
+    assert m is S.One
+    m = Add(0, 1, evaluate=False)
+    assert isinstance(m, Add) and m.args == (0, 1)
+
+
+def test_ncpow():
+    x = Symbol('x', commutative=False)
+    y = Symbol('y', commutative=False)
+    z = Symbol('z', commutative=False)
+    a = Symbol('a')
+    b = Symbol('b')
+    c = Symbol('c')
+
+    assert (x**2)*(y**2) != (y**2)*(x**2)
+    assert (x**-2)*y != y*(x**2)
+    assert 2**x*2**y != 2**(x + y)
+    assert 2**x*2**y*2**z != 2**(x + y + z)
+    assert 2**x*2**(2*x) == 2**(3*x)
+    assert 2**x*2**(2*x)*2**x == 2**(4*x)
+    assert exp(x)*exp(y) != exp(y)*exp(x)
+    assert exp(x)*exp(y)*exp(z) != exp(y)*exp(x)*exp(z)
+    assert exp(x)*exp(y)*exp(z) != exp(x + y + z)
+    assert x**a*x**b != x**(a + b)
+    assert x**a*x**b*x**c != x**(a + b + c)
+    assert x**3*x**4 == x**7
+    assert x**3*x**4*x**2 == x**9
+    assert x**a*x**(4*a) == x**(5*a)
+    assert x**a*x**(4*a)*x**a == x**(6*a)
+
+
+def test_powerbug():
+    x = Symbol("x")
+    assert x**1 != (-x)**1
+    assert x**2 == (-x)**2
+    assert x**3 != (-x)**3
+    assert x**4 == (-x)**4
+    assert x**5 != (-x)**5
+    assert x**6 == (-x)**6
+
+    assert x**128 == (-x)**128
+    assert x**129 != (-x)**129
+
+    assert (2*x)**2 == (-2*x)**2
+
+
+def test_Mul_doesnt_expand_exp():
+    x = Symbol('x')
+    y = Symbol('y')
+    assert unchanged(Mul, exp(x), exp(y))
+    assert unchanged(Mul, 2**x, 2**y)
+    assert x**2*x**3 == x**5
+    assert 2**x*3**x == 6**x
+    assert x**(y)*x**(2*y) == x**(3*y)
+    assert sqrt(2)*sqrt(2) == 2
+    assert 2**x*2**(2*x) == 2**(3*x)
+    assert sqrt(2)*2**Rational(1, 4)*5**Rational(3, 4) == 10**Rational(3, 4)
+    assert (x**(-log(5)/log(3))*x)/(x*x**( - log(5)/log(3))) == sympify(1)
+
+
+def test_Mul_is_integer():
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True)
+    nr = Symbol('nr', rational=False)
+    ir = Symbol('ir', irrational=True)
+    nz = Symbol('nz', integer=True, zero=False)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+    i2 = Symbol('2', prime=True, even=True)
+
+    assert (k/3).is_integer is None
+    assert (nz/3).is_integer is None
+    assert (nr/3).is_integer is False
+    assert (ir/3).is_integer is False
+    assert (x*k*n).is_integer is None
+    assert (e/2).is_integer is True
+    assert (e**2/2).is_integer is True
+    assert (2/k).is_integer is None
+    assert (2/k**2).is_integer is None
+    assert ((-1)**k*n).is_integer is True
+    assert (3*k*e/2).is_integer is True
+    assert (2*k*e/3).is_integer is None
+    assert (e/o).is_integer is None
+    assert (o/e).is_integer is False
+    assert (o/i2).is_integer is False
+    assert Mul(k, 1/k, evaluate=False).is_integer is None
+    assert Mul(2., S.Half, evaluate=False).is_integer is None
+    assert (2*sqrt(k)).is_integer is None
+    assert (2*k**n).is_integer is None
+
+    s = 2**2**2**Pow(2, 1000, evaluate=False)
+    m = Mul(s, s, evaluate=False)
+    assert m.is_integer
+
+    # broken in 1.6 and before, see #20161
+    xq = Symbol('xq', rational=True)
+    yq = Symbol('yq', rational=True)
+    assert (xq*yq).is_integer is None
+    e_20161 = Mul(-1,Mul(1,Pow(2,-1,evaluate=False),evaluate=False),evaluate=False)
+    assert e_20161.is_integer is not True # expand(e_20161) -> -1/2, but no need to see that in the assumption without evaluation
+
+
+def test_Add_Mul_is_integer():
+    x = Symbol('x')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True)
+    nk = Symbol('nk', integer=False)
+    nr = Symbol('nr', rational=False)
+    nz = Symbol('nz', integer=True, zero=False)
+
+    assert (-nk).is_integer is None
+    assert (-nr).is_integer is False
+    assert (2*k).is_integer is True
+    assert (-k).is_integer is True
+
+    assert (k + nk).is_integer is False
+    assert (k + n).is_integer is True
+    assert (k + x).is_integer is None
+    assert (k + n*x).is_integer is None
+    assert (k + n/3).is_integer is None
+    assert (k + nz/3).is_integer is None
+    assert (k + nr/3).is_integer is False
+
+    assert ((1 + sqrt(3))*(-sqrt(3) + 1)).is_integer is not False
+    assert (1 + (1 + sqrt(3))*(-sqrt(3) + 1)).is_integer is not False
+
+
+def test_Add_Mul_is_finite():
+    x = Symbol('x', extended_real=True, finite=False)
+
+    assert sin(x).is_finite is True
+    assert (x*sin(x)).is_finite is None
+    assert (x*atan(x)).is_finite is False
+    assert (1024*sin(x)).is_finite is True
+    assert (sin(x)*exp(x)).is_finite is None
+    assert (sin(x)*cos(x)).is_finite is True
+    assert (x*sin(x)*exp(x)).is_finite is None
+
+    assert (sin(x) - 67).is_finite is True
+    assert (sin(x) + exp(x)).is_finite is not True
+    assert (1 + x).is_finite is False
+    assert (1 + x**2 + (1 + x)*(1 - x)).is_finite is None
+    assert (sqrt(2)*(1 + x)).is_finite is False
+    assert (sqrt(2)*(1 + x)*(1 - x)).is_finite is False
+
+
+def test_Mul_is_even_odd():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+
+    k = Symbol('k', odd=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', even=True)
+
+    assert (2*x).is_even is True
+    assert (2*x).is_odd is False
+
+    assert (3*x).is_even is None
+    assert (3*x).is_odd is None
+
+    assert (k/3).is_integer is None
+    assert (k/3).is_even is None
+    assert (k/3).is_odd is None
+
+    assert (2*n).is_even is True
+    assert (2*n).is_odd is False
+
+    assert (2*m).is_even is True
+    assert (2*m).is_odd is False
+
+    assert (-n).is_even is False
+    assert (-n).is_odd is True
+
+    assert (k*n).is_even is False
+    assert (k*n).is_odd is True
+
+    assert (k*m).is_even is True
+    assert (k*m).is_odd is False
+
+    assert (k*n*m).is_even is True
+    assert (k*n*m).is_odd is False
+
+    assert (k*m*x).is_even is True
+    assert (k*m*x).is_odd is False
+
+    # issue 6791:
+    assert (x/2).is_integer is None
+    assert (k/2).is_integer is False
+    assert (m/2).is_integer is True
+
+    assert (x*y).is_even is None
+    assert (x*x).is_even is None
+    assert (x*(x + k)).is_even is True
+    assert (x*(x + m)).is_even is None
+
+    assert (x*y).is_odd is None
+    assert (x*x).is_odd is None
+    assert (x*(x + k)).is_odd is False
+    assert (x*(x + m)).is_odd is None
+
+    # issue 8648
+    assert (m**2/2).is_even
+    assert (m**2/3).is_even is False
+    assert (2/m**2).is_odd is False
+    assert (2/m).is_odd is None
+
+
+@XFAIL
+def test_evenness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    k = Symbol('k', odd=True)
+    assert (x*y*(y + k)).is_even is True
+    assert (y*x*(x + k)).is_even is True
+
+
+def test_evenness_in_ternary_integer_product_with_even():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    m = Symbol('m', even=True)
+    assert (x*y*(y + m)).is_even is None
+
+
+@XFAIL
+def test_oddness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    k = Symbol('k', odd=True)
+    assert (x*y*(y + k)).is_odd is False
+    assert (y*x*(x + k)).is_odd is False
+
+
+def test_oddness_in_ternary_integer_product_with_even():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    m = Symbol('m', even=True)
+    assert (x*y*(y + m)).is_odd is None
+
+
+def test_Mul_is_rational():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, nonzero=True)
+
+    assert (n/m).is_rational is True
+    assert (x/pi).is_rational is None
+    assert (x/n).is_rational is None
+    assert (m/pi).is_rational is False
+
+    r = Symbol('r', rational=True)
+    assert (pi*r).is_rational is None
+
+    # issue 8008
+    z = Symbol('z', zero=True)
+    i = Symbol('i', imaginary=True)
+    assert (z*i).is_rational is True
+    bi = Symbol('i', imaginary=True, finite=True)
+    assert (z*bi).is_zero is True
+
+
+def test_Add_is_rational():
+    x = Symbol('x')
+    n = Symbol('n', rational=True)
+    m = Symbol('m', rational=True)
+
+    assert (n + m).is_rational is True
+    assert (x + pi).is_rational is None
+    assert (x + n).is_rational is None
+    assert (n + pi).is_rational is False
+
+
+def test_Add_is_even_odd():
+    x = Symbol('x', integer=True)
+
+    k = Symbol('k', odd=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', even=True)
+
+    assert (k + 7).is_even is True
+    assert (k + 7).is_odd is False
+
+    assert (-k + 7).is_even is True
+    assert (-k + 7).is_odd is False
+
+    assert (k - 12).is_even is False
+    assert (k - 12).is_odd is True
+
+    assert (-k - 12).is_even is False
+    assert (-k - 12).is_odd is True
+
+    assert (k + n).is_even is True
+    assert (k + n).is_odd is False
+
+    assert (k + m).is_even is False
+    assert (k + m).is_odd is True
+
+    assert (k + n + m).is_even is True
+    assert (k + n + m).is_odd is False
+
+    assert (k + n + x + m).is_even is None
+    assert (k + n + x + m).is_odd is None
+
+
+def test_Mul_is_negative_positive():
+    x = Symbol('x', real=True)
+    y = Symbol('y', extended_real=False, complex=True)
+    z = Symbol('z', zero=True)
+
+    e = 2*z
+    assert e.is_Mul and e.is_positive is False and e.is_negative is False
+
+    neg = Symbol('neg', negative=True)
+    pos = Symbol('pos', positive=True)
+    nneg = Symbol('nneg', nonnegative=True)
+    npos = Symbol('npos', nonpositive=True)
+
+    assert neg.is_negative is True
+    assert (-neg).is_negative is False
+    assert (2*neg).is_negative is True
+
+    assert (2*pos)._eval_is_extended_negative() is False
+    assert (2*pos).is_negative is False
+
+    assert pos.is_negative is False
+    assert (-pos).is_negative is True
+    assert (2*pos).is_negative is False
+
+    assert (pos*neg).is_negative is True
+    assert (2*pos*neg).is_negative is True
+    assert (-pos*neg).is_negative is False
+    assert (pos*neg*y).is_negative is False     # y.is_real=F;  !real -> !neg
+
+    assert nneg.is_negative is False
+    assert (-nneg).is_negative is None
+    assert (2*nneg).is_negative is False
+
+    assert npos.is_negative is None
+    assert (-npos).is_negative is False
+    assert (2*npos).is_negative is None
+
+    assert (nneg*npos).is_negative is None
+
+    assert (neg*nneg).is_negative is None
+    assert (neg*npos).is_negative is False
+
+    assert (pos*nneg).is_negative is False
+    assert (pos*npos).is_negative is None
+
+    assert (npos*neg*nneg).is_negative is False
+    assert (npos*pos*nneg).is_negative is None
+
+    assert (-npos*neg*nneg).is_negative is None
+    assert (-npos*pos*nneg).is_negative is False
+
+    assert (17*npos*neg*nneg).is_negative is False
+    assert (17*npos*pos*nneg).is_negative is None
+
+    assert (neg*npos*pos*nneg).is_negative is False
+
+    assert (x*neg).is_negative is None
+    assert (nneg*npos*pos*x*neg).is_negative is None
+
+    assert neg.is_positive is False
+    assert (-neg).is_positive is True
+    assert (2*neg).is_positive is False
+
+    assert pos.is_positive is True
+    assert (-pos).is_positive is False
+    assert (2*pos).is_positive is True
+
+    assert (pos*neg).is_positive is False
+    assert (2*pos*neg).is_positive is False
+    assert (-pos*neg).is_positive is True
+    assert (-pos*neg*y).is_positive is False    # y.is_real=F;  !real -> !neg
+
+    assert nneg.is_positive is None
+    assert (-nneg).is_positive is False
+    assert (2*nneg).is_positive is None
+
+    assert npos.is_positive is False
+    assert (-npos).is_positive is None
+    assert (2*npos).is_positive is False
+
+    assert (nneg*npos).is_positive is False
+
+    assert (neg*nneg).is_positive is False
+    assert (neg*npos).is_positive is None
+
+    assert (pos*nneg).is_positive is None
+    assert (pos*npos).is_positive is False
+
+    assert (npos*neg*nneg).is_positive is None
+    assert (npos*pos*nneg).is_positive is False
+
+    assert (-npos*neg*nneg).is_positive is False
+    assert (-npos*pos*nneg).is_positive is None
+
+    assert (17*npos*neg*nneg).is_positive is None
+    assert (17*npos*pos*nneg).is_positive is False
+
+    assert (neg*npos*pos*nneg).is_positive is None
+
+    assert (x*neg).is_positive is None
+    assert (nneg*npos*pos*x*neg).is_positive is None
+
+
+def test_Mul_is_negative_positive_2():
+    a = Symbol('a', nonnegative=True)
+    b = Symbol('b', nonnegative=True)
+    c = Symbol('c', nonpositive=True)
+    d = Symbol('d', nonpositive=True)
+
+    assert (a*b).is_nonnegative is True
+    assert (a*b).is_negative is False
+    assert (a*b).is_zero is None
+    assert (a*b).is_positive is None
+
+    assert (c*d).is_nonnegative is True
+    assert (c*d).is_negative is False
+    assert (c*d).is_zero is None
+    assert (c*d).is_positive is None
+
+    assert (a*c).is_nonpositive is True
+    assert (a*c).is_positive is False
+    assert (a*c).is_zero is None
+    assert (a*c).is_negative is None
+
+
+def test_Mul_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert k.is_nonpositive is True
+    assert (-k).is_nonpositive is False
+    assert (2*k).is_nonpositive is True
+
+    assert n.is_nonpositive is False
+    assert (-n).is_nonpositive is True
+    assert (2*n).is_nonpositive is False
+
+    assert (n*k).is_nonpositive is True
+    assert (2*n*k).is_nonpositive is True
+    assert (-n*k).is_nonpositive is False
+
+    assert u.is_nonpositive is None
+    assert (-u).is_nonpositive is True
+    assert (2*u).is_nonpositive is None
+
+    assert v.is_nonpositive is True
+    assert (-v).is_nonpositive is None
+    assert (2*v).is_nonpositive is True
+
+    assert (u*v).is_nonpositive is True
+
+    assert (k*u).is_nonpositive is True
+    assert (k*v).is_nonpositive is None
+
+    assert (n*u).is_nonpositive is None
+    assert (n*v).is_nonpositive is True
+
+    assert (v*k*u).is_nonpositive is None
+    assert (v*n*u).is_nonpositive is True
+
+    assert (-v*k*u).is_nonpositive is True
+    assert (-v*n*u).is_nonpositive is None
+
+    assert (17*v*k*u).is_nonpositive is None
+    assert (17*v*n*u).is_nonpositive is True
+
+    assert (k*v*n*u).is_nonpositive is None
+
+    assert (x*k).is_nonpositive is None
+    assert (u*v*n*x*k).is_nonpositive is None
+
+    assert k.is_nonnegative is False
+    assert (-k).is_nonnegative is True
+    assert (2*k).is_nonnegative is False
+
+    assert n.is_nonnegative is True
+    assert (-n).is_nonnegative is False
+    assert (2*n).is_nonnegative is True
+
+    assert (n*k).is_nonnegative is False
+    assert (2*n*k).is_nonnegative is False
+    assert (-n*k).is_nonnegative is True
+
+    assert u.is_nonnegative is True
+    assert (-u).is_nonnegative is None
+    assert (2*u).is_nonnegative is True
+
+    assert v.is_nonnegative is None
+    assert (-v).is_nonnegative is True
+    assert (2*v).is_nonnegative is None
+
+    assert (u*v).is_nonnegative is None
+
+    assert (k*u).is_nonnegative is None
+    assert (k*v).is_nonnegative is True
+
+    assert (n*u).is_nonnegative is True
+    assert (n*v).is_nonnegative is None
+
+    assert (v*k*u).is_nonnegative is True
+    assert (v*n*u).is_nonnegative is None
+
+    assert (-v*k*u).is_nonnegative is None
+    assert (-v*n*u).is_nonnegative is True
+
+    assert (17*v*k*u).is_nonnegative is True
+    assert (17*v*n*u).is_nonnegative is None
+
+    assert (k*v*n*u).is_nonnegative is True
+
+    assert (x*k).is_nonnegative is None
+    assert (u*v*n*x*k).is_nonnegative is None
+
+
+def test_Add_is_negative_positive():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert (k - 2).is_negative is True
+    assert (k + 17).is_negative is None
+    assert (-k - 5).is_negative is None
+    assert (-k + 123).is_negative is False
+
+    assert (k - n).is_negative is True
+    assert (k + n).is_negative is None
+    assert (-k - n).is_negative is None
+    assert (-k + n).is_negative is False
+
+    assert (k - n - 2).is_negative is True
+    assert (k + n + 17).is_negative is None
+    assert (-k - n - 5).is_negative is None
+    assert (-k + n + 123).is_negative is False
+
+    assert (-2*k + 123*n + 17).is_negative is False
+
+    assert (k + u).is_negative is None
+    assert (k + v).is_negative is True
+    assert (n + u).is_negative is False
+    assert (n + v).is_negative is None
+
+    assert (u - v).is_negative is False
+    assert (u + v).is_negative is None
+    assert (-u - v).is_negative is None
+    assert (-u + v).is_negative is None
+
+    assert (u - v + n + 2).is_negative is False
+    assert (u + v + n + 2).is_negative is None
+    assert (-u - v + n + 2).is_negative is None
+    assert (-u + v + n + 2).is_negative is None
+
+    assert (k + x).is_negative is None
+    assert (k + x - n).is_negative is None
+
+    assert (k - 2).is_positive is False
+    assert (k + 17).is_positive is None
+    assert (-k - 5).is_positive is None
+    assert (-k + 123).is_positive is True
+
+    assert (k - n).is_positive is False
+    assert (k + n).is_positive is None
+    assert (-k - n).is_positive is None
+    assert (-k + n).is_positive is True
+
+    assert (k - n - 2).is_positive is False
+    assert (k + n + 17).is_positive is None
+    assert (-k - n - 5).is_positive is None
+    assert (-k + n + 123).is_positive is True
+
+    assert (-2*k + 123*n + 17).is_positive is True
+
+    assert (k + u).is_positive is None
+    assert (k + v).is_positive is False
+    assert (n + u).is_positive is True
+    assert (n + v).is_positive is None
+
+    assert (u - v).is_positive is None
+    assert (u + v).is_positive is None
+    assert (-u - v).is_positive is None
+    assert (-u + v).is_positive is False
+
+    assert (u - v - n - 2).is_positive is None
+    assert (u + v - n - 2).is_positive is None
+    assert (-u - v - n - 2).is_positive is None
+    assert (-u + v - n - 2).is_positive is False
+
+    assert (n + x).is_positive is None
+    assert (n + x - k).is_positive is None
+
+    z = (-3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2)
+    assert z.is_zero
+    z = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert z.is_zero
+
+
+def test_Add_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert (u - 2).is_nonpositive is None
+    assert (u + 17).is_nonpositive is False
+    assert (-u - 5).is_nonpositive is True
+    assert (-u + 123).is_nonpositive is None
+
+    assert (u - v).is_nonpositive is None
+    assert (u + v).is_nonpositive is None
+    assert (-u - v).is_nonpositive is None
+    assert (-u + v).is_nonpositive is True
+
+    assert (u - v - 2).is_nonpositive is None
+    assert (u + v + 17).is_nonpositive is None
+    assert (-u - v - 5).is_nonpositive is None
+    assert (-u + v - 123).is_nonpositive is True
+
+    assert (-2*u + 123*v - 17).is_nonpositive is True
+
+    assert (k + u).is_nonpositive is None
+    assert (k + v).is_nonpositive is True
+    assert (n + u).is_nonpositive is False
+    assert (n + v).is_nonpositive is None
+
+    assert (k - n).is_nonpositive is True
+    assert (k + n).is_nonpositive is None
+    assert (-k - n).is_nonpositive is None
+    assert (-k + n).is_nonpositive is False
+
+    assert (k - n + u + 2).is_nonpositive is None
+    assert (k + n + u + 2).is_nonpositive is None
+    assert (-k - n + u + 2).is_nonpositive is None
+    assert (-k + n + u + 2).is_nonpositive is False
+
+    assert (u + x).is_nonpositive is None
+    assert (v - x - n).is_nonpositive is None
+
+    assert (u - 2).is_nonnegative is None
+    assert (u + 17).is_nonnegative is True
+    assert (-u - 5).is_nonnegative is False
+    assert (-u + 123).is_nonnegative is None
+
+    assert (u - v).is_nonnegative is True
+    assert (u + v).is_nonnegative is None
+    assert (-u - v).is_nonnegative is None
+    assert (-u + v).is_nonnegative is None
+
+    assert (u - v + 2).is_nonnegative is True
+    assert (u + v + 17).is_nonnegative is None
+    assert (-u - v - 5).is_nonnegative is None
+    assert (-u + v - 123).is_nonnegative is False
+
+    assert (2*u - 123*v + 17).is_nonnegative is True
+
+    assert (k + u).is_nonnegative is None
+    assert (k + v).is_nonnegative is False
+    assert (n + u).is_nonnegative is True
+    assert (n + v).is_nonnegative is None
+
+    assert (k - n).is_nonnegative is False
+    assert (k + n).is_nonnegative is None
+    assert (-k - n).is_nonnegative is None
+    assert (-k + n).is_nonnegative is True
+
+    assert (k - n - u - 2).is_nonnegative is False
+    assert (k + n - u - 2).is_nonnegative is None
+    assert (-k - n - u - 2).is_nonnegative is None
+    assert (-k + n - u - 2).is_nonnegative is None
+
+    assert (u - x).is_nonnegative is None
+    assert (v + x + n).is_nonnegative is None
+
+
+def test_Pow_is_integer():
+    x = Symbol('x')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True, nonnegative=True)
+    m = Symbol('m', integer=True, positive=True)
+
+    assert (k**2).is_integer is True
+    assert (k**(-2)).is_integer is None
+    assert ((m + 1)**(-2)).is_integer is False
+    assert (m**(-1)).is_integer is None  # issue 8580
+
+    assert (2**k).is_integer is None
+    assert (2**(-k)).is_integer is None
+
+    assert (2**n).is_integer is True
+    assert (2**(-n)).is_integer is None
+
+    assert (2**m).is_integer is True
+    assert (2**(-m)).is_integer is False
+
+    assert (x**2).is_integer is None
+    assert (2**x).is_integer is None
+
+    assert (k**n).is_integer is True
+    assert (k**(-n)).is_integer is None
+
+    assert (k**x).is_integer is None
+    assert (x**k).is_integer is None
+
+    assert (k**(n*m)).is_integer is True
+    assert (k**(-n*m)).is_integer is None
+
+    assert sqrt(3).is_integer is False
+    assert sqrt(.3).is_integer is False
+    assert Pow(3, 2, evaluate=False).is_integer is True
+    assert Pow(3, 0, evaluate=False).is_integer is True
+    assert Pow(3, -2, evaluate=False).is_integer is False
+    assert Pow(S.Half, 3, evaluate=False).is_integer is False
+    # decided by re-evaluating
+    assert Pow(3, S.Half, evaluate=False).is_integer is False
+    assert Pow(3, S.Half, evaluate=False).is_integer is False
+    assert Pow(4, S.Half, evaluate=False).is_integer is True
+    assert Pow(S.Half, -2, evaluate=False).is_integer is True
+
+    assert ((-1)**k).is_integer
+
+    # issue 8641
+    x = Symbol('x', real=True, integer=False)
+    assert (x**2).is_integer is None
+
+    # issue 10458
+    x = Symbol('x', positive=True)
+    assert (1/(x + 1)).is_integer is False
+    assert (1/(-x - 1)).is_integer is False
+    assert (-1/(x + 1)).is_integer is False
+    # issue 23287
+    assert (x**2/2).is_integer is None
+
+    # issue 8648-like
+    k = Symbol('k', even=True)
+    assert (k**3/2).is_integer
+    assert (k**3/8).is_integer
+    assert (k**3/16).is_integer is None
+    assert (2/k).is_integer is None
+    assert (2/k**2).is_integer is False
+    o = Symbol('o', odd=True)
+    assert (k/o).is_integer is None
+    o = Symbol('o', odd=True, prime=True)
+    assert (k/o).is_integer is False
+
+
+def test_Pow_is_real():
+    x = Symbol('x', real=True)
+    y = Symbol('y', positive=True)
+
+    assert (x**2).is_real is True
+    assert (x**3).is_real is True
+    assert (x**x).is_real is None
+    assert (y**x).is_real is True
+
+    assert (x**Rational(1, 3)).is_real is None
+    assert (y**Rational(1, 3)).is_real is True
+
+    assert sqrt(-1 - sqrt(2)).is_real is False
+
+    i = Symbol('i', imaginary=True)
+    assert (i**i).is_real is None
+    assert (I**i).is_extended_real is True
+    assert ((-I)**i).is_extended_real is True
+    assert (2**i).is_real is None  # (2**(pi/log(2) * I)) is real, 2**I is not
+    assert (2**I).is_real is False
+    assert (2**-I).is_real is False
+    assert (i**2).is_extended_real is True
+    assert (i**3).is_extended_real is False
+    assert (i**x).is_real is None  # could be (-I)**(2/3)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+    k = Symbol('k', integer=True)
+    assert (i**e).is_extended_real is True
+    assert (i**o).is_extended_real is False
+    assert (i**k).is_real is None
+    assert (i**(4*k)).is_extended_real is True
+
+    x = Symbol("x", nonnegative=True)
+    y = Symbol("y", nonnegative=True)
+    assert im(x**y).expand(complex=True) is S.Zero
+    assert (x**y).is_real is True
+    i = Symbol('i', imaginary=True)
+    assert (exp(i)**I).is_extended_real is True
+    assert log(exp(i)).is_imaginary is None  # i could be 2*pi*I
+    c = Symbol('c', complex=True)
+    assert log(c).is_real is None  # c could be 0 or 2, too
+    assert log(exp(c)).is_real is None  # log(0), log(E), ...
+    n = Symbol('n', negative=False)
+    assert log(n).is_real is None
+    n = Symbol('n', nonnegative=True)
+    assert log(n).is_real is None
+
+    assert sqrt(-I).is_real is False  # issue 7843
+
+    i = Symbol('i', integer=True)
+    assert (1/(i-1)).is_real is None
+    assert (1/(i-1)).is_extended_real is None
+
+    # test issue 20715
+    from sympy.core.parameters import evaluate
+    x = S(-1)
+    with evaluate(False):
+        assert x.is_negative is True
+
+    f = Pow(x, -1)
+    with evaluate(False):
+        assert f.is_imaginary is False
+
+
+def test_real_Pow():
+    k = Symbol('k', integer=True, nonzero=True)
+    assert (k**(I*pi/log(k))).is_real
+
+
+def test_Pow_is_finite():
+    xe = Symbol('xe', extended_real=True)
+    xr = Symbol('xr', real=True)
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    i = Symbol('i', integer=True)
+
+    assert (xe**2).is_finite is None  # xe could be oo
+    assert (xr**2).is_finite is True
+
+    assert (xe**xe).is_finite is None
+    assert (xr**xe).is_finite is None
+    assert (xe**xr).is_finite is None
+    # FIXME: The line below should be True rather than None
+    # assert (xr**xr).is_finite is True
+    assert (xr**xr).is_finite is None
+
+    assert (p**xe).is_finite is None
+    assert (p**xr).is_finite is True
+
+    assert (n**xe).is_finite is None
+    assert (n**xr).is_finite is True
+
+    assert (sin(xe)**2).is_finite is True
+    assert (sin(xr)**2).is_finite is True
+
+    assert (sin(xe)**xe).is_finite is None  # xe, xr could be -pi
+    assert (sin(xr)**xr).is_finite is None
+
+    # FIXME: Should the line below be True rather than None?
+    assert (sin(xe)**exp(xe)).is_finite is None
+    assert (sin(xr)**exp(xr)).is_finite is True
+
+    assert (1/sin(xe)).is_finite is None  # if zero, no, otherwise yes
+    assert (1/sin(xr)).is_finite is None
+
+    assert (1/exp(xe)).is_finite is None  # xe could be -oo
+    assert (1/exp(xr)).is_finite is True
+
+    assert (1/S.Pi).is_finite is True
+
+    assert (1/(i-1)).is_finite is None
+
+
+def test_Pow_is_even_odd():
+    x = Symbol('x')
+
+    k = Symbol('k', even=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    p = Symbol('p', integer=True, positive=True)
+
+    assert ((-1)**n).is_odd
+    assert ((-1)**k).is_odd
+    assert ((-1)**(m - p)).is_odd
+
+    assert (k**2).is_even is True
+    assert (n**2).is_even is False
+    assert (2**k).is_even is None
+    assert (x**2).is_even is None
+
+    assert (k**m).is_even is None
+    assert (n**m).is_even is False
+
+    assert (k**p).is_even is True
+    assert (n**p).is_even is False
+
+    assert (m**k).is_even is None
+    assert (p**k).is_even is None
+
+    assert (m**n).is_even is None
+    assert (p**n).is_even is None
+
+    assert (k**x).is_even is None
+    assert (n**x).is_even is None
+
+    assert (k**2).is_odd is False
+    assert (n**2).is_odd is True
+    assert (3**k).is_odd is None
+
+    assert (k**m).is_odd is None
+    assert (n**m).is_odd is True
+
+    assert (k**p).is_odd is False
+    assert (n**p).is_odd is True
+
+    assert (m**k).is_odd is None
+    assert (p**k).is_odd is None
+
+    assert (m**n).is_odd is None
+    assert (p**n).is_odd is None
+
+    assert (k**x).is_odd is None
+    assert (n**x).is_odd is None
+
+
+def test_Pow_is_negative_positive():
+    r = Symbol('r', real=True)
+
+    k = Symbol('k', integer=True, positive=True)
+    n = Symbol('n', even=True)
+    m = Symbol('m', odd=True)
+
+    x = Symbol('x')
+
+    assert (2**r).is_positive is True
+    assert ((-2)**r).is_positive is None
+    assert ((-2)**n).is_positive is True
+    assert ((-2)**m).is_positive is False
+
+    assert (k**2).is_positive is True
+    assert (k**(-2)).is_positive is True
+
+    assert (k**r).is_positive is True
+    assert ((-k)**r).is_positive is None
+    assert ((-k)**n).is_positive is True
+    assert ((-k)**m).is_positive is False
+
+    assert (2**r).is_negative is False
+    assert ((-2)**r).is_negative is None
+    assert ((-2)**n).is_negative is False
+    assert ((-2)**m).is_negative is True
+
+    assert (k**2).is_negative is False
+    assert (k**(-2)).is_negative is False
+
+    assert (k**r).is_negative is False
+    assert ((-k)**r).is_negative is None
+    assert ((-k)**n).is_negative is False
+    assert ((-k)**m).is_negative is True
+
+    assert (2**x).is_positive is None
+    assert (2**x).is_negative is None
+
+
+def test_Pow_is_zero():
+    z = Symbol('z', zero=True)
+    e = z**2
+    assert e.is_zero
+    assert e.is_positive is False
+    assert e.is_negative is False
+
+    assert Pow(0, 0, evaluate=False).is_zero is False
+    assert Pow(0, 3, evaluate=False).is_zero
+    assert Pow(0, oo, evaluate=False).is_zero
+    assert Pow(0, -3, evaluate=False).is_zero is False
+    assert Pow(0, -oo, evaluate=False).is_zero is False
+    assert Pow(2, 2, evaluate=False).is_zero is False
+
+    a = Symbol('a', zero=False)
+    assert Pow(a, 3).is_zero is False  # issue 7965
+
+    assert Pow(2, oo, evaluate=False).is_zero is False
+    assert Pow(2, -oo, evaluate=False).is_zero
+    assert Pow(S.Half, oo, evaluate=False).is_zero
+    assert Pow(S.Half, -oo, evaluate=False).is_zero is False
+
+    # All combinations of real/complex base/exponent
+    h = S.Half
+    T = True
+    F = False
+    N = None
+
+    pow_iszero = [
+        ['**',  0,  h,  1,  2, -h, -1,-2,-2*I,-I/2,I/2,1+I,oo,-oo,zoo],
+        [   0,  F,  T,  T,  T,  F,  F,  F,  F,  F,  F,  N,  T,  F,  N],
+        [   h,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [   1,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  N],
+        [   2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [  -h,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [  -1,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  N],
+        [  -2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [-2*I,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [-I/2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [ I/2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [ 1+I,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [  oo,  F,  F,  F,  F,  T,  T,  T,  F,  F,  F,  F,  F,  T,  N],
+        [ -oo,  F,  F,  F,  F,  T,  T,  T,  F,  F,  F,  F,  F,  T,  N],
+        [ zoo,  F,  F,  F,  F,  T,  T,  T,  N,  N,  N,  N,  F,  T,  N]
+    ]
+
+    def test_table(table):
+        n = len(table[0])
+        for row in range(1, n):
+            base = table[row][0]
+            for col in range(1, n):
+                exp = table[0][col]
+                is_zero = table[row][col]
+                # The actual test here:
+                assert Pow(base, exp, evaluate=False).is_zero is is_zero
+
+    test_table(pow_iszero)
+
+    # A zero symbol...
+    zo, zo2 = symbols('zo, zo2', zero=True)
+
+    # All combinations of finite symbols
+    zf, zf2 = symbols('zf, zf2', finite=True)
+    wf, wf2 = symbols('wf, wf2', nonzero=True)
+    xf, xf2 = symbols('xf, xf2', real=True)
+    yf, yf2 = symbols('yf, yf2', nonzero=True)
+    af, af2 = symbols('af, af2', positive=True)
+    bf, bf2 = symbols('bf, bf2', nonnegative=True)
+    cf, cf2 = symbols('cf, cf2', negative=True)
+    df, df2 = symbols('df, df2', nonpositive=True)
+
+    # Without finiteness:
+    zi, zi2 = symbols('zi, zi2')
+    wi, wi2 = symbols('wi, wi2', zero=False)
+    xi, xi2 = symbols('xi, xi2', extended_real=True)
+    yi, yi2 = symbols('yi, yi2', zero=False, extended_real=True)
+    ai, ai2 = symbols('ai, ai2', extended_positive=True)
+    bi, bi2 = symbols('bi, bi2', extended_nonnegative=True)
+    ci, ci2 = symbols('ci, ci2', extended_negative=True)
+    di, di2 = symbols('di, di2', extended_nonpositive=True)
+
+    pow_iszero_sym = [
+        ['**',zo,wf,yf,af,cf,zf,xf,bf,df,zi,wi,xi,yi,ai,bi,ci,di],
+        [ zo2, F, N, N, T, F, N, N, N, F, N, N, N, N, T, N, F, F],
+        [ wf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ yf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ af2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ cf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ zf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ xf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ bf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ df2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ zi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ wi2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ xi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ yi2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ ai2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ bi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ ci2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ di2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N]
+    ]
+
+    test_table(pow_iszero_sym)
+
+    # In some cases (x**x).is_zero is different from (x**y).is_zero even if y
+    # has the same assumptions as x.
+    assert (zo ** zo).is_zero is False
+    assert (wf ** wf).is_zero is False
+    assert (yf ** yf).is_zero is False
+    assert (af ** af).is_zero is False
+    assert (cf ** cf).is_zero is False
+    assert (zf ** zf).is_zero is None
+    assert (xf ** xf).is_zero is None
+    assert (bf ** bf).is_zero is False # None in table
+    assert (df ** df).is_zero is None
+    assert (zi ** zi).is_zero is None
+    assert (wi ** wi).is_zero is None
+    assert (xi ** xi).is_zero is None
+    assert (yi ** yi).is_zero is None
+    assert (ai ** ai).is_zero is False # None in table
+    assert (bi ** bi).is_zero is False # None in table
+    assert (ci ** ci).is_zero is None
+    assert (di ** di).is_zero is None
+
+
+def test_Pow_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', integer=True, nonnegative=True)
+    l = Symbol('l', integer=True, positive=True)
+    n = Symbol('n', even=True)
+    m = Symbol('m', odd=True)
+
+    assert (x**(4*k)).is_nonnegative is True
+    assert (2**x).is_nonnegative is True
+    assert ((-2)**x).is_nonnegative is None
+    assert ((-2)**n).is_nonnegative is True
+    assert ((-2)**m).is_nonnegative is False
+
+    assert (k**2).is_nonnegative is True
+    assert (k**(-2)).is_nonnegative is None
+    assert (k**k).is_nonnegative is True
+
+    assert (k**x).is_nonnegative is None    # NOTE (0**x).is_real = U
+    assert (l**x).is_nonnegative is True
+    assert (l**x).is_positive is True
+    assert ((-k)**x).is_nonnegative is None
+
+    assert ((-k)**m).is_nonnegative is None
+
+    assert (2**x).is_nonpositive is False
+    assert ((-2)**x).is_nonpositive is None
+    assert ((-2)**n).is_nonpositive is False
+    assert ((-2)**m).is_nonpositive is True
+
+    assert (k**2).is_nonpositive is None
+    assert (k**(-2)).is_nonpositive is None
+
+    assert (k**x).is_nonpositive is None
+    assert ((-k)**x).is_nonpositive is None
+    assert ((-k)**n).is_nonpositive is None
+
+
+    assert (x**2).is_nonnegative is True
+    i = symbols('i', imaginary=True)
+    assert (i**2).is_nonpositive is True
+    assert (i**4).is_nonpositive is False
+    assert (i**3).is_nonpositive is False
+    assert (I**i).is_nonnegative is True
+    assert (exp(I)**i).is_nonnegative is True
+
+    assert ((-l)**n).is_nonnegative is True
+    assert ((-l)**m).is_nonpositive is True
+    assert ((-k)**n).is_nonnegative is None
+    assert ((-k)**m).is_nonpositive is None
+
+
+def test_Mul_is_imaginary_real():
+    r = Symbol('r', real=True)
+    p = Symbol('p', positive=True)
+    i1 = Symbol('i1', imaginary=True)
+    i2 = Symbol('i2', imaginary=True)
+    x = Symbol('x')
+
+    assert I.is_imaginary is True
+    assert I.is_real is False
+    assert (-I).is_imaginary is True
+    assert (-I).is_real is False
+    assert (3*I).is_imaginary is True
+    assert (3*I).is_real is False
+    assert (I*I).is_imaginary is False
+    assert (I*I).is_real is True
+
+    e = (p + p*I)
+    j = Symbol('j', integer=True, zero=False)
+    assert (e**j).is_real is None
+    assert (e**(2*j)).is_real is None
+    assert (e**j).is_imaginary is None
+    assert (e**(2*j)).is_imaginary is None
+
+    assert (e**-1).is_imaginary is False
+    assert (e**2).is_imaginary
+    assert (e**3).is_imaginary is False
+    assert (e**4).is_imaginary is False
+    assert (e**5).is_imaginary is False
+    assert (e**-1).is_real is False
+    assert (e**2).is_real is False
+    assert (e**3).is_real is False
+    assert (e**4).is_real is True
+    assert (e**5).is_real is False
+    assert (e**3).is_complex
+
+    assert (r*i1).is_imaginary is None
+    assert (r*i1).is_real is None
+
+    assert (x*i1).is_imaginary is None
+    assert (x*i1).is_real is None
+
+    assert (i1*i2).is_imaginary is False
+    assert (i1*i2).is_real is True
+
+    assert (r*i1*i2).is_imaginary is False
+    assert (r*i1*i2).is_real is True
+
+    # Github's issue 5874:
+    nr = Symbol('nr', real=False, complex=True)  # e.g. I or 1 + I
+    a = Symbol('a', real=True, nonzero=True)
+    b = Symbol('b', real=True)
+    assert (i1*nr).is_real is None
+    assert (a*nr).is_real is False
+    assert (b*nr).is_real is None
+
+    ni = Symbol('ni', imaginary=False, complex=True)  # e.g. 2 or 1 + I
+    a = Symbol('a', real=True, nonzero=True)
+    b = Symbol('b', real=True)
+    assert (i1*ni).is_real is False
+    assert (a*ni).is_real is None
+    assert (b*ni).is_real is None
+
+
+def test_Mul_hermitian_antihermitian():
+    xz, yz = symbols('xz, yz', zero=True, antihermitian=True)
+    xf, yf = symbols('xf, yf', hermitian=False, antihermitian=False, finite=True)
+    xh, yh = symbols('xh, yh', hermitian=True, antihermitian=False, nonzero=True)
+    xa, ya = symbols('xa, ya', hermitian=False, antihermitian=True, zero=False, finite=True)
+    assert (xz*xh).is_hermitian is True
+    assert (xz*xh).is_antihermitian is True
+    assert (xz*xa).is_hermitian is True
+    assert (xz*xa).is_antihermitian is True
+    assert (xf*yf).is_hermitian is None
+    assert (xf*yf).is_antihermitian is None
+    assert (xh*yh).is_hermitian is True
+    assert (xh*yh).is_antihermitian is False
+    assert (xh*ya).is_hermitian is False
+    assert (xh*ya).is_antihermitian is True
+    assert (xa*ya).is_hermitian is True
+    assert (xa*ya).is_antihermitian is False
+
+    a = Symbol('a', hermitian=True, zero=False)
+    b = Symbol('b', hermitian=True)
+    c = Symbol('c', hermitian=False)
+    d = Symbol('d', antihermitian=True)
+    e1 = Mul(a, b, c, evaluate=False)
+    e2 = Mul(b, a, c, evaluate=False)
+    e3 = Mul(a, b, c, d, evaluate=False)
+    e4 = Mul(b, a, c, d, evaluate=False)
+    e5 = Mul(a, c, evaluate=False)
+    e6 = Mul(a, c, d, evaluate=False)
+    assert e1.is_hermitian is None
+    assert e2.is_hermitian is None
+    assert e1.is_antihermitian is None
+    assert e2.is_antihermitian is None
+    assert e3.is_antihermitian is None
+    assert e4.is_antihermitian is None
+    assert e5.is_antihermitian is None
+    assert e6.is_antihermitian is None
+
+
+def test_Add_is_comparable():
+    assert (x + y).is_comparable is False
+    assert (x + 1).is_comparable is False
+    assert (Rational(1, 3) - sqrt(8)).is_comparable is True
+
+
+def test_Mul_is_comparable():
+    assert (x*y).is_comparable is False
+    assert (x*2).is_comparable is False
+    assert (sqrt(2)*Rational(1, 3)).is_comparable is True
+
+
+def test_Pow_is_comparable():
+    assert (x**y).is_comparable is False
+    assert (x**2).is_comparable is False
+    assert (sqrt(Rational(1, 3))).is_comparable is True
+
+
+def test_Add_is_positive_2():
+    e = Rational(1, 3) - sqrt(8)
+    assert e.is_positive is False
+    assert e.is_negative is True
+
+    e = pi - 1
+    assert e.is_positive is True
+    assert e.is_negative is False
+
+
+def test_Add_is_irrational():
+    i = Symbol('i', irrational=True)
+
+    assert i.is_irrational is True
+    assert i.is_rational is False
+
+    assert (i + 1).is_irrational is True
+    assert (i + 1).is_rational is False
+
+
+def test_Mul_is_irrational():
+    expr = Mul(1, 2, 3, evaluate=False)
+    assert expr.is_irrational is False
+    expr = Mul(1, I, I, evaluate=False)
+    assert expr.is_rational is None # I * I = -1 but *no evaluation allowed*
+    # sqrt(2) * I * I = -sqrt(2) is irrational but
+    # this can't be determined without evaluating the
+    # expression and the eval_is routines shouldn't do that
+    expr = Mul(sqrt(2), I, I, evaluate=False)
+    assert expr.is_irrational is None
+
+
+def test_issue_3531():
+    # https://github.com/sympy/sympy/issues/3531
+    # https://github.com/sympy/sympy/pull/18116
+    class MightyNumeric(tuple):
+        def __rtruediv__(self, other):
+            return "something"
+
+    assert sympify(1)/MightyNumeric((1, 2)) == "something"
+
+
+def test_issue_3531b():
+    class Foo:
+        def __init__(self):
+            self.field = 1.0
+
+        def __mul__(self, other):
+            self.field = self.field * other
+
+        def __rmul__(self, other):
+            self.field = other * self.field
+    f = Foo()
+    x = Symbol("x")
+    assert f*x == x*f
+
+
+def test_bug3():
+    a = Symbol("a")
+    b = Symbol("b", positive=True)
+    e = 2*a + b
+    f = b + 2*a
+    assert e == f
+
+
+def test_suppressed_evaluation():
+    a = Add(0, 3, 2, evaluate=False)
+    b = Mul(1, 3, 2, evaluate=False)
+    c = Pow(3, 2, evaluate=False)
+    assert a != 6
+    assert a.func is Add
+    assert a.args == (0, 3, 2)
+    assert b != 6
+    assert b.func is Mul
+    assert b.args == (1, 3, 2)
+    assert c != 9
+    assert c.func is Pow
+    assert c.args == (3, 2)
+
+
+def test_AssocOp_doit():
+    a = Add(x,x, evaluate=False)
+    b = Mul(y,y, evaluate=False)
+    c = Add(b,b, evaluate=False)
+    d = Mul(a,a, evaluate=False)
+    assert c.doit(deep=False).func == Mul
+    assert c.doit(deep=False).args == (2,y,y)
+    assert c.doit().func == Mul
+    assert c.doit().args == (2, Pow(y,2))
+    assert d.doit(deep=False).func == Pow
+    assert d.doit(deep=False).args == (a, 2*S.One)
+    assert d.doit().func == Mul
+    assert d.doit().args == (4*S.One, Pow(x,2))
+
+
+def test_Add_Mul_Expr_args():
+    nonexpr = [Basic(), Poly(x, x), FiniteSet(x)]
+    for typ in [Add, Mul]:
+        for obj in nonexpr:
+            # The cache can mess with the stacklevel check
+            with warns(SymPyDeprecationWarning, test_stacklevel=False):
+                typ(obj, 1)
+
+
+def test_Add_as_coeff_mul():
+    # issue 5524.  These should all be (1, self)
+    assert (x + 1).as_coeff_mul() == (1, (x + 1,))
+    assert (x + 2).as_coeff_mul() == (1, (x + 2,))
+    assert (x + 3).as_coeff_mul() == (1, (x + 3,))
+
+    assert (x - 1).as_coeff_mul() == (1, (x - 1,))
+    assert (x - 2).as_coeff_mul() == (1, (x - 2,))
+    assert (x - 3).as_coeff_mul() == (1, (x - 3,))
+
+    n = Symbol('n', integer=True)
+    assert (n + 1).as_coeff_mul() == (1, (n + 1,))
+    assert (n + 2).as_coeff_mul() == (1, (n + 2,))
+    assert (n + 3).as_coeff_mul() == (1, (n + 3,))
+
+    assert (n - 1).as_coeff_mul() == (1, (n - 1,))
+    assert (n - 2).as_coeff_mul() == (1, (n - 2,))
+    assert (n - 3).as_coeff_mul() == (1, (n - 3,))
+
+
+def test_Pow_as_coeff_mul_doesnt_expand():
+    assert exp(x + y).as_coeff_mul() == (1, (exp(x + y),))
+    assert exp(x + exp(x + y)) != exp(x + exp(x)*exp(y))
+
+def test_issue_24751():
+    expr = Add(-2, -3, evaluate=False)
+    expr1 = Add(-1, expr, evaluate=False)
+    assert int(expr1) == int((-3 - 2) - 1)
+
+
+def test_issue_3514_18626():
+    assert sqrt(S.Half) * sqrt(6) == 2 * sqrt(3)/2
+    assert S.Half*sqrt(6)*sqrt(2) == sqrt(3)
+    assert sqrt(6)/2*sqrt(2) == sqrt(3)
+    assert sqrt(6)*sqrt(2)/2 == sqrt(3)
+    assert sqrt(8)**Rational(2, 3) == 2
+
+
+def test_make_args():
+    assert Add.make_args(x) == (x,)
+    assert Mul.make_args(x) == (x,)
+
+    assert Add.make_args(x*y*z) == (x*y*z,)
+    assert Mul.make_args(x*y*z) == (x*y*z).args
+
+    assert Add.make_args(x + y + z) == (x + y + z).args
+    assert Mul.make_args(x + y + z) == (x + y + z,)
+
+    assert Add.make_args((x + y)**z) == ((x + y)**z,)
+    assert Mul.make_args((x + y)**z) == ((x + y)**z,)
+
+
+def test_issue_5126():
+    assert (-2)**x*(-3)**x != 6**x
+    i = Symbol('i', integer=1)
+    assert (-2)**i*(-3)**i == 6**i
+
+
+def test_Rational_as_content_primitive():
+    c, p = S.One, S.Zero
+    assert (c*p).as_content_primitive() == (c, p)
+    c, p = S.Half, S.One
+    assert (c*p).as_content_primitive() == (c, p)
+
+
+def test_Add_as_content_primitive():
+    assert (x + 2).as_content_primitive() == (1, x + 2)
+
+    assert (3*x + 2).as_content_primitive() == (1, 3*x + 2)
+    assert (3*x + 3).as_content_primitive() == (3, x + 1)
+    assert (3*x + 6).as_content_primitive() == (3, x + 2)
+
+    assert (3*x + 2*y).as_content_primitive() == (1, 3*x + 2*y)
+    assert (3*x + 3*y).as_content_primitive() == (3, x + y)
+    assert (3*x + 6*y).as_content_primitive() == (3, x + 2*y)
+
+    assert (3/x + 2*x*y*z**2).as_content_primitive() == (1, 3/x + 2*x*y*z**2)
+    assert (3/x + 3*x*y*z**2).as_content_primitive() == (3, 1/x + x*y*z**2)
+    assert (3/x + 6*x*y*z**2).as_content_primitive() == (3, 1/x + 2*x*y*z**2)
+
+    assert (2*x/3 + 4*y/9).as_content_primitive() == \
+        (Rational(2, 9), 3*x + 2*y)
+    assert (2*x/3 + 2.5*y).as_content_primitive() == \
+        (Rational(1, 3), 2*x + 7.5*y)
+
+    # the coefficient may sort to a position other than 0
+    p = 3 + x + y
+    assert (2*p).expand().as_content_primitive() == (2, p)
+    assert (2.0*p).expand().as_content_primitive() == (1, 2.*p)
+    p *= -1
+    assert (2*p).expand().as_content_primitive() == (2, p)
+
+
+def test_Mul_as_content_primitive():
+    assert (2*x).as_content_primitive() == (2, x)
+    assert (x*(2 + 2*x)).as_content_primitive() == (2, x*(1 + x))
+    assert (x*(2 + 2*y)*(3*x + 3)**2).as_content_primitive() == \
+        (18, x*(1 + y)*(x + 1)**2)
+    assert ((2 + 2*x)**2*(3 + 6*x) + S.Half).as_content_primitive() == \
+        (S.Half, 24*(x + 1)**2*(2*x + 1) + 1)
+
+
+def test_Pow_as_content_primitive():
+    assert (x**y).as_content_primitive() == (1, x**y)
+    assert ((2*x + 2)**y).as_content_primitive() == \
+        (1, (Mul(2, (x + 1), evaluate=False))**y)
+    assert ((2*x + 2)**3).as_content_primitive() == (8, (x + 1)**3)
+
+
+def test_issue_5460():
+    u = Mul(2, (1 + x), evaluate=False)
+    assert (2 + u).args == (2, u)
+
+
+def test_product_irrational():
+    assert (I*pi).is_irrational is False
+    # The following used to be deduced from the above bug:
+    assert (I*pi).is_positive is False
+
+
+def test_issue_5919():
+    assert (x/(y*(1 + y))).expand() == x/(y**2 + y)
+
+
+def test_Mod():
+    assert Mod(x, 1).func is Mod
+    assert pi % pi is S.Zero
+    assert Mod(5, 3) == 2
+    assert Mod(-5, 3) == 1
+    assert Mod(5, -3) == -1
+    assert Mod(-5, -3) == -2
+    assert type(Mod(3.2, 2, evaluate=False)) == Mod
+    assert 5 % x == Mod(5, x)
+    assert x % 5 == Mod(x, 5)
+    assert x % y == Mod(x, y)
+    assert (x % y).subs({x: 5, y: 3}) == 2
+    assert Mod(nan, 1) is nan
+    assert Mod(1, nan) is nan
+    assert Mod(nan, nan) is nan
+
+    assert Mod(0, x) == 0
+    with raises(ZeroDivisionError):
+        Mod(x, 0)
+
+    k = Symbol('k', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    assert (x**m % x).func is Mod
+    assert (k**(-m) % k).func is Mod
+    assert k**m % k == 0
+    assert (-2*k)**m % k == 0
+
+    # Float handling
+    point3 = Float(3.3) % 1
+    assert (x - 3.3) % 1 == Mod(1.*x + 1 - point3, 1)
+    assert Mod(-3.3, 1) == 1 - point3
+    assert Mod(0.7, 1) == Float(0.7)
+    e = Mod(1.3, 1)
+    assert comp(e, .3) and e.is_Float
+    e = Mod(1.3, .7)
+    assert comp(e, .6) and e.is_Float
+    e = Mod(1.3, Rational(7, 10))
+    assert comp(e, .6) and e.is_Float
+    e = Mod(Rational(13, 10), 0.7)
+    assert comp(e, .6) and e.is_Float
+    e = Mod(Rational(13, 10), Rational(7, 10))
+    assert comp(e, .6) and e.is_Rational
+
+    # check that sign is right
+    r2 = sqrt(2)
+    r3 = sqrt(3)
+    for i in [-r3, -r2, r2, r3]:
+        for j in [-r3, -r2, r2, r3]:
+            assert verify_numerically(i % j, i.n() % j.n())
+    for _x in range(4):
+        for _y in range(9):
+            reps = [(x, _x), (y, _y)]
+            assert Mod(3*x + y, 9).subs(reps) == (3*_x + _y) % 9
+
+    # denesting
+    t = Symbol('t', real=True)
+    assert Mod(Mod(x, t), t) == Mod(x, t)
+    assert Mod(-Mod(x, t), t) == Mod(-x, t)
+    assert Mod(Mod(x, 2*t), t) == Mod(x, t)
+    assert Mod(-Mod(x, 2*t), t) == Mod(-x, t)
+    assert Mod(Mod(x, t), 2*t) == Mod(x, t)
+    assert Mod(-Mod(x, t), -2*t) == -Mod(x, t)
+    for i in [-4, -2, 2, 4]:
+        for j in [-4, -2, 2, 4]:
+            for k in range(4):
+                assert Mod(Mod(x, i), j).subs({x: k}) == (k % i) % j
+                assert Mod(-Mod(x, i), j).subs({x: k}) == -(k % i) % j
+
+    # known difference
+    assert Mod(5*sqrt(2), sqrt(5)) == 5*sqrt(2) - 3*sqrt(5)
+    p = symbols('p', positive=True)
+    assert Mod(2, p + 3) == 2
+    assert Mod(-2, p + 3) == p + 1
+    assert Mod(2, -p - 3) == -p - 1
+    assert Mod(-2, -p - 3) == -2
+    assert Mod(p + 5, p + 3) == 2
+    assert Mod(-p - 5, p + 3) == p + 1
+    assert Mod(p + 5, -p - 3) == -p - 1
+    assert Mod(-p - 5, -p - 3) == -2
+    assert Mod(p + 1, p - 1).func is Mod
+
+    # handling sums
+    assert (x + 3) % 1 == Mod(x, 1)
+    assert (x + 3.0) % 1 == Mod(1.*x, 1)
+    assert (x - S(33)/10) % 1 == Mod(x + S(7)/10, 1)
+
+    a = Mod(.6*x + y, .3*y)
+    b = Mod(0.1*y + 0.6*x, 0.3*y)
+    # Test that a, b are equal, with 1e-14 accuracy in coefficients
+    eps = 1e-14
+    assert abs((a.args[0] - b.args[0]).subs({x: 1, y: 1})) < eps
+    assert abs((a.args[1] - b.args[1]).subs({x: 1, y: 1})) < eps
+
+    assert (x + 1) % x == 1 % x
+    assert (x + y) % x == y % x
+    assert (x + y + 2) % x == (y + 2) % x
+    assert (a + 3*x + 1) % (2*x) == Mod(a + x + 1, 2*x)
+    assert (12*x + 18*y) % (3*x) == 3*Mod(6*y, x)
+
+    # gcd extraction
+    assert (-3*x) % (-2*y) == -Mod(3*x, 2*y)
+    assert (.6*pi) % (.3*x*pi) == 0.3*pi*Mod(2, x)
+    assert (.6*pi) % (.31*x*pi) == pi*Mod(0.6, 0.31*x)
+    assert (6*pi) % (.3*x*pi) == 0.3*pi*Mod(20, x)
+    assert (6*pi) % (.31*x*pi) == pi*Mod(6, 0.31*x)
+    assert (6*pi) % (.42*x*pi) == pi*Mod(6, 0.42*x)
+    assert (12*x) % (2*y) == 2*Mod(6*x, y)
+    assert (12*x) % (3*5*y) == 3*Mod(4*x, 5*y)
+    assert (12*x) % (15*x*y) == 3*x*Mod(4, 5*y)
+    assert (-2*pi) % (3*pi) == pi
+    assert (2*x + 2) % (x + 1) == 0
+    assert (x*(x + 1)) % (x + 1) == (x + 1)*Mod(x, 1)
+    assert Mod(5.0*x, 0.1*y) == 0.1*Mod(50*x, y)
+    i = Symbol('i', integer=True)
+    assert (3*i*x) % (2*i*y) == i*Mod(3*x, 2*y)
+    assert Mod(4*i, 4) == 0
+
+    # issue 8677
+    n = Symbol('n', integer=True, positive=True)
+    assert factorial(n) % n == 0
+    assert factorial(n + 2) % n == 0
+    assert (factorial(n + 4) % (n + 5)).func is Mod
+
+    # Wilson's theorem
+    assert factorial(18042, evaluate=False) % 18043 == 18042
+    p = Symbol('n', prime=True)
+    assert factorial(p - 1) % p == p - 1
+    assert factorial(p - 1) % -p == -1
+    assert (factorial(3, evaluate=False) % 4).doit() == 2
+    n = Symbol('n', composite=True, odd=True)
+    assert factorial(n - 1) % n == 0
+
+    # symbolic with known parity
+    n = Symbol('n', even=True)
+    assert Mod(n, 2) == 0
+    n = Symbol('n', odd=True)
+    assert Mod(n, 2) == 1
+
+    # issue 10963
+    assert (x**6000%400).args[1] == 400
+
+    #issue 13543
+    assert Mod(Mod(x + 1, 2) + 1, 2) == Mod(x, 2)
+
+    x1 = Symbol('x1', integer=True)
+    assert Mod(Mod(x1 + 2, 4)*(x1 + 4), 4) == Mod(x1*(x1 + 2), 4)
+    assert Mod(Mod(x1 + 2, 4)*4, 4) == 0
+
+    # issue 15493
+    i, j = symbols('i j', integer=True, positive=True)
+    assert Mod(3*i, 2) == Mod(i, 2)
+    assert Mod(8*i/j, 4) == 4*Mod(2*i/j, 1)
+    assert Mod(8*i, 4) == 0
+
+    # rewrite
+    assert Mod(x, y).rewrite(floor) == x - y*floor(x/y)
+    assert ((x - Mod(x, y))/y).rewrite(floor) == floor(x/y)
+
+    # issue 21373
+    from sympy.functions.elementary.hyperbolic import sinh
+    from sympy.functions.elementary.piecewise import Piecewise
+
+    x_r, y_r = symbols('x_r y_r', real=True)
+    assert (Piecewise((x_r, y_r > x_r), (y_r, True)) / z) % 1
+    expr = exp(sinh(Piecewise((x_r, y_r > x_r), (y_r, True)) / z))
+    expr.subs({1: 1.0})
+    sinh(Piecewise((x_r, y_r > x_r), (y_r, True)) * z ** -1.0).is_zero
+
+    # issue 24215
+    from sympy.abc import phi
+    assert Mod(4.0*Mod(phi, 1) , 2) == 2.0*(Mod(2*(Mod(phi, 1)), 1))
+
+
+def test_Mod_Pow():
+    # modular exponentiation
+    assert isinstance(Mod(Pow(2, 2, evaluate=False), 3), Integer)
+
+    assert Mod(Pow(4, 13, evaluate=False), 497) == Mod(Pow(4, 13), 497)
+    assert Mod(Pow(2, 10000000000, evaluate=False), 3) == 1
+    assert Mod(Pow(32131231232, 9**10**6, evaluate=False),10**12) == \
+        pow(32131231232,9**10**6,10**12)
+    assert Mod(Pow(33284959323, 123**999, evaluate=False),11**13) == \
+        pow(33284959323,123**999,11**13)
+    assert Mod(Pow(78789849597, 333**555, evaluate=False),12**9) == \
+        pow(78789849597,333**555,12**9)
+
+    # modular nested exponentiation
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 16
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 6487
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 32191
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 18016
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 5137
+
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 16
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 256
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 6487
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 38281
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 15928
+
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 256
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 9229
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 25708
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 26608
+    expr = Pow(expr, expr, evaluate=False)
+    # XXX This used to fail in a nondeterministic way because of overflow
+    # error.
+    assert Mod(expr, 3**10) == 1966
+
+
+def test_Mod_is_integer():
+    p = Symbol('p', integer=True)
+    q1 = Symbol('q1', integer=True)
+    q2 = Symbol('q2', integer=True, nonzero=True)
+    assert Mod(x, y).is_integer is None
+    assert Mod(p, q1).is_integer is None
+    assert Mod(x, q2).is_integer is None
+    assert Mod(p, q2).is_integer
+
+
+def test_Mod_is_nonposneg():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, positive=True)
+    assert (n%3).is_nonnegative
+    assert Mod(n, -3).is_nonpositive
+    assert Mod(n, k).is_nonnegative
+    assert Mod(n, -k).is_nonpositive
+    assert Mod(k, n).is_nonnegative is None
+
+
+def test_issue_6001():
+    A = Symbol("A", commutative=False)
+    eq = A + A**2
+    # it doesn't matter whether it's True or False; they should
+    # just all be the same
+    assert (
+        eq.is_commutative ==
+        (eq + 1).is_commutative ==
+        (A + 1).is_commutative)
+
+    B = Symbol("B", commutative=False)
+    # Although commutative terms could cancel we return True
+    # meaning "there are non-commutative symbols; aftersubstitution
+    # that definition can change, e.g. (A*B).subs(B,A**-1) -> 1
+    assert (sqrt(2)*A).is_commutative is False
+    assert (sqrt(2)*A*B).is_commutative is False
+
+
+def test_polar():
+    from sympy.functions.elementary.complexes import polar_lift
+    p = Symbol('p', polar=True)
+    x = Symbol('x')
+    assert p.is_polar
+    assert x.is_polar is None
+    assert S.One.is_polar is None
+    assert (p**x).is_polar is True
+    assert (x**p).is_polar is None
+    assert ((2*p)**x).is_polar is True
+    assert (2*p).is_polar is True
+    assert (-2*p).is_polar is not True
+    assert (polar_lift(-2)*p).is_polar is True
+
+    q = Symbol('q', polar=True)
+    assert (p*q)**2 == p**2 * q**2
+    assert (2*q)**2 == 4 * q**2
+    assert ((p*q)**x).expand() == p**x * q**x
+
+
+def test_issue_6040():
+    a, b = Pow(1, 2, evaluate=False), S.One
+    assert a != b
+    assert b != a
+    assert not (a == b)
+    assert not (b == a)
+
+
+def test_issue_6082():
+    # Comparison is symmetric
+    assert Basic.compare(Max(x, 1), Max(x, 2)) == \
+      - Basic.compare(Max(x, 2), Max(x, 1))
+    # Equal expressions compare equal
+    assert Basic.compare(Max(x, 1), Max(x, 1)) == 0
+    # Basic subtypes (such as Max) compare different than standard types
+    assert Basic.compare(Max(1, x), frozenset((1, x))) != 0
+
+
+def test_issue_6077():
+    assert x**2.0/x == x**1.0
+    assert x/x**2.0 == x**-1.0
+    assert x*x**2.0 == x**3.0
+    assert x**1.5*x**2.5 == x**4.0
+
+    assert 2**(2.0*x)/2**x == 2**(1.0*x)
+    assert 2**x/2**(2.0*x) == 2**(-1.0*x)
+    assert 2**x*2**(2.0*x) == 2**(3.0*x)
+    assert 2**(1.5*x)*2**(2.5*x) == 2**(4.0*x)
+
+
+def test_mul_flatten_oo():
+    p = symbols('p', positive=True)
+    n, m = symbols('n,m', negative=True)
+    x_im = symbols('x_im', imaginary=True)
+    assert n*oo is -oo
+    assert n*m*oo is oo
+    assert p*oo is oo
+    assert x_im*oo != I*oo  # i could be +/- 3*I -> +/-oo
+
+
+def test_add_flatten():
+    # see https://github.com/sympy/sympy/issues/2633#issuecomment-29545524
+    a = oo + I*oo
+    b = oo - I*oo
+    assert a + b is nan
+    assert a - b is nan
+    # FIXME: This evaluates as:
+    #   >>> 1/a
+    #   0*(oo + oo*I)
+    # which should not simplify to 0. Should be fixed in Pow.eval
+    #assert (1/a).simplify() == (1/b).simplify() == 0
+
+    a = Pow(2, 3, evaluate=False)
+    assert a + a == 16
+
+
+def test_issue_5160_6087_6089_6090():
+    # issue 6087
+    assert ((-2*x*y**y)**3.2).n(2) == (2**3.2*(-x*y**y)**3.2).n(2)
+    # issue 6089
+    A, B, C = symbols('A,B,C', commutative=False)
+    assert (2.*B*C)**3 == 8.0*(B*C)**3
+    assert (-2.*B*C)**3 == -8.0*(B*C)**3
+    assert (-2*B*C)**2 == 4*(B*C)**2
+    # issue 5160
+    assert sqrt(-1.0*x) == 1.0*sqrt(-x)
+    assert sqrt(1.0*x) == 1.0*sqrt(x)
+    # issue 6090
+    assert (-2*x*y*A*B)**2 == 4*x**2*y**2*(A*B)**2
+
+
+def test_float_int_round():
+    assert int(float(sqrt(10))) == int(sqrt(10))
+    assert int(pi**1000) % 10 == 2
+    assert int(Float('1.123456789012345678901234567890e20', '')) == \
+        int(112345678901234567890)
+    assert int(Float('1.123456789012345678901234567890e25', '')) == \
+        int(11234567890123456789012345)
+    # decimal forces float so it's not an exact integer ending in 000000
+    assert int(Float('1.123456789012345678901234567890e35', '')) == \
+        112345678901234567890123456789000192
+    assert int(Float('123456789012345678901234567890e5', '')) == \
+        12345678901234567890123456789000000
+    assert Integer(Float('1.123456789012345678901234567890e20', '')) == \
+        112345678901234567890
+    assert Integer(Float('1.123456789012345678901234567890e25', '')) == \
+        11234567890123456789012345
+    # decimal forces float so it's not an exact integer ending in 000000
+    assert Integer(Float('1.123456789012345678901234567890e35', '')) == \
+        112345678901234567890123456789000192
+    assert Integer(Float('123456789012345678901234567890e5', '')) == \
+        12345678901234567890123456789000000
+    assert same_and_same_prec(Float('123000e-2',''), Float('1230.00', ''))
+    assert same_and_same_prec(Float('123000e2',''), Float('12300000', ''))
+
+    assert int(1 + Rational('.9999999999999999999999999')) == 1
+    assert int(pi/1e20) == 0
+    assert int(1 + pi/1e20) == 1
+    assert int(Add(1.2, -2, evaluate=False)) == int(1.2 - 2)
+    assert int(Add(1.2, +2, evaluate=False)) == int(1.2 + 2)
+    assert int(Add(1 + Float('.99999999999999999', ''), evaluate=False)) == 1
+    raises(TypeError, lambda: float(x))
+    raises(TypeError, lambda: float(sqrt(-1)))
+
+    assert int(12345678901234567890 + cos(1)**2 + sin(1)**2) == \
+        12345678901234567891
+
+
+def test_issue_6611a():
+    assert Mul.flatten([3**Rational(1, 3),
+        Pow(-Rational(1, 9), Rational(2, 3), evaluate=False)]) == \
+        ([Rational(1, 3), (-1)**Rational(2, 3)], [], None)
+
+
+def test_denest_add_mul():
+    # when working with evaluated expressions make sure they denest
+    eq = x + 1
+    eq = Add(eq, 2, evaluate=False)
+    eq = Add(eq, 2, evaluate=False)
+    assert Add(*eq.args) == x + 5
+    eq = x*2
+    eq = Mul(eq, 2, evaluate=False)
+    eq = Mul(eq, 2, evaluate=False)
+    assert Mul(*eq.args) == 8*x
+    # but don't let them denest unnecessarily
+    eq = Mul(-2, x - 2, evaluate=False)
+    assert 2*eq == Mul(-4, x - 2, evaluate=False)
+    assert -eq == Mul(2, x - 2, evaluate=False)
+
+
+def test_mul_coeff():
+    # It is important that all Numbers be removed from the seq;
+    # This can be tricky when powers combine to produce those numbers
+    p = exp(I*pi/3)
+    assert p**2*x*p*y*p*x*p**2 == x**2*y
+
+
+def test_mul_zero_detection():
+    nz = Dummy(real=True, zero=False)
+    r = Dummy(extended_real=True)
+    c = Dummy(real=False, complex=True)
+    c2 = Dummy(real=False, complex=True)
+    i = Dummy(imaginary=True)
+    e = nz*r*c
+    assert e.is_imaginary is None
+    assert e.is_extended_real is None
+    e = nz*c
+    assert e.is_imaginary is None
+    assert e.is_extended_real is False
+    e = nz*i*c
+    assert e.is_imaginary is False
+    assert e.is_extended_real is None
+    # check for more than one complex; it is important to use
+    # uniquely named Symbols to ensure that two factors appear
+    # e.g. if the symbols have the same name they just become
+    # a single factor, a power.
+    e = nz*i*c*c2
+    assert e.is_imaginary is None
+    assert e.is_extended_real is None
+
+    # _eval_is_extended_real and _eval_is_zero both employ trapping of the
+    # zero value so args should be tested in both directions and
+    # TO AVOID GETTING THE CACHED RESULT, Dummy MUST BE USED
+
+    # real is unknown
+    def test(z, b, e):
+        if z.is_zero and b.is_finite:
+            assert e.is_extended_real and e.is_zero
+        else:
+            assert e.is_extended_real is None
+            if b.is_finite:
+                if z.is_zero:
+                    assert e.is_zero
+                else:
+                    assert e.is_zero is None
+            elif b.is_finite is False:
+                if z.is_zero is None:
+                    assert e.is_zero is None
+                else:
+                    assert e.is_zero is False
+
+
+    for iz, ib in product(*[[True, False, None]]*2):
+        z = Dummy('z', nonzero=iz)
+        b = Dummy('f', finite=ib)
+        e = Mul(z, b, evaluate=False)
+        test(z, b, e)
+        z = Dummy('nz', nonzero=iz)
+        b = Dummy('f', finite=ib)
+        e = Mul(b, z, evaluate=False)
+        test(z, b, e)
+
+    # real is True
+    def test(z, b, e):
+        if z.is_zero and not b.is_finite:
+            assert e.is_extended_real is None
+        else:
+            assert e.is_extended_real is True
+
+    for iz, ib in product(*[[True, False, None]]*2):
+        z = Dummy('z', nonzero=iz, extended_real=True)
+        b = Dummy('b', finite=ib, extended_real=True)
+        e = Mul(z, b, evaluate=False)
+        test(z, b, e)
+        z = Dummy('z', nonzero=iz, extended_real=True)
+        b = Dummy('b', finite=ib, extended_real=True)
+        e = Mul(b, z, evaluate=False)
+        test(z, b, e)
+
+
+def test_Mul_with_zero_infinite():
+    zer = Dummy(zero=True)
+    inf = Dummy(finite=False)
+
+    e = Mul(zer, inf, evaluate=False)
+    assert e.is_extended_positive is None
+    assert e.is_hermitian is None
+
+    e = Mul(inf, zer, evaluate=False)
+    assert e.is_extended_positive is None
+    assert e.is_hermitian is None
+
+
+def test_Mul_does_not_cancel_infinities():
+    a, b = symbols('a b')
+    assert ((zoo + 3*a)/(3*a + zoo)) is nan
+    assert ((b - oo)/(b - oo)) is nan
+    # issue 13904
+    expr = (1/(a+b) + 1/(a-b))/(1/(a+b) - 1/(a-b))
+    assert expr.subs(b, a) is nan
+
+
+def test_Mul_does_not_distribute_infinity():
+    a, b = symbols('a b')
+    assert ((1 + I)*oo).is_Mul
+    assert ((a + b)*(-oo)).is_Mul
+    assert ((a + 1)*zoo).is_Mul
+    assert ((1 + I)*oo).is_finite is False
+    z = (1 + I)*oo
+    assert ((1 - I)*z).expand() is oo
+
+
+def test_issue_8247_8354():
+    from sympy.functions.elementary.trigonometric import tan
+    z = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert z.is_positive is False  # it's 0
+    z = S('''-2**(1/3)*(3*sqrt(93) + 29)**2 - 4*(3*sqrt(93) + 29)**(4/3) +
+        12*sqrt(93)*(3*sqrt(93) + 29)**(1/3) + 116*(3*sqrt(93) + 29)**(1/3) +
+        174*2**(1/3)*sqrt(93) + 1678*2**(1/3)''')
+    assert z.is_positive is False  # it's 0
+    z = 2*(-3*tan(19*pi/90) + sqrt(3))*cos(11*pi/90)*cos(19*pi/90) - \
+        sqrt(3)*(-3 + 4*cos(19*pi/90)**2)
+    assert z.is_positive is not True  # it's zero and it shouldn't hang
+    z = S('''9*(3*sqrt(93) + 29)**(2/3)*((3*sqrt(93) +
+        29)**(1/3)*(-2**(2/3)*(3*sqrt(93) + 29)**(1/3) - 2) - 2*2**(1/3))**3 +
+        72*(3*sqrt(93) + 29)**(2/3)*(81*sqrt(93) + 783) + (162*sqrt(93) +
+        1566)*((3*sqrt(93) + 29)**(1/3)*(-2**(2/3)*(3*sqrt(93) + 29)**(1/3) -
+        2) - 2*2**(1/3))**2''')
+    assert z.is_positive is False  # it's 0 (and a single _mexpand isn't enough)
+
+
+def test_Add_is_zero():
+    x, y = symbols('x y', zero=True)
+    assert (x + y).is_zero
+
+    # Issue 15873
+    e = -2*I + (1 + I)**2
+    assert e.is_zero is None
+
+
+def test_issue_14392():
+    assert (sin(zoo)**2).as_real_imag() == (nan, nan)
+
+
+def test_divmod():
+    assert divmod(x, y) == (x//y, x % y)
+    assert divmod(x, 3) == (x//3, x % 3)
+    assert divmod(3, x) == (3//x, 3 % x)
+
+
+def test__neg__():
+    assert -(x*y) == -x*y
+    assert -(-x*y) == x*y
+    assert -(1.*x) == -1.*x
+    assert -(-1.*x) == 1.*x
+    assert -(2.*x) == -2.*x
+    assert -(-2.*x) == 2.*x
+    with distribute(False):
+        eq = -(x + y)
+        assert eq.is_Mul and eq.args == (-1, x + y)
+    with evaluate(False):
+        eq = -(x + y)
+        assert eq.is_Mul and eq.args == (-1, x + y)
+
+
+def test_issue_18507():
+    assert Mul(zoo, zoo, 0) is nan
+
+
+def test_issue_17130():
+    e = Add(b, -b, I, -I, evaluate=False)
+    assert e.is_zero is None # ideally this would be True
+
+
+def test_issue_21034():
+    e = -I*log((re(asin(5)) + I*im(asin(5)))/sqrt(re(asin(5))**2 + im(asin(5))**2))/pi
+    assert e.round(2)
+
+
+def test_issue_22021():
+    from sympy.calculus.accumulationbounds import AccumBounds
+    # these objects are special cases in Mul
+    from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads
+    L = TensorIndexType("L")
+    i = tensor_indices("i", L)
+    A, B = tensor_heads("A B", [L])
+    e = A(i) + B(i)
+    assert -e == -1*e
+    e = zoo + x
+    assert -e == -1*e
+    a = AccumBounds(1, 2)
+    e = a + x
+    assert -e == -1*e
+    for args in permutations((zoo, a, x)):
+        e = Add(*args, evaluate=False)
+        assert -e == -1*e
+    assert 2*Add(1, x, x, evaluate=False) == 4*x + 2
+
+
+def test_issue_22244():
+    assert -(zoo*x) == zoo*x
+
+
+def test_issue_22453():
+    from sympy.utilities.iterables import cartes
+    e = Symbol('e', extended_positive=True)
+    for a, b in cartes(*[[oo, -oo, 3]]*2):
+        if a == b == 3:
+            continue
+        i = a + I*b
+        assert i**(1 + e) is S.ComplexInfinity
+        assert i**-e is S.Zero
+        assert unchanged(Pow, i, e)
+    assert 1/(oo + I*oo) is S.Zero
+    r, i = [Dummy(infinite=True, extended_real=True) for _ in range(2)]
+    assert 1/(r + I*i) is S.Zero
+    assert 1/(3 + I*i) is S.Zero
+    assert 1/(r + I*3) is S.Zero
+
+
+def test_issue_22613():
+    assert (0**(x - 2)).as_content_primitive() == (1, 0**(x - 2))
+    assert (0**(x + 2)).as_content_primitive() == (1, 0**(x + 2))

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_assumptions.py

@@ -0,0 +1,1335 @@
+from sympy.core.mod import Mod
+from sympy.core.numbers import (I, oo, pi)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, sin)
+from sympy.simplify.simplify import simplify
+from sympy.core import Symbol, S, Rational, Integer, Dummy, Wild, Pow
+from sympy.core.assumptions import (assumptions, check_assumptions,
+    failing_assumptions, common_assumptions, _generate_assumption_rules,
+    _load_pre_generated_assumption_rules)
+from sympy.core.facts import InconsistentAssumptions
+from sympy.core.random import seed
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+def test_symbol_unset():
+    x = Symbol('x', real=True, integer=True)
+    assert x.is_real is True
+    assert x.is_integer is True
+    assert x.is_imaginary is False
+    assert x.is_noninteger is False
+    assert x.is_number is False
+
+
+def test_zero():
+    z = Integer(0)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is False
+    assert z.is_negative is False
+    assert z.is_nonpositive is True
+    assert z.is_nonnegative is True
+    assert z.is_even is True
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+    assert z.is_number is True
+
+
+def test_one():
+    z = Integer(1)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is True
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_number is True
+    assert z.is_composite is False  # issue 8807
+
+
+def test_negativeone():
+    z = Integer(-1)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is False
+    assert z.is_negative is True
+    assert z.is_nonpositive is True
+    assert z.is_nonnegative is False
+    assert z.is_even is False
+    assert z.is_odd is True
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+    assert z.is_number is True
+
+
+def test_infinity():
+    oo = S.Infinity
+
+    assert oo.is_commutative is True
+    assert oo.is_integer is False
+    assert oo.is_rational is False
+    assert oo.is_algebraic is False
+    assert oo.is_transcendental is False
+    assert oo.is_extended_real is True
+    assert oo.is_real is False
+    assert oo.is_complex is False
+    assert oo.is_noninteger is True
+    assert oo.is_irrational is False
+    assert oo.is_imaginary is False
+    assert oo.is_nonzero is False
+    assert oo.is_positive is False
+    assert oo.is_negative is False
+    assert oo.is_nonpositive is False
+    assert oo.is_nonnegative is False
+    assert oo.is_extended_nonzero is True
+    assert oo.is_extended_positive is True
+    assert oo.is_extended_negative is False
+    assert oo.is_extended_nonpositive is False
+    assert oo.is_extended_nonnegative is True
+    assert oo.is_even is False
+    assert oo.is_odd is False
+    assert oo.is_finite is False
+    assert oo.is_infinite is True
+    assert oo.is_comparable is True
+    assert oo.is_prime is False
+    assert oo.is_composite is False
+    assert oo.is_number is True
+
+
+def test_neg_infinity():
+    mm = S.NegativeInfinity
+
+    assert mm.is_commutative is True
+    assert mm.is_integer is False
+    assert mm.is_rational is False
+    assert mm.is_algebraic is False
+    assert mm.is_transcendental is False
+    assert mm.is_extended_real is True
+    assert mm.is_real is False
+    assert mm.is_complex is False
+    assert mm.is_noninteger is True
+    assert mm.is_irrational is False
+    assert mm.is_imaginary is False
+    assert mm.is_nonzero is False
+    assert mm.is_positive is False
+    assert mm.is_negative is False
+    assert mm.is_nonpositive is False
+    assert mm.is_nonnegative is False
+    assert mm.is_extended_nonzero is True
+    assert mm.is_extended_positive is False
+    assert mm.is_extended_negative is True
+    assert mm.is_extended_nonpositive is True
+    assert mm.is_extended_nonnegative is False
+    assert mm.is_even is False
+    assert mm.is_odd is False
+    assert mm.is_finite is False
+    assert mm.is_infinite is True
+    assert mm.is_comparable is True
+    assert mm.is_prime is False
+    assert mm.is_composite is False
+    assert mm.is_number is True
+
+
+def test_zoo():
+    zoo = S.ComplexInfinity
+    assert zoo.is_complex is False
+    assert zoo.is_real is False
+    assert zoo.is_prime is False
+
+
+def test_nan():
+    nan = S.NaN
+
+    assert nan.is_commutative is True
+    assert nan.is_integer is None
+    assert nan.is_rational is None
+    assert nan.is_algebraic is None
+    assert nan.is_transcendental is None
+    assert nan.is_real is None
+    assert nan.is_complex is None
+    assert nan.is_noninteger is None
+    assert nan.is_irrational is None
+    assert nan.is_imaginary is None
+    assert nan.is_positive is None
+    assert nan.is_negative is None
+    assert nan.is_nonpositive is None
+    assert nan.is_nonnegative is None
+    assert nan.is_even is None
+    assert nan.is_odd is None
+    assert nan.is_finite is None
+    assert nan.is_infinite is None
+    assert nan.is_comparable is False
+    assert nan.is_prime is None
+    assert nan.is_composite is None
+    assert nan.is_number is True
+
+
+def test_pos_rational():
+    r = Rational(3, 4)
+    assert r.is_commutative is True
+    assert r.is_integer is False
+    assert r.is_rational is True
+    assert r.is_algebraic is True
+    assert r.is_transcendental is False
+    assert r.is_real is True
+    assert r.is_complex is True
+    assert r.is_noninteger is True
+    assert r.is_irrational is False
+    assert r.is_imaginary is False
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonpositive is False
+    assert r.is_nonnegative is True
+    assert r.is_even is False
+    assert r.is_odd is False
+    assert r.is_finite is True
+    assert r.is_infinite is False
+    assert r.is_comparable is True
+    assert r.is_prime is False
+    assert r.is_composite is False
+
+    r = Rational(1, 4)
+    assert r.is_nonpositive is False
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonnegative is True
+    r = Rational(5, 4)
+    assert r.is_negative is False
+    assert r.is_positive is True
+    assert r.is_nonpositive is False
+    assert r.is_nonnegative is True
+    r = Rational(5, 3)
+    assert r.is_nonnegative is True
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonpositive is False
+
+
+def test_neg_rational():
+    r = Rational(-3, 4)
+    assert r.is_positive is False
+    assert r.is_nonpositive is True
+    assert r.is_negative is True
+    assert r.is_nonnegative is False
+    r = Rational(-1, 4)
+    assert r.is_nonpositive is True
+    assert r.is_positive is False
+    assert r.is_negative is True
+    assert r.is_nonnegative is False
+    r = Rational(-5, 4)
+    assert r.is_negative is True
+    assert r.is_positive is False
+    assert r.is_nonpositive is True
+    assert r.is_nonnegative is False
+    r = Rational(-5, 3)
+    assert r.is_nonnegative is False
+    assert r.is_positive is False
+    assert r.is_negative is True
+    assert r.is_nonpositive is True
+
+
+def test_pi():
+    z = S.Pi
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is False
+    assert z.is_transcendental is True
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is True
+    assert z.is_irrational is True
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_E():
+    z = S.Exp1
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is False
+    assert z.is_transcendental is True
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is True
+    assert z.is_irrational is True
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_I():
+    z = S.ImaginaryUnit
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is False
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is True
+    assert z.is_positive is False
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is False
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is False
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_symbol_real_false():
+    # issue 3848
+    a = Symbol('a', real=False)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_zero is False
+
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_nonzero is False
+
+    assert a.is_extended_negative is None
+    assert a.is_extended_positive is None
+    assert a.is_extended_nonnegative is None
+    assert a.is_extended_nonpositive is None
+    assert a.is_extended_nonzero is None
+
+
+def test_symbol_extended_real_false():
+    # issue 3848
+    a = Symbol('a', extended_real=False)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_zero is False
+
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_nonzero is False
+
+    assert a.is_extended_negative is False
+    assert a.is_extended_positive is False
+    assert a.is_extended_nonnegative is False
+    assert a.is_extended_nonpositive is False
+    assert a.is_extended_nonzero is False
+
+
+def test_symbol_imaginary():
+    a = Symbol('a', imaginary=True)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_zero is False
+    assert a.is_nonzero is False  # since nonzero -> real
+
+
+def test_symbol_zero():
+    x = Symbol('x', zero=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive
+    assert x.is_negative is False
+    assert x.is_nonnegative
+    assert x.is_zero is True
+    # TODO Change to x.is_nonzero is None
+    # See https://github.com/sympy/sympy/pull/9583
+    assert x.is_nonzero is False
+    assert x.is_finite is True
+
+
+def test_symbol_positive():
+    x = Symbol('x', positive=True)
+    assert x.is_positive is True
+    assert x.is_nonpositive is False
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_neg_symbol_positive():
+    x = -Symbol('x', positive=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is True
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_symbol_nonpositive():
+    x = Symbol('x', nonpositive=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_nonpositive():
+    x = -Symbol('x', nonpositive=True)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive():
+    x = Symbol('x', positive=False)
+    assert x.is_positive is False
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive_mul():
+    # To test pull request 9379
+    # Explicit handling of arg.is_positive=False was added to Mul._eval_is_positive
+    x = 2*Symbol('x', positive=False)
+    assert x.is_positive is False  # This was None before
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+@XFAIL
+def test_symbol_infinitereal_mul():
+    ix = Symbol('ix', infinite=True, extended_real=True)
+    assert (-ix).is_extended_positive is None
+
+
+def test_neg_symbol_falsepositive():
+    x = -Symbol('x', positive=False)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_falsenegative():
+    # To test pull request 9379
+    # Explicit handling of arg.is_negative=False was added to Mul._eval_is_positive
+    x = -Symbol('x', negative=False)
+    assert x.is_positive is False  # This was None before
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive_real():
+    x = Symbol('x', positive=False, real=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_falsepositive_real():
+    x = -Symbol('x', positive=False, real=True)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsenonnegative():
+    x = Symbol('x', nonnegative=False)
+    assert x.is_positive is False
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is None
+
+
+@XFAIL
+def test_neg_symbol_falsenonnegative():
+    x = -Symbol('x', nonnegative=False)
+    assert x.is_positive is None
+    assert x.is_nonpositive is False  # this currently returns None
+    assert x.is_negative is False  # this currently returns None
+    assert x.is_nonnegative is None
+    assert x.is_zero is False  # this currently returns None
+    assert x.is_nonzero is True  # this currently returns None
+
+
+def test_symbol_falsenonnegative_real():
+    x = Symbol('x', nonnegative=False, real=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is True
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_neg_symbol_falsenonnegative_real():
+    x = -Symbol('x', nonnegative=False, real=True)
+    assert x.is_positive is True
+    assert x.is_nonpositive is False
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_prime():
+    assert S.NegativeOne.is_prime is False
+    assert S(-2).is_prime is False
+    assert S(-4).is_prime is False
+    assert S.Zero.is_prime is False
+    assert S.One.is_prime is False
+    assert S(2).is_prime is True
+    assert S(17).is_prime is True
+    assert S(4).is_prime is False
+
+
+def test_composite():
+    assert S.NegativeOne.is_composite is False
+    assert S(-2).is_composite is False
+    assert S(-4).is_composite is False
+    assert S.Zero.is_composite is False
+    assert S(2).is_composite is False
+    assert S(17).is_composite is False
+    assert S(4).is_composite is True
+    x = Dummy(integer=True, positive=True, prime=False)
+    assert x.is_composite is None # x could be 1
+    assert (x + 1).is_composite is None
+    x = Dummy(positive=True, even=True, prime=False)
+    assert x.is_integer is True
+    assert x.is_composite is True
+
+
+def test_prime_symbol():
+    x = Symbol('x', prime=True)
+    assert x.is_prime is True
+    assert x.is_integer is True
+    assert x.is_positive is True
+    assert x.is_negative is False
+    assert x.is_nonpositive is False
+    assert x.is_nonnegative is True
+
+    x = Symbol('x', prime=False)
+    assert x.is_prime is False
+    assert x.is_integer is None
+    assert x.is_positive is None
+    assert x.is_negative is None
+    assert x.is_nonpositive is None
+    assert x.is_nonnegative is None
+
+
+def test_symbol_noncommutative():
+    x = Symbol('x', commutative=True)
+    assert x.is_complex is None
+
+    x = Symbol('x', commutative=False)
+    assert x.is_integer is False
+    assert x.is_rational is False
+    assert x.is_algebraic is False
+    assert x.is_irrational is False
+    assert x.is_real is False
+    assert x.is_complex is False
+
+
+def test_other_symbol():
+    x = Symbol('x', integer=True)
+    assert x.is_integer is True
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonnegative=True)
+    assert x.is_integer is True
+    assert x.is_nonnegative is True
+    assert x.is_negative is False
+    assert x.is_positive is None
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonpositive=True)
+    assert x.is_integer is True
+    assert x.is_nonpositive is True
+    assert x.is_positive is False
+    assert x.is_negative is None
+    assert x.is_finite is True
+
+    x = Symbol('x', odd=True)
+    assert x.is_odd is True
+    assert x.is_even is False
+    assert x.is_integer is True
+    assert x.is_finite is True
+
+    x = Symbol('x', odd=False)
+    assert x.is_odd is False
+    assert x.is_even is None
+    assert x.is_integer is None
+    assert x.is_finite is None
+
+    x = Symbol('x', even=True)
+    assert x.is_even is True
+    assert x.is_odd is False
+    assert x.is_integer is True
+    assert x.is_finite is True
+
+    x = Symbol('x', even=False)
+    assert x.is_even is False
+    assert x.is_odd is None
+    assert x.is_integer is None
+    assert x.is_finite is None
+
+    x = Symbol('x', integer=True, nonnegative=True)
+    assert x.is_integer is True
+    assert x.is_nonnegative is True
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonpositive=True)
+    assert x.is_integer is True
+    assert x.is_nonpositive is True
+    assert x.is_finite is True
+
+    x = Symbol('x', rational=True)
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', rational=False)
+    assert x.is_real is None
+    assert x.is_finite is None
+
+    x = Symbol('x', irrational=True)
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', irrational=False)
+    assert x.is_real is None
+    assert x.is_finite is None
+
+    with raises(AttributeError):
+        x.is_real = False
+
+    x = Symbol('x', algebraic=True)
+    assert x.is_transcendental is False
+    x = Symbol('x', transcendental=True)
+    assert x.is_algebraic is False
+    assert x.is_rational is False
+    assert x.is_integer is False
+
+
+def test_evaluate_false():
+    # Previously this failed because the assumptions query would make new
+    # expressions and some of the evaluation logic would fail under
+    # evaluate(False).
+    from sympy.core.parameters import evaluate
+    from sympy.abc import x, h
+    f = 2**x**7
+    with evaluate(False):
+        fh = f.xreplace({x: x+h})
+        assert fh.exp.is_rational is None
+
+
+def test_issue_3825():
+    """catch: hash instability"""
+    x = Symbol("x")
+    y = Symbol("y")
+    a1 = x + y
+    a2 = y + x
+    a2.is_comparable
+
+    h1 = hash(a1)
+    h2 = hash(a2)
+    assert h1 == h2
+
+
+def test_issue_4822():
+    z = (-1)**Rational(1, 3)*(1 - I*sqrt(3))
+    assert z.is_real in [True, None]
+
+
+def test_hash_vs_typeinfo():
+    """seemingly different typeinfo, but in fact equal"""
+
+    # the following two are semantically equal
+    x1 = Symbol('x', even=True)
+    x2 = Symbol('x', integer=True, odd=False)
+
+    assert hash(x1) == hash(x2)
+    assert x1 == x2
+
+
+def test_hash_vs_typeinfo_2():
+    """different typeinfo should mean !eq"""
+    # the following two are semantically different
+    x = Symbol('x')
+    x1 = Symbol('x', even=True)
+
+    assert x != x1
+    assert hash(x) != hash(x1)  # This might fail with very low probability
+
+
+def test_hash_vs_eq():
+    """catch: different hash for equal objects"""
+    a = 1 + S.Pi    # important: do not fold it into a Number instance
+    ha = hash(a)  # it should be Add/Mul/... to trigger the bug
+
+    a.is_positive   # this uses .evalf() and deduces it is positive
+    assert a.is_positive is True
+
+    # be sure that hash stayed the same
+    assert ha == hash(a)
+
+    # now b should be the same expression
+    b = a.expand(trig=True)
+    hb = hash(b)
+
+    assert a == b
+    assert ha == hb
+
+
+def test_Add_is_pos_neg():
+    # these cover lines not covered by the rest of tests in core
+    n = Symbol('n', extended_negative=True, infinite=True)
+    nn = Symbol('n', extended_nonnegative=True, infinite=True)
+    np = Symbol('n', extended_nonpositive=True, infinite=True)
+    p = Symbol('p', extended_positive=True, infinite=True)
+    r = Dummy(extended_real=True, finite=False)
+    x = Symbol('x')
+    xf = Symbol('xf', finite=True)
+    assert (n + p).is_extended_positive is None
+    assert (n + x).is_extended_positive is None
+    assert (p + x).is_extended_positive is None
+    assert (n + p).is_extended_negative is None
+    assert (n + x).is_extended_negative is None
+    assert (p + x).is_extended_negative is None
+
+    assert (n + xf).is_extended_positive is False
+    assert (p + xf).is_extended_positive is True
+    assert (n + xf).is_extended_negative is True
+    assert (p + xf).is_extended_negative is False
+
+    assert (x - S.Infinity).is_extended_negative is None  # issue 7798
+    # issue 8046, 16.2
+    assert (p + nn).is_extended_positive
+    assert (n + np).is_extended_negative
+    assert (p + r).is_extended_positive is None
+
+
+def test_Add_is_imaginary():
+    nn = Dummy(nonnegative=True)
+    assert (I*nn + I).is_imaginary  # issue 8046, 17
+
+
+def test_Add_is_algebraic():
+    a = Symbol('a', algebraic=True)
+    b = Symbol('a', algebraic=True)
+    na = Symbol('na', algebraic=False)
+    nb = Symbol('nb', algebraic=False)
+    x = Symbol('x')
+    assert (a + b).is_algebraic
+    assert (na + nb).is_algebraic is None
+    assert (a + na).is_algebraic is False
+    assert (a + x).is_algebraic is None
+    assert (na + x).is_algebraic is None
+
+
+def test_Mul_is_algebraic():
+    a = Symbol('a', algebraic=True)
+    b = Symbol('b', algebraic=True)
+    na = Symbol('na', algebraic=False)
+    an = Symbol('an', algebraic=True, nonzero=True)
+    nb = Symbol('nb', algebraic=False)
+    x = Symbol('x')
+    assert (a*b).is_algebraic is True
+    assert (na*nb).is_algebraic is None
+    assert (a*na).is_algebraic is None
+    assert (an*na).is_algebraic is False
+    assert (a*x).is_algebraic is None
+    assert (na*x).is_algebraic is None
+
+
+def test_Pow_is_algebraic():
+    e = Symbol('e', algebraic=True)
+
+    assert Pow(1, e, evaluate=False).is_algebraic
+    assert Pow(0, e, evaluate=False).is_algebraic
+
+    a = Symbol('a', algebraic=True)
+    azf = Symbol('azf', algebraic=True, zero=False)
+    na = Symbol('na', algebraic=False)
+    ia = Symbol('ia', algebraic=True, irrational=True)
+    ib = Symbol('ib', algebraic=True, irrational=True)
+    r = Symbol('r', rational=True)
+    x = Symbol('x')
+    assert (a**2).is_algebraic is True
+    assert (a**r).is_algebraic is None
+    assert (azf**r).is_algebraic is True
+    assert (a**x).is_algebraic is None
+    assert (na**r).is_algebraic is None
+    assert (ia**r).is_algebraic is True
+    assert (ia**ib).is_algebraic is False
+
+    assert (a**e).is_algebraic is None
+
+    # Gelfond-Schneider constant:
+    assert Pow(2, sqrt(2), evaluate=False).is_algebraic is False
+
+    assert Pow(S.GoldenRatio, sqrt(3), evaluate=False).is_algebraic is False
+
+    # issue 8649
+    t = Symbol('t', real=True, transcendental=True)
+    n = Symbol('n', integer=True)
+    assert (t**n).is_algebraic is None
+    assert (t**n).is_integer is None
+
+    assert (pi**3).is_algebraic is False
+    r = Symbol('r', zero=True)
+    assert (pi**r).is_algebraic is True
+
+
+def test_Mul_is_prime_composite():
+    x = Symbol('x', positive=True, integer=True)
+    y = Symbol('y', positive=True, integer=True)
+    assert (x*y).is_prime is None
+    assert ( (x+1)*(y+1) ).is_prime is False
+    assert ( (x+1)*(y+1) ).is_composite is True
+
+    x = Symbol('x', positive=True)
+    assert ( (x+1)*(y+1) ).is_prime is None
+    assert ( (x+1)*(y+1) ).is_composite is None
+
+
+def test_Pow_is_pos_neg():
+    z = Symbol('z', real=True)
+    w = Symbol('w', nonpositive=True)
+
+    assert (S.NegativeOne**S(2)).is_positive is True
+    assert (S.One**z).is_positive is True
+    assert (S.NegativeOne**S(3)).is_positive is False
+    assert (S.Zero**S.Zero).is_positive is True  # 0**0 is 1
+    assert (w**S(3)).is_positive is False
+    assert (w**S(2)).is_positive is None
+    assert (I**2).is_positive is False
+    assert (I**4).is_positive is True
+
+    # tests emerging from #16332 issue
+    p = Symbol('p', zero=True)
+    q = Symbol('q', zero=False, real=True)
+    j = Symbol('j', zero=False, even=True)
+    x = Symbol('x', zero=True)
+    y = Symbol('y', zero=True)
+    assert (p**q).is_positive is False
+    assert (p**q).is_negative is False
+    assert (p**j).is_positive is False
+    assert (x**y).is_positive is True   # 0**0
+    assert (x**y).is_negative is False
+
+
+def test_Pow_is_prime_composite():
+    x = Symbol('x', positive=True, integer=True)
+    y = Symbol('y', positive=True, integer=True)
+    assert (x**y).is_prime is None
+    assert ( x**(y+1) ).is_prime is False
+    assert ( x**(y+1) ).is_composite is None
+    assert ( (x+1)**(y+1) ).is_composite is True
+    assert ( (-x-1)**(2*y) ).is_composite is True
+
+    x = Symbol('x', positive=True)
+    assert (x**y).is_prime is None
+
+
+def test_Mul_is_infinite():
+    x = Symbol('x')
+    f = Symbol('f', finite=True)
+    i = Symbol('i', infinite=True)
+    z = Dummy(zero=True)
+    nzf = Dummy(finite=True, zero=False)
+    from sympy.core.mul import Mul
+    assert (x*f).is_finite is None
+    assert (x*i).is_finite is None
+    assert (f*i).is_finite is None
+    assert (x*f*i).is_finite is None
+    assert (z*i).is_finite is None
+    assert (nzf*i).is_finite is False
+    assert (z*f).is_finite is True
+    assert Mul(0, f, evaluate=False).is_finite is True
+    assert Mul(0, i, evaluate=False).is_finite is None
+
+    assert (x*f).is_infinite is None
+    assert (x*i).is_infinite is None
+    assert (f*i).is_infinite is None
+    assert (x*f*i).is_infinite is None
+    assert (z*i).is_infinite is S.NaN.is_infinite
+    assert (nzf*i).is_infinite is True
+    assert (z*f).is_infinite is False
+    assert Mul(0, f, evaluate=False).is_infinite is False
+    assert Mul(0, i, evaluate=False).is_infinite is S.NaN.is_infinite
+
+
+def test_Add_is_infinite():
+    x = Symbol('x')
+    f = Symbol('f', finite=True)
+    i = Symbol('i', infinite=True)
+    i2 = Symbol('i2', infinite=True)
+    z = Dummy(zero=True)
+    nzf = Dummy(finite=True, zero=False)
+    from sympy.core.add import Add
+    assert (x+f).is_finite is None
+    assert (x+i).is_finite is None
+    assert (f+i).is_finite is False
+    assert (x+f+i).is_finite is None
+    assert (z+i).is_finite is False
+    assert (nzf+i).is_finite is False
+    assert (z+f).is_finite is True
+    assert (i+i2).is_finite is None
+    assert Add(0, f, evaluate=False).is_finite is True
+    assert Add(0, i, evaluate=False).is_finite is False
+
+    assert (x+f).is_infinite is None
+    assert (x+i).is_infinite is None
+    assert (f+i).is_infinite is True
+    assert (x+f+i).is_infinite is None
+    assert (z+i).is_infinite is True
+    assert (nzf+i).is_infinite is True
+    assert (z+f).is_infinite is False
+    assert (i+i2).is_infinite is None
+    assert Add(0, f, evaluate=False).is_infinite is False
+    assert Add(0, i, evaluate=False).is_infinite is True
+
+
+def test_special_is_rational():
+    i = Symbol('i', integer=True)
+    i2 = Symbol('i2', integer=True)
+    ni = Symbol('ni', integer=True, nonzero=True)
+    r = Symbol('r', rational=True)
+    rn = Symbol('r', rational=True, nonzero=True)
+    nr = Symbol('nr', irrational=True)
+    x = Symbol('x')
+    assert sqrt(3).is_rational is False
+    assert (3 + sqrt(3)).is_rational is False
+    assert (3*sqrt(3)).is_rational is False
+    assert exp(3).is_rational is False
+    assert exp(ni).is_rational is False
+    assert exp(rn).is_rational is False
+    assert exp(x).is_rational is None
+    assert exp(log(3), evaluate=False).is_rational is True
+    assert log(exp(3), evaluate=False).is_rational is True
+    assert log(3).is_rational is False
+    assert log(ni + 1).is_rational is False
+    assert log(rn + 1).is_rational is False
+    assert log(x).is_rational is None
+    assert (sqrt(3) + sqrt(5)).is_rational is None
+    assert (sqrt(3) + S.Pi).is_rational is False
+    assert (x**i).is_rational is None
+    assert (i**i).is_rational is True
+    assert (i**i2).is_rational is None
+    assert (r**i).is_rational is None
+    assert (r**r).is_rational is None
+    assert (r**x).is_rational is None
+    assert (nr**i).is_rational is None  # issue 8598
+    assert (nr**Symbol('z', zero=True)).is_rational
+    assert sin(1).is_rational is False
+    assert sin(ni).is_rational is False
+    assert sin(rn).is_rational is False
+    assert sin(x).is_rational is None
+    assert asin(r).is_rational is False
+    assert sin(asin(3), evaluate=False).is_rational is True
+
+
+@XFAIL
+def test_issue_6275():
+    x = Symbol('x')
+    # both zero or both Muls...but neither "change would be very appreciated.
+    # This is similar to x/x => 1 even though if x = 0, it is really nan.
+    assert isinstance(x*0, type(0*S.Infinity))
+    if 0*S.Infinity is S.NaN:
+        b = Symbol('b', finite=None)
+        assert (b*0).is_zero is None
+
+
+def test_sanitize_assumptions():
+    # issue 6666
+    for cls in (Symbol, Dummy, Wild):
+        x = cls('x', real=1, positive=0)
+        assert x.is_real is True
+        assert x.is_positive is False
+        assert cls('', real=True, positive=None).is_positive is None
+        raises(ValueError, lambda: cls('', commutative=None))
+    raises(ValueError, lambda: Symbol._sanitize({"commutative": None}))
+
+
+def test_special_assumptions():
+    e = -3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2
+    assert simplify(e < 0) is S.false
+    assert simplify(e > 0) is S.false
+    assert (e == 0) is False  # it's not a literal 0
+    assert e.equals(0) is True
+
+
+def test_inconsistent():
+    # cf. issues 5795 and 5545
+    raises(InconsistentAssumptions, lambda: Symbol('x', real=True,
+           commutative=False))
+
+
+def test_issue_6631():
+    assert ((-1)**(I)).is_real is True
+    assert ((-1)**(I*2)).is_real is True
+    assert ((-1)**(I/2)).is_real is True
+    assert ((-1)**(I*S.Pi)).is_real is True
+    assert (I**(I + 2)).is_real is True
+
+
+def test_issue_2730():
+    assert (1/(1 + I)).is_real is False
+
+
+def test_issue_4149():
+    assert (3 + I).is_complex
+    assert (3 + I).is_imaginary is False
+    assert (3*I + S.Pi*I).is_imaginary
+    # as Zero.is_imaginary is False, see issue 7649
+    y = Symbol('y', real=True)
+    assert (3*I + S.Pi*I + y*I).is_imaginary is None
+    p = Symbol('p', positive=True)
+    assert (3*I + S.Pi*I + p*I).is_imaginary
+    n = Symbol('n', negative=True)
+    assert (-3*I - S.Pi*I + n*I).is_imaginary
+
+    i = Symbol('i', imaginary=True)
+    assert ([(i**a).is_imaginary for a in range(4)] ==
+            [False, True, False, True])
+
+    # tests from the PR #7887:
+    e = S("-sqrt(3)*I/2 + 0.866025403784439*I")
+    assert e.is_real is False
+    assert e.is_imaginary
+
+
+def test_issue_2920():
+    n = Symbol('n', negative=True)
+    assert sqrt(n).is_imaginary
+
+
+def test_issue_7899():
+    x = Symbol('x', real=True)
+    assert (I*x).is_real is None
+    assert ((x - I)*(x - 1)).is_zero is None
+    assert ((x - I)*(x - 1)).is_real is None
+
+
+@XFAIL
+def test_issue_7993():
+    x = Dummy(integer=True)
+    y = Dummy(noninteger=True)
+    assert (x - y).is_zero is False
+
+
+def test_issue_8075():
+    raises(InconsistentAssumptions, lambda: Dummy(zero=True, finite=False))
+    raises(InconsistentAssumptions, lambda: Dummy(zero=True, infinite=True))
+
+
+def test_issue_8642():
+    x = Symbol('x', real=True, integer=False)
+    assert (x*2).is_integer is None, (x*2).is_integer
+
+
+def test_issues_8632_8633_8638_8675_8992():
+    p = Dummy(integer=True, positive=True)
+    nn = Dummy(integer=True, nonnegative=True)
+    assert (p - S.Half).is_positive
+    assert (p - 1).is_nonnegative
+    assert (nn + 1).is_positive
+    assert (-p + 1).is_nonpositive
+    assert (-nn - 1).is_negative
+    prime = Dummy(prime=True)
+    assert (prime - 2).is_nonnegative
+    assert (prime - 3).is_nonnegative is None
+    even = Dummy(positive=True, even=True)
+    assert (even - 2).is_nonnegative
+
+    p = Dummy(positive=True)
+    assert (p/(p + 1) - 1).is_negative
+    assert ((p + 2)**3 - S.Half).is_positive
+    n = Dummy(negative=True)
+    assert (n - 3).is_nonpositive
+
+
+def test_issue_9115_9150():
+    n = Dummy('n', integer=True, nonnegative=True)
+    assert (factorial(n) >= 1) == True
+    assert (factorial(n) < 1) == False
+
+    assert factorial(n + 1).is_even is None
+    assert factorial(n + 2).is_even is True
+    assert factorial(n + 2) >= 2
+
+
+def test_issue_9165():
+    z = Symbol('z', zero=True)
+    f = Symbol('f', finite=False)
+    assert 0/z is S.NaN
+    assert 0*(1/z) is S.NaN
+    assert 0*f is S.NaN
+
+
+def test_issue_10024():
+    x = Dummy('x')
+    assert Mod(x, 2*pi).is_zero is None
+
+
+def test_issue_10302():
+    x = Symbol('x')
+    r = Symbol('r', real=True)
+    u = -(3*2**pi)**(1/pi) + 2*3**(1/pi)
+    i = u + u*I
+
+    assert i.is_real is None  # w/o simplification this should fail
+    assert (u + i).is_zero is None
+    assert (1 + i).is_zero is False
+
+    a = Dummy('a', zero=True)
+    assert (a + I).is_zero is False
+    assert (a + r*I).is_zero is None
+    assert (a + I).is_imaginary
+    assert (a + x + I).is_imaginary is None
+    assert (a + r*I + I).is_imaginary is None
+
+
+def test_complex_reciprocal_imaginary():
+    assert (1 / (4 + 3*I)).is_imaginary is False
+
+
+def test_issue_16313():
+    x = Symbol('x', extended_real=False)
+    k = Symbol('k', real=True)
+    l = Symbol('l', real=True, zero=False)
+    assert (-x).is_real is False
+    assert (k*x).is_real is None  # k can be zero also
+    assert (l*x).is_real is False
+    assert (l*x*x).is_real is None  # since x*x can be a real number
+    assert (-x).is_positive is False
+
+
+def test_issue_16579():
+    # extended_real -> finite | infinite
+    x = Symbol('x', extended_real=True, infinite=False)
+    y = Symbol('y', extended_real=True, finite=False)
+    assert x.is_finite is True
+    assert y.is_infinite is True
+
+    # With PR 16978, complex now implies finite
+    c = Symbol('c', complex=True)
+    assert c.is_finite is True
+    raises(InconsistentAssumptions, lambda: Dummy(complex=True, finite=False))
+
+    # Now infinite == !finite
+    nf = Symbol('nf', finite=False)
+    assert nf.is_infinite is True
+
+
+def test_issue_17556():
+    z = I*oo
+    assert z.is_imaginary is False
+    assert z.is_finite is False
+
+
+def test_issue_21651():
+    k = Symbol('k', positive=True, integer=True)
+    exp = 2*2**(-k)
+    assert exp.is_integer is None
+
+
+def test_assumptions_copy():
+    assert assumptions(Symbol('x'), {"commutative": True}
+        ) == {'commutative': True}
+    assert assumptions(Symbol('x'), ['integer']) == {}
+    assert assumptions(Symbol('x'), ['commutative']
+        ) == {'commutative': True}
+    assert assumptions(Symbol('x')) == {'commutative': True}
+    assert assumptions(1)['positive']
+    assert assumptions(3 + I) == {
+        'algebraic': True,
+        'commutative': True,
+        'complex': True,
+        'composite': False,
+        'even': False,
+        'extended_negative': False,
+        'extended_nonnegative': False,
+        'extended_nonpositive': False,
+        'extended_nonzero': False,
+        'extended_positive': False,
+        'extended_real': False,
+        'finite': True,
+        'imaginary': False,
+        'infinite': False,
+        'integer': False,
+        'irrational': False,
+        'negative': False,
+        'noninteger': False,
+        'nonnegative': False,
+        'nonpositive': False,
+        'nonzero': False,
+        'odd': False,
+        'positive': False,
+        'prime': False,
+        'rational': False,
+        'real': False,
+        'transcendental': False,
+        'zero': False}
+
+
+def test_check_assumptions():
+    assert check_assumptions(1, 0) is False
+    x = Symbol('x', positive=True)
+    assert check_assumptions(1, x) is True
+    assert check_assumptions(1, 1) is True
+    assert check_assumptions(-1, 1) is False
+    i = Symbol('i', integer=True)
+    # don't know if i is positive (or prime, etc...)
+    assert check_assumptions(i, 1) is None
+    assert check_assumptions(Dummy(integer=None), integer=True) is None
+    assert check_assumptions(Dummy(integer=None), integer=False) is None
+    assert check_assumptions(Dummy(integer=False), integer=True) is False
+    assert check_assumptions(Dummy(integer=True), integer=False) is False
+    # no T/F assumptions to check
+    assert check_assumptions(Dummy(integer=False), integer=None) is True
+    raises(ValueError, lambda: check_assumptions(2*x, x, positive=True))
+
+
+def test_failing_assumptions():
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert failing_assumptions(6*x + y, **x.assumptions0) == \
+    {'real': None, 'imaginary': None, 'complex': None, 'hermitian': None,
+    'positive': None, 'nonpositive': None, 'nonnegative': None, 'nonzero': None,
+    'negative': None, 'zero': None, 'extended_real': None, 'finite': None,
+    'infinite': None, 'extended_negative': None, 'extended_nonnegative': None,
+    'extended_nonpositive': None, 'extended_nonzero': None,
+    'extended_positive': None }
+
+
+def test_common_assumptions():
+    assert common_assumptions([0, 1, 2]
+        ) == {'algebraic': True, 'irrational': False, 'hermitian':
+        True, 'extended_real': True, 'real': True, 'extended_negative':
+        False, 'extended_nonnegative': True, 'integer': True,
+        'rational': True, 'imaginary': False, 'complex': True,
+        'commutative': True,'noninteger': False, 'composite': False,
+        'infinite': False, 'nonnegative': True, 'finite': True,
+        'transcendental': False,'negative': False}
+    assert common_assumptions([0, 1, 2], 'positive integer'.split()
+        ) == {'integer': True}
+    assert common_assumptions([0, 1, 2], []) == {}
+    assert common_assumptions([], ['integer']) == {}
+    assert common_assumptions([0], ['integer']) == {'integer': True}
+
+def test_pre_generated_assumption_rules_are_valid():
+    # check the pre-generated assumptions match freshly generated assumptions
+    # if this check fails, consider updating the assumptions
+    # see sympy.core.assumptions._generate_assumption_rules
+    pre_generated_assumptions =_load_pre_generated_assumption_rules()
+    generated_assumptions =_generate_assumption_rules()
+    assert pre_generated_assumptions._to_python() == generated_assumptions._to_python(), "pre-generated assumptions are invalid, see sympy.core.assumptions._generate_assumption_rules"
+
+
+def test_ask_shuffle():
+    grp = PermutationGroup(Permutation(1, 0, 2), Permutation(2, 1, 3))
+
+    seed(123)
+    first = grp.random()
+    seed(123)
+    simplify(I)
+    second = grp.random()
+    seed(123)
+    simplify(-I)
+    third = grp.random()
+
+    assert first == second == third

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_basic.py

@@ -0,0 +1,319 @@
+"""This tests sympy/core/basic.py with (ideally) no reference to subclasses
+of Basic or Atom."""
+
+import collections
+
+from sympy.assumptions.ask import Q
+from sympy.core.basic import (Basic, Atom, as_Basic,
+    _atomic, _aresame)
+from sympy.core.containers import Tuple
+from sympy.core.function import Function, Lambda
+from sympy.core.numbers import I, pi
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.concrete.summations import Sum
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.functions.elementary.exponential import exp
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+b1 = Basic()
+b2 = Basic(b1)
+b3 = Basic(b2)
+b21 = Basic(b2, b1)
+
+
+def test__aresame():
+    assert not _aresame(Basic(Tuple()), Basic())
+    assert not _aresame(Basic(S(2)), Basic(S(2.)))
+
+
+def test_structure():
+    assert b21.args == (b2, b1)
+    assert b21.func(*b21.args) == b21
+    assert bool(b1)
+
+
+def test_immutable():
+    assert not hasattr(b1, '__dict__')
+    with raises(AttributeError):
+        b1.x = 1
+
+
+def test_equality():
+    instances = [b1, b2, b3, b21, Basic(b1, b1, b1), Basic]
+    for i, b_i in enumerate(instances):
+        for j, b_j in enumerate(instances):
+            assert (b_i == b_j) == (i == j)
+            assert (b_i != b_j) == (i != j)
+
+    assert Basic() != []
+    assert not(Basic() == [])
+    assert Basic() != 0
+    assert not(Basic() == 0)
+
+    class Foo:
+        """
+        Class that is unaware of Basic, and relies on both classes returning
+        the NotImplemented singleton for equivalence to evaluate to False.
+
+        """
+
+    b = Basic()
+    foo = Foo()
+
+    assert b != foo
+    assert foo != b
+    assert not b == foo
+    assert not foo == b
+
+    class Bar:
+        """
+        Class that considers itself equal to any instance of Basic, and relies
+        on Basic returning the NotImplemented singleton in order to achieve
+        a symmetric equivalence relation.
+
+        """
+        def __eq__(self, other):
+            if isinstance(other, Basic):
+                return True
+            return NotImplemented
+
+        def __ne__(self, other):
+            return not self == other
+
+    bar = Bar()
+
+    assert b == bar
+    assert bar == b
+    assert not b != bar
+    assert not bar != b
+
+
+def test_matches_basic():
+    instances = [Basic(b1, b1, b2), Basic(b1, b2, b1), Basic(b2, b1, b1),
+                 Basic(b1, b2), Basic(b2, b1), b2, b1]
+    for i, b_i in enumerate(instances):
+        for j, b_j in enumerate(instances):
+            if i == j:
+                assert b_i.matches(b_j) == {}
+            else:
+                assert b_i.matches(b_j) is None
+    assert b1.match(b1) == {}
+
+
+def test_has():
+    assert b21.has(b1)
+    assert b21.has(b3, b1)
+    assert b21.has(Basic)
+    assert not b1.has(b21, b3)
+    assert not b21.has()
+    assert not b21.has(str)
+    assert not Symbol("x").has("x")
+
+
+def test_subs():
+    assert b21.subs(b2, b1) == Basic(b1, b1)
+    assert b21.subs(b2, b21) == Basic(b21, b1)
+    assert b3.subs(b2, b1) == b2
+
+    assert b21.subs([(b2, b1), (b1, b2)]) == Basic(b2, b2)
+
+    assert b21.subs({b1: b2, b2: b1}) == Basic(b2, b2)
+    assert b21.subs(collections.ChainMap({b1: b2}, {b2: b1})) == Basic(b2, b2)
+    assert b21.subs(collections.OrderedDict([(b2, b1), (b1, b2)])) == Basic(b2, b2)
+
+    raises(ValueError, lambda: b21.subs('bad arg'))
+    raises(ValueError, lambda: b21.subs(b1, b2, b3))
+    # dict(b1=foo) creates a string 'b1' but leaves foo unchanged; subs
+    # will convert the first to a symbol but will raise an error if foo
+    # cannot be sympified; sympification is strict if foo is not string
+    raises(ValueError, lambda: b21.subs(b1='bad arg'))
+
+    assert Symbol("text").subs({"text": b1}) == b1
+    assert Symbol("s").subs({"s": 1}) == 1
+
+
+def test_subs_with_unicode_symbols():
+    expr = Symbol('var1')
+    replaced = expr.subs('var1', 'x')
+    assert replaced.name == 'x'
+
+    replaced = expr.subs('var1', 'x')
+    assert replaced.name == 'x'
+
+
+def test_atoms():
+    assert b21.atoms() == {Basic()}
+
+
+def test_free_symbols_empty():
+    assert b21.free_symbols == set()
+
+
+def test_doit():
+    assert b21.doit() == b21
+    assert b21.doit(deep=False) == b21
+
+
+def test_S():
+    assert repr(S) == 'S'
+
+
+def test_xreplace():
+    assert b21.xreplace({b2: b1}) == Basic(b1, b1)
+    assert b21.xreplace({b2: b21}) == Basic(b21, b1)
+    assert b3.xreplace({b2: b1}) == b2
+    assert Basic(b1, b2).xreplace({b1: b2, b2: b1}) == Basic(b2, b1)
+    assert Atom(b1).xreplace({b1: b2}) == Atom(b1)
+    assert Atom(b1).xreplace({Atom(b1): b2}) == b2
+    raises(TypeError, lambda: b1.xreplace())
+    raises(TypeError, lambda: b1.xreplace([b1, b2]))
+    for f in (exp, Function('f')):
+        assert f.xreplace({}) == f
+        assert f.xreplace({}, hack2=True) == f
+        assert f.xreplace({f: b1}) == b1
+        assert f.xreplace({f: b1}, hack2=True) == b1
+
+
+def test_sorted_args():
+    x = symbols('x')
+    assert b21._sorted_args == b21.args
+    raises(AttributeError, lambda: x._sorted_args)
+
+def test_call():
+    x, y = symbols('x y')
+    # See the long history of this in issues 5026 and 5105.
+
+    raises(TypeError, lambda: sin(x)({ x : 1, sin(x) : 2}))
+    raises(TypeError, lambda: sin(x)(1))
+
+    # No effect as there are no callables
+    assert sin(x).rcall(1) == sin(x)
+    assert (1 + sin(x)).rcall(1) == 1 + sin(x)
+
+    # Effect in the pressence of callables
+    l = Lambda(x, 2*x)
+    assert (l + x).rcall(y) == 2*y + x
+    assert (x**l).rcall(2) == x**4
+    # TODO UndefinedFunction does not subclass Expr
+    #f = Function('f')
+    #assert (2*f)(x) == 2*f(x)
+
+    assert (Q.real & Q.positive).rcall(x) == Q.real(x) & Q.positive(x)
+
+
+def test_rewrite():
+    x, y, z = symbols('x y z')
+    a, b = symbols('a b')
+    f1 = sin(x) + cos(x)
+    assert f1.rewrite(cos,exp) == exp(I*x)/2 + sin(x) + exp(-I*x)/2
+    assert f1.rewrite([cos],sin) == sin(x) + sin(x + pi/2, evaluate=False)
+    f2 = sin(x) + cos(y)/gamma(z)
+    assert f2.rewrite(sin,exp) == -I*(exp(I*x) - exp(-I*x))/2 + cos(y)/gamma(z)
+
+    assert f1.rewrite() == f1
+
+def test_literal_evalf_is_number_is_zero_is_comparable():
+    x = symbols('x')
+    f = Function('f')
+
+    # issue 5033
+    assert f.is_number is False
+    # issue 6646
+    assert f(1).is_number is False
+    i = Integral(0, (x, x, x))
+    # expressions that are symbolically 0 can be difficult to prove
+    # so in case there is some easy way to know if something is 0
+    # it should appear in the is_zero property for that object;
+    # if is_zero is true evalf should always be able to compute that
+    # zero
+    assert i.n() == 0
+    assert i.is_zero
+    assert i.is_number is False
+    assert i.evalf(2, strict=False) == 0
+
+    # issue 10268
+    n = sin(1)**2 + cos(1)**2 - 1
+    assert n.is_comparable is False
+    assert n.n(2).is_comparable is False
+    assert n.n(2).n(2).is_comparable
+
+
+def test_as_Basic():
+    assert as_Basic(1) is S.One
+    assert as_Basic(()) == Tuple()
+    raises(TypeError, lambda: as_Basic([]))
+
+
+def test_atomic():
+    g, h = map(Function, 'gh')
+    x = symbols('x')
+    assert _atomic(g(x + h(x))) == {g(x + h(x))}
+    assert _atomic(g(x + h(x)), recursive=True) == {h(x), x, g(x + h(x))}
+    assert _atomic(1) == set()
+    assert _atomic(Basic(S(1), S(2))) == set()
+
+
+def test_as_dummy():
+    u, v, x, y, z, _0, _1 = symbols('u v x y z _0 _1')
+    assert Lambda(x, x + 1).as_dummy() == Lambda(_0, _0 + 1)
+    assert Lambda(x, x + _0).as_dummy() == Lambda(_1, _0 + _1)
+    eq = (1 + Sum(x, (x, 1, x)))
+    ans = 1 + Sum(_0, (_0, 1, x))
+    once = eq.as_dummy()
+    assert once == ans
+    twice = once.as_dummy()
+    assert twice == ans
+    assert Integral(x + _0, (x, x + 1), (_0, 1, 2)
+        ).as_dummy() == Integral(_0 + _1, (_0, x + 1), (_1, 1, 2))
+    for T in (Symbol, Dummy):
+        d = T('x', real=True)
+        D = d.as_dummy()
+        assert D != d and D.func == Dummy and D.is_real is None
+    assert Dummy().as_dummy().is_commutative
+    assert Dummy(commutative=False).as_dummy().is_commutative is False
+
+
+def test_canonical_variables():
+    x, i0, i1 = symbols('x _:2')
+    assert Integral(x, (x, x + 1)).canonical_variables == {x: i0}
+    assert Integral(x, (x, x + 1), (i0, 1, 2)).canonical_variables == {
+        x: i0, i0: i1}
+    assert Integral(x, (x, x + i0)).canonical_variables == {x: i1}
+
+
+def test_replace_exceptions():
+    from sympy.core.symbol import Wild
+    x, y = symbols('x y')
+    e = (x**2 + x*y)
+    raises(TypeError, lambda: e.replace(sin, 2))
+    b = Wild('b')
+    c = Wild('c')
+    raises(TypeError, lambda: e.replace(b*c, c.is_real))
+    raises(TypeError, lambda: e.replace(b.is_real, 1))
+    raises(TypeError, lambda: e.replace(lambda d: d.is_Number, 1))
+
+
+def test_ManagedProperties():
+    # ManagedProperties is now deprecated. Here we do our best to check that if
+    # someone is using it then it does work in the way that it previously did
+    # but gives a deprecation warning.
+    from sympy.core.assumptions import ManagedProperties
+
+    myclasses = []
+
+    class MyMeta(ManagedProperties):
+        def __init__(cls, *args, **kwargs):
+            myclasses.append('executed')
+            super().__init__(*args, **kwargs)
+
+    code = """
+class MySubclass(Basic, metaclass=MyMeta):
+    pass
+"""
+    with warns_deprecated_sympy():
+        exec(code)
+
+    assert myclasses == ['executed']

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_cache.py

@@ -0,0 +1,91 @@
+import sys
+from sympy.core.cache import cacheit, cached_property, lazy_function
+from sympy.testing.pytest import raises
+
+def test_cacheit_doc():
+    @cacheit
+    def testfn():
+        "test docstring"
+        pass
+
+    assert testfn.__doc__ == "test docstring"
+    assert testfn.__name__ == "testfn"
+
+def test_cacheit_unhashable():
+    @cacheit
+    def testit(x):
+        return x
+
+    assert testit(1) == 1
+    assert testit(1) == 1
+    a = {}
+    assert testit(a) == {}
+    a[1] = 2
+    assert testit(a) == {1: 2}
+
+def test_cachit_exception():
+    # Make sure the cache doesn't call functions multiple times when they
+    # raise TypeError
+
+    a = []
+
+    @cacheit
+    def testf(x):
+        a.append(0)
+        raise TypeError
+
+    raises(TypeError, lambda: testf(1))
+    assert len(a) == 1
+
+    a.clear()
+    # Unhashable type
+    raises(TypeError, lambda: testf([]))
+    assert len(a) == 1
+
+    @cacheit
+    def testf2(x):
+        a.append(0)
+        raise TypeError("Error")
+
+    a.clear()
+    raises(TypeError, lambda: testf2(1))
+    assert len(a) == 1
+
+    a.clear()
+    # Unhashable type
+    raises(TypeError, lambda: testf2([]))
+    assert len(a) == 1
+
+def test_cached_property():
+    class A:
+        def __init__(self, value):
+            self.value = value
+            self.calls = 0
+
+        @cached_property
+        def prop(self):
+            self.calls = self.calls + 1
+            return self.value
+
+    a = A(2)
+    assert a.calls == 0
+    assert a.prop == 2
+    assert a.calls == 1
+    assert a.prop == 2
+    assert a.calls == 1
+    b = A(None)
+    assert b.prop == None
+
+
+def test_lazy_function():
+    module_name='xmlrpc.client'
+    function_name = 'gzip_decode'
+    lazy = lazy_function(module_name, function_name)
+    assert lazy(b'') == b''
+    assert module_name in sys.modules
+    assert function_name in str(lazy)
+    repr_lazy = repr(lazy)
+    assert 'LazyFunction' in repr_lazy
+    assert function_name in repr_lazy
+
+    lazy = lazy_function('sympy.core.cache', 'cheap')

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_compatibility.py

@@ -0,0 +1,6 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+def test_compatibility_submodule():
+    # Test the sympy.core.compatibility deprecation warning
+    with warns_deprecated_sympy():
+        import sympy.core.compatibility # noqa:F401

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_complex.py

@@ -0,0 +1,226 @@
+from sympy.core.function import expand_complex
+from sympy.core.numbers import (I, Integer, Rational, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.hyperbolic import (cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+
+def test_complex():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    e = (a + I*b)*(a - I*b)
+    assert e.expand() == a**2 + b**2
+    assert sqrt(I) == Pow(I, S.Half)
+
+
+def test_conjugate():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    c = Symbol("c", imaginary=True)
+    d = Symbol("d", imaginary=True)
+    x = Symbol('x')
+    z = a + I*b + c + I*d
+    zc = a - I*b - c + I*d
+    assert conjugate(z) == zc
+    assert conjugate(exp(z)) == exp(zc)
+    assert conjugate(exp(I*x)) == exp(-I*conjugate(x))
+    assert conjugate(z**5) == zc**5
+    assert conjugate(abs(x)) == abs(x)
+    assert conjugate(sign(z)) == sign(zc)
+    assert conjugate(sin(z)) == sin(zc)
+    assert conjugate(cos(z)) == cos(zc)
+    assert conjugate(tan(z)) == tan(zc)
+    assert conjugate(cot(z)) == cot(zc)
+    assert conjugate(sinh(z)) == sinh(zc)
+    assert conjugate(cosh(z)) == cosh(zc)
+    assert conjugate(tanh(z)) == tanh(zc)
+    assert conjugate(coth(z)) == coth(zc)
+
+
+def test_abs1():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    assert abs(a) == Abs(a)
+    assert abs(-a) == abs(a)
+    assert abs(a + I*b) == sqrt(a**2 + b**2)
+
+
+def test_abs2():
+    a = Symbol("a", real=False)
+    b = Symbol("b", real=False)
+    assert abs(a) != a
+    assert abs(-a) != a
+    assert abs(a + I*b) != sqrt(a**2 + b**2)
+
+
+def test_evalc():
+    x = Symbol("x", real=True)
+    y = Symbol("y", real=True)
+    z = Symbol("z")
+    assert ((x + I*y)**2).expand(complex=True) == x**2 + 2*I*x*y - y**2
+    assert expand_complex(z**(2*I)) == (re((re(z) + I*im(z))**(2*I)) +
+        I*im((re(z) + I*im(z))**(2*I)))
+    assert expand_complex(
+        z**(2*I), deep=False) == I*im(z**(2*I)) + re(z**(2*I))
+
+    assert exp(I*x) != cos(x) + I*sin(x)
+    assert exp(I*x).expand(complex=True) == cos(x) + I*sin(x)
+    assert exp(I*x + y).expand(complex=True) == exp(y)*cos(x) + I*sin(x)*exp(y)
+
+    assert sin(I*x).expand(complex=True) == I * sinh(x)
+    assert sin(x + I*y).expand(complex=True) == sin(x)*cosh(y) + \
+        I * sinh(y) * cos(x)
+
+    assert cos(I*x).expand(complex=True) == cosh(x)
+    assert cos(x + I*y).expand(complex=True) == cos(x)*cosh(y) - \
+        I * sinh(y) * sin(x)
+
+    assert tan(I*x).expand(complex=True) == tanh(x) * I
+    assert tan(x + I*y).expand(complex=True) == (
+        sin(2*x)/(cos(2*x) + cosh(2*y)) +
+        I*sinh(2*y)/(cos(2*x) + cosh(2*y)))
+
+    assert sinh(I*x).expand(complex=True) == I * sin(x)
+    assert sinh(x + I*y).expand(complex=True) == sinh(x)*cos(y) + \
+        I * sin(y) * cosh(x)
+
+    assert cosh(I*x).expand(complex=True) == cos(x)
+    assert cosh(x + I*y).expand(complex=True) == cosh(x)*cos(y) + \
+        I * sin(y) * sinh(x)
+
+    assert tanh(I*x).expand(complex=True) == tan(x) * I
+    assert tanh(x + I*y).expand(complex=True) == (
+        (sinh(x)*cosh(x) + I*cos(y)*sin(y)) /
+        (sinh(x)**2 + cos(y)**2)).expand()
+
+
+def test_pythoncomplex():
+    x = Symbol("x")
+    assert 4j*x != 4*x*I
+    assert 4j*x == 4.0*x*I
+    assert 4.1j*x != 4*x*I
+
+
+def test_rootcomplex():
+    R = Rational
+    assert ((+1 + I)**R(1, 2)).expand(
+        complex=True) == 2**R(1, 4)*cos(  pi/8) + 2**R(1, 4)*sin(  pi/8)*I
+    assert ((-1 - I)**R(1, 2)).expand(
+        complex=True) == 2**R(1, 4)*cos(3*pi/8) - 2**R(1, 4)*sin(3*pi/8)*I
+    assert (sqrt(-10)*I).as_real_imag() == (-sqrt(10), 0)
+
+
+def test_expand_inverse():
+    assert (1/(1 + I)).expand(complex=True) == (1 - I)/2
+    assert ((1 + 2*I)**(-2)).expand(complex=True) == (-3 - 4*I)/25
+    assert ((1 + I)**(-8)).expand(complex=True) == Rational(1, 16)
+
+
+def test_expand_complex():
+    assert ((2 + 3*I)**10).expand(complex=True) == -341525 - 145668*I
+    # the following two tests are to ensure the SymPy uses an efficient
+    # algorithm for calculating powers of complex numbers. They should execute
+    # in something like 0.01s.
+    assert ((2 + 3*I)**1000).expand(complex=True) == \
+        -81079464736246615951519029367296227340216902563389546989376269312984127074385455204551402940331021387412262494620336565547972162814110386834027871072723273110439771695255662375718498785908345629702081336606863762777939617745464755635193139022811989314881997210583159045854968310911252660312523907616129080027594310008539817935736331124833163907518549408018652090650537035647520296539436440394920287688149200763245475036722326561143851304795139005599209239350981457301460233967137708519975586996623552182807311159141501424576682074392689622074945519232029999 + \
+        46938745946789557590804551905243206242164799136976022474337918748798900569942573265747576032611189047943842446167719177749107138603040963603119861476016947257034472364028585381714774667326478071264878108114128915685688115488744955550920239128462489496563930809677159214598114273887061533057125164518549173898349061972857446844052995037423459472376202251620778517659247970283904820245958198842631651569984310559418135975795868314764489884749573052997832686979294085577689571149679540256349988338406458116270429842222666345146926395233040564229555893248370000*I
+    assert ((2 + 3*I/4)**1000).expand(complex=True) == \
+        Integer(1)*37079892761199059751745775382463070250205990218394308874593455293485167797989691280095867197640410033222367257278387021789651672598831503296531725827158233077451476545928116965316544607115843772405184272449644892857783761260737279675075819921259597776770965829089907990486964515784097181964312256560561065607846661496055417619388874421218472707497847700629822858068783288579581649321248495739224020822198695759609598745114438265083593711851665996586461937988748911532242908776883696631067311443171682974330675406616373422505939887984366289623091300746049101284856530270685577940283077888955692921951247230006346681086274961362500646889925803654263491848309446197554307105991537357310209426736453173441104334496173618419659521888945605315751089087820455852582920963561495787655250624781448951403353654348109893478206364632640344111022531861683064175862889459084900614967785405977231549003280842218501570429860550379522498497412180001/114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376 + \
+        I*421638390580169706973991429333213477486930178424989246669892530737775352519112934278994501272111385966211392610029433824534634841747911783746811994443436271013377059560245191441549885048056920190833693041257216263519792201852046825443439142932464031501882145407459174948712992271510309541474392303461939389368955986650538525895866713074543004916049550090364398070215427272240155060576252568700906004691224321432509053286859100920489253598392100207663785243368195857086816912514025693453058403158416856847185079684216151337200057494966741268925263085619240941610301610538225414050394612058339070756009433535451561664522479191267503989904464718368605684297071150902631208673621618217106272361061676184840810762902463998065947687814692402219182668782278472952758690939877465065070481351343206840649517150634973307937551168752642148704904383991876969408056379195860410677814566225456558230131911142229028179902418223009651437985670625/1793954211366022694113801876840128100034871409513586250746316776290259783425578615401030447369541046747571819748417910583511123376348523955353017744010395602173906080395504375010762174191250701116076984219741972574712741619474818186676828531882286780795390571221287481389759837587864244524002565968286448146002639202882164150037179450123657170327105882819203167448541028601906377066191895183769810676831353109303069033234715310287563158747705988305326397404720186258671215368588625611876280581509852855552819149745718992630449787803625851701801184123166018366180137512856918294030710215034138299203584
+    assert ((2 + 3*I)**-1000).expand(complex=True) == \
+        Integer(1)*-81079464736246615951519029367296227340216902563389546989376269312984127074385455204551402940331021387412262494620336565547972162814110386834027871072723273110439771695255662375718498785908345629702081336606863762777939617745464755635193139022811989314881997210583159045854968310911252660312523907616129080027594310008539817935736331124833163907518549408018652090650537035647520296539436440394920287688149200763245475036722326561143851304795139005599209239350981457301460233967137708519975586996623552182807311159141501424576682074392689622074945519232029999/8777125472973511649630750050295188683351430110097915876250894978429797369155961290321829625004920141758416719066805645579710744290541337680113772670040386863849283653078324415471816788604945889094925784900885812724984087843737442111926413818245854362613018058774368703971604921858023116665586358870612944209398056562604561248859926344335598822815885851096698226775053153403320782439987679978321289537645645163767251396759519805603090332694449553371530571613352311006350058217982509738362083094920649452123351717366337410243853659113315547584871655479914439219520157174729130746351059075207407866012574386726064196992865627149566238044625779078186624347183905913357718850537058578084932880569701242598663149911276357125355850792073635533676541250531086757377369962506979378337216411188347761901006460813413505861461267545723590468627854202034450569581626648934062198718362303420281555886394558137408159453103395918783625713213314350531051312551733021627153081075080140680608080529736975658786227362251632725009435866547613598753584705455955419696609282059191031962604169242974038517575645939316377801594539335940001 - Integer(1)*46938745946789557590804551905243206242164799136976022474337918748798900569942573265747576032611189047943842446167719177749107138603040963603119861476016947257034472364028585381714774667326478071264878108114128915685688115488744955550920239128462489496563930809677159214598114273887061533057125164518549173898349061972857446844052995037423459472376202251620778517659247970283904820245958198842631651569984310559418135975795868314764489884749573052997832686979294085577689571149679540256349988338406458116270429842222666345146926395233040564229555893248370000*I/8777125472973511649630750050295188683351430110097915876250894978429797369155961290321829625004920141758416719066805645579710744290541337680113772670040386863849283653078324415471816788604945889094925784900885812724984087843737442111926413818245854362613018058774368703971604921858023116665586358870612944209398056562604561248859926344335598822815885851096698226775053153403320782439987679978321289537645645163767251396759519805603090332694449553371530571613352311006350058217982509738362083094920649452123351717366337410243853659113315547584871655479914439219520157174729130746351059075207407866012574386726064196992865627149566238044625779078186624347183905913357718850537058578084932880569701242598663149911276357125355850792073635533676541250531086757377369962506979378337216411188347761901006460813413505861461267545723590468627854202034450569581626648934062198718362303420281555886394558137408159453103395918783625713213314350531051312551733021627153081075080140680608080529736975658786227362251632725009435866547613598753584705455955419696609282059191031962604169242974038517575645939316377801594539335940001
+    assert ((2 + 3*I/4)**-1000).expand(complex=True) == \
+        Integer(1)*4257256305661027385394552848555894604806501409793288342610746813288539790051927148781268212212078237301273165351052934681382567968787279534591114913777456610214738290619922068269909423637926549603264174216950025398244509039145410016404821694746262142525173737175066432954496592560621330313807235750500564940782099283410261748370262433487444897446779072067625787246390824312580440138770014838135245148574339248259670887549732495841810961088930810608893772914812838358159009303794863047635845688453859317690488124382253918725010358589723156019888846606295866740117645571396817375322724096486161308083462637370825829567578309445855481578518239186117686659177284332344643124760453112513611749309168470605289172320376911472635805822082051716625171429727162039621902266619821870482519063133136820085579315127038372190224739238686708451840610064871885616258831386810233957438253532027049148030157164346719204500373766157143311767338973363806106967439378604898250533766359989107510507493549529158818602327525235240510049484816090584478644771183158342479140194633579061295740839490629457435283873180259847394582069479062820225159699506175855369539201399183443253793905149785994830358114153241481884290274629611529758663543080724574566578220908907477622643689220814376054314972190402285121776593824615083669045183404206291739005554569305329760211752815718335731118664756831942466773261465213581616104242113894521054475516019456867271362053692785300826523328020796670205463390909136593859765912483565093461468865534470710132881677639651348709376/2103100954337624833663208713697737151593634525061637972297915388685604042449504336765884978184588688426595940401280828953096857809292320006227881797146858511436638446932833617514351442216409828605662238790280753075176269765767010004889778647709740770757817960711900340755635772183674511158570690702969774966791073165467918123298694584729211212414462628433370481195120564586361368504153395406845170075275051749019600057116719726628746724489572189061061036426955163696859127711110719502594479795200686212257570291758725259007379710596548777812659422174199194837355646482046783616494013289495563083118517507178847555801163089723056310287760875135196081975602765511153122381201303871673391366630940702817360340900568748719988954847590748960761446218262344767250783946365392689256634180417145926390656439421745644011831124277463643383712803287985472471755648426749842410972650924240795946699346613614779460399530274263580007672855851663196114585312432954432654691485867618908420370875753749297487803461900447407917655296784879220450937110470920633595689721819488638484547259978337741496090602390463594556401615298457456112485536498177883358587125449801777718900375736758266215245325999241624148841915093787519330809347240990363802360596034171167818310322276373120180985148650099673289383722502488957717848531612020897298448601714154586319660314294591620415272119454982220034319689607295960162971300417552364254983071768070124456169427638371140064235083443242844616326538396503937972586505546495649094344512270582463639152160238137952390380581401171977159154009407415523525096743009110916334144716516647041176989758534635251844947906038080852185583742296318878233394998111078843229681030277039104786225656992262073797524057992347971177720807155842376332851559276430280477639539393920006008737472164850104411971830120295750221200029811143140323763349636629725073624360001 - Integer(1)*3098214262599218784594285246258841485430681674561917573155883806818465520660668045042109232930382494608383663464454841313154390741655282039877410154577448327874989496074260116195788919037407420625081798124301494353693248757853222257918294662198297114746822817460991242508743651430439120439020484502408313310689912381846149597061657483084652685283853595100434135149479564507015504022249330340259111426799121454516345905101620532787348293877485702600390665276070250119465888154331218827342488849948540687659846652377277250614246402784754153678374932540789808703029043827352976139228402417432199779415751301480406673762521987999573209628597459357964214510139892316208670927074795773830798600837815329291912002136924506221066071242281626618211060464126372574400100990746934953437169840312584285942093951405864225230033279614235191326102697164613004299868695519642598882914862568516635347204441042798206770888274175592401790040170576311989738272102077819127459014286741435419468254146418098278519775722104890854275995510700298782146199325790002255362719776098816136732897323406228294203133323296591166026338391813696715894870956511298793595675308998014158717167429941371979636895553724830981754579086664608880698350866487717403917070872269853194118364230971216854931998642990452908852258008095741042117326241406479532880476938937997238098399302185675832474590293188864060116934035867037219176916416481757918864533515526389079998129329045569609325290897577497835388451456680707076072624629697883854217331728051953671643278797380171857920000*I/2103100954337624833663208713697737151593634525061637972297915388685604042449504336765884978184588688426595940401280828953096857809292320006227881797146858511436638446932833617514351442216409828605662238790280753075176269765767010004889778647709740770757817960711900340755635772183674511158570690702969774966791073165467918123298694584729211212414462628433370481195120564586361368504153395406845170075275051749019600057116719726628746724489572189061061036426955163696859127711110719502594479795200686212257570291758725259007379710596548777812659422174199194837355646482046783616494013289495563083118517507178847555801163089723056310287760875135196081975602765511153122381201303871673391366630940702817360340900568748719988954847590748960761446218262344767250783946365392689256634180417145926390656439421745644011831124277463643383712803287985472471755648426749842410972650924240795946699346613614779460399530274263580007672855851663196114585312432954432654691485867618908420370875753749297487803461900447407917655296784879220450937110470920633595689721819488638484547259978337741496090602390463594556401615298457456112485536498177883358587125449801777718900375736758266215245325999241624148841915093787519330809347240990363802360596034171167818310322276373120180985148650099673289383722502488957717848531612020897298448601714154586319660314294591620415272119454982220034319689607295960162971300417552364254983071768070124456169427638371140064235083443242844616326538396503937972586505546495649094344512270582463639152160238137952390380581401171977159154009407415523525096743009110916334144716516647041176989758534635251844947906038080852185583742296318878233394998111078843229681030277039104786225656992262073797524057992347971177720807155842376332851559276430280477639539393920006008737472164850104411971830120295750221200029811143140323763349636629725073624360001
+
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    assert exp(a*(2 + I*b)).expand(complex=True) == \
+        I*exp(2*a)*sin(a*b) + exp(2*a)*cos(a*b)
+
+
+def test_expand():
+    f = (16 - 2*sqrt(29))**2
+    assert f.expand() == 372 - 64*sqrt(29)
+    f = (Integer(1)/2 + I/2)**10
+    assert f.expand() == I/32
+    f = (Integer(1)/2 + I)**10
+    assert f.expand() == Integer(237)/1024 - 779*I/256
+
+
+def test_re_im1652():
+    x = Symbol('x')
+    assert re(x) == re(conjugate(x))
+    assert im(x) == - im(conjugate(x))
+    assert im(x)*re(conjugate(x)) + im(conjugate(x)) * re(x) == 0
+
+
+def test_issue_5084():
+    x = Symbol('x')
+    assert ((x + x*I)/(1 + I)).as_real_imag() == (re((x + I*x)/(1 + I)
+            ), im((x + I*x)/(1 + I)))
+
+
+def test_issue_5236():
+    assert (cos(1 + I)**3).as_real_imag() == (-3*sin(1)**2*sinh(1)**2*cos(1)*cosh(1) +
+        cos(1)**3*cosh(1)**3, -3*cos(1)**2*cosh(1)**2*sin(1)*sinh(1) + sin(1)**3*sinh(1)**3)
+
+
+def test_real_imag():
+    x, y, z = symbols('x, y, z')
+    X, Y, Z = symbols('X, Y, Z', commutative=False)
+    a = Symbol('a', real=True)
+    assert (2*a*x).as_real_imag() == (2*a*re(x), 2*a*im(x))
+
+    # issue 5395:
+    assert (x*x.conjugate()).as_real_imag() == (Abs(x)**2, 0)
+    assert im(x*x.conjugate()) == 0
+    assert im(x*y.conjugate()*z*y) == im(x*z)*Abs(y)**2
+    assert im(x*y.conjugate()*x*y) == im(x**2)*Abs(y)**2
+    assert im(Z*y.conjugate()*X*y) == im(Z*X)*Abs(y)**2
+    assert im(X*X.conjugate()) == im(X*X.conjugate(), evaluate=False)
+    assert (sin(x)*sin(x).conjugate()).as_real_imag() == \
+        (Abs(sin(x))**2, 0)
+
+    # issue 6573:
+    assert (x**2).as_real_imag() == (re(x)**2 - im(x)**2, 2*re(x)*im(x))
+
+    # issue 6428:
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+    assert (i*r*x).as_real_imag() == (I*i*r*im(x), -I*i*r*re(x))
+    assert (i*r*x*(y + 2)).as_real_imag() == (
+        I*i*r*(re(y) + 2)*im(x) + I*i*r*re(x)*im(y),
+        -I*i*r*(re(y) + 2)*re(x) + I*i*r*im(x)*im(y))
+
+    # issue 7106:
+    assert ((1 + I)/(1 - I)).as_real_imag() == (0, 1)
+    assert ((1 + 2*I)*(1 + 3*I)).as_real_imag() == (-5, 5)
+
+
+def test_pow_issue_1724():
+    e = ((S.NegativeOne)**(S.One/3))
+    assert e.conjugate().n() == e.n().conjugate()
+    e = S('-2/3 - (-29/54 + sqrt(93)/18)**(1/3) - 1/(9*(-29/54 + sqrt(93)/18)**(1/3))')
+    assert e.conjugate().n() == e.n().conjugate()
+    e = 2**I
+    assert e.conjugate().n() == e.n().conjugate()
+
+
+def test_issue_5429():
+    assert sqrt(I).conjugate() != sqrt(I)
+
+def test_issue_4124():
+    from sympy.core.numbers import oo
+    assert expand_complex(I*oo) == oo*I
+
+def test_issue_11518():
+    x = Symbol("x", real=True)
+    y = Symbol("y", real=True)
+    r = sqrt(x**2 + y**2)
+    assert conjugate(r) == r
+    s = abs(x + I * y)
+    assert conjugate(s) == r

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_constructor_postprocessor.py

@@ -0,0 +1,87 @@
+from sympy.core.basic import Basic
+from sympy.core.mul import Mul
+from sympy.core.symbol import (Symbol, symbols)
+
+from sympy.testing.pytest import XFAIL
+
+class SymbolInMulOnce(Symbol):
+    # Test class for a symbol that can only appear once in a `Mul` expression.
+    pass
+
+
+Basic._constructor_postprocessor_mapping[SymbolInMulOnce] = {
+    "Mul": [lambda x: x],
+    "Pow": [lambda x: x.base if isinstance(x.base, SymbolInMulOnce) else x],
+    "Add": [lambda x: x],
+}
+
+
+def _postprocess_SymbolRemovesOtherSymbols(expr):
+    args = tuple(i for i in expr.args if not isinstance(i, Symbol) or isinstance(i, SymbolRemovesOtherSymbols))
+    if args == expr.args:
+        return expr
+    return Mul.fromiter(args)
+
+
+class SymbolRemovesOtherSymbols(Symbol):
+    # Test class for a symbol that removes other symbols in `Mul`.
+    pass
+
+Basic._constructor_postprocessor_mapping[SymbolRemovesOtherSymbols] = {
+    "Mul": [_postprocess_SymbolRemovesOtherSymbols],
+}
+
+class SubclassSymbolInMulOnce(SymbolInMulOnce):
+    pass
+
+class SubclassSymbolRemovesOtherSymbols(SymbolRemovesOtherSymbols):
+    pass
+
+
+def test_constructor_postprocessors1():
+    x = SymbolInMulOnce("x")
+    y = SymbolInMulOnce("y")
+    assert isinstance(3*x, Mul)
+    assert (3*x).args == (3, x)
+    assert x*x == x
+    assert 3*x*x == 3*x
+    assert 2*x*x + x == 3*x
+    assert x**3*y*y == x*y
+    assert x**5 + y*x**3 == x + x*y
+
+    w = SymbolRemovesOtherSymbols("w")
+    assert x*w == w
+    assert (3*w).args == (3, w)
+    assert set((w + x).args) == {x, w}
+
+def test_constructor_postprocessors2():
+    x = SubclassSymbolInMulOnce("x")
+    y = SubclassSymbolInMulOnce("y")
+    assert isinstance(3*x, Mul)
+    assert (3*x).args == (3, x)
+    assert x*x == x
+    assert 3*x*x == 3*x
+    assert 2*x*x + x == 3*x
+    assert x**3*y*y == x*y
+    assert x**5 + y*x**3 == x + x*y
+
+    w = SubclassSymbolRemovesOtherSymbols("w")
+    assert x*w == w
+    assert (3*w).args == (3, w)
+    assert set((w + x).args) == {x, w}
+
+
+@XFAIL
+def test_subexpression_postprocessors():
+    # The postprocessors used to work with subexpressions, but the
+    # functionality was removed. See #15948.
+    a = symbols("a")
+    x = SymbolInMulOnce("x")
+    w = SymbolRemovesOtherSymbols("w")
+    assert 3*a*w**2 == 3*w**2
+    assert 3*a*x**3*w**2 == 3*w**2
+
+    x = SubclassSymbolInMulOnce("x")
+    w = SubclassSymbolRemovesOtherSymbols("w")
+    assert 3*a*w**2 == 3*w**2
+    assert 3*a*x**3*w**2 == 3*w**2

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_containers.py

@@ -0,0 +1,217 @@
+from collections import defaultdict
+
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.numbers import Integer
+from sympy.core.kind import NumberKind
+from sympy.matrices.common import MatrixKind
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.core.sympify import sympify
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import FiniteSet
+from sympy.core.containers import tuple_wrapper, TupleKind
+from sympy.core.expr import unchanged
+from sympy.core.function import Function, Lambda
+from sympy.core.relational import Eq
+from sympy.testing.pytest import raises
+from sympy.utilities.iterables import is_sequence, iterable
+
+from sympy.abc import x, y
+
+
+def test_Tuple():
+    t = (1, 2, 3, 4)
+    st = Tuple(*t)
+    assert set(sympify(t)) == set(st)
+    assert len(t) == len(st)
+    assert set(sympify(t[:2])) == set(st[:2])
+    assert isinstance(st[:], Tuple)
+    assert st == Tuple(1, 2, 3, 4)
+    assert st.func(*st.args) == st
+    p, q, r, s = symbols('p q r s')
+    t2 = (p, q, r, s)
+    st2 = Tuple(*t2)
+    assert st2.atoms() == set(t2)
+    assert st == st2.subs({p: 1, q: 2, r: 3, s: 4})
+    # issue 5505
+    assert all(isinstance(arg, Basic) for arg in st.args)
+    assert Tuple(p, 1).subs(p, 0) == Tuple(0, 1)
+    assert Tuple(p, Tuple(p, 1)).subs(p, 0) == Tuple(0, Tuple(0, 1))
+
+    assert Tuple(t2) == Tuple(Tuple(*t2))
+    assert Tuple.fromiter(t2) == Tuple(*t2)
+    assert Tuple.fromiter(x for x in range(4)) == Tuple(0, 1, 2, 3)
+    assert st2.fromiter(st2.args) == st2
+
+
+def test_Tuple_contains():
+    t1, t2 = Tuple(1), Tuple(2)
+    assert t1 in Tuple(1, 2, 3, t1, Tuple(t2))
+    assert t2 not in Tuple(1, 2, 3, t1, Tuple(t2))
+
+
+def test_Tuple_concatenation():
+    assert Tuple(1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+    assert (1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+    assert Tuple(1, 2) + (3, 4) == Tuple(1, 2, 3, 4)
+    raises(TypeError, lambda: Tuple(1, 2) + 3)
+    raises(TypeError, lambda: 1 + Tuple(2, 3))
+
+    #the Tuple case in __radd__ is only reached when a subclass is involved
+    class Tuple2(Tuple):
+        def __radd__(self, other):
+            return Tuple.__radd__(self, other + other)
+    assert Tuple(1, 2) + Tuple2(3, 4) == Tuple(1, 2, 1, 2, 3, 4)
+    assert Tuple2(1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+
+
+def test_Tuple_equality():
+    assert not isinstance(Tuple(1, 2), tuple)
+    assert (Tuple(1, 2) == (1, 2)) is True
+    assert (Tuple(1, 2) != (1, 2)) is False
+    assert (Tuple(1, 2) == (1, 3)) is False
+    assert (Tuple(1, 2) != (1, 3)) is True
+    assert (Tuple(1, 2) == Tuple(1, 2)) is True
+    assert (Tuple(1, 2) != Tuple(1, 2)) is False
+    assert (Tuple(1, 2) == Tuple(1, 3)) is False
+    assert (Tuple(1, 2) != Tuple(1, 3)) is True
+
+
+def test_Tuple_Eq():
+    assert Eq(Tuple(), Tuple()) is S.true
+    assert Eq(Tuple(1), 1) is S.false
+    assert Eq(Tuple(1, 2), Tuple(1)) is S.false
+    assert Eq(Tuple(1), Tuple(1)) is S.true
+    assert Eq(Tuple(1, 2), Tuple(1, 3)) is S.false
+    assert Eq(Tuple(1, 2), Tuple(1, 2)) is S.true
+    assert unchanged(Eq, Tuple(1, x), Tuple(1, 2))
+    assert Eq(Tuple(1, x), Tuple(1, 2)).subs(x, 2) is S.true
+    assert unchanged(Eq, Tuple(1, 2), x)
+    f = Function('f')
+    assert unchanged(Eq, Tuple(1), f(x))
+    assert Eq(Tuple(1), f(x)).subs(x, 1).subs(f, Lambda(y, (y,))) is S.true
+
+
+def test_Tuple_comparision():
+    assert (Tuple(1, 3) >= Tuple(-10, 30)) is S.true
+    assert (Tuple(1, 3) <= Tuple(-10, 30)) is S.false
+    assert (Tuple(1, 3) >= Tuple(1, 3)) is S.true
+    assert (Tuple(1, 3) <= Tuple(1, 3)) is S.true
+
+
+def test_Tuple_tuple_count():
+    assert Tuple(0, 1, 2, 3).tuple_count(4) == 0
+    assert Tuple(0, 4, 1, 2, 3).tuple_count(4) == 1
+    assert Tuple(0, 4, 1, 4, 2, 3).tuple_count(4) == 2
+    assert Tuple(0, 4, 1, 4, 2, 4, 3).tuple_count(4) == 3
+
+
+def test_Tuple_index():
+    assert Tuple(4, 0, 1, 2, 3).index(4) == 0
+    assert Tuple(0, 4, 1, 2, 3).index(4) == 1
+    assert Tuple(0, 1, 4, 2, 3).index(4) == 2
+    assert Tuple(0, 1, 2, 4, 3).index(4) == 3
+    assert Tuple(0, 1, 2, 3, 4).index(4) == 4
+
+    raises(ValueError, lambda: Tuple(0, 1, 2, 3).index(4))
+    raises(ValueError, lambda: Tuple(4, 0, 1, 2, 3).index(4, 1))
+    raises(ValueError, lambda: Tuple(0, 1, 2, 3, 4).index(4, 1, 4))
+
+
+def test_Tuple_mul():
+    assert Tuple(1, 2, 3)*2 == Tuple(1, 2, 3, 1, 2, 3)
+    assert 2*Tuple(1, 2, 3) == Tuple(1, 2, 3, 1, 2, 3)
+    assert Tuple(1, 2, 3)*Integer(2) == Tuple(1, 2, 3, 1, 2, 3)
+    assert Integer(2)*Tuple(1, 2, 3) == Tuple(1, 2, 3, 1, 2, 3)
+
+    raises(TypeError, lambda: Tuple(1, 2, 3)*S.Half)
+    raises(TypeError, lambda: S.Half*Tuple(1, 2, 3))
+
+
+def test_tuple_wrapper():
+
+    @tuple_wrapper
+    def wrap_tuples_and_return(*t):
+        return t
+
+    p = symbols('p')
+    assert wrap_tuples_and_return(p, 1) == (p, 1)
+    assert wrap_tuples_and_return((p, 1)) == (Tuple(p, 1),)
+    assert wrap_tuples_and_return(1, (p, 2), 3) == (1, Tuple(p, 2), 3)
+
+
+def test_iterable_is_sequence():
+    ordered = [[], (), Tuple(), Matrix([[]])]
+    unordered = [set()]
+    not_sympy_iterable = [{}, '', '']
+    assert all(is_sequence(i) for i in ordered)
+    assert all(not is_sequence(i) for i in unordered)
+    assert all(iterable(i) for i in ordered + unordered)
+    assert all(not iterable(i) for i in not_sympy_iterable)
+    assert all(iterable(i, exclude=None) for i in not_sympy_iterable)
+
+
+def test_TupleKind():
+    kind = TupleKind(NumberKind, MatrixKind(NumberKind))
+    assert Tuple(1, Matrix([1, 2])).kind is kind
+    assert Tuple(1, 2).kind is TupleKind(NumberKind, NumberKind)
+    assert Tuple(1, 2).kind.element_kind == (NumberKind, NumberKind)
+
+
+def test_Dict():
+    x, y, z = symbols('x y z')
+    d = Dict({x: 1, y: 2, z: 3})
+    assert d[x] == 1
+    assert d[y] == 2
+    raises(KeyError, lambda: d[2])
+    raises(KeyError, lambda: d['2'])
+    assert len(d) == 3
+    assert set(d.keys()) == {x, y, z}
+    assert set(d.values()) == {S.One, S(2), S(3)}
+    assert d.get(5, 'default') == 'default'
+    assert d.get('5', 'default') == 'default'
+    assert x in d and z in d and 5 not in d and '5' not in d
+    assert d.has(x) and d.has(1)  # SymPy Basic .has method
+
+    # Test input types
+    # input - a Python dict
+    # input - items as args - SymPy style
+    assert (Dict({x: 1, y: 2, z: 3}) ==
+            Dict((x, 1), (y, 2), (z, 3)))
+
+    raises(TypeError, lambda: Dict(((x, 1), (y, 2), (z, 3))))
+    with raises(NotImplementedError):
+        d[5] = 6  # assert immutability
+
+    assert set(
+        d.items()) == {Tuple(x, S.One), Tuple(y, S(2)), Tuple(z, S(3))}
+    assert set(d) == {x, y, z}
+    assert str(d) == '{x: 1, y: 2, z: 3}'
+    assert d.__repr__() == '{x: 1, y: 2, z: 3}'
+
+    # Test creating a Dict from a Dict.
+    d = Dict({x: 1, y: 2, z: 3})
+    assert d == Dict(d)
+
+    # Test for supporting defaultdict
+    d = defaultdict(int)
+    assert d[x] == 0
+    assert d[y] == 0
+    assert d[z] == 0
+    assert Dict(d)
+    d = Dict(d)
+    assert len(d) == 3
+    assert set(d.keys()) == {x, y, z}
+    assert set(d.values()) == {S.Zero, S.Zero, S.Zero}
+
+
+def test_issue_5788():
+    args = [(1, 2), (2, 1)]
+    for o in [Dict, Tuple, FiniteSet]:
+        # __eq__ and arg handling
+        if o != Tuple:
+            assert o(*args) == o(*reversed(args))
+        pair = [o(*args), o(*reversed(args))]
+        assert sorted(pair) == sorted(pair)
+        assert set(o(*args))  # doesn't fail

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_count_ops.py

@@ -0,0 +1,155 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import (Derivative, Function, count_ops)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import (Eq, Rel)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Equivalent, ITE, Implies, Nand,
+    Nor, Not, Or, Xor)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.core.containers import Tuple
+
+x, y, z = symbols('x,y,z')
+a, b, c = symbols('a,b,c')
+
+def test_count_ops_non_visual():
+    def count(val):
+        return count_ops(val, visual=False)
+    assert count(x) == 0
+    assert count(x) is not S.Zero
+    assert count(x + y) == 1
+    assert count(x + y) is not S.One
+    assert count(x + y*x + 2*y) == 4
+    assert count({x + y: x}) == 1
+    assert count({x + y: S(2) + x}) is not S.One
+    assert count(x < y) == 1
+    assert count(Or(x,y)) == 1
+    assert count(And(x,y)) == 1
+    assert count(Not(x)) == 1
+    assert count(Nor(x,y)) == 2
+    assert count(Nand(x,y)) == 2
+    assert count(Xor(x,y)) == 1
+    assert count(Implies(x,y)) == 1
+    assert count(Equivalent(x,y)) == 1
+    assert count(ITE(x,y,z)) == 1
+    assert count(ITE(True,x,y)) == 0
+
+
+def test_count_ops_visual():
+    ADD, MUL, POW, SIN, COS, EXP, AND, D, G, M = symbols(
+        'Add Mul Pow sin cos exp And Derivative Integral Sum'.upper())
+    DIV, SUB, NEG = symbols('DIV SUB NEG')
+    LT, LE, GT, GE, EQ, NE = symbols('LT LE GT GE EQ NE')
+    NOT, OR, AND, XOR, IMPLIES, EQUIVALENT, _ITE, BASIC, TUPLE = symbols(
+        'Not Or And Xor Implies Equivalent ITE Basic Tuple'.upper())
+
+    def count(val):
+        return count_ops(val, visual=True)
+
+    assert count(7) is S.Zero
+    assert count(S(7)) is S.Zero
+    assert count(-1) == NEG
+    assert count(-2) == NEG
+    assert count(S(2)/3) == DIV
+    assert count(Rational(2, 3)) == DIV
+    assert count(pi/3) == DIV
+    assert count(-pi/3) == DIV + NEG
+    assert count(I - 1) == SUB
+    assert count(1 - I) == SUB
+    assert count(1 - 2*I) == SUB + MUL
+
+    assert count(x) is S.Zero
+    assert count(-x) == NEG
+    assert count(-2*x/3) == NEG + DIV + MUL
+    assert count(Rational(-2, 3)*x) == NEG + DIV + MUL
+    assert count(1/x) == DIV
+    assert count(1/(x*y)) == DIV + MUL
+    assert count(-1/x) == NEG + DIV
+    assert count(-2/x) == NEG + DIV
+    assert count(x/y) == DIV
+    assert count(-x/y) == NEG + DIV
+
+    assert count(x**2) == POW
+    assert count(-x**2) == POW + NEG
+    assert count(-2*x**2) == POW + MUL + NEG
+
+    assert count(x + pi/3) == ADD + DIV
+    assert count(x + S.One/3) == ADD + DIV
+    assert count(x + Rational(1, 3)) == ADD + DIV
+    assert count(x + y) == ADD
+    assert count(x - y) == SUB
+    assert count(y - x) == SUB
+    assert count(-1/(x - y)) == DIV + NEG + SUB
+    assert count(-1/(y - x)) == DIV + NEG + SUB
+    assert count(1 + x**y) == ADD + POW
+    assert count(1 + x + y) == 2*ADD
+    assert count(1 + x + y + z) == 3*ADD
+    assert count(1 + x**y + 2*x*y + y**2) == 3*ADD + 2*POW + 2*MUL
+    assert count(2*z + y + x + 1) == 3*ADD + MUL
+    assert count(2*z + y**17 + x + 1) == 3*ADD + MUL + POW
+    assert count(2*z + y**17 + x + sin(x)) == 3*ADD + POW + MUL + SIN
+    assert count(2*z + y**17 + x + sin(x**2)) == 3*ADD + MUL + 2*POW + SIN
+    assert count(2*z + y**17 + x + sin(
+        x**2) + exp(cos(x))) == 4*ADD + MUL + 2*POW + EXP + COS + SIN
+
+    assert count(Derivative(x, x)) == D
+    assert count(Integral(x, x) + 2*x/(1 + x)) == G + DIV + MUL + 2*ADD
+    assert count(Sum(x, (x, 1, x + 1)) + 2*x/(1 + x)) == M + DIV + MUL + 3*ADD
+    assert count(Basic()) is S.Zero
+
+    assert count({x + 1: sin(x)}) == ADD + SIN
+    assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD
+    assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2*ADD
+    assert count({}) is S.Zero
+    assert count([x + 1, sin(x)*y, None]) == SIN + ADD + MUL
+    assert count([]) is S.Zero
+
+    assert count(Basic()) == 0
+    assert count(Basic(Basic(),Basic(x,x+y))) == ADD + 2*BASIC
+    assert count(Basic(x, x + y)) == ADD + BASIC
+    assert [count(Rel(x, y, op)) for op in '< <= > >= == <> !='.split()
+        ] == [LT, LE, GT, GE, EQ, NE, NE]
+    assert count(Or(x, y)) == OR
+    assert count(And(x, y)) == AND
+    assert count(Or(x, Or(y, And(z, a)))) == AND + OR
+    assert count(Nor(x, y)) == NOT + OR
+    assert count(Nand(x, y)) == NOT + AND
+    assert count(Xor(x, y)) == XOR
+    assert count(Implies(x, y)) == IMPLIES
+    assert count(Equivalent(x, y)) == EQUIVALENT
+    assert count(ITE(x, y, z)) == _ITE
+    assert count([Or(x, y), And(x, y), Basic(x + y)]
+        ) == ADD + AND + BASIC + OR
+
+    assert count(Basic(Tuple(x))) == BASIC + TUPLE
+    #It checks that TUPLE is counted as an operation.
+
+    assert count(Eq(x + y, S(2))) == ADD + EQ
+
+
+def test_issue_9324():
+    def count(val):
+        return count_ops(val, visual=False)
+
+    M = MatrixSymbol('M', 10, 10)
+    assert count(M[0, 0]) == 0
+    assert count(2 * M[0, 0] + M[5, 7]) == 2
+    P = MatrixSymbol('P', 3, 3)
+    Q = MatrixSymbol('Q', 3, 3)
+    assert count(P + Q) == 1
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True)
+    M = MatrixSymbol('M', m + n, m * m)
+    assert count(M[0, 1]) == 2
+
+
+def test_issue_21532():
+    f = Function('f')
+    g = Function('g')
+    FUNC_F, FUNC_G = symbols('FUNC_F, FUNC_G')
+    assert f(x).count_ops(visual=True) == FUNC_F
+    assert g(x).count_ops(visual=True) == FUNC_G

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_diff.py

@@ -0,0 +1,160 @@
+from sympy.concrete.summations import Sum
+from sympy.core.expr import Expr
+from sympy.core.function import (Derivative, Function, diff, Subs)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.testing.pytest import raises
+from sympy.abc import a, b, c, x, y, z
+
+def test_diff():
+    assert Rational(1, 3).diff(x) is S.Zero
+    assert I.diff(x) is S.Zero
+    assert pi.diff(x) is S.Zero
+    assert x.diff(x, 0) == x
+    assert (x**2).diff(x, 2, x) == 0
+    assert (x**2).diff((x, 2), x) == 0
+    assert (x**2).diff((x, 1), x) == 2
+    assert (x**2).diff((x, 1), (x, 1)) == 2
+    assert (x**2).diff((x, 2)) == 2
+    assert (x**2).diff(x, y, 0) == 2*x
+    assert (x**2).diff(x, (y, 0)) == 2*x
+    assert (x**2).diff(x, y) == 0
+    raises(ValueError, lambda: x.diff(1, x))
+
+    p = Rational(5)
+    e = a*b + b**p
+    assert e.diff(a) == b
+    assert e.diff(b) == a + 5*b**4
+    assert e.diff(b).diff(a) == Rational(1)
+    e = a*(b + c)
+    assert e.diff(a) == b + c
+    assert e.diff(b) == a
+    assert e.diff(b).diff(a) == Rational(1)
+    e = c**p
+    assert e.diff(c, 6) == Rational(0)
+    assert e.diff(c, 5) == Rational(120)
+    e = c**Rational(2)
+    assert e.diff(c) == 2*c
+    e = a*b*c
+    assert e.diff(c) == a*b
+
+
+def test_diff2():
+    n3 = Rational(3)
+    n2 = Rational(2)
+    n6 = Rational(6)
+
+    e = n3*(-n2 + x**n2)*cos(x) + x*(-n6 + x**n2)*sin(x)
+    assert e == 3*(-2 + x**2)*cos(x) + x*(-6 + x**2)*sin(x)
+    assert e.diff(x).expand() == x**3*cos(x)
+
+    e = (x + 1)**3
+    assert e.diff(x) == 3*(x + 1)**2
+    e = x*(x + 1)**3
+    assert e.diff(x) == (x + 1)**3 + 3*x*(x + 1)**2
+    e = 2*exp(x*x)*x
+    assert e.diff(x) == 2*exp(x**2) + 4*x**2*exp(x**2)
+
+
+def test_diff3():
+    p = Rational(5)
+    e = a*b + sin(b**p)
+    assert e == a*b + sin(b**5)
+    assert e.diff(a) == b
+    assert e.diff(b) == a + 5*b**4*cos(b**5)
+    e = tan(c)
+    assert e == tan(c)
+    assert e.diff(c) in [cos(c)**(-2), 1 + sin(c)**2/cos(c)**2, 1 + tan(c)**2]
+    e = c*log(c) - c
+    assert e == -c + c*log(c)
+    assert e.diff(c) == log(c)
+    e = log(sin(c))
+    assert e == log(sin(c))
+    assert e.diff(c) in [sin(c)**(-1)*cos(c), cot(c)]
+    e = (Rational(2)**a/log(Rational(2)))
+    assert e == 2**a*log(Rational(2))**(-1)
+    assert e.diff(a) == 2**a
+
+
+def test_diff_no_eval_derivative():
+    class My(Expr):
+        def __new__(cls, x):
+            return Expr.__new__(cls, x)
+
+    # My doesn't have its own _eval_derivative method
+    assert My(x).diff(x).func is Derivative
+    assert My(x).diff(x, 3).func is Derivative
+    assert re(x).diff(x, 2) == Derivative(re(x), (x, 2))  # issue 15518
+    assert diff(NDimArray([re(x), im(x)]), (x, 2)) == NDimArray(
+        [Derivative(re(x), (x, 2)), Derivative(im(x), (x, 2))])
+    # it doesn't have y so it shouldn't need a method for this case
+    assert My(x).diff(y) == 0
+
+
+def test_speed():
+    # this should return in 0.0s. If it takes forever, it's wrong.
+    assert x.diff(x, 10**8) == 0
+
+
+def test_deriv_noncommutative():
+    A = Symbol("A", commutative=False)
+    f = Function("f")
+    assert A*f(x)*A == f(x)*A**2
+    assert A*f(x).diff(x)*A == f(x).diff(x) * A**2
+
+
+def test_diff_nth_derivative():
+    f =  Function("f")
+    n = Symbol("n", integer=True)
+
+    expr = diff(sin(x), (x, n))
+    expr2 = diff(f(x), (x, 2))
+    expr3 = diff(f(x), (x, n))
+
+    assert expr.subs(sin(x), cos(-x)) == Derivative(cos(-x), (x, n))
+    assert expr.subs(n, 1).doit() == cos(x)
+    assert expr.subs(n, 2).doit() == -sin(x)
+
+    assert expr2.subs(Derivative(f(x), x), y) == Derivative(y, x)
+    # Currently not supported (cannot determine if `n > 1`):
+    #assert expr3.subs(Derivative(f(x), x), y) == Derivative(y, (x, n-1))
+    assert expr3 == Derivative(f(x), (x, n))
+
+    assert diff(x, (x, n)) == Piecewise((x, Eq(n, 0)), (1, Eq(n, 1)), (0, True))
+    assert diff(2*x, (x, n)).dummy_eq(
+        Sum(Piecewise((2*x*factorial(n)/(factorial(y)*factorial(-y + n)),
+        Eq(y, 0) & Eq(Max(0, -y + n), 0)),
+        (2*factorial(n)/(factorial(y)*factorial(-y + n)), Eq(y, 0) & Eq(Max(0,
+        -y + n), 1)), (0, True)), (y, 0, n)))
+    # TODO: assert diff(x**2, (x, n)) == x**(2-n)*ff(2, n)
+    exprm = x*sin(x)
+    mul_diff = diff(exprm, (x, n))
+    assert isinstance(mul_diff, Sum)
+    for i in range(5):
+        assert mul_diff.subs(n, i).doit() == exprm.diff((x, i)).expand()
+
+    exprm2 = 2*y*x*sin(x)*cos(x)*log(x)*exp(x)
+    dex = exprm2.diff((x, n))
+    assert isinstance(dex, Sum)
+    for i in range(7):
+        assert dex.subs(n, i).doit().expand() == \
+        exprm2.diff((x, i)).expand()
+
+    assert (cos(x)*sin(y)).diff([[x, y, z]]) == NDimArray([
+        -sin(x)*sin(y), cos(x)*cos(y), 0])
+
+
+def test_issue_16160():
+    assert Derivative(x**3, (x, x)).subs(x, 2) == Subs(
+        Derivative(x**3, (x, 2)), x, 2)
+    assert Derivative(1 + x**3, (x, x)).subs(x, 0
+        ) == Derivative(1 + y**3, (y, 0)).subs(y, 0)

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_equal.py

@@ -0,0 +1,89 @@
+from sympy.core.numbers import Rational
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.exponential import exp
+
+
+def test_equal():
+    b = Symbol("b")
+    a = Symbol("a")
+    e1 = a + b
+    e2 = 2*a*b
+    e3 = a**3*b**2
+    e4 = a*b + b*a
+    assert not e1 == e2
+    assert not e1 == e2
+    assert e1 != e2
+    assert e2 == e4
+    assert e2 != e3
+    assert not e2 == e3
+
+    x = Symbol("x")
+    e1 = exp(x + 1/x)
+    y = Symbol("x")
+    e2 = exp(y + 1/y)
+    assert e1 == e2
+    assert not e1 != e2
+    y = Symbol("y")
+    e2 = exp(y + 1/y)
+    assert not e1 == e2
+    assert e1 != e2
+
+    e5 = Rational(3) + 2*x - x - x
+    assert e5 == 3
+    assert 3 == e5
+    assert e5 != 4
+    assert 4 != e5
+    assert e5 != 3 + x
+    assert 3 + x != e5
+
+
+def test_expevalbug():
+    x = Symbol("x")
+    e1 = exp(1*x)
+    e3 = exp(x)
+    assert e1 == e3
+
+
+def test_cmp_bug1():
+    class T:
+        pass
+
+    t = T()
+    x = Symbol("x")
+
+    assert not (x == t)
+    assert (x != t)
+
+
+def test_cmp_bug2():
+    class T:
+        pass
+
+    t = T()
+
+    assert not (Symbol == t)
+    assert (Symbol != t)
+
+
+def test_cmp_issue_4357():
+    """ Check that Basic subclasses can be compared with sympifiable objects.
+
+    https://github.com/sympy/sympy/issues/4357
+    """
+    assert not (Symbol == 1)
+    assert (Symbol != 1)
+    assert not (Symbol == 'x')
+    assert (Symbol != 'x')
+
+
+def test_dummy_eq():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    u = Dummy('u')
+
+    assert (u**2 + 1).dummy_eq(x**2 + 1) is True
+    assert ((u**2 + 1) == (x**2 + 1)) is False
+
+    assert (u**2 + y).dummy_eq(x**2 + y, x) is True
+    assert (u**2 + y).dummy_eq(x**2 + y, y) is False

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_eval.py

@@ -0,0 +1,95 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, tan)
+from sympy.testing.pytest import XFAIL
+
+
+def test_add_eval():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Rational(1)
+    p = Rational(5)
+    assert a*b + c + p == a*b + 6
+    assert c + a + p == a + 6
+    assert c + a - p == a + (-4)
+    assert a + a == 2*a
+    assert a + p + a == 2*a + 5
+    assert c + p == Rational(6)
+    assert b + a - b == a
+
+
+def test_addmul_eval():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Rational(1)
+    p = Rational(5)
+    assert c + a + b*c + a - p == 2*a + b + (-4)
+    assert a*2 + p + a == a*2 + 5 + a
+    assert a*2 + p + a == 3*a + 5
+    assert a*2 + a == 3*a
+
+
+def test_pow_eval():
+    # XXX Pow does not fully support conversion of negative numbers
+    #     to their complex equivalent
+
+    assert sqrt(-1) == I
+
+    assert sqrt(-4) == 2*I
+    assert sqrt( 4) == 2
+    assert (8)**Rational(1, 3) == 2
+    assert (-8)**Rational(1, 3) == 2*((-1)**Rational(1, 3))
+
+    assert sqrt(-2) == I*sqrt(2)
+    assert (-1)**Rational(1, 3) != I
+    assert (-10)**Rational(1, 3) != I*((10)**Rational(1, 3))
+    assert (-2)**Rational(1, 4) != (2)**Rational(1, 4)
+
+    assert 64**Rational(1, 3) == 4
+    assert 64**Rational(2, 3) == 16
+    assert 24/sqrt(64) == 3
+    assert (-27)**Rational(1, 3) == 3*(-1)**Rational(1, 3)
+
+    assert (cos(2) / tan(2))**2 == (cos(2) / tan(2))**2
+
+
+@XFAIL
+def test_pow_eval_X1():
+    assert (-1)**Rational(1, 3) == S.Half + S.Half*I*sqrt(3)
+
+
+def test_mulpow_eval():
+    x = Symbol('x')
+    assert sqrt(50)/(sqrt(2)*x) == 5/x
+    assert sqrt(27)/sqrt(3) == 3
+
+
+def test_evalpow_bug():
+    x = Symbol("x")
+    assert 1/(1/x) == x
+    assert 1/(-1/x) == -x
+
+
+def test_symbol_expand():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    f = x**4*y**4
+    assert f == x**4*y**4
+    assert f == f.expand()
+
+    g = (x*y)**4
+    assert g == f
+    assert g.expand() == f
+    assert g.expand() == g.expand().expand()
+
+
+def test_function():
+    f, l = map(Function, 'fl')
+    x = Symbol('x')
+    assert exp(l(x))*l(x)/exp(l(x)) == l(x)
+    assert exp(f(x))*f(x)/exp(f(x)) == f(x)

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_evalf.py

@@ -0,0 +1,732 @@
+import math
+
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.evalf import N
+from sympy.core.function import (Function, nfloat)
+from sympy.core.mul import Mul
+from sympy.core import (GoldenRatio)
+from sympy.core.numbers import (AlgebraicNumber, E, Float, I, Rational,
+                                oo, zoo, nan, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.elementary.complexes import (Abs, re, im)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, cosh)
+from sympy.functions.elementary.integers import (ceiling, floor)
+from sympy.functions.elementary.miscellaneous import (Max, sqrt)
+from sympy.functions.elementary.trigonometric import (acos, atan, cos, sin, tan)
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.polys.polytools import factor
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.printing import srepr
+from sympy.printing.str import sstr
+from sympy.simplify.simplify import simplify
+from sympy.core.numbers import comp
+from sympy.core.evalf import (complex_accuracy, PrecisionExhausted,
+                              scaled_zero, get_integer_part, as_mpmath, evalf, _evalf_with_bounded_error)
+from mpmath import inf, ninf, make_mpc
+from mpmath.libmp.libmpf import from_float, fzero
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import n, x, y
+
+
+def NS(e, n=15, **options):
+    return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+
+def test_evalf_helpers():
+    from mpmath.libmp import finf
+    assert complex_accuracy((from_float(2.0), None, 35, None)) == 35
+    assert complex_accuracy((from_float(2.0), from_float(10.0), 35, 100)) == 37
+    assert complex_accuracy(
+        (from_float(2.0), from_float(1000.0), 35, 100)) == 43
+    assert complex_accuracy((from_float(2.0), from_float(10.0), 100, 35)) == 35
+    assert complex_accuracy(
+        (from_float(2.0), from_float(1000.0), 100, 35)) == 35
+    assert complex_accuracy(finf) == math.inf
+    assert complex_accuracy(zoo) == math.inf
+    raises(ValueError, lambda: get_integer_part(zoo, 1, {}))
+
+
+def test_evalf_basic():
+    assert NS('pi', 15) == '3.14159265358979'
+    assert NS('2/3', 10) == '0.6666666667'
+    assert NS('355/113-pi', 6) == '2.66764e-7'
+    assert NS('16*atan(1/5)-4*atan(1/239)', 15) == '3.14159265358979'
+
+
+def test_cancellation():
+    assert NS(Add(pi, Rational(1, 10**1000), -pi, evaluate=False), 15,
+              maxn=1200) == '1.00000000000000e-1000'
+
+
+def test_evalf_powers():
+    assert NS('pi**(10**20)', 10) == '1.339148777e+49714987269413385435'
+    assert NS(pi**(10**100), 10) == ('4.946362032e+4971498726941338543512682882'
+          '9089887365167832438044244613405349992494711208'
+          '95526746555473864642912223')
+    assert NS('2**(1/10**50)', 15) == '1.00000000000000'
+    assert NS('2**(1/10**50)-1', 15) == '6.93147180559945e-51'
+
+# Evaluation of Rump's ill-conditioned polynomial
+
+
+def test_evalf_rump():
+    a = 1335*y**6/4 + x**2*(11*x**2*y**2 - y**6 - 121*y**4 - 2) + 11*y**8/2 + x/(2*y)
+    assert NS(a, 15, subs={x: 77617, y: 33096}) == '-0.827396059946821'
+
+
+def test_evalf_complex():
+    assert NS('2*sqrt(pi)*I', 10) == '3.544907702*I'
+    assert NS('3+3*I', 15) == '3.00000000000000 + 3.00000000000000*I'
+    assert NS('E+pi*I', 15) == '2.71828182845905 + 3.14159265358979*I'
+    assert NS('pi * (3+4*I)', 15) == '9.42477796076938 + 12.5663706143592*I'
+    assert NS('I*(2+I)', 15) == '-1.00000000000000 + 2.00000000000000*I'
+
+
+@XFAIL
+def test_evalf_complex_bug():
+    assert NS('(pi+E*I)*(E+pi*I)', 15) in ('0.e-15 + 17.25866050002*I',
+              '0.e-17 + 17.25866050002*I', '-0.e-17 + 17.25866050002*I')
+
+
+def test_evalf_complex_powers():
+    assert NS('(E+pi*I)**100000000000000000') == \
+        '-3.58896782867793e+61850354284995199 + 4.58581754997159e+61850354284995199*I'
+    # XXX: rewrite if a+a*I simplification introduced in SymPy
+    #assert NS('(pi + pi*I)**2') in ('0.e-15 + 19.7392088021787*I', '0.e-16 + 19.7392088021787*I')
+    assert NS('(pi + pi*I)**2', chop=True) == '19.7392088021787*I'
+    assert NS(
+        '(pi + 1/10**8 + pi*I)**2') == '6.2831853e-8 + 19.7392088650106*I'
+    assert NS('(pi + 1/10**12 + pi*I)**2') == '6.283e-12 + 19.7392088021850*I'
+    assert NS('(pi + pi*I)**4', chop=True) == '-389.636364136010'
+    assert NS(
+        '(pi + 1/10**8 + pi*I)**4') == '-389.636366616512 + 2.4805021e-6*I'
+    assert NS('(pi + 1/10**12 + pi*I)**4') == '-389.636364136258 + 2.481e-10*I'
+    assert NS(
+        '(10000*pi + 10000*pi*I)**4', chop=True) == '-3.89636364136010e+18'
+
+
+@XFAIL
+def test_evalf_complex_powers_bug():
+    assert NS('(pi + pi*I)**4') == '-389.63636413601 + 0.e-14*I'
+
+
+def test_evalf_exponentiation():
+    assert NS(sqrt(-pi)) == '1.77245385090552*I'
+    assert NS(Pow(pi*I, Rational(
+        1, 2), evaluate=False)) == '1.25331413731550 + 1.25331413731550*I'
+    assert NS(pi**I) == '0.413292116101594 + 0.910598499212615*I'
+    assert NS(pi**(E + I/3)) == '20.8438653991931 + 8.36343473930031*I'
+    assert NS((pi + I/3)**(E + I/3)) == '17.2442906093590 + 13.6839376767037*I'
+    assert NS(exp(pi)) == '23.1406926327793'
+    assert NS(exp(pi + E*I)) == '-21.0981542849657 + 9.50576358282422*I'
+    assert NS(pi**pi) == '36.4621596072079'
+    assert NS((-pi)**pi) == '-32.9138577418939 - 15.6897116534332*I'
+    assert NS((-pi)**(-pi)) == '-0.0247567717232697 + 0.0118013091280262*I'
+
+# An example from Smith, "Multiple Precision Complex Arithmetic and Functions"
+
+
+def test_evalf_complex_cancellation():
+    A = Rational('63287/100000')
+    B = Rational('52498/100000')
+    C = Rational('69301/100000')
+    D = Rational('83542/100000')
+    F = Rational('2231321613/2500000000')
+    # XXX: the number of returned mantissa digits in the real part could
+    # change with the implementation. What matters is that the returned digits are
+    # correct; those that are showing now are correct.
+    # >>> ((A+B*I)*(C+D*I)).expand()
+    # 64471/10000000000 + 2231321613*I/2500000000
+    # >>> 2231321613*4
+    # 8925286452L
+    assert NS((A + B*I)*(C + D*I), 6) == '6.44710e-6 + 0.892529*I'
+    assert NS((A + B*I)*(C + D*I), 10) == '6.447100000e-6 + 0.8925286452*I'
+    assert NS((A + B*I)*(
+        C + D*I) - F*I, 5) in ('6.4471e-6 + 0.e-14*I', '6.4471e-6 - 0.e-14*I')
+
+
+def test_evalf_logs():
+    assert NS("log(3+pi*I)", 15) == '1.46877619736226 + 0.808448792630022*I'
+    assert NS("log(pi*I)", 15) == '1.14472988584940 + 1.57079632679490*I'
+    assert NS('log(-1 + 0.00001)', 2) == '-1.0e-5 + 3.1*I'
+    assert NS('log(100, 10, evaluate=False)', 15) == '2.00000000000000'
+    assert NS('-2*I*log(-(-1)**(S(1)/9))', 15) == '-5.58505360638185'
+
+
+def test_evalf_trig():
+    assert NS('sin(1)', 15) == '0.841470984807897'
+    assert NS('cos(1)', 15) == '0.540302305868140'
+    assert NS('sin(10**-6)', 15) == '9.99999999999833e-7'
+    assert NS('cos(10**-6)', 15) == '0.999999999999500'
+    assert NS('sin(E*10**100)', 15) == '0.409160531722613'
+    # Some input near roots
+    assert NS(sin(exp(pi*sqrt(163))*pi), 15) == '-2.35596641936785e-12'
+    assert NS(sin(pi*10**100 + Rational(7, 10**5), evaluate=False), 15, maxn=120) == \
+        '6.99999999428333e-5'
+    assert NS(sin(Rational(7, 10**5), evaluate=False), 15) == \
+        '6.99999999428333e-5'
+
+# Check detection of various false identities
+
+
+def test_evalf_near_integers():
+    # Binet's formula
+    f = lambda n: ((1 + sqrt(5))**n)/(2**n * sqrt(5))
+    assert NS(f(5000) - fibonacci(5000), 10, maxn=1500) == '5.156009964e-1046'
+    # Some near-integer identities from
+    # http://mathworld.wolfram.com/AlmostInteger.html
+    assert NS('sin(2017*2**(1/5))', 15) == '-1.00000000000000'
+    assert NS('sin(2017*2**(1/5))', 20) == '-0.99999999999999997857'
+    assert NS('1+sin(2017*2**(1/5))', 15) == '2.14322287389390e-17'
+    assert NS('45 - 613*E/37 + 35/991', 15) == '6.03764498766326e-11'
+
+
+def test_evalf_ramanujan():
+    assert NS(exp(pi*sqrt(163)) - 640320**3 - 744, 10) == '-7.499274028e-13'
+    # A related identity
+    A = 262537412640768744*exp(-pi*sqrt(163))
+    B = 196884*exp(-2*pi*sqrt(163))
+    C = 103378831900730205293632*exp(-3*pi*sqrt(163))
+    assert NS(1 - A - B + C, 10) == '1.613679005e-59'
+
+# Input that for various reasons have failed at some point
+
+
+def test_evalf_bugs():
+    assert NS(sin(1) + exp(-10**10), 10) == NS(sin(1), 10)
+    assert NS(exp(10**10) + sin(1), 10) == NS(exp(10**10), 10)
+    assert NS('expand_log(log(1+1/10**50))', 20) == '1.0000000000000000000e-50'
+    assert NS('log(10**100,10)', 10) == '100.0000000'
+    assert NS('log(2)', 10) == '0.6931471806'
+    assert NS(
+        '(sin(x)-x)/x**3', 15, subs={x: '1/10**50'}) == '-0.166666666666667'
+    assert NS(sin(1) + Rational(
+        1, 10**100)*I, 15) == '0.841470984807897 + 1.00000000000000e-100*I'
+    assert x.evalf() == x
+    assert NS((1 + I)**2*I, 6) == '-2.00000'
+    d = {n: (
+        -1)**Rational(6, 7), y: (-1)**Rational(4, 7), x: (-1)**Rational(2, 7)}
+    assert NS((x*(1 + y*(1 + n))).subs(d).evalf(), 6) == '0.346011 + 0.433884*I'
+    assert NS(((-I - sqrt(2)*I)**2).evalf()) == '-5.82842712474619'
+    assert NS((1 + I)**2*I, 15) == '-2.00000000000000'
+    # issue 4758 (1/2):
+    assert NS(pi.evalf(69) - pi) == '-4.43863937855894e-71'
+    # issue 4758 (2/2): With the bug present, this still only fails if the
+    # terms are in the order given here. This is not generally the case,
+    # because the order depends on the hashes of the terms.
+    assert NS(20 - 5008329267844*n**25 - 477638700*n**37 - 19*n,
+              subs={n: .01}) == '19.8100000000000'
+    assert NS(((x - 1)*(1 - x)**1000).n()
+              ) == '(1.00000000000000 - x)**1000*(x - 1.00000000000000)'
+    assert NS((-x).n()) == '-x'
+    assert NS((-2*x).n()) == '-2.00000000000000*x'
+    assert NS((-2*x*y).n()) == '-2.00000000000000*x*y'
+    assert cos(x).n(subs={x: 1+I}) == cos(x).subs(x, 1+I).n()
+    # issue 6660. Also NaN != mpmath.nan
+    # In this order:
+    # 0*nan, 0/nan, 0*inf, 0/inf
+    # 0+nan, 0-nan, 0+inf, 0-inf
+    # >>> n = Some Number
+    # n*nan, n/nan, n*inf, n/inf
+    # n+nan, n-nan, n+inf, n-inf
+    assert (0*E**(oo)).n() is S.NaN
+    assert (0/E**(oo)).n() is S.Zero
+
+    assert (0+E**(oo)).n() is S.Infinity
+    assert (0-E**(oo)).n() is S.NegativeInfinity
+
+    assert (5*E**(oo)).n() is S.Infinity
+    assert (5/E**(oo)).n() is S.Zero
+
+    assert (5+E**(oo)).n() is S.Infinity
+    assert (5-E**(oo)).n() is S.NegativeInfinity
+
+    #issue 7416
+    assert as_mpmath(0.0, 10, {'chop': True}) == 0
+
+    #issue 5412
+    assert ((oo*I).n() == S.Infinity*I)
+    assert ((oo+oo*I).n() == S.Infinity + S.Infinity*I)
+
+    #issue 11518
+    assert NS(2*x**2.5, 5) == '2.0000*x**2.5000'
+
+    #issue 13076
+    assert NS(Mul(Max(0, y), x, evaluate=False).evalf()) == 'x*Max(0, y)'
+
+    #issue 18516
+    assert NS(log(S(3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376)/36360291795869936842385267079543319118023385026001623040346035832580600191583895484198508262979388783308179702534403855752855931517013066142992430916562025780021771247847643450125342836565813209972590371590152578728008385990139795377610001).evalf(15, chop=True)) == '-oo'
+
+
+def test_evalf_integer_parts():
+    a = floor(log(8)/log(2) - exp(-1000), evaluate=False)
+    b = floor(log(8)/log(2), evaluate=False)
+    assert a.evalf() == 3.0
+    assert b.evalf() == 3.0
+    # equals, as a fallback, can still fail but it might succeed as here
+    assert ceiling(10*(sin(1)**2 + cos(1)**2)) == 10
+
+    assert int(floor(factorial(50)/E, evaluate=False).evalf(70)) == \
+        int(11188719610782480504630258070757734324011354208865721592720336800)
+    assert int(ceiling(factorial(50)/E, evaluate=False).evalf(70)) == \
+        int(11188719610782480504630258070757734324011354208865721592720336801)
+    assert int(floor(GoldenRatio**999 / sqrt(5) + S.Half)
+               .evalf(1000)) == fibonacci(999)
+    assert int(floor(GoldenRatio**1000 / sqrt(5) + S.Half)
+               .evalf(1000)) == fibonacci(1000)
+
+    assert ceiling(x).evalf(subs={x: 3}) == 3.0
+    assert ceiling(x).evalf(subs={x: 3*I}) == 3.0*I
+    assert ceiling(x).evalf(subs={x: 2 + 3*I}) == 2.0 + 3.0*I
+    assert ceiling(x).evalf(subs={x: 3.}) == 3.0
+    assert ceiling(x).evalf(subs={x: 3.*I}) == 3.0*I
+    assert ceiling(x).evalf(subs={x: 2. + 3*I}) == 2.0 + 3.0*I
+
+    assert float((floor(1.5, evaluate=False)+1/9).evalf()) == 1 + 1/9
+    assert float((floor(0.5, evaluate=False)+20).evalf()) == 20
+
+    # issue 19991
+    n = 1169809367327212570704813632106852886389036911
+    r = 744723773141314414542111064094745678855643068
+
+    assert floor(n / (pi / 2)) == r
+    assert floor(80782 * sqrt(2)) == 114242
+
+    # issue 20076
+    assert 260515 - floor(260515/pi + 1/2) * pi == atan(tan(260515))
+
+
+def test_evalf_trig_zero_detection():
+    a = sin(160*pi, evaluate=False)
+    t = a.evalf(maxn=100)
+    assert abs(t) < 1e-100
+    assert t._prec < 2
+    assert a.evalf(chop=True) == 0
+    raises(PrecisionExhausted, lambda: a.evalf(strict=True))
+
+
+def test_evalf_sum():
+    assert Sum(n,(n,1,2)).evalf() == 3.
+    assert Sum(n,(n,1,2)).doit().evalf() == 3.
+    # the next test should return instantly
+    assert Sum(1/n,(n,1,2)).evalf() == 1.5
+
+    # issue 8219
+    assert Sum(E/factorial(n), (n, 0, oo)).evalf() == (E*E).evalf()
+    # issue 8254
+    assert Sum(2**n*n/factorial(n), (n, 0, oo)).evalf() == (2*E*E).evalf()
+    # issue 8411
+    s = Sum(1/x**2, (x, 100, oo))
+    assert s.n() == s.doit().n()
+
+
+def test_evalf_divergent_series():
+    raises(ValueError, lambda: Sum(1/n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(n/(n**2 + 1), (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(n**2, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(2**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-2)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((2*n + 3)/(3*n**2 + 4), (n, 0, oo)).evalf())
+    raises(ValueError, lambda: Sum((0.5*n**3)/(n**4 + 1), (n, 0, oo)).evalf())
+
+
+def test_evalf_product():
+    assert Product(n, (n, 1, 10)).evalf() == 3628800.
+    assert comp(Product(1 - S.Half**2/n**2, (n, 1, oo)).n(5), 0.63662)
+    assert Product(n, (n, -1, 3)).evalf() == 0
+
+
+def test_evalf_py_methods():
+    assert abs(float(pi + 1) - 4.1415926535897932) < 1e-10
+    assert abs(complex(pi + 1) - 4.1415926535897932) < 1e-10
+    assert abs(
+        complex(pi + E*I) - (3.1415926535897931 + 2.7182818284590451j)) < 1e-10
+    raises(TypeError, lambda: float(pi + x))
+
+
+def test_evalf_power_subs_bugs():
+    assert (x**2).evalf(subs={x: 0}) == 0
+    assert sqrt(x).evalf(subs={x: 0}) == 0
+    assert (x**Rational(2, 3)).evalf(subs={x: 0}) == 0
+    assert (x**x).evalf(subs={x: 0}) == 1.0
+    assert (3**x).evalf(subs={x: 0}) == 1.0
+    assert exp(x).evalf(subs={x: 0}) == 1.0
+    assert ((2 + I)**x).evalf(subs={x: 0}) == 1.0
+    assert (0**x).evalf(subs={x: 0}) == 1.0
+
+
+def test_evalf_arguments():
+    raises(TypeError, lambda: pi.evalf(method="garbage"))
+
+
+def test_implemented_function_evalf():
+    from sympy.utilities.lambdify import implemented_function
+    f = Function('f')
+    f = implemented_function(f, lambda x: x + 1)
+    assert str(f(x)) == "f(x)"
+    assert str(f(2)) == "f(2)"
+    assert f(2).evalf() == 3.0
+    assert f(x).evalf() == f(x)
+    f = implemented_function(Function('sin'), lambda x: x + 1)
+    assert f(2).evalf() != sin(2)
+    del f._imp_     # XXX: due to caching _imp_ would influence all other tests
+
+
+def test_evaluate_false():
+    for no in [0, False]:
+        assert Add(3, 2, evaluate=no).is_Add
+        assert Mul(3, 2, evaluate=no).is_Mul
+        assert Pow(3, 2, evaluate=no).is_Pow
+    assert Pow(y, 2, evaluate=True) - Pow(y, 2, evaluate=True) == 0
+
+
+def test_evalf_relational():
+    assert Eq(x/5, y/10).evalf() == Eq(0.2*x, 0.1*y)
+    # if this first assertion fails it should be replaced with
+    # one that doesn't
+    assert unchanged(Eq, (3 - I)**2/2 + I, 0)
+    assert Eq((3 - I)**2/2 + I, 0).n() is S.false
+    assert nfloat(Eq((3 - I)**2 + I, 0)) == S.false
+
+
+def test_issue_5486():
+    assert not cos(sqrt(0.5 + I)).n().is_Function
+
+
+def test_issue_5486_bug():
+    from sympy.core.expr import Expr
+    from sympy.core.numbers import I
+    assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
+
+
+def test_bugs():
+    from sympy.functions.elementary.complexes import (polar_lift, re)
+
+    assert abs(re((1 + I)**2)) < 1e-15
+
+    # anything that evalf's to 0 will do in place of polar_lift
+    assert abs(polar_lift(0)).n() == 0
+
+
+def test_subs():
+    assert NS('besseli(-x, y) - besseli(x, y)', subs={x: 3.5, y: 20.0}) == \
+        '-4.92535585957223e-10'
+    assert NS('Piecewise((x, x>0)) + Piecewise((1-x, x>0))', subs={x: 0.1}) == \
+        '1.00000000000000'
+    raises(TypeError, lambda: x.evalf(subs=(x, 1)))
+
+
+def test_issue_4956_5204():
+    # issue 4956
+    v = S('''(-27*12**(1/3)*sqrt(31)*I +
+    27*2**(2/3)*3**(1/3)*sqrt(31)*I)/(-2511*2**(2/3)*3**(1/3) +
+    (29*18**(1/3) + 9*2**(1/3)*3**(2/3)*sqrt(31)*I +
+    87*2**(1/3)*3**(1/6)*I)**2)''')
+    assert NS(v, 1) == '0.e-118 - 0.e-118*I'
+
+    # issue 5204
+    v = S('''-(357587765856 + 18873261792*249**(1/2) + 56619785376*I*83**(1/2) +
+    108755765856*I*3**(1/2) + 41281887168*6**(1/3)*(1422 +
+    54*249**(1/2))**(1/3) - 1239810624*6**(1/3)*249**(1/2)*(1422 +
+    54*249**(1/2))**(1/3) - 3110400000*I*6**(1/3)*83**(1/2)*(1422 +
+    54*249**(1/2))**(1/3) + 13478400000*I*3**(1/2)*6**(1/3)*(1422 +
+    54*249**(1/2))**(1/3) + 1274950152*6**(2/3)*(1422 +
+    54*249**(1/2))**(2/3) + 32347944*6**(2/3)*249**(1/2)*(1422 +
+    54*249**(1/2))**(2/3) - 1758790152*I*3**(1/2)*6**(2/3)*(1422 +
+    54*249**(1/2))**(2/3) - 304403832*I*6**(2/3)*83**(1/2)*(1422 +
+    4*249**(1/2))**(2/3))/(175732658352 + (1106028 + 25596*249**(1/2) +
+    76788*I*83**(1/2))**2)''')
+    assert NS(v, 5) == '0.077284 + 1.1104*I'
+    assert NS(v, 1) == '0.08 + 1.*I'
+
+
+def test_old_docstring():
+    a = (E + pi*I)*(E - pi*I)
+    assert NS(a) == '17.2586605000200'
+    assert a.n() == 17.25866050002001
+
+
+def test_issue_4806():
+    assert integrate(atan(x)**2, (x, -1, 1)).evalf().round(1) == Float(0.5, 1)
+    assert atan(0, evaluate=False).n() == 0
+
+
+def test_evalf_mul():
+    # SymPy should not try to expand this; it should be handled term-wise
+    # in evalf through mpmath
+    assert NS(product(1 + sqrt(n)*I, (n, 1, 500)), 1) == '5.e+567 + 2.e+568*I'
+
+
+def test_scaled_zero():
+    a, b = (([0], 1, 100, 1), -1)
+    assert scaled_zero(100) == (a, b)
+    assert scaled_zero(a) == (0, 1, 100, 1)
+    a, b = (([1], 1, 100, 1), -1)
+    assert scaled_zero(100, -1) == (a, b)
+    assert scaled_zero(a) == (1, 1, 100, 1)
+    raises(ValueError, lambda: scaled_zero(scaled_zero(100)))
+    raises(ValueError, lambda: scaled_zero(100, 2))
+    raises(ValueError, lambda: scaled_zero(100, 0))
+    raises(ValueError, lambda: scaled_zero((1, 5, 1, 3)))
+
+
+def test_chop_value():
+    for i in range(-27, 28):
+        assert (Pow(10, i)*2).n(chop=10**i) and not (Pow(10, i)).n(chop=10**i)
+
+
+def test_infinities():
+    assert oo.evalf(chop=True) == inf
+    assert (-oo).evalf(chop=True) == ninf
+
+
+def test_to_mpmath():
+    assert sqrt(3)._to_mpmath(20)._mpf_ == (0, int(908093), -19, 20)
+    assert S(3.2)._to_mpmath(20)._mpf_ == (0, int(838861), -18, 20)
+
+
+def test_issue_6632_evalf():
+    add = (-100000*sqrt(2500000001) + 5000000001)
+    assert add.n() == 9.999999998e-11
+    assert (add*add).n() == 9.999999996e-21
+
+
+def test_issue_4945():
+    from sympy.abc import H
+    assert (H/0).evalf(subs={H:1}) == zoo
+
+
+def test_evalf_integral():
+    # test that workprec has to increase in order to get a result other than 0
+    eps = Rational(1, 1000000)
+    assert Integral(sin(x), (x, -pi, pi + eps)).n(2)._prec == 10
+
+
+def test_issue_8821_highprec_from_str():
+    s = str(pi.evalf(128))
+    p = N(s)
+    assert Abs(sin(p)) < 1e-15
+    p = N(s, 64)
+    assert Abs(sin(p)) < 1e-64
+
+
+def test_issue_8853():
+    p = Symbol('x', even=True, positive=True)
+    assert floor(-p - S.Half).is_even == False
+    assert floor(-p + S.Half).is_even == True
+    assert ceiling(p - S.Half).is_even == True
+    assert ceiling(p + S.Half).is_even == False
+
+    assert get_integer_part(S.Half, -1, {}, True) == (0, 0)
+    assert get_integer_part(S.Half, 1, {}, True) == (1, 0)
+    assert get_integer_part(Rational(-1, 2), -1, {}, True) == (-1, 0)
+    assert get_integer_part(Rational(-1, 2), 1, {}, True) == (0, 0)
+
+
+def test_issue_17681():
+    class identity_func(Function):
+
+        def _eval_evalf(self, *args, **kwargs):
+            return self.args[0].evalf(*args, **kwargs)
+
+    assert floor(identity_func(S(0))) == 0
+    assert get_integer_part(S(0), 1, {}, True) == (0, 0)
+
+
+def test_issue_9326():
+    from sympy.core.symbol import Dummy
+    d1 = Dummy('d')
+    d2 = Dummy('d')
+    e = d1 + d2
+    assert e.evalf(subs = {d1: 1, d2: 2}) == 3.0
+
+
+def test_issue_10323():
+    assert ceiling(sqrt(2**30 + 1)) == 2**15 + 1
+
+
+def test_AssocOp_Function():
+    # the first arg of Min is not comparable in the imaginary part
+    raises(ValueError, lambda: S('''
+    Min(-sqrt(3)*cos(pi/18)/6 + re(1/((-1/2 - sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3 + sin(pi/18)/2 + 2 + I*(-cos(pi/18)/2 -
+    sqrt(3)*sin(pi/18)/6 + im(1/((-1/2 - sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3), re(1/((-1/2 + sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3 - sqrt(3)*cos(pi/18)/6 - sin(pi/18)/2 + 2 +
+    I*(im(1/((-1/2 + sqrt(3)*I/2)*(1/6 + sqrt(3)*I/18)**(1/3)))/3 -
+    sqrt(3)*sin(pi/18)/6 + cos(pi/18)/2))'''))
+    # if that is changed so a non-comparable number remains as
+    # an arg, then the Min/Max instantiation needs to be changed
+    # to watch out for non-comparable args when making simplifications
+    # and the following test should be added instead (with e being
+    # the sympified expression above):
+    # raises(ValueError, lambda: e._eval_evalf(2))
+
+
+def test_issue_10395():
+    eq = x*Max(0, y)
+    assert nfloat(eq) == eq
+    eq = x*Max(y, -1.1)
+    assert nfloat(eq) == eq
+    assert Max(y, 4).n() == Max(4.0, y)
+
+
+def test_issue_13098():
+    assert floor(log(S('9.'+'9'*20), 10)) == 0
+    assert ceiling(log(S('9.'+'9'*20), 10)) == 1
+    assert floor(log(20 - S('9.'+'9'*20), 10)) == 1
+    assert ceiling(log(20 - S('9.'+'9'*20), 10)) == 2
+
+
+def test_issue_14601():
+    e = 5*x*y/2 - y*(35*(x**3)/2 - 15*x/2)
+    subst = {x:0.0, y:0.0}
+    e2 = e.evalf(subs=subst)
+    assert float(e2) == 0.0
+    assert float((x + x*(x**2 + x)).evalf(subs={x: 0.0})) == 0.0
+
+
+def test_issue_11151():
+    z = S.Zero
+    e = Sum(z, (x, 1, 2))
+    assert e != z  # it shouldn't evaluate
+    # when it does evaluate, this is what it should give
+    assert evalf(e, 15, {}) == \
+        evalf(z, 15, {}) == (None, None, 15, None)
+    # so this shouldn't fail
+    assert (e/2).n() == 0
+    # this was where the issue appeared
+    expr0 = Sum(x**2 + x, (x, 1, 2))
+    expr1 = Sum(0, (x, 1, 2))
+    expr2 = expr1/expr0
+    assert simplify(factor(expr2) - expr2) == 0
+
+
+def test_issue_13425():
+    assert N('2**.5', 30) == N('sqrt(2)', 30)
+    assert N('x - x', 30) == 0
+    assert abs((N('pi*.1', 22)*10 - pi).n()) < 1e-22
+
+
+def test_issue_17421():
+    assert N(acos(-I + acosh(cosh(cosh(1) + I)))) == 1.0*I
+
+
+def test_issue_20291():
+    from sympy.sets import EmptySet, Reals
+    from sympy.sets.sets import (Complement, FiniteSet, Intersection)
+    a = Symbol('a')
+    b = Symbol('b')
+    A = FiniteSet(a, b)
+    assert A.evalf(subs={a: 1, b: 2}) == FiniteSet(1.0, 2.0)
+    B = FiniteSet(a-b, 1)
+    assert B.evalf(subs={a: 1, b: 2}) == FiniteSet(-1.0, 1.0)
+
+    sol = Complement(Intersection(FiniteSet(-b/2 - sqrt(b**2-4*pi)/2), Reals), FiniteSet(0))
+    assert sol.evalf(subs={b: 1}) == EmptySet
+
+
+def test_evalf_with_zoo():
+    assert (1/x).evalf(subs={x: 0}) == zoo  # issue 8242
+    assert (-1/x).evalf(subs={x: 0}) == zoo  # PR 16150
+    assert (0 ** x).evalf(subs={x: -1}) == zoo  # PR 16150
+    assert (0 ** x).evalf(subs={x: -1 + I}) == nan
+    assert Mul(2, Pow(0, -1, evaluate=False), evaluate=False).evalf() == zoo  # issue 21147
+    assert Mul(x, 1/x, evaluate=False).evalf(subs={x: 0}) == Mul(x, 1/x, evaluate=False).subs(x, 0) == nan
+    assert Mul(1/x, 1/x, evaluate=False).evalf(subs={x: 0}) == zoo
+    assert Mul(1/x, Abs(1/x), evaluate=False).evalf(subs={x: 0}) == zoo
+    assert Abs(zoo, evaluate=False).evalf() == oo
+    assert re(zoo, evaluate=False).evalf() == nan
+    assert im(zoo, evaluate=False).evalf() == nan
+    assert Add(zoo, zoo, evaluate=False).evalf() == nan
+    assert Add(oo, zoo, evaluate=False).evalf() == nan
+    assert Pow(zoo, -1, evaluate=False).evalf() == 0
+    assert Pow(zoo, Rational(-1, 3), evaluate=False).evalf() == 0
+    assert Pow(zoo, Rational(1, 3), evaluate=False).evalf() == zoo
+    assert Pow(zoo, S.Half, evaluate=False).evalf() == zoo
+    assert Pow(zoo, 2, evaluate=False).evalf() == zoo
+    assert Pow(0, zoo, evaluate=False).evalf() == nan
+    assert log(zoo, evaluate=False).evalf() == zoo
+    assert zoo.evalf(chop=True) == zoo
+    assert x.evalf(subs={x: zoo}) == zoo
+
+
+def test_evalf_with_bounded_error():
+    cases = [
+        # zero
+        (Rational(0), None, 1),
+        # zero im part
+        (pi, None, 10),
+        # zero real part
+        (pi*I, None, 10),
+        # re and im nonzero
+        (2-3*I, None, 5),
+        # similar tests again, but using eps instead of m
+        (Rational(0), Rational(1, 2), None),
+        (pi, Rational(1, 1000), None),
+        (pi * I, Rational(1, 1000), None),
+        (2 - 3 * I, Rational(1, 1000), None),
+        # very large eps
+        (2 - 3 * I, Rational(1000), None),
+        # case where x already small, hence some cancellation in p = m + n - 1
+        (Rational(1234, 10**8), Rational(1, 10**12), None),
+    ]
+    for x0, eps, m in cases:
+        a, b, _, _ = evalf(x0, 53, {})
+        c, d, _, _ = _evalf_with_bounded_error(x0, eps, m)
+        if eps is None:
+            eps = 2**(-m)
+        z = make_mpc((a or fzero, b or fzero))
+        w = make_mpc((c or fzero, d or fzero))
+        assert abs(w - z) < eps
+
+    # eps must be positive
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, Rational(0)))
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, -pi))
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, I))
+
+
+def test_issue_22849():
+    a = -8 + 3 * sqrt(3)
+    x = AlgebraicNumber(a)
+    assert evalf(a, 1, {}) == evalf(x, 1, {})
+
+
+def test_evalf_real_alg_num():
+    # This test demonstrates why the entry for `AlgebraicNumber` in
+    # `sympy.core.evalf._create_evalf_table()` has to use `x.to_root()`,
+    # instead of `x.as_expr()`. If the latter is used, then `z` will be
+    # a complex number with `0.e-20` for imaginary part, even though `a5`
+    # is a real number.
+    zeta = Symbol('zeta')
+    a5 = AlgebraicNumber(CRootOf(cyclotomic_poly(5), -1), [-1, -1, 0, 0], alias=zeta)
+    z = a5.evalf()
+    assert isinstance(z, Float)
+    assert not hasattr(z, '_mpc_')
+    assert hasattr(z, '_mpf_')
+
+
+def test_issue_20733():
+    expr = 1/((x - 9)*(x - 8)*(x - 7)*(x - 4)**2*(x - 3)**3*(x - 2))
+    assert str(expr.evalf(1, subs={x:1})) == '-4.e-5'
+    assert str(expr.evalf(2, subs={x:1})) == '-4.1e-5'
+    assert str(expr.evalf(11, subs={x:1})) == '-4.1335978836e-5'
+    assert str(expr.evalf(20, subs={x:1})) == '-0.000041335978835978835979'
+
+    expr = Mul(*((x - i) for i in range(2, 1000)))
+    assert srepr(expr.evalf(2, subs={x: 1})) == "Float('4.0271e+2561', precision=10)"
+    assert srepr(expr.evalf(10, subs={x: 1})) == "Float('4.02790050126e+2561', precision=37)"
+    assert srepr(expr.evalf(53, subs={x: 1})) == "Float('4.0279005012722099453824067459760158730668154575647110393e+2561', precision=179)"

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_expand.py

@@ -0,0 +1,351 @@
+from sympy.core.expr import unchanged
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational as R, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.order import O
+from sympy.simplify.radsimp import expand_numer
+from sympy.core.function import expand, expand_multinomial, expand_power_base
+
+from sympy.testing.pytest import raises
+from sympy.core.random import verify_numerically
+
+from sympy.abc import x, y, z
+
+
+def test_expand_no_log():
+    assert (
+        (1 + log(x**4))**2).expand(log=False) == 1 + 2*log(x**4) + log(x**4)**2
+    assert ((1 + log(x**4))*(1 + log(x**3))).expand(
+        log=False) == 1 + log(x**4) + log(x**3) + log(x**4)*log(x**3)
+
+
+def test_expand_no_multinomial():
+    assert ((1 + x)*(1 + (1 + x)**4)).expand(multinomial=False) == \
+        1 + x + (1 + x)**4 + x*(1 + x)**4
+
+
+def test_expand_negative_integer_powers():
+    expr = (x + y)**(-2)
+    assert expr.expand() == 1 / (2*x*y + x**2 + y**2)
+    assert expr.expand(multinomial=False) == (x + y)**(-2)
+    expr = (x + y)**(-3)
+    assert expr.expand() == 1 / (3*x*x*y + 3*x*y*y + x**3 + y**3)
+    assert expr.expand(multinomial=False) == (x + y)**(-3)
+    expr = (x + y)**(2) * (x + y)**(-4)
+    assert expr.expand() == 1 / (2*x*y + x**2 + y**2)
+    assert expr.expand(multinomial=False) == (x + y)**(-2)
+
+
+def test_expand_non_commutative():
+    A = Symbol('A', commutative=False)
+    B = Symbol('B', commutative=False)
+    C = Symbol('C', commutative=False)
+    a = Symbol('a')
+    b = Symbol('b')
+    i = Symbol('i', integer=True)
+    n = Symbol('n', negative=True)
+    m = Symbol('m', negative=True)
+    p = Symbol('p', polar=True)
+    np = Symbol('p', polar=False)
+
+    assert (C*(A + B)).expand() == C*A + C*B
+    assert (C*(A + B)).expand() != A*C + B*C
+    assert ((A + B)**2).expand() == A**2 + A*B + B*A + B**2
+    assert ((A + B)**3).expand() == (A**2*B + B**2*A + A*B**2 + B*A**2 +
+                                     A**3 + B**3 + A*B*A + B*A*B)
+    # issue 6219
+    assert ((a*A*B*A**-1)**2).expand() == a**2*A*B**2/A
+    # Note that (a*A*B*A**-1)**2 is automatically converted to a**2*(A*B*A**-1)**2
+    assert ((a*A*B*A**-1)**2).expand(deep=False) == a**2*(A*B*A**-1)**2
+    assert ((a*A*B*A**-1)**2).expand() == a**2*(A*B**2*A**-1)
+    assert ((a*A*B*A**-1)**2).expand(force=True) == a**2*A*B**2*A**(-1)
+    assert ((a*A*B)**2).expand() == a**2*A*B*A*B
+    assert ((a*A)**2).expand() == a**2*A**2
+    assert ((a*A*B)**i).expand() == a**i*(A*B)**i
+    assert ((a*A*(B*(A*B/A)**2))**i).expand() == a**i*(A*B*A*B**2/A)**i
+    # issue 6558
+    assert (A*B*(A*B)**-1).expand() == 1
+    assert ((a*A)**i).expand() == a**i*A**i
+    assert ((a*A*B*A**-1)**3).expand() == a**3*A*B**3/A
+    assert ((a*A*B*A*B/A)**3).expand() == \
+        a**3*A*B*(A*B**2)*(A*B**2)*A*B*A**(-1)
+    assert ((a*A*B*A*B/A)**-2).expand() == \
+        A*B**-1*A**-1*B**-2*A**-1*B**-1*A**-1/a**2
+    assert ((a*b*A*B*A**-1)**i).expand() == a**i*b**i*(A*B/A)**i
+    assert ((a*(a*b)**i)**i).expand() == a**i*a**(i**2)*b**(i**2)
+    e = Pow(Mul(a, 1/a, A, B, evaluate=False), S(2), evaluate=False)
+    assert e.expand() == A*B*A*B
+    assert sqrt(a*(A*b)**i).expand() == sqrt(a*b**i*A**i)
+    assert (sqrt(-a)**a).expand() == sqrt(-a)**a
+    assert expand((-2*n)**(i/3)) == 2**(i/3)*(-n)**(i/3)
+    assert expand((-2*n*m)**(i/a)) == (-2)**(i/a)*(-n)**(i/a)*(-m)**(i/a)
+    assert expand((-2*a*p)**b) == 2**b*p**b*(-a)**b
+    assert expand((-2*a*np)**b) == 2**b*(-a*np)**b
+    assert expand(sqrt(A*B)) == sqrt(A*B)
+    assert expand(sqrt(-2*a*b)) == sqrt(2)*sqrt(-a*b)
+
+
+def test_expand_radicals():
+    a = (x + y)**R(1, 2)
+
+    assert (a**1).expand() == a
+    assert (a**3).expand() == x*a + y*a
+    assert (a**5).expand() == x**2*a + 2*x*y*a + y**2*a
+
+    assert (1/a**1).expand() == 1/a
+    assert (1/a**3).expand() == 1/(x*a + y*a)
+    assert (1/a**5).expand() == 1/(x**2*a + 2*x*y*a + y**2*a)
+
+    a = (x + y)**R(1, 3)
+
+    assert (a**1).expand() == a
+    assert (a**2).expand() == a**2
+    assert (a**4).expand() == x*a + y*a
+    assert (a**5).expand() == x*a**2 + y*a**2
+    assert (a**7).expand() == x**2*a + 2*x*y*a + y**2*a
+
+
+def test_expand_modulus():
+    assert ((x + y)**11).expand(modulus=11) == x**11 + y**11
+    assert ((x + sqrt(2)*y)**11).expand(modulus=11) == x**11 + 10*sqrt(2)*y**11
+    assert (x + y/2).expand(modulus=1) == y/2
+
+    raises(ValueError, lambda: ((x + y)**11).expand(modulus=0))
+    raises(ValueError, lambda: ((x + y)**11).expand(modulus=x))
+
+
+def test_issue_5743():
+    assert (x*sqrt(
+        x + y)*(1 + sqrt(x + y))).expand() == x**2 + x*y + x*sqrt(x + y)
+    assert (x*sqrt(
+        x + y)*(1 + x*sqrt(x + y))).expand() == x**3 + x**2*y + x*sqrt(x + y)
+
+
+def test_expand_frac():
+    assert expand((x + y)*y/x/(x + 1), frac=True) == \
+        (x*y + y**2)/(x**2 + x)
+    assert expand((x + y)*y/x/(x + 1), numer=True) == \
+        (x*y + y**2)/(x*(x + 1))
+    assert expand((x + y)*y/x/(x + 1), denom=True) == \
+        y*(x + y)/(x**2 + x)
+    eq = (x + 1)**2/y
+    assert expand_numer(eq, multinomial=False) == eq
+
+
+def test_issue_6121():
+    eq = -I*exp(-3*I*pi/4)/(4*pi**(S(3)/2)*sqrt(x))
+    assert eq.expand(complex=True)  # does not give oo recursion
+    eq = -I*exp(-3*I*pi/4)/(4*pi**(R(3, 2))*sqrt(x))
+    assert eq.expand(complex=True)  # does not give oo recursion
+
+
+def test_expand_power_base():
+    assert expand_power_base((x*y*z)**4) == x**4*y**4*z**4
+    assert expand_power_base((x*y*z)**x).is_Pow
+    assert expand_power_base((x*y*z)**x, force=True) == x**x*y**x*z**x
+    assert expand_power_base((x*(y*z)**2)**3) == x**3*y**6*z**6
+
+    assert expand_power_base((sin((x*y)**2)*y)**z).is_Pow
+    assert expand_power_base(
+        (sin((x*y)**2)*y)**z, force=True) == sin((x*y)**2)**z*y**z
+    assert expand_power_base(
+        (sin((x*y)**2)*y)**z, deep=True) == (sin(x**2*y**2)*y)**z
+
+    assert expand_power_base(exp(x)**2) == exp(2*x)
+    assert expand_power_base((exp(x)*exp(y))**2) == exp(2*x)*exp(2*y)
+
+    assert expand_power_base(
+        (exp((x*y)**z)*exp(y))**2) == exp(2*(x*y)**z)*exp(2*y)
+    assert expand_power_base((exp((x*y)**z)*exp(
+        y))**2, deep=True, force=True) == exp(2*x**z*y**z)*exp(2*y)
+
+    assert expand_power_base((exp(x)*exp(y))**z).is_Pow
+    assert expand_power_base(
+        (exp(x)*exp(y))**z, force=True) == exp(x)**z*exp(y)**z
+
+
+def test_expand_arit():
+    a = Symbol("a")
+    b = Symbol("b", positive=True)
+    c = Symbol("c")
+
+    p = R(5)
+    e = (a + b)*c
+    assert e == c*(a + b)
+    assert (e.expand() - a*c - b*c) == R(0)
+    e = (a + b)*(a + b)
+    assert e == (a + b)**2
+    assert e.expand() == 2*a*b + a**2 + b**2
+    e = (a + b)*(a + b)**R(2)
+    assert e == (a + b)**3
+    assert e.expand() == 3*b*a**2 + 3*a*b**2 + a**3 + b**3
+    assert e.expand() == 3*b*a**2 + 3*a*b**2 + a**3 + b**3
+    e = (a + b)*(a + c)*(b + c)
+    assert e == (a + c)*(a + b)*(b + c)
+    assert e.expand() == 2*a*b*c + b*a**2 + c*a**2 + b*c**2 + a*c**2 + c*b**2 + a*b**2
+    e = (a + R(1))**p
+    assert e == (1 + a)**5
+    assert e.expand() == 1 + 5*a + 10*a**2 + 10*a**3 + 5*a**4 + a**5
+    e = (a + b + c)*(a + c + p)
+    assert e == (5 + a + c)*(a + b + c)
+    assert e.expand() == 5*a + 5*b + 5*c + 2*a*c + b*c + a*b + a**2 + c**2
+    x = Symbol("x")
+    s = exp(x*x) - 1
+    e = s.nseries(x, 0, 6)/x**2
+    assert e.expand() == 1 + x**2/2 + O(x**4)
+
+    e = (x*(y + z))**(x*(y + z))*(x + y)
+    assert e.expand(power_exp=False, power_base=False) == x*(x*y + x*
+                    z)**(x*y + x*z) + y*(x*y + x*z)**(x*y + x*z)
+    assert e.expand(power_exp=False, power_base=False, deep=False) == x* \
+        (x*(y + z))**(x*(y + z)) + y*(x*(y + z))**(x*(y + z))
+    e = x * (x + (y + 1)**2)
+    assert e.expand(deep=False) == x**2 + x*(y + 1)**2
+    e = (x*(y + z))**z
+    assert e.expand(power_base=True, mul=True, deep=True) in [x**z*(y +
+                    z)**z, (x*y + x*z)**z]
+    assert ((2*y)**z).expand() == 2**z*y**z
+    p = Symbol('p', positive=True)
+    assert sqrt(-x).expand().is_Pow
+    assert sqrt(-x).expand(force=True) == I*sqrt(x)
+    assert ((2*y*p)**z).expand() == 2**z*p**z*y**z
+    assert ((2*y*p*x)**z).expand() == 2**z*p**z*(x*y)**z
+    assert ((2*y*p*x)**z).expand(force=True) == 2**z*p**z*x**z*y**z
+    assert ((2*y*p*-pi)**z).expand() == 2**z*pi**z*p**z*(-y)**z
+    assert ((2*y*p*-pi*x)**z).expand() == 2**z*pi**z*p**z*(-x*y)**z
+    n = Symbol('n', negative=True)
+    m = Symbol('m', negative=True)
+    assert ((-2*x*y*n)**z).expand() == 2**z*(-n)**z*(x*y)**z
+    assert ((-2*x*y*n*m)**z).expand() == 2**z*(-m)**z*(-n)**z*(-x*y)**z
+    # issue 5482
+    assert sqrt(-2*x*n) == sqrt(2)*sqrt(-n)*sqrt(x)
+    # issue 5605 (2)
+    assert (cos(x + y)**2).expand(trig=True) in [
+        (-sin(x)*sin(y) + cos(x)*cos(y))**2,
+        sin(x)**2*sin(y)**2 - 2*sin(x)*sin(y)*cos(x)*cos(y) + cos(x)**2*cos(y)**2
+    ]
+
+    # Check that this isn't too slow
+    x = Symbol('x')
+    W = 1
+    for i in range(1, 21):
+        W = W * (x - i)
+    W = W.expand()
+    assert W.has(-1672280820*x**15)
+
+def test_expand_mul():
+    # part of issue 20597
+    e = Mul(2, 3, evaluate=False)
+    assert e.expand() == 6
+
+    e = Mul(2, 3, 1/x, evaluate = False)
+    assert e.expand() == 6/x
+    e = Mul(2, R(1, 3), evaluate=False)
+    assert e.expand() == R(2, 3)
+
+def test_power_expand():
+    """Test for Pow.expand()"""
+    a = Symbol('a')
+    b = Symbol('b')
+    p = (a + b)**2
+    assert p.expand() == a**2 + b**2 + 2*a*b
+
+    p = (1 + 2*(1 + a))**2
+    assert p.expand() == 9 + 4*(a**2) + 12*a
+
+    p = 2**(a + b)
+    assert p.expand() == 2**a*2**b
+
+    A = Symbol('A', commutative=False)
+    B = Symbol('B', commutative=False)
+    assert (2**(A + B)).expand() == 2**(A + B)
+    assert (A**(a + b)).expand() != A**(a + b)
+
+
+def test_issues_5919_6830():
+    # issue 5919
+    n = -1 + 1/x
+    z = n/x/(-n)**2 - 1/n/x
+    assert expand(z) == 1/(x**2 - 2*x + 1) - 1/(x - 2 + 1/x) - 1/(-x + 1)
+
+    # issue 6830
+    p = (1 + x)**2
+    assert expand_multinomial((1 + x*p)**2) == (
+        x**2*(x**4 + 4*x**3 + 6*x**2 + 4*x + 1) + 2*x*(x**2 + 2*x + 1) + 1)
+    assert expand_multinomial((1 + (y + x)*p)**2) == (
+        2*((x + y)*(x**2 + 2*x + 1)) + (x**2 + 2*x*y + y**2)*
+        (x**4 + 4*x**3 + 6*x**2 + 4*x + 1) + 1)
+    A = Symbol('A', commutative=False)
+    p = (1 + A)**2
+    assert expand_multinomial((1 + x*p)**2) == (
+        x**2*(1 + 4*A + 6*A**2 + 4*A**3 + A**4) + 2*x*(1 + 2*A + A**2) + 1)
+    assert expand_multinomial((1 + (y + x)*p)**2) == (
+        (x + y)*(1 + 2*A + A**2)*2 + (x**2 + 2*x*y + y**2)*
+        (1 + 4*A + 6*A**2 + 4*A**3 + A**4) + 1)
+    assert expand_multinomial((1 + (y + x)*p)**3) == (
+        (x + y)*(1 + 2*A + A**2)*3 + (x**2 + 2*x*y + y**2)*(1 + 4*A +
+        6*A**2 + 4*A**3 + A**4)*3 + (x**3 + 3*x**2*y + 3*x*y**2 + y**3)*(1 + 6*A
+        + 15*A**2 + 20*A**3 + 15*A**4 + 6*A**5 + A**6) + 1)
+    # unevaluate powers
+    eq = (Pow((x + 1)*((A + 1)**2), 2, evaluate=False))
+    # - in this case the base is not an Add so no further
+    #   expansion is done
+    assert expand_multinomial(eq) == \
+        (x**2 + 2*x + 1)*(1 + 4*A + 6*A**2 + 4*A**3 + A**4)
+    # - but here, the expanded base *is* an Add so it gets expanded
+    eq = (Pow(((A + 1)**2), 2, evaluate=False))
+    assert expand_multinomial(eq) == 1 + 4*A + 6*A**2 + 4*A**3 + A**4
+
+    # coverage
+    def ok(a, b, n):
+        e = (a + I*b)**n
+        return verify_numerically(e, expand_multinomial(e))
+
+    for a in [2, S.Half]:
+        for b in [3, R(1, 3)]:
+            for n in range(2, 6):
+                assert ok(a, b, n)
+
+    assert expand_multinomial((x + 1 + O(z))**2) == \
+        1 + 2*x + x**2 + O(z)
+    assert expand_multinomial((x + 1 + O(z))**3) == \
+        1 + 3*x + 3*x**2 + x**3 + O(z)
+
+    assert expand_multinomial(3**(x + y + 3)) == 27*3**(x + y)
+
+def test_expand_log():
+    t = Symbol('t', positive=True)
+    # after first expansion, -2*log(2) + log(4); then 0 after second
+    assert expand(log(t**2) - log(t**2/4) - 2*log(2)) == 0
+
+
+def test_issue_23952():
+    assert (x**(y + z)).expand(force=True) == x**y*x**z
+    one = Symbol('1', integer=True, prime=True, odd=True, positive=True)
+    two = Symbol('2', integer=True, prime=True, even=True)
+    e = two - one
+    for b in (0, x):
+        # 0**e = 0, 0**-e = zoo; but if expanded then nan
+        assert unchanged(Pow, b, e)  # power_exp
+        assert unchanged(Pow, b, -e)  # power_exp
+        assert unchanged(Pow, b, y - x)  # power_exp
+        assert unchanged(Pow, b, 3 - x)  # multinomial
+        assert (b**e).expand().is_Pow  # power_exp
+        assert (b**-e).expand().is_Pow  # power_exp
+        assert (b**(y - x)).expand().is_Pow  # power_exp
+        assert (b**(3 - x)).expand().is_Pow  # multinomial
+    nn1 = Symbol('nn1', nonnegative=True)
+    nn2 = Symbol('nn2', nonnegative=True)
+    nn3 = Symbol('nn3', nonnegative=True)
+    assert (x**(nn1 + nn2)).expand() == x**nn1*x**nn2
+    assert (x**(-nn1 - nn2)).expand() == x**-nn1*x**-nn2
+    assert unchanged(Pow, x, nn1 + nn2 - nn3)
+    assert unchanged(Pow, x, 1 + nn2 - nn3)
+    assert unchanged(Pow, x, nn1 - nn2)
+    assert unchanged(Pow, x, 1 - nn2)
+    assert unchanged(Pow, x, -1 + nn2)

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_expr.py

@@ -0,0 +1,2261 @@
+from sympy.assumptions.refine import refine
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import (ExprBuilder, unchanged, Expr,
+    UnevaluatedExpr)
+from sympy.core.function import (Function, expand, WildFunction,
+    AppliedUndef, Derivative, diff, Subs)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (NumberSymbol, E, zoo, oo, Float, I,
+    Rational, nan, Integer, Number, pi, _illegal)
+from sympy.core.power import Pow
+from sympy.core.relational import Ge, Lt, Gt, Le
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Symbol, symbols, Dummy, Wild
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp_polar, exp, log
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import tan, sin, cos
+from sympy.functions.special.delta_functions import (Heaviside,
+    DiracDelta)
+from sympy.functions.special.error_functions import Si
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate, Integral
+from sympy.physics.secondquant import FockState
+from sympy.polys.partfrac import apart
+from sympy.polys.polytools import factor, cancel, Poly
+from sympy.polys.rationaltools import together
+from sympy.series.order import O
+from sympy.sets.sets import FiniteSet
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.radsimp import collect, radsimp
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import simplify, nsimplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.tensor.indexed import Indexed
+from sympy.physics.units import meter
+
+from sympy.testing.pytest import raises, XFAIL
+
+from sympy.abc import a, b, c, n, t, u, x, y, z
+
+
+f, g, h = symbols('f,g,h', cls=Function)
+
+
+class DummyNumber:
+    """
+    Minimal implementation of a number that works with SymPy.
+
+    If one has a Number class (e.g. Sage Integer, or some other custom class)
+    that one wants to work well with SymPy, one has to implement at least the
+    methods of this class DummyNumber, resp. its subclasses I5 and F1_1.
+
+    Basically, one just needs to implement either __int__() or __float__() and
+    then one needs to make sure that the class works with Python integers and
+    with itself.
+    """
+
+    def __radd__(self, a):
+        if isinstance(a, (int, float)):
+            return a + self.number
+        return NotImplemented
+
+    def __add__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number + a
+        return NotImplemented
+
+    def __rsub__(self, a):
+        if isinstance(a, (int, float)):
+            return a - self.number
+        return NotImplemented
+
+    def __sub__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number - a
+        return NotImplemented
+
+    def __rmul__(self, a):
+        if isinstance(a, (int, float)):
+            return a * self.number
+        return NotImplemented
+
+    def __mul__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number * a
+        return NotImplemented
+
+    def __rtruediv__(self, a):
+        if isinstance(a, (int, float)):
+            return a / self.number
+        return NotImplemented
+
+    def __truediv__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number / a
+        return NotImplemented
+
+    def __rpow__(self, a):
+        if isinstance(a, (int, float)):
+            return a ** self.number
+        return NotImplemented
+
+    def __pow__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number ** a
+        return NotImplemented
+
+    def __pos__(self):
+        return self.number
+
+    def __neg__(self):
+        return - self.number
+
+
+class I5(DummyNumber):
+    number = 5
+
+    def __int__(self):
+        return self.number
+
+
+class F1_1(DummyNumber):
+    number = 1.1
+
+    def __float__(self):
+        return self.number
+
+i5 = I5()
+f1_1 = F1_1()
+
+# basic SymPy objects
+basic_objs = [
+    Rational(2),
+    Float("1.3"),
+    x,
+    y,
+    pow(x, y)*y,
+]
+
+# all supported objects
+all_objs = basic_objs + [
+    5,
+    5.5,
+    i5,
+    f1_1
+]
+
+
+def dotest(s):
+    for xo in all_objs:
+        for yo in all_objs:
+            s(xo, yo)
+    return True
+
+
+def test_basic():
+    def j(a, b):
+        x = a
+        x = +a
+        x = -a
+        x = a + b
+        x = a - b
+        x = a*b
+        x = a/b
+        x = a**b
+        del x
+    assert dotest(j)
+
+
+def test_ibasic():
+    def s(a, b):
+        x = a
+        x += b
+        x = a
+        x -= b
+        x = a
+        x *= b
+        x = a
+        x /= b
+    assert dotest(s)
+
+
+class NonBasic:
+    '''This class represents an object that knows how to implement binary
+    operations like +, -, etc with Expr but is not a subclass of Basic itself.
+    The NonExpr subclass below does subclass Basic but not Expr.
+
+    For both NonBasic and NonExpr it should be possible for them to override
+    Expr.__add__ etc because Expr.__add__ should be returning NotImplemented
+    for non Expr classes. Otherwise Expr.__add__ would create meaningless
+    objects like Add(Integer(1), FiniteSet(2)) and it wouldn't be possible for
+    other classes to override these operations when interacting with Expr.
+    '''
+    def __add__(self, other):
+        return SpecialOp('+', self, other)
+
+    def __radd__(self, other):
+        return SpecialOp('+', other, self)
+
+    def __sub__(self, other):
+        return SpecialOp('-', self, other)
+
+    def __rsub__(self, other):
+        return SpecialOp('-', other, self)
+
+    def __mul__(self, other):
+        return SpecialOp('*', self, other)
+
+    def __rmul__(self, other):
+        return SpecialOp('*', other, self)
+
+    def __truediv__(self, other):
+        return SpecialOp('/', self, other)
+
+    def __rtruediv__(self, other):
+        return SpecialOp('/', other, self)
+
+    def __floordiv__(self, other):
+        return SpecialOp('//', self, other)
+
+    def __rfloordiv__(self, other):
+        return SpecialOp('//', other, self)
+
+    def __mod__(self, other):
+        return SpecialOp('%', self, other)
+
+    def __rmod__(self, other):
+        return SpecialOp('%', other, self)
+
+    def __divmod__(self, other):
+        return SpecialOp('divmod', self, other)
+
+    def __rdivmod__(self, other):
+        return SpecialOp('divmod', other, self)
+
+    def __pow__(self, other):
+        return SpecialOp('**', self, other)
+
+    def __rpow__(self, other):
+        return SpecialOp('**', other, self)
+
+    def __lt__(self, other):
+        return SpecialOp('<', self, other)
+
+    def __gt__(self, other):
+        return SpecialOp('>', self, other)
+
+    def __le__(self, other):
+        return SpecialOp('<=', self, other)
+
+    def __ge__(self, other):
+        return SpecialOp('>=', self, other)
+
+
+class NonExpr(Basic, NonBasic):
+    '''Like NonBasic above except this is a subclass of Basic but not Expr'''
+    pass
+
+
+class SpecialOp():
+    '''Represents the results of operations with NonBasic and NonExpr'''
+    def __new__(cls, op, arg1, arg2):
+        obj = object.__new__(cls)
+        obj.args = (op, arg1, arg2)
+        return obj
+
+
+class NonArithmetic(Basic):
+    '''Represents a Basic subclass that does not support arithmetic operations'''
+    pass
+
+
+def test_cooperative_operations():
+    '''Tests that Expr uses binary operations cooperatively.
+
+    In particular it should be possible for non-Expr classes to override
+    binary operators like +, - etc when used with Expr instances. This should
+    work for non-Expr classes whether they are Basic subclasses or not. Also
+    non-Expr classes that do not define binary operators with Expr should give
+    TypeError.
+    '''
+    # A bunch of instances of Expr subclasses
+    exprs = [
+        Expr(),
+        S.Zero,
+        S.One,
+        S.Infinity,
+        S.NegativeInfinity,
+        S.ComplexInfinity,
+        S.Half,
+        Float(0.5),
+        Integer(2),
+        Symbol('x'),
+        Mul(2, Symbol('x')),
+        Add(2, Symbol('x')),
+        Pow(2, Symbol('x')),
+    ]
+
+    for e in exprs:
+        # Test that these classes can override arithmetic operations in
+        # combination with various Expr types.
+        for ne in [NonBasic(), NonExpr()]:
+
+            results = [
+                (ne + e, ('+', ne, e)),
+                (e + ne, ('+', e, ne)),
+                (ne - e, ('-', ne, e)),
+                (e - ne, ('-', e, ne)),
+                (ne * e, ('*', ne, e)),
+                (e * ne, ('*', e, ne)),
+                (ne / e, ('/', ne, e)),
+                (e / ne, ('/', e, ne)),
+                (ne // e, ('//', ne, e)),
+                (e // ne, ('//', e, ne)),
+                (ne % e, ('%', ne, e)),
+                (e % ne, ('%', e, ne)),
+                (divmod(ne, e), ('divmod', ne, e)),
+                (divmod(e, ne), ('divmod', e, ne)),
+                (ne ** e, ('**', ne, e)),
+                (e ** ne, ('**', e, ne)),
+                (e < ne, ('>', ne, e)),
+                (ne < e, ('<', ne, e)),
+                (e > ne, ('<', ne, e)),
+                (ne > e, ('>', ne, e)),
+                (e <= ne, ('>=', ne, e)),
+                (ne <= e, ('<=', ne, e)),
+                (e >= ne, ('<=', ne, e)),
+                (ne >= e, ('>=', ne, e)),
+            ]
+
+            for res, args in results:
+                assert type(res) is SpecialOp and res.args == args
+
+        # These classes do not support binary operators with Expr. Every
+        # operation should raise in combination with any of the Expr types.
+        for na in [NonArithmetic(), object()]:
+
+            raises(TypeError, lambda : e + na)
+            raises(TypeError, lambda : na + e)
+            raises(TypeError, lambda : e - na)
+            raises(TypeError, lambda : na - e)
+            raises(TypeError, lambda : e * na)
+            raises(TypeError, lambda : na * e)
+            raises(TypeError, lambda : e / na)
+            raises(TypeError, lambda : na / e)
+            raises(TypeError, lambda : e // na)
+            raises(TypeError, lambda : na // e)
+            raises(TypeError, lambda : e % na)
+            raises(TypeError, lambda : na % e)
+            raises(TypeError, lambda : divmod(e, na))
+            raises(TypeError, lambda : divmod(na, e))
+            raises(TypeError, lambda : e ** na)
+            raises(TypeError, lambda : na ** e)
+            raises(TypeError, lambda : e > na)
+            raises(TypeError, lambda : na > e)
+            raises(TypeError, lambda : e < na)
+            raises(TypeError, lambda : na < e)
+            raises(TypeError, lambda : e >= na)
+            raises(TypeError, lambda : na >= e)
+            raises(TypeError, lambda : e <= na)
+            raises(TypeError, lambda : na <= e)
+
+
+def test_relational():
+    from sympy.core.relational import Lt
+    assert (pi < 3) is S.false
+    assert (pi <= 3) is S.false
+    assert (pi > 3) is S.true
+    assert (pi >= 3) is S.true
+    assert (-pi < 3) is S.true
+    assert (-pi <= 3) is S.true
+    assert (-pi > 3) is S.false
+    assert (-pi >= 3) is S.false
+    r = Symbol('r', real=True)
+    assert (r - 2 < r - 3) is S.false
+    assert Lt(x + I, x + I + 2).func == Lt  # issue 8288
+
+
+def test_relational_assumptions():
+    m1 = Symbol("m1", nonnegative=False)
+    m2 = Symbol("m2", positive=False)
+    m3 = Symbol("m3", nonpositive=False)
+    m4 = Symbol("m4", negative=False)
+    assert (m1 < 0) == Lt(m1, 0)
+    assert (m2 <= 0) == Le(m2, 0)
+    assert (m3 > 0) == Gt(m3, 0)
+    assert (m4 >= 0) == Ge(m4, 0)
+    m1 = Symbol("m1", nonnegative=False, real=True)
+    m2 = Symbol("m2", positive=False, real=True)
+    m3 = Symbol("m3", nonpositive=False, real=True)
+    m4 = Symbol("m4", negative=False, real=True)
+    assert (m1 < 0) is S.true
+    assert (m2 <= 0) is S.true
+    assert (m3 > 0) is S.true
+    assert (m4 >= 0) is S.true
+    m1 = Symbol("m1", negative=True)
+    m2 = Symbol("m2", nonpositive=True)
+    m3 = Symbol("m3", positive=True)
+    m4 = Symbol("m4", nonnegative=True)
+    assert (m1 < 0) is S.true
+    assert (m2 <= 0) is S.true
+    assert (m3 > 0) is S.true
+    assert (m4 >= 0) is S.true
+    m1 = Symbol("m1", negative=False, real=True)
+    m2 = Symbol("m2", nonpositive=False, real=True)
+    m3 = Symbol("m3", positive=False, real=True)
+    m4 = Symbol("m4", nonnegative=False, real=True)
+    assert (m1 < 0) is S.false
+    assert (m2 <= 0) is S.false
+    assert (m3 > 0) is S.false
+    assert (m4 >= 0) is S.false
+
+
+# See https://github.com/sympy/sympy/issues/17708
+#def test_relational_noncommutative():
+#    from sympy import Lt, Gt, Le, Ge
+#    A, B = symbols('A,B', commutative=False)
+#    assert (A < B) == Lt(A, B)
+#    assert (A <= B) == Le(A, B)
+#    assert (A > B) == Gt(A, B)
+#    assert (A >= B) == Ge(A, B)
+
+
+def test_basic_nostr():
+    for obj in basic_objs:
+        raises(TypeError, lambda: obj + '1')
+        raises(TypeError, lambda: obj - '1')
+        if obj == 2:
+            assert obj * '1' == '11'
+        else:
+            raises(TypeError, lambda: obj * '1')
+        raises(TypeError, lambda: obj / '1')
+        raises(TypeError, lambda: obj ** '1')
+
+
+def test_series_expansion_for_uniform_order():
+    assert (1/x + y + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + y + x).series(x, 0, 1) == 1/x + y + O(x)
+    assert (1/x + 1 + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + 1 + x).series(x, 0, 1) == 1/x + 1 + O(x)
+    assert (1/x + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + y + y*x + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + y + y*x + x).series(x, 0, 1) == 1/x + y + O(x)
+
+
+def test_leadterm():
+    assert (3 + 2*x**(log(3)/log(2) - 1)).leadterm(x) == (3, 0)
+
+    assert (1/x**2 + 1 + x + x**2).leadterm(x)[1] == -2
+    assert (1/x + 1 + x + x**2).leadterm(x)[1] == -1
+    assert (x**2 + 1/x).leadterm(x)[1] == -1
+    assert (1 + x**2).leadterm(x)[1] == 0
+    assert (x + 1).leadterm(x)[1] == 0
+    assert (x + x**2).leadterm(x)[1] == 1
+    assert (x**2).leadterm(x)[1] == 2
+
+
+def test_as_leading_term():
+    assert (3 + 2*x**(log(3)/log(2) - 1)).as_leading_term(x) == 3
+    assert (1/x**2 + 1 + x + x**2).as_leading_term(x) == 1/x**2
+    assert (1/x + 1 + x + x**2).as_leading_term(x) == 1/x
+    assert (x**2 + 1/x).as_leading_term(x) == 1/x
+    assert (1 + x**2).as_leading_term(x) == 1
+    assert (x + 1).as_leading_term(x) == 1
+    assert (x + x**2).as_leading_term(x) == x
+    assert (x**2).as_leading_term(x) == x**2
+    assert (x + oo).as_leading_term(x) is oo
+
+    raises(ValueError, lambda: (x + 1).as_leading_term(1))
+
+    # https://github.com/sympy/sympy/issues/21177
+    e = -3*x + (x + Rational(3, 2) - sqrt(3)*S.ImaginaryUnit/2)**2\
+        - Rational(3, 2) + 3*sqrt(3)*S.ImaginaryUnit/2
+    assert e.as_leading_term(x) == \
+        (12*sqrt(3)*x - 12*S.ImaginaryUnit*x)/(4*sqrt(3) + 12*S.ImaginaryUnit)
+
+    # https://github.com/sympy/sympy/issues/21245
+    e = 1 - x - x**2
+    d = (1 + sqrt(5))/2
+    assert e.subs(x, y + 1/d).as_leading_term(y) == \
+        (-576*sqrt(5)*y - 1280*y)/(256*sqrt(5) + 576)
+
+
+def test_leadterm2():
+    assert (x*cos(1)*cos(1 + sin(1)) + sin(1 + sin(1))).leadterm(x) == \
+           (sin(1 + sin(1)), 0)
+
+
+def test_leadterm3():
+    assert (y + z + x).leadterm(x) == (y + z, 0)
+
+
+def test_as_leading_term2():
+    assert (x*cos(1)*cos(1 + sin(1)) + sin(1 + sin(1))).as_leading_term(x) == \
+        sin(1 + sin(1))
+
+
+def test_as_leading_term3():
+    assert (2 + pi + x).as_leading_term(x) == 2 + pi
+    assert (2*x + pi*x + x**2).as_leading_term(x) == 2*x + pi*x
+
+
+def test_as_leading_term4():
+    # see issue 6843
+    n = Symbol('n', integer=True, positive=True)
+    r = -n**3/(2*n**2 + 4*n + 2) - n**2/(n**2 + 2*n + 1) + \
+        n**2/(n + 1) - n/(2*n**2 + 4*n + 2) + n/(n*x + x) + 2*n/(n + 1) - \
+        1 + 1/(n*x + x) + 1/(n + 1) - 1/x
+    assert r.as_leading_term(x).cancel() == n/2
+
+
+def test_as_leading_term_stub():
+    class foo(Function):
+        pass
+    assert foo(1/x).as_leading_term(x) == foo(1/x)
+    assert foo(1).as_leading_term(x) == foo(1)
+    raises(NotImplementedError, lambda: foo(x).as_leading_term(x))
+
+
+def test_as_leading_term_deriv_integral():
+    # related to issue 11313
+    assert Derivative(x ** 3, x).as_leading_term(x) == 3*x**2
+    assert Derivative(x ** 3, y).as_leading_term(x) == 0
+
+    assert Integral(x ** 3, x).as_leading_term(x) == x**4/4
+    assert Integral(x ** 3, y).as_leading_term(x) == y*x**3
+
+    assert Derivative(exp(x), x).as_leading_term(x) == 1
+    assert Derivative(log(x), x).as_leading_term(x) == (1/x).as_leading_term(x)
+
+
+def test_atoms():
+    assert x.atoms() == {x}
+    assert (1 + x).atoms() == {x, S.One}
+
+    assert (1 + 2*cos(x)).atoms(Symbol) == {x}
+    assert (1 + 2*cos(x)).atoms(Symbol, Number) == {S.One, S(2), x}
+
+    assert (2*(x**(y**x))).atoms() == {S(2), x, y}
+
+    assert S.Half.atoms() == {S.Half}
+    assert S.Half.atoms(Symbol) == set()
+
+    assert sin(oo).atoms(oo) == set()
+
+    assert Poly(0, x).atoms() == {S.Zero, x}
+    assert Poly(1, x).atoms() == {S.One, x}
+
+    assert Poly(x, x).atoms() == {x}
+    assert Poly(x, x, y).atoms() == {x, y}
+    assert Poly(x + y, x, y).atoms() == {x, y}
+    assert Poly(x + y, x, y, z).atoms() == {x, y, z}
+    assert Poly(x + y*t, x, y, z).atoms() == {t, x, y, z}
+
+    assert (I*pi).atoms(NumberSymbol) == {pi}
+    assert (I*pi).atoms(NumberSymbol, I) == \
+        (I*pi).atoms(I, NumberSymbol) == {pi, I}
+
+    assert exp(exp(x)).atoms(exp) == {exp(exp(x)), exp(x)}
+    assert (1 + x*(2 + y) + exp(3 + z)).atoms(Add) == \
+        {1 + x*(2 + y) + exp(3 + z), 2 + y, 3 + z}
+
+    # issue 6132
+    e = (f(x) + sin(x) + 2)
+    assert e.atoms(AppliedUndef) == \
+        {f(x)}
+    assert e.atoms(AppliedUndef, Function) == \
+        {f(x), sin(x)}
+    assert e.atoms(Function) == \
+        {f(x), sin(x)}
+    assert e.atoms(AppliedUndef, Number) == \
+        {f(x), S(2)}
+    assert e.atoms(Function, Number) == \
+        {S(2), sin(x), f(x)}
+
+
+def test_is_polynomial():
+    k = Symbol('k', nonnegative=True, integer=True)
+
+    assert Rational(2).is_polynomial(x, y, z) is True
+    assert (S.Pi).is_polynomial(x, y, z) is True
+
+    assert x.is_polynomial(x) is True
+    assert x.is_polynomial(y) is True
+
+    assert (x**2).is_polynomial(x) is True
+    assert (x**2).is_polynomial(y) is True
+
+    assert (x**(-2)).is_polynomial(x) is False
+    assert (x**(-2)).is_polynomial(y) is True
+
+    assert (2**x).is_polynomial(x) is False
+    assert (2**x).is_polynomial(y) is True
+
+    assert (x**k).is_polynomial(x) is False
+    assert (x**k).is_polynomial(k) is False
+    assert (x**x).is_polynomial(x) is False
+    assert (k**k).is_polynomial(k) is False
+    assert (k**x).is_polynomial(k) is False
+
+    assert (x**(-k)).is_polynomial(x) is False
+    assert ((2*x)**k).is_polynomial(x) is False
+
+    assert (x**2 + 3*x - 8).is_polynomial(x) is True
+    assert (x**2 + 3*x - 8).is_polynomial(y) is True
+
+    assert (x**2 + 3*x - 8).is_polynomial() is True
+
+    assert sqrt(x).is_polynomial(x) is False
+    assert (sqrt(x)**3).is_polynomial(x) is False
+
+    assert (x**2 + 3*x*sqrt(y) - 8).is_polynomial(x) is True
+    assert (x**2 + 3*x*sqrt(y) - 8).is_polynomial(y) is False
+
+    assert ((x**2)*(y**2) + x*(y**2) + y*x + exp(2)).is_polynomial() is True
+    assert ((x**2)*(y**2) + x*(y**2) + y*x + exp(x)).is_polynomial() is False
+
+    assert (
+        (x**2)*(y**2) + x*(y**2) + y*x + exp(2)).is_polynomial(x, y) is True
+    assert (
+        (x**2)*(y**2) + x*(y**2) + y*x + exp(x)).is_polynomial(x, y) is False
+
+    assert (1/f(x) + 1).is_polynomial(f(x)) is False
+
+
+def test_is_rational_function():
+    assert Integer(1).is_rational_function() is True
+    assert Integer(1).is_rational_function(x) is True
+
+    assert Rational(17, 54).is_rational_function() is True
+    assert Rational(17, 54).is_rational_function(x) is True
+
+    assert (12/x).is_rational_function() is True
+    assert (12/x).is_rational_function(x) is True
+
+    assert (x/y).is_rational_function() is True
+    assert (x/y).is_rational_function(x) is True
+    assert (x/y).is_rational_function(x, y) is True
+
+    assert (x**2 + 1/x/y).is_rational_function() is True
+    assert (x**2 + 1/x/y).is_rational_function(x) is True
+    assert (x**2 + 1/x/y).is_rational_function(x, y) is True
+
+    assert (sin(y)/x).is_rational_function() is False
+    assert (sin(y)/x).is_rational_function(y) is False
+    assert (sin(y)/x).is_rational_function(x) is True
+    assert (sin(y)/x).is_rational_function(x, y) is False
+
+    for i in _illegal:
+        assert not i.is_rational_function()
+        for d in (1, x):
+            assert not (i/d).is_rational_function()
+
+
+def test_is_meromorphic():
+    f = a/x**2 + b + x + c*x**2
+    assert f.is_meromorphic(x, 0) is True
+    assert f.is_meromorphic(x, 1) is True
+    assert f.is_meromorphic(x, zoo) is True
+
+    g = 3 + 2*x**(log(3)/log(2) - 1)
+    assert g.is_meromorphic(x, 0) is False
+    assert g.is_meromorphic(x, 1) is True
+    assert g.is_meromorphic(x, zoo) is False
+
+    n = Symbol('n', integer=True)
+    e = sin(1/x)**n*x
+    assert e.is_meromorphic(x, 0) is False
+    assert e.is_meromorphic(x, 1) is True
+    assert e.is_meromorphic(x, zoo) is False
+
+    e = log(x)**pi
+    assert e.is_meromorphic(x, 0) is False
+    assert e.is_meromorphic(x, 1) is False
+    assert e.is_meromorphic(x, 2) is True
+    assert e.is_meromorphic(x, zoo) is False
+
+    assert (log(x)**a).is_meromorphic(x, 0) is False
+    assert (log(x)**a).is_meromorphic(x, 1) is False
+    assert (a**log(x)).is_meromorphic(x, 0) is None
+    assert (3**log(x)).is_meromorphic(x, 0) is False
+    assert (3**log(x)).is_meromorphic(x, 1) is True
+
+def test_is_algebraic_expr():
+    assert sqrt(3).is_algebraic_expr(x) is True
+    assert sqrt(3).is_algebraic_expr() is True
+
+    eq = ((1 + x**2)/(1 - y**2))**(S.One/3)
+    assert eq.is_algebraic_expr(x) is True
+    assert eq.is_algebraic_expr(y) is True
+
+    assert (sqrt(x) + y**(S(2)/3)).is_algebraic_expr(x) is True
+    assert (sqrt(x) + y**(S(2)/3)).is_algebraic_expr(y) is True
+    assert (sqrt(x) + y**(S(2)/3)).is_algebraic_expr() is True
+
+    assert (cos(y)/sqrt(x)).is_algebraic_expr() is False
+    assert (cos(y)/sqrt(x)).is_algebraic_expr(x) is True
+    assert (cos(y)/sqrt(x)).is_algebraic_expr(y) is False
+    assert (cos(y)/sqrt(x)).is_algebraic_expr(x, y) is False
+
+
+def test_SAGE1():
+    #see https://github.com/sympy/sympy/issues/3346
+    class MyInt:
+        def _sympy_(self):
+            return Integer(5)
+    m = MyInt()
+    e = Rational(2)*m
+    assert e == 10
+
+    raises(TypeError, lambda: Rational(2)*MyInt)
+
+
+def test_SAGE2():
+    class MyInt:
+        def __int__(self):
+            return 5
+    assert sympify(MyInt()) == 5
+    e = Rational(2)*MyInt()
+    assert e == 10
+
+    raises(TypeError, lambda: Rational(2)*MyInt)
+
+
+def test_SAGE3():
+    class MySymbol:
+        def __rmul__(self, other):
+            return ('mys', other, self)
+
+    o = MySymbol()
+    e = x*o
+
+    assert e == ('mys', x, o)
+
+
+def test_len():
+    e = x*y
+    assert len(e.args) == 2
+    e = x + y + z
+    assert len(e.args) == 3
+
+
+def test_doit():
+    a = Integral(x**2, x)
+
+    assert isinstance(a.doit(), Integral) is False
+
+    assert isinstance(a.doit(integrals=True), Integral) is False
+    assert isinstance(a.doit(integrals=False), Integral) is True
+
+    assert (2*Integral(x, x)).doit() == x**2
+
+
+def test_attribute_error():
+    raises(AttributeError, lambda: x.cos())
+    raises(AttributeError, lambda: x.sin())
+    raises(AttributeError, lambda: x.exp())
+
+
+def test_args():
+    assert (x*y).args in ((x, y), (y, x))
+    assert (x + y).args in ((x, y), (y, x))
+    assert (x*y + 1).args in ((x*y, 1), (1, x*y))
+    assert sin(x*y).args == (x*y,)
+    assert sin(x*y).args[0] == x*y
+    assert (x**y).args == (x, y)
+    assert (x**y).args[0] == x
+    assert (x**y).args[1] == y
+
+
+def test_noncommutative_expand_issue_3757():
+    A, B, C = symbols('A,B,C', commutative=False)
+    assert A*B - B*A != 0
+    assert (A*(A + B)*B).expand() == A**2*B + A*B**2
+    assert (A*(A + B + C)*B).expand() == A**2*B + A*B**2 + A*C*B
+
+
+def test_as_numer_denom():
+    a, b, c = symbols('a, b, c')
+
+    assert nan.as_numer_denom() == (nan, 1)
+    assert oo.as_numer_denom() == (oo, 1)
+    assert (-oo).as_numer_denom() == (-oo, 1)
+    assert zoo.as_numer_denom() == (zoo, 1)
+    assert (-zoo).as_numer_denom() == (zoo, 1)
+
+    assert x.as_numer_denom() == (x, 1)
+    assert (1/x).as_numer_denom() == (1, x)
+    assert (x/y).as_numer_denom() == (x, y)
+    assert (x/2).as_numer_denom() == (x, 2)
+    assert (x*y/z).as_numer_denom() == (x*y, z)
+    assert (x/(y*z)).as_numer_denom() == (x, y*z)
+    assert S.Half.as_numer_denom() == (1, 2)
+    assert (1/y**2).as_numer_denom() == (1, y**2)
+    assert (x/y**2).as_numer_denom() == (x, y**2)
+    assert ((x**2 + 1)/y).as_numer_denom() == (x**2 + 1, y)
+    assert (x*(y + 1)/y**7).as_numer_denom() == (x*(y + 1), y**7)
+    assert (x**-2).as_numer_denom() == (1, x**2)
+    assert (a/x + b/2/x + c/3/x).as_numer_denom() == \
+        (6*a + 3*b + 2*c, 6*x)
+    assert (a/x + b/2/x + c/3/y).as_numer_denom() == \
+        (2*c*x + y*(6*a + 3*b), 6*x*y)
+    assert (a/x + b/2/x + c/.5/x).as_numer_denom() == \
+        (2*a + b + 4.0*c, 2*x)
+    # this should take no more than a few seconds
+    assert int(log(Add(*[Dummy()/i/x for i in range(1, 705)]
+                       ).as_numer_denom()[1]/x).n(4)) == 705
+    for i in [S.Infinity, S.NegativeInfinity, S.ComplexInfinity]:
+        assert (i + x/3).as_numer_denom() == \
+            (x + i, 3)
+    assert (S.Infinity + x/3 + y/4).as_numer_denom() == \
+        (4*x + 3*y + S.Infinity, 12)
+    assert (oo*x + zoo*y).as_numer_denom() == \
+        (zoo*y + oo*x, 1)
+
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    assert (A*B*C**-1).as_numer_denom() == (A*B*C**-1, 1)
+    assert (A*B*C**-1/x).as_numer_denom() == (A*B*C**-1, x)
+    assert (C**-1*A*B).as_numer_denom() == (C**-1*A*B, 1)
+    assert (C**-1*A*B/x).as_numer_denom() == (C**-1*A*B, x)
+    assert ((A*B*C)**-1).as_numer_denom() == ((A*B*C)**-1, 1)
+    assert ((A*B*C)**-1/x).as_numer_denom() == ((A*B*C)**-1, x)
+
+    # the following morphs from Add to Mul during processing
+    assert Add(0, (x + y)/z/-2, evaluate=False).as_numer_denom(
+        ) == (-x - y, 2*z)
+
+
+def test_trunc():
+    import math
+    x, y = symbols('x y')
+    assert math.trunc(2) == 2
+    assert math.trunc(4.57) == 4
+    assert math.trunc(-5.79) == -5
+    assert math.trunc(pi) == 3
+    assert math.trunc(log(7)) == 1
+    assert math.trunc(exp(5)) == 148
+    assert math.trunc(cos(pi)) == -1
+    assert math.trunc(sin(5)) == 0
+
+    raises(TypeError, lambda: math.trunc(x))
+    raises(TypeError, lambda: math.trunc(x + y**2))
+    raises(TypeError, lambda: math.trunc(oo))
+
+
+def test_as_independent():
+    assert S.Zero.as_independent(x, as_Add=True) == (0, 0)
+    assert S.Zero.as_independent(x, as_Add=False) == (0, 0)
+    assert (2*x*sin(x) + y + x).as_independent(x) == (y, x + 2*x*sin(x))
+    assert (2*x*sin(x) + y + x).as_independent(y) == (x + 2*x*sin(x), y)
+
+    assert (2*x*sin(x) + y + x).as_independent(x, y) == (0, y + x + 2*x*sin(x))
+
+    assert (x*sin(x)*cos(y)).as_independent(x) == (cos(y), x*sin(x))
+    assert (x*sin(x)*cos(y)).as_independent(y) == (x*sin(x), cos(y))
+
+    assert (x*sin(x)*cos(y)).as_independent(x, y) == (1, x*sin(x)*cos(y))
+
+    assert (sin(x)).as_independent(x) == (1, sin(x))
+    assert (sin(x)).as_independent(y) == (sin(x), 1)
+
+    assert (2*sin(x)).as_independent(x) == (2, sin(x))
+    assert (2*sin(x)).as_independent(y) == (2*sin(x), 1)
+
+    # issue 4903 = 1766b
+    n1, n2, n3 = symbols('n1 n2 n3', commutative=False)
+    assert (n1 + n1*n2).as_independent(n2) == (n1, n1*n2)
+    assert (n2*n1 + n1*n2).as_independent(n2) == (0, n1*n2 + n2*n1)
+    assert (n1*n2*n1).as_independent(n2) == (n1, n2*n1)
+    assert (n1*n2*n1).as_independent(n1) == (1, n1*n2*n1)
+
+    assert (3*x).as_independent(x, as_Add=True) == (0, 3*x)
+    assert (3*x).as_independent(x, as_Add=False) == (3, x)
+    assert (3 + x).as_independent(x, as_Add=True) == (3, x)
+    assert (3 + x).as_independent(x, as_Add=False) == (1, 3 + x)
+
+    # issue 5479
+    assert (3*x).as_independent(Symbol) == (3, x)
+
+    # issue 5648
+    assert (n1*x*y).as_independent(x) == (n1*y, x)
+    assert ((x + n1)*(x - y)).as_independent(x) == (1, (x + n1)*(x - y))
+    assert ((x + n1)*(x - y)).as_independent(y) == (x + n1, x - y)
+    assert (DiracDelta(x - n1)*DiracDelta(x - y)).as_independent(x) \
+        == (1, DiracDelta(x - n1)*DiracDelta(x - y))
+    assert (x*y*n1*n2*n3).as_independent(n2) == (x*y*n1, n2*n3)
+    assert (x*y*n1*n2*n3).as_independent(n1) == (x*y, n1*n2*n3)
+    assert (x*y*n1*n2*n3).as_independent(n3) == (x*y*n1*n2, n3)
+    assert (DiracDelta(x - n1)*DiracDelta(y - n1)*DiracDelta(x - n2)).as_independent(y) == \
+           (DiracDelta(x - n1)*DiracDelta(x - n2), DiracDelta(y - n1))
+
+    # issue 5784
+    assert (x + Integral(x, (x, 1, 2))).as_independent(x, strict=True) == \
+           (Integral(x, (x, 1, 2)), x)
+
+    eq = Add(x, -x, 2, -3, evaluate=False)
+    assert eq.as_independent(x) == (-1, Add(x, -x, evaluate=False))
+    eq = Mul(x, 1/x, 2, -3, evaluate=False)
+    assert eq.as_independent(x) == (-6, Mul(x, 1/x, evaluate=False))
+
+    assert (x*y).as_independent(z, as_Add=True) == (x*y, 0)
+
+@XFAIL
+def test_call_2():
+    # TODO UndefinedFunction does not subclass Expr
+    assert (2*f)(x) == 2*f(x)
+
+
+def test_replace():
+    e = log(sin(x)) + tan(sin(x**2))
+
+    assert e.replace(sin, cos) == log(cos(x)) + tan(cos(x**2))
+    assert e.replace(
+        sin, lambda a: sin(2*a)) == log(sin(2*x)) + tan(sin(2*x**2))
+
+    a = Wild('a')
+    b = Wild('b')
+
+    assert e.replace(sin(a), cos(a)) == log(cos(x)) + tan(cos(x**2))
+    assert e.replace(
+        sin(a), lambda a: sin(2*a)) == log(sin(2*x)) + tan(sin(2*x**2))
+    # test exact
+    assert (2*x).replace(a*x + b, b - a, exact=True) == 2*x
+    assert (2*x).replace(a*x + b, b - a) == 2*x
+    assert (2*x).replace(a*x + b, b - a, exact=False) == 2/x
+    assert (2*x).replace(a*x + b, lambda a, b: b - a, exact=True) == 2*x
+    assert (2*x).replace(a*x + b, lambda a, b: b - a) == 2*x
+    assert (2*x).replace(a*x + b, lambda a, b: b - a, exact=False) == 2/x
+
+    g = 2*sin(x**3)
+
+    assert g.replace(
+        lambda expr: expr.is_Number, lambda expr: expr**2) == 4*sin(x**9)
+
+    assert cos(x).replace(cos, sin, map=True) == (sin(x), {cos(x): sin(x)})
+    assert sin(x).replace(cos, sin) == sin(x)
+
+    cond, func = lambda x: x.is_Mul, lambda x: 2*x
+    assert (x*y).replace(cond, func, map=True) == (2*x*y, {x*y: 2*x*y})
+    assert (x*(1 + x*y)).replace(cond, func, map=True) == \
+        (2*x*(2*x*y + 1), {x*(2*x*y + 1): 2*x*(2*x*y + 1), x*y: 2*x*y})
+    assert (y*sin(x)).replace(sin, lambda expr: sin(expr)/y, map=True) == \
+        (sin(x), {sin(x): sin(x)/y})
+    # if not simultaneous then y*sin(x) -> y*sin(x)/y = sin(x) -> sin(x)/y
+    assert (y*sin(x)).replace(sin, lambda expr: sin(expr)/y,
+        simultaneous=False) == sin(x)/y
+    assert (x**2 + O(x**3)).replace(Pow, lambda b, e: b**e/e
+        ) == x**2/2 + O(x**3)
+    assert (x**2 + O(x**3)).replace(Pow, lambda b, e: b**e/e,
+        simultaneous=False) == x**2/2 + O(x**3)
+    assert (x*(x*y + 3)).replace(lambda x: x.is_Mul, lambda x: 2 + x) == \
+        x*(x*y + 5) + 2
+    e = (x*y + 1)*(2*x*y + 1) + 1
+    assert e.replace(cond, func, map=True) == (
+        2*((2*x*y + 1)*(4*x*y + 1)) + 1,
+        {2*x*y: 4*x*y, x*y: 2*x*y, (2*x*y + 1)*(4*x*y + 1):
+        2*((2*x*y + 1)*(4*x*y + 1))})
+    assert x.replace(x, y) == y
+    assert (x + 1).replace(1, 2) == x + 2
+
+    # https://groups.google.com/forum/#!topic/sympy/8wCgeC95tz0
+    n1, n2, n3 = symbols('n1:4', commutative=False)
+    assert (n1*f(n2)).replace(f, lambda x: x) == n1*n2
+    assert (n3*f(n2)).replace(f, lambda x: x) == n3*n2
+
+    # issue 16725
+    assert S.Zero.replace(Wild('x'), 1) == 1
+    # let the user override the default decision of False
+    assert S.Zero.replace(Wild('x'), 1, exact=True) == 0
+
+
+def test_find():
+    expr = (x + y + 2 + sin(3*x))
+
+    assert expr.find(lambda u: u.is_Integer) == {S(2), S(3)}
+    assert expr.find(lambda u: u.is_Symbol) == {x, y}
+
+    assert expr.find(lambda u: u.is_Integer, group=True) == {S(2): 1, S(3): 1}
+    assert expr.find(lambda u: u.is_Symbol, group=True) == {x: 2, y: 1}
+
+    assert expr.find(Integer) == {S(2), S(3)}
+    assert expr.find(Symbol) == {x, y}
+
+    assert expr.find(Integer, group=True) == {S(2): 1, S(3): 1}
+    assert expr.find(Symbol, group=True) == {x: 2, y: 1}
+
+    a = Wild('a')
+
+    expr = sin(sin(x)) + sin(x) + cos(x) + x
+
+    assert expr.find(lambda u: type(u) is sin) == {sin(x), sin(sin(x))}
+    assert expr.find(
+        lambda u: type(u) is sin, group=True) == {sin(x): 2, sin(sin(x)): 1}
+
+    assert expr.find(sin(a)) == {sin(x), sin(sin(x))}
+    assert expr.find(sin(a), group=True) == {sin(x): 2, sin(sin(x)): 1}
+
+    assert expr.find(sin) == {sin(x), sin(sin(x))}
+    assert expr.find(sin, group=True) == {sin(x): 2, sin(sin(x)): 1}
+
+
+def test_count():
+    expr = (x + y + 2 + sin(3*x))
+
+    assert expr.count(lambda u: u.is_Integer) == 2
+    assert expr.count(lambda u: u.is_Symbol) == 3
+
+    assert expr.count(Integer) == 2
+    assert expr.count(Symbol) == 3
+    assert expr.count(2) == 1
+
+    a = Wild('a')
+
+    assert expr.count(sin) == 1
+    assert expr.count(sin(a)) == 1
+    assert expr.count(lambda u: type(u) is sin) == 1
+
+    assert f(x).count(f(x)) == 1
+    assert f(x).diff(x).count(f(x)) == 1
+    assert f(x).diff(x).count(x) == 2
+
+
+def test_has_basics():
+    p = Wild('p')
+
+    assert sin(x).has(x)
+    assert sin(x).has(sin)
+    assert not sin(x).has(y)
+    assert not sin(x).has(cos)
+    assert f(x).has(x)
+    assert f(x).has(f)
+    assert not f(x).has(y)
+    assert not f(x).has(g)
+
+    assert f(x).diff(x).has(x)
+    assert f(x).diff(x).has(f)
+    assert f(x).diff(x).has(Derivative)
+    assert not f(x).diff(x).has(y)
+    assert not f(x).diff(x).has(g)
+    assert not f(x).diff(x).has(sin)
+
+    assert (x**2).has(Symbol)
+    assert not (x**2).has(Wild)
+    assert (2*p).has(Wild)
+
+    assert not x.has()
+
+
+def test_has_multiple():
+    f = x**2*y + sin(2**t + log(z))
+
+    assert f.has(x)
+    assert f.has(y)
+    assert f.has(z)
+    assert f.has(t)
+
+    assert not f.has(u)
+
+    assert f.has(x, y, z, t)
+    assert f.has(x, y, z, t, u)
+
+    i = Integer(4400)
+
+    assert not i.has(x)
+
+    assert (i*x**i).has(x)
+    assert not (i*y**i).has(x)
+    assert (i*y**i).has(x, y)
+    assert not (i*y**i).has(x, z)
+
+
+def test_has_piecewise():
+    f = (x*y + 3/y)**(3 + 2)
+    p = Piecewise((g(x), x < -1), (1, x <= 1), (f, True))
+
+    assert p.has(x)
+    assert p.has(y)
+    assert not p.has(z)
+    assert p.has(1)
+    assert p.has(3)
+    assert not p.has(4)
+    assert p.has(f)
+    assert p.has(g)
+    assert not p.has(h)
+
+
+def test_has_iterative():
+    A, B, C = symbols('A,B,C', commutative=False)
+    f = x*gamma(x)*sin(x)*exp(x*y)*A*B*C*cos(x*A*B)
+
+    assert f.has(x)
+    assert f.has(x*y)
+    assert f.has(x*sin(x))
+    assert not f.has(x*sin(y))
+    assert f.has(x*A)
+    assert f.has(x*A*B)
+    assert not f.has(x*A*C)
+    assert f.has(x*A*B*C)
+    assert not f.has(x*A*C*B)
+    assert f.has(x*sin(x)*A*B*C)
+    assert not f.has(x*sin(x)*A*C*B)
+    assert not f.has(x*sin(y)*A*B*C)
+    assert f.has(x*gamma(x))
+    assert not f.has(x + sin(x))
+
+    assert (x & y & z).has(x & z)
+
+
+def test_has_integrals():
+    f = Integral(x**2 + sin(x*y*z), (x, 0, x + y + z))
+
+    assert f.has(x + y)
+    assert f.has(x + z)
+    assert f.has(y + z)
+
+    assert f.has(x*y)
+    assert f.has(x*z)
+    assert f.has(y*z)
+
+    assert not f.has(2*x + y)
+    assert not f.has(2*x*y)
+
+
+def test_has_tuple():
+    assert Tuple(x, y).has(x)
+    assert not Tuple(x, y).has(z)
+    assert Tuple(f(x), g(x)).has(x)
+    assert not Tuple(f(x), g(x)).has(y)
+    assert Tuple(f(x), g(x)).has(f)
+    assert Tuple(f(x), g(x)).has(f(x))
+    # XXX to be deprecated
+    #assert not Tuple(f, g).has(x)
+    #assert Tuple(f, g).has(f)
+    #assert not Tuple(f, g).has(h)
+    assert Tuple(True).has(True)
+    assert Tuple(True).has(S.true)
+    assert not Tuple(True).has(1)
+
+
+def test_has_units():
+    from sympy.physics.units import m, s
+
+    assert (x*m/s).has(x)
+    assert (x*m/s).has(y, z) is False
+
+
+def test_has_polys():
+    poly = Poly(x**2 + x*y*sin(z), x, y, t)
+
+    assert poly.has(x)
+    assert poly.has(x, y, z)
+    assert poly.has(x, y, z, t)
+
+
+def test_has_physics():
+    assert FockState((x, y)).has(x)
+
+
+def test_as_poly_as_expr():
+    f = x**2 + 2*x*y
+
+    assert f.as_poly().as_expr() == f
+    assert f.as_poly(x, y).as_expr() == f
+
+    assert (f + sin(x)).as_poly(x, y) is None
+
+    p = Poly(f, x, y)
+
+    assert p.as_poly() == p
+
+    # https://github.com/sympy/sympy/issues/20610
+    assert S(2).as_poly() is None
+    assert sqrt(2).as_poly(extension=True) is None
+
+    raises(AttributeError, lambda: Tuple(x, x).as_poly(x))
+    raises(AttributeError, lambda: Tuple(x ** 2, x, y).as_poly(x))
+
+
+def test_nonzero():
+    assert bool(S.Zero) is False
+    assert bool(S.One) is True
+    assert bool(x) is True
+    assert bool(x + y) is True
+    assert bool(x - x) is False
+    assert bool(x*y) is True
+    assert bool(x*1) is True
+    assert bool(x*0) is False
+
+
+def test_is_number():
+    assert Float(3.14).is_number is True
+    assert Integer(737).is_number is True
+    assert Rational(3, 2).is_number is True
+    assert Rational(8).is_number is True
+    assert x.is_number is False
+    assert (2*x).is_number is False
+    assert (x + y).is_number is False
+    assert log(2).is_number is True
+    assert log(x).is_number is False
+    assert (2 + log(2)).is_number is True
+    assert (8 + log(2)).is_number is True
+    assert (2 + log(x)).is_number is False
+    assert (8 + log(2) + x).is_number is False
+    assert (1 + x**2/x - x).is_number is True
+    assert Tuple(Integer(1)).is_number is False
+    assert Add(2, x).is_number is False
+    assert Mul(3, 4).is_number is True
+    assert Pow(log(2), 2).is_number is True
+    assert oo.is_number is True
+    g = WildFunction('g')
+    assert g.is_number is False
+    assert (2*g).is_number is False
+    assert (x**2).subs(x, 3).is_number is True
+
+    # test extensibility of .is_number
+    # on subinstances of Basic
+    class A(Basic):
+        pass
+    a = A()
+    assert a.is_number is False
+
+
+def test_as_coeff_add():
+    assert S(2).as_coeff_add() == (2, ())
+    assert S(3.0).as_coeff_add() == (0, (S(3.0),))
+    assert S(-3.0).as_coeff_add() == (0, (S(-3.0),))
+    assert x.as_coeff_add() == (0, (x,))
+    assert (x - 1).as_coeff_add() == (-1, (x,))
+    assert (x + 1).as_coeff_add() == (1, (x,))
+    assert (x + 2).as_coeff_add() == (2, (x,))
+    assert (x + y).as_coeff_add(y) == (x, (y,))
+    assert (3*x).as_coeff_add(y) == (3*x, ())
+    # don't do expansion
+    e = (x + y)**2
+    assert e.as_coeff_add(y) == (0, (e,))
+
+
+def test_as_coeff_mul():
+    assert S(2).as_coeff_mul() == (2, ())
+    assert S(3.0).as_coeff_mul() == (1, (S(3.0),))
+    assert S(-3.0).as_coeff_mul() == (-1, (S(3.0),))
+    assert S(-3.0).as_coeff_mul(rational=False) == (-S(3.0), ())
+    assert x.as_coeff_mul() == (1, (x,))
+    assert (-x).as_coeff_mul() == (-1, (x,))
+    assert (2*x).as_coeff_mul() == (2, (x,))
+    assert (x*y).as_coeff_mul(y) == (x, (y,))
+    assert (3 + x).as_coeff_mul() == (1, (3 + x,))
+    assert (3 + x).as_coeff_mul(y) == (3 + x, ())
+    # don't do expansion
+    e = exp(x + y)
+    assert e.as_coeff_mul(y) == (1, (e,))
+    e = 2**(x + y)
+    assert e.as_coeff_mul(y) == (1, (e,))
+    assert (1.1*x).as_coeff_mul(rational=False) == (1.1, (x,))
+    assert (1.1*x).as_coeff_mul() == (1, (1.1, x))
+    assert (-oo*x).as_coeff_mul(rational=True) == (-1, (oo, x))
+
+
+def test_as_coeff_exponent():
+    assert (3*x**4).as_coeff_exponent(x) == (3, 4)
+    assert (2*x**3).as_coeff_exponent(x) == (2, 3)
+    assert (4*x**2).as_coeff_exponent(x) == (4, 2)
+    assert (6*x**1).as_coeff_exponent(x) == (6, 1)
+    assert (3*x**0).as_coeff_exponent(x) == (3, 0)
+    assert (2*x**0).as_coeff_exponent(x) == (2, 0)
+    assert (1*x**0).as_coeff_exponent(x) == (1, 0)
+    assert (0*x**0).as_coeff_exponent(x) == (0, 0)
+    assert (-1*x**0).as_coeff_exponent(x) == (-1, 0)
+    assert (-2*x**0).as_coeff_exponent(x) == (-2, 0)
+    assert (2*x**3 + pi*x**3).as_coeff_exponent(x) == (2 + pi, 3)
+    assert (x*log(2)/(2*x + pi*x)).as_coeff_exponent(x) == \
+        (log(2)/(2 + pi), 0)
+    # issue 4784
+    D = Derivative
+    fx = D(f(x), x)
+    assert fx.as_coeff_exponent(f(x)) == (fx, 0)
+
+
+def test_extractions():
+    for base in (2, S.Exp1):
+        assert Pow(base**x, 3, evaluate=False
+            ).extract_multiplicatively(base**x) == base**(2*x)
+        assert (base**(5*x)).extract_multiplicatively(
+            base**(3*x)) == base**(2*x)
+    assert ((x*y)**3).extract_multiplicatively(x**2 * y) == x*y**2
+    assert ((x*y)**3).extract_multiplicatively(x**4 * y) is None
+    assert (2*x).extract_multiplicatively(2) == x
+    assert (2*x).extract_multiplicatively(3) is None
+    assert (2*x).extract_multiplicatively(-1) is None
+    assert (S.Half*x).extract_multiplicatively(3) == x/6
+    assert (sqrt(x)).extract_multiplicatively(x) is None
+    assert (sqrt(x)).extract_multiplicatively(1/x) is None
+    assert x.extract_multiplicatively(-x) is None
+    assert (-2 - 4*I).extract_multiplicatively(-2) == 1 + 2*I
+    assert (-2 - 4*I).extract_multiplicatively(3) is None
+    assert (-2*x - 4*y - 8).extract_multiplicatively(-2) == x + 2*y + 4
+    assert (-2*x*y - 4*x**2*y).extract_multiplicatively(-2*y) == 2*x**2 + x
+    assert (2*x*y + 4*x**2*y).extract_multiplicatively(2*y) == 2*x**2 + x
+    assert (-4*y**2*x).extract_multiplicatively(-3*y) is None
+    assert (2*x).extract_multiplicatively(1) == 2*x
+    assert (-oo).extract_multiplicatively(5) is -oo
+    assert (oo).extract_multiplicatively(5) is oo
+
+    assert ((x*y)**3).extract_additively(1) is None
+    assert (x + 1).extract_additively(x) == 1
+    assert (x + 1).extract_additively(2*x) is None
+    assert (x + 1).extract_additively(-x) is None
+    assert (-x + 1).extract_additively(2*x) is None
+    assert (2*x + 3).extract_additively(x) == x + 3
+    assert (2*x + 3).extract_additively(2) == 2*x + 1
+    assert (2*x + 3).extract_additively(3) == 2*x
+    assert (2*x + 3).extract_additively(-2) is None
+    assert (2*x + 3).extract_additively(3*x) is None
+    assert (2*x + 3).extract_additively(2*x) == 3
+    assert x.extract_additively(0) == x
+    assert S(2).extract_additively(x) is None
+    assert S(2.).extract_additively(2.) is S.Zero
+    assert S(2.).extract_additively(2) is S.Zero
+    assert S(2*x + 3).extract_additively(x + 1) == x + 2
+    assert S(2*x + 3).extract_additively(y + 1) is None
+    assert S(2*x - 3).extract_additively(x + 1) is None
+    assert S(2*x - 3).extract_additively(y + z) is None
+    assert ((a + 1)*x*4 + y).extract_additively(x).expand() == \
+        4*a*x + 3*x + y
+    assert ((a + 1)*x*4 + 3*y).extract_additively(x + 2*y).expand() == \
+        4*a*x + 3*x + y
+    assert (y*(x + 1)).extract_additively(x + 1) is None
+    assert ((y + 1)*(x + 1) + 3).extract_additively(x + 1) == \
+        y*(x + 1) + 3
+    assert ((x + y)*(x + 1) + x + y + 3).extract_additively(x + y) == \
+        x*(x + y) + 3
+    assert (x + y + 2*((x + y)*(x + 1)) + 3).extract_additively((x + y)*(x + 1)) == \
+        x + y + (x + 1)*(x + y) + 3
+    assert ((y + 1)*(x + 2*y + 1) + 3).extract_additively(y + 1) == \
+        (x + 2*y)*(y + 1) + 3
+    assert (-x - x*I).extract_additively(-x) == -I*x
+    # extraction does not leave artificats, now
+    assert (4*x*(y + 1) + y).extract_additively(x) == x*(4*y + 3) + y
+
+    n = Symbol("n", integer=True)
+    assert (Integer(-3)).could_extract_minus_sign() is True
+    assert (-n*x + x).could_extract_minus_sign() != \
+        (n*x - x).could_extract_minus_sign()
+    assert (x - y).could_extract_minus_sign() != \
+        (-x + y).could_extract_minus_sign()
+    assert (1 - x - y).could_extract_minus_sign() is True
+    assert (1 - x + y).could_extract_minus_sign() is False
+    assert ((-x - x*y)/y).could_extract_minus_sign() is False
+    assert ((x + x*y)/(-y)).could_extract_minus_sign() is True
+    assert ((x + x*y)/y).could_extract_minus_sign() is False
+    assert ((-x - y)/(x + y)).could_extract_minus_sign() is False
+
+    class sign_invariant(Function, Expr):
+        nargs = 1
+        def __neg__(self):
+            return self
+    foo = sign_invariant(x)
+    assert foo == -foo
+    assert foo.could_extract_minus_sign() is False
+    assert (x - y).could_extract_minus_sign() is False
+    assert (-x + y).could_extract_minus_sign() is True
+    assert (x - 1).could_extract_minus_sign() is False
+    assert (1 - x).could_extract_minus_sign() is True
+    assert (sqrt(2) - 1).could_extract_minus_sign() is True
+    assert (1 - sqrt(2)).could_extract_minus_sign() is False
+    # check that result is canonical
+    eq = (3*x + 15*y).extract_multiplicatively(3)
+    assert eq.args == eq.func(*eq.args).args
+
+
+def test_nan_extractions():
+    for r in (1, 0, I, nan):
+        assert nan.extract_additively(r) is None
+        assert nan.extract_multiplicatively(r) is None
+
+
+def test_coeff():
+    assert (x + 1).coeff(x + 1) == 1
+    assert (3*x).coeff(0) == 0
+    assert (z*(1 + x)*x**2).coeff(1 + x) == z*x**2
+    assert (1 + 2*x*x**(1 + x)).coeff(x*x**(1 + x)) == 2
+    assert (1 + 2*x**(y + z)).coeff(x**(y + z)) == 2
+    assert (3 + 2*x + 4*x**2).coeff(1) == 0
+    assert (3 + 2*x + 4*x**2).coeff(-1) == 0
+    assert (3 + 2*x + 4*x**2).coeff(x) == 2
+    assert (3 + 2*x + 4*x**2).coeff(x**2) == 4
+    assert (3 + 2*x + 4*x**2).coeff(x**3) == 0
+
+    assert (-x/8 + x*y).coeff(x) == Rational(-1, 8) + y
+    assert (-x/8 + x*y).coeff(-x) == S.One/8
+    assert (4*x).coeff(2*x) == 0
+    assert (2*x).coeff(2*x) == 1
+    assert (-oo*x).coeff(x*oo) == -1
+    assert (10*x).coeff(x, 0) == 0
+    assert (10*x).coeff(10*x, 0) == 0
+
+    n1, n2 = symbols('n1 n2', commutative=False)
+    assert (n1*n2).coeff(n1) == 1
+    assert (n1*n2).coeff(n2) == n1
+    assert (n1*n2 + x*n1).coeff(n1) == 1  # 1*n1*(n2+x)
+    assert (n2*n1 + x*n1).coeff(n1) == n2 + x
+    assert (n2*n1 + x*n1**2).coeff(n1) == n2
+    assert (n1**x).coeff(n1) == 0
+    assert (n1*n2 + n2*n1).coeff(n1) == 0
+    assert (2*(n1 + n2)*n2).coeff(n1 + n2, right=1) == n2
+    assert (2*(n1 + n2)*n2).coeff(n1 + n2, right=0) == 2
+
+    assert (2*f(x) + 3*f(x).diff(x)).coeff(f(x)) == 2
+
+    expr = z*(x + y)**2
+    expr2 = z*(x + y)**2 + z*(2*x + 2*y)**2
+    assert expr.coeff(z) == (x + y)**2
+    assert expr.coeff(x + y) == 0
+    assert expr2.coeff(z) == (x + y)**2 + (2*x + 2*y)**2
+
+    assert (x + y + 3*z).coeff(1) == x + y
+    assert (-x + 2*y).coeff(-1) == x
+    assert (x - 2*y).coeff(-1) == 2*y
+    assert (3 + 2*x + 4*x**2).coeff(1) == 0
+    assert (-x - 2*y).coeff(2) == -y
+    assert (x + sqrt(2)*x).coeff(sqrt(2)) == x
+    assert (3 + 2*x + 4*x**2).coeff(x) == 2
+    assert (3 + 2*x + 4*x**2).coeff(x**2) == 4
+    assert (3 + 2*x + 4*x**2).coeff(x**3) == 0
+    assert (z*(x + y)**2).coeff((x + y)**2) == z
+    assert (z*(x + y)**2).coeff(x + y) == 0
+    assert (2 + 2*x + (x + 1)*y).coeff(x + 1) == y
+
+    assert (x + 2*y + 3).coeff(1) == x
+    assert (x + 2*y + 3).coeff(x, 0) == 2*y + 3
+    assert (x**2 + 2*y + 3*x).coeff(x**2, 0) == 2*y + 3*x
+    assert x.coeff(0, 0) == 0
+    assert x.coeff(x, 0) == 0
+
+    n, m, o, l = symbols('n m o l', commutative=False)
+    assert n.coeff(n) == 1
+    assert y.coeff(n) == 0
+    assert (3*n).coeff(n) == 3
+    assert (2 + n).coeff(x*m) == 0
+    assert (2*x*n*m).coeff(x) == 2*n*m
+    assert (2 + n).coeff(x*m*n + y) == 0
+    assert (2*x*n*m).coeff(3*n) == 0
+    assert (n*m + m*n*m).coeff(n) == 1 + m
+    assert (n*m + m*n*m).coeff(n, right=True) == m  # = (1 + m)*n*m
+    assert (n*m + m*n).coeff(n) == 0
+    assert (n*m + o*m*n).coeff(m*n) == o
+    assert (n*m + o*m*n).coeff(m*n, right=True) == 1
+    assert (n*m + n*m*n).coeff(n*m, right=True) == 1 + n  # = n*m*(n + 1)
+
+    assert (x*y).coeff(z, 0) == x*y
+
+    assert (x*n + y*n + z*m).coeff(n) == x + y
+    assert (n*m + n*o + o*l).coeff(n, right=True) == m + o
+    assert (x*n*m*n + y*n*m*o + z*l).coeff(m, right=True) == x*n + y*o
+    assert (x*n*m*n + x*n*m*o + z*l).coeff(m, right=True) == n + o
+    assert (x*n*m*n + x*n*m*o + z*l).coeff(m) == x*n
+
+
+def test_coeff2():
+    r, kappa = symbols('r, kappa')
+    psi = Function("psi")
+    g = 1/r**2 * (2*r*psi(r).diff(r, 1) + r**2 * psi(r).diff(r, 2))
+    g = g.expand()
+    assert g.coeff(psi(r).diff(r)) == 2/r
+
+
+def test_coeff2_0():
+    r, kappa = symbols('r, kappa')
+    psi = Function("psi")
+    g = 1/r**2 * (2*r*psi(r).diff(r, 1) + r**2 * psi(r).diff(r, 2))
+    g = g.expand()
+
+    assert g.coeff(psi(r).diff(r, 2)) == 1
+
+
+def test_coeff_expand():
+    expr = z*(x + y)**2
+    expr2 = z*(x + y)**2 + z*(2*x + 2*y)**2
+    assert expr.coeff(z) == (x + y)**2
+    assert expr2.coeff(z) == (x + y)**2 + (2*x + 2*y)**2
+
+
+def test_integrate():
+    assert x.integrate(x) == x**2/2
+    assert x.integrate((x, 0, 1)) == S.Half
+
+
+def test_as_base_exp():
+    assert x.as_base_exp() == (x, S.One)
+    assert (x*y*z).as_base_exp() == (x*y*z, S.One)
+    assert (x + y + z).as_base_exp() == (x + y + z, S.One)
+    assert ((x + y)**z).as_base_exp() == (x + y, z)
+
+
+def test_issue_4963():
+    assert hasattr(Mul(x, y), "is_commutative")
+    assert hasattr(Mul(x, y, evaluate=False), "is_commutative")
+    assert hasattr(Pow(x, y), "is_commutative")
+    assert hasattr(Pow(x, y, evaluate=False), "is_commutative")
+    expr = Mul(Pow(2, 2, evaluate=False), 3, evaluate=False) + 1
+    assert hasattr(expr, "is_commutative")
+
+
+def test_action_verbs():
+    assert nsimplify(1/(exp(3*pi*x/5) + 1)) == \
+        (1/(exp(3*pi*x/5) + 1)).nsimplify()
+    assert ratsimp(1/x + 1/y) == (1/x + 1/y).ratsimp()
+    assert trigsimp(log(x), deep=True) == (log(x)).trigsimp(deep=True)
+    assert radsimp(1/(2 + sqrt(2))) == (1/(2 + sqrt(2))).radsimp()
+    assert radsimp(1/(a + b*sqrt(c)), symbolic=False) == \
+        (1/(a + b*sqrt(c))).radsimp(symbolic=False)
+    assert powsimp(x**y*x**z*y**z, combine='all') == \
+        (x**y*x**z*y**z).powsimp(combine='all')
+    assert (x**t*y**t).powsimp(force=True) == (x*y)**t
+    assert simplify(x**y*x**z*y**z) == (x**y*x**z*y**z).simplify()
+    assert together(1/x + 1/y) == (1/x + 1/y).together()
+    assert collect(a*x**2 + b*x**2 + a*x - b*x + c, x) == \
+        (a*x**2 + b*x**2 + a*x - b*x + c).collect(x)
+    assert apart(y/(y + 2)/(y + 1), y) == (y/(y + 2)/(y + 1)).apart(y)
+    assert combsimp(y/(x + 2)/(x + 1)) == (y/(x + 2)/(x + 1)).combsimp()
+    assert gammasimp(gamma(x)/gamma(x-5)) == (gamma(x)/gamma(x-5)).gammasimp()
+    assert factor(x**2 + 5*x + 6) == (x**2 + 5*x + 6).factor()
+    assert refine(sqrt(x**2)) == sqrt(x**2).refine()
+    assert cancel((x**2 + 5*x + 6)/(x + 2)) == ((x**2 + 5*x + 6)/(x + 2)).cancel()
+
+
+def test_as_powers_dict():
+    assert x.as_powers_dict() == {x: 1}
+    assert (x**y*z).as_powers_dict() == {x: y, z: 1}
+    assert Mul(2, 2, evaluate=False).as_powers_dict() == {S(2): S(2)}
+    assert (x*y).as_powers_dict()[z] == 0
+    assert (x + y).as_powers_dict()[z] == 0
+
+
+def test_as_coefficients_dict():
+    check = [S.One, x, y, x*y, 1]
+    assert [Add(3*x, 2*x, y, 3).as_coefficients_dict()[i] for i in check] == \
+        [3, 5, 1, 0, 3]
+    assert [Add(3*x, 2*x, y, 3, evaluate=False).as_coefficients_dict()[i]
+            for i in check] == [3, 5, 1, 0, 3]
+    assert [(3*x*y).as_coefficients_dict()[i] for i in check] == \
+        [0, 0, 0, 3, 0]
+    assert [(3.0*x*y).as_coefficients_dict()[i] for i in check] == \
+        [0, 0, 0, 3.0, 0]
+    assert (3.0*x*y).as_coefficients_dict()[3.0*x*y] == 0
+    eq = x*(x + 1)*a + x*b + c/x
+    assert eq.as_coefficients_dict(x) == {x: b, 1/x: c,
+        x*(x + 1): a}
+    assert eq.expand().as_coefficients_dict(x) == {x**2: a, x: a + b, 1/x: c}
+    assert x.as_coefficients_dict() == {x: S.One}
+
+
+def test_args_cnc():
+    A = symbols('A', commutative=False)
+    assert (x + A).args_cnc() == \
+        [[], [x + A]]
+    assert (x + a).args_cnc() == \
+        [[a + x], []]
+    assert (x*a).args_cnc() == \
+        [[a, x], []]
+    assert (x*y*A*(A + 1)).args_cnc(cset=True) == \
+        [{x, y}, [A, 1 + A]]
+    assert Mul(x, x, evaluate=False).args_cnc(cset=True, warn=False) == \
+        [{x}, []]
+    assert Mul(x, x**2, evaluate=False).args_cnc(cset=True, warn=False) == \
+        [{x, x**2}, []]
+    raises(ValueError, lambda: Mul(x, x, evaluate=False).args_cnc(cset=True))
+    assert Mul(x, y, x, evaluate=False).args_cnc() == \
+        [[x, y, x], []]
+    # always split -1 from leading number
+    assert (-1.*x).args_cnc() == [[-1, 1.0, x], []]
+
+
+def test_new_rawargs():
+    n = Symbol('n', commutative=False)
+    a = x + n
+    assert a.is_commutative is False
+    assert a._new_rawargs(x).is_commutative
+    assert a._new_rawargs(x, y).is_commutative
+    assert a._new_rawargs(x, n).is_commutative is False
+    assert a._new_rawargs(x, y, n).is_commutative is False
+    m = x*n
+    assert m.is_commutative is False
+    assert m._new_rawargs(x).is_commutative
+    assert m._new_rawargs(n).is_commutative is False
+    assert m._new_rawargs(x, y).is_commutative
+    assert m._new_rawargs(x, n).is_commutative is False
+    assert m._new_rawargs(x, y, n).is_commutative is False
+
+    assert m._new_rawargs(x, n, reeval=False).is_commutative is False
+    assert m._new_rawargs(S.One) is S.One
+
+
+def test_issue_5226():
+    assert Add(evaluate=False) == 0
+    assert Mul(evaluate=False) == 1
+    assert Mul(x + y, evaluate=False).is_Add
+
+
+def test_free_symbols():
+    # free_symbols should return the free symbols of an object
+    assert S.One.free_symbols == set()
+    assert x.free_symbols == {x}
+    assert Integral(x, (x, 1, y)).free_symbols == {y}
+    assert (-Integral(x, (x, 1, y))).free_symbols == {y}
+    assert meter.free_symbols == set()
+    assert (meter**x).free_symbols == {x}
+
+
+def test_has_free():
+    assert x.has_free(x)
+    assert not x.has_free(y)
+    assert (x + y).has_free(x)
+    assert (x + y).has_free(*(x, z))
+    assert f(x).has_free(x)
+    assert f(x).has_free(f(x))
+    assert Integral(f(x), (f(x), 1, y)).has_free(y)
+    assert not Integral(f(x), (f(x), 1, y)).has_free(x)
+    assert not Integral(f(x), (f(x), 1, y)).has_free(f(x))
+    # simple extraction
+    assert (x + 1 + y).has_free(x + 1)
+    assert not (x + 2 + y).has_free(x + 1)
+    assert (2 + 3*x*y).has_free(3*x)
+    raises(TypeError, lambda: x.has_free({x, y}))
+    s = FiniteSet(1, 2)
+    assert Piecewise((s, x > 3), (4, True)).has_free(s)
+    assert not Piecewise((1, x > 3), (4, True)).has_free(s)
+    # can't make set of these, but fallback will handle
+    raises(TypeError, lambda: x.has_free(y, []))
+
+
+def test_has_xfree():
+    assert (x + 1).has_xfree({x})
+    assert ((x + 1)**2).has_xfree({x + 1})
+    assert not (x + y + 1).has_xfree({x + 1})
+    raises(TypeError, lambda: x.has_xfree(x))
+    raises(TypeError, lambda: x.has_xfree([x]))
+
+
+def test_issue_5300():
+    x = Symbol('x', commutative=False)
+    assert x*sqrt(2)/sqrt(6) == x*sqrt(3)/3
+
+
+def test_floordiv():
+    from sympy.functions.elementary.integers import floor
+    assert x // y == floor(x / y)
+
+
+def test_as_coeff_Mul():
+    assert Integer(3).as_coeff_Mul() == (Integer(3), Integer(1))
+    assert Rational(3, 4).as_coeff_Mul() == (Rational(3, 4), Integer(1))
+    assert Float(5.0).as_coeff_Mul() == (Float(5.0), Integer(1))
+
+    assert (Integer(3)*x).as_coeff_Mul() == (Integer(3), x)
+    assert (Rational(3, 4)*x).as_coeff_Mul() == (Rational(3, 4), x)
+    assert (Float(5.0)*x).as_coeff_Mul() == (Float(5.0), x)
+
+    assert (Integer(3)*x*y).as_coeff_Mul() == (Integer(3), x*y)
+    assert (Rational(3, 4)*x*y).as_coeff_Mul() == (Rational(3, 4), x*y)
+    assert (Float(5.0)*x*y).as_coeff_Mul() == (Float(5.0), x*y)
+
+    assert (x).as_coeff_Mul() == (S.One, x)
+    assert (x*y).as_coeff_Mul() == (S.One, x*y)
+    assert (-oo*x).as_coeff_Mul(rational=True) == (-1, oo*x)
+
+
+def test_as_coeff_Add():
+    assert Integer(3).as_coeff_Add() == (Integer(3), Integer(0))
+    assert Rational(3, 4).as_coeff_Add() == (Rational(3, 4), Integer(0))
+    assert Float(5.0).as_coeff_Add() == (Float(5.0), Integer(0))
+
+    assert (Integer(3) + x).as_coeff_Add() == (Integer(3), x)
+    assert (Rational(3, 4) + x).as_coeff_Add() == (Rational(3, 4), x)
+    assert (Float(5.0) + x).as_coeff_Add() == (Float(5.0), x)
+    assert (Float(5.0) + x).as_coeff_Add(rational=True) == (0, Float(5.0) + x)
+
+    assert (Integer(3) + x + y).as_coeff_Add() == (Integer(3), x + y)
+    assert (Rational(3, 4) + x + y).as_coeff_Add() == (Rational(3, 4), x + y)
+    assert (Float(5.0) + x + y).as_coeff_Add() == (Float(5.0), x + y)
+
+    assert (x).as_coeff_Add() == (S.Zero, x)
+    assert (x*y).as_coeff_Add() == (S.Zero, x*y)
+
+
+def test_expr_sorting():
+
+    exprs = [1/x**2, 1/x, sqrt(sqrt(x)), sqrt(x), x, sqrt(x)**3, x**2]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [x, 2*x, 2*x**2, 2*x**3, x**n, 2*x**n, sin(x), sin(x)**n,
+             sin(x**2), cos(x), cos(x**2), tan(x)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [x + 1, x**2 + x + 1, x**3 + x**2 + x + 1]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [S(4), x - 3*I/2, x + 3*I/2, x - 4*I + 1, x + 4*I + 1]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [f(1), f(2), f(3), f(1, 2, 3), g(1), g(2), g(3), g(1, 2, 3)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [f(x), g(x), exp(x), sin(x), cos(x), factorial(x)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [Tuple(x, y), Tuple(x, z), Tuple(x, y, z)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [[3], [1, 2]]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [[1, 2], [2, 3]]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [[1, 2], [1, 2, 3]]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [{x: -y}, {x: y}]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [{1}, {1, 2}]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    a, b = exprs = [Dummy('x'), Dummy('x')]
+    assert sorted([b, a], key=default_sort_key) == exprs
+
+
+def test_as_ordered_factors():
+
+    assert x.as_ordered_factors() == [x]
+    assert (2*x*x**n*sin(x)*cos(x)).as_ordered_factors() \
+        == [Integer(2), x, x**n, sin(x), cos(x)]
+
+    args = [f(1), f(2), f(3), f(1, 2, 3), g(1), g(2), g(3), g(1, 2, 3)]
+    expr = Mul(*args)
+
+    assert expr.as_ordered_factors() == args
+
+    A, B = symbols('A,B', commutative=False)
+
+    assert (A*B).as_ordered_factors() == [A, B]
+    assert (B*A).as_ordered_factors() == [B, A]
+
+
+def test_as_ordered_terms():
+
+    assert x.as_ordered_terms() == [x]
+    assert (sin(x)**2*cos(x) + sin(x)*cos(x)**2 + 1).as_ordered_terms() \
+        == [sin(x)**2*cos(x), sin(x)*cos(x)**2, 1]
+
+    args = [f(1), f(2), f(3), f(1, 2, 3), g(1), g(2), g(3), g(1, 2, 3)]
+    expr = Add(*args)
+
+    assert expr.as_ordered_terms() == args
+
+    assert (1 + 4*sqrt(3)*pi*x).as_ordered_terms() == [4*pi*x*sqrt(3), 1]
+
+    assert ( 2 + 3*I).as_ordered_terms() == [2, 3*I]
+    assert (-2 + 3*I).as_ordered_terms() == [-2, 3*I]
+    assert ( 2 - 3*I).as_ordered_terms() == [2, -3*I]
+    assert (-2 - 3*I).as_ordered_terms() == [-2, -3*I]
+
+    assert ( 4 + 3*I).as_ordered_terms() == [4, 3*I]
+    assert (-4 + 3*I).as_ordered_terms() == [-4, 3*I]
+    assert ( 4 - 3*I).as_ordered_terms() == [4, -3*I]
+    assert (-4 - 3*I).as_ordered_terms() == [-4, -3*I]
+
+    e = x**2*y**2 + x*y**4 + y + 2
+
+    assert e.as_ordered_terms(order="lex") == [x**2*y**2, x*y**4, y, 2]
+    assert e.as_ordered_terms(order="grlex") == [x*y**4, x**2*y**2, y, 2]
+    assert e.as_ordered_terms(order="rev-lex") == [2, y, x*y**4, x**2*y**2]
+    assert e.as_ordered_terms(order="rev-grlex") == [2, y, x**2*y**2, x*y**4]
+
+    k = symbols('k')
+    assert k.as_ordered_terms(data=True) == ([(k, ((1.0, 0.0), (1,), ()))], [k])
+
+
+def test_sort_key_atomic_expr():
+    from sympy.physics.units import m, s
+    assert sorted([-m, s], key=lambda arg: arg.sort_key()) == [-m, s]
+
+
+def test_eval_interval():
+    assert exp(x)._eval_interval(*Tuple(x, 0, 1)) == exp(1) - exp(0)
+
+    # issue 4199
+    a = x/y
+    raises(NotImplementedError, lambda: a._eval_interval(x, S.Zero, oo)._eval_interval(y, oo, S.Zero))
+    raises(NotImplementedError, lambda: a._eval_interval(x, S.Zero, oo)._eval_interval(y, S.Zero, oo))
+    a = x - y
+    raises(NotImplementedError, lambda: a._eval_interval(x, S.One, oo)._eval_interval(y, oo, S.One))
+    raises(ValueError, lambda: x._eval_interval(x, None, None))
+    a = -y*Heaviside(x - y)
+    assert a._eval_interval(x, -oo, oo) == -y
+    assert a._eval_interval(x, oo, -oo) == y
+
+
+def test_eval_interval_zoo():
+    # Test that limit is used when zoo is returned
+    assert Si(1/x)._eval_interval(x, S.Zero, S.One) == -pi/2 + Si(1)
+
+
+def test_primitive():
+    assert (3*(x + 1)**2).primitive() == (3, (x + 1)**2)
+    assert (6*x + 2).primitive() == (2, 3*x + 1)
+    assert (x/2 + 3).primitive() == (S.Half, x + 6)
+    eq = (6*x + 2)*(x/2 + 3)
+    assert eq.primitive()[0] == 1
+    eq = (2 + 2*x)**2
+    assert eq.primitive()[0] == 1
+    assert (4.0*x).primitive() == (1, 4.0*x)
+    assert (4.0*x + y/2).primitive() == (S.Half, 8.0*x + y)
+    assert (-2*x).primitive() == (2, -x)
+    assert Add(5*z/7, 0.5*x, 3*y/2, evaluate=False).primitive() == \
+        (S.One/14, 7.0*x + 21*y + 10*z)
+    for i in [S.Infinity, S.NegativeInfinity, S.ComplexInfinity]:
+        assert (i + x/3).primitive() == \
+            (S.One/3, i + x)
+    assert (S.Infinity + 2*x/3 + 4*y/7).primitive() == \
+        (S.One/21, 14*x + 12*y + oo)
+    assert S.Zero.primitive() == (S.One, S.Zero)
+
+
+def test_issue_5843():
+    a = 1 + x
+    assert (2*a).extract_multiplicatively(a) == 2
+    assert (4*a).extract_multiplicatively(2*a) == 2
+    assert ((3*a)*(2*a)).extract_multiplicatively(a) == 6*a
+
+
+def test_is_constant():
+    from sympy.solvers.solvers import checksol
+    assert Sum(x, (x, 1, 10)).is_constant() is True
+    assert Sum(x, (x, 1, n)).is_constant() is False
+    assert Sum(x, (x, 1, n)).is_constant(y) is True
+    assert Sum(x, (x, 1, n)).is_constant(n) is False
+    assert Sum(x, (x, 1, n)).is_constant(x) is True
+    eq = a*cos(x)**2 + a*sin(x)**2 - a
+    assert eq.is_constant() is True
+    assert eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
+    assert x.is_constant() is False
+    assert x.is_constant(y) is True
+    assert log(x/y).is_constant() is False
+
+    assert checksol(x, x, Sum(x, (x, 1, n))) is False
+    assert checksol(x, x, Sum(x, (x, 1, n))) is False
+    assert f(1).is_constant
+    assert checksol(x, x, f(x)) is False
+
+    assert Pow(x, S.Zero, evaluate=False).is_constant() is True  # == 1
+    assert Pow(S.Zero, x, evaluate=False).is_constant() is False  # == 0 or 1
+    assert (2**x).is_constant() is False
+    assert Pow(S(2), S(3), evaluate=False).is_constant() is True
+
+    z1, z2 = symbols('z1 z2', zero=True)
+    assert (z1 + 2*z2).is_constant() is True
+
+    assert meter.is_constant() is True
+    assert (3*meter).is_constant() is True
+    assert (x*meter).is_constant() is False
+
+
+def test_equals():
+    assert (-3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2).equals(0)
+    assert (x**2 - 1).equals((x + 1)*(x - 1))
+    assert (cos(x)**2 + sin(x)**2).equals(1)
+    assert (a*cos(x)**2 + a*sin(x)**2).equals(a)
+    r = sqrt(2)
+    assert (-1/(r + r*x) + 1/r/(1 + x)).equals(0)
+    assert factorial(x + 1).equals((x + 1)*factorial(x))
+    assert sqrt(3).equals(2*sqrt(3)) is False
+    assert (sqrt(5)*sqrt(3)).equals(sqrt(3)) is False
+    assert (sqrt(5) + sqrt(3)).equals(0) is False
+    assert (sqrt(5) + pi).equals(0) is False
+    assert meter.equals(0) is False
+    assert (3*meter**2).equals(0) is False
+    eq = -(-1)**(S(3)/4)*6**(S.One/4) + (-6)**(S.One/4)*I
+    if eq != 0:  # if canonicalization makes this zero, skip the test
+        assert eq.equals(0)
+    assert sqrt(x).equals(0) is False
+
+    # from integrate(x*sqrt(1 + 2*x), x);
+    # diff is zero only when assumptions allow
+    i = 2*sqrt(2)*x**(S(5)/2)*(1 + 1/(2*x))**(S(5)/2)/5 + \
+        2*sqrt(2)*x**(S(3)/2)*(1 + 1/(2*x))**(S(5)/2)/(-6 - 3/x)
+    ans = sqrt(2*x + 1)*(6*x**2 + x - 1)/15
+    diff = i - ans
+    assert diff.equals(0) is None  # should be False, but previously this was False due to wrong intermediate result
+    assert diff.subs(x, Rational(-1, 2)/2) == 7*sqrt(2)/120
+    # there are regions for x for which the expression is True, for
+    # example, when x < -1/2 or x > 0 the expression is zero
+    p = Symbol('p', positive=True)
+    assert diff.subs(x, p).equals(0) is True
+    assert diff.subs(x, -1).equals(0) is True
+
+    # prove via minimal_polynomial or self-consistency
+    eq = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert eq.equals(0)
+    q = 3**Rational(1, 3) + 3
+    p = expand(q**3)**Rational(1, 3)
+    assert (p - q).equals(0)
+
+    # issue 6829
+    # eq = q*x + q/4 + x**4 + x**3 + 2*x**2 - S.One/3
+    # z = eq.subs(x, solve(eq, x)[0])
+    q = symbols('q')
+    z = (q*(-sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12)/2 - sqrt((2*q - S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/6)/2 - S.One/4) + q/4 + (-sqrt(-2*(-(q
+    - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) - S(13)/12)/2 - sqrt((2*q
+    - S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/6)/2 - S.One/4)**4 + (-sqrt(-2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/12)/2 - sqrt((2*q -
+    S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/6)/2 - S.One/4)**3 + 2*(-sqrt(-2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/12)/2 - sqrt((2*q -
+    S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/6)/2 - S.One/4)**2 - Rational(1, 3))
+    assert z.equals(0)
+
+
+def test_random():
+    from sympy.functions.combinatorial.numbers import lucas
+    from sympy.simplify.simplify import posify
+    assert posify(x)[0]._random() is not None
+    assert lucas(n)._random(2, -2, 0, -1, 1) is None
+
+    # issue 8662
+    assert Piecewise((Max(x, y), z))._random() is None
+
+
+def test_round():
+    assert str(Float('0.1249999').round(2)) == '0.12'
+    d20 = 12345678901234567890
+    ans = S(d20).round(2)
+    assert ans.is_Integer and ans == d20
+    ans = S(d20).round(-2)
+    assert ans.is_Integer and ans == 12345678901234567900
+    assert str(S('1/7').round(4)) == '0.1429'
+    assert str(S('.[12345]').round(4)) == '0.1235'
+    assert str(S('.1349').round(2)) == '0.13'
+    n = S(12345)
+    ans = n.round()
+    assert ans.is_Integer
+    assert ans == n
+    ans = n.round(1)
+    assert ans.is_Integer
+    assert ans == n
+    ans = n.round(4)
+    assert ans.is_Integer
+    assert ans == n
+    assert n.round(-1) == 12340
+
+    r = Float(str(n)).round(-4)
+    assert r == 10000.0
+
+    assert n.round(-5) == 0
+
+    assert str((pi + sqrt(2)).round(2)) == '4.56'
+    assert (10*(pi + sqrt(2))).round(-1) == 50.0
+    raises(TypeError, lambda: round(x + 2, 2))
+    assert str(S(2.3).round(1)) == '2.3'
+    # rounding in SymPy (as in Decimal) should be
+    # exact for the given precision; we check here
+    # that when a 5 follows the last digit that
+    # the rounded digit will be even.
+    for i in range(-99, 100):
+        # construct a decimal that ends in 5, e.g. 123 -> 0.1235
+        s = str(abs(i))
+        p = len(s)  # we are going to round to the last digit of i
+        n = '0.%s5' % s  # put a 5 after i's digits
+        j = p + 2  # 2 for '0.'
+        if i < 0:  # 1 for '-'
+            j += 1
+            n = '-' + n
+        v = str(Float(n).round(p))[:j]  # pertinent digits
+        if v.endswith('.'):
+          continue  # it ends with 0 which is even
+        L = int(v[-1])  # last digit
+        assert L % 2 == 0, (n, '->', v)
+
+    assert (Float(.3, 3) + 2*pi).round() == 7
+    assert (Float(.3, 3) + 2*pi*100).round() == 629
+    assert (pi + 2*E*I).round() == 3 + 5*I
+    # don't let request for extra precision give more than
+    # what is known (in this case, only 3 digits)
+    assert str((Float(.03, 3) + 2*pi/100).round(5)) == '0.0928'
+    assert str((Float(.03, 3) + 2*pi/100).round(4)) == '0.0928'
+
+    assert S.Zero.round() == 0
+
+    a = (Add(1, Float('1.' + '9'*27, ''), evaluate=0))
+    assert a.round(10) == Float('3.000000000000000000000000000', '')
+    assert a.round(25) == Float('3.000000000000000000000000000', '')
+    assert a.round(26) == Float('3.000000000000000000000000000', '')
+    assert a.round(27) == Float('2.999999999999999999999999999', '')
+    assert a.round(30) == Float('2.999999999999999999999999999', '')
+
+    # XXX: Should round set the precision of the result?
+    #      The previous version of the tests above is this but they only pass
+    #      because Floats with unequal precision compare equal:
+    #
+    # assert a.round(10) == Float('3.0000000000', '')
+    # assert a.round(25) == Float('3.0000000000000000000000000', '')
+    # assert a.round(26) == Float('3.00000000000000000000000000', '')
+    # assert a.round(27) == Float('2.999999999999999999999999999', '')
+    # assert a.round(30) == Float('2.999999999999999999999999999', '')
+
+    raises(TypeError, lambda: x.round())
+    raises(TypeError, lambda: f(1).round())
+
+    # exact magnitude of 10
+    assert str(S.One.round()) == '1'
+    assert str(S(100).round()) == '100'
+
+    # applied to real and imaginary portions
+    assert (2*pi + E*I).round() == 6 + 3*I
+    assert (2*pi + I/10).round() == 6
+    assert (pi/10 + 2*I).round() == 2*I
+    # the lhs re and im parts are Float with dps of 2
+    # and those on the right have dps of 15 so they won't compare
+    # equal unless we use string or compare components (which will
+    # then coerce the floats to the same precision) or re-create
+    # the floats
+    assert str((pi/10 + E*I).round(2)) == '0.31 + 2.72*I'
+    assert str((pi/10 + E*I).round(2).as_real_imag()) == '(0.31, 2.72)'
+    assert str((pi/10 + E*I).round(2)) == '0.31 + 2.72*I'
+
+    # issue 6914
+    assert (I**(I + 3)).round(3) == Float('-0.208', '')*I
+
+    # issue 8720
+    assert S(-123.6).round() == -124
+    assert S(-1.5).round() == -2
+    assert S(-100.5).round() == -100
+    assert S(-1.5 - 10.5*I).round() == -2 - 10*I
+
+    # issue 7961
+    assert str(S(0.006).round(2)) == '0.01'
+    assert str(S(0.00106).round(4)) == '0.0011'
+
+    # issue 8147
+    assert S.NaN.round() is S.NaN
+    assert S.Infinity.round() is S.Infinity
+    assert S.NegativeInfinity.round() is S.NegativeInfinity
+    assert S.ComplexInfinity.round() is S.ComplexInfinity
+
+    # check that types match
+    for i in range(2):
+        fi = float(i)
+        # 2 args
+        assert all(type(round(i, p)) is int for p in (-1, 0, 1))
+        assert all(S(i).round(p).is_Integer for p in (-1, 0, 1))
+        assert all(type(round(fi, p)) is float for p in (-1, 0, 1))
+        assert all(S(fi).round(p).is_Float for p in (-1, 0, 1))
+        # 1 arg (p is None)
+        assert type(round(i)) is int
+        assert S(i).round().is_Integer
+        assert type(round(fi)) is int
+        assert S(fi).round().is_Integer
+
+
+def test_held_expression_UnevaluatedExpr():
+    x = symbols("x")
+    he = UnevaluatedExpr(1/x)
+    e1 = x*he
+
+    assert isinstance(e1, Mul)
+    assert e1.args == (x, he)
+    assert e1.doit() == 1
+    assert UnevaluatedExpr(Derivative(x, x)).doit(deep=False
+        ) == Derivative(x, x)
+    assert UnevaluatedExpr(Derivative(x, x)).doit() == 1
+
+    xx = Mul(x, x, evaluate=False)
+    assert xx != x**2
+
+    ue2 = UnevaluatedExpr(xx)
+    assert isinstance(ue2, UnevaluatedExpr)
+    assert ue2.args == (xx,)
+    assert ue2.doit() == x**2
+    assert ue2.doit(deep=False) == xx
+
+    x2 = UnevaluatedExpr(2)*2
+    assert type(x2) is Mul
+    assert x2.args == (2, UnevaluatedExpr(2))
+
+def test_round_exception_nostr():
+    # Don't use the string form of the expression in the round exception, as
+    # it's too slow
+    s = Symbol('bad')
+    try:
+        s.round()
+    except TypeError as e:
+        assert 'bad' not in str(e)
+    else:
+        # Did not raise
+        raise AssertionError("Did not raise")
+
+
+def test_extract_branch_factor():
+    assert exp_polar(2.0*I*pi).extract_branch_factor() == (1, 1)
+
+
+def test_identity_removal():
+    assert Add.make_args(x + 0) == (x,)
+    assert Mul.make_args(x*1) == (x,)
+
+
+def test_float_0():
+    assert Float(0.0) + 1 == Float(1.0)
+
+
+@XFAIL
+def test_float_0_fail():
+    assert Float(0.0)*x == Float(0.0)
+    assert (x + Float(0.0)).is_Add
+
+
+def test_issue_6325():
+    ans = (b**2 + z**2 - (b*(a + b*t) + z*(c + t*z))**2/(
+        (a + b*t)**2 + (c + t*z)**2))/sqrt((a + b*t)**2 + (c + t*z)**2)
+    e = sqrt((a + b*t)**2 + (c + z*t)**2)
+    assert diff(e, t, 2) == ans
+    assert e.diff(t, 2) == ans
+    assert diff(e, t, 2, simplify=False) != ans
+
+
+def test_issue_7426():
+    f1 = a % c
+    f2 = x % z
+    assert f1.equals(f2) is None
+
+
+def test_issue_11122():
+    x = Symbol('x', extended_positive=False)
+    assert unchanged(Gt, x, 0)  # (x > 0)
+    # (x > 0) should remain unevaluated after PR #16956
+
+    x = Symbol('x', positive=False, real=True)
+    assert (x > 0) is S.false
+
+
+def test_issue_10651():
+    x = Symbol('x', real=True)
+    e1 = (-1 + x)/(1 - x)
+    e3 = (4*x**2 - 4)/((1 - x)*(1 + x))
+    e4 = 1/(cos(x)**2) - (tan(x))**2
+    x = Symbol('x', positive=True)
+    e5 = (1 + x)/x
+    assert e1.is_constant() is None
+    assert e3.is_constant() is None
+    assert e4.is_constant() is None
+    assert e5.is_constant() is False
+
+
+def test_issue_10161():
+    x = symbols('x', real=True)
+    assert x*abs(x)*abs(x) == x**3
+
+
+def test_issue_10755():
+    x = symbols('x')
+    raises(TypeError, lambda: int(log(x)))
+    raises(TypeError, lambda: log(x).round(2))
+
+
+def test_issue_11877():
+    x = symbols('x')
+    assert integrate(log(S.Half - x), (x, 0, S.Half)) == Rational(-1, 2) -log(2)/2
+
+
+def test_normal():
+    x = symbols('x')
+    e = Mul(S.Half, 1 + x, evaluate=False)
+    assert e.normal() == e
+
+
+def test_expr():
+    x = symbols('x')
+    raises(TypeError, lambda: tan(x).series(x, 2, oo, "+"))
+
+
+def test_ExprBuilder():
+    eb = ExprBuilder(Mul)
+    eb.args.extend([x, x])
+    assert eb.build() == x**2
+
+
+def test_issue_22020():
+    from sympy.parsing.sympy_parser import parse_expr
+    x = parse_expr("log((2*V/3-V)/C)/-(R+r)*C")
+    y = parse_expr("log((2*V/3-V)/C)/-(R+r)*2")
+    assert x.equals(y) is False
+
+
+def test_non_string_equality():
+    # Expressions should not compare equal to strings
+    x = symbols('x')
+    one = sympify(1)
+    assert (x == 'x') is False
+    assert (x != 'x') is True
+    assert (one == '1') is False
+    assert (one != '1') is True
+    assert (x + 1 == 'x + 1') is False
+    assert (x + 1 != 'x + 1') is True
+
+    # Make sure == doesn't try to convert the resulting expression to a string
+    # (e.g., by calling sympify() instead of _sympify())
+
+    class BadRepr:
+        def __repr__(self):
+            raise RuntimeError
+
+    assert (x == BadRepr()) is False
+    assert (x != BadRepr()) is True
+
+
+def test_21494():
+    from sympy.testing.pytest import warns_deprecated_sympy
+
+    with warns_deprecated_sympy():
+        assert x.expr_free_symbols == {x}
+
+    with warns_deprecated_sympy():
+        assert Basic().expr_free_symbols == set()
+
+    with warns_deprecated_sympy():
+        assert S(2).expr_free_symbols == {S(2)}
+
+    with warns_deprecated_sympy():
+        assert Indexed("A", x).expr_free_symbols == {Indexed("A", x)}
+
+    with warns_deprecated_sympy():
+        assert Subs(x, x, 0).expr_free_symbols == set()
+
+
+def test_Expr__eq__iterable_handling():
+    assert x != range(3)
+
+
+def test_format():
+    assert '{:1.2f}'.format(S.Zero) == '0.00'
+    assert '{:+3.0f}'.format(S(3)) == ' +3'
+    assert '{:23.20f}'.format(pi) == ' 3.14159265358979323846'
+    assert '{:50.48f}'.format(exp(sin(1))) == '2.319776824715853173956590377503266813254904772376'

llmeval-env/lib/python3.10/site-packages/sympy/core/tests/test_exprtools.py

@@ -0,0 +1,493 @@
+"""Tests for tools for manipulating of large commutative expressions. """
+
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O
+from sympy.sets.sets import Interval
+from sympy.simplify.radsimp import collect
+from sympy.simplify.simplify import simplify
+from sympy.core.exprtools import (decompose_power, Factors, Term, _gcd_terms,
+                                  gcd_terms, factor_terms, factor_nc, _mask_nc,
+                                  _monotonic_sign)
+from sympy.core.mul import _keep_coeff as _keep_coeff
+from sympy.simplify.cse_opts import sub_pre
+from sympy.testing.pytest import raises
+
+from sympy.abc import a, b, t, x, y, z
+
+
+def test_decompose_power():
+    assert decompose_power(x) == (x, 1)
+    assert decompose_power(x**2) == (x, 2)
+    assert decompose_power(x**(2*y)) == (x**y, 2)
+    assert decompose_power(x**(2*y/3)) == (x**(y/3), 2)
+    assert decompose_power(x**(y*Rational(2, 3))) == (x**(y/3), 2)
+
+
+def test_Factors():
+    assert Factors() == Factors({}) == Factors(S.One)
+    assert Factors().as_expr() is S.One
+    assert Factors({x: 2, y: 3, sin(x): 4}).as_expr() == x**2*y**3*sin(x)**4
+    assert Factors(S.Infinity) == Factors({oo: 1})
+    assert Factors(S.NegativeInfinity) == Factors({oo: 1, -1: 1})
+    # issue #18059:
+    assert Factors((x**2)**S.Half).as_expr() == (x**2)**S.Half
+
+    a = Factors({x: 5, y: 3, z: 7})
+    b = Factors({      y: 4, z: 3, t: 10})
+
+    assert a.mul(b) == a*b == Factors({x: 5, y: 7, z: 10, t: 10})
+
+    assert a.div(b) == divmod(a, b) == \
+        (Factors({x: 5, z: 4}), Factors({y: 1, t: 10}))
+    assert a.quo(b) == a/b == Factors({x: 5, z: 4})
+    assert a.rem(b) == a % b == Factors({y: 1, t: 10})
+
+    assert a.pow(3) == a**3 == Factors({x: 15, y: 9, z: 21})
+    assert b.pow(3) == b**3 == Factors({y: 12, z: 9, t: 30})
+
+    assert a.gcd(b) == Factors({y: 3, z: 3})
+    assert a.lcm(b) == Factors({x: 5, y: 4, z: 7, t: 10})
+
+    a = Factors({x: 4, y: 7, t: 7})
+    b = Factors({z: 1, t: 3})
+
+    assert a.normal(b) == (Factors({x: 4, y: 7, t: 4}), Factors({z: 1}))
+
+    assert Factors(sqrt(2)*x).as_expr() == sqrt(2)*x
+
+    assert Factors(-I)*I == Factors()
+    assert Factors({S.NegativeOne: S(3)})*Factors({S.NegativeOne: S.One, I: S(5)}) == \
+        Factors(I)
+    assert Factors(sqrt(I)*I) == Factors(I**(S(3)/2)) == Factors({I: S(3)/2})
+    assert Factors({I: S(3)/2}).as_expr() == I**(S(3)/2)
+
+    assert Factors(S(2)**x).div(S(3)**x) == \
+        (Factors({S(2): x}), Factors({S(3): x}))
+    assert Factors(2**(2*x + 2)).div(S(8)) == \
+        (Factors({S(2): 2*x + 2}), Factors({S(8): S.One}))
+
+    # coverage
+    # /!\ things break if this is not True
+    assert Factors({S.NegativeOne: Rational(3, 2)}) == Factors({I: S.One, S.NegativeOne: S.One})
+    assert Factors({I: S.One, S.NegativeOne: Rational(1, 3)}).as_expr() == I*(-1)**Rational(1, 3)
+
+    assert Factors(-1.) == Factors({S.NegativeOne: S.One, S(1.): 1})
+    assert Factors(-2.) == Factors({S.NegativeOne: S.One, S(2.): 1})
+    assert Factors((-2.)**x) == Factors({S(-2.): x})
+    assert Factors(S(-2)) == Factors({S.NegativeOne: S.One, S(2): 1})
+    assert Factors(S.Half) == Factors({S(2): -S.One})
+    assert Factors(Rational(3, 2)) == Factors({S(3): S.One, S(2): S.NegativeOne})
+    assert Factors({I: S.One}) == Factors(I)
+    assert Factors({-1.0: 2, I: 1}) == Factors({S(1.0): 1, I: 1})
+    assert Factors({S.NegativeOne: Rational(-3, 2)}).as_expr() == I
+    A = symbols('A', commutative=False)
+    assert Factors(2*A**2) == Factors({S(2): 1, A**2: 1})
+    assert Factors(I) == Factors({I: S.One})
+    assert Factors(x).normal(S(2)) == (Factors(x), Factors(S(2)))
+    assert Factors(x).normal(S.Zero) == (Factors(), Factors(S.Zero))
+    raises(ZeroDivisionError, lambda: Factors(x).div(S.Zero))
+    assert Factors(x).mul(S(2)) == Factors(2*x)
+    assert Factors(x).mul(S.Zero).is_zero
+    assert Factors(x).mul(1/x).is_one
+    assert Factors(x**sqrt(2)**3).as_expr() == x**(2*sqrt(2))
+    assert Factors(x)**Factors(S(2)) == Factors(x**2)
+    assert Factors(x).gcd(S.Zero) == Factors(x)
+    assert Factors(x).lcm(S.Zero).is_zero
+    assert Factors(S.Zero).div(x) == (Factors(S.Zero), Factors())
+    assert Factors(x).div(x) == (Factors(), Factors())
+    assert Factors({x: .2})/Factors({x: .2}) == Factors()
+    assert Factors(x) != Factors()
+    assert Factors(S.Zero).normal(x) == (Factors(S.Zero), Factors())
+    n, d = x**(2 + y), x**2
+    f = Factors(n)
+    assert f.div(d) == f.normal(d) == (Factors(x**y), Factors())
+    assert f.gcd(d) == Factors()
+    d = x**y
+    assert f.div(d) == f.normal(d) == (Factors(x**2), Factors())
+    assert f.gcd(d) == Factors(d)
+    n = d = 2**x
+    f = Factors(n)
+    assert f.div(d) == f.normal(d) == (Factors(), Factors())
+    assert f.gcd(d) == Factors(d)
+    n, d = 2**x, 2**y
+    f = Factors(n)
+    assert f.div(d) == f.normal(d) == (Factors({S(2): x}), Factors({S(2): y}))
+    assert f.gcd(d) == Factors()
+
+    # extraction of constant only
+    n = x**(x + 3)
+    assert Factors(n).normal(x**-3) == (Factors({x: x + 6}), Factors({}))
+    assert Factors(n).normal(x**3) == (Factors({x: x}), Factors({}))
+    assert Factors(n).normal(x**4) == (Factors({x: x}), Factors({x: 1}))
+    assert Factors(n).normal(x**(y - 3)) == \
+        (Factors({x: x + 6}), Factors({x: y}))
+    assert Factors(n).normal(x**(y + 3)) == (Factors({x: x}), Factors({x: y}))
+    assert Factors(n).normal(x**(y + 4)) == \
+        (Factors({x: x}), Factors({x: y + 1}))
+
+    assert Factors(n).div(x**-3) == (Factors({x: x + 6}), Factors({}))
+    assert Factors(n).div(x**3) == (Factors({x: x}), Factors({}))
+    assert Factors(n).div(x**4) == (Factors({x: x}), Factors({x: 1}))
+    assert Factors(n).div(x**(y - 3)) == \
+        (Factors({x: x + 6}), Factors({x: y}))
+    assert Factors(n).div(x**(y + 3)) == (Factors({x: x}), Factors({x: y}))
+    assert Factors(n).div(x**(y + 4)) == \
+        (Factors({x: x}), Factors({x: y + 1}))
+
+    assert Factors(3 * x / 2) == Factors({3: 1, 2: -1, x: 1})
+    assert Factors(x * x / y) == Factors({x: 2, y: -1})
+    assert Factors(27 * x / y**9) == Factors({27: 1, x: 1, y: -9})
+
+
+def test_Term():
+    a = Term(4*x*y**2/z/t**3)
+    b = Term(2*x**3*y**5/t**3)
+
+    assert a == Term(4, Factors({x: 1, y: 2}), Factors({z: 1, t: 3}))
+    assert b == Term(2, Factors({x: 3, y: 5}), Factors({t: 3}))
+
+    assert a.as_expr() == 4*x*y**2/z/t**3
+    assert b.as_expr() == 2*x**3*y**5/t**3
+
+    assert a.inv() == \
+        Term(S.One/4, Factors({z: 1, t: 3}), Factors({x: 1, y: 2}))
+    assert b.inv() == Term(S.Half, Factors({t: 3}), Factors({x: 3, y: 5}))
+
+    assert a.mul(b) == a*b == \
+        Term(8, Factors({x: 4, y: 7}), Factors({z: 1, t: 6}))
+    assert a.quo(b) == a/b == Term(2, Factors({}), Factors({x: 2, y: 3, z: 1}))
+
+    assert a.pow(3) == a**3 == \
+        Term(64, Factors({x: 3, y: 6}), Factors({z: 3, t: 9}))
+    assert b.pow(3) == b**3 == Term(8, Factors({x: 9, y: 15}), Factors({t: 9}))
+
+    assert a.pow(-3) == a**(-3) == \
+        Term(S.One/64, Factors({z: 3, t: 9}), Factors({x: 3, y: 6}))
+    assert b.pow(-3) == b**(-3) == \
+        Term(S.One/8, Factors({t: 9}), Factors({x: 9, y: 15}))
+
+    assert a.gcd(b) == Term(2, Factors({x: 1, y: 2}), Factors({t: 3}))
+    assert a.lcm(b) == Term(4, Factors({x: 3, y: 5}), Factors({z: 1, t: 3}))
+
+    a = Term(4*x*y**2/z/t**3)
+    b = Term(2*x**3*y**5*t**7)
+
+    assert a.mul(b) == Term(8, Factors({x: 4, y: 7, t: 4}), Factors({z: 1}))
+
+    assert Term((2*x + 2)**3) == Term(8, Factors({x + 1: 3}), Factors({}))
+    assert Term((2*x + 2)*(3*x + 6)**2) == \
+        Term(18, Factors({x + 1: 1, x + 2: 2}), Factors({}))
+
+
+def test_gcd_terms():
+    f = 2*(x + 1)*(x + 4)/(5*x**2 + 5) + (2*x + 2)*(x + 5)/(x**2 + 1)/5 + \
+        (2*x + 2)*(x + 6)/(5*x**2 + 5)
+
+    assert _gcd_terms(f) == ((Rational(6, 5))*((1 + x)/(1 + x**2)), 5 + x, 1)
+    assert _gcd_terms(Add.make_args(f)) == \
+        ((Rational(6, 5))*((1 + x)/(1 + x**2)), 5 + x, 1)
+
+    newf = (Rational(6, 5))*((1 + x)*(5 + x)/(1 + x**2))
+    assert gcd_terms(f) == newf
+    args = Add.make_args(f)
+    # non-Basic sequences of terms treated as terms of Add
+    assert gcd_terms(list(args)) == newf
+    assert gcd_terms(tuple(args)) == newf
+    assert gcd_terms(set(args)) == newf
+    # but a Basic sequence is treated as a container
+    assert gcd_terms(Tuple(*args)) != newf
+    assert gcd_terms(Basic(Tuple(S(1), 3*y + 3*x*y), Tuple(S(1), S(3)))) == \
+        Basic(Tuple(S(1), 3*y*(x + 1)), Tuple(S(1), S(3)))
+    # but we shouldn't change keys of a dictionary or some may be lost
+    assert gcd_terms(Dict((x*(1 + y), S(2)), (x + x*y, y + x*y))) == \
+        Dict({x*(y + 1): S(2), x + x*y: y*(1 + x)})
+
+    assert gcd_terms((2*x + 2)**3 + (2*x + 2)**2) == 4*(x + 1)**2*(2*x + 3)
+
+    assert gcd_terms(0) == 0
+    assert gcd_terms(1) == 1
+    assert gcd_terms(x) == x
+    assert gcd_terms(2 + 2*x) == Mul(2, 1 + x, evaluate=False)
+    arg = x*(2*x + 4*y)
+    garg = 2*x*(x + 2*y)
+    assert gcd_terms(arg) == garg
+    assert gcd_terms(sin(arg)) == sin(garg)
+
+    # issue 6139-like
+    alpha, alpha1, alpha2, alpha3 = symbols('alpha:4')
+    a = alpha**2 - alpha*x**2 + alpha + x**3 - x*(alpha + 1)
+    rep = (alpha, (1 + sqrt(5))/2 + alpha1*x + alpha2*x**2 + alpha3*x**3)
+    s = (a/(x - alpha)).subs(*rep).series(x, 0, 1)
+    assert simplify(collect(s, x)) == -sqrt(5)/2 - Rational(3, 2) + O(x)
+
+    # issue 5917
+    assert _gcd_terms([S.Zero, S.Zero]) == (0, 0, 1)
+    assert _gcd_terms([2*x + 4]) == (2, x + 2, 1)
+
+    eq = x/(x + 1/x)
+    assert gcd_terms(eq, fraction=False) == eq
+    eq = x/2/y + 1/x/y
+    assert gcd_terms(eq, fraction=True, clear=True) == \
+        (x**2 + 2)/(2*x*y)
+    assert gcd_terms(eq, fraction=True, clear=False) == \
+        (x**2/2 + 1)/(x*y)
+    assert gcd_terms(eq, fraction=False, clear=True) == \
+        (x + 2/x)/(2*y)
+    assert gcd_terms(eq, fraction=False, clear=False) == \
+        (x/2 + 1/x)/y
+
+
+def test_factor_terms():
+    A = Symbol('A', commutative=False)
+    assert factor_terms(9*(x + x*y + 1) + (3*x + 3)**(2 + 2*x)) == \
+        9*x*y + 9*x + _keep_coeff(S(3), x + 1)**_keep_coeff(S(2), x + 1) + 9
+    assert factor_terms(9*(x + x*y + 1) + (3)**(2 + 2*x)) == \
+        _keep_coeff(S(9), 3**(2*x) + x*y + x + 1)
+    assert factor_terms(3**(2 + 2*x) + a*3**(2 + 2*x)) == \
+        9*3**(2*x)*(a + 1)
+    assert factor_terms(x + x*A) == \
+        x*(1 + A)
+    assert factor_terms(sin(x + x*A)) == \
+        sin(x*(1 + A))
+    assert factor_terms((3*x + 3)**((2 + 2*x)/3)) == \
+        _keep_coeff(S(3), x + 1)**_keep_coeff(Rational(2, 3), x + 1)
+    assert factor_terms(x + (x*y + x)**(3*x + 3)) == \
+        x + (x*(y + 1))**_keep_coeff(S(3), x + 1)
+    assert factor_terms(a*(x + x*y) + b*(x*2 + y*x*2)) == \
+        x*(a + 2*b)*(y + 1)
+    i = Integral(x, (x, 0, oo))
+    assert factor_terms(i) == i
+
+    assert factor_terms(x/2 + y) == x/2 + y
+    # fraction doesn't apply to integer denominators
+    assert factor_terms(x/2 + y, fraction=True) == x/2 + y
+    # clear *does* apply to the integer denominators
+    assert factor_terms(x/2 + y, clear=True) == Mul(S.Half, x + 2*y, evaluate=False)
+
+    # check radical extraction
+    eq = sqrt(2) + sqrt(10)
+    assert factor_terms(eq) == eq
+    assert factor_terms(eq, radical=True) == sqrt(2)*(1 + sqrt(5))
+    eq = root(-6, 3) + root(6, 3)
+    assert factor_terms(eq, radical=True) == 6**(S.One/3)*(1 + (-1)**(S.One/3))
+
+    eq = [x + x*y]
+    ans = [x*(y + 1)]
+    for c in [list, tuple, set]:
+        assert factor_terms(c(eq)) == c(ans)
+    assert factor_terms(Tuple(x + x*y)) == Tuple(x*(y + 1))
+    assert factor_terms(Interval(0, 1)) == Interval(0, 1)
+    e = 1/sqrt(a/2 + 1)
+    assert factor_terms(e, clear=False) == 1/sqrt(a/2 + 1)
+    assert factor_terms(e, clear=True) == sqrt(2)/sqrt(a + 2)
+
+    eq = x/(x + 1/x) + 1/(x**2 + 1)
+    assert factor_terms(eq, fraction=False) == eq
+    assert factor_terms(eq, fraction=True) == 1
+
+    assert factor_terms((1/(x**3 + x**2) + 2/x**2)*y) == \
+        y*(2 + 1/(x + 1))/x**2
+
+    # if not True, then processesing for this in factor_terms is not necessary
+    assert gcd_terms(-x - y) == -x - y
+    assert factor_terms(-x - y) == Mul(-1, x + y, evaluate=False)
+
+    # if not True, then "special" processesing in factor_terms is not necessary
+    assert gcd_terms(exp(Mul(-1, x + 1))) == exp(-x - 1)
+    e = exp(-x - 2) + x
+    assert factor_terms(e) == exp(Mul(-1, x + 2, evaluate=False)) + x
+    assert factor_terms(e, sign=False) == e
+    assert factor_terms(exp(-4*x - 2) - x) == -x + exp(Mul(-2, 2*x + 1, evaluate=False))
+
+    # sum/integral tests
+    for F in (Sum, Integral):
+        assert factor_terms(F(x, (y, 1, 10))) == x * F(1, (y, 1, 10))
+        assert factor_terms(F(x, (y, 1, 10)) + x) == x * (1 + F(1, (y, 1, 10)))
+        assert factor_terms(F(x*y + x*y**2, (y, 1, 10))) == x*F(y*(y + 1), (y, 1, 10))
+
+    # expressions involving Pow terms with base 0
+    assert factor_terms(0**(x - 2) - 1) == 0**(x - 2) - 1
+    assert factor_terms(0**(x + 2) - 1) == 0**(x + 2) - 1
+    assert factor_terms((0**(x + 2) - 1).subs(x,-2)) == 0
+
+
+def test_xreplace():
+    e = Mul(2, 1 + x, evaluate=False)
+    assert e.xreplace({}) == e
+    assert e.xreplace({y: x}) == e
+
+
+def test_factor_nc():
+    x, y = symbols('x,y')
+    k = symbols('k', integer=True)
+    n, m, o = symbols('n,m,o', commutative=False)
+
+    # mul and multinomial expansion is needed
+    from sympy.core.function import _mexpand
+    e = x*(1 + y)**2
+    assert _mexpand(e) == x + x*2*y + x*y**2
+
+    def factor_nc_test(e):
+        ex = _mexpand(e)
+        assert ex.is_Add
+        f = factor_nc(ex)
+        assert not f.is_Add and _mexpand(f) == ex
+
+    factor_nc_test(x*(1 + y))
+    factor_nc_test(n*(x + 1))
+    factor_nc_test(n*(x + m))
+    factor_nc_test((x + m)*n)
+    factor_nc_test(n*m*(x*o + n*o*m)*n)
+    s = Sum(x, (x, 1, 2))
+    factor_nc_test(x*(1 + s))
+    factor_nc_test(x*(1 + s)*s)
+    factor_nc_test(x*(1 + sin(s)))
+    factor_nc_test((1 + n)**2)
+
+    factor_nc_test((x + n)*(x + m)*(x + y))
+    factor_nc_test(x*(n*m + 1))
+    factor_nc_test(x*(n*m + x))
+    factor_nc_test(x*(x*n*m + 1))
+    factor_nc_test(n*(m/x + o))
+    factor_nc_test(m*(n + o/2))
+    factor_nc_test(x*n*(x*m + 1))
+    factor_nc_test(x*(m*n + x*n*m))
+    factor_nc_test(n*(1 - m)*n**2)
+
+    factor_nc_test((n + m)**2)
+    factor_nc_test((n - m)*(n + m)**2)
+    factor_nc_test((n + m)**2*(n - m))
+    factor_nc_test((m - n)*(n + m)**2*(n - m))
+
+    assert factor_nc(n*(n + n*m)) == n**2*(1 + m)
+    assert factor_nc(m*(m*n + n*m*n**2)) == m*(m + n*m*n)*n
+    eq = m*sin(n) - sin(n)*m
+    assert factor_nc(eq) == eq
+
+    # for coverage:
+    from sympy.physics.secondquant import Commutator
+    from sympy.polys.polytools import factor
+    eq = 1 + x*Commutator(m, n)
+    assert factor_nc(eq) == eq
+    eq = x*Commutator(m, n) + x*Commutator(m, o)*Commutator(m, n)
+    assert factor(eq) == x*(1 + Commutator(m, o))*Commutator(m, n)
+
+    # issue 6534
+    assert (2*n + 2*m).factor() == 2*(n + m)
+
+    # issue 6701
+    _n = symbols('nz', zero=False, commutative=False)
+    assert factor_nc(_n**k + _n**(k + 1)) == _n**k*(1 + _n)
+    assert factor_nc((m*n)**k + (m*n)**(k + 1)) == (1 + m*n)*(m*n)**k
+
+    # issue 6918
+    assert factor_nc(-n*(2*x**2 + 2*x)) == -2*n*x*(x + 1)
+
+
+def test_issue_6360():
+    a, b = symbols("a b")
+    apb = a + b
+    eq = apb + apb**2*(-2*a - 2*b)
+    assert factor_terms(sub_pre(eq)) == a + b - 2*(a + b)**3
+
+
+def test_issue_7903():
+    a = symbols(r'a', real=True)
+    t = exp(I*cos(a)) + exp(-I*sin(a))
+    assert t.simplify()
+
+def test_issue_8263():
+    F, G = symbols('F, G', commutative=False, cls=Function)
+    x, y = symbols('x, y')
+    expr, dummies, _ = _mask_nc(F(x)*G(y) - G(y)*F(x))
+    for v in dummies.values():
+        assert not v.is_commutative
+    assert not expr.is_zero
+
+def test_monotonic_sign():
+    F = _monotonic_sign
+    x = symbols('x')
+    assert F(x) is None
+    assert F(-x) is None
+    assert F(Dummy(prime=True)) == 2
+    assert F(Dummy(prime=True, odd=True)) == 3
+    assert F(Dummy(composite=True)) == 4
+    assert F(Dummy(composite=True, odd=True)) == 9
+    assert F(Dummy(positive=True, integer=True)) == 1
+    assert F(Dummy(positive=True, even=True)) == 2
+    assert F(Dummy(positive=True, even=True, prime=False)) == 4
+    assert F(Dummy(negative=True, integer=True)) == -1
+    assert F(Dummy(negative=True, even=True)) == -2
+    assert F(Dummy(zero=True)) == 0
+    assert F(Dummy(nonnegative=True)) == 0
+    assert F(Dummy(nonpositive=True)) == 0
+
+    assert F(Dummy(positive=True) + 1).is_positive
+    assert F(Dummy(positive=True, integer=True) - 1).is_nonnegative
+    assert F(Dummy(positive=True) - 1) is None
+    assert F(Dummy(negative=True) + 1) is None
+    assert F(Dummy(negative=True, integer=True) - 1).is_nonpositive
+    assert F(Dummy(negative=True) - 1).is_negative
+    assert F(-Dummy(positive=True) + 1) is None
+    assert F(-Dummy(positive=True, integer=True) - 1).is_negative
+    assert F(-Dummy(positive=True) - 1).is_negative
+    assert F(-Dummy(negative=True) + 1).is_positive
+    assert F(-Dummy(negative=True, integer=True) - 1).is_nonnegative
+    assert F(-Dummy(negative=True) - 1) is None
+    x = Dummy(negative=True)
+    assert F(x**3).is_nonpositive
+    assert F(x**3 + log(2)*x - 1).is_negative
+    x = Dummy(positive=True)
+    assert F(-x**3).is_nonpositive
+
+    p = Dummy(positive=True)
+    assert F(1/p).is_positive
+    assert F(p/(p + 1)).is_positive
+    p = Dummy(nonnegative=True)
+    assert F(p/(p + 1)).is_nonnegative
+    p = Dummy(positive=True)
+    assert F(-1/p).is_negative
+    p = Dummy(nonpositive=True)
+    assert F(p/(-p + 1)).is_nonpositive
+
+    p = Dummy(positive=True, integer=True)
+    q = Dummy(positive=True, integer=True)
+    assert F(-2/p/q).is_negative
+    assert F(-2/(p - 1)/q) is None
+
+    assert F((p - 1)*q + 1).is_positive
+    assert F(-(p - 1)*q - 1).is_negative
+
+def test_issue_17256():
+    from sympy.sets.fancysets import Range
+    x = Symbol('x')
+    s1 = Sum(x + 1, (x, 1, 9))
+    s2 = Sum(x + 1, (x, Range(1, 10)))
+    a = Symbol('a')
+    r1 = s1.xreplace({x:a})
+    r2 = s2.xreplace({x:a})
+
+    assert r1.doit() == r2.doit()
+    s1 = Sum(x + 1, (x, 0, 9))
+    s2 = Sum(x + 1, (x, Range(10)))
+    a = Symbol('a')
+    r1 = s1.xreplace({x:a})
+    r2 = s2.xreplace({x:a})
+    assert r1 == r2
+
+def test_issue_21623():
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    M = MatrixSymbol('X', 2, 2)
+    assert gcd_terms(M[0,0], 1) == M[0,0]