Add files using upload-large-folder tool

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

@@ -0,0 +1,692 @@
+"""
+This module contains the machinery handling assumptions.
+Do also consider the guide :ref:`assumptions-guide`.
+
+All symbolic objects have assumption attributes that can be accessed via
+``.is_<assumption name>`` attribute.
+
+Assumptions determine certain properties of symbolic objects and can
+have 3 possible values: ``True``, ``False``, ``None``.  ``True`` is returned if the
+object has the property and ``False`` is returned if it does not or cannot
+(i.e. does not make sense):
+
+    >>> from sympy import I
+    >>> I.is_algebraic
+    True
+    >>> I.is_real
+    False
+    >>> I.is_prime
+    False
+
+When the property cannot be determined (or when a method is not
+implemented) ``None`` will be returned. For example,  a generic symbol, ``x``,
+may or may not be positive so a value of ``None`` is returned for ``x.is_positive``.
+
+By default, all symbolic values are in the largest set in the given context
+without specifying the property. For example, a symbol that has a property
+being integer, is also real, complex, etc.
+
+Here follows a list of possible assumption names:
+
+.. glossary::
+
+    commutative
+        object commutes with any other object with
+        respect to multiplication operation. See [12]_.
+
+    complex
+        object can have only values from the set
+        of complex numbers. See [13]_.
+
+    imaginary
+        object value is a number that can be written as a real
+        number multiplied by the imaginary unit ``I``.  See
+        [3]_.  Please note that ``0`` is not considered to be an
+        imaginary number, see
+        `issue #7649 <https://github.com/sympy/sympy/issues/7649>`_.
+
+    real
+        object can have only values from the set
+        of real numbers.
+
+    extended_real
+        object can have only values from the set
+        of real numbers, ``oo`` and ``-oo``.
+
+    integer
+        object can have only values from the set
+        of integers.
+
+    odd
+    even
+        object can have only values from the set of
+        odd (even) integers [2]_.
+
+    prime
+        object is a natural number greater than 1 that has
+        no positive divisors other than 1 and itself.  See [6]_.
+
+    composite
+        object is a positive integer that has at least one positive
+        divisor other than 1 or the number itself.  See [4]_.
+
+    zero
+        object has the value of 0.
+
+    nonzero
+        object is a real number that is not zero.
+
+    rational
+        object can have only values from the set
+        of rationals.
+
+    algebraic
+        object can have only values from the set
+        of algebraic numbers [11]_.
+
+    transcendental
+        object can have only values from the set
+        of transcendental numbers [10]_.
+
+    irrational
+        object value cannot be represented exactly by :class:`~.Rational`, see [5]_.
+
+    finite
+    infinite
+        object absolute value is bounded (arbitrarily large).
+        See [7]_, [8]_, [9]_.
+
+    negative
+    nonnegative
+        object can have only negative (nonnegative)
+        values [1]_.
+
+    positive
+    nonpositive
+        object can have only positive (nonpositive) values.
+
+    extended_negative
+    extended_nonnegative
+    extended_positive
+    extended_nonpositive
+    extended_nonzero
+        as without the extended part, but also including infinity with
+        corresponding sign, e.g., extended_positive includes ``oo``
+
+    hermitian
+    antihermitian
+        object belongs to the field of Hermitian
+        (antihermitian) operators.
+
+Examples
+========
+
+    >>> from sympy import Symbol
+    >>> x = Symbol('x', real=True); x
+    x
+    >>> x.is_real
+    True
+    >>> x.is_complex
+    True
+
+See Also
+========
+
+.. seealso::
+
+    :py:class:`sympy.core.numbers.ImaginaryUnit`
+    :py:class:`sympy.core.numbers.Zero`
+    :py:class:`sympy.core.numbers.One`
+    :py:class:`sympy.core.numbers.Infinity`
+    :py:class:`sympy.core.numbers.NegativeInfinity`
+    :py:class:`sympy.core.numbers.ComplexInfinity`
+
+Notes
+=====
+
+The fully-resolved assumptions for any SymPy expression
+can be obtained as follows:
+
+    >>> from sympy.core.assumptions import assumptions
+    >>> x = Symbol('x',positive=True)
+    >>> assumptions(x + I)
+    {'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, 'zero':
+    False}
+
+Developers Notes
+================
+
+The current (and possibly incomplete) values are stored
+in the ``obj._assumptions dictionary``; queries to getter methods
+(with property decorators) or attributes of objects/classes
+will return values and update the dictionary.
+
+    >>> eq = x**2 + I
+    >>> eq._assumptions
+    {}
+    >>> eq.is_finite
+    True
+    >>> eq._assumptions
+    {'finite': True, 'infinite': False}
+
+For a :class:`~.Symbol`, there are two locations for assumptions that may
+be of interest. The ``assumptions0`` attribute gives the full set of
+assumptions derived from a given set of initial assumptions. The
+latter assumptions are stored as ``Symbol._assumptions_orig``
+
+    >>> Symbol('x', prime=True, even=True)._assumptions_orig
+    {'even': True, 'prime': True}
+
+The ``_assumptions_orig`` are not necessarily canonical nor are they filtered
+in any way: they records the assumptions used to instantiate a Symbol and (for
+storage purposes) represent a more compact representation of the assumptions
+needed to recreate the full set in ``Symbol.assumptions0``.
+
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Negative_number
+.. [2] https://en.wikipedia.org/wiki/Parity_%28mathematics%29
+.. [3] https://en.wikipedia.org/wiki/Imaginary_number
+.. [4] https://en.wikipedia.org/wiki/Composite_number
+.. [5] https://en.wikipedia.org/wiki/Irrational_number
+.. [6] https://en.wikipedia.org/wiki/Prime_number
+.. [7] https://en.wikipedia.org/wiki/Finite
+.. [8] https://docs.python.org/3/library/math.html#math.isfinite
+.. [9] https://numpy.org/doc/stable/reference/generated/numpy.isfinite.html
+.. [10] https://en.wikipedia.org/wiki/Transcendental_number
+.. [11] https://en.wikipedia.org/wiki/Algebraic_number
+.. [12] https://en.wikipedia.org/wiki/Commutative_property
+.. [13] https://en.wikipedia.org/wiki/Complex_number
+
+"""
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from .facts import FactRules, FactKB
+from .sympify import sympify
+
+from sympy.core.random import _assumptions_shuffle as shuffle
+from sympy.core.assumptions_generated import generated_assumptions as _assumptions
+
+def _load_pre_generated_assumption_rules():
+    """ Load the assumption rules from pre-generated data
+
+    To update the pre-generated data, see :method::`_generate_assumption_rules`
+    """
+    _assume_rules=FactRules._from_python(_assumptions)
+    return _assume_rules
+
+def _generate_assumption_rules():
+    """ Generate the default assumption rules
+
+    This method should only be called to update the pre-generated
+    assumption rules.
+
+    To update the pre-generated assumptions run: bin/ask_update.py
+
+    """
+    _assume_rules = FactRules([
+
+    'integer        ->  rational',
+    'rational       ->  real',
+    'rational       ->  algebraic',
+    'algebraic      ->  complex',
+    'transcendental ==  complex & !algebraic',
+    'real           ->  hermitian',
+    'imaginary      ->  complex',
+    'imaginary      ->  antihermitian',
+    'extended_real  ->  commutative',
+    'complex        ->  commutative',
+    'complex        ->  finite',
+
+    'odd            ==  integer & !even',
+    'even           ==  integer & !odd',
+
+    'real           ->  complex',
+    'extended_real  ->  real | infinite',
+    'real           ==  extended_real & finite',
+
+    'extended_real        ==  extended_negative | zero | extended_positive',
+    'extended_negative    ==  extended_nonpositive & extended_nonzero',
+    'extended_positive    ==  extended_nonnegative & extended_nonzero',
+
+    'extended_nonpositive ==  extended_real & !extended_positive',
+    'extended_nonnegative ==  extended_real & !extended_negative',
+
+    'real           ==  negative | zero | positive',
+    'negative       ==  nonpositive & nonzero',
+    'positive       ==  nonnegative & nonzero',
+
+    'nonpositive    ==  real & !positive',
+    'nonnegative    ==  real & !negative',
+
+    'positive       ==  extended_positive & finite',
+    'negative       ==  extended_negative & finite',
+    'nonpositive    ==  extended_nonpositive & finite',
+    'nonnegative    ==  extended_nonnegative & finite',
+    'nonzero        ==  extended_nonzero & finite',
+
+    'zero           ->  even & finite',
+    'zero           ==  extended_nonnegative & extended_nonpositive',
+    'zero           ==  nonnegative & nonpositive',
+    'nonzero        ->  real',
+
+    'prime          ->  integer & positive',
+    'composite      ->  integer & positive & !prime',
+    '!composite     ->  !positive | !even | prime',
+
+    'irrational     ==  real & !rational',
+
+    'imaginary      ->  !extended_real',
+
+    'infinite       ==  !finite',
+    'noninteger     ==  extended_real & !integer',
+    'extended_nonzero == extended_real & !zero',
+    ])
+    return _assume_rules
+
+
+_assume_rules = _load_pre_generated_assumption_rules()
+_assume_defined = _assume_rules.defined_facts.copy()
+_assume_defined.add('polar')
+_assume_defined = frozenset(_assume_defined)
+
+
+def assumptions(expr, _check=None):
+    """return the T/F assumptions of ``expr``"""
+    n = sympify(expr)
+    if n.is_Symbol:
+        rv = n.assumptions0  # are any important ones missing?
+        if _check is not None:
+            rv = {k: rv[k] for k in set(rv) & set(_check)}
+        return rv
+    rv = {}
+    for k in _assume_defined if _check is None else _check:
+        v = getattr(n, 'is_{}'.format(k))
+        if v is not None:
+            rv[k] = v
+    return rv
+
+
+def common_assumptions(exprs, check=None):
+    """return those assumptions which have the same True or False
+    value for all the given expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.core import common_assumptions
+    >>> from sympy import oo, pi, sqrt
+    >>> common_assumptions([-4, 0, sqrt(2), 2, pi, oo])
+    {'commutative': True, 'composite': False,
+    'extended_real': True, 'imaginary': False, 'odd': False}
+
+    By default, all assumptions are tested; pass an iterable of the
+    assumptions to limit those that are reported:
+
+    >>> common_assumptions([0, 1, 2], ['positive', 'integer'])
+    {'integer': True}
+    """
+    check = _assume_defined if check is None else set(check)
+    if not check or not exprs:
+        return {}
+
+    # get all assumptions for each
+    assume = [assumptions(i, _check=check) for i in sympify(exprs)]
+    # focus on those of interest that are True
+    for i, e in enumerate(assume):
+        assume[i] = {k: e[k] for k in set(e) & check}
+    # what assumptions are in common?
+    common = set.intersection(*[set(i) for i in assume])
+    # which ones hold the same value
+    a = assume[0]
+    return {k: a[k] for k in common if all(a[k] == b[k]
+        for b in assume)}
+
+
+def failing_assumptions(expr, **assumptions):
+    """
+    Return a dictionary containing assumptions with values not
+    matching those of the passed assumptions.
+
+    Examples
+    ========
+
+    >>> from sympy import failing_assumptions, Symbol
+
+    >>> x = Symbol('x', positive=True)
+    >>> y = Symbol('y')
+    >>> failing_assumptions(6*x + y, positive=True)
+    {'positive': None}
+
+    >>> failing_assumptions(x**2 - 1, positive=True)
+    {'positive': None}
+
+    If *expr* satisfies all of the assumptions, an empty dictionary is returned.
+
+    >>> failing_assumptions(x**2, positive=True)
+    {}
+
+    """
+    expr = sympify(expr)
+    failed = {}
+    for k in assumptions:
+        test = getattr(expr, 'is_%s' % k, None)
+        if test is not assumptions[k]:
+            failed[k] = test
+    return failed  # {} or {assumption: value != desired}
+
+
+def check_assumptions(expr, against=None, **assume):
+    """
+    Checks whether assumptions of ``expr`` match the T/F assumptions
+    given (or possessed by ``against``). True is returned if all
+    assumptions match; False is returned if there is a mismatch and
+    the assumption in ``expr`` is not None; else None is returned.
+
+    Explanation
+    ===========
+
+    *assume* is a dict of assumptions with True or False values
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, pi, I, exp, check_assumptions
+    >>> check_assumptions(-5, integer=True)
+    True
+    >>> check_assumptions(pi, real=True, integer=False)
+    True
+    >>> check_assumptions(pi, negative=True)
+    False
+    >>> check_assumptions(exp(I*pi/7), real=False)
+    True
+    >>> x = Symbol('x', positive=True)
+    >>> check_assumptions(2*x + 1, positive=True)
+    True
+    >>> check_assumptions(-2*x - 5, positive=True)
+    False
+
+    To check assumptions of *expr* against another variable or expression,
+    pass the expression or variable as ``against``.
+
+    >>> check_assumptions(2*x + 1, x)
+    True
+
+    To see if a number matches the assumptions of an expression, pass
+    the number as the first argument, else its specific assumptions
+    may not have a non-None value in the expression:
+
+    >>> check_assumptions(x, 3)
+    >>> check_assumptions(3, x)
+    True
+
+    ``None`` is returned if ``check_assumptions()`` could not conclude.
+
+    >>> check_assumptions(2*x - 1, x)
+
+    >>> z = Symbol('z')
+    >>> check_assumptions(z, real=True)
+
+    See Also
+    ========
+
+    failing_assumptions
+
+    """
+    expr = sympify(expr)
+    if against is not None:
+        if assume:
+            raise ValueError(
+                'Expecting `against` or `assume`, not both.')
+        assume = assumptions(against)
+    known = True
+    for k, v in assume.items():
+        if v is None:
+            continue
+        e = getattr(expr, 'is_' + k, None)
+        if e is None:
+            known = None
+        elif v != e:
+            return False
+    return known
+
+
+class StdFactKB(FactKB):
+    """A FactKB specialized for the built-in rules
+
+    This is the only kind of FactKB that Basic objects should use.
+    """
+    def __init__(self, facts=None):
+        super().__init__(_assume_rules)
+        # save a copy of the facts dict
+        if not facts:
+            self._generator = {}
+        elif not isinstance(facts, FactKB):
+            self._generator = facts.copy()
+        else:
+            self._generator = facts.generator
+        if facts:
+            self.deduce_all_facts(facts)
+
+    def copy(self):
+        return self.__class__(self)
+
+    @property
+    def generator(self):
+        return self._generator.copy()
+
+
+def as_property(fact):
+    """Convert a fact name to the name of the corresponding property"""
+    return 'is_%s' % fact
+
+
+def make_property(fact):
+    """Create the automagic property corresponding to a fact."""
+
+    def getit(self):
+        try:
+            return self._assumptions[fact]
+        except KeyError:
+            if self._assumptions is self.default_assumptions:
+                self._assumptions = self.default_assumptions.copy()
+            return _ask(fact, self)
+
+    getit.func_name = as_property(fact)
+    return property(getit)
+
+
+def _ask(fact, obj):
+    """
+    Find the truth value for a property of an object.
+
+    This function is called when a request is made to see what a fact
+    value is.
+
+    For this we use several techniques:
+
+    First, the fact-evaluation function is tried, if it exists (for
+    example _eval_is_integer). Then we try related facts. For example
+
+        rational   -->   integer
+
+    another example is joined rule:
+
+        integer & !odd  --> even
+
+    so in the latter case if we are looking at what 'even' value is,
+    'integer' and 'odd' facts will be asked.
+
+    In all cases, when we settle on some fact value, its implications are
+    deduced, and the result is cached in ._assumptions.
+    """
+    # FactKB which is dict-like and maps facts to their known values:
+    assumptions = obj._assumptions
+
+    # A dict that maps facts to their handlers:
+    handler_map = obj._prop_handler
+
+    # This is our queue of facts to check:
+    facts_to_check = [fact]
+    facts_queued = {fact}
+
+    # Loop over the queue as it extends
+    for fact_i in facts_to_check:
+
+        # If fact_i has already been determined then we don't need to rerun the
+        # handler. There is a potential race condition for multithreaded code
+        # though because it's possible that fact_i was checked in another
+        # thread. The main logic of the loop below would potentially skip
+        # checking assumptions[fact] in this case so we check it once after the
+        # loop to be sure.
+        if fact_i in assumptions:
+            continue
+
+        # Now we call the associated handler for fact_i if it exists.
+        fact_i_value = None
+        handler_i = handler_map.get(fact_i)
+        if handler_i is not None:
+            fact_i_value = handler_i(obj)
+
+        # If we get a new value for fact_i then we should update our knowledge
+        # of fact_i as well as any related facts that can be inferred using the
+        # inference rules connecting the fact_i and any other fact values that
+        # are already known.
+        if fact_i_value is not None:
+            assumptions.deduce_all_facts(((fact_i, fact_i_value),))
+
+        # Usually if assumptions[fact] is now not None then that is because of
+        # the call to deduce_all_facts above. The handler for fact_i returned
+        # True or False and knowing fact_i (which is equal to fact in the first
+        # iteration) implies knowing a value for fact. It is also possible
+        # though that independent code e.g. called indirectly by the handler or
+        # called in another thread in a multithreaded context might have
+        # resulted in assumptions[fact] being set. Either way we return it.
+        fact_value = assumptions.get(fact)
+        if fact_value is not None:
+            return fact_value
+
+        # Extend the queue with other facts that might determine fact_i. Here
+        # we randomise the order of the facts that are checked. This should not
+        # lead to any non-determinism if all handlers are logically consistent
+        # with the inference rules for the facts. Non-deterministic assumptions
+        # queries can result from bugs in the handlers that are exposed by this
+        # call to shuffle. These are pushed to the back of the queue meaning
+        # that the inference graph is traversed in breadth-first order.
+        new_facts_to_check = list(_assume_rules.prereq[fact_i] - facts_queued)
+        shuffle(new_facts_to_check)
+        facts_to_check.extend(new_facts_to_check)
+        facts_queued.update(new_facts_to_check)
+
+    # The above loop should be able to handle everything fine in a
+    # single-threaded context but in multithreaded code it is possible that
+    # this thread skipped computing a particular fact that was computed in
+    # another thread (due to the continue). In that case it is possible that
+    # fact was inferred and is now stored in the assumptions dict but it wasn't
+    # checked for in the body of the loop. This is an obscure case but to make
+    # sure we catch it we check once here at the end of the loop.
+    if fact in assumptions:
+        return assumptions[fact]
+
+    # This query can not be answered. It's possible that e.g. another thread
+    # has already stored None for fact but assumptions._tell does not mind if
+    # we call _tell twice setting the same value. If this raises
+    # InconsistentAssumptions then it probably means that another thread
+    # attempted to compute this and got a value of True or False rather than
+    # None. In that case there must be a bug in at least one of the handlers.
+    # If the handlers are all deterministic and are consistent with the
+    # inference rules then the same value should be computed for fact in all
+    # threads.
+    assumptions._tell(fact, None)
+    return None
+
+
+def _prepare_class_assumptions(cls):
+    """Precompute class level assumptions and generate handlers.
+
+    This is called by Basic.__init_subclass__ each time a Basic subclass is
+    defined.
+    """
+
+    local_defs = {}
+    for k in _assume_defined:
+        attrname = as_property(k)
+        v = cls.__dict__.get(attrname, '')
+        if isinstance(v, (bool, int, type(None))):
+            if v is not None:
+                v = bool(v)
+            local_defs[k] = v
+
+    defs = {}
+    for base in reversed(cls.__bases__):
+        assumptions = getattr(base, '_explicit_class_assumptions', None)
+        if assumptions is not None:
+            defs.update(assumptions)
+    defs.update(local_defs)
+
+    cls._explicit_class_assumptions = defs
+    cls.default_assumptions = StdFactKB(defs)
+
+    cls._prop_handler = {}
+    for k in _assume_defined:
+        eval_is_meth = getattr(cls, '_eval_is_%s' % k, None)
+        if eval_is_meth is not None:
+            cls._prop_handler[k] = eval_is_meth
+
+    # Put definite results directly into the class dict, for speed
+    for k, v in cls.default_assumptions.items():
+        setattr(cls, as_property(k), v)
+
+    # protection e.g. for Integer.is_even=F <- (Rational.is_integer=F)
+    derived_from_bases = set()
+    for base in cls.__bases__:
+        default_assumptions = getattr(base, 'default_assumptions', None)
+        # is an assumption-aware class
+        if default_assumptions is not None:
+            derived_from_bases.update(default_assumptions)
+
+    for fact in derived_from_bases - set(cls.default_assumptions):
+        pname = as_property(fact)
+        if pname not in cls.__dict__:
+            setattr(cls, pname, make_property(fact))
+
+    # Finally, add any missing automagic property (e.g. for Basic)
+    for fact in _assume_defined:
+        pname = as_property(fact)
+        if not hasattr(cls, pname):
+            setattr(cls, pname, make_property(fact))
+
+
+# XXX: ManagedProperties used to be the metaclass for Basic but now Basic does
+# not use a metaclass. We leave this here for backwards compatibility for now
+# in case someone has been using the ManagedProperties class in downstream
+# code. The reason that it might have been used is that when subclassing a
+# class and wanting to use a metaclass the metaclass must be a subclass of the
+# metaclass for the class that is being subclassed. Anyone wanting to subclass
+# Basic and use a metaclass in their subclass would have needed to subclass
+# ManagedProperties. Here ManagedProperties is not the metaclass for Basic any
+# more but it should still be usable as a metaclass for Basic subclasses since
+# it is a subclass of type which is now the metaclass for Basic.
+class ManagedProperties(type):
+    def __init__(cls, *args, **kwargs):
+        msg = ("The ManagedProperties metaclass. "
+               "Basic does not use metaclasses any more")
+        sympy_deprecation_warning(msg,
+            deprecated_since_version="1.12",
+            active_deprecations_target='managedproperties')
+
+        # Here we still call this function in case someone is using
+        # ManagedProperties for something that is not a Basic subclass. For
+        # Basic subclasses this function is now called by __init_subclass__ and
+        # so this metaclass is not needed any more.
+        _prepare_class_assumptions(cls)

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

@@ -0,0 +1,1615 @@
+"""
+Do NOT manually edit this file.
+Instead, run ./bin/ask_update.py.
+"""
+
+defined_facts = [
+    'algebraic',
+    'antihermitian',
+    'commutative',
+    'complex',
+    'composite',
+    'even',
+    'extended_negative',
+    'extended_nonnegative',
+    'extended_nonpositive',
+    'extended_nonzero',
+    'extended_positive',
+    'extended_real',
+    'finite',
+    'hermitian',
+    'imaginary',
+    'infinite',
+    'integer',
+    'irrational',
+    'negative',
+    'noninteger',
+    'nonnegative',
+    'nonpositive',
+    'nonzero',
+    'odd',
+    'positive',
+    'prime',
+    'rational',
+    'real',
+    'transcendental',
+    'zero',
+] # defined_facts
+
+
+full_implications = dict( [
+    # Implications of algebraic = True:
+    (('algebraic', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('finite', True),
+        ('infinite', False),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of algebraic = False:
+    (('algebraic', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of antihermitian = True:
+    (('antihermitian', True), set( (
+       ) ),
+     ),
+    # Implications of antihermitian = False:
+    (('antihermitian', False), set( (
+        ('imaginary', False),
+       ) ),
+     ),
+    # Implications of commutative = True:
+    (('commutative', True), set( (
+       ) ),
+     ),
+    # Implications of commutative = False:
+    (('commutative', False), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', False),
+        ('imaginary', 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),
+       ) ),
+     ),
+    # Implications of complex = True:
+    (('complex', True), set( (
+        ('commutative', True),
+        ('finite', True),
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of complex = False:
+    (('complex', False), set( (
+        ('algebraic', False),
+        ('composite', False),
+        ('even', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of composite = True:
+    (('composite', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('positive', True),
+        ('prime', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of composite = False:
+    (('composite', False), set( (
+       ) ),
+     ),
+    # Implications of even = True:
+    (('even', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('noninteger', False),
+        ('odd', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of even = False:
+    (('even', False), set( (
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_negative = True:
+    (('extended_negative', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('nonnegative', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_negative = False:
+    (('extended_negative', False), set( (
+        ('negative', False),
+       ) ),
+     ),
+    # Implications of extended_nonnegative = True:
+    (('extended_nonnegative', True), set( (
+        ('commutative', True),
+        ('extended_negative', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('negative', False),
+       ) ),
+     ),
+    # Implications of extended_nonnegative = False:
+    (('extended_nonnegative', False), set( (
+        ('composite', False),
+        ('extended_positive', False),
+        ('nonnegative', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonpositive = True:
+    (('extended_nonpositive', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_nonpositive = False:
+    (('extended_nonpositive', False), set( (
+        ('extended_negative', False),
+        ('negative', False),
+        ('nonpositive', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonzero = True:
+    (('extended_nonzero', True), set( (
+        ('commutative', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonzero = False:
+    (('extended_nonzero', False), set( (
+        ('composite', False),
+        ('extended_negative', False),
+        ('extended_positive', False),
+        ('negative', False),
+        ('nonzero', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_positive = True:
+    (('extended_positive', True), set( (
+        ('commutative', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('negative', False),
+        ('nonpositive', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_positive = False:
+    (('extended_positive', False), set( (
+        ('composite', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_real = True:
+    (('extended_real', True), set( (
+        ('commutative', True),
+        ('imaginary', False),
+       ) ),
+     ),
+    # Implications of extended_real = False:
+    (('extended_real', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', 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),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of finite = True:
+    (('finite', True), set( (
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of finite = False:
+    (('finite', False), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('imaginary', False),
+        ('infinite', True),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of hermitian = True:
+    (('hermitian', True), set( (
+       ) ),
+     ),
+    # Implications of hermitian = False:
+    (('hermitian', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of imaginary = True:
+    (('imaginary', True), set( (
+        ('antihermitian', 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),
+        ('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),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of imaginary = False:
+    (('imaginary', False), set( (
+       ) ),
+     ),
+    # Implications of infinite = True:
+    (('infinite', True), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('finite', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of infinite = False:
+    (('infinite', False), set( (
+        ('finite', True),
+       ) ),
+     ),
+    # Implications of integer = True:
+    (('integer', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('irrational', False),
+        ('noninteger', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of integer = False:
+    (('integer', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of irrational = True:
+    (('irrational', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', False),
+        ('noninteger', True),
+        ('nonzero', True),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of irrational = False:
+    (('irrational', False), set( (
+       ) ),
+     ),
+    # Implications of negative = True:
+    (('negative', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_negative', True),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('nonnegative', False),
+        ('nonpositive', True),
+        ('nonzero', True),
+        ('positive', False),
+        ('prime', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of negative = False:
+    (('negative', False), set( (
+       ) ),
+     ),
+    # Implications of noninteger = True:
+    (('noninteger', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of noninteger = False:
+    (('noninteger', False), set( (
+       ) ),
+     ),
+    # Implications of nonnegative = True:
+    (('nonnegative', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('negative', False),
+        ('real', True),
+       ) ),
+     ),
+    # Implications of nonnegative = False:
+    (('nonnegative', False), set( (
+        ('composite', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonpositive = True:
+    (('nonpositive', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_nonpositive', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('positive', False),
+        ('prime', False),
+        ('real', True),
+       ) ),
+     ),
+    # Implications of nonpositive = False:
+    (('nonpositive', False), set( (
+        ('negative', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonzero = True:
+    (('nonzero', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonzero = False:
+    (('nonzero', False), set( (
+        ('composite', False),
+        ('negative', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of odd = True:
+    (('odd', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('noninteger', False),
+        ('nonzero', True),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of odd = False:
+    (('odd', False), set( (
+       ) ),
+     ),
+    # Implications of positive = True:
+    (('positive', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('negative', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of positive = False:
+    (('positive', False), set( (
+        ('composite', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of prime = True:
+    (('prime', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('positive', True),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of prime = False:
+    (('prime', False), set( (
+       ) ),
+     ),
+    # Implications of rational = True:
+    (('rational', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('irrational', False),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of rational = False:
+    (('rational', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of real = True:
+    (('real', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of real = False:
+    (('real', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of transcendental = True:
+    (('transcendental', True), set( (
+        ('algebraic', False),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('finite', True),
+        ('infinite', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of transcendental = False:
+    (('transcendental', False), set( (
+       ) ),
+     ),
+    # Implications of zero = True:
+    (('zero', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', True),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of zero = False:
+    (('zero', False), set( (
+       ) ),
+     ),
+ ] ) # full_implications
+
+
+prereq = {
+
+    # facts that could determine the value of algebraic
+    'algebraic': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of antihermitian
+    'antihermitian': {
+        'imaginary',
+    },
+
+    # facts that could determine the value of commutative
+    'commutative': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of complex
+    'complex': {
+        'algebraic',
+        'commutative',
+        'composite',
+        'even',
+        'finite',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of composite
+    'composite': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of even
+    'even': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'noninteger',
+        'odd',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_negative
+    'extended_negative': {
+        'commutative',
+        'composite',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonnegative',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonnegative
+    'extended_nonnegative': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonnegative',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonpositive
+    'extended_nonpositive': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonpositive',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonzero
+    'extended_nonzero': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_positive
+    'extended_positive': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonpositive',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_real
+    'extended_real': {
+        'commutative',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of finite
+    'finite': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of hermitian
+    'hermitian': {
+        'composite',
+        'even',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of imaginary
+    'imaginary': {
+        'antihermitian',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of infinite
+    'infinite': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of integer
+    'integer': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'irrational',
+        'noninteger',
+        'odd',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of irrational
+    'irrational': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of negative
+    'negative': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of noninteger
+    'noninteger': {
+        'commutative',
+        'composite',
+        'even',
+        'extended_real',
+        'imaginary',
+        'integer',
+        'irrational',
+        'odd',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of nonnegative
+    'nonnegative': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of nonpositive
+    'nonpositive': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_nonpositive',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of nonzero
+    'nonzero': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_nonzero',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'irrational',
+        'negative',
+        'odd',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of odd
+    'odd': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'noninteger',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of positive
+    'positive': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of prime
+    'prime': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of rational
+    'rational': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'odd',
+        'prime',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of real
+    'real': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'zero',
+    },
+
+    # facts that could determine the value of transcendental
+    'transcendental': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'zero',
+    },
+
+    # facts that could determine the value of zero
+    'zero': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+    },
+
+} # prereq
+
+
+# Note: the order of the beta rules is used in the beta_triggers
+beta_rules = [
+
+    # Rules implying composite = True
+    ({('even', True), ('positive', True), ('prime', False)},
+        ('composite', True)),
+
+    # Rules implying even = False
+    ({('composite', False), ('positive', True), ('prime', False)},
+        ('even', False)),
+
+    # Rules implying even = True
+    ({('integer', True), ('odd', False)},
+        ('even', True)),
+
+    # Rules implying extended_negative = True
+    ({('extended_positive', False), ('extended_real', True), ('zero', False)},
+        ('extended_negative', True)),
+    ({('extended_nonpositive', True), ('extended_nonzero', True)},
+        ('extended_negative', True)),
+
+    # Rules implying extended_nonnegative = True
+    ({('extended_negative', False), ('extended_real', True)},
+        ('extended_nonnegative', True)),
+
+    # Rules implying extended_nonpositive = True
+    ({('extended_positive', False), ('extended_real', True)},
+        ('extended_nonpositive', True)),
+
+    # Rules implying extended_nonzero = True
+    ({('extended_real', True), ('zero', False)},
+        ('extended_nonzero', True)),
+
+    # Rules implying extended_positive = True
+    ({('extended_negative', False), ('extended_real', True), ('zero', False)},
+        ('extended_positive', True)),
+    ({('extended_nonnegative', True), ('extended_nonzero', True)},
+        ('extended_positive', True)),
+
+    # Rules implying extended_real = False
+    ({('infinite', False), ('real', False)},
+        ('extended_real', False)),
+    ({('extended_negative', False), ('extended_positive', False), ('zero', False)},
+        ('extended_real', False)),
+
+    # Rules implying infinite = True
+    ({('extended_real', True), ('real', False)},
+        ('infinite', True)),
+
+    # Rules implying irrational = True
+    ({('rational', False), ('real', True)},
+        ('irrational', True)),
+
+    # Rules implying negative = True
+    ({('positive', False), ('real', True), ('zero', False)},
+        ('negative', True)),
+    ({('nonpositive', True), ('nonzero', True)},
+        ('negative', True)),
+    ({('extended_negative', True), ('finite', True)},
+        ('negative', True)),
+
+    # Rules implying noninteger = True
+    ({('extended_real', True), ('integer', False)},
+        ('noninteger', True)),
+
+    # Rules implying nonnegative = True
+    ({('negative', False), ('real', True)},
+        ('nonnegative', True)),
+    ({('extended_nonnegative', True), ('finite', True)},
+        ('nonnegative', True)),
+
+    # Rules implying nonpositive = True
+    ({('positive', False), ('real', True)},
+        ('nonpositive', True)),
+    ({('extended_nonpositive', True), ('finite', True)},
+        ('nonpositive', True)),
+
+    # Rules implying nonzero = True
+    ({('extended_nonzero', True), ('finite', True)},
+        ('nonzero', True)),
+
+    # Rules implying odd = True
+    ({('even', False), ('integer', True)},
+        ('odd', True)),
+
+    # Rules implying positive = False
+    ({('composite', False), ('even', True), ('prime', False)},
+        ('positive', False)),
+
+    # Rules implying positive = True
+    ({('negative', False), ('real', True), ('zero', False)},
+        ('positive', True)),
+    ({('nonnegative', True), ('nonzero', True)},
+        ('positive', True)),
+    ({('extended_positive', True), ('finite', True)},
+        ('positive', True)),
+
+    # Rules implying prime = True
+    ({('composite', False), ('even', True), ('positive', True)},
+        ('prime', True)),
+
+    # Rules implying real = False
+    ({('negative', False), ('positive', False), ('zero', False)},
+        ('real', False)),
+
+    # Rules implying real = True
+    ({('extended_real', True), ('infinite', False)},
+        ('real', True)),
+    ({('extended_real', True), ('finite', True)},
+        ('real', True)),
+
+    # Rules implying transcendental = True
+    ({('algebraic', False), ('complex', True)},
+        ('transcendental', True)),
+
+    # Rules implying zero = True
+    ({('extended_negative', False), ('extended_positive', False), ('extended_real', True)},
+        ('zero', True)),
+    ({('negative', False), ('positive', False), ('real', True)},
+        ('zero', True)),
+    ({('extended_nonnegative', True), ('extended_nonpositive', True)},
+        ('zero', True)),
+    ({('nonnegative', True), ('nonpositive', True)},
+        ('zero', True)),
+
+] # beta_rules
+beta_triggers = {
+    ('algebraic', False): [32, 11, 3, 8, 29, 14, 25, 13, 17, 7],
+    ('algebraic', True): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('antihermitian', False): [],
+    ('commutative', False): [],
+    ('complex', False): [10, 12, 11, 3, 8, 17, 7],
+    ('complex', True): [32, 10, 30, 31, 27, 16, 21, 19, 22],
+    ('composite', False): [1, 28, 24],
+    ('composite', True): [23, 2],
+    ('even', False): [23, 11, 3, 8, 29, 14, 25, 7],
+    ('even', True): [3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 0, 28, 24, 7],
+    ('extended_negative', False): [11, 33, 8, 5, 29, 34, 25, 18],
+    ('extended_negative', True): [30, 12, 31, 29, 14, 20, 16, 21, 22, 17],
+    ('extended_nonnegative', False): [11, 3, 6, 29, 14, 20, 7],
+    ('extended_nonnegative', True): [30, 12, 31, 33, 8, 9, 6, 29, 34, 25, 18, 19, 35, 17, 7],
+    ('extended_nonpositive', False): [11, 8, 5, 29, 25, 18, 7],
+    ('extended_nonpositive', True): [30, 12, 31, 3, 33, 4, 5, 29, 14, 34, 20, 21, 35, 17, 7],
+    ('extended_nonzero', False): [11, 33, 6, 5, 29, 34, 20, 18],
+    ('extended_nonzero', True): [30, 12, 31, 3, 8, 4, 9, 6, 5, 29, 14, 25, 22, 17],
+    ('extended_positive', False): [11, 3, 33, 6, 29, 14, 34, 20],
+    ('extended_positive', True): [30, 12, 31, 29, 25, 18, 27, 19, 22, 17],
+    ('extended_real', False): [],
+    ('extended_real', True): [30, 12, 31, 3, 33, 8, 6, 5, 17, 7],
+    ('finite', False): [11, 3, 8, 17, 7],
+    ('finite', True): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('hermitian', False): [10, 12, 11, 3, 8, 17, 7],
+    ('imaginary', True): [32],
+    ('infinite', False): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('infinite', True): [11, 3, 8, 17, 7],
+    ('integer', False): [11, 3, 8, 29, 14, 25, 17, 7],
+    ('integer', True): [23, 2, 3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 7],
+    ('irrational', True): [32, 3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19],
+    ('negative', False): [29, 34, 25, 18],
+    ('negative', True): [32, 13, 17],
+    ('noninteger', True): [30, 12, 31, 3, 8, 4, 9, 6, 5, 29, 14, 25, 22],
+    ('nonnegative', False): [11, 3, 8, 29, 14, 20, 7],
+    ('nonnegative', True): [32, 33, 8, 9, 6, 34, 25, 26, 20, 27, 21, 22, 35, 36, 13, 17, 7],
+    ('nonpositive', False): [11, 3, 8, 29, 25, 18, 7],
+    ('nonpositive', True): [32, 3, 33, 4, 5, 14, 34, 15, 18, 16, 19, 22, 35, 36, 13, 17, 7],
+    ('nonzero', False): [29, 34, 20, 18],
+    ('nonzero', True): [32, 3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19, 13, 17],
+    ('odd', False): [2],
+    ('odd', True): [3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19],
+    ('positive', False): [29, 14, 34, 20],
+    ('positive', True): [32, 0, 1, 28, 13, 17],
+    ('prime', False): [0, 1, 24],
+    ('prime', True): [23, 2],
+    ('rational', False): [11, 3, 8, 29, 14, 25, 13, 17, 7],
+    ('rational', True): [3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 17, 7],
+    ('real', False): [10, 12, 11, 3, 8, 17, 7],
+    ('real', True): [32, 3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 13, 17, 7],
+    ('transcendental', True): [10, 30, 31, 11, 3, 8, 29, 14, 25, 27, 16, 21, 19, 22, 13, 17, 7],
+    ('zero', False): [11, 3, 8, 29, 14, 25, 7],
+    ('zero', True): [],
+} # beta_triggers
+
+
+generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,
+               'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers}

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

@@ -0,0 +1,2233 @@
+"""Base class for all the objects in SymPy"""
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Mapping
+from itertools import chain, zip_longest
+
+from .assumptions import _prepare_class_assumptions
+from .cache import cacheit
+from .core import ordering_of_classes
+from .sympify import _sympify, sympify, SympifyError, _external_converter
+from .sorting import ordered
+from .kind import Kind, UndefinedKind
+from ._print_helpers import Printable
+
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable, numbered_symbols
+from sympy.utilities.misc import filldedent, func_name
+
+from inspect import getmro
+
+
+def as_Basic(expr):
+    """Return expr as a Basic instance using strict sympify
+    or raise a TypeError; this is just a wrapper to _sympify,
+    raising a TypeError instead of a SympifyError."""
+    try:
+        return _sympify(expr)
+    except SympifyError:
+        raise TypeError(
+            'Argument must be a Basic object, not `%s`' % func_name(
+            expr))
+
+
+def _old_compare(x: type, y: type) -> int:
+    # If the other object is not a Basic subclass, then we are not equal to it.
+    if not issubclass(y, Basic):
+        return -1
+
+    n1 = x.__name__
+    n2 = y.__name__
+    if n1 == n2:
+        return 0
+
+    UNKNOWN = len(ordering_of_classes) + 1
+    try:
+        i1 = ordering_of_classes.index(n1)
+    except ValueError:
+        i1 = UNKNOWN
+    try:
+        i2 = ordering_of_classes.index(n2)
+    except ValueError:
+        i2 = UNKNOWN
+    if i1 == UNKNOWN and i2 == UNKNOWN:
+        return (n1 > n2) - (n1 < n2)
+    return (i1 > i2) - (i1 < i2)
+
+
+class Basic(Printable):
+    """
+    Base class for all SymPy objects.
+
+    Notes and conventions
+    =====================
+
+    1) Always use ``.args``, when accessing parameters of some instance:
+
+    >>> from sympy import cot
+    >>> from sympy.abc import x, y
+
+    >>> cot(x).args
+    (x,)
+
+    >>> cot(x).args[0]
+    x
+
+    >>> (x*y).args
+    (x, y)
+
+    >>> (x*y).args[1]
+    y
+
+
+    2) Never use internal methods or variables (the ones prefixed with ``_``):
+
+    >>> cot(x)._args    # do not use this, use cot(x).args instead
+    (x,)
+
+
+    3)  By "SymPy object" we mean something that can be returned by
+        ``sympify``.  But not all objects one encounters using SymPy are
+        subclasses of Basic.  For example, mutable objects are not:
+
+        >>> from sympy import Basic, Matrix, sympify
+        >>> A = Matrix([[1, 2], [3, 4]]).as_mutable()
+        >>> isinstance(A, Basic)
+        False
+
+        >>> B = sympify(A)
+        >>> isinstance(B, Basic)
+        True
+    """
+    __slots__ = ('_mhash',              # hash value
+                 '_args',               # arguments
+                 '_assumptions'
+                )
+
+    _args: tuple[Basic, ...]
+    _mhash: int | None
+
+    @property
+    def __sympy__(self):
+        return True
+
+    def __init_subclass__(cls):
+        # Initialize the default_assumptions FactKB and also any assumptions
+        # property methods. This method will only be called for subclasses of
+        # Basic but not for Basic itself so we call
+        # _prepare_class_assumptions(Basic) below the class definition.
+        _prepare_class_assumptions(cls)
+
+    # To be overridden with True in the appropriate subclasses
+    is_number = False
+    is_Atom = False
+    is_Symbol = False
+    is_symbol = False
+    is_Indexed = False
+    is_Dummy = False
+    is_Wild = False
+    is_Function = False
+    is_Add = False
+    is_Mul = False
+    is_Pow = False
+    is_Number = False
+    is_Float = False
+    is_Rational = False
+    is_Integer = False
+    is_NumberSymbol = False
+    is_Order = False
+    is_Derivative = False
+    is_Piecewise = False
+    is_Poly = False
+    is_AlgebraicNumber = False
+    is_Relational = False
+    is_Equality = False
+    is_Boolean = False
+    is_Not = False
+    is_Matrix = False
+    is_Vector = False
+    is_Point = False
+    is_MatAdd = False
+    is_MatMul = False
+    is_real: bool | None
+    is_extended_real: bool | None
+    is_zero: bool | None
+    is_negative: bool | None
+    is_commutative: bool | None
+
+    kind: Kind = UndefinedKind
+
+    def __new__(cls, *args):
+        obj = object.__new__(cls)
+        obj._assumptions = cls.default_assumptions
+        obj._mhash = None  # will be set by __hash__ method.
+
+        obj._args = args  # all items in args must be Basic objects
+        return obj
+
+    def copy(self):
+        return self.func(*self.args)
+
+    def __getnewargs__(self):
+        return self.args
+
+    def __getstate__(self):
+        return None
+
+    def __setstate__(self, state):
+        for name, value in state.items():
+            setattr(self, name, value)
+
+    def __reduce_ex__(self, protocol):
+        if protocol < 2:
+            msg = "Only pickle protocol 2 or higher is supported by SymPy"
+            raise NotImplementedError(msg)
+        return super().__reduce_ex__(protocol)
+
+    def __hash__(self) -> int:
+        # hash cannot be cached using cache_it because infinite recurrence
+        # occurs as hash is needed for setting cache dictionary keys
+        h = self._mhash
+        if h is None:
+            h = hash((type(self).__name__,) + self._hashable_content())
+            self._mhash = h
+        return h
+
+    def _hashable_content(self):
+        """Return a tuple of information about self that can be used to
+        compute the hash. If a class defines additional attributes,
+        like ``name`` in Symbol, then this method should be updated
+        accordingly to return such relevant attributes.
+
+        Defining more than _hashable_content is necessary if __eq__ has
+        been defined by a class. See note about this in Basic.__eq__."""
+        return self._args
+
+    @property
+    def assumptions0(self):
+        """
+        Return object `type` assumptions.
+
+        For example:
+
+          Symbol('x', real=True)
+          Symbol('x', integer=True)
+
+        are different objects. In other words, besides Python type (Symbol in
+        this case), the initial assumptions are also forming their typeinfo.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy.abc import x
+        >>> x.assumptions0
+        {'commutative': True}
+        >>> x = Symbol("x", positive=True)
+        >>> x.assumptions0
+        {'commutative': True, 'complex': True, 'extended_negative': False,
+         'extended_nonnegative': True, 'extended_nonpositive': False,
+         'extended_nonzero': True, 'extended_positive': True, 'extended_real':
+         True, 'finite': True, 'hermitian': True, 'imaginary': False,
+         'infinite': False, 'negative': False, 'nonnegative': True,
+         'nonpositive': False, 'nonzero': True, 'positive': True, 'real':
+         True, 'zero': False}
+        """
+        return {}
+
+    def compare(self, other):
+        """
+        Return -1, 0, 1 if the object is smaller, equal, or greater than other.
+
+        Not in the mathematical sense. If the object is of a different type
+        from the "other" then their classes are ordered according to
+        the sorted_classes list.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> x.compare(y)
+        -1
+        >>> x.compare(x)
+        0
+        >>> y.compare(x)
+        1
+
+        """
+        # all redefinitions of __cmp__ method should start with the
+        # following lines:
+        if self is other:
+            return 0
+        n1 = self.__class__
+        n2 = other.__class__
+        c = _old_compare(n1, n2)
+        if c:
+            return c
+        #
+        st = self._hashable_content()
+        ot = other._hashable_content()
+        c = (len(st) > len(ot)) - (len(st) < len(ot))
+        if c:
+            return c
+        for l, r in zip(st, ot):
+            l = Basic(*l) if isinstance(l, frozenset) else l
+            r = Basic(*r) if isinstance(r, frozenset) else r
+            if isinstance(l, Basic):
+                c = l.compare(r)
+            else:
+                c = (l > r) - (l < r)
+            if c:
+                return c
+        return 0
+
+    @staticmethod
+    def _compare_pretty(a, b):
+        from sympy.series.order import Order
+        if isinstance(a, Order) and not isinstance(b, Order):
+            return 1
+        if not isinstance(a, Order) and isinstance(b, Order):
+            return -1
+
+        if a.is_Rational and b.is_Rational:
+            l = a.p * b.q
+            r = b.p * a.q
+            return (l > r) - (l < r)
+        else:
+            from .symbol import Wild
+            p1, p2, p3 = Wild("p1"), Wild("p2"), Wild("p3")
+            r_a = a.match(p1 * p2**p3)
+            if r_a and p3 in r_a:
+                a3 = r_a[p3]
+                r_b = b.match(p1 * p2**p3)
+                if r_b and p3 in r_b:
+                    b3 = r_b[p3]
+                    c = Basic.compare(a3, b3)
+                    if c != 0:
+                        return c
+
+        return Basic.compare(a, b)
+
+    @classmethod
+    def fromiter(cls, args, **assumptions):
+        """
+        Create a new object from an iterable.
+
+        This is a convenience function that allows one to create objects from
+        any iterable, without having to convert to a list or tuple first.
+
+        Examples
+        ========
+
+        >>> from sympy import Tuple
+        >>> Tuple.fromiter(i for i in range(5))
+        (0, 1, 2, 3, 4)
+
+        """
+        return cls(*tuple(args), **assumptions)
+
+    @classmethod
+    def class_key(cls):
+        """Nice order of classes."""
+        return 5, 0, cls.__name__
+
+    @cacheit
+    def sort_key(self, order=None):
+        """
+        Return a sort key.
+
+        Examples
+        ========
+
+        >>> from sympy import S, I
+
+        >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())
+        [1/2, -I, I]
+
+        >>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]")
+        [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]
+        >>> sorted(_, key=lambda x: x.sort_key())
+        [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]
+
+        """
+
+        # XXX: remove this when issue 5169 is fixed
+        def inner_key(arg):
+            if isinstance(arg, Basic):
+                return arg.sort_key(order)
+            else:
+                return arg
+
+        args = self._sorted_args
+        args = len(args), tuple([inner_key(arg) for arg in args])
+        return self.class_key(), args, S.One.sort_key(), S.One
+
+    def _do_eq_sympify(self, other):
+        """Returns a boolean indicating whether a == b when either a
+        or b is not a Basic. This is only done for types that were either
+        added to `converter` by a 3rd party or when the object has `_sympy_`
+        defined. This essentially reuses the code in `_sympify` that is
+        specific for this use case. Non-user defined types that are meant
+        to work with SymPy should be handled directly in the __eq__ methods
+        of the `Basic` classes it could equate to and not be converted. Note
+        that after conversion, `==`  is used again since it is not
+        necessarily clear whether `self` or `other`'s __eq__ method needs
+        to be used."""
+        for superclass in type(other).__mro__:
+            conv = _external_converter.get(superclass)
+            if conv is not None:
+                return self == conv(other)
+        if hasattr(other, '_sympy_'):
+            return self == other._sympy_()
+        return NotImplemented
+
+    def __eq__(self, other):
+        """Return a boolean indicating whether a == b on the basis of
+        their symbolic trees.
+
+        This is the same as a.compare(b) == 0 but faster.
+
+        Notes
+        =====
+
+        If a class that overrides __eq__() needs to retain the
+        implementation of __hash__() from a parent class, the
+        interpreter must be told this explicitly by setting
+        __hash__ : Callable[[object], int] = <ParentClass>.__hash__.
+        Otherwise the inheritance of __hash__() will be blocked,
+        just as if __hash__ had been explicitly set to None.
+
+        References
+        ==========
+
+        from https://docs.python.org/dev/reference/datamodel.html#object.__hash__
+        """
+        if self is other:
+            return True
+
+        if not isinstance(other, Basic):
+            return self._do_eq_sympify(other)
+
+        # check for pure number expr
+        if  not (self.is_Number and other.is_Number) and (
+                type(self) != type(other)):
+            return False
+        a, b = self._hashable_content(), other._hashable_content()
+        if a != b:
+            return False
+        # check number *in* an expression
+        for a, b in zip(a, b):
+            if not isinstance(a, Basic):
+                continue
+            if a.is_Number and type(a) != type(b):
+                return False
+        return True
+
+    def __ne__(self, other):
+        """``a != b``  -> Compare two symbolic trees and see whether they are different
+
+        this is the same as:
+
+        ``a.compare(b) != 0``
+
+        but faster
+        """
+        return not self == other
+
+    def dummy_eq(self, other, symbol=None):
+        """
+        Compare two expressions and handle dummy symbols.
+
+        Examples
+        ========
+
+        >>> from sympy import Dummy
+        >>> from sympy.abc import x, y
+
+        >>> u = Dummy('u')
+
+        >>> (u**2 + 1).dummy_eq(x**2 + 1)
+        True
+        >>> (u**2 + 1) == (x**2 + 1)
+        False
+
+        >>> (u**2 + y).dummy_eq(x**2 + y, x)
+        True
+        >>> (u**2 + y).dummy_eq(x**2 + y, y)
+        False
+
+        """
+        s = self.as_dummy()
+        o = _sympify(other)
+        o = o.as_dummy()
+
+        dummy_symbols = [i for i in s.free_symbols if i.is_Dummy]
+
+        if len(dummy_symbols) == 1:
+            dummy = dummy_symbols.pop()
+        else:
+            return s == o
+
+        if symbol is None:
+            symbols = o.free_symbols
+
+            if len(symbols) == 1:
+                symbol = symbols.pop()
+            else:
+                return s == o
+
+        tmp = dummy.__class__()
+
+        return s.xreplace({dummy: tmp}) == o.xreplace({symbol: tmp})
+
+    def atoms(self, *types):
+        """Returns the atoms that form the current object.
+
+        By default, only objects that are truly atomic and cannot
+        be divided into smaller pieces are returned: symbols, numbers,
+        and number symbols like I and pi. It is possible to request
+        atoms of any type, however, as demonstrated below.
+
+        Examples
+        ========
+
+        >>> from sympy import I, pi, sin
+        >>> from sympy.abc import x, y
+        >>> (1 + x + 2*sin(y + I*pi)).atoms()
+        {1, 2, I, pi, x, y}
+
+        If one or more types are given, the results will contain only
+        those types of atoms.
+
+        >>> from sympy import Number, NumberSymbol, Symbol
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)
+        {x, y}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)
+        {1, 2}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)
+        {1, 2, pi}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)
+        {1, 2, I, pi}
+
+        Note that I (imaginary unit) and zoo (complex infinity) are special
+        types of number symbols and are not part of the NumberSymbol class.
+
+        The type can be given implicitly, too:
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol
+        {x, y}
+
+        Be careful to check your assumptions when using the implicit option
+        since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type
+        of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all
+        integers in an expression:
+
+        >>> from sympy import S
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
+        {1}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))
+        {1, 2}
+
+        Finally, arguments to atoms() can select more than atomic atoms: any
+        SymPy type (loaded in core/__init__.py) can be listed as an argument
+        and those types of "atoms" as found in scanning the arguments of the
+        expression recursively:
+
+        >>> from sympy import Function, Mul
+        >>> from sympy.core.function import AppliedUndef
+        >>> f = Function('f')
+        >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)
+        {f(x), sin(y + I*pi)}
+        >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)
+        {f(x)}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)
+        {I*pi, 2*sin(y + I*pi)}
+
+        """
+        if types:
+            types = tuple(
+                [t if isinstance(t, type) else type(t) for t in types])
+        nodes = _preorder_traversal(self)
+        if types:
+            result = {node for node in nodes if isinstance(node, types)}
+        else:
+            result = {node for node in nodes if not node.args}
+        return result
+
+    @property
+    def free_symbols(self) -> set[Basic]:
+        """Return from the atoms of self those which are free symbols.
+
+        Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols
+
+        For most expressions, all symbols are free symbols. For some classes
+        this is not true. e.g. Integrals use Symbols for the dummy variables
+        which are bound variables, so Integral has a method to return all
+        symbols except those. Derivative keeps track of symbols with respect
+        to which it will perform a derivative; those are
+        bound variables, too, so it has its own free_symbols method.
+
+        Any other method that uses bound variables should implement a
+        free_symbols method."""
+        empty: set[Basic] = set()
+        return empty.union(*(a.free_symbols for a in self.args))
+
+    @property
+    def expr_free_symbols(self):
+        sympy_deprecation_warning("""
+        The expr_free_symbols property is deprecated. Use free_symbols to get
+        the free symbols of an expression.
+        """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-expr-free-symbols")
+        return set()
+
+    def as_dummy(self):
+        """Return the expression with any objects having structurally
+        bound symbols replaced with unique, canonical symbols within
+        the object in which they appear and having only the default
+        assumption for commutativity being True. When applied to a
+        symbol a new symbol having only the same commutativity will be
+        returned.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, Symbol
+        >>> from sympy.abc import x
+        >>> r = Symbol('r', real=True)
+        >>> Integral(r, (r, x)).as_dummy()
+        Integral(_0, (_0, x))
+        >>> _.variables[0].is_real is None
+        True
+        >>> r.as_dummy()
+        _r
+
+        Notes
+        =====
+
+        Any object that has structurally bound variables should have
+        a property, `bound_symbols` that returns those symbols
+        appearing in the object.
+        """
+        from .symbol import Dummy, Symbol
+        def can(x):
+            # mask free that shadow bound
+            free = x.free_symbols
+            bound = set(x.bound_symbols)
+            d = {i: Dummy() for i in bound & free}
+            x = x.subs(d)
+            # replace bound with canonical names
+            x = x.xreplace(x.canonical_variables)
+            # return after undoing masking
+            return x.xreplace({v: k for k, v in d.items()})
+        if not self.has(Symbol):
+            return self
+        return self.replace(
+            lambda x: hasattr(x, 'bound_symbols'),
+            can,
+            simultaneous=False)
+
+    @property
+    def canonical_variables(self):
+        """Return a dictionary mapping any variable defined in
+        ``self.bound_symbols`` to Symbols that do not clash
+        with any free symbols in the expression.
+
+        Examples
+        ========
+
+        >>> from sympy import Lambda
+        >>> from sympy.abc import x
+        >>> Lambda(x, 2*x).canonical_variables
+        {x: _0}
+        """
+        if not hasattr(self, 'bound_symbols'):
+            return {}
+        dums = numbered_symbols('_')
+        reps = {}
+        # watch out for free symbol that are not in bound symbols;
+        # those that are in bound symbols are about to get changed
+        bound = self.bound_symbols
+        names = {i.name for i in self.free_symbols - set(bound)}
+        for b in bound:
+            d = next(dums)
+            if b.is_Symbol:
+                while d.name in names:
+                    d = next(dums)
+            reps[b] = d
+        return reps
+
+    def rcall(self, *args):
+        """Apply on the argument recursively through the expression tree.
+
+        This method is used to simulate a common abuse of notation for
+        operators. For instance, in SymPy the following will not work:
+
+        ``(x+Lambda(y, 2*y))(z) == x+2*z``,
+
+        however, you can use:
+
+        >>> from sympy import Lambda
+        >>> from sympy.abc import x, y, z
+        >>> (x + Lambda(y, 2*y)).rcall(z)
+        x + 2*z
+        """
+        return Basic._recursive_call(self, args)
+
+    @staticmethod
+    def _recursive_call(expr_to_call, on_args):
+        """Helper for rcall method."""
+        from .symbol import Symbol
+        def the_call_method_is_overridden(expr):
+            for cls in getmro(type(expr)):
+                if '__call__' in cls.__dict__:
+                    return cls != Basic
+
+        if callable(expr_to_call) and the_call_method_is_overridden(expr_to_call):
+            if isinstance(expr_to_call, Symbol):  # XXX When you call a Symbol it is
+                return expr_to_call               # transformed into an UndefFunction
+            else:
+                return expr_to_call(*on_args)
+        elif expr_to_call.args:
+            args = [Basic._recursive_call(
+                sub, on_args) for sub in expr_to_call.args]
+            return type(expr_to_call)(*args)
+        else:
+            return expr_to_call
+
+    def is_hypergeometric(self, k):
+        from sympy.simplify.simplify import hypersimp
+        from sympy.functions.elementary.piecewise import Piecewise
+        if self.has(Piecewise):
+            return None
+        return hypersimp(self, k) is not None
+
+    @property
+    def is_comparable(self):
+        """Return True if self can be computed to a real number
+        (or already is a real number) with precision, else False.
+
+        Examples
+        ========
+
+        >>> from sympy import exp_polar, pi, I
+        >>> (I*exp_polar(I*pi/2)).is_comparable
+        True
+        >>> (I*exp_polar(I*pi*2)).is_comparable
+        False
+
+        A False result does not mean that `self` cannot be rewritten
+        into a form that would be comparable. For example, the
+        difference computed below is zero but without simplification
+        it does not evaluate to a zero with precision:
+
+        >>> e = 2**pi*(1 + 2**pi)
+        >>> dif = e - e.expand()
+        >>> dif.is_comparable
+        False
+        >>> dif.n(2)._prec
+        1
+
+        """
+        is_extended_real = self.is_extended_real
+        if is_extended_real is False:
+            return False
+        if not self.is_number:
+            return False
+        # don't re-eval numbers that are already evaluated since
+        # this will create spurious precision
+        n, i = [p.evalf(2) if not p.is_Number else p
+            for p in self.as_real_imag()]
+        if not (i.is_Number and n.is_Number):
+            return False
+        if i:
+            # if _prec = 1 we can't decide and if not,
+            # the answer is False because numbers with
+            # imaginary parts can't be compared
+            # so return False
+            return False
+        else:
+            return n._prec != 1
+
+    @property
+    def func(self):
+        """
+        The top-level function in an expression.
+
+        The following should hold for all objects::
+
+            >> x == x.func(*x.args)
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> a = 2*x
+        >>> a.func
+        <class 'sympy.core.mul.Mul'>
+        >>> a.args
+        (2, x)
+        >>> a.func(*a.args)
+        2*x
+        >>> a == a.func(*a.args)
+        True
+
+        """
+        return self.__class__
+
+    @property
+    def args(self) -> tuple[Basic, ...]:
+        """Returns a tuple of arguments of 'self'.
+
+        Examples
+        ========
+
+        >>> from sympy import cot
+        >>> from sympy.abc import x, y
+
+        >>> cot(x).args
+        (x,)
+
+        >>> cot(x).args[0]
+        x
+
+        >>> (x*y).args
+        (x, y)
+
+        >>> (x*y).args[1]
+        y
+
+        Notes
+        =====
+
+        Never use self._args, always use self.args.
+        Only use _args in __new__ when creating a new function.
+        Do not override .args() from Basic (so that it is easy to
+        change the interface in the future if needed).
+        """
+        return self._args
+
+    @property
+    def _sorted_args(self):
+        """
+        The same as ``args``.  Derived classes which do not fix an
+        order on their arguments should override this method to
+        produce the sorted representation.
+        """
+        return self.args
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """A stub to allow Basic args (like Tuple) to be skipped when computing
+        the content and primitive components of an expression.
+
+        See Also
+        ========
+
+        sympy.core.expr.Expr.as_content_primitive
+        """
+        return S.One, self
+
+    def subs(self, *args, **kwargs):
+        """
+        Substitutes old for new in an expression after sympifying args.
+
+        `args` is either:
+          - two arguments, e.g. foo.subs(old, new)
+          - one iterable argument, e.g. foo.subs(iterable). The iterable may be
+             o an iterable container with (old, new) pairs. In this case the
+               replacements are processed in the order given with successive
+               patterns possibly affecting replacements already made.
+             o a dict or set whose key/value items correspond to old/new pairs.
+               In this case the old/new pairs will be sorted by op count and in
+               case of a tie, by number of args and the default_sort_key. The
+               resulting sorted list is then processed as an iterable container
+               (see previous).
+
+        If the keyword ``simultaneous`` is True, the subexpressions will not be
+        evaluated until all the substitutions have been made.
+
+        Examples
+        ========
+
+        >>> from sympy import pi, exp, limit, oo
+        >>> from sympy.abc import x, y
+        >>> (1 + x*y).subs(x, pi)
+        pi*y + 1
+        >>> (1 + x*y).subs({x:pi, y:2})
+        1 + 2*pi
+        >>> (1 + x*y).subs([(x, pi), (y, 2)])
+        1 + 2*pi
+        >>> reps = [(y, x**2), (x, 2)]
+        >>> (x + y).subs(reps)
+        6
+        >>> (x + y).subs(reversed(reps))
+        x**2 + 2
+
+        >>> (x**2 + x**4).subs(x**2, y)
+        y**2 + y
+
+        To replace only the x**2 but not the x**4, use xreplace:
+
+        >>> (x**2 + x**4).xreplace({x**2: y})
+        x**4 + y
+
+        To delay evaluation until all substitutions have been made,
+        set the keyword ``simultaneous`` to True:
+
+        >>> (x/y).subs([(x, 0), (y, 0)])
+        0
+        >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)
+        nan
+
+        This has the added feature of not allowing subsequent substitutions
+        to affect those already made:
+
+        >>> ((x + y)/y).subs({x + y: y, y: x + y})
+        1
+        >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)
+        y/(x + y)
+
+        In order to obtain a canonical result, unordered iterables are
+        sorted by count_op length, number of arguments and by the
+        default_sort_key to break any ties. All other iterables are left
+        unsorted.
+
+        >>> from sympy import sqrt, sin, cos
+        >>> from sympy.abc import a, b, c, d, e
+
+        >>> A = (sqrt(sin(2*x)), a)
+        >>> B = (sin(2*x), b)
+        >>> C = (cos(2*x), c)
+        >>> D = (x, d)
+        >>> E = (exp(x), e)
+
+        >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)
+
+        >>> expr.subs(dict([A, B, C, D, E]))
+        a*c*sin(d*e) + b
+
+        The resulting expression represents a literal replacement of the
+        old arguments with the new arguments. This may not reflect the
+        limiting behavior of the expression:
+
+        >>> (x**3 - 3*x).subs({x: oo})
+        nan
+
+        >>> limit(x**3 - 3*x, x, oo)
+        oo
+
+        If the substitution will be followed by numerical
+        evaluation, it is better to pass the substitution to
+        evalf as
+
+        >>> (1/x).evalf(subs={x: 3.0}, n=21)
+        0.333333333333333333333
+
+        rather than
+
+        >>> (1/x).subs({x: 3.0}).evalf(21)
+        0.333333333333333314830
+
+        as the former will ensure that the desired level of precision is
+        obtained.
+
+        See Also
+        ========
+        replace: replacement capable of doing wildcard-like matching,
+                 parsing of match, and conditional replacements
+        xreplace: exact node replacement in expr tree; also capable of
+                  using matching rules
+        sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision
+
+        """
+        from .containers import Dict
+        from .symbol import Dummy, Symbol
+        from .numbers import _illegal
+
+        unordered = False
+        if len(args) == 1:
+
+            sequence = args[0]
+            if isinstance(sequence, set):
+                unordered = True
+            elif isinstance(sequence, (Dict, Mapping)):
+                unordered = True
+                sequence = sequence.items()
+            elif not iterable(sequence):
+                raise ValueError(filldedent("""
+                   When a single argument is passed to subs
+                   it should be a dictionary of old: new pairs or an iterable
+                   of (old, new) tuples."""))
+        elif len(args) == 2:
+            sequence = [args]
+        else:
+            raise ValueError("subs accepts either 1 or 2 arguments")
+
+        def sympify_old(old):
+            if isinstance(old, str):
+                # Use Symbol rather than parse_expr for old
+                return Symbol(old)
+            elif isinstance(old, type):
+                # Allow a type e.g. Function('f') or sin
+                return sympify(old, strict=False)
+            else:
+                return sympify(old, strict=True)
+
+        def sympify_new(new):
+            if isinstance(new, (str, type)):
+                # Allow a type or parse a string input
+                return sympify(new, strict=False)
+            else:
+                return sympify(new, strict=True)
+
+        sequence = [(sympify_old(s1), sympify_new(s2)) for s1, s2 in sequence]
+
+        # skip if there is no change
+        sequence = [(s1, s2) for s1, s2 in sequence if not _aresame(s1, s2)]
+
+        simultaneous = kwargs.pop('simultaneous', False)
+
+        if unordered:
+            from .sorting import _nodes, default_sort_key
+            sequence = dict(sequence)
+            # order so more complex items are first and items
+            # of identical complexity are ordered so
+            # f(x) < f(y) < x < y
+            # \___ 2 __/    \_1_/  <- number of nodes
+            #
+            # For more complex ordering use an unordered sequence.
+            k = list(ordered(sequence, default=False, keys=(
+                lambda x: -_nodes(x),
+                default_sort_key,
+                )))
+            sequence = [(k, sequence[k]) for k in k]
+            # do infinities first
+            if not simultaneous:
+                redo = [i for i, seq in enumerate(sequence) if seq[1] in _illegal]
+                for i in reversed(redo):
+                    sequence.insert(0, sequence.pop(i))
+
+        if simultaneous:  # XXX should this be the default for dict subs?
+            reps = {}
+            rv = self
+            kwargs['hack2'] = True
+            m = Dummy('subs_m')
+            for old, new in sequence:
+                com = new.is_commutative
+                if com is None:
+                    com = True
+                d = Dummy('subs_d', commutative=com)
+                # using d*m so Subs will be used on dummy variables
+                # in things like Derivative(f(x, y), x) in which x
+                # is both free and bound
+                rv = rv._subs(old, d*m, **kwargs)
+                if not isinstance(rv, Basic):
+                    break
+                reps[d] = new
+            reps[m] = S.One  # get rid of m
+            return rv.xreplace(reps)
+        else:
+            rv = self
+            for old, new in sequence:
+                rv = rv._subs(old, new, **kwargs)
+                if not isinstance(rv, Basic):
+                    break
+            return rv
+
+    @cacheit
+    def _subs(self, old, new, **hints):
+        """Substitutes an expression old -> new.
+
+        If self is not equal to old then _eval_subs is called.
+        If _eval_subs does not want to make any special replacement
+        then a None is received which indicates that the fallback
+        should be applied wherein a search for replacements is made
+        amongst the arguments of self.
+
+        >>> from sympy import Add
+        >>> from sympy.abc import x, y, z
+
+        Examples
+        ========
+
+        Add's _eval_subs knows how to target x + y in the following
+        so it makes the change:
+
+        >>> (x + y + z).subs(x + y, 1)
+        z + 1
+
+        Add's _eval_subs does not need to know how to find x + y in
+        the following:
+
+        >>> Add._eval_subs(z*(x + y) + 3, x + y, 1) is None
+        True
+
+        The returned None will cause the fallback routine to traverse the args and
+        pass the z*(x + y) arg to Mul where the change will take place and the
+        substitution will succeed:
+
+        >>> (z*(x + y) + 3).subs(x + y, 1)
+        z + 3
+
+        ** Developers Notes **
+
+        An _eval_subs routine for a class should be written if:
+
+            1) any arguments are not instances of Basic (e.g. bool, tuple);
+
+            2) some arguments should not be targeted (as in integration
+               variables);
+
+            3) if there is something other than a literal replacement
+               that should be attempted (as in Piecewise where the condition
+               may be updated without doing a replacement).
+
+        If it is overridden, here are some special cases that might arise:
+
+            1) If it turns out that no special change was made and all
+               the original sub-arguments should be checked for
+               replacements then None should be returned.
+
+            2) If it is necessary to do substitutions on a portion of
+               the expression then _subs should be called. _subs will
+               handle the case of any sub-expression being equal to old
+               (which usually would not be the case) while its fallback
+               will handle the recursion into the sub-arguments. For
+               example, after Add's _eval_subs removes some matching terms
+               it must process the remaining terms so it calls _subs
+               on each of the un-matched terms and then adds them
+               onto the terms previously obtained.
+
+           3) If the initial expression should remain unchanged then
+              the original expression should be returned. (Whenever an
+              expression is returned, modified or not, no further
+              substitution of old -> new is attempted.) Sum's _eval_subs
+              routine uses this strategy when a substitution is attempted
+              on any of its summation variables.
+        """
+
+        def fallback(self, old, new):
+            """
+            Try to replace old with new in any of self's arguments.
+            """
+            hit = False
+            args = list(self.args)
+            for i, arg in enumerate(args):
+                if not hasattr(arg, '_eval_subs'):
+                    continue
+                arg = arg._subs(old, new, **hints)
+                if not _aresame(arg, args[i]):
+                    hit = True
+                    args[i] = arg
+            if hit:
+                rv = self.func(*args)
+                hack2 = hints.get('hack2', False)
+                if hack2 and self.is_Mul and not rv.is_Mul:  # 2-arg hack
+                    coeff = S.One
+                    nonnumber = []
+                    for i in args:
+                        if i.is_Number:
+                            coeff *= i
+                        else:
+                            nonnumber.append(i)
+                    nonnumber = self.func(*nonnumber)
+                    if coeff is S.One:
+                        return nonnumber
+                    else:
+                        return self.func(coeff, nonnumber, evaluate=False)
+                return rv
+            return self
+
+        if _aresame(self, old):
+            return new
+
+        rv = self._eval_subs(old, new)
+        if rv is None:
+            rv = fallback(self, old, new)
+        return rv
+
+    def _eval_subs(self, old, new):
+        """Override this stub if you want to do anything more than
+        attempt a replacement of old with new in the arguments of self.
+
+        See also
+        ========
+
+        _subs
+        """
+        return None
+
+    def xreplace(self, rule):
+        """
+        Replace occurrences of objects within the expression.
+
+        Parameters
+        ==========
+
+        rule : dict-like
+            Expresses a replacement rule
+
+        Returns
+        =======
+
+        xreplace : the result of the replacement
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, pi, exp
+        >>> x, y, z = symbols('x y z')
+        >>> (1 + x*y).xreplace({x: pi})
+        pi*y + 1
+        >>> (1 + x*y).xreplace({x: pi, y: 2})
+        1 + 2*pi
+
+        Replacements occur only if an entire node in the expression tree is
+        matched:
+
+        >>> (x*y + z).xreplace({x*y: pi})
+        z + pi
+        >>> (x*y*z).xreplace({x*y: pi})
+        x*y*z
+        >>> (2*x).xreplace({2*x: y, x: z})
+        y
+        >>> (2*2*x).xreplace({2*x: y, x: z})
+        4*z
+        >>> (x + y + 2).xreplace({x + y: 2})
+        x + y + 2
+        >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
+        x + exp(y) + 2
+
+        xreplace does not differentiate between free and bound symbols. In the
+        following, subs(x, y) would not change x since it is a bound symbol,
+        but xreplace does:
+
+        >>> from sympy import Integral
+        >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
+        Integral(y, (y, 1, 2*y))
+
+        Trying to replace x with an expression raises an error:
+
+        >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP
+        ValueError: Invalid limits given: ((2*y, 1, 4*y),)
+
+        See Also
+        ========
+        replace: replacement capable of doing wildcard-like matching,
+                 parsing of match, and conditional replacements
+        subs: substitution of subexpressions as defined by the objects
+              themselves.
+
+        """
+        value, _ = self._xreplace(rule)
+        return value
+
+    def _xreplace(self, rule):
+        """
+        Helper for xreplace. Tracks whether a replacement actually occurred.
+        """
+        if self in rule:
+            return rule[self], True
+        elif rule:
+            args = []
+            changed = False
+            for a in self.args:
+                _xreplace = getattr(a, '_xreplace', None)
+                if _xreplace is not None:
+                    a_xr = _xreplace(rule)
+                    args.append(a_xr[0])
+                    changed |= a_xr[1]
+                else:
+                    args.append(a)
+            args = tuple(args)
+            if changed:
+                return self.func(*args), True
+        return self, False
+
+    @cacheit
+    def has(self, *patterns):
+        """
+        Test whether any subexpression matches any of the patterns.
+
+        Examples
+        ========
+
+        >>> from sympy import sin
+        >>> from sympy.abc import x, y, z
+        >>> (x**2 + sin(x*y)).has(z)
+        False
+        >>> (x**2 + sin(x*y)).has(x, y, z)
+        True
+        >>> x.has(x)
+        True
+
+        Note ``has`` is a structural algorithm with no knowledge of
+        mathematics. Consider the following half-open interval:
+
+        >>> from sympy import Interval
+        >>> i = Interval.Lopen(0, 5); i
+        Interval.Lopen(0, 5)
+        >>> i.args
+        (0, 5, True, False)
+        >>> i.has(4)  # there is no "4" in the arguments
+        False
+        >>> i.has(0)  # there *is* a "0" in the arguments
+        True
+
+        Instead, use ``contains`` to determine whether a number is in the
+        interval or not:
+
+        >>> i.contains(4)
+        True
+        >>> i.contains(0)
+        False
+
+
+        Note that ``expr.has(*patterns)`` is exactly equivalent to
+        ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is
+        returned when the list of patterns is empty.
+
+        >>> x.has()
+        False
+
+        """
+        return self._has(iterargs, *patterns)
+
+    def has_xfree(self, s: set[Basic]):
+        """Return True if self has any of the patterns in s as a
+        free argument, else False. This is like `Basic.has_free`
+        but this will only report exact argument matches.
+
+        Examples
+        ========
+
+        >>> from sympy import Function
+        >>> from sympy.abc import x, y
+        >>> f = Function('f')
+        >>> f(x).has_xfree({f})
+        False
+        >>> f(x).has_xfree({f(x)})
+        True
+        >>> f(x + 1).has_xfree({x})
+        True
+        >>> f(x + 1).has_xfree({x + 1})
+        True
+        >>> f(x + y + 1).has_xfree({x + 1})
+        False
+        """
+        # protect O(1) containment check by requiring:
+        if type(s) is not set:
+            raise TypeError('expecting set argument')
+        return any(a in s for a in iterfreeargs(self))
+
+    @cacheit
+    def has_free(self, *patterns):
+        """Return True if self has object(s) ``x`` as a free expression
+        else False.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, Function
+        >>> from sympy.abc import x, y
+        >>> f = Function('f')
+        >>> g = Function('g')
+        >>> expr = Integral(f(x), (f(x), 1, g(y)))
+        >>> expr.free_symbols
+        {y}
+        >>> expr.has_free(g(y))
+        True
+        >>> expr.has_free(*(x, f(x)))
+        False
+
+        This works for subexpressions and types, too:
+
+        >>> expr.has_free(g)
+        True
+        >>> (x + y + 1).has_free(y + 1)
+        True
+        """
+        if not patterns:
+            return False
+        p0 = patterns[0]
+        if len(patterns) == 1 and iterable(p0) and not isinstance(p0, Basic):
+            # Basic can contain iterables (though not non-Basic, ideally)
+            # but don't encourage mixed passing patterns
+            raise TypeError(filldedent('''
+                Expecting 1 or more Basic args, not a single
+                non-Basic iterable. Don't forget to unpack
+                iterables: `eq.has_free(*patterns)`'''))
+        # try quick test first
+        s = set(patterns)
+        rv = self.has_xfree(s)
+        if rv:
+            return rv
+        # now try matching through slower _has
+        return self._has(iterfreeargs, *patterns)
+
+    def _has(self, iterargs, *patterns):
+        # separate out types and unhashable objects
+        type_set = set()  # only types
+        p_set = set()  # hashable non-types
+        for p in patterns:
+            if isinstance(p, type) and issubclass(p, Basic):
+                type_set.add(p)
+                continue
+            if not isinstance(p, Basic):
+                try:
+                    p = _sympify(p)
+                except SympifyError:
+                    continue  # Basic won't have this in it
+            p_set.add(p)  # fails if object defines __eq__ but
+                          # doesn't define __hash__
+        types = tuple(type_set)   #
+        for i in iterargs(self):  #
+            if i in p_set:        # <--- here, too
+                return True
+            if isinstance(i, types):
+                return True
+
+        # use matcher if defined, e.g. operations defines
+        # matcher that checks for exact subset containment,
+        # (x + y + 1).has(x + 1) -> True
+        for i in p_set - type_set:  # types don't have matchers
+            if not hasattr(i, '_has_matcher'):
+                continue
+            match = i._has_matcher()
+            if any(match(arg) for arg in iterargs(self)):
+                return True
+
+        # no success
+        return False
+
+    def replace(self, query, value, map=False, simultaneous=True, exact=None):
+        """
+        Replace matching subexpressions of ``self`` with ``value``.
+
+        If ``map = True`` then also return the mapping {old: new} where ``old``
+        was a sub-expression found with query and ``new`` is the replacement
+        value for it. If the expression itself does not match the query, then
+        the returned value will be ``self.xreplace(map)`` otherwise it should
+        be ``self.subs(ordered(map.items()))``.
+
+        Traverses an expression tree and performs replacement of matching
+        subexpressions from the bottom to the top of the tree. The default
+        approach is to do the replacement in a simultaneous fashion so
+        changes made are targeted only once. If this is not desired or causes
+        problems, ``simultaneous`` can be set to False.
+
+        In addition, if an expression containing more than one Wild symbol
+        is being used to match subexpressions and the ``exact`` flag is None
+        it will be set to True so the match will only succeed if all non-zero
+        values are received for each Wild that appears in the match pattern.
+        Setting this to False accepts a match of 0; while setting it True
+        accepts all matches that have a 0 in them. See example below for
+        cautions.
+
+        The list of possible combinations of queries and replacement values
+        is listed below:
+
+        Examples
+        ========
+
+        Initial setup
+
+        >>> from sympy import log, sin, cos, tan, Wild, Mul, Add
+        >>> from sympy.abc import x, y
+        >>> f = log(sin(x)) + tan(sin(x**2))
+
+        1.1. type -> type
+            obj.replace(type, newtype)
+
+            When object of type ``type`` is found, replace it with the
+            result of passing its argument(s) to ``newtype``.
+
+            >>> f.replace(sin, cos)
+            log(cos(x)) + tan(cos(x**2))
+            >>> sin(x).replace(sin, cos, map=True)
+            (cos(x), {sin(x): cos(x)})
+            >>> (x*y).replace(Mul, Add)
+            x + y
+
+        1.2. type -> func
+            obj.replace(type, func)
+
+            When object of type ``type`` is found, apply ``func`` to its
+            argument(s). ``func`` must be written to handle the number
+            of arguments of ``type``.
+
+            >>> f.replace(sin, lambda arg: sin(2*arg))
+            log(sin(2*x)) + tan(sin(2*x**2))
+            >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))
+            sin(2*x*y)
+
+        2.1. pattern -> expr
+            obj.replace(pattern(wild), expr(wild))
+
+            Replace subexpressions matching ``pattern`` with the expression
+            written in terms of the Wild symbols in ``pattern``.
+
+            >>> a, b = map(Wild, 'ab')
+            >>> f.replace(sin(a), tan(a))
+            log(tan(x)) + tan(tan(x**2))
+            >>> f.replace(sin(a), tan(a/2))
+            log(tan(x/2)) + tan(tan(x**2/2))
+            >>> f.replace(sin(a), a)
+            log(x) + tan(x**2)
+            >>> (x*y).replace(a*x, a)
+            y
+
+            Matching is exact by default when more than one Wild symbol
+            is used: matching fails unless the match gives non-zero
+            values for all Wild symbols:
+
+            >>> (2*x + y).replace(a*x + b, b - a)
+            y - 2
+            >>> (2*x).replace(a*x + b, b - a)
+            2*x
+
+            When set to False, the results may be non-intuitive:
+
+            >>> (2*x).replace(a*x + b, b - a, exact=False)
+            2/x
+
+        2.2. pattern -> func
+            obj.replace(pattern(wild), lambda wild: expr(wild))
+
+            All behavior is the same as in 2.1 but now a function in terms of
+            pattern variables is used rather than an expression:
+
+            >>> f.replace(sin(a), lambda a: sin(2*a))
+            log(sin(2*x)) + tan(sin(2*x**2))
+
+        3.1. func -> func
+            obj.replace(filter, func)
+
+            Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``
+            is True.
+
+            >>> g = 2*sin(x**3)
+            >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
+            4*sin(x**9)
+
+        The expression itself is also targeted by the query but is done in
+        such a fashion that changes are not made twice.
+
+            >>> e = x*(x*y + 1)
+            >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
+            2*x*(2*x*y + 1)
+
+        When matching a single symbol, `exact` will default to True, but
+        this may or may not be the behavior that is desired:
+
+        Here, we want `exact=False`:
+
+        >>> from sympy import Function
+        >>> f = Function('f')
+        >>> e = f(1) + f(0)
+        >>> q = f(a), lambda a: f(a + 1)
+        >>> e.replace(*q, exact=False)
+        f(1) + f(2)
+        >>> e.replace(*q, exact=True)
+        f(0) + f(2)
+
+        But here, the nature of matching makes selecting
+        the right setting tricky:
+
+        >>> e = x**(1 + y)
+        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)
+        x
+        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)
+        x**(-x - y + 1)
+        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)
+        x
+        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)
+        x**(1 - y)
+
+        It is probably better to use a different form of the query
+        that describes the target expression more precisely:
+
+        >>> (1 + x**(1 + y)).replace(
+        ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,
+        ... lambda x: x.base**(1 - (x.exp - 1)))
+        ...
+        x**(1 - y) + 1
+
+        See Also
+        ========
+
+        subs: substitution of subexpressions as defined by the objects
+              themselves.
+        xreplace: exact node replacement in expr tree; also capable of
+                  using matching rules
+
+        """
+
+        try:
+            query = _sympify(query)
+        except SympifyError:
+            pass
+        try:
+            value = _sympify(value)
+        except SympifyError:
+            pass
+        if isinstance(query, type):
+            _query = lambda expr: isinstance(expr, query)
+
+            if isinstance(value, type):
+                _value = lambda expr, result: value(*expr.args)
+            elif callable(value):
+                _value = lambda expr, result: value(*expr.args)
+            else:
+                raise TypeError(
+                    "given a type, replace() expects another "
+                    "type or a callable")
+        elif isinstance(query, Basic):
+            _query = lambda expr: expr.match(query)
+            if exact is None:
+                from .symbol import Wild
+                exact = (len(query.atoms(Wild)) > 1)
+
+            if isinstance(value, Basic):
+                if exact:
+                    _value = lambda expr, result: (value.subs(result)
+                        if all(result.values()) else expr)
+                else:
+                    _value = lambda expr, result: value.subs(result)
+            elif callable(value):
+                # match dictionary keys get the trailing underscore stripped
+                # from them and are then passed as keywords to the callable;
+                # if ``exact`` is True, only accept match if there are no null
+                # values amongst those matched.
+                if exact:
+                    _value = lambda expr, result: (value(**
+                        {str(k)[:-1]: v for k, v in result.items()})
+                        if all(val for val in result.values()) else expr)
+                else:
+                    _value = lambda expr, result: value(**
+                        {str(k)[:-1]: v for k, v in result.items()})
+            else:
+                raise TypeError(
+                    "given an expression, replace() expects "
+                    "another expression or a callable")
+        elif callable(query):
+            _query = query
+
+            if callable(value):
+                _value = lambda expr, result: value(expr)
+            else:
+                raise TypeError(
+                    "given a callable, replace() expects "
+                    "another callable")
+        else:
+            raise TypeError(
+                "first argument to replace() must be a "
+                "type, an expression or a callable")
+
+        def walk(rv, F):
+            """Apply ``F`` to args and then to result.
+            """
+            args = getattr(rv, 'args', None)
+            if args is not None:
+                if args:
+                    newargs = tuple([walk(a, F) for a in args])
+                    if args != newargs:
+                        rv = rv.func(*newargs)
+                        if simultaneous:
+                            # if rv is something that was already
+                            # matched (that was changed) then skip
+                            # applying F again
+                            for i, e in enumerate(args):
+                                if rv == e and e != newargs[i]:
+                                    return rv
+                rv = F(rv)
+            return rv
+
+        mapping = {}  # changes that took place
+
+        def rec_replace(expr):
+            result = _query(expr)
+            if result or result == {}:
+                v = _value(expr, result)
+                if v is not None and v != expr:
+                    if map:
+                        mapping[expr] = v
+                    expr = v
+            return expr
+
+        rv = walk(self, rec_replace)
+        return (rv, mapping) if map else rv
+
+    def find(self, query, group=False):
+        """Find all subexpressions matching a query."""
+        query = _make_find_query(query)
+        results = list(filter(query, _preorder_traversal(self)))
+
+        if not group:
+            return set(results)
+        else:
+            groups = {}
+
+            for result in results:
+                if result in groups:
+                    groups[result] += 1
+                else:
+                    groups[result] = 1
+
+            return groups
+
+    def count(self, query):
+        """Count the number of matching subexpressions."""
+        query = _make_find_query(query)
+        return sum(bool(query(sub)) for sub in _preorder_traversal(self))
+
+    def matches(self, expr, repl_dict=None, old=False):
+        """
+        Helper method for match() that looks for a match between Wild symbols
+        in self and expressions in expr.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Wild, Basic
+        >>> a, b, c = symbols('a b c')
+        >>> x = Wild('x')
+        >>> Basic(a + x, x).matches(Basic(a + b, c)) is None
+        True
+        >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
+        {x_: b + c}
+        """
+        expr = sympify(expr)
+        if not isinstance(expr, self.__class__):
+            return None
+
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+
+        if self == expr:
+            return repl_dict
+
+        if len(self.args) != len(expr.args):
+            return None
+
+        d = repl_dict  # already a copy
+        for arg, other_arg in zip(self.args, expr.args):
+            if arg == other_arg:
+                continue
+            if arg.is_Relational:
+                try:
+                    d = arg.xreplace(d).matches(other_arg, d, old=old)
+                except TypeError: # Should be InvalidComparisonError when introduced
+                    d = None
+            else:
+                    d = arg.xreplace(d).matches(other_arg, d, old=old)
+            if d is None:
+                return None
+        return d
+
+    def match(self, pattern, old=False):
+        """
+        Pattern matching.
+
+        Wild symbols match all.
+
+        Return ``None`` when expression (self) does not match
+        with pattern. Otherwise return a dictionary such that::
+
+          pattern.xreplace(self.match(pattern)) == self
+
+        Examples
+        ========
+
+        >>> from sympy import Wild, Sum
+        >>> from sympy.abc import x, y
+        >>> p = Wild("p")
+        >>> q = Wild("q")
+        >>> r = Wild("r")
+        >>> e = (x+y)**(x+y)
+        >>> e.match(p**p)
+        {p_: x + y}
+        >>> e.match(p**q)
+        {p_: x + y, q_: x + y}
+        >>> e = (2*x)**2
+        >>> e.match(p*q**r)
+        {p_: 4, q_: x, r_: 2}
+        >>> (p*q**r).xreplace(e.match(p*q**r))
+        4*x**2
+
+        Structurally bound symbols are ignored during matching:
+
+        >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))
+        {p_: 2}
+
+        But they can be identified if desired:
+
+        >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))
+        {p_: 2, q_: x}
+
+        The ``old`` flag will give the old-style pattern matching where
+        expressions and patterns are essentially solved to give the
+        match. Both of the following give None unless ``old=True``:
+
+        >>> (x - 2).match(p - x, old=True)
+        {p_: 2*x - 2}
+        >>> (2/x).match(p*x, old=True)
+        {p_: 2/x**2}
+
+        """
+        pattern = sympify(pattern)
+        # match non-bound symbols
+        canonical = lambda x: x if x.is_Symbol else x.as_dummy()
+        m = canonical(pattern).matches(canonical(self), old=old)
+        if m is None:
+            return m
+        from .symbol import Wild
+        from .function import WildFunction
+        from ..tensor.tensor import WildTensor, WildTensorIndex, WildTensorHead
+        wild = pattern.atoms(Wild, WildFunction, WildTensor, WildTensorIndex, WildTensorHead)
+        # sanity check
+        if set(m) - wild:
+            raise ValueError(filldedent('''
+            Some `matches` routine did not use a copy of repl_dict
+            and injected unexpected symbols. Report this as an
+            error at https://github.com/sympy/sympy/issues'''))
+        # now see if bound symbols were requested
+        bwild = wild - set(m)
+        if not bwild:
+            return m
+        # replace free-Wild symbols in pattern with match result
+        # so they will match but not be in the next match
+        wpat = pattern.xreplace(m)
+        # identify remaining bound wild
+        w = wpat.matches(self, old=old)
+        # add them to m
+        if w:
+            m.update(w)
+        # done
+        return m
+
+    def count_ops(self, visual=None):
+        """Wrapper for count_ops that returns the operation count."""
+        from .function import count_ops
+        return count_ops(self, visual)
+
+    def doit(self, **hints):
+        """Evaluate objects that are not evaluated by default like limits,
+        integrals, sums and products. All objects of this kind will be
+        evaluated recursively, unless some species were excluded via 'hints'
+        or unless the 'deep' hint was set to 'False'.
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x
+
+        >>> 2*Integral(x, x)
+        2*Integral(x, x)
+
+        >>> (2*Integral(x, x)).doit()
+        x**2
+
+        >>> (2*Integral(x, x)).doit(deep=False)
+        2*Integral(x, x)
+
+        """
+        if hints.get('deep', True):
+            terms = [term.doit(**hints) if isinstance(term, Basic) else term
+                                         for term in self.args]
+            return self.func(*terms)
+        else:
+            return self
+
+    def simplify(self, **kwargs):
+        """See the simplify function in sympy.simplify"""
+        from sympy.simplify.simplify import simplify
+        return simplify(self, **kwargs)
+
+    def refine(self, assumption=True):
+        """See the refine function in sympy.assumptions"""
+        from sympy.assumptions.refine import refine
+        return refine(self, assumption)
+
+    def _eval_derivative_n_times(self, s, n):
+        # This is the default evaluator for derivatives (as called by `diff`
+        # and `Derivative`), it will attempt a loop to derive the expression
+        # `n` times by calling the corresponding `_eval_derivative` method,
+        # while leaving the derivative unevaluated if `n` is symbolic.  This
+        # method should be overridden if the object has a closed form for its
+        # symbolic n-th derivative.
+        from .numbers import Integer
+        if isinstance(n, (int, Integer)):
+            obj = self
+            for i in range(n):
+                obj2 = obj._eval_derivative(s)
+                if obj == obj2 or obj2 is None:
+                    break
+                obj = obj2
+            return obj2
+        else:
+            return None
+
+    def rewrite(self, *args, deep=True, **hints):
+        """
+        Rewrite *self* using a defined rule.
+
+        Rewriting transforms an expression to another, which is mathematically
+        equivalent but structurally different. For example you can rewrite
+        trigonometric functions as complex exponentials or combinatorial
+        functions as gamma function.
+
+        This method takes a *pattern* and a *rule* as positional arguments.
+        *pattern* is optional parameter which defines the types of expressions
+        that will be transformed. If it is not passed, all possible expressions
+        will be rewritten. *rule* defines how the expression will be rewritten.
+
+        Parameters
+        ==========
+
+        args : Expr
+            A *rule*, or *pattern* and *rule*.
+            - *pattern* is a type or an iterable of types.
+            - *rule* can be any object.
+
+        deep : bool, optional
+            If ``True``, subexpressions are recursively transformed. Default is
+            ``True``.
+
+        Examples
+        ========
+
+        If *pattern* is unspecified, all possible expressions are transformed.
+
+        >>> from sympy import cos, sin, exp, I
+        >>> from sympy.abc import x
+        >>> expr = cos(x) + I*sin(x)
+        >>> expr.rewrite(exp)
+        exp(I*x)
+
+        Pattern can be a type or an iterable of types.
+
+        >>> expr.rewrite(sin, exp)
+        exp(I*x)/2 + cos(x) - exp(-I*x)/2
+        >>> expr.rewrite([cos,], exp)
+        exp(I*x)/2 + I*sin(x) + exp(-I*x)/2
+        >>> expr.rewrite([cos, sin], exp)
+        exp(I*x)
+
+        Rewriting behavior can be implemented by defining ``_eval_rewrite()``
+        method.
+
+        >>> from sympy import Expr, sqrt, pi
+        >>> class MySin(Expr):
+        ...     def _eval_rewrite(self, rule, args, **hints):
+        ...         x, = args
+        ...         if rule == cos:
+        ...             return cos(pi/2 - x, evaluate=False)
+        ...         if rule == sqrt:
+        ...             return sqrt(1 - cos(x)**2)
+        >>> MySin(MySin(x)).rewrite(cos)
+        cos(-cos(-x + pi/2) + pi/2)
+        >>> MySin(x).rewrite(sqrt)
+        sqrt(1 - cos(x)**2)
+
+        Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards
+        compatibility reason. This may be removed in the future and using it is
+        discouraged.
+
+        >>> class MySin(Expr):
+        ...     def _eval_rewrite_as_cos(self, *args, **hints):
+        ...         x, = args
+        ...         return cos(pi/2 - x, evaluate=False)
+        >>> MySin(x).rewrite(cos)
+        cos(-x + pi/2)
+
+        """
+        if not args:
+            return self
+
+        hints.update(deep=deep)
+
+        pattern = args[:-1]
+        rule = args[-1]
+
+        # support old design by _eval_rewrite_as_[...] method
+        if isinstance(rule, str):
+            method = "_eval_rewrite_as_%s" % rule
+        elif hasattr(rule, "__name__"):
+            # rule is class or function
+            clsname = rule.__name__
+            method = "_eval_rewrite_as_%s" % clsname
+        else:
+            # rule is instance
+            clsname = rule.__class__.__name__
+            method = "_eval_rewrite_as_%s" % clsname
+
+        if pattern:
+            if iterable(pattern[0]):
+                pattern = pattern[0]
+            pattern = tuple(p for p in pattern if self.has(p))
+            if not pattern:
+                return self
+        # hereafter, empty pattern is interpreted as all pattern.
+
+        return self._rewrite(pattern, rule, method, **hints)
+
+    def _rewrite(self, pattern, rule, method, **hints):
+        deep = hints.pop('deep', True)
+        if deep:
+            args = [a._rewrite(pattern, rule, method, **hints)
+                    for a in self.args]
+        else:
+            args = self.args
+        if not pattern or any(isinstance(self, p) for p in pattern):
+            meth = getattr(self, method, None)
+            if meth is not None:
+                rewritten = meth(*args, **hints)
+            else:
+                rewritten = self._eval_rewrite(rule, args, **hints)
+            if rewritten is not None:
+                return rewritten
+        if not args:
+            return self
+        return self.func(*args)
+
+    def _eval_rewrite(self, rule, args, **hints):
+        return None
+
+    _constructor_postprocessor_mapping = {}  # type: ignore
+
+    @classmethod
+    def _exec_constructor_postprocessors(cls, obj):
+        # WARNING: This API is experimental.
+
+        # This is an experimental API that introduces constructor
+        # postprosessors for SymPy Core elements. If an argument of a SymPy
+        # expression has a `_constructor_postprocessor_mapping` attribute, it will
+        # be interpreted as a dictionary containing lists of postprocessing
+        # functions for matching expression node names.
+
+        clsname = obj.__class__.__name__
+        postprocessors = defaultdict(list)
+        for i in obj.args:
+            try:
+                postprocessor_mappings = (
+                    Basic._constructor_postprocessor_mapping[cls].items()
+                    for cls in type(i).mro()
+                    if cls in Basic._constructor_postprocessor_mapping
+                )
+                for k, v in chain.from_iterable(postprocessor_mappings):
+                    postprocessors[k].extend([j for j in v if j not in postprocessors[k]])
+            except TypeError:
+                pass
+
+        for f in postprocessors.get(clsname, []):
+            obj = f(obj)
+
+        return obj
+
+    def _sage_(self):
+        """
+        Convert *self* to a symbolic expression of SageMath.
+
+        This version of the method is merely a placeholder.
+        """
+        old_method = self._sage_
+        from sage.interfaces.sympy import sympy_init
+        sympy_init()  # may monkey-patch _sage_ method into self's class or superclasses
+        if old_method == self._sage_:
+            raise NotImplementedError('conversion to SageMath is not implemented')
+        else:
+            # call the freshly monkey-patched method
+            return self._sage_()
+
+    def could_extract_minus_sign(self):
+        return False  # see Expr.could_extract_minus_sign
+
+
+# For all Basic subclasses _prepare_class_assumptions is called by
+# Basic.__init_subclass__ but that method is not called for Basic itself so we
+# call the function here instead.
+_prepare_class_assumptions(Basic)
+
+
+class Atom(Basic):
+    """
+    A parent class for atomic things. An atom is an expression with no subexpressions.
+
+    Examples
+    ========
+
+    Symbol, Number, Rational, Integer, ...
+    But not: Add, Mul, Pow, ...
+    """
+
+    is_Atom = True
+
+    __slots__ = ()
+
+    def matches(self, expr, repl_dict=None, old=False):
+        if self == expr:
+            if repl_dict is None:
+                return {}
+            return repl_dict.copy()
+
+    def xreplace(self, rule, hack2=False):
+        return rule.get(self, self)
+
+    def doit(self, **hints):
+        return self
+
+    @classmethod
+    def class_key(cls):
+        return 2, 0, cls.__name__
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (1, (str(self),)), S.One.sort_key(), S.One
+
+    def _eval_simplify(self, **kwargs):
+        return self
+
+    @property
+    def _sorted_args(self):
+        # this is here as a safeguard against accidentally using _sorted_args
+        # on Atoms -- they cannot be rebuilt as atom.func(*atom._sorted_args)
+        # since there are no args. So the calling routine should be checking
+        # to see that this property is not called for Atoms.
+        raise AttributeError('Atoms have no args. It might be necessary'
+        ' to make a check for Atoms in the calling code.')
+
+
+def _aresame(a, b):
+    """Return True if a and b are structurally the same, else False.
+
+    Examples
+    ========
+
+    In SymPy (as in Python) two numbers compare the same if they
+    have the same underlying base-2 representation even though
+    they may not be the same type:
+
+    >>> from sympy import S
+    >>> 2.0 == S(2)
+    True
+    >>> 0.5 == S.Half
+    True
+
+    This routine was written to provide a query for such cases that
+    would give false when the types do not match:
+
+    >>> from sympy.core.basic import _aresame
+    >>> _aresame(S(2.0), S(2))
+    False
+
+    """
+    from .numbers import Number
+    from .function import AppliedUndef, UndefinedFunction as UndefFunc
+    if isinstance(a, Number) and isinstance(b, Number):
+        return a == b and a.__class__ == b.__class__
+    for i, j in zip_longest(_preorder_traversal(a), _preorder_traversal(b)):
+        if i != j or type(i) != type(j):
+            if ((isinstance(i, UndefFunc) and isinstance(j, UndefFunc)) or
+                (isinstance(i, AppliedUndef) and isinstance(j, AppliedUndef))):
+                if i.class_key() != j.class_key():
+                    return False
+            else:
+                return False
+    return True
+
+
+def _ne(a, b):
+    # use this as a second test after `a != b` if you want to make
+    # sure that things are truly equal, e.g.
+    # a, b = 0.5, S.Half
+    # a !=b or _ne(a, b) -> True
+    from .numbers import Number
+    # 0.5 == S.Half
+    if isinstance(a, Number) and isinstance(b, Number):
+        return a.__class__ != b.__class__
+
+
+def _atomic(e, recursive=False):
+    """Return atom-like quantities as far as substitution is
+    concerned: Derivatives, Functions and Symbols. Do not
+    return any 'atoms' that are inside such quantities unless
+    they also appear outside, too, unless `recursive` is True.
+
+    Examples
+    ========
+
+    >>> from sympy import Derivative, Function, cos
+    >>> from sympy.abc import x, y
+    >>> from sympy.core.basic import _atomic
+    >>> f = Function('f')
+    >>> _atomic(x + y)
+    {x, y}
+    >>> _atomic(x + f(y))
+    {x, f(y)}
+    >>> _atomic(Derivative(f(x), x) + cos(x) + y)
+    {y, cos(x), Derivative(f(x), x)}
+
+    """
+    pot = _preorder_traversal(e)
+    seen = set()
+    if isinstance(e, Basic):
+        free = getattr(e, "free_symbols", None)
+        if free is None:
+            return {e}
+    else:
+        return set()
+    from .symbol import Symbol
+    from .function import Derivative, Function
+    atoms = set()
+    for p in pot:
+        if p in seen:
+            pot.skip()
+            continue
+        seen.add(p)
+        if isinstance(p, Symbol) and p in free:
+            atoms.add(p)
+        elif isinstance(p, (Derivative, Function)):
+            if not recursive:
+                pot.skip()
+            atoms.add(p)
+    return atoms
+
+
+def _make_find_query(query):
+    """Convert the argument of Basic.find() into a callable"""
+    try:
+        query = _sympify(query)
+    except SympifyError:
+        pass
+    if isinstance(query, type):
+        return lambda expr: isinstance(expr, query)
+    elif isinstance(query, Basic):
+        return lambda expr: expr.match(query) is not None
+    return query
+
+# Delayed to avoid cyclic import
+from .singleton import S
+from .traversal import (preorder_traversal as _preorder_traversal,
+   iterargs, iterfreeargs)
+
+preorder_traversal = deprecated(
+    """
+    Using preorder_traversal from the sympy.core.basic submodule is
+    deprecated.
+
+    Instead, use preorder_traversal from the top-level sympy namespace, like
+
+        sympy.preorder_traversal
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-traversal-functions-moved",
+)(_preorder_traversal)

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

@@ -0,0 +1,1801 @@
+"""
+Adaptive numerical evaluation of SymPy expressions, using mpmath
+for mathematical functions.
+"""
+from __future__ import annotations
+from typing import Tuple as tTuple, Optional, Union as tUnion, Callable, List, Dict as tDict, Type, TYPE_CHECKING, \
+    Any, overload
+
+import math
+
+import mpmath.libmp as libmp
+from mpmath import (
+    make_mpc, make_mpf, mp, mpc, mpf, nsum, quadts, quadosc, workprec)
+from mpmath import inf as mpmath_inf
+from mpmath.libmp import (from_int, from_man_exp, from_rational, fhalf,
+        fnan, finf, fninf, fnone, fone, fzero, mpf_abs, mpf_add,
+        mpf_atan, mpf_atan2, mpf_cmp, mpf_cos, mpf_e, mpf_exp, mpf_log, mpf_lt,
+        mpf_mul, mpf_neg, mpf_pi, mpf_pow, mpf_pow_int, mpf_shift, mpf_sin,
+        mpf_sqrt, normalize, round_nearest, to_int, to_str)
+from mpmath.libmp import bitcount as mpmath_bitcount
+from mpmath.libmp.backend import MPZ
+from mpmath.libmp.libmpc import _infs_nan
+from mpmath.libmp.libmpf import dps_to_prec, prec_to_dps
+
+from .sympify import sympify
+from .singleton import S
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.lambdify import lambdify
+from sympy.utilities.misc import as_int
+
+if TYPE_CHECKING:
+    from sympy.core.expr import Expr
+    from sympy.core.add import Add
+    from sympy.core.mul import Mul
+    from sympy.core.power import Pow
+    from sympy.core.symbol import Symbol
+    from sympy.integrals.integrals import Integral
+    from sympy.concrete.summations import Sum
+    from sympy.concrete.products import Product
+    from sympy.functions.elementary.exponential import exp, log
+    from sympy.functions.elementary.complexes import Abs, re, im
+    from sympy.functions.elementary.integers import ceiling, floor
+    from sympy.functions.elementary.trigonometric import atan
+    from .numbers import Float, Rational, Integer, AlgebraicNumber, Number
+
+LG10 = math.log(10, 2)
+rnd = round_nearest
+
+
+def bitcount(n):
+    """Return smallest integer, b, such that |n|/2**b < 1.
+    """
+    return mpmath_bitcount(abs(int(n)))
+
+# Used in a few places as placeholder values to denote exponents and
+# precision levels, e.g. of exact numbers. Must be careful to avoid
+# passing these to mpmath functions or returning them in final results.
+INF = float(mpmath_inf)
+MINUS_INF = float(-mpmath_inf)
+
+# ~= 100 digits. Real men set this to INF.
+DEFAULT_MAXPREC = 333
+
+
+class PrecisionExhausted(ArithmeticError):
+    pass
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#              Helper functions for arithmetic and complex parts             #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+"""
+An mpf value tuple is a tuple of integers (sign, man, exp, bc)
+representing a floating-point number: [1, -1][sign]*man*2**exp where
+sign is 0 or 1 and bc should correspond to the number of bits used to
+represent the mantissa (man) in binary notation, e.g.
+"""
+MPF_TUP = tTuple[int, int, int, int]  # mpf value tuple
+
+"""
+Explanation
+===========
+
+>>> from sympy.core.evalf import bitcount
+>>> sign, man, exp, bc = 0, 5, 1, 3
+>>> n = [1, -1][sign]*man*2**exp
+>>> n, bitcount(man)
+(10, 3)
+
+A temporary result is a tuple (re, im, re_acc, im_acc) where
+re and im are nonzero mpf value tuples representing approximate
+numbers, or None to denote exact zeros.
+
+re_acc, im_acc are integers denoting log2(e) where e is the estimated
+relative accuracy of the respective complex part, but may be anything
+if the corresponding complex part is None.
+
+"""
+TMP_RES = Any  # temporary result, should be some variant of
+# tUnion[tTuple[Optional[MPF_TUP], Optional[MPF_TUP],
+#               Optional[int], Optional[int]],
+#        'ComplexInfinity']
+# but mypy reports error because it doesn't know as we know
+# 1. re and re_acc are either both None or both MPF_TUP
+# 2. sometimes the result can't be zoo
+
+# type of the "options" parameter in internal evalf functions
+OPT_DICT = tDict[str, Any]
+
+
+def fastlog(x: Optional[MPF_TUP]) -> tUnion[int, Any]:
+    """Fast approximation of log2(x) for an mpf value tuple x.
+
+    Explanation
+    ===========
+
+    Calculated as exponent + width of mantissa. This is an
+    approximation for two reasons: 1) it gives the ceil(log2(abs(x)))
+    value and 2) it is too high by 1 in the case that x is an exact
+    power of 2. Although this is easy to remedy by testing to see if
+    the odd mpf mantissa is 1 (indicating that one was dealing with
+    an exact power of 2) that would decrease the speed and is not
+    necessary as this is only being used as an approximation for the
+    number of bits in x. The correct return value could be written as
+    "x[2] + (x[3] if x[1] != 1 else 0)".
+        Since mpf tuples always have an odd mantissa, no check is done
+    to see if the mantissa is a multiple of 2 (in which case the
+    result would be too large by 1).
+
+    Examples
+    ========
+
+    >>> from sympy import log
+    >>> from sympy.core.evalf import fastlog, bitcount
+    >>> s, m, e = 0, 5, 1
+    >>> bc = bitcount(m)
+    >>> n = [1, -1][s]*m*2**e
+    >>> n, (log(n)/log(2)).evalf(2), fastlog((s, m, e, bc))
+    (10, 3.3, 4)
+    """
+
+    if not x or x == fzero:
+        return MINUS_INF
+    return x[2] + x[3]
+
+
+def pure_complex(v: 'Expr', or_real=False) -> tuple['Number', 'Number'] | None:
+    """Return a and b if v matches a + I*b where b is not zero and
+    a and b are Numbers, else None. If `or_real` is True then 0 will
+    be returned for `b` if `v` is a real number.
+
+    Examples
+    ========
+
+    >>> from sympy.core.evalf import pure_complex
+    >>> from sympy import sqrt, I, S
+    >>> a, b, surd = S(2), S(3), sqrt(2)
+    >>> pure_complex(a)
+    >>> pure_complex(a, or_real=True)
+    (2, 0)
+    >>> pure_complex(surd)
+    >>> pure_complex(a + b*I)
+    (2, 3)
+    >>> pure_complex(I)
+    (0, 1)
+    """
+    h, t = v.as_coeff_Add()
+    if t:
+        c, i = t.as_coeff_Mul()
+        if i is S.ImaginaryUnit:
+            return h, c
+    elif or_real:
+        return h, S.Zero
+    return None
+
+
+# I don't know what this is, see function scaled_zero below
+SCALED_ZERO_TUP = tTuple[List[int], int, int, int]
+
+
+@overload
+def scaled_zero(mag: SCALED_ZERO_TUP, sign=1) -> MPF_TUP:
+    ...
+@overload
+def scaled_zero(mag: int, sign=1) -> tTuple[SCALED_ZERO_TUP, int]:
+    ...
+def scaled_zero(mag: tUnion[SCALED_ZERO_TUP, int], sign=1) -> \
+        tUnion[MPF_TUP, tTuple[SCALED_ZERO_TUP, int]]:
+    """Return an mpf representing a power of two with magnitude ``mag``
+    and -1 for precision. Or, if ``mag`` is a scaled_zero tuple, then just
+    remove the sign from within the list that it was initially wrapped
+    in.
+
+    Examples
+    ========
+
+    >>> from sympy.core.evalf import scaled_zero
+    >>> from sympy import Float
+    >>> z, p = scaled_zero(100)
+    >>> z, p
+    (([0], 1, 100, 1), -1)
+    >>> ok = scaled_zero(z)
+    >>> ok
+    (0, 1, 100, 1)
+    >>> Float(ok)
+    1.26765060022823e+30
+    >>> Float(ok, p)
+    0.e+30
+    >>> ok, p = scaled_zero(100, -1)
+    >>> Float(scaled_zero(ok), p)
+    -0.e+30
+    """
+    if isinstance(mag, tuple) and len(mag) == 4 and iszero(mag, scaled=True):
+        return (mag[0][0],) + mag[1:]
+    elif isinstance(mag, SYMPY_INTS):
+        if sign not in [-1, 1]:
+            raise ValueError('sign must be +/-1')
+        rv, p = mpf_shift(fone, mag), -1
+        s = 0 if sign == 1 else 1
+        rv = ([s],) + rv[1:]
+        return rv, p
+    else:
+        raise ValueError('scaled zero expects int or scaled_zero tuple.')
+
+
+def iszero(mpf: tUnion[MPF_TUP, SCALED_ZERO_TUP, None], scaled=False) -> Optional[bool]:
+    if not scaled:
+        return not mpf or not mpf[1] and not mpf[-1]
+    return mpf and isinstance(mpf[0], list) and mpf[1] == mpf[-1] == 1
+
+
+def complex_accuracy(result: TMP_RES) -> tUnion[int, Any]:
+    """
+    Returns relative accuracy of a complex number with given accuracies
+    for the real and imaginary parts. The relative accuracy is defined
+    in the complex norm sense as ||z|+|error|| / |z| where error
+    is equal to (real absolute error) + (imag absolute error)*i.
+
+    The full expression for the (logarithmic) error can be approximated
+    easily by using the max norm to approximate the complex norm.
+
+    In the worst case (re and im equal), this is wrong by a factor
+    sqrt(2), or by log2(sqrt(2)) = 0.5 bit.
+    """
+    if result is S.ComplexInfinity:
+        return INF
+    re, im, re_acc, im_acc = result
+    if not im:
+        if not re:
+            return INF
+        return re_acc
+    if not re:
+        return im_acc
+    re_size = fastlog(re)
+    im_size = fastlog(im)
+    absolute_error = max(re_size - re_acc, im_size - im_acc)
+    relative_error = absolute_error - max(re_size, im_size)
+    return -relative_error
+
+
+def get_abs(expr: 'Expr', prec: int, options: OPT_DICT) -> TMP_RES:
+    result = evalf(expr, prec + 2, options)
+    if result is S.ComplexInfinity:
+        return finf, None, prec, None
+    re, im, re_acc, im_acc = result
+    if not re:
+        re, re_acc, im, im_acc = im, im_acc, re, re_acc
+    if im:
+        if expr.is_number:
+            abs_expr, _, acc, _ = evalf(abs(N(expr, prec + 2)),
+                                        prec + 2, options)
+            return abs_expr, None, acc, None
+        else:
+            if 'subs' in options:
+                return libmp.mpc_abs((re, im), prec), None, re_acc, None
+            return abs(expr), None, prec, None
+    elif re:
+        return mpf_abs(re), None, re_acc, None
+    else:
+        return None, None, None, None
+
+
+def get_complex_part(expr: 'Expr', no: int, prec: int, options: OPT_DICT) -> TMP_RES:
+    """no = 0 for real part, no = 1 for imaginary part"""
+    workprec = prec
+    i = 0
+    while 1:
+        res = evalf(expr, workprec, options)
+        if res is S.ComplexInfinity:
+            return fnan, None, prec, None
+        value, accuracy = res[no::2]
+        # XXX is the last one correct? Consider re((1+I)**2).n()
+        if (not value) or accuracy >= prec or -value[2] > prec:
+            return value, None, accuracy, None
+        workprec += max(30, 2**i)
+        i += 1
+
+
+def evalf_abs(expr: 'Abs', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_abs(expr.args[0], prec, options)
+
+
+def evalf_re(expr: 're', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_complex_part(expr.args[0], 0, prec, options)
+
+
+def evalf_im(expr: 'im', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_complex_part(expr.args[0], 1, prec, options)
+
+
+def finalize_complex(re: MPF_TUP, im: MPF_TUP, prec: int) -> TMP_RES:
+    if re == fzero and im == fzero:
+        raise ValueError("got complex zero with unknown accuracy")
+    elif re == fzero:
+        return None, im, None, prec
+    elif im == fzero:
+        return re, None, prec, None
+
+    size_re = fastlog(re)
+    size_im = fastlog(im)
+    if size_re > size_im:
+        re_acc = prec
+        im_acc = prec + min(-(size_re - size_im), 0)
+    else:
+        im_acc = prec
+        re_acc = prec + min(-(size_im - size_re), 0)
+    return re, im, re_acc, im_acc
+
+
+def chop_parts(value: TMP_RES, prec: int) -> TMP_RES:
+    """
+    Chop off tiny real or complex parts.
+    """
+    if value is S.ComplexInfinity:
+        return value
+    re, im, re_acc, im_acc = value
+    # Method 1: chop based on absolute value
+    if re and re not in _infs_nan and (fastlog(re) < -prec + 4):
+        re, re_acc = None, None
+    if im and im not in _infs_nan and (fastlog(im) < -prec + 4):
+        im, im_acc = None, None
+    # Method 2: chop if inaccurate and relatively small
+    if re and im:
+        delta = fastlog(re) - fastlog(im)
+        if re_acc < 2 and (delta - re_acc <= -prec + 4):
+            re, re_acc = None, None
+        if im_acc < 2 and (delta - im_acc >= prec - 4):
+            im, im_acc = None, None
+    return re, im, re_acc, im_acc
+
+
+def check_target(expr: 'Expr', result: TMP_RES, prec: int):
+    a = complex_accuracy(result)
+    if a < prec:
+        raise PrecisionExhausted("Failed to distinguish the expression: \n\n%s\n\n"
+            "from zero. Try simplifying the input, using chop=True, or providing "
+            "a higher maxn for evalf" % (expr))
+
+
+def get_integer_part(expr: 'Expr', no: int, options: OPT_DICT, return_ints=False) -> \
+        tUnion[TMP_RES, tTuple[int, int]]:
+    """
+    With no = 1, computes ceiling(expr)
+    With no = -1, computes floor(expr)
+
+    Note: this function either gives the exact result or signals failure.
+    """
+    from sympy.functions.elementary.complexes import re, im
+    # The expression is likely less than 2^30 or so
+    assumed_size = 30
+    result = evalf(expr, assumed_size, options)
+    if result is S.ComplexInfinity:
+        raise ValueError("Cannot get integer part of Complex Infinity")
+    ire, iim, ire_acc, iim_acc = result
+
+    # We now know the size, so we can calculate how much extra precision
+    # (if any) is needed to get within the nearest integer
+    if ire and iim:
+        gap = max(fastlog(ire) - ire_acc, fastlog(iim) - iim_acc)
+    elif ire:
+        gap = fastlog(ire) - ire_acc
+    elif iim:
+        gap = fastlog(iim) - iim_acc
+    else:
+        # ... or maybe the expression was exactly zero
+        if return_ints:
+            return 0, 0
+        else:
+            return None, None, None, None
+
+    margin = 10
+
+    if gap >= -margin:
+        prec = margin + assumed_size + gap
+        ire, iim, ire_acc, iim_acc = evalf(
+            expr, prec, options)
+    else:
+        prec = assumed_size
+
+    # We can now easily find the nearest integer, but to find floor/ceil, we
+    # must also calculate whether the difference to the nearest integer is
+    # positive or negative (which may fail if very close).
+    def calc_part(re_im: 'Expr', nexpr: MPF_TUP):
+        from .add import Add
+        _, _, exponent, _ = nexpr
+        is_int = exponent == 0
+        nint = int(to_int(nexpr, rnd))
+        if is_int:
+            # make sure that we had enough precision to distinguish
+            # between nint and the re or im part (re_im) of expr that
+            # was passed to calc_part
+            ire, iim, ire_acc, iim_acc = evalf(
+                re_im - nint, 10, options)  # don't need much precision
+            assert not iim
+            size = -fastlog(ire) + 2  # -ve b/c ire is less than 1
+            if size > prec:
+                ire, iim, ire_acc, iim_acc = evalf(
+                    re_im, size, options)
+                assert not iim
+                nexpr = ire
+            nint = int(to_int(nexpr, rnd))
+            _, _, new_exp, _ = ire
+            is_int = new_exp == 0
+        if not is_int:
+            # if there are subs and they all contain integer re/im parts
+            # then we can (hopefully) safely substitute them into the
+            # expression
+            s = options.get('subs', False)
+            if s:
+                doit = True
+                # use strict=False with as_int because we take
+                # 2.0 == 2
+                for v in s.values():
+                    try:
+                        as_int(v, strict=False)
+                    except ValueError:
+                        try:
+                            [as_int(i, strict=False) for i in v.as_real_imag()]
+                            continue
+                        except (ValueError, AttributeError):
+                            doit = False
+                            break
+                if doit:
+                    re_im = re_im.subs(s)
+
+            re_im = Add(re_im, -nint, evaluate=False)
+            x, _, x_acc, _ = evalf(re_im, 10, options)
+            try:
+                check_target(re_im, (x, None, x_acc, None), 3)
+            except PrecisionExhausted:
+                if not re_im.equals(0):
+                    raise PrecisionExhausted
+                x = fzero
+            nint += int(no*(mpf_cmp(x or fzero, fzero) == no))
+        nint = from_int(nint)
+        return nint, INF
+
+    re_, im_, re_acc, im_acc = None, None, None, None
+
+    if ire:
+        re_, re_acc = calc_part(re(expr, evaluate=False), ire)
+    if iim:
+        im_, im_acc = calc_part(im(expr, evaluate=False), iim)
+
+    if return_ints:
+        return int(to_int(re_ or fzero)), int(to_int(im_ or fzero))
+    return re_, im_, re_acc, im_acc
+
+
+def evalf_ceiling(expr: 'ceiling', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_integer_part(expr.args[0], 1, options)
+
+
+def evalf_floor(expr: 'floor', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_integer_part(expr.args[0], -1, options)
+
+
+def evalf_float(expr: 'Float', prec: int, options: OPT_DICT) -> TMP_RES:
+    return expr._mpf_, None, prec, None
+
+
+def evalf_rational(expr: 'Rational', prec: int, options: OPT_DICT) -> TMP_RES:
+    return from_rational(expr.p, expr.q, prec), None, prec, None
+
+
+def evalf_integer(expr: 'Integer', prec: int, options: OPT_DICT) -> TMP_RES:
+    return from_int(expr.p, prec), None, prec, None
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Arithmetic operations                           #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def add_terms(terms: list, prec: int, target_prec: int) -> \
+        tTuple[tUnion[MPF_TUP, SCALED_ZERO_TUP, None], Optional[int]]:
+    """
+    Helper for evalf_add. Adds a list of (mpfval, accuracy) terms.
+
+    Returns
+    =======
+
+    - None, None if there are no non-zero terms;
+    - terms[0] if there is only 1 term;
+    - scaled_zero if the sum of the terms produces a zero by cancellation
+      e.g. mpfs representing 1 and -1 would produce a scaled zero which need
+      special handling since they are not actually zero and they are purposely
+      malformed to ensure that they cannot be used in anything but accuracy
+      calculations;
+    - a tuple that is scaled to target_prec that corresponds to the
+      sum of the terms.
+
+    The returned mpf tuple will be normalized to target_prec; the input
+    prec is used to define the working precision.
+
+    XXX explain why this is needed and why one cannot just loop using mpf_add
+    """
+
+    terms = [t for t in terms if not iszero(t[0])]
+    if not terms:
+        return None, None
+    elif len(terms) == 1:
+        return terms[0]
+
+    # see if any argument is NaN or oo and thus warrants a special return
+    special = []
+    from .numbers import Float
+    for t in terms:
+        arg = Float._new(t[0], 1)
+        if arg is S.NaN or arg.is_infinite:
+            special.append(arg)
+    if special:
+        from .add import Add
+        rv = evalf(Add(*special), prec + 4, {})
+        return rv[0], rv[2]
+
+    working_prec = 2*prec
+    sum_man, sum_exp = 0, 0
+    absolute_err: List[int] = []
+
+    for x, accuracy in terms:
+        sign, man, exp, bc = x
+        if sign:
+            man = -man
+        absolute_err.append(bc + exp - accuracy)
+        delta = exp - sum_exp
+        if exp >= sum_exp:
+            # x much larger than existing sum?
+            # first: quick test
+            if ((delta > working_prec) and
+                ((not sum_man) or
+                 delta - bitcount(abs(sum_man)) > working_prec)):
+                sum_man = man
+                sum_exp = exp
+            else:
+                sum_man += (man << delta)
+        else:
+            delta = -delta
+            # x much smaller than existing sum?
+            if delta - bc > working_prec:
+                if not sum_man:
+                    sum_man, sum_exp = man, exp
+            else:
+                sum_man = (sum_man << delta) + man
+                sum_exp = exp
+    absolute_error = max(absolute_err)
+    if not sum_man:
+        return scaled_zero(absolute_error)
+    if sum_man < 0:
+        sum_sign = 1
+        sum_man = -sum_man
+    else:
+        sum_sign = 0
+    sum_bc = bitcount(sum_man)
+    sum_accuracy = sum_exp + sum_bc - absolute_error
+    r = normalize(sum_sign, sum_man, sum_exp, sum_bc, target_prec,
+        rnd), sum_accuracy
+    return r
+
+
+def evalf_add(v: 'Add', prec: int, options: OPT_DICT) -> TMP_RES:
+    res = pure_complex(v)
+    if res:
+        h, c = res
+        re, _, re_acc, _ = evalf(h, prec, options)
+        im, _, im_acc, _ = evalf(c, prec, options)
+        return re, im, re_acc, im_acc
+
+    oldmaxprec = options.get('maxprec', DEFAULT_MAXPREC)
+
+    i = 0
+    target_prec = prec
+    while 1:
+        options['maxprec'] = min(oldmaxprec, 2*prec)
+
+        terms = [evalf(arg, prec + 10, options) for arg in v.args]
+        n = terms.count(S.ComplexInfinity)
+        if n >= 2:
+            return fnan, None, prec, None
+        re, re_acc = add_terms(
+            [a[0::2] for a in terms if isinstance(a, tuple) and a[0]], prec, target_prec)
+        im, im_acc = add_terms(
+            [a[1::2] for a in terms if isinstance(a, tuple) and a[1]], prec, target_prec)
+        if n == 1:
+            if re in (finf, fninf, fnan) or im in (finf, fninf, fnan):
+                return fnan, None, prec, None
+            return S.ComplexInfinity
+        acc = complex_accuracy((re, im, re_acc, im_acc))
+        if acc >= target_prec:
+            if options.get('verbose'):
+                print("ADD: wanted", target_prec, "accurate bits, got", re_acc, im_acc)
+            break
+        else:
+            if (prec - target_prec) > options['maxprec']:
+                break
+
+            prec = prec + max(10 + 2**i, target_prec - acc)
+            i += 1
+            if options.get('verbose'):
+                print("ADD: restarting with prec", prec)
+
+    options['maxprec'] = oldmaxprec
+    if iszero(re, scaled=True):
+        re = scaled_zero(re)
+    if iszero(im, scaled=True):
+        im = scaled_zero(im)
+    return re, im, re_acc, im_acc
+
+
+def evalf_mul(v: 'Mul', prec: int, options: OPT_DICT) -> TMP_RES:
+    res = pure_complex(v)
+    if res:
+        # the only pure complex that is a mul is h*I
+        _, h = res
+        im, _, im_acc, _ = evalf(h, prec, options)
+        return None, im, None, im_acc
+    args = list(v.args)
+
+    # see if any argument is NaN or oo and thus warrants a special return
+    has_zero = False
+    special = []
+    from .numbers import Float
+    for arg in args:
+        result = evalf(arg, prec, options)
+        if result is S.ComplexInfinity:
+            special.append(result)
+            continue
+        if result[0] is None:
+            if result[1] is None:
+                has_zero = True
+            continue
+        num = Float._new(result[0], 1)
+        if num is S.NaN:
+            return fnan, None, prec, None
+        if num.is_infinite:
+            special.append(num)
+    if special:
+        if has_zero:
+            return fnan, None, prec, None
+        from .mul import Mul
+        return evalf(Mul(*special), prec + 4, {})
+    if has_zero:
+        return None, None, None, None
+
+    # With guard digits, multiplication in the real case does not destroy
+    # accuracy. This is also true in the complex case when considering the
+    # total accuracy; however accuracy for the real or imaginary parts
+    # separately may be lower.
+    acc = prec
+
+    # XXX: big overestimate
+    working_prec = prec + len(args) + 5
+
+    # Empty product is 1
+    start = man, exp, bc = MPZ(1), 0, 1
+
+    # First, we multiply all pure real or pure imaginary numbers.
+    # direction tells us that the result should be multiplied by
+    # I**direction; all other numbers get put into complex_factors
+    # to be multiplied out after the first phase.
+    last = len(args)
+    direction = 0
+    args.append(S.One)
+    complex_factors = []
+
+    for i, arg in enumerate(args):
+        if i != last and pure_complex(arg):
+            args[-1] = (args[-1]*arg).expand()
+            continue
+        elif i == last and arg is S.One:
+            continue
+        re, im, re_acc, im_acc = evalf(arg, working_prec, options)
+        if re and im:
+            complex_factors.append((re, im, re_acc, im_acc))
+            continue
+        elif re:
+            (s, m, e, b), w_acc = re, re_acc
+        elif im:
+            (s, m, e, b), w_acc = im, im_acc
+            direction += 1
+        else:
+            return None, None, None, None
+        direction += 2*s
+        man *= m
+        exp += e
+        bc += b
+        while bc > 3*working_prec:
+            man >>= working_prec
+            exp += working_prec
+            bc -= working_prec
+        acc = min(acc, w_acc)
+    sign = (direction & 2) >> 1
+    if not complex_factors:
+        v = normalize(sign, man, exp, bitcount(man), prec, rnd)
+        # multiply by i
+        if direction & 1:
+            return None, v, None, acc
+        else:
+            return v, None, acc, None
+    else:
+        # initialize with the first term
+        if (man, exp, bc) != start:
+            # there was a real part; give it an imaginary part
+            re, im = (sign, man, exp, bitcount(man)), (0, MPZ(0), 0, 0)
+            i0 = 0
+        else:
+            # there is no real part to start (other than the starting 1)
+            wre, wim, wre_acc, wim_acc = complex_factors[0]
+            acc = min(acc,
+                      complex_accuracy((wre, wim, wre_acc, wim_acc)))
+            re = wre
+            im = wim
+            i0 = 1
+
+        for wre, wim, wre_acc, wim_acc in complex_factors[i0:]:
+            # acc is the overall accuracy of the product; we aren't
+            # computing exact accuracies of the product.
+            acc = min(acc,
+                      complex_accuracy((wre, wim, wre_acc, wim_acc)))
+
+            use_prec = working_prec
+            A = mpf_mul(re, wre, use_prec)
+            B = mpf_mul(mpf_neg(im), wim, use_prec)
+            C = mpf_mul(re, wim, use_prec)
+            D = mpf_mul(im, wre, use_prec)
+            re = mpf_add(A, B, use_prec)
+            im = mpf_add(C, D, use_prec)
+        if options.get('verbose'):
+            print("MUL: wanted", prec, "accurate bits, got", acc)
+        # multiply by I
+        if direction & 1:
+            re, im = mpf_neg(im), re
+        return re, im, acc, acc
+
+
+def evalf_pow(v: 'Pow', prec: int, options) -> TMP_RES:
+
+    target_prec = prec
+    base, exp = v.args
+
+    # We handle x**n separately. This has two purposes: 1) it is much
+    # faster, because we avoid calling evalf on the exponent, and 2) it
+    # allows better handling of real/imaginary parts that are exactly zero
+    if exp.is_Integer:
+        p: int = exp.p  # type: ignore
+        # Exact
+        if not p:
+            return fone, None, prec, None
+        # Exponentiation by p magnifies relative error by |p|, so the
+        # base must be evaluated with increased precision if p is large
+        prec += int(math.log(abs(p), 2))
+        result = evalf(base, prec + 5, options)
+        if result is S.ComplexInfinity:
+            if p < 0:
+                return None, None, None, None
+            return result
+        re, im, re_acc, im_acc = result
+        # Real to integer power
+        if re and not im:
+            return mpf_pow_int(re, p, target_prec), None, target_prec, None
+        # (x*I)**n = I**n * x**n
+        if im and not re:
+            z = mpf_pow_int(im, p, target_prec)
+            case = p % 4
+            if case == 0:
+                return z, None, target_prec, None
+            if case == 1:
+                return None, z, None, target_prec
+            if case == 2:
+                return mpf_neg(z), None, target_prec, None
+            if case == 3:
+                return None, mpf_neg(z), None, target_prec
+        # Zero raised to an integer power
+        if not re:
+            if p < 0:
+                return S.ComplexInfinity
+            return None, None, None, None
+        # General complex number to arbitrary integer power
+        re, im = libmp.mpc_pow_int((re, im), p, prec)
+        # Assumes full accuracy in input
+        return finalize_complex(re, im, target_prec)
+
+    result = evalf(base, prec + 5, options)
+    if result is S.ComplexInfinity:
+        if exp.is_Rational:
+            if exp < 0:
+                return None, None, None, None
+            return result
+        raise NotImplementedError
+
+    # Pure square root
+    if exp is S.Half:
+        xre, xim, _, _ = result
+        # General complex square root
+        if xim:
+            re, im = libmp.mpc_sqrt((xre or fzero, xim), prec)
+            return finalize_complex(re, im, prec)
+        if not xre:
+            return None, None, None, None
+        # Square root of a negative real number
+        if mpf_lt(xre, fzero):
+            return None, mpf_sqrt(mpf_neg(xre), prec), None, prec
+        # Positive square root
+        return mpf_sqrt(xre, prec), None, prec, None
+
+    # We first evaluate the exponent to find its magnitude
+    # This determines the working precision that must be used
+    prec += 10
+    result = evalf(exp, prec, options)
+    if result is S.ComplexInfinity:
+        return fnan, None, prec, None
+    yre, yim, _, _ = result
+    # Special cases: x**0
+    if not (yre or yim):
+        return fone, None, prec, None
+
+    ysize = fastlog(yre)
+    # Restart if too big
+    # XXX: prec + ysize might exceed maxprec
+    if ysize > 5:
+        prec += ysize
+        yre, yim, _, _ = evalf(exp, prec, options)
+
+    # Pure exponential function; no need to evalf the base
+    if base is S.Exp1:
+        if yim:
+            re, im = libmp.mpc_exp((yre or fzero, yim), prec)
+            return finalize_complex(re, im, target_prec)
+        return mpf_exp(yre, target_prec), None, target_prec, None
+
+    xre, xim, _, _ = evalf(base, prec + 5, options)
+    # 0**y
+    if not (xre or xim):
+        if yim:
+            return fnan, None, prec, None
+        if yre[0] == 1:  # y < 0
+            return S.ComplexInfinity
+        return None, None, None, None
+
+    # (real ** complex) or (complex ** complex)
+    if yim:
+        re, im = libmp.mpc_pow(
+            (xre or fzero, xim or fzero), (yre or fzero, yim),
+            target_prec)
+        return finalize_complex(re, im, target_prec)
+    # complex ** real
+    if xim:
+        re, im = libmp.mpc_pow_mpf((xre or fzero, xim), yre, target_prec)
+        return finalize_complex(re, im, target_prec)
+    # negative ** real
+    elif mpf_lt(xre, fzero):
+        re, im = libmp.mpc_pow_mpf((xre, fzero), yre, target_prec)
+        return finalize_complex(re, im, target_prec)
+    # positive ** real
+    else:
+        return mpf_pow(xre, yre, target_prec), None, target_prec, None
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Special functions                               #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def evalf_exp(expr: 'exp', prec: int, options: OPT_DICT) -> TMP_RES:
+    from .power import Pow
+    return evalf_pow(Pow(S.Exp1, expr.exp, evaluate=False), prec, options)
+
+
+def evalf_trig(v: 'Expr', prec: int, options: OPT_DICT) -> TMP_RES:
+    """
+    This function handles sin and cos of complex arguments.
+
+    TODO: should also handle tan of complex arguments.
+    """
+    from sympy.functions.elementary.trigonometric import cos, sin
+    if isinstance(v, cos):
+        func = mpf_cos
+    elif isinstance(v, sin):
+        func = mpf_sin
+    else:
+        raise NotImplementedError
+    arg = v.args[0]
+    # 20 extra bits is possibly overkill. It does make the need
+    # to restart very unlikely
+    xprec = prec + 20
+    re, im, re_acc, im_acc = evalf(arg, xprec, options)
+    if im:
+        if 'subs' in options:
+            v = v.subs(options['subs'])
+        return evalf(v._eval_evalf(prec), prec, options)
+    if not re:
+        if isinstance(v, cos):
+            return fone, None, prec, None
+        elif isinstance(v, sin):
+            return None, None, None, None
+        else:
+            raise NotImplementedError
+    # For trigonometric functions, we are interested in the
+    # fixed-point (absolute) accuracy of the argument.
+    xsize = fastlog(re)
+    # Magnitude <= 1.0. OK to compute directly, because there is no
+    # danger of hitting the first root of cos (with sin, magnitude
+    # <= 2.0 would actually be ok)
+    if xsize < 1:
+        return func(re, prec, rnd), None, prec, None
+    # Very large
+    if xsize >= 10:
+        xprec = prec + xsize
+        re, im, re_acc, im_acc = evalf(arg, xprec, options)
+    # Need to repeat in case the argument is very close to a
+    # multiple of pi (or pi/2), hitting close to a root
+    while 1:
+        y = func(re, prec, rnd)
+        ysize = fastlog(y)
+        gap = -ysize
+        accuracy = (xprec - xsize) - gap
+        if accuracy < prec:
+            if options.get('verbose'):
+                print("SIN/COS", accuracy, "wanted", prec, "gap", gap)
+                print(to_str(y, 10))
+            if xprec > options.get('maxprec', DEFAULT_MAXPREC):
+                return y, None, accuracy, None
+            xprec += gap
+            re, im, re_acc, im_acc = evalf(arg, xprec, options)
+            continue
+        else:
+            return y, None, prec, None
+
+
+def evalf_log(expr: 'log', prec: int, options: OPT_DICT) -> TMP_RES:
+    if len(expr.args)>1:
+        expr = expr.doit()
+        return evalf(expr, prec, options)
+    arg = expr.args[0]
+    workprec = prec + 10
+    result = evalf(arg, workprec, options)
+    if result is S.ComplexInfinity:
+        return result
+    xre, xim, xacc, _ = result
+
+    # evalf can return NoneTypes if chop=True
+    # issue 18516, 19623
+    if xre is xim is None:
+        # Dear reviewer, I do not know what -inf is;
+        # it looks to be (1, 0, -789, -3)
+        # but I'm not sure in general,
+        # so we just let mpmath figure
+        # it out by taking log of 0 directly.
+        # It would be better to return -inf instead.
+        xre = fzero
+
+    if xim:
+        from sympy.functions.elementary.complexes import Abs
+        from sympy.functions.elementary.exponential import log
+
+        # XXX: use get_abs etc instead
+        re = evalf_log(
+            log(Abs(arg, evaluate=False), evaluate=False), prec, options)
+        im = mpf_atan2(xim, xre or fzero, prec)
+        return re[0], im, re[2], prec
+
+    imaginary_term = (mpf_cmp(xre, fzero) < 0)
+
+    re = mpf_log(mpf_abs(xre), prec, rnd)
+    size = fastlog(re)
+    if prec - size > workprec and re != fzero:
+        from .add import Add
+        # We actually need to compute 1+x accurately, not x
+        add = Add(S.NegativeOne, arg, evaluate=False)
+        xre, xim, _, _ = evalf_add(add, prec, options)
+        prec2 = workprec - fastlog(xre)
+        # xre is now x - 1 so we add 1 back here to calculate x
+        re = mpf_log(mpf_abs(mpf_add(xre, fone, prec2)), prec, rnd)
+
+    re_acc = prec
+
+    if imaginary_term:
+        return re, mpf_pi(prec), re_acc, prec
+    else:
+        return re, None, re_acc, None
+
+
+def evalf_atan(v: 'atan', prec: int, options: OPT_DICT) -> TMP_RES:
+    arg = v.args[0]
+    xre, xim, reacc, imacc = evalf(arg, prec + 5, options)
+    if xre is xim is None:
+        return (None,)*4
+    if xim:
+        raise NotImplementedError
+    return mpf_atan(xre, prec, rnd), None, prec, None
+
+
+def evalf_subs(prec: int, subs: dict) -> dict:
+    """ Change all Float entries in `subs` to have precision prec. """
+    newsubs = {}
+    for a, b in subs.items():
+        b = S(b)
+        if b.is_Float:
+            b = b._eval_evalf(prec)
+        newsubs[a] = b
+    return newsubs
+
+
+def evalf_piecewise(expr: 'Expr', prec: int, options: OPT_DICT) -> TMP_RES:
+    from .numbers import Float, Integer
+    if 'subs' in options:
+        expr = expr.subs(evalf_subs(prec, options['subs']))
+        newopts = options.copy()
+        del newopts['subs']
+        if hasattr(expr, 'func'):
+            return evalf(expr, prec, newopts)
+        if isinstance(expr, float):
+            return evalf(Float(expr), prec, newopts)
+        if isinstance(expr, int):
+            return evalf(Integer(expr), prec, newopts)
+
+    # We still have undefined symbols
+    raise NotImplementedError
+
+
+def evalf_alg_num(a: 'AlgebraicNumber', prec: int, options: OPT_DICT) -> TMP_RES:
+    return evalf(a.to_root(), prec, options)
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            High-level operations                           #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def as_mpmath(x: Any, prec: int, options: OPT_DICT) -> tUnion[mpc, mpf]:
+    from .numbers import Infinity, NegativeInfinity, Zero
+    x = sympify(x)
+    if isinstance(x, Zero) or x == 0.0:
+        return mpf(0)
+    if isinstance(x, Infinity):
+        return mpf('inf')
+    if isinstance(x, NegativeInfinity):
+        return mpf('-inf')
+    # XXX
+    result = evalf(x, prec, options)
+    return quad_to_mpmath(result)
+
+
+def do_integral(expr: 'Integral', prec: int, options: OPT_DICT) -> TMP_RES:
+    func = expr.args[0]
+    x, xlow, xhigh = expr.args[1]
+    if xlow == xhigh:
+        xlow = xhigh = 0
+    elif x not in func.free_symbols:
+        # only the difference in limits matters in this case
+        # so if there is a symbol in common that will cancel
+        # out when taking the difference, then use that
+        # difference
+        if xhigh.free_symbols & xlow.free_symbols:
+            diff = xhigh - xlow
+            if diff.is_number:
+                xlow, xhigh = 0, diff
+
+    oldmaxprec = options.get('maxprec', DEFAULT_MAXPREC)
+    options['maxprec'] = min(oldmaxprec, 2*prec)
+
+    with workprec(prec + 5):
+        xlow = as_mpmath(xlow, prec + 15, options)
+        xhigh = as_mpmath(xhigh, prec + 15, options)
+
+        # Integration is like summation, and we can phone home from
+        # the integrand function to update accuracy summation style
+        # Note that this accuracy is inaccurate, since it fails
+        # to account for the variable quadrature weights,
+        # but it is better than nothing
+
+        from sympy.functions.elementary.trigonometric import cos, sin
+        from .symbol import Wild
+
+        have_part = [False, False]
+        max_real_term: tUnion[float, int] = MINUS_INF
+        max_imag_term: tUnion[float, int] = MINUS_INF
+
+        def f(t: 'Expr') -> tUnion[mpc, mpf]:
+            nonlocal max_real_term, max_imag_term
+            re, im, re_acc, im_acc = evalf(func, mp.prec, {'subs': {x: t}})
+
+            have_part[0] = re or have_part[0]
+            have_part[1] = im or have_part[1]
+
+            max_real_term = max(max_real_term, fastlog(re))
+            max_imag_term = max(max_imag_term, fastlog(im))
+
+            if im:
+                return mpc(re or fzero, im)
+            return mpf(re or fzero)
+
+        if options.get('quad') == 'osc':
+            A = Wild('A', exclude=[x])
+            B = Wild('B', exclude=[x])
+            D = Wild('D')
+            m = func.match(cos(A*x + B)*D)
+            if not m:
+                m = func.match(sin(A*x + B)*D)
+            if not m:
+                raise ValueError("An integrand of the form sin(A*x+B)*f(x) "
+                  "or cos(A*x+B)*f(x) is required for oscillatory quadrature")
+            period = as_mpmath(2*S.Pi/m[A], prec + 15, options)
+            result = quadosc(f, [xlow, xhigh], period=period)
+            # XXX: quadosc does not do error detection yet
+            quadrature_error = MINUS_INF
+        else:
+            result, quadrature_err = quadts(f, [xlow, xhigh], error=1)
+            quadrature_error = fastlog(quadrature_err._mpf_)
+
+    options['maxprec'] = oldmaxprec
+
+    if have_part[0]:
+        re: Optional[MPF_TUP] = result.real._mpf_
+        re_acc: Optional[int]
+        if re == fzero:
+            re_s, re_acc = scaled_zero(int(-max(prec, max_real_term, quadrature_error)))
+            re = scaled_zero(re_s)  # handled ok in evalf_integral
+        else:
+            re_acc = int(-max(max_real_term - fastlog(re) - prec, quadrature_error))
+    else:
+        re, re_acc = None, None
+
+    if have_part[1]:
+        im: Optional[MPF_TUP] = result.imag._mpf_
+        im_acc: Optional[int]
+        if im == fzero:
+            im_s, im_acc = scaled_zero(int(-max(prec, max_imag_term, quadrature_error)))
+            im = scaled_zero(im_s)  # handled ok in evalf_integral
+        else:
+            im_acc = int(-max(max_imag_term - fastlog(im) - prec, quadrature_error))
+    else:
+        im, im_acc = None, None
+
+    result = re, im, re_acc, im_acc
+    return result
+
+
+def evalf_integral(expr: 'Integral', prec: int, options: OPT_DICT) -> TMP_RES:
+    limits = expr.limits
+    if len(limits) != 1 or len(limits[0]) != 3:
+        raise NotImplementedError
+    workprec = prec
+    i = 0
+    maxprec = options.get('maxprec', INF)
+    while 1:
+        result = do_integral(expr, workprec, options)
+        accuracy = complex_accuracy(result)
+        if accuracy >= prec:  # achieved desired precision
+            break
+        if workprec >= maxprec:  # can't increase accuracy any more
+            break
+        if accuracy == -1:
+            # maybe the answer really is zero and maybe we just haven't increased
+            # the precision enough. So increase by doubling to not take too long
+            # to get to maxprec.
+            workprec *= 2
+        else:
+            workprec += max(prec, 2**i)
+        workprec = min(workprec, maxprec)
+        i += 1
+    return result
+
+
+def check_convergence(numer: 'Expr', denom: 'Expr', n: 'Symbol') -> tTuple[int, Any, Any]:
+    """
+    Returns
+    =======
+
+    (h, g, p) where
+    -- h is:
+        > 0 for convergence of rate 1/factorial(n)**h
+        < 0 for divergence of rate factorial(n)**(-h)
+        = 0 for geometric or polynomial convergence or divergence
+
+    -- abs(g) is:
+        > 1 for geometric convergence of rate 1/h**n
+        < 1 for geometric divergence of rate h**n
+        = 1 for polynomial convergence or divergence
+
+        (g < 0 indicates an alternating series)
+
+    -- p is:
+        > 1 for polynomial convergence of rate 1/n**h
+        <= 1 for polynomial divergence of rate n**(-h)
+
+    """
+    from sympy.polys.polytools import Poly
+    npol = Poly(numer, n)
+    dpol = Poly(denom, n)
+    p = npol.degree()
+    q = dpol.degree()
+    rate = q - p
+    if rate:
+        return rate, None, None
+    constant = dpol.LC() / npol.LC()
+    from .numbers import equal_valued
+    if not equal_valued(abs(constant), 1):
+        return rate, constant, None
+    if npol.degree() == dpol.degree() == 0:
+        return rate, constant, 0
+    pc = npol.all_coeffs()[1]
+    qc = dpol.all_coeffs()[1]
+    return rate, constant, (qc - pc)/dpol.LC()
+
+
+def hypsum(expr: 'Expr', n: 'Symbol', start: int, prec: int) -> mpf:
+    """
+    Sum a rapidly convergent infinite hypergeometric series with
+    given general term, e.g. e = hypsum(1/factorial(n), n). The
+    quotient between successive terms must be a quotient of integer
+    polynomials.
+    """
+    from .numbers import Float, equal_valued
+    from sympy.simplify.simplify import hypersimp
+
+    if prec == float('inf'):
+        raise NotImplementedError('does not support inf prec')
+
+    if start:
+        expr = expr.subs(n, n + start)
+    hs = hypersimp(expr, n)
+    if hs is None:
+        raise NotImplementedError("a hypergeometric series is required")
+    num, den = hs.as_numer_denom()
+
+    func1 = lambdify(n, num)
+    func2 = lambdify(n, den)
+
+    h, g, p = check_convergence(num, den, n)
+
+    if h < 0:
+        raise ValueError("Sum diverges like (n!)^%i" % (-h))
+
+    term = expr.subs(n, 0)
+    if not term.is_Rational:
+        raise NotImplementedError("Non rational term functionality is not implemented.")
+
+    # Direct summation if geometric or faster
+    if h > 0 or (h == 0 and abs(g) > 1):
+        term = (MPZ(term.p) << prec) // term.q
+        s = term
+        k = 1
+        while abs(term) > 5:
+            term *= MPZ(func1(k - 1))
+            term //= MPZ(func2(k - 1))
+            s += term
+            k += 1
+        return from_man_exp(s, -prec)
+    else:
+        alt = g < 0
+        if abs(g) < 1:
+            raise ValueError("Sum diverges like (%i)^n" % abs(1/g))
+        if p < 1 or (equal_valued(p, 1) and not alt):
+            raise ValueError("Sum diverges like n^%i" % (-p))
+        # We have polynomial convergence: use Richardson extrapolation
+        vold = None
+        ndig = prec_to_dps(prec)
+        while True:
+            # Need to use at least quad precision because a lot of cancellation
+            # might occur in the extrapolation process; we check the answer to
+            # make sure that the desired precision has been reached, too.
+            prec2 = 4*prec
+            term0 = (MPZ(term.p) << prec2) // term.q
+
+            def summand(k, _term=[term0]):
+                if k:
+                    k = int(k)
+                    _term[0] *= MPZ(func1(k - 1))
+                    _term[0] //= MPZ(func2(k - 1))
+                return make_mpf(from_man_exp(_term[0], -prec2))
+
+            with workprec(prec):
+                v = nsum(summand, [0, mpmath_inf], method='richardson')
+            vf = Float(v, ndig)
+            if vold is not None and vold == vf:
+                break
+            prec += prec  # double precision each time
+            vold = vf
+
+        return v._mpf_
+
+
+def evalf_prod(expr: 'Product', prec: int, options: OPT_DICT) -> TMP_RES:
+    if all((l[1] - l[2]).is_Integer for l in expr.limits):
+        result = evalf(expr.doit(), prec=prec, options=options)
+    else:
+        from sympy.concrete.summations import Sum
+        result = evalf(expr.rewrite(Sum), prec=prec, options=options)
+    return result
+
+
+def evalf_sum(expr: 'Sum', prec: int, options: OPT_DICT) -> TMP_RES:
+    from .numbers import Float
+    if 'subs' in options:
+        expr = expr.subs(options['subs'])
+    func = expr.function
+    limits = expr.limits
+    if len(limits) != 1 or len(limits[0]) != 3:
+        raise NotImplementedError
+    if func.is_zero:
+        return None, None, prec, None
+    prec2 = prec + 10
+    try:
+        n, a, b = limits[0]
+        if b is not S.Infinity or a is S.NegativeInfinity or a != int(a):
+            raise NotImplementedError
+        # Use fast hypergeometric summation if possible
+        v = hypsum(func, n, int(a), prec2)
+        delta = prec - fastlog(v)
+        if fastlog(v) < -10:
+            v = hypsum(func, n, int(a), delta)
+        return v, None, min(prec, delta), None
+    except NotImplementedError:
+        # Euler-Maclaurin summation for general series
+        eps = Float(2.0)**(-prec)
+        for i in range(1, 5):
+            m = n = 2**i * prec
+            s, err = expr.euler_maclaurin(m=m, n=n, eps=eps,
+                eval_integral=False)
+            err = err.evalf()
+            if err is S.NaN:
+                raise NotImplementedError
+            if err <= eps:
+                break
+        err = fastlog(evalf(abs(err), 20, options)[0])
+        re, im, re_acc, im_acc = evalf(s, prec2, options)
+        if re_acc is None:
+            re_acc = -err
+        if im_acc is None:
+            im_acc = -err
+        return re, im, re_acc, im_acc
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Symbolic interface                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def evalf_symbol(x: 'Expr', prec: int, options: OPT_DICT) -> TMP_RES:
+    val = options['subs'][x]
+    if isinstance(val, mpf):
+        if not val:
+            return None, None, None, None
+        return val._mpf_, None, prec, None
+    else:
+        if '_cache' not in options:
+            options['_cache'] = {}
+        cache = options['_cache']
+        cached, cached_prec = cache.get(x, (None, MINUS_INF))
+        if cached_prec >= prec:
+            return cached
+        v = evalf(sympify(val), prec, options)
+        cache[x] = (v, prec)
+        return v
+
+
+evalf_table: tDict[Type['Expr'], Callable[['Expr', int, OPT_DICT], TMP_RES]] = {}
+
+
+def _create_evalf_table():
+    global evalf_table
+    from sympy.concrete.products import Product
+    from sympy.concrete.summations import Sum
+    from .add import Add
+    from .mul import Mul
+    from .numbers import Exp1, Float, Half, ImaginaryUnit, Integer, NaN, NegativeOne, One, Pi, Rational, \
+        Zero, ComplexInfinity, AlgebraicNumber
+    from .power import Pow
+    from .symbol import Dummy, Symbol
+    from sympy.functions.elementary.complexes import Abs, im, re
+    from sympy.functions.elementary.exponential import exp, log
+    from sympy.functions.elementary.integers import ceiling, floor
+    from sympy.functions.elementary.piecewise import Piecewise
+    from sympy.functions.elementary.trigonometric import atan, cos, sin
+    from sympy.integrals.integrals import Integral
+    evalf_table = {
+        Symbol: evalf_symbol,
+        Dummy: evalf_symbol,
+        Float: evalf_float,
+        Rational: evalf_rational,
+        Integer: evalf_integer,
+        Zero: lambda x, prec, options: (None, None, prec, None),
+        One: lambda x, prec, options: (fone, None, prec, None),
+        Half: lambda x, prec, options: (fhalf, None, prec, None),
+        Pi: lambda x, prec, options: (mpf_pi(prec), None, prec, None),
+        Exp1: lambda x, prec, options: (mpf_e(prec), None, prec, None),
+        ImaginaryUnit: lambda x, prec, options: (None, fone, None, prec),
+        NegativeOne: lambda x, prec, options: (fnone, None, prec, None),
+        ComplexInfinity: lambda x, prec, options: S.ComplexInfinity,
+        NaN: lambda x, prec, options: (fnan, None, prec, None),
+
+        exp: evalf_exp,
+
+        cos: evalf_trig,
+        sin: evalf_trig,
+
+        Add: evalf_add,
+        Mul: evalf_mul,
+        Pow: evalf_pow,
+
+        log: evalf_log,
+        atan: evalf_atan,
+        Abs: evalf_abs,
+
+        re: evalf_re,
+        im: evalf_im,
+        floor: evalf_floor,
+        ceiling: evalf_ceiling,
+
+        Integral: evalf_integral,
+        Sum: evalf_sum,
+        Product: evalf_prod,
+        Piecewise: evalf_piecewise,
+
+        AlgebraicNumber: evalf_alg_num,
+    }
+
+
+def evalf(x: 'Expr', prec: int, options: OPT_DICT) -> TMP_RES:
+    """
+    Evaluate the ``Expr`` instance, ``x``
+    to a binary precision of ``prec``. This
+    function is supposed to be used internally.
+
+    Parameters
+    ==========
+
+    x : Expr
+        The formula to evaluate to a float.
+    prec : int
+        The binary precision that the output should have.
+    options : dict
+        A dictionary with the same entries as
+        ``EvalfMixin.evalf`` and in addition,
+        ``maxprec`` which is the maximum working precision.
+
+    Returns
+    =======
+
+    An optional tuple, ``(re, im, re_acc, im_acc)``
+    which are the real, imaginary, real accuracy
+    and imaginary accuracy respectively. ``re`` is
+    an mpf value tuple and so is ``im``. ``re_acc``
+    and ``im_acc`` are ints.
+
+    NB: all these return values can be ``None``.
+    If all values are ``None``, then that represents 0.
+    Note that 0 is also represented as ``fzero = (0, 0, 0, 0)``.
+    """
+    from sympy.functions.elementary.complexes import re as re_, im as im_
+    try:
+        rf = evalf_table[type(x)]
+        r = rf(x, prec, options)
+    except KeyError:
+        # Fall back to ordinary evalf if possible
+        if 'subs' in options:
+            x = x.subs(evalf_subs(prec, options['subs']))
+        xe = x._eval_evalf(prec)
+        if xe is None:
+            raise NotImplementedError
+        as_real_imag = getattr(xe, "as_real_imag", None)
+        if as_real_imag is None:
+            raise NotImplementedError # e.g. FiniteSet(-1.0, 1.0).evalf()
+        re, im = as_real_imag()
+        if re.has(re_) or im.has(im_):
+            raise NotImplementedError
+        if re == 0.0:
+            re = None
+            reprec = None
+        elif re.is_number:
+            re = re._to_mpmath(prec, allow_ints=False)._mpf_
+            reprec = prec
+        else:
+            raise NotImplementedError
+        if im == 0.0:
+            im = None
+            imprec = None
+        elif im.is_number:
+            im = im._to_mpmath(prec, allow_ints=False)._mpf_
+            imprec = prec
+        else:
+            raise NotImplementedError
+        r = re, im, reprec, imprec
+
+    if options.get("verbose"):
+        print("### input", x)
+        print("### output", to_str(r[0] or fzero, 50) if isinstance(r, tuple) else r)
+        print("### raw", r) # r[0], r[2]
+        print()
+    chop = options.get('chop', False)
+    if chop:
+        if chop is True:
+            chop_prec = prec
+        else:
+            # convert (approximately) from given tolerance;
+            # the formula here will will make 1e-i rounds to 0 for
+            # i in the range +/-27 while 2e-i will not be chopped
+            chop_prec = int(round(-3.321*math.log10(chop) + 2.5))
+            if chop_prec == 3:
+                chop_prec -= 1
+        r = chop_parts(r, chop_prec)
+    if options.get("strict"):
+        check_target(x, r, prec)
+    return r
+
+
+def quad_to_mpmath(q, ctx=None):
+    """Turn the quad returned by ``evalf`` into an ``mpf`` or ``mpc``. """
+    mpc = make_mpc if ctx is None else ctx.make_mpc
+    mpf = make_mpf if ctx is None else ctx.make_mpf
+    if q is S.ComplexInfinity:
+        raise NotImplementedError
+    re, im, _, _ = q
+    if im:
+        if not re:
+            re = fzero
+        return mpc((re, im))
+    elif re:
+        return mpf(re)
+    else:
+        return mpf(fzero)
+
+
+class EvalfMixin:
+    """Mixin class adding evalf capability."""
+
+    __slots__ = ()  # type: tTuple[str, ...]
+
+    def evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False):
+        """
+        Evaluate the given formula to an accuracy of *n* digits.
+
+        Parameters
+        ==========
+
+        subs : dict, optional
+            Substitute numerical values for symbols, e.g.
+            ``subs={x:3, y:1+pi}``. The substitutions must be given as a
+            dictionary.
+
+        maxn : int, optional
+            Allow a maximum temporary working precision of maxn digits.
+
+        chop : bool or number, optional
+            Specifies how to replace tiny real or imaginary parts in
+            subresults by exact zeros.
+
+            When ``True`` the chop value defaults to standard precision.
+
+            Otherwise the chop value is used to determine the
+            magnitude of "small" for purposes of chopping.
+
+            >>> from sympy import N
+            >>> x = 1e-4
+            >>> N(x, chop=True)
+            0.000100000000000000
+            >>> N(x, chop=1e-5)
+            0.000100000000000000
+            >>> N(x, chop=1e-4)
+            0
+
+        strict : bool, optional
+            Raise ``PrecisionExhausted`` if any subresult fails to
+            evaluate to full accuracy, given the available maxprec.
+
+        quad : str, optional
+            Choose algorithm for numerical quadrature. By default,
+            tanh-sinh quadrature is used. For oscillatory
+            integrals on an infinite interval, try ``quad='osc'``.
+
+        verbose : bool, optional
+            Print debug information.
+
+        Notes
+        =====
+
+        When Floats are naively substituted into an expression,
+        precision errors may adversely affect the result. For example,
+        adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is
+        then subtracted, the result will be 0.
+        That is exactly what happens in the following:
+
+        >>> from sympy.abc import x, y, z
+        >>> values = {x: 1e16, y: 1, z: 1e16}
+        >>> (x + y - z).subs(values)
+        0
+
+        Using the subs argument for evalf is the accurate way to
+        evaluate such an expression:
+
+        >>> (x + y - z).evalf(subs=values)
+        1.00000000000000
+        """
+        from .numbers import Float, Number
+        n = n if n is not None else 15
+
+        if subs and is_sequence(subs):
+            raise TypeError('subs must be given as a dictionary')
+
+        # for sake of sage that doesn't like evalf(1)
+        if n == 1 and isinstance(self, Number):
+            from .expr import _mag
+            rv = self.evalf(2, subs, maxn, chop, strict, quad, verbose)
+            m = _mag(rv)
+            rv = rv.round(1 - m)
+            return rv
+
+        if not evalf_table:
+            _create_evalf_table()
+        prec = dps_to_prec(n)
+        options = {'maxprec': max(prec, int(maxn*LG10)), 'chop': chop,
+               'strict': strict, 'verbose': verbose}
+        if subs is not None:
+            options['subs'] = subs
+        if quad is not None:
+            options['quad'] = quad
+        try:
+            result = evalf(self, prec + 4, options)
+        except NotImplementedError:
+            # Fall back to the ordinary evalf
+            if hasattr(self, 'subs') and subs is not None:  # issue 20291
+                v = self.subs(subs)._eval_evalf(prec)
+            else:
+                v = self._eval_evalf(prec)
+            if v is None:
+                return self
+            elif not v.is_number:
+                return v
+            try:
+                # If the result is numerical, normalize it
+                result = evalf(v, prec, options)
+            except NotImplementedError:
+                # Probably contains symbols or unknown functions
+                return v
+        if result is S.ComplexInfinity:
+            return result
+        re, im, re_acc, im_acc = result
+        if re is S.NaN or im is S.NaN:
+            return S.NaN
+        if re:
+            p = max(min(prec, re_acc), 1)
+            re = Float._new(re, p)
+        else:
+            re = S.Zero
+        if im:
+            p = max(min(prec, im_acc), 1)
+            im = Float._new(im, p)
+            return re + im*S.ImaginaryUnit
+        else:
+            return re
+
+    n = evalf
+
+    def _evalf(self, prec):
+        """Helper for evalf. Does the same thing but takes binary precision"""
+        r = self._eval_evalf(prec)
+        if r is None:
+            r = self
+        return r
+
+    def _eval_evalf(self, prec):
+        return
+
+    def _to_mpmath(self, prec, allow_ints=True):
+        # mpmath functions accept ints as input
+        errmsg = "cannot convert to mpmath number"
+        if allow_ints and self.is_Integer:
+            return self.p
+        if hasattr(self, '_as_mpf_val'):
+            return make_mpf(self._as_mpf_val(prec))
+        try:
+            result = evalf(self, prec, {})
+            return quad_to_mpmath(result)
+        except NotImplementedError:
+            v = self._eval_evalf(prec)
+            if v is None:
+                raise ValueError(errmsg)
+            if v.is_Float:
+                return make_mpf(v._mpf_)
+            # Number + Number*I is also fine
+            re, im = v.as_real_imag()
+            if allow_ints and re.is_Integer:
+                re = from_int(re.p)
+            elif re.is_Float:
+                re = re._mpf_
+            else:
+                raise ValueError(errmsg)
+            if allow_ints and im.is_Integer:
+                im = from_int(im.p)
+            elif im.is_Float:
+                im = im._mpf_
+            else:
+                raise ValueError(errmsg)
+            return make_mpc((re, im))
+
+
+def N(x, n=15, **options):
+    r"""
+    Calls x.evalf(n, \*\*options).
+
+    Explanations
+    ============
+
+    Both .n() and N() are equivalent to .evalf(); use the one that you like better.
+    See also the docstring of .evalf() for information on the options.
+
+    Examples
+    ========
+
+    >>> from sympy import Sum, oo, N
+    >>> from sympy.abc import k
+    >>> Sum(1/k**k, (k, 1, oo))
+    Sum(k**(-k), (k, 1, oo))
+    >>> N(_, 4)
+    1.291
+
+    """
+    # by using rational=True, any evaluation of a string
+    # will be done using exact values for the Floats
+    return sympify(x, rational=True).evalf(n, **options)
+
+
+def _evalf_with_bounded_error(x: 'Expr', eps: 'Optional[Expr]' = None,
+                              m: int = 0,
+                              options: Optional[OPT_DICT] = None) -> TMP_RES:
+    """
+    Evaluate *x* to within a bounded absolute error.
+
+    Parameters
+    ==========
+
+    x : Expr
+        The quantity to be evaluated.
+    eps : Expr, None, optional (default=None)
+        Positive real upper bound on the acceptable error.
+    m : int, optional (default=0)
+        If *eps* is None, then use 2**(-m) as the upper bound on the error.
+    options: OPT_DICT
+        As in the ``evalf`` function.
+
+    Returns
+    =======
+
+    A tuple ``(re, im, re_acc, im_acc)``, as returned by ``evalf``.
+
+    See Also
+    ========
+
+    evalf
+
+    """
+    if eps is not None:
+        if not (eps.is_Rational or eps.is_Float) or not eps > 0:
+            raise ValueError("eps must be positive")
+        r, _, _, _ = evalf(1/eps, 1, {})
+        m = fastlog(r)
+
+    c, d, _, _ = evalf(x, 1, {})
+    # Note: If x = a + b*I, then |a| <= 2|c| and |b| <= 2|d|, with equality
+    # only in the zero case.
+    # If a is non-zero, then |c| = 2**nc for some integer nc, and c has
+    # bitcount 1. Therefore 2**fastlog(c) = 2**(nc+1) = 2|c| is an upper bound
+    # on |a|. Likewise for b and d.
+    nr, ni = fastlog(c), fastlog(d)
+    n = max(nr, ni) + 1
+    # If x is 0, then n is MINUS_INF, and p will be 1. Otherwise,
+    # n - 1 bits get us past the integer parts of a and b, and +1 accounts for
+    # the factor of <= sqrt(2) that is |x|/max(|a|, |b|).
+    p = max(1, m + n + 1)
+
+    options = options or {}
+    return evalf(x, p, options)

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

@@ -0,0 +1,1569 @@
+"""Tools for manipulating of large commutative expressions. """
+
+from .add import Add
+from .mul import Mul, _keep_coeff
+from .power import Pow
+from .basic import Basic
+from .expr import Expr
+from .function import expand_power_exp
+from .sympify import sympify
+from .numbers import Rational, Integer, Number, I, equal_valued
+from .singleton import S
+from .sorting import default_sort_key, ordered
+from .symbol import Dummy
+from .traversal import preorder_traversal
+from .coreerrors import NonCommutativeExpression
+from .containers import Tuple, Dict
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.utilities.iterables import (common_prefix, common_suffix,
+        variations, iterable, is_sequence)
+
+from collections import defaultdict
+from typing import Tuple as tTuple
+
+
+_eps = Dummy(positive=True)
+
+
+def _isnumber(i):
+    return isinstance(i, (SYMPY_INTS, float)) or i.is_Number
+
+
+def _monotonic_sign(self):
+    """Return the value closest to 0 that ``self`` may have if all symbols
+    are signed and the result is uniformly the same sign for all values of symbols.
+    If a symbol is only signed but not known to be an
+    integer or the result is 0 then a symbol representative of the sign of self
+    will be returned. Otherwise, None is returned if a) the sign could be positive
+    or negative or b) self is not in one of the following forms:
+
+    - L(x, y, ...) + A: a function linear in all symbols x, y, ... with an
+      additive constant; if A is zero then the function can be a monomial whose
+      sign is monotonic over the range of the variables, e.g. (x + 1)**3 if x is
+      nonnegative.
+    - A/L(x, y, ...) + B: the inverse of a function linear in all symbols x, y, ...
+      that does not have a sign change from positive to negative for any set
+      of values for the variables.
+    - M(x, y, ...) + A: a monomial M whose factors are all signed and a constant, A.
+    - A/M(x, y, ...) + B: the inverse of a monomial and constants A and B.
+    - P(x): a univariate polynomial
+
+    Examples
+    ========
+
+    >>> from sympy.core.exprtools import _monotonic_sign as F
+    >>> from sympy import Dummy
+    >>> nn = Dummy(integer=True, nonnegative=True)
+    >>> p = Dummy(integer=True, positive=True)
+    >>> p2 = Dummy(integer=True, positive=True)
+    >>> F(nn + 1)
+    1
+    >>> F(p - 1)
+    _nneg
+    >>> F(nn*p + 1)
+    1
+    >>> F(p2*p + 1)
+    2
+    >>> F(nn - 1)  # could be negative, zero or positive
+    """
+    if not self.is_extended_real:
+        return
+
+    if (-self).is_Symbol:
+        rv = _monotonic_sign(-self)
+        return rv if rv is None else -rv
+
+    if not self.is_Add and self.as_numer_denom()[1].is_number:
+        s = self
+        if s.is_prime:
+            if s.is_odd:
+                return Integer(3)
+            else:
+                return Integer(2)
+        elif s.is_composite:
+            if s.is_odd:
+                return Integer(9)
+            else:
+                return Integer(4)
+        elif s.is_positive:
+            if s.is_even:
+                if s.is_prime is False:
+                    return Integer(4)
+                else:
+                    return Integer(2)
+            elif s.is_integer:
+                return S.One
+            else:
+                return _eps
+        elif s.is_extended_negative:
+            if s.is_even:
+                return Integer(-2)
+            elif s.is_integer:
+                return S.NegativeOne
+            else:
+                return -_eps
+        if s.is_zero or s.is_extended_nonpositive or s.is_extended_nonnegative:
+            return S.Zero
+        return None
+
+    # univariate polynomial
+    free = self.free_symbols
+    if len(free) == 1:
+        if self.is_polynomial():
+            from sympy.polys.polytools import real_roots
+            from sympy.polys.polyroots import roots
+            from sympy.polys.polyerrors import PolynomialError
+            x = free.pop()
+            x0 = _monotonic_sign(x)
+            if x0 in (_eps, -_eps):
+                x0 = S.Zero
+            if x0 is not None:
+                d = self.diff(x)
+                if d.is_number:
+                    currentroots = []
+                else:
+                    try:
+                        currentroots = real_roots(d)
+                    except (PolynomialError, NotImplementedError):
+                        currentroots = [r for r in roots(d, x) if r.is_extended_real]
+                y = self.subs(x, x0)
+                if x.is_nonnegative and all(
+                        (r - x0).is_nonpositive for r in currentroots):
+                    if y.is_nonnegative and d.is_positive:
+                        if y:
+                            return y if y.is_positive else Dummy('pos', positive=True)
+                        else:
+                            return Dummy('nneg', nonnegative=True)
+                    if y.is_nonpositive and d.is_negative:
+                        if y:
+                            return y if y.is_negative else Dummy('neg', negative=True)
+                        else:
+                            return Dummy('npos', nonpositive=True)
+                elif x.is_nonpositive and all(
+                        (r - x0).is_nonnegative for r in currentroots):
+                    if y.is_nonnegative and d.is_negative:
+                        if y:
+                            return Dummy('pos', positive=True)
+                        else:
+                            return Dummy('nneg', nonnegative=True)
+                    if y.is_nonpositive and d.is_positive:
+                        if y:
+                            return Dummy('neg', negative=True)
+                        else:
+                            return Dummy('npos', nonpositive=True)
+        else:
+            n, d = self.as_numer_denom()
+            den = None
+            if n.is_number:
+                den = _monotonic_sign(d)
+            elif not d.is_number:
+                if _monotonic_sign(n) is not None:
+                    den = _monotonic_sign(d)
+            if den is not None and (den.is_positive or den.is_negative):
+                v = n*den
+                if v.is_positive:
+                    return Dummy('pos', positive=True)
+                elif v.is_nonnegative:
+                    return Dummy('nneg', nonnegative=True)
+                elif v.is_negative:
+                    return Dummy('neg', negative=True)
+                elif v.is_nonpositive:
+                    return Dummy('npos', nonpositive=True)
+        return None
+
+    # multivariate
+    c, a = self.as_coeff_Add()
+    v = None
+    if not a.is_polynomial():
+        # F/A or A/F where A is a number and F is a signed, rational monomial
+        n, d = a.as_numer_denom()
+        if not (n.is_number or d.is_number):
+            return
+        if (
+                a.is_Mul or a.is_Pow) and \
+                a.is_rational and \
+                all(p.exp.is_Integer for p in a.atoms(Pow) if p.is_Pow) and \
+                (a.is_positive or a.is_negative):
+            v = S.One
+            for ai in Mul.make_args(a):
+                if ai.is_number:
+                    v *= ai
+                    continue
+                reps = {}
+                for x in ai.free_symbols:
+                    reps[x] = _monotonic_sign(x)
+                    if reps[x] is None:
+                        return
+                v *= ai.subs(reps)
+    elif c:
+        # signed linear expression
+        if not any(p for p in a.atoms(Pow) if not p.is_number) and (a.is_nonpositive or a.is_nonnegative):
+            free = list(a.free_symbols)
+            p = {}
+            for i in free:
+                v = _monotonic_sign(i)
+                if v is None:
+                    return
+                p[i] = v or (_eps if i.is_nonnegative else -_eps)
+            v = a.xreplace(p)
+    if v is not None:
+        rv = v + c
+        if v.is_nonnegative and rv.is_positive:
+            return rv.subs(_eps, 0)
+        if v.is_nonpositive and rv.is_negative:
+            return rv.subs(_eps, 0)
+
+
+def decompose_power(expr: Expr) -> tTuple[Expr, int]:
+    """
+    Decompose power into symbolic base and integer exponent.
+
+    Examples
+    ========
+
+    >>> from sympy.core.exprtools import decompose_power
+    >>> from sympy.abc import x, y
+    >>> from sympy import exp
+
+    >>> decompose_power(x)
+    (x, 1)
+    >>> decompose_power(x**2)
+    (x, 2)
+    >>> decompose_power(exp(2*y/3))
+    (exp(y/3), 2)
+
+    """
+    base, exp = expr.as_base_exp()
+
+    if exp.is_Number:
+        if exp.is_Rational:
+            if not exp.is_Integer:
+                base = Pow(base, Rational(1, exp.q))  # type: ignore
+            e = exp.p  # type: ignore
+        else:
+            base, e = expr, 1
+    else:
+        exp, tail = exp.as_coeff_Mul(rational=True)
+
+        if exp is S.NegativeOne:
+            base, e = Pow(base, tail), -1
+        elif exp is not S.One:
+            # todo: after dropping python 3.7 support, use overload and Literal
+            #  in as_coeff_Mul to make exp Rational, and remove these 2 ignores
+            tail = _keep_coeff(Rational(1, exp.q), tail)  # type: ignore
+            base, e = Pow(base, tail), exp.p  # type: ignore
+        else:
+            base, e = expr, 1
+
+    return base, e
+
+
+def decompose_power_rat(expr: Expr) -> tTuple[Expr, Rational]:
+    """
+    Decompose power into symbolic base and rational exponent;
+    if the exponent is not a Rational, then separate only the
+    integer coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.core.exprtools import decompose_power_rat
+    >>> from sympy.abc import x
+    >>> from sympy import sqrt, exp
+
+    >>> decompose_power_rat(sqrt(x))
+    (x, 1/2)
+    >>> decompose_power_rat(exp(-3*x/2))
+    (exp(x/2), -3)
+
+    """
+    _ = base, exp = expr.as_base_exp()
+    return _ if exp.is_Rational else decompose_power(expr)
+
+
+class Factors:
+    """Efficient representation of ``f_1*f_2*...*f_n``."""
+
+    __slots__ = ('factors', 'gens')
+
+    def __init__(self, factors=None):  # Factors
+        """Initialize Factors from dict or expr.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x
+        >>> from sympy import I
+        >>> e = 2*x**3
+        >>> Factors(e)
+        Factors({2: 1, x: 3})
+        >>> Factors(e.as_powers_dict())
+        Factors({2: 1, x: 3})
+        >>> f = _
+        >>> f.factors  # underlying dictionary
+        {2: 1, x: 3}
+        >>> f.gens  # base of each factor
+        frozenset({2, x})
+        >>> Factors(0)
+        Factors({0: 1})
+        >>> Factors(I)
+        Factors({I: 1})
+
+        Notes
+        =====
+
+        Although a dictionary can be passed, only minimal checking is
+        performed: powers of -1 and I are made canonical.
+
+        """
+        if isinstance(factors, (SYMPY_INTS, float)):
+            factors = S(factors)
+        if isinstance(factors, Factors):
+            factors = factors.factors.copy()
+        elif factors in (None, S.One):
+            factors = {}
+        elif factors is S.Zero or factors == 0:
+            factors = {S.Zero: S.One}
+        elif isinstance(factors, Number):
+            n = factors
+            factors = {}
+            if n < 0:
+                factors[S.NegativeOne] = S.One
+                n = -n
+            if n is not S.One:
+                if n.is_Float or n.is_Integer or n is S.Infinity:
+                    factors[n] = S.One
+                elif n.is_Rational:
+                    # since we're processing Numbers, the denominator is
+                    # stored with a negative exponent; all other factors
+                    # are left .
+                    if n.p != 1:
+                        factors[Integer(n.p)] = S.One
+                    factors[Integer(n.q)] = S.NegativeOne
+                else:
+                    raise ValueError('Expected Float|Rational|Integer, not %s' % n)
+        elif isinstance(factors, Basic) and not factors.args:
+            factors = {factors: S.One}
+        elif isinstance(factors, Expr):
+            c, nc = factors.args_cnc()
+            i = c.count(I)
+            for _ in range(i):
+                c.remove(I)
+            factors = dict(Mul._from_args(c).as_powers_dict())
+            # Handle all rational Coefficients
+            for f in list(factors.keys()):
+                if isinstance(f, Rational) and not isinstance(f, Integer):
+                    p, q = Integer(f.p), Integer(f.q)
+                    factors[p] = (factors[p] if p in factors else S.Zero) + factors[f]
+                    factors[q] = (factors[q] if q in factors else S.Zero) - factors[f]
+                    factors.pop(f)
+            if i:
+                factors[I] = factors.get(I, S.Zero) + i
+            if nc:
+                factors[Mul(*nc, evaluate=False)] = S.One
+        else:
+            factors = factors.copy()  # /!\ should be dict-like
+
+            # tidy up -/+1 and I exponents if Rational
+
+            handle = [k for k in factors if k is I or k in (-1, 1)]
+            if handle:
+                i1 = S.One
+                for k in handle:
+                    if not _isnumber(factors[k]):
+                        continue
+                    i1 *= k**factors.pop(k)
+                if i1 is not S.One:
+                    for a in i1.args if i1.is_Mul else [i1]:  # at worst, -1.0*I*(-1)**e
+                        if a is S.NegativeOne:
+                            factors[a] = S.One
+                        elif a is I:
+                            factors[I] = S.One
+                        elif a.is_Pow:
+                            factors[a.base] = factors.get(a.base, S.Zero) + a.exp
+                        elif equal_valued(a, 1):
+                            factors[a] = S.One
+                        elif equal_valued(a, -1):
+                            factors[-a] = S.One
+                            factors[S.NegativeOne] = S.One
+                        else:
+                            raise ValueError('unexpected factor in i1: %s' % a)
+
+        self.factors = factors
+        keys = getattr(factors, 'keys', None)
+        if keys is None:
+            raise TypeError('expecting Expr or dictionary')
+        self.gens = frozenset(keys())
+
+    def __hash__(self):  # Factors
+        keys = tuple(ordered(self.factors.keys()))
+        values = [self.factors[k] for k in keys]
+        return hash((keys, values))
+
+    def __repr__(self):  # Factors
+        return "Factors({%s})" % ', '.join(
+            ['%s: %s' % (k, v) for k, v in ordered(self.factors.items())])
+
+    @property
+    def is_zero(self):  # Factors
+        """
+        >>> from sympy.core.exprtools import Factors
+        >>> Factors(0).is_zero
+        True
+        """
+        f = self.factors
+        return len(f) == 1 and S.Zero in f
+
+    @property
+    def is_one(self):  # Factors
+        """
+        >>> from sympy.core.exprtools import Factors
+        >>> Factors(1).is_one
+        True
+        """
+        return not self.factors
+
+    def as_expr(self):  # Factors
+        """Return the underlying expression.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y
+        >>> Factors((x*y**2).as_powers_dict()).as_expr()
+        x*y**2
+
+        """
+
+        args = []
+        for factor, exp in self.factors.items():
+            if exp != 1:
+                if isinstance(exp, Integer):
+                    b, e = factor.as_base_exp()
+                    e = _keep_coeff(exp, e)
+                    args.append(b**e)
+                else:
+                    args.append(factor**exp)
+            else:
+                args.append(factor)
+        return Mul(*args)
+
+    def mul(self, other):  # Factors
+        """Return Factors of ``self * other``.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.mul(b)
+        Factors({x: 2, y: 3, z: -1})
+        >>> a*b
+        Factors({x: 2, y: 3, z: -1})
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+        if any(f.is_zero for f in (self, other)):
+            return Factors(S.Zero)
+        factors = dict(self.factors)
+
+        for factor, exp in other.factors.items():
+            if factor in factors:
+                exp = factors[factor] + exp
+
+                if not exp:
+                    del factors[factor]
+                    continue
+
+            factors[factor] = exp
+
+        return Factors(factors)
+
+    def normal(self, other):
+        """Return ``self`` and ``other`` with ``gcd`` removed from each.
+        The only differences between this and method ``div`` is that this
+        is 1) optimized for the case when there are few factors in common and
+        2) this does not raise an error if ``other`` is zero.
+
+        See Also
+        ========
+        div
+
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if other.is_zero:
+                return (Factors(), Factors(S.Zero))
+            if self.is_zero:
+                return (Factors(S.Zero), Factors())
+
+        self_factors = dict(self.factors)
+        other_factors = dict(other.factors)
+
+        for factor, self_exp in self.factors.items():
+            try:
+                other_exp = other.factors[factor]
+            except KeyError:
+                continue
+
+            exp = self_exp - other_exp
+
+            if not exp:
+                del self_factors[factor]
+                del other_factors[factor]
+            elif _isnumber(exp):
+                if exp > 0:
+                    self_factors[factor] = exp
+                    del other_factors[factor]
+                else:
+                    del self_factors[factor]
+                    other_factors[factor] = -exp
+            else:
+                r = self_exp.extract_additively(other_exp)
+                if r is not None:
+                    if r:
+                        self_factors[factor] = r
+                        del other_factors[factor]
+                    else:  # should be handled already
+                        del self_factors[factor]
+                        del other_factors[factor]
+                else:
+                    sc, sa = self_exp.as_coeff_Add()
+                    if sc:
+                        oc, oa = other_exp.as_coeff_Add()
+                        diff = sc - oc
+                        if diff > 0:
+                            self_factors[factor] -= oc
+                            other_exp = oa
+                        elif diff < 0:
+                            self_factors[factor] -= sc
+                            other_factors[factor] -= sc
+                            other_exp = oa - diff
+                        else:
+                            self_factors[factor] = sa
+                            other_exp = oa
+                    if other_exp:
+                        other_factors[factor] = other_exp
+                    else:
+                        del other_factors[factor]
+
+        return Factors(self_factors), Factors(other_factors)
+
+    def div(self, other):  # Factors
+        """Return ``self`` and ``other`` with ``gcd`` removed from each.
+        This is optimized for the case when there are many factors in common.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> from sympy import S
+
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> a.div(a)
+        (Factors({}), Factors({}))
+        >>> a.div(x*z)
+        (Factors({y: 2}), Factors({z: 1}))
+
+        The ``/`` operator only gives ``quo``:
+
+        >>> a/x
+        Factors({y: 2})
+
+        Factors treats its factors as though they are all in the numerator, so
+        if you violate this assumption the results will be correct but will
+        not strictly correspond to the numerator and denominator of the ratio:
+
+        >>> a.div(x/z)
+        (Factors({y: 2}), Factors({z: -1}))
+
+        Factors is also naive about bases: it does not attempt any denesting
+        of Rational-base terms, for example the following does not become
+        2**(2*x)/2.
+
+        >>> Factors(2**(2*x + 2)).div(S(8))
+        (Factors({2: 2*x + 2}), Factors({8: 1}))
+
+        factor_terms can clean up such Rational-bases powers:
+
+        >>> from sympy import factor_terms
+        >>> n, d = Factors(2**(2*x + 2)).div(S(8))
+        >>> n.as_expr()/d.as_expr()
+        2**(2*x + 2)/8
+        >>> factor_terms(_)
+        2**(2*x)/2
+
+        """
+        quo, rem = dict(self.factors), {}
+
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if other.is_zero:
+                raise ZeroDivisionError
+            if self.is_zero:
+                return (Factors(S.Zero), Factors())
+
+        for factor, exp in other.factors.items():
+            if factor in quo:
+                d = quo[factor] - exp
+                if _isnumber(d):
+                    if d <= 0:
+                        del quo[factor]
+
+                    if d >= 0:
+                        if d:
+                            quo[factor] = d
+
+                        continue
+
+                    exp = -d
+
+                else:
+                    r = quo[factor].extract_additively(exp)
+                    if r is not None:
+                        if r:
+                            quo[factor] = r
+                        else:  # should be handled already
+                            del quo[factor]
+                    else:
+                        other_exp = exp
+                        sc, sa = quo[factor].as_coeff_Add()
+                        if sc:
+                            oc, oa = other_exp.as_coeff_Add()
+                            diff = sc - oc
+                            if diff > 0:
+                                quo[factor] -= oc
+                                other_exp = oa
+                            elif diff < 0:
+                                quo[factor] -= sc
+                                other_exp = oa - diff
+                            else:
+                                quo[factor] = sa
+                                other_exp = oa
+                        if other_exp:
+                            rem[factor] = other_exp
+                        else:
+                            assert factor not in rem
+                    continue
+
+            rem[factor] = exp
+
+        return Factors(quo), Factors(rem)
+
+    def quo(self, other):  # Factors
+        """Return numerator Factor of ``self / other``.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.quo(b)  # same as a/b
+        Factors({y: 1})
+        """
+        return self.div(other)[0]
+
+    def rem(self, other):  # Factors
+        """Return denominator Factors of ``self / other``.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.rem(b)
+        Factors({z: -1})
+        >>> a.rem(a)
+        Factors({})
+        """
+        return self.div(other)[1]
+
+    def pow(self, other):  # Factors
+        """Return self raised to a non-negative integer power.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> a**2
+        Factors({x: 2, y: 4})
+
+        """
+        if isinstance(other, Factors):
+            other = other.as_expr()
+            if other.is_Integer:
+                other = int(other)
+        if isinstance(other, SYMPY_INTS) and other >= 0:
+            factors = {}
+
+            if other:
+                for factor, exp in self.factors.items():
+                    factors[factor] = exp*other
+
+            return Factors(factors)
+        else:
+            raise ValueError("expected non-negative integer, got %s" % other)
+
+    def gcd(self, other):  # Factors
+        """Return Factors of ``gcd(self, other)``. The keys are
+        the intersection of factors with the minimum exponent for
+        each factor.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.gcd(b)
+        Factors({x: 1, y: 1})
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if other.is_zero:
+                return Factors(self.factors)
+
+        factors = {}
+
+        for factor, exp in self.factors.items():
+            factor, exp = sympify(factor), sympify(exp)
+            if factor in other.factors:
+                lt = (exp - other.factors[factor]).is_negative
+                if lt == True:
+                    factors[factor] = exp
+                elif lt == False:
+                    factors[factor] = other.factors[factor]
+
+        return Factors(factors)
+
+    def lcm(self, other):  # Factors
+        """Return Factors of ``lcm(self, other)`` which are
+        the union of factors with the maximum exponent for
+        each factor.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.lcm(b)
+        Factors({x: 1, y: 2, z: -1})
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if any(f.is_zero for f in (self, other)):
+                return Factors(S.Zero)
+
+        factors = dict(self.factors)
+
+        for factor, exp in other.factors.items():
+            if factor in factors:
+                exp = max(exp, factors[factor])
+
+            factors[factor] = exp
+
+        return Factors(factors)
+
+    def __mul__(self, other):  # Factors
+        return self.mul(other)
+
+    def __divmod__(self, other):  # Factors
+        return self.div(other)
+
+    def __truediv__(self, other):  # Factors
+        return self.quo(other)
+
+    def __mod__(self, other):  # Factors
+        return self.rem(other)
+
+    def __pow__(self, other):  # Factors
+        return self.pow(other)
+
+    def __eq__(self, other):  # Factors
+        if not isinstance(other, Factors):
+            other = Factors(other)
+        return self.factors == other.factors
+
+    def __ne__(self, other):  # Factors
+        return not self == other
+
+
+class Term:
+    """Efficient representation of ``coeff*(numer/denom)``. """
+
+    __slots__ = ('coeff', 'numer', 'denom')
+
+    def __init__(self, term, numer=None, denom=None):  # Term
+        if numer is None and denom is None:
+            if not term.is_commutative:
+                raise NonCommutativeExpression(
+                    'commutative expression expected')
+
+            coeff, factors = term.as_coeff_mul()
+            numer, denom = defaultdict(int), defaultdict(int)
+
+            for factor in factors:
+                base, exp = decompose_power(factor)
+
+                if base.is_Add:
+                    cont, base = base.primitive()
+                    coeff *= cont**exp
+
+                if exp > 0:
+                    numer[base] += exp
+                else:
+                    denom[base] += -exp
+
+            numer = Factors(numer)
+            denom = Factors(denom)
+        else:
+            coeff = term
+
+            if numer is None:
+                numer = Factors()
+
+            if denom is None:
+                denom = Factors()
+
+        self.coeff = coeff
+        self.numer = numer
+        self.denom = denom
+
+    def __hash__(self):  # Term
+        return hash((self.coeff, self.numer, self.denom))
+
+    def __repr__(self):  # Term
+        return "Term(%s, %s, %s)" % (self.coeff, self.numer, self.denom)
+
+    def as_expr(self):  # Term
+        return self.coeff*(self.numer.as_expr()/self.denom.as_expr())
+
+    def mul(self, other):  # Term
+        coeff = self.coeff*other.coeff
+        numer = self.numer.mul(other.numer)
+        denom = self.denom.mul(other.denom)
+
+        numer, denom = numer.normal(denom)
+
+        return Term(coeff, numer, denom)
+
+    def inv(self):  # Term
+        return Term(1/self.coeff, self.denom, self.numer)
+
+    def quo(self, other):  # Term
+        return self.mul(other.inv())
+
+    def pow(self, other):  # Term
+        if other < 0:
+            return self.inv().pow(-other)
+        else:
+            return Term(self.coeff ** other,
+                        self.numer.pow(other),
+                        self.denom.pow(other))
+
+    def gcd(self, other):  # Term
+        return Term(self.coeff.gcd(other.coeff),
+                    self.numer.gcd(other.numer),
+                    self.denom.gcd(other.denom))
+
+    def lcm(self, other):  # Term
+        return Term(self.coeff.lcm(other.coeff),
+                    self.numer.lcm(other.numer),
+                    self.denom.lcm(other.denom))
+
+    def __mul__(self, other):  # Term
+        if isinstance(other, Term):
+            return self.mul(other)
+        else:
+            return NotImplemented
+
+    def __truediv__(self, other):  # Term
+        if isinstance(other, Term):
+            return self.quo(other)
+        else:
+            return NotImplemented
+
+    def __pow__(self, other):  # Term
+        if isinstance(other, SYMPY_INTS):
+            return self.pow(other)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):  # Term
+        return (self.coeff == other.coeff and
+                self.numer == other.numer and
+                self.denom == other.denom)
+
+    def __ne__(self, other):  # Term
+        return not self == other
+
+
+def _gcd_terms(terms, isprimitive=False, fraction=True):
+    """Helper function for :func:`gcd_terms`.
+
+    Parameters
+    ==========
+
+    isprimitive : boolean, optional
+        If ``isprimitive`` is True then the call to primitive
+        for an Add will be skipped. This is useful when the
+        content has already been extracted.
+
+    fraction : boolean, optional
+        If ``fraction`` is True then the expression will appear over a common
+        denominator, the lcm of all term denominators.
+    """
+
+    if isinstance(terms, Basic) and not isinstance(terms, Tuple):
+        terms = Add.make_args(terms)
+
+    terms = list(map(Term, [t for t in terms if t]))
+
+    # there is some simplification that may happen if we leave this
+    # here rather than duplicate it before the mapping of Term onto
+    # the terms
+    if len(terms) == 0:
+        return S.Zero, S.Zero, S.One
+
+    if len(terms) == 1:
+        cont = terms[0].coeff
+        numer = terms[0].numer.as_expr()
+        denom = terms[0].denom.as_expr()
+
+    else:
+        cont = terms[0]
+        for term in terms[1:]:
+            cont = cont.gcd(term)
+
+        for i, term in enumerate(terms):
+            terms[i] = term.quo(cont)
+
+        if fraction:
+            denom = terms[0].denom
+
+            for term in terms[1:]:
+                denom = denom.lcm(term.denom)
+
+            numers = []
+            for term in terms:
+                numer = term.numer.mul(denom.quo(term.denom))
+                numers.append(term.coeff*numer.as_expr())
+        else:
+            numers = [t.as_expr() for t in terms]
+            denom = Term(S.One).numer
+
+        cont = cont.as_expr()
+        numer = Add(*numers)
+        denom = denom.as_expr()
+
+    if not isprimitive and numer.is_Add:
+        _cont, numer = numer.primitive()
+        cont *= _cont
+
+    return cont, numer, denom
+
+
+def gcd_terms(terms, isprimitive=False, clear=True, fraction=True):
+    """Compute the GCD of ``terms`` and put them together.
+
+    Parameters
+    ==========
+
+    terms : Expr
+        Can be an expression or a non-Basic sequence of expressions
+        which will be handled as though they are terms from a sum.
+
+    isprimitive : bool, optional
+        If ``isprimitive`` is True the _gcd_terms will not run the primitive
+        method on the terms.
+
+    clear : bool, optional
+        It controls the removal of integers from the denominator of an Add
+        expression. When True (default), all numerical denominator will be cleared;
+        when False the denominators will be cleared only if all terms had numerical
+        denominators other than 1.
+
+    fraction : bool, optional
+        When True (default), will put the expression over a common
+        denominator.
+
+    Examples
+    ========
+
+    >>> from sympy import gcd_terms
+    >>> from sympy.abc import x, y
+
+    >>> gcd_terms((x + 1)**2*y + (x + 1)*y**2)
+    y*(x + 1)*(x + y + 1)
+    >>> gcd_terms(x/2 + 1)
+    (x + 2)/2
+    >>> gcd_terms(x/2 + 1, clear=False)
+    x/2 + 1
+    >>> gcd_terms(x/2 + y/2, clear=False)
+    (x + y)/2
+    >>> gcd_terms(x/2 + 1/x)
+    (x**2 + 2)/(2*x)
+    >>> gcd_terms(x/2 + 1/x, fraction=False)
+    (x + 2/x)/2
+    >>> gcd_terms(x/2 + 1/x, fraction=False, clear=False)
+    x/2 + 1/x
+
+    >>> gcd_terms(x/2/y + 1/x/y)
+    (x**2 + 2)/(2*x*y)
+    >>> gcd_terms(x/2/y + 1/x/y, clear=False)
+    (x**2/2 + 1)/(x*y)
+    >>> gcd_terms(x/2/y + 1/x/y, clear=False, fraction=False)
+    (x/2 + 1/x)/y
+
+    The ``clear`` flag was ignored in this case because the returned
+    expression was a rational expression, not a simple sum.
+
+    See Also
+    ========
+
+    factor_terms, sympy.polys.polytools.terms_gcd
+
+    """
+    def mask(terms):
+        """replace nc portions of each term with a unique Dummy symbols
+        and return the replacements to restore them"""
+        args = [(a, []) if a.is_commutative else a.args_cnc() for a in terms]
+        reps = []
+        for i, (c, nc) in enumerate(args):
+            if nc:
+                nc = Mul(*nc)
+                d = Dummy()
+                reps.append((d, nc))
+                c.append(d)
+                args[i] = Mul(*c)
+            else:
+                args[i] = c
+        return args, dict(reps)
+
+    isadd = isinstance(terms, Add)
+    addlike = isadd or not isinstance(terms, Basic) and \
+        is_sequence(terms, include=set) and \
+        not isinstance(terms, Dict)
+
+    if addlike:
+        if isadd:  # i.e. an Add
+            terms = list(terms.args)
+        else:
+            terms = sympify(terms)
+        terms, reps = mask(terms)
+        cont, numer, denom = _gcd_terms(terms, isprimitive, fraction)
+        numer = numer.xreplace(reps)
+        coeff, factors = cont.as_coeff_Mul()
+        if not clear:
+            c, _coeff = coeff.as_coeff_Mul()
+            if not c.is_Integer and not clear and numer.is_Add:
+                n, d = c.as_numer_denom()
+                _numer = numer/d
+                if any(a.as_coeff_Mul()[0].is_Integer
+                        for a in _numer.args):
+                    numer = _numer
+                    coeff = n*_coeff
+        return _keep_coeff(coeff, factors*numer/denom, clear=clear)
+
+    if not isinstance(terms, Basic):
+        return terms
+
+    if terms.is_Atom:
+        return terms
+
+    if terms.is_Mul:
+        c, args = terms.as_coeff_mul()
+        return _keep_coeff(c, Mul(*[gcd_terms(i, isprimitive, clear, fraction)
+            for i in args]), clear=clear)
+
+    def handle(a):
+        # don't treat internal args like terms of an Add
+        if not isinstance(a, Expr):
+            if isinstance(a, Basic):
+                if not a.args:
+                    return a
+                return a.func(*[handle(i) for i in a.args])
+            return type(a)([handle(i) for i in a])
+        return gcd_terms(a, isprimitive, clear, fraction)
+
+    if isinstance(terms, Dict):
+        return Dict(*[(k, handle(v)) for k, v in terms.args])
+    return terms.func(*[handle(i) for i in terms.args])
+
+
+def _factor_sum_int(expr, **kwargs):
+    """Return Sum or Integral object with factors that are not
+    in the wrt variables removed. In cases where there are additive
+    terms in the function of the object that are independent, the
+    object will be separated into two objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Sum, factor_terms
+    >>> from sympy.abc import x, y
+    >>> factor_terms(Sum(x + y, (x, 1, 3)))
+    y*Sum(1, (x, 1, 3)) + Sum(x, (x, 1, 3))
+    >>> factor_terms(Sum(x*y, (x, 1, 3)))
+    y*Sum(x, (x, 1, 3))
+
+    Notes
+    =====
+
+    If a function in the summand or integrand is replaced
+    with a symbol, then this simplification should not be
+    done or else an incorrect result will be obtained when
+    the symbol is replaced with an expression that depends
+    on the variables of summation/integration:
+
+    >>> eq = Sum(y, (x, 1, 3))
+    >>> factor_terms(eq).subs(y, x).doit()
+    3*x
+    >>> eq.subs(y, x).doit()
+    6
+    """
+    result = expr.function
+    if result == 0:
+        return S.Zero
+    limits = expr.limits
+
+    # get the wrt variables
+    wrt = {i.args[0] for i in limits}
+
+    # factor out any common terms that are independent of wrt
+    f = factor_terms(result, **kwargs)
+    i, d = f.as_independent(*wrt)
+    if isinstance(f, Add):
+        return i * expr.func(1, *limits) + expr.func(d, *limits)
+    else:
+        return i * expr.func(d, *limits)
+
+
+def factor_terms(expr, radical=False, clear=False, fraction=False, sign=True):
+    """Remove common factors from terms in all arguments without
+    changing the underlying structure of the expr. No expansion or
+    simplification (and no processing of non-commutatives) is performed.
+
+    Parameters
+    ==========
+
+    radical: bool, optional
+        If radical=True then a radical common to all terms will be factored
+        out of any Add sub-expressions of the expr.
+
+    clear : bool, optional
+        If clear=False (default) then coefficients will not be separated
+        from a single Add if they can be distributed to leave one or more
+        terms with integer coefficients.
+
+    fraction : bool, optional
+        If fraction=True (default is False) then a common denominator will be
+        constructed for the expression.
+
+    sign : bool, optional
+        If sign=True (default) then even if the only factor in common is a -1,
+        it will be factored out of the expression.
+
+    Examples
+    ========
+
+    >>> from sympy import factor_terms, Symbol
+    >>> from sympy.abc import x, y
+    >>> factor_terms(x + x*(2 + 4*y)**3)
+    x*(8*(2*y + 1)**3 + 1)
+    >>> A = Symbol('A', commutative=False)
+    >>> factor_terms(x*A + x*A + x*y*A)
+    x*(y*A + 2*A)
+
+    When ``clear`` is False, a rational will only be factored out of an
+    Add expression if all terms of the Add have coefficients that are
+    fractions:
+
+    >>> factor_terms(x/2 + 1, clear=False)
+    x/2 + 1
+    >>> factor_terms(x/2 + 1, clear=True)
+    (x + 2)/2
+
+    If a -1 is all that can be factored out, to *not* factor it out, the
+    flag ``sign`` must be False:
+
+    >>> factor_terms(-x - y)
+    -(x + y)
+    >>> factor_terms(-x - y, sign=False)
+    -x - y
+    >>> factor_terms(-2*x - 2*y, sign=False)
+    -2*(x + y)
+
+    See Also
+    ========
+
+    gcd_terms, sympy.polys.polytools.terms_gcd
+
+    """
+    def do(expr):
+        from sympy.concrete.summations import Sum
+        from sympy.integrals.integrals import Integral
+        is_iterable = iterable(expr)
+
+        if not isinstance(expr, Basic) or expr.is_Atom:
+            if is_iterable:
+                return type(expr)([do(i) for i in expr])
+            return expr
+
+        if expr.is_Pow or expr.is_Function or \
+                is_iterable or not hasattr(expr, 'args_cnc'):
+            args = expr.args
+            newargs = tuple([do(i) for i in args])
+            if newargs == args:
+                return expr
+            return expr.func(*newargs)
+
+        if isinstance(expr, (Sum, Integral)):
+            return _factor_sum_int(expr,
+                radical=radical, clear=clear,
+                fraction=fraction, sign=sign)
+
+        cont, p = expr.as_content_primitive(radical=radical, clear=clear)
+        if p.is_Add:
+            list_args = [do(a) for a in Add.make_args(p)]
+            # get a common negative (if there) which gcd_terms does not remove
+            if not any(a.as_coeff_Mul()[0].extract_multiplicatively(-1) is None
+                       for a in list_args):
+                cont = -cont
+                list_args = [-a for a in list_args]
+            # watch out for exp(-(x+2)) which gcd_terms will change to exp(-x-2)
+            special = {}
+            for i, a in enumerate(list_args):
+                b, e = a.as_base_exp()
+                if e.is_Mul and e != Mul(*e.args):
+                    list_args[i] = Dummy()
+                    special[list_args[i]] = a
+            # rebuild p not worrying about the order which gcd_terms will fix
+            p = Add._from_args(list_args)
+            p = gcd_terms(p,
+                isprimitive=True,
+                clear=clear,
+                fraction=fraction).xreplace(special)
+        elif p.args:
+            p = p.func(
+                *[do(a) for a in p.args])
+        rv = _keep_coeff(cont, p, clear=clear, sign=sign)
+        return rv
+    expr = sympify(expr)
+    return do(expr)
+
+
+def _mask_nc(eq, name=None):
+    """
+    Return ``eq`` with non-commutative objects replaced with Dummy
+    symbols. A dictionary that can be used to restore the original
+    values is returned: if it is None, the expression is noncommutative
+    and cannot be made commutative. The third value returned is a list
+    of any non-commutative symbols that appear in the returned equation.
+
+    Explanation
+    ===========
+
+    All non-commutative objects other than Symbols are replaced with
+    a non-commutative Symbol. Identical objects will be identified
+    by identical symbols.
+
+    If there is only 1 non-commutative object in an expression it will
+    be replaced with a commutative symbol. Otherwise, the non-commutative
+    entities are retained and the calling routine should handle
+    replacements in this case since some care must be taken to keep
+    track of the ordering of symbols when they occur within Muls.
+
+    Parameters
+    ==========
+
+    name : str
+        ``name``, if given, is the name that will be used with numbered Dummy
+        variables that will replace the non-commutative objects and is mainly
+        used for doctesting purposes.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.secondquant import Commutator, NO, F, Fd
+    >>> from sympy import symbols
+    >>> from sympy.core.exprtools import _mask_nc
+    >>> from sympy.abc import x, y
+    >>> A, B, C = symbols('A,B,C', commutative=False)
+
+    One nc-symbol:
+
+    >>> _mask_nc(A**2 - x**2, 'd')
+    (_d0**2 - x**2, {_d0: A}, [])
+
+    Multiple nc-symbols:
+
+    >>> _mask_nc(A**2 - B**2, 'd')
+    (A**2 - B**2, {}, [A, B])
+
+    An nc-object with nc-symbols but no others outside of it:
+
+    >>> _mask_nc(1 + x*Commutator(A, B), 'd')
+    (_d0*x + 1, {_d0: Commutator(A, B)}, [])
+    >>> _mask_nc(NO(Fd(x)*F(y)), 'd')
+    (_d0, {_d0: NO(CreateFermion(x)*AnnihilateFermion(y))}, [])
+
+    Multiple nc-objects:
+
+    >>> eq = x*Commutator(A, B) + x*Commutator(A, C)*Commutator(A, B)
+    >>> _mask_nc(eq, 'd')
+    (x*_d0 + x*_d1*_d0, {_d0: Commutator(A, B), _d1: Commutator(A, C)}, [_d0, _d1])
+
+    Multiple nc-objects and nc-symbols:
+
+    >>> eq = A*Commutator(A, B) + B*Commutator(A, C)
+    >>> _mask_nc(eq, 'd')
+    (A*_d0 + B*_d1, {_d0: Commutator(A, B), _d1: Commutator(A, C)}, [_d0, _d1, A, B])
+
+    """
+    name = name or 'mask'
+    # Make Dummy() append sequential numbers to the name
+
+    def numbered_names():
+        i = 0
+        while True:
+            yield name + str(i)
+            i += 1
+
+    names = numbered_names()
+
+    def Dummy(*args, **kwargs):
+        from .symbol import Dummy
+        return Dummy(next(names), *args, **kwargs)
+
+    expr = eq
+    if expr.is_commutative:
+        return eq, {}, []
+
+    # identify nc-objects; symbols and other
+    rep = []
+    nc_obj = set()
+    nc_syms = set()
+    pot = preorder_traversal(expr, keys=default_sort_key)
+    for i, a in enumerate(pot):
+        if any(a == r[0] for r in rep):
+            pot.skip()
+        elif not a.is_commutative:
+            if a.is_symbol:
+                nc_syms.add(a)
+                pot.skip()
+            elif not (a.is_Add or a.is_Mul or a.is_Pow):
+                nc_obj.add(a)
+                pot.skip()
+
+    # If there is only one nc symbol or object, it can be factored regularly
+    # but polys is going to complain, so replace it with a Dummy.
+    if len(nc_obj) == 1 and not nc_syms:
+        rep.append((nc_obj.pop(), Dummy()))
+    elif len(nc_syms) == 1 and not nc_obj:
+        rep.append((nc_syms.pop(), Dummy()))
+
+    # Any remaining nc-objects will be replaced with an nc-Dummy and
+    # identified as an nc-Symbol to watch out for
+    nc_obj = sorted(nc_obj, key=default_sort_key)
+    for n in nc_obj:
+        nc = Dummy(commutative=False)
+        rep.append((n, nc))
+        nc_syms.add(nc)
+    expr = expr.subs(rep)
+
+    nc_syms = list(nc_syms)
+    nc_syms.sort(key=default_sort_key)
+    return expr, {v: k for k, v in rep}, nc_syms
+
+
+def factor_nc(expr):
+    """Return the factored form of ``expr`` while handling non-commutative
+    expressions.
+
+    Examples
+    ========
+
+    >>> from sympy import factor_nc, Symbol
+    >>> from sympy.abc import x
+    >>> A = Symbol('A', commutative=False)
+    >>> B = Symbol('B', commutative=False)
+    >>> factor_nc((x**2 + 2*A*x + A**2).expand())
+    (x + A)**2
+    >>> factor_nc(((x + A)*(x + B)).expand())
+    (x + A)*(x + B)
+    """
+    expr = sympify(expr)
+    if not isinstance(expr, Expr) or not expr.args:
+        return expr
+    if not expr.is_Add:
+        return expr.func(*[factor_nc(a) for a in expr.args])
+    expr = expr.func(*[expand_power_exp(i) for i in expr.args])
+
+    from sympy.polys.polytools import gcd, factor
+    expr, rep, nc_symbols = _mask_nc(expr)
+
+    if rep:
+        return factor(expr).subs(rep)
+    else:
+        args = [a.args_cnc() for a in Add.make_args(expr)]
+        c = g = l = r = S.One
+        hit = False
+        # find any commutative gcd term
+        for i, a in enumerate(args):
+            if i == 0:
+                c = Mul._from_args(a[0])
+            elif a[0]:
+                c = gcd(c, Mul._from_args(a[0]))
+            else:
+                c = S.One
+        if c is not S.One:
+            hit = True
+            c, g = c.as_coeff_Mul()
+            if g is not S.One:
+                for i, (cc, _) in enumerate(args):
+                    cc = list(Mul.make_args(Mul._from_args(list(cc))/g))
+                    args[i][0] = cc
+            for i, (cc, _) in enumerate(args):
+                if cc:
+                    cc[0] = cc[0]/c
+                else:
+                    cc = [1/c]
+                args[i][0] = cc
+        # find any noncommutative common prefix
+        for i, a in enumerate(args):
+            if i == 0:
+                n = a[1][:]
+            else:
+                n = common_prefix(n, a[1])
+            if not n:
+                # is there a power that can be extracted?
+                if not args[0][1]:
+                    break
+                b, e = args[0][1][0].as_base_exp()
+                ok = False
+                if e.is_Integer:
+                    for t in args:
+                        if not t[1]:
+                            break
+                        bt, et = t[1][0].as_base_exp()
+                        if et.is_Integer and bt == b:
+                            e = min(e, et)
+                        else:
+                            break
+                    else:
+                        ok = hit = True
+                        l = b**e
+                        il = b**-e
+                        for _ in args:
+                            _[1][0] = il*_[1][0]
+                        break
+                if not ok:
+                    break
+        else:
+            hit = True
+            lenn = len(n)
+            l = Mul(*n)
+            for _ in args:
+                _[1] = _[1][lenn:]
+        # find any noncommutative common suffix
+        for i, a in enumerate(args):
+            if i == 0:
+                n = a[1][:]
+            else:
+                n = common_suffix(n, a[1])
+            if not n:
+                # is there a power that can be extracted?
+                if not args[0][1]:
+                    break
+                b, e = args[0][1][-1].as_base_exp()
+                ok = False
+                if e.is_Integer:
+                    for t in args:
+                        if not t[1]:
+                            break
+                        bt, et = t[1][-1].as_base_exp()
+                        if et.is_Integer and bt == b:
+                            e = min(e, et)
+                        else:
+                            break
+                    else:
+                        ok = hit = True
+                        r = b**e
+                        il = b**-e
+                        for _ in args:
+                            _[1][-1] = _[1][-1]*il
+                        break
+                if not ok:
+                    break
+        else:
+            hit = True
+            lenn = len(n)
+            r = Mul(*n)
+            for _ in args:
+                _[1] = _[1][:len(_[1]) - lenn]
+        if hit:
+            mid = Add(*[Mul(*cc)*Mul(*nc) for cc, nc in args])
+        else:
+            mid = expr
+
+        from sympy.simplify.powsimp import powsimp
+
+        # sort the symbols so the Dummys would appear in the same
+        # order as the original symbols, otherwise you may introduce
+        # a factor of -1, e.g. A**2 - B**2) -- {A:y, B:x} --> y**2 - x**2
+        # and the former factors into two terms, (A - B)*(A + B) while the
+        # latter factors into 3 terms, (-1)*(x - y)*(x + y)
+        rep1 = [(n, Dummy()) for n in sorted(nc_symbols, key=default_sort_key)]
+        unrep1 = [(v, k) for k, v in rep1]
+        unrep1.reverse()
+        new_mid, r2, _ = _mask_nc(mid.subs(rep1))
+        new_mid = powsimp(factor(new_mid))
+
+        new_mid = new_mid.subs(r2).subs(unrep1)
+
+        if new_mid.is_Pow:
+            return _keep_coeff(c, g*l*new_mid*r)
+
+        if new_mid.is_Mul:
+            def _pemexpand(expr):
+                "Expand with the minimal set of hints necessary to check the result."
+                return expr.expand(deep=True, mul=True, power_exp=True,
+                    power_base=False, basic=False, multinomial=True, log=False)
+            # XXX TODO there should be a way to inspect what order the terms
+            # must be in and just select the plausible ordering without
+            # checking permutations
+            cfac = []
+            ncfac = []
+            for f in new_mid.args:
+                if f.is_commutative:
+                    cfac.append(f)
+                else:
+                    b, e = f.as_base_exp()
+                    if e.is_Integer:
+                        ncfac.extend([b]*e)
+                    else:
+                        ncfac.append(f)
+            pre_mid = g*Mul(*cfac)*l
+            target = _pemexpand(expr/c)
+            for s in variations(ncfac, len(ncfac)):
+                ok = pre_mid*Mul(*s)*r
+                if _pemexpand(ok) == target:
+                    return _keep_coeff(c, ok)
+
+        # mid was an Add that didn't factor successfully
+        return _keep_coeff(c, g*l*mid*r)

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

@@ -0,0 +1,634 @@
+r"""This is rule-based deduction system for SymPy
+
+The whole thing is split into two parts
+
+ - rules compilation and preparation of tables
+ - runtime inference
+
+For rule-based inference engines, the classical work is RETE algorithm [1],
+[2] Although we are not implementing it in full (or even significantly)
+it's still worth a read to understand the underlying ideas.
+
+In short, every rule in a system of rules is one of two forms:
+
+ - atom                     -> ...      (alpha rule)
+ - And(atom1, atom2, ...)   -> ...      (beta rule)
+
+
+The major complexity is in efficient beta-rules processing and usually for an
+expert system a lot of effort goes into code that operates on beta-rules.
+
+
+Here we take minimalistic approach to get something usable first.
+
+ - (preparation)    of alpha- and beta- networks, everything except
+ - (runtime)        FactRules.deduce_all_facts
+
+             _____________________________________
+            ( Kirr: I've never thought that doing )
+            ( logic stuff is that difficult...    )
+             -------------------------------------
+                    o   ^__^
+                     o  (oo)\_______
+                        (__)\       )\/\
+                            ||----w |
+                            ||     ||
+
+
+Some references on the topic
+----------------------------
+
+[1] https://en.wikipedia.org/wiki/Rete_algorithm
+[2] http://reports-archive.adm.cs.cmu.edu/anon/1995/CMU-CS-95-113.pdf
+
+https://en.wikipedia.org/wiki/Propositional_formula
+https://en.wikipedia.org/wiki/Inference_rule
+https://en.wikipedia.org/wiki/List_of_rules_of_inference
+"""
+
+from collections import defaultdict
+from typing import Iterator
+
+from .logic import Logic, And, Or, Not
+
+
+def _base_fact(atom):
+    """Return the literal fact of an atom.
+
+    Effectively, this merely strips the Not around a fact.
+    """
+    if isinstance(atom, Not):
+        return atom.arg
+    else:
+        return atom
+
+
+def _as_pair(atom):
+    if isinstance(atom, Not):
+        return (atom.arg, False)
+    else:
+        return (atom, True)
+
+# XXX this prepares forward-chaining rules for alpha-network
+
+
+def transitive_closure(implications):
+    """
+    Computes the transitive closure of a list of implications
+
+    Uses Warshall's algorithm, as described at
+    http://www.cs.hope.edu/~cusack/Notes/Notes/DiscreteMath/Warshall.pdf.
+    """
+    full_implications = set(implications)
+    literals = set().union(*map(set, full_implications))
+
+    for k in literals:
+        for i in literals:
+            if (i, k) in full_implications:
+                for j in literals:
+                    if (k, j) in full_implications:
+                        full_implications.add((i, j))
+
+    return full_implications
+
+
+def deduce_alpha_implications(implications):
+    """deduce all implications
+
+       Description by example
+       ----------------------
+
+       given set of logic rules:
+
+         a -> b
+         b -> c
+
+       we deduce all possible rules:
+
+         a -> b, c
+         b -> c
+
+
+       implications: [] of (a,b)
+       return:       {} of a -> set([b, c, ...])
+    """
+    implications = implications + [(Not(j), Not(i)) for (i, j) in implications]
+    res = defaultdict(set)
+    full_implications = transitive_closure(implications)
+    for a, b in full_implications:
+        if a == b:
+            continue    # skip a->a cyclic input
+
+        res[a].add(b)
+
+    # Clean up tautologies and check consistency
+    for a, impl in res.items():
+        impl.discard(a)
+        na = Not(a)
+        if na in impl:
+            raise ValueError(
+                'implications are inconsistent: %s -> %s %s' % (a, na, impl))
+
+    return res
+
+
+def apply_beta_to_alpha_route(alpha_implications, beta_rules):
+    """apply additional beta-rules (And conditions) to already-built
+    alpha implication tables
+
+       TODO: write about
+
+       - static extension of alpha-chains
+       - attaching refs to beta-nodes to alpha chains
+
+
+       e.g.
+
+       alpha_implications:
+
+       a  ->  [b, !c, d]
+       b  ->  [d]
+       ...
+
+
+       beta_rules:
+
+       &(b,d) -> e
+
+
+       then we'll extend a's rule to the following
+
+       a  ->  [b, !c, d, e]
+    """
+    x_impl = {}
+    for x in alpha_implications.keys():
+        x_impl[x] = (set(alpha_implications[x]), [])
+    for bcond, bimpl in beta_rules:
+        for bk in bcond.args:
+            if bk in x_impl:
+                continue
+            x_impl[bk] = (set(), [])
+
+    # static extensions to alpha rules:
+    # A: x -> a,b   B: &(a,b) -> c  ==>  A: x -> a,b,c
+    seen_static_extension = True
+    while seen_static_extension:
+        seen_static_extension = False
+
+        for bcond, bimpl in beta_rules:
+            if not isinstance(bcond, And):
+                raise TypeError("Cond is not And")
+            bargs = set(bcond.args)
+            for x, (ximpls, bb) in x_impl.items():
+                x_all = ximpls | {x}
+                # A: ... -> a   B: &(...) -> a  is non-informative
+                if bimpl not in x_all and bargs.issubset(x_all):
+                    ximpls.add(bimpl)
+
+                    # we introduced new implication - now we have to restore
+                    # completeness of the whole set.
+                    bimpl_impl = x_impl.get(bimpl)
+                    if bimpl_impl is not None:
+                        ximpls |= bimpl_impl[0]
+                    seen_static_extension = True
+
+    # attach beta-nodes which can be possibly triggered by an alpha-chain
+    for bidx, (bcond, bimpl) in enumerate(beta_rules):
+        bargs = set(bcond.args)
+        for x, (ximpls, bb) in x_impl.items():
+            x_all = ximpls | {x}
+            # A: ... -> a   B: &(...) -> a      (non-informative)
+            if bimpl in x_all:
+                continue
+            # A: x -> a...  B: &(!a,...) -> ... (will never trigger)
+            # A: x -> a...  B: &(...) -> !a     (will never trigger)
+            if any(Not(xi) in bargs or Not(xi) == bimpl for xi in x_all):
+                continue
+
+            if bargs & x_all:
+                bb.append(bidx)
+
+    return x_impl
+
+
+def rules_2prereq(rules):
+    """build prerequisites table from rules
+
+       Description by example
+       ----------------------
+
+       given set of logic rules:
+
+         a -> b, c
+         b -> c
+
+       we build prerequisites (from what points something can be deduced):
+
+         b <- a
+         c <- a, b
+
+       rules:   {} of a -> [b, c, ...]
+       return:  {} of c <- [a, b, ...]
+
+       Note however, that this prerequisites may be *not* enough to prove a
+       fact. An example is 'a -> b' rule, where prereq(a) is b, and prereq(b)
+       is a. That's because a=T -> b=T, and b=F -> a=F, but a=F -> b=?
+    """
+    prereq = defaultdict(set)
+    for (a, _), impl in rules.items():
+        if isinstance(a, Not):
+            a = a.args[0]
+        for (i, _) in impl:
+            if isinstance(i, Not):
+                i = i.args[0]
+            prereq[i].add(a)
+    return prereq
+
+################
+# RULES PROVER #
+################
+
+
+class TautologyDetected(Exception):
+    """(internal) Prover uses it for reporting detected tautology"""
+    pass
+
+
+class Prover:
+    """ai - prover of logic rules
+
+       given a set of initial rules, Prover tries to prove all possible rules
+       which follow from given premises.
+
+       As a result proved_rules are always either in one of two forms: alpha or
+       beta:
+
+       Alpha rules
+       -----------
+
+       This are rules of the form::
+
+         a -> b & c & d & ...
+
+
+       Beta rules
+       ----------
+
+       This are rules of the form::
+
+         &(a,b,...) -> c & d & ...
+
+
+       i.e. beta rules are join conditions that say that something follows when
+       *several* facts are true at the same time.
+    """
+
+    def __init__(self):
+        self.proved_rules = []
+        self._rules_seen = set()
+
+    def split_alpha_beta(self):
+        """split proved rules into alpha and beta chains"""
+        rules_alpha = []    # a      -> b
+        rules_beta = []     # &(...) -> b
+        for a, b in self.proved_rules:
+            if isinstance(a, And):
+                rules_beta.append((a, b))
+            else:
+                rules_alpha.append((a, b))
+        return rules_alpha, rules_beta
+
+    @property
+    def rules_alpha(self):
+        return self.split_alpha_beta()[0]
+
+    @property
+    def rules_beta(self):
+        return self.split_alpha_beta()[1]
+
+    def process_rule(self, a, b):
+        """process a -> b rule"""   # TODO write more?
+        if (not a) or isinstance(b, bool):
+            return
+        if isinstance(a, bool):
+            return
+        if (a, b) in self._rules_seen:
+            return
+        else:
+            self._rules_seen.add((a, b))
+
+        # this is the core of processing
+        try:
+            self._process_rule(a, b)
+        except TautologyDetected:
+            pass
+
+    def _process_rule(self, a, b):
+        # right part first
+
+        # a -> b & c    -->  a -> b  ;  a -> c
+        # (?) FIXME this is only correct when b & c != null !
+
+        if isinstance(b, And):
+            sorted_bargs = sorted(b.args, key=str)
+            for barg in sorted_bargs:
+                self.process_rule(a, barg)
+
+        # a -> b | c    -->  !b & !c -> !a
+        #               -->   a & !b -> c
+        #               -->   a & !c -> b
+        elif isinstance(b, Or):
+            sorted_bargs = sorted(b.args, key=str)
+            # detect tautology first
+            if not isinstance(a, Logic):    # Atom
+                # tautology:  a -> a|c|...
+                if a in sorted_bargs:
+                    raise TautologyDetected(a, b, 'a -> a|c|...')
+            self.process_rule(And(*[Not(barg) for barg in b.args]), Not(a))
+
+            for bidx in range(len(sorted_bargs)):
+                barg = sorted_bargs[bidx]
+                brest = sorted_bargs[:bidx] + sorted_bargs[bidx + 1:]
+                self.process_rule(And(a, Not(barg)), Or(*brest))
+
+        # left part
+
+        # a & b -> c    -->  IRREDUCIBLE CASE -- WE STORE IT AS IS
+        #                    (this will be the basis of beta-network)
+        elif isinstance(a, And):
+            sorted_aargs = sorted(a.args, key=str)
+            if b in sorted_aargs:
+                raise TautologyDetected(a, b, 'a & b -> a')
+            self.proved_rules.append((a, b))
+            # XXX NOTE at present we ignore  !c -> !a | !b
+
+        elif isinstance(a, Or):
+            sorted_aargs = sorted(a.args, key=str)
+            if b in sorted_aargs:
+                raise TautologyDetected(a, b, 'a | b -> a')
+            for aarg in sorted_aargs:
+                self.process_rule(aarg, b)
+
+        else:
+            # both `a` and `b` are atoms
+            self.proved_rules.append((a, b))             # a  -> b
+            self.proved_rules.append((Not(b), Not(a)))   # !b -> !a
+
+########################################
+
+
+class FactRules:
+    """Rules that describe how to deduce facts in logic space
+
+       When defined, these rules allow implications to quickly be determined
+       for a set of facts. For this precomputed deduction tables are used.
+       see `deduce_all_facts`   (forward-chaining)
+
+       Also it is possible to gather prerequisites for a fact, which is tried
+       to be proven.    (backward-chaining)
+
+
+       Definition Syntax
+       -----------------
+
+       a -> b       -- a=T -> b=T  (and automatically b=F -> a=F)
+       a -> !b      -- a=T -> b=F
+       a == b       -- a -> b & b -> a
+       a -> b & c   -- a=T -> b=T & c=T
+       # TODO b | c
+
+
+       Internals
+       ---------
+
+       .full_implications[k, v]: all the implications of fact k=v
+       .beta_triggers[k, v]: beta rules that might be triggered when k=v
+       .prereq  -- {} k <- [] of k's prerequisites
+
+       .defined_facts -- set of defined fact names
+    """
+
+    def __init__(self, rules):
+        """Compile rules into internal lookup tables"""
+
+        if isinstance(rules, str):
+            rules = rules.splitlines()
+
+        # --- parse and process rules ---
+        P = Prover()
+
+        for rule in rules:
+            # XXX `a` is hardcoded to be always atom
+            a, op, b = rule.split(None, 2)
+
+            a = Logic.fromstring(a)
+            b = Logic.fromstring(b)
+
+            if op == '->':
+                P.process_rule(a, b)
+            elif op == '==':
+                P.process_rule(a, b)
+                P.process_rule(b, a)
+            else:
+                raise ValueError('unknown op %r' % op)
+
+        # --- build deduction networks ---
+        self.beta_rules = []
+        for bcond, bimpl in P.rules_beta:
+            self.beta_rules.append(
+                ({_as_pair(a) for a in bcond.args}, _as_pair(bimpl)))
+
+        # deduce alpha implications
+        impl_a = deduce_alpha_implications(P.rules_alpha)
+
+        # now:
+        # - apply beta rules to alpha chains  (static extension), and
+        # - further associate beta rules to alpha chain (for inference
+        # at runtime)
+        impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
+
+        # extract defined fact names
+        self.defined_facts = {_base_fact(k) for k in impl_ab.keys()}
+
+        # build rels (forward chains)
+        full_implications = defaultdict(set)
+        beta_triggers = defaultdict(set)
+        for k, (impl, betaidxs) in impl_ab.items():
+            full_implications[_as_pair(k)] = {_as_pair(i) for i in impl}
+            beta_triggers[_as_pair(k)] = betaidxs
+
+        self.full_implications = full_implications
+        self.beta_triggers = beta_triggers
+
+        # build prereq (backward chains)
+        prereq = defaultdict(set)
+        rel_prereq = rules_2prereq(full_implications)
+        for k, pitems in rel_prereq.items():
+            prereq[k] |= pitems
+        self.prereq = prereq
+
+    def _to_python(self) -> str:
+        """ Generate a string with plain python representation of the instance """
+        return '\n'.join(self.print_rules())
+
+    @classmethod
+    def _from_python(cls, data : dict):
+        """ Generate an instance from the plain python representation """
+        self = cls('')
+        for key in ['full_implications', 'beta_triggers', 'prereq']:
+            d=defaultdict(set)
+            d.update(data[key])
+            setattr(self, key, d)
+        self.beta_rules = data['beta_rules']
+        self.defined_facts = set(data['defined_facts'])
+
+        return self
+
+    def _defined_facts_lines(self):
+        yield 'defined_facts = ['
+        for fact in sorted(self.defined_facts):
+            yield f'    {fact!r},'
+        yield '] # defined_facts'
+
+    def _full_implications_lines(self):
+        yield 'full_implications = dict( ['
+        for fact in sorted(self.defined_facts):
+            for value in (True, False):
+                yield f'    # Implications of {fact} = {value}:'
+                yield f'    (({fact!r}, {value!r}), set( ('
+                implications = self.full_implications[(fact, value)]
+                for implied in sorted(implications):
+                    yield f'        {implied!r},'
+                yield '       ) ),'
+                yield '     ),'
+        yield ' ] ) # full_implications'
+
+    def _prereq_lines(self):
+        yield 'prereq = {'
+        yield ''
+        for fact in sorted(self.prereq):
+            yield f'    # facts that could determine the value of {fact}'
+            yield f'    {fact!r}: {{'
+            for pfact in sorted(self.prereq[fact]):
+                yield f'        {pfact!r},'
+            yield '    },'
+            yield ''
+        yield '} # prereq'
+
+    def _beta_rules_lines(self):
+        reverse_implications = defaultdict(list)
+        for n, (pre, implied) in enumerate(self.beta_rules):
+            reverse_implications[implied].append((pre, n))
+
+        yield '# Note: the order of the beta rules is used in the beta_triggers'
+        yield 'beta_rules = ['
+        yield ''
+        m = 0
+        indices = {}
+        for implied in sorted(reverse_implications):
+            fact, value = implied
+            yield f'    # Rules implying {fact} = {value}'
+            for pre, n in reverse_implications[implied]:
+                indices[n] = m
+                m += 1
+                setstr = ", ".join(map(str, sorted(pre)))
+                yield f'    ({{{setstr}}},'
+                yield f'        {implied!r}),'
+            yield ''
+        yield '] # beta_rules'
+
+        yield 'beta_triggers = {'
+        for query in sorted(self.beta_triggers):
+            fact, value = query
+            triggers = [indices[n] for n in self.beta_triggers[query]]
+            yield f'    {query!r}: {triggers!r},'
+        yield '} # beta_triggers'
+
+    def print_rules(self) -> Iterator[str]:
+        """ Returns a generator with lines to represent the facts and rules """
+        yield from self._defined_facts_lines()
+        yield ''
+        yield ''
+        yield from self._full_implications_lines()
+        yield ''
+        yield ''
+        yield from self._prereq_lines()
+        yield ''
+        yield ''
+        yield from self._beta_rules_lines()
+        yield ''
+        yield ''
+        yield "generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,"
+        yield "               'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers}"
+
+
+class InconsistentAssumptions(ValueError):
+    def __str__(self):
+        kb, fact, value = self.args
+        return "%s, %s=%s" % (kb, fact, value)
+
+
+class FactKB(dict):
+    """
+    A simple propositional knowledge base relying on compiled inference rules.
+    """
+    def __str__(self):
+        return '{\n%s}' % ',\n'.join(
+            ["\t%s: %s" % i for i in sorted(self.items())])
+
+    def __init__(self, rules):
+        self.rules = rules
+
+    def _tell(self, k, v):
+        """Add fact k=v to the knowledge base.
+
+        Returns True if the KB has actually been updated, False otherwise.
+        """
+        if k in self and self[k] is not None:
+            if self[k] == v:
+                return False
+            else:
+                raise InconsistentAssumptions(self, k, v)
+        else:
+            self[k] = v
+            return True
+
+    # *********************************************
+    # * This is the workhorse, so keep it *fast*. *
+    # *********************************************
+    def deduce_all_facts(self, facts):
+        """
+        Update the KB with all the implications of a list of facts.
+
+        Facts can be specified as a dictionary or as a list of (key, value)
+        pairs.
+        """
+        # keep frequently used attributes locally, so we'll avoid extra
+        # attribute access overhead
+        full_implications = self.rules.full_implications
+        beta_triggers = self.rules.beta_triggers
+        beta_rules = self.rules.beta_rules
+
+        if isinstance(facts, dict):
+            facts = facts.items()
+
+        while facts:
+            beta_maytrigger = set()
+
+            # --- alpha chains ---
+            for k, v in facts:
+                if not self._tell(k, v) or v is None:
+                    continue
+
+                # lookup routing tables
+                for key, value in full_implications[k, v]:
+                    self._tell(key, value)
+
+                beta_maytrigger.update(beta_triggers[k, v])
+
+            # --- beta chains ---
+            facts = []
+            for bidx in beta_maytrigger:
+                bcond, bimpl = beta_rules[bidx]
+                if all(self.get(k) is v for k, v in bcond):
+                    facts.append(bimpl)

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

@@ -0,0 +1,388 @@
+"""
+Module to efficiently partition SymPy objects.
+
+This system is introduced because class of SymPy object does not always
+represent the mathematical classification of the entity. For example,
+``Integral(1, x)`` and ``Integral(Matrix([1,2]), x)`` are both instance
+of ``Integral`` class. However the former is number and the latter is
+matrix.
+
+One way to resolve this is defining subclass for each mathematical type,
+such as ``MatAdd`` for the addition between matrices. Basic algebraic
+operation such as addition or multiplication take this approach, but
+defining every class for every mathematical object is not scalable.
+
+Therefore, we define the "kind" of the object and let the expression
+infer the kind of itself from its arguments. Function and class can
+filter the arguments by their kind, and behave differently according to
+the type of itself.
+
+This module defines basic kinds for core objects. Other kinds such as
+``ArrayKind`` or ``MatrixKind`` can be found in corresponding modules.
+
+.. notes::
+       This approach is experimental, and can be replaced or deleted in the future.
+       See https://github.com/sympy/sympy/pull/20549.
+"""
+
+from collections import defaultdict
+
+from .cache import cacheit
+from sympy.multipledispatch.dispatcher import (Dispatcher,
+    ambiguity_warn, ambiguity_register_error_ignore_dup,
+    str_signature, RaiseNotImplementedError)
+
+
+class KindMeta(type):
+    """
+    Metaclass for ``Kind``.
+
+    Assigns empty ``dict`` as class attribute ``_inst`` for every class,
+    in order to endow singleton-like behavior.
+    """
+    def __new__(cls, clsname, bases, dct):
+        dct['_inst'] = {}
+        return super().__new__(cls, clsname, bases, dct)
+
+
+class Kind(object, metaclass=KindMeta):
+    """
+    Base class for kinds.
+
+    Kind of the object represents the mathematical classification that
+    the entity falls into. It is expected that functions and classes
+    recognize and filter the argument by its kind.
+
+    Kind of every object must be carefully selected so that it shows the
+    intention of design. Expressions may have different kind according
+    to the kind of its arguments. For example, arguments of ``Add``
+    must have common kind since addition is group operator, and the
+    resulting ``Add()`` has the same kind.
+
+    For the performance, each kind is as broad as possible and is not
+    based on set theory. For example, ``NumberKind`` includes not only
+    complex number but expression containing ``S.Infinity`` or ``S.NaN``
+    which are not strictly number.
+
+    Kind may have arguments as parameter. For example, ``MatrixKind()``
+    may be constructed with one element which represents the kind of its
+    elements.
+
+    ``Kind`` behaves in singleton-like fashion. Same signature will
+    return the same object.
+
+    """
+    def __new__(cls, *args):
+        if args in cls._inst:
+            inst = cls._inst[args]
+        else:
+            inst = super().__new__(cls)
+            cls._inst[args] = inst
+        return inst
+
+
+class _UndefinedKind(Kind):
+    """
+    Default kind for all SymPy object. If the kind is not defined for
+    the object, or if the object cannot infer the kind from its
+    arguments, this will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Expr
+    >>> Expr().kind
+    UndefinedKind
+    """
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def __repr__(self):
+        return "UndefinedKind"
+
+UndefinedKind = _UndefinedKind()
+
+
+class _NumberKind(Kind):
+    """
+    Kind for all numeric object.
+
+    This kind represents every number, including complex numbers,
+    infinity and ``S.NaN``. Other objects such as quaternions do not
+    have this kind.
+
+    Most ``Expr`` are initially designed to represent the number, so
+    this will be the most common kind in SymPy core. For example
+    ``Symbol()``, which represents a scalar, has this kind as long as it
+    is commutative.
+
+    Numbers form a field. Any operation between number-kind objects will
+    result this kind as well.
+
+    Examples
+    ========
+
+    >>> from sympy import S, oo, Symbol
+    >>> S.One.kind
+    NumberKind
+    >>> (-oo).kind
+    NumberKind
+    >>> S.NaN.kind
+    NumberKind
+
+    Commutative symbol are treated as number.
+
+    >>> x = Symbol('x')
+    >>> x.kind
+    NumberKind
+    >>> Symbol('y', commutative=False).kind
+    UndefinedKind
+
+    Operation between numbers results number.
+
+    >>> (x+1).kind
+    NumberKind
+
+    See Also
+    ========
+
+    sympy.core.expr.Expr.is_Number : check if the object is strictly
+    subclass of ``Number`` class.
+
+    sympy.core.expr.Expr.is_number : check if the object is number
+    without any free symbol.
+
+    """
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def __repr__(self):
+        return "NumberKind"
+
+NumberKind = _NumberKind()
+
+
+class _BooleanKind(Kind):
+    """
+    Kind for boolean objects.
+
+    SymPy's ``S.true``, ``S.false``, and built-in ``True`` and ``False``
+    have this kind. Boolean number ``1`` and ``0`` are not relevant.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Q
+    >>> S.true.kind
+    BooleanKind
+    >>> Q.even(3).kind
+    BooleanKind
+    """
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def __repr__(self):
+        return "BooleanKind"
+
+BooleanKind = _BooleanKind()
+
+
+class KindDispatcher:
+    """
+    Dispatcher to select a kind from multiple kinds by binary dispatching.
+
+    .. notes::
+       This approach is experimental, and can be replaced or deleted in
+       the future.
+
+    Explanation
+    ===========
+
+    SymPy object's :obj:`sympy.core.kind.Kind()` vaguely represents the
+    algebraic structure where the object belongs to. Therefore, with
+    given operation, we can always find a dominating kind among the
+    different kinds. This class selects the kind by recursive binary
+    dispatching. If the result cannot be determined, ``UndefinedKind``
+    is returned.
+
+    Examples
+    ========
+
+    Multiplication between numbers return number.
+
+    >>> from sympy import NumberKind, Mul
+    >>> Mul._kind_dispatcher(NumberKind, NumberKind)
+    NumberKind
+
+    Multiplication between number and unknown-kind object returns unknown kind.
+
+    >>> from sympy import UndefinedKind
+    >>> Mul._kind_dispatcher(NumberKind, UndefinedKind)
+    UndefinedKind
+
+    Any number and order of kinds is allowed.
+
+    >>> Mul._kind_dispatcher(UndefinedKind, NumberKind)
+    UndefinedKind
+    >>> Mul._kind_dispatcher(NumberKind, UndefinedKind, NumberKind)
+    UndefinedKind
+
+    Since matrix forms a vector space over scalar field, multiplication
+    between matrix with numeric element and number returns matrix with
+    numeric element.
+
+    >>> from sympy.matrices import MatrixKind
+    >>> Mul._kind_dispatcher(MatrixKind(NumberKind), NumberKind)
+    MatrixKind(NumberKind)
+
+    If a matrix with number element and another matrix with unknown-kind
+    element are multiplied, we know that the result is matrix but the
+    kind of its elements is unknown.
+
+    >>> Mul._kind_dispatcher(MatrixKind(NumberKind), MatrixKind(UndefinedKind))
+    MatrixKind(UndefinedKind)
+
+    Parameters
+    ==========
+
+    name : str
+
+    commutative : bool, optional
+        If True, binary dispatch will be automatically registered in
+        reversed order as well.
+
+    doc : str, optional
+
+    """
+    def __init__(self, name, commutative=False, doc=None):
+        self.name = name
+        self.doc = doc
+        self.commutative = commutative
+        self._dispatcher = Dispatcher(name)
+
+    def __repr__(self):
+        return "<dispatched %s>" % self.name
+
+    def register(self, *types, **kwargs):
+        """
+        Register the binary dispatcher for two kind classes.
+
+        If *self.commutative* is ``True``, signature in reversed order is
+        automatically registered as well.
+        """
+        on_ambiguity = kwargs.pop("on_ambiguity", None)
+        if not on_ambiguity:
+            if self.commutative:
+                on_ambiguity = ambiguity_register_error_ignore_dup
+            else:
+                on_ambiguity = ambiguity_warn
+        kwargs.update(on_ambiguity=on_ambiguity)
+
+        if not len(types) == 2:
+            raise RuntimeError(
+                "Only binary dispatch is supported, but got %s types: <%s>." % (
+                len(types), str_signature(types)
+            ))
+
+        def _(func):
+            self._dispatcher.add(types, func, **kwargs)
+            if self.commutative:
+                self._dispatcher.add(tuple(reversed(types)), func, **kwargs)
+        return _
+
+    def __call__(self, *args, **kwargs):
+        if self.commutative:
+            kinds = frozenset(args)
+        else:
+            kinds = []
+            prev = None
+            for a in args:
+                if prev is not a:
+                    kinds.append(a)
+                    prev = a
+        return self.dispatch_kinds(kinds, **kwargs)
+
+    @cacheit
+    def dispatch_kinds(self, kinds, **kwargs):
+        # Quick exit for the case where all kinds are same
+        if len(kinds) == 1:
+            result, = kinds
+            if not isinstance(result, Kind):
+                raise RuntimeError("%s is not a kind." % result)
+            return result
+
+        for i,kind in enumerate(kinds):
+            if not isinstance(kind, Kind):
+                raise RuntimeError("%s is not a kind." % kind)
+
+            if i == 0:
+                result = kind
+            else:
+                prev_kind = result
+
+                t1, t2 = type(prev_kind), type(kind)
+                k1, k2 = prev_kind, kind
+                func = self._dispatcher.dispatch(t1, t2)
+                if func is None and self.commutative:
+                    # try reversed order
+                    func = self._dispatcher.dispatch(t2, t1)
+                    k1, k2 = k2, k1
+                if func is None:
+                    # unregistered kind relation
+                    result = UndefinedKind
+                else:
+                    result = func(k1, k2)
+                if not isinstance(result, Kind):
+                    raise RuntimeError(
+                        "Dispatcher for {!r} and {!r} must return a Kind, but got {!r}".format(
+                        prev_kind, kind, result
+                    ))
+
+        return result
+
+    @property
+    def __doc__(self):
+        docs = [
+            "Kind dispatcher : %s" % self.name,
+            "Note that support for this is experimental. See the docs for :class:`KindDispatcher` for details"
+        ]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        s = "Registered kind 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 func, sigs in typ_sigs.items():
+
+            sigs_str = ', '.join('<%s>' % str_signature(sig) for sig in sigs)
+
+            if isinstance(func, RaiseNotImplementedError):
+                amb_sigs.append(sigs_str)
+                continue
+
+            s = 'Inputs: %s\n' % sigs_str
+            s += '-' * len(s) + '\n'
+            if func.__doc__:
+                s += func.__doc__.strip()
+            else:
+                s += func.__name__
+            docs.append(s)
+
+        if amb_sigs:
+            s = "Ambiguous kind 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/mul.py

@@ -0,0 +1,2195 @@
+from typing import Tuple as tTuple
+from collections import defaultdict
+from functools import cmp_to_key, reduce
+from itertools import product
+import operator
+
+from .sympify import sympify
+from .basic import Basic
+from .singleton import S
+from .operations import AssocOp, AssocOpDispatcher
+from .cache import cacheit
+from .logic import fuzzy_not, _fuzzy_group
+from .expr import Expr
+from .parameters import global_parameters
+from .kind import KindDispatcher
+from .traversal import bottom_up
+
+from sympy.utilities.iterables import sift
+
+# internal marker to indicate:
+#   "there are still non-commutative objects -- don't forget to process them"
+class NC_Marker:
+    is_Order = False
+    is_Mul = False
+    is_Number = False
+    is_Poly = False
+
+    is_commutative = False
+
+
+# Key for sorting commutative args in canonical order
+_args_sortkey = cmp_to_key(Basic.compare)
+def _mulsort(args):
+    # in-place sorting of args
+    args.sort(key=_args_sortkey)
+
+
+def _unevaluated_Mul(*args):
+    """Return a well-formed unevaluated Mul: Numbers are collected and
+    put in slot 0, any arguments that are Muls will be flattened, and args
+    are sorted. Use this when args have changed but you still want to return
+    an unevaluated Mul.
+
+    Examples
+    ========
+
+    >>> from sympy.core.mul import _unevaluated_Mul as uMul
+    >>> from sympy import S, sqrt, Mul
+    >>> from sympy.abc import x
+    >>> a = uMul(*[S(3.0), x, S(2)])
+    >>> a.args[0]
+    6.00000000000000
+    >>> a.args[1]
+    x
+
+    Two unevaluated Muls with the same arguments will
+    always compare as equal during testing:
+
+    >>> m = uMul(sqrt(2), sqrt(3))
+    >>> m == uMul(sqrt(3), sqrt(2))
+    True
+    >>> u = Mul(sqrt(3), sqrt(2), evaluate=False)
+    >>> m == uMul(u)
+    True
+    >>> m == Mul(*m.args)
+    False
+
+    """
+    args = list(args)
+    newargs = []
+    ncargs = []
+    co = S.One
+    while args:
+        a = args.pop()
+        if a.is_Mul:
+            c, nc = a.args_cnc()
+            args.extend(c)
+            if nc:
+                ncargs.append(Mul._from_args(nc))
+        elif a.is_Number:
+            co *= a
+        else:
+            newargs.append(a)
+    _mulsort(newargs)
+    if co is not S.One:
+        newargs.insert(0, co)
+    if ncargs:
+        newargs.append(Mul._from_args(ncargs))
+    return Mul._from_args(newargs)
+
+
+class Mul(Expr, AssocOp):
+    """
+    Expression representing multiplication operation for algebraic field.
+
+    .. 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 ``Mul()`` must be ``Expr``. Infix operator ``*``
+    on most scalar objects in SymPy calls this class.
+
+    Another use of ``Mul()`` is to represent the structure of abstract
+    multiplication so that its arguments can be substituted to return
+    different class. Refer to examples section for this.
+
+    ``Mul()`` evaluates the argument unless ``evaluate=False`` is passed.
+    The evaluation logic includes:
+
+    1. Flattening
+        ``Mul(x, Mul(y, z))`` -> ``Mul(x, y, z)``
+
+    2. Identity removing
+        ``Mul(x, 1, y)`` -> ``Mul(x, y)``
+
+    3. Exponent collecting by ``.as_base_exp()``
+        ``Mul(x, x**2)`` -> ``Pow(x, 3)``
+
+    4. Term sorting
+        ``Mul(y, x, 2)`` -> ``Mul(2, x, y)``
+
+    Since multiplication can be vector space operation, arguments may
+    have the different :obj:`sympy.core.kind.Kind()`. Kind of the
+    resulting object is automatically inferred.
+
+    Examples
+    ========
+
+    >>> from sympy import Mul
+    >>> from sympy.abc import x, y
+    >>> Mul(x, 1)
+    x
+    >>> Mul(x, x)
+    x**2
+
+    If ``evaluate=False`` is passed, result is not evaluated.
+
+    >>> Mul(1, 2, evaluate=False)
+    1*2
+    >>> Mul(x, x, evaluate=False)
+    x*x
+
+    ``Mul()`` also represents the general structure of multiplication
+    operation.
+
+    >>> from sympy import MatrixSymbol
+    >>> A = MatrixSymbol('A', 2,2)
+    >>> expr = Mul(x,y).subs({y:A})
+    >>> expr
+    x*A
+    >>> type(expr)
+    <class 'sympy.matrices.expressions.matmul.MatMul'>
+
+    See Also
+    ========
+
+    MatMul
+
+    """
+    __slots__ = ()
+
+    args: tTuple[Expr]
+
+    is_Mul = True
+
+    _args_type = Expr
+    _kind_dispatcher = KindDispatcher("Mul_kind_dispatcher", commutative=True)
+
+    @property
+    def kind(self):
+        arg_kinds = (a.kind for a in self.args)
+        return self._kind_dispatcher(*arg_kinds)
+
+    def could_extract_minus_sign(self):
+        if self == (-self):
+            return False  # e.g. zoo*x == -zoo*x
+        c = self.args[0]
+        return c.is_Number and c.is_extended_negative
+
+    def __neg__(self):
+        c, args = self.as_coeff_mul()
+        if args[0] is not S.ComplexInfinity:
+            c = -c
+        if c is not S.One:
+            if args[0].is_Number:
+                args = list(args)
+                if c is S.NegativeOne:
+                    args[0] = -args[0]
+                else:
+                    args[0] *= c
+            else:
+                args = (c,) + args
+        return self._from_args(args, self.is_commutative)
+
+    @classmethod
+    def flatten(cls, seq):
+        """Return commutative, noncommutative and order arguments by
+        combining related terms.
+
+        Notes
+        =====
+            * In an expression like ``a*b*c``, Python process this through SymPy
+              as ``Mul(Mul(a, b), c)``. This can have undesirable consequences.
+
+              -  Sometimes terms are not combined as one would like:
+                 {c.f. https://github.com/sympy/sympy/issues/4596}
+
+                >>> from sympy import Mul, sqrt
+                >>> from sympy.abc import x, y, z
+                >>> 2*(x + 1) # this is the 2-arg Mul behavior
+                2*x + 2
+                >>> y*(x + 1)*2
+                2*y*(x + 1)
+                >>> 2*(x + 1)*y # 2-arg result will be obtained first
+                y*(2*x + 2)
+                >>> Mul(2, x + 1, y) # all 3 args simultaneously processed
+                2*y*(x + 1)
+                >>> 2*((x + 1)*y) # parentheses can control this behavior
+                2*y*(x + 1)
+
+                Powers with compound bases may not find a single base to
+                combine with unless all arguments are processed at once.
+                Post-processing may be necessary in such cases.
+                {c.f. https://github.com/sympy/sympy/issues/5728}
+
+                >>> a = sqrt(x*sqrt(y))
+                >>> a**3
+                (x*sqrt(y))**(3/2)
+                >>> Mul(a,a,a)
+                (x*sqrt(y))**(3/2)
+                >>> a*a*a
+                x*sqrt(y)*sqrt(x*sqrt(y))
+                >>> _.subs(a.base, z).subs(z, a.base)
+                (x*sqrt(y))**(3/2)
+
+              -  If more than two terms are being multiplied then all the
+                 previous terms will be re-processed for each new argument.
+                 So if each of ``a``, ``b`` and ``c`` were :class:`Mul`
+                 expression, then ``a*b*c`` (or building up the product
+                 with ``*=``) will process all the arguments of ``a`` and
+                 ``b`` twice: once when ``a*b`` is computed and again when
+                 ``c`` is multiplied.
+
+                 Using ``Mul(a, b, c)`` will process all arguments once.
+
+            * The results of Mul are cached according to arguments, so flatten
+              will only be called once for ``Mul(a, b, c)``. If you can
+              structure a calculation so the arguments are most likely to be
+              repeats then this can save time in computing the answer. For
+              example, say you had a Mul, M, that you wished to divide by ``d[i]``
+              and multiply by ``n[i]`` and you suspect there are many repeats
+              in ``n``. It would be better to compute ``M*n[i]/d[i]`` rather
+              than ``M/d[i]*n[i]`` since every time n[i] is a repeat, the
+              product, ``M*n[i]`` will be returned without flattening -- the
+              cached value will be returned. If you divide by the ``d[i]``
+              first (and those are more unique than the ``n[i]``) then that will
+              create a new Mul, ``M/d[i]`` the args of which will be traversed
+              again when it is multiplied by ``n[i]``.
+
+              {c.f. https://github.com/sympy/sympy/issues/5706}
+
+              This consideration is moot if the cache is turned off.
+
+            NB
+            --
+              The validity of the above notes depends on the implementation
+              details of Mul and flatten which may change at any time. Therefore,
+              you should only consider them when your code is highly performance
+              sensitive.
+
+              Removal of 1 from the sequence is already handled by AssocOp.__new__.
+        """
+
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.matrices.expressions import MatrixExpr
+        rv = None
+        if len(seq) == 2:
+            a, b = seq
+            if b.is_Rational:
+                a, b = b, a
+                seq = [a, b]
+            assert a is not S.One
+            if not a.is_zero and a.is_Rational:
+                r, b = b.as_coeff_Mul()
+                if b.is_Add:
+                    if r is not S.One:  # 2-arg hack
+                        # leave the Mul as a Mul?
+                        ar = a*r
+                        if ar is S.One:
+                            arb = b
+                        else:
+                            arb = cls(a*r, b, evaluate=False)
+                        rv = [arb], [], None
+                    elif global_parameters.distribute and b.is_commutative:
+                        newb = Add(*[_keep_coeff(a, bi) for bi in b.args])
+                        rv = [newb], [], None
+            if rv:
+                return rv
+
+        # apply associativity, separate commutative part of seq
+        c_part = []         # out: commutative factors
+        nc_part = []        # out: non-commutative factors
+
+        nc_seq = []
+
+        coeff = S.One       # standalone term
+                            # e.g. 3 * ...
+
+        c_powers = []       # (base,exp)      n
+                            # e.g. (x,n) for x
+
+        num_exp = []        # (num-base, exp)           y
+                            # e.g.  (3, y)  for  ... * 3  * ...
+
+        neg1e = S.Zero      # exponent on -1 extracted from Number-based Pow and I
+
+        pnum_rat = {}       # (num-base, Rat-exp)          1/2
+                            # e.g.  (3, 1/2)  for  ... * 3     * ...
+
+        order_symbols = None
+
+        # --- PART 1 ---
+        #
+        # "collect powers and coeff":
+        #
+        # o coeff
+        # o c_powers
+        # o num_exp
+        # o neg1e
+        # o pnum_rat
+        #
+        # NOTE: this is optimized for all-objects-are-commutative case
+        for o in seq:
+            # O(x)
+            if o.is_Order:
+                o, order_symbols = o.as_expr_variables(order_symbols)
+
+            # Mul([...])
+            if o.is_Mul:
+                if o.is_commutative:
+                    seq.extend(o.args)    # XXX zerocopy?
+
+                else:
+                    # NCMul can have commutative parts as well
+                    for q in o.args:
+                        if q.is_commutative:
+                            seq.append(q)
+                        else:
+                            nc_seq.append(q)
+
+                    # append non-commutative marker, so we don't forget to
+                    # process scheduled non-commutative objects
+                    seq.append(NC_Marker)
+
+                continue
+
+            # 3
+            elif o.is_Number:
+                if o is S.NaN or coeff is S.ComplexInfinity and o.is_zero:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+                elif coeff.is_Number or isinstance(coeff, AccumBounds):  # it could be zoo
+                    coeff *= o
+                    if coeff is S.NaN:
+                        # we know for sure the result will be nan
+                        return [S.NaN], [], None
+                continue
+
+            elif isinstance(o, AccumBounds):
+                coeff = o.__mul__(coeff)
+                continue
+
+            elif o is S.ComplexInfinity:
+                if not coeff:
+                    # 0 * zoo = NaN
+                    return [S.NaN], [], None
+                coeff = S.ComplexInfinity
+                continue
+
+            elif o is S.ImaginaryUnit:
+                neg1e += S.Half
+                continue
+
+            elif o.is_commutative:
+                #      e
+                # o = b
+                b, e = o.as_base_exp()
+
+                #  y
+                # 3
+                if o.is_Pow:
+                    if b.is_Number:
+
+                        # get all the factors with numeric base so they can be
+                        # combined below, but don't combine negatives unless
+                        # the exponent is an integer
+                        if e.is_Rational:
+                            if e.is_Integer:
+                                coeff *= Pow(b, e)  # it is an unevaluated power
+                                continue
+                            elif e.is_negative:    # also a sign of an unevaluated power
+                                seq.append(Pow(b, e))
+                                continue
+                            elif b.is_negative:
+                                neg1e += e
+                                b = -b
+                            if b is not S.One:
+                                pnum_rat.setdefault(b, []).append(e)
+                            continue
+                        elif b.is_positive or e.is_integer:
+                            num_exp.append((b, e))
+                            continue
+
+                c_powers.append((b, e))
+
+            # NON-COMMUTATIVE
+            # TODO: Make non-commutative exponents not combine automatically
+            else:
+                if o is not NC_Marker:
+                    nc_seq.append(o)
+
+                # process nc_seq (if any)
+                while nc_seq:
+                    o = nc_seq.pop(0)
+                    if not nc_part:
+                        nc_part.append(o)
+                        continue
+
+                    #                             b    c       b+c
+                    # try to combine last terms: a  * a   ->  a
+                    o1 = nc_part.pop()
+                    b1, e1 = o1.as_base_exp()
+                    b2, e2 = o.as_base_exp()
+                    new_exp = e1 + e2
+                    # Only allow powers to combine if the new exponent is
+                    # not an Add. This allow things like a**2*b**3 == a**5
+                    # if a.is_commutative == False, but prohibits
+                    # a**x*a**y and x**a*x**b from combining (x,y commute).
+                    if b1 == b2 and (not new_exp.is_Add):
+                        o12 = b1 ** new_exp
+
+                        # now o12 could be a commutative object
+                        if o12.is_commutative:
+                            seq.append(o12)
+                            continue
+                        else:
+                            nc_seq.insert(0, o12)
+
+                    else:
+                        nc_part.extend([o1, o])
+
+        # We do want a combined exponent if it would not be an Add, such as
+        #  y    2y     3y
+        # x  * x   -> x
+        # We determine if two exponents have the same term by using
+        # as_coeff_Mul.
+        #
+        # Unfortunately, this isn't smart enough to consider combining into
+        # exponents that might already be adds, so things like:
+        #  z - y    y
+        # x      * x  will be left alone.  This is because checking every possible
+        # combination can slow things down.
+
+        # gather exponents of common bases...
+        def _gather(c_powers):
+            common_b = {}  # b:e
+            for b, e in c_powers:
+                co = e.as_coeff_Mul()
+                common_b.setdefault(b, {}).setdefault(
+                    co[1], []).append(co[0])
+            for b, d in common_b.items():
+                for di, li in d.items():
+                    d[di] = Add(*li)
+            new_c_powers = []
+            for b, e in common_b.items():
+                new_c_powers.extend([(b, c*t) for t, c in e.items()])
+            return new_c_powers
+
+        # in c_powers
+        c_powers = _gather(c_powers)
+
+        # and in num_exp
+        num_exp = _gather(num_exp)
+
+        # --- PART 2 ---
+        #
+        # o process collected powers  (x**0 -> 1; x**1 -> x; otherwise Pow)
+        # o combine collected powers  (2**x * 3**x -> 6**x)
+        #   with numeric base
+
+        # ................................
+        # now we have:
+        # - coeff:
+        # - c_powers:    (b, e)
+        # - num_exp:     (2, e)
+        # - pnum_rat:    {(1/3, [1/3, 2/3, 1/4])}
+
+        #  0             1
+        # x  -> 1       x  -> x
+
+        # this should only need to run twice; if it fails because
+        # it needs to be run more times, perhaps this should be
+        # changed to a "while True" loop -- the only reason it
+        # isn't such now is to allow a less-than-perfect result to
+        # be obtained rather than raising an error or entering an
+        # infinite loop
+        for i in range(2):
+            new_c_powers = []
+            changed = False
+            for b, e in c_powers:
+                if e.is_zero:
+                    # canceling out infinities yields NaN
+                    if (b.is_Add or b.is_Mul) and any(infty in b.args
+                        for infty in (S.ComplexInfinity, S.Infinity,
+                                      S.NegativeInfinity)):
+                        return [S.NaN], [], None
+                    continue
+                if e is S.One:
+                    if b.is_Number:
+                        coeff *= b
+                        continue
+                    p = b
+                if e is not S.One:
+                    p = Pow(b, e)
+                    # check to make sure that the base doesn't change
+                    # after exponentiation; to allow for unevaluated
+                    # Pow, we only do so if b is not already a Pow
+                    if p.is_Pow and not b.is_Pow:
+                        bi = b
+                        b, e = p.as_base_exp()
+                        if b != bi:
+                            changed = True
+                c_part.append(p)
+                new_c_powers.append((b, e))
+            # there might have been a change, but unless the base
+            # matches some other base, there is nothing to do
+            if changed and len({
+                    b for b, e in new_c_powers}) != len(new_c_powers):
+                # start over again
+                c_part = []
+                c_powers = _gather(new_c_powers)
+            else:
+                break
+
+        #  x    x     x
+        # 2  * 3  -> 6
+        inv_exp_dict = {}   # exp:Mul(num-bases)     x    x
+                            # e.g.  x:6  for  ... * 2  * 3  * ...
+        for b, e in num_exp:
+            inv_exp_dict.setdefault(e, []).append(b)
+        for e, b in inv_exp_dict.items():
+            inv_exp_dict[e] = cls(*b)
+        c_part.extend([Pow(b, e) for e, b in inv_exp_dict.items() if e])
+
+        # b, e -> e' = sum(e), b
+        # {(1/5, [1/3]), (1/2, [1/12, 1/4]} -> {(1/3, [1/5, 1/2])}
+        comb_e = {}
+        for b, e in pnum_rat.items():
+            comb_e.setdefault(Add(*e), []).append(b)
+        del pnum_rat
+        # process them, reducing exponents to values less than 1
+        # and updating coeff if necessary else adding them to
+        # num_rat for further processing
+        num_rat = []
+        for e, b in comb_e.items():
+            b = cls(*b)
+            if e.q == 1:
+                coeff *= Pow(b, e)
+                continue
+            if e.p > e.q:
+                e_i, ep = divmod(e.p, e.q)
+                coeff *= Pow(b, e_i)
+                e = Rational(ep, e.q)
+            num_rat.append((b, e))
+        del comb_e
+
+        # extract gcd of bases in num_rat
+        # 2**(1/3)*6**(1/4) -> 2**(1/3+1/4)*3**(1/4)
+        pnew = defaultdict(list)
+        i = 0  # steps through num_rat which may grow
+        while i < len(num_rat):
+            bi, ei = num_rat[i]
+            grow = []
+            for j in range(i + 1, len(num_rat)):
+                bj, ej = num_rat[j]
+                g = bi.gcd(bj)
+                if g is not S.One:
+                    # 4**r1*6**r2 -> 2**(r1+r2)  *  2**r1 *  3**r2
+                    # this might have a gcd with something else
+                    e = ei + ej
+                    if e.q == 1:
+                        coeff *= Pow(g, e)
+                    else:
+                        if e.p > e.q:
+                            e_i, ep = divmod(e.p, e.q)  # change e in place
+                            coeff *= Pow(g, e_i)
+                            e = Rational(ep, e.q)
+                        grow.append((g, e))
+                    # update the jth item
+                    num_rat[j] = (bj/g, ej)
+                    # update bi that we are checking with
+                    bi = bi/g
+                    if bi is S.One:
+                        break
+            if bi is not S.One:
+                obj = Pow(bi, ei)
+                if obj.is_Number:
+                    coeff *= obj
+                else:
+                    # changes like sqrt(12) -> 2*sqrt(3)
+                    for obj in Mul.make_args(obj):
+                        if obj.is_Number:
+                            coeff *= obj
+                        else:
+                            assert obj.is_Pow
+                            bi, ei = obj.args
+                            pnew[ei].append(bi)
+
+            num_rat.extend(grow)
+            i += 1
+
+        # combine bases of the new powers
+        for e, b in pnew.items():
+            pnew[e] = cls(*b)
+
+        # handle -1 and I
+        if neg1e:
+            # treat I as (-1)**(1/2) and compute -1's total exponent
+            p, q =  neg1e.as_numer_denom()
+            # if the integer part is odd, extract -1
+            n, p = divmod(p, q)
+            if n % 2:
+                coeff = -coeff
+            # if it's a multiple of 1/2 extract I
+            if q == 2:
+                c_part.append(S.ImaginaryUnit)
+            elif p:
+                # see if there is any positive base this power of
+                # -1 can join
+                neg1e = Rational(p, q)
+                for e, b in pnew.items():
+                    if e == neg1e and b.is_positive:
+                        pnew[e] = -b
+                        break
+                else:
+                    # keep it separate; we've already evaluated it as
+                    # much as possible so evaluate=False
+                    c_part.append(Pow(S.NegativeOne, neg1e, evaluate=False))
+
+        # add all the pnew powers
+        c_part.extend([Pow(b, e) for e, b in pnew.items()])
+
+        # oo, -oo
+        if coeff in (S.Infinity, S.NegativeInfinity):
+            def _handle_for_oo(c_part, coeff_sign):
+                new_c_part = []
+                for t in c_part:
+                    if t.is_extended_positive:
+                        continue
+                    if t.is_extended_negative:
+                        coeff_sign *= -1
+                        continue
+                    new_c_part.append(t)
+                return new_c_part, coeff_sign
+            c_part, coeff_sign = _handle_for_oo(c_part, 1)
+            nc_part, coeff_sign = _handle_for_oo(nc_part, coeff_sign)
+            coeff *= coeff_sign
+
+        # zoo
+        if coeff is S.ComplexInfinity:
+            # zoo might be
+            #   infinite_real + bounded_im
+            #   bounded_real + infinite_im
+            #   infinite_real + infinite_im
+            # and non-zero real or imaginary will not change that status.
+            c_part = [c for c in c_part if not (fuzzy_not(c.is_zero) and
+                                                c.is_extended_real is not None)]
+            nc_part = [c for c in nc_part if not (fuzzy_not(c.is_zero) and
+                                                  c.is_extended_real is not None)]
+
+        # 0
+        elif coeff.is_zero:
+            # we know for sure the result will be 0 except the multiplicand
+            # is infinity or a matrix
+            if any(isinstance(c, MatrixExpr) for c in nc_part):
+                return [coeff], nc_part, order_symbols
+            if any(c.is_finite == False for c in c_part):
+                return [S.NaN], [], order_symbols
+            return [coeff], [], order_symbols
+
+        # check for straggling Numbers that were produced
+        _new = []
+        for i in c_part:
+            if i.is_Number:
+                coeff *= i
+            else:
+                _new.append(i)
+        c_part = _new
+
+        # order commutative part canonically
+        _mulsort(c_part)
+
+        # current code expects coeff to be always in slot-0
+        if coeff is not S.One:
+            c_part.insert(0, coeff)
+
+        # we are done
+        if (global_parameters.distribute and not nc_part and len(c_part) == 2 and
+                c_part[0].is_Number and c_part[0].is_finite and c_part[1].is_Add):
+            # 2*(1+a) -> 2 + 2 * a
+            coeff = c_part[0]
+            c_part = [Add(*[coeff*f for f in c_part[1].args])]
+
+        return c_part, nc_part, order_symbols
+
+    def _eval_power(self, e):
+
+        # don't break up NC terms: (A*B)**3 != A**3*B**3, it is A*B*A*B*A*B
+        cargs, nc = self.args_cnc(split_1=False)
+
+        if e.is_Integer:
+            return Mul(*[Pow(b, e, evaluate=False) for b in cargs]) * \
+                Pow(Mul._from_args(nc), e, evaluate=False)
+        if e.is_Rational and e.q == 2:
+            if self.is_imaginary:
+                a = self.as_real_imag()[1]
+                if a.is_Rational:
+                    from .power import integer_nthroot
+                    n, d = abs(a/2).as_numer_denom()
+                    n, t = integer_nthroot(n, 2)
+                    if t:
+                        d, t = integer_nthroot(d, 2)
+                        if t:
+                            from sympy.functions.elementary.complexes import sign
+                            r = sympify(n)/d
+                            return _unevaluated_Mul(r**e.p, (1 + sign(a)*S.ImaginaryUnit)**e.p)
+
+        p = Pow(self, e, evaluate=False)
+
+        if e.is_Rational or e.is_Float:
+            return p._eval_expand_power_base()
+
+        return p
+
+    @classmethod
+    def class_key(cls):
+        return 3, 0, cls.__name__
+
+    def _eval_evalf(self, prec):
+        c, m = self.as_coeff_Mul()
+        if c is S.NegativeOne:
+            if m.is_Mul:
+                rv = -AssocOp._eval_evalf(m, prec)
+            else:
+                mnew = m._eval_evalf(prec)
+                if mnew is not None:
+                    m = mnew
+                rv = -m
+        else:
+            rv = AssocOp._eval_evalf(self, prec)
+        if rv.is_number:
+            return rv.expand()
+        return rv
+
+    @property
+    def _mpc_(self):
+        """
+        Convert self to an mpmath mpc if possible
+        """
+        from .numbers import Float
+        im_part, imag_unit = self.as_coeff_Mul()
+        if imag_unit is not 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 Mul to mpc. Must be of the form Number*I")
+
+        return (Float(0)._mpf_, Float(im_part)._mpf_)
+
+    @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_mul() which gives the head and a tuple containing
+          the arguments of the tail when treated as a Mul.
+        - if you want the coefficient when self is treated as an Add
+          then use self.as_coeff_add()[0]
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> (3*x*y).as_two_terms()
+        (3, x*y)
+        """
+        args = self.args
+
+        if len(args) == 1:
+            return S.One, self
+        elif len(args) == 2:
+            return args
+
+        else:
+            return args[0], self._new_rawargs(*args[1:])
+
+    @cacheit
+    def as_coeff_mul(self, *deps, rational=True, **kwargs):
+        if deps:
+            l1, l2 = sift(self.args, lambda x: x.has(*deps), binary=True)
+            return self._new_rawargs(*l2), tuple(l1)
+        args = self.args
+        if args[0].is_Number:
+            if not rational or args[0].is_Rational:
+                return args[0], args[1:]
+            elif args[0].is_extended_negative:
+                return S.NegativeOne, (-args[0],) + args[1:]
+        return S.One, args
+
+    def as_coeff_Mul(self, rational=False):
+        """
+        Efficiently extract the coefficient of a product.
+        """
+        coeff, args = self.args[0], self.args[1:]
+
+        if coeff.is_Number:
+            if not rational or coeff.is_Rational:
+                if len(args) == 1:
+                    return coeff, args[0]
+                else:
+                    return coeff, self._new_rawargs(*args)
+            elif coeff.is_extended_negative:
+                return S.NegativeOne, self._new_rawargs(*((-coeff,) + args))
+        return S.One, self
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.complexes import Abs, im, re
+        other = []
+        coeffr = []
+        coeffi = []
+        addterms = S.One
+        for a in self.args:
+            r, i = a.as_real_imag()
+            if i.is_zero:
+                coeffr.append(r)
+            elif r.is_zero:
+                coeffi.append(i*S.ImaginaryUnit)
+            elif a.is_commutative:
+                aconj = a.conjugate() if other else None
+                # search for complex conjugate pairs:
+                for i, x in enumerate(other):
+                    if x == aconj:
+                        coeffr.append(Abs(x)**2)
+                        del other[i]
+                        break
+                else:
+                    if a.is_Add:
+                        addterms *= a
+                    else:
+                        other.append(a)
+            else:
+                other.append(a)
+        m = self.func(*other)
+        if hints.get('ignore') == m:
+            return
+        if len(coeffi) % 2:
+            imco = im(coeffi.pop(0))
+            # all other pairs make a real factor; they will be
+            # put into reco below
+        else:
+            imco = S.Zero
+        reco = self.func(*(coeffr + coeffi))
+        r, i = (reco*re(m), reco*im(m))
+        if addterms == 1:
+            if m == 1:
+                if imco.is_zero:
+                    return (reco, S.Zero)
+                else:
+                    return (S.Zero, reco*imco)
+            if imco is S.Zero:
+                return (r, i)
+            return (-imco*i, imco*r)
+        from .function import expand_mul
+        addre, addim = expand_mul(addterms, deep=False).as_real_imag()
+        if imco is S.Zero:
+            return (r*addre - i*addim, i*addre + r*addim)
+        else:
+            r, i = -imco*i, imco*r
+            return (r*addre - i*addim, r*addim + i*addre)
+
+    @staticmethod
+    def _expandsums(sums):
+        """
+        Helper function for _eval_expand_mul.
+
+        sums must be a list of instances of Basic.
+        """
+
+        L = len(sums)
+        if L == 1:
+            return sums[0].args
+        terms = []
+        left = Mul._expandsums(sums[:L//2])
+        right = Mul._expandsums(sums[L//2:])
+
+        terms = [Mul(a, b) for a in left for b in right]
+        added = Add(*terms)
+        return Add.make_args(added)  # it may have collapsed down to one term
+
+    def _eval_expand_mul(self, **hints):
+        from sympy.simplify.radsimp import fraction
+
+        # Handle things like 1/(x*(x + 1)), which are automatically converted
+        # to 1/x*1/(x + 1)
+        expr = self
+        n, d = fraction(expr)
+        if d.is_Mul:
+            n, d = [i._eval_expand_mul(**hints) if i.is_Mul else i
+                for i in (n, d)]
+        expr = n/d
+        if not expr.is_Mul:
+            return expr
+
+        plain, sums, rewrite = [], [], False
+        for factor in expr.args:
+            if factor.is_Add:
+                sums.append(factor)
+                rewrite = True
+            else:
+                if factor.is_commutative:
+                    plain.append(factor)
+                else:
+                    sums.append(Basic(factor))  # Wrapper
+
+        if not rewrite:
+            return expr
+        else:
+            plain = self.func(*plain)
+            if sums:
+                deep = hints.get("deep", False)
+                terms = self.func._expandsums(sums)
+                args = []
+                for term in terms:
+                    t = self.func(plain, term)
+                    if t.is_Mul and any(a.is_Add for a in t.args) and deep:
+                        t = t._eval_expand_mul()
+                    args.append(t)
+                return Add(*args)
+            else:
+                return plain
+
+    @cacheit
+    def _eval_derivative(self, s):
+        args = list(self.args)
+        terms = []
+        for i in range(len(args)):
+            d = args[i].diff(s)
+            if d:
+                # Note: reduce is used in step of Mul as Mul is unable to
+                # handle subtypes and operation priority:
+                terms.append(reduce(lambda x, y: x*y, (args[:i] + [d] + args[i + 1:]), S.One))
+        return Add.fromiter(terms)
+
+    @cacheit
+    def _eval_derivative_n_times(self, s, n):
+        from .function import AppliedUndef
+        from .symbol import Symbol, symbols, Dummy
+        if not isinstance(s, (AppliedUndef, Symbol)):
+            # other types of s may not be well behaved, e.g.
+            # (cos(x)*sin(y)).diff([[x, y, z]])
+            return super()._eval_derivative_n_times(s, n)
+        from .numbers import Integer
+        args = self.args
+        m = len(args)
+        if isinstance(n, (int, Integer)):
+            # https://en.wikipedia.org/wiki/General_Leibniz_rule#More_than_two_factors
+            terms = []
+            from sympy.ntheory.multinomial import multinomial_coefficients_iterator
+            for kvals, c in multinomial_coefficients_iterator(m, n):
+                p = Mul(*[arg.diff((s, k)) for k, arg in zip(kvals, args)])
+                terms.append(c * p)
+            return Add(*terms)
+        from sympy.concrete.summations import Sum
+        from sympy.functions.combinatorial.factorials import factorial
+        from sympy.functions.elementary.miscellaneous import Max
+        kvals = symbols("k1:%i" % m, cls=Dummy)
+        klast = n - sum(kvals)
+        nfact = factorial(n)
+        e, l = (# better to use the multinomial?
+            nfact/prod(map(factorial, kvals))/factorial(klast)*\
+            Mul(*[args[t].diff((s, kvals[t])) for t in range(m-1)])*\
+            args[-1].diff((s, Max(0, klast))),
+            [(k, 0, n) for k in kvals])
+        return Sum(e, *l)
+
+    def _eval_difference_delta(self, n, step):
+        from sympy.series.limitseq import difference_delta as dd
+        arg0 = self.args[0]
+        rest = Mul(*self.args[1:])
+        return (arg0.subs(n, n + step) * dd(rest, n, step) + dd(arg0, n, step) *
+                rest)
+
+    def _matches_simple(self, expr, repl_dict):
+        # handle (w*3).matches('x*5') -> {w: x*5/3}
+        coeff, terms = self.as_coeff_Mul()
+        terms = Mul.make_args(terms)
+        if len(terms) == 1:
+            newexpr = self.__class__._combine_inverse(expr, coeff)
+            return terms[0].matches(newexpr, repl_dict)
+        return
+
+    def matches(self, expr, repl_dict=None, old=False):
+        expr = sympify(expr)
+        if self.is_commutative and expr.is_commutative:
+            return self._matches_commutative(expr, repl_dict, old)
+        elif self.is_commutative is not expr.is_commutative:
+            return None
+
+        # Proceed only if both both expressions are non-commutative
+        c1, nc1 = self.args_cnc()
+        c2, nc2 = expr.args_cnc()
+        c1, c2 = [c or [1] for c in [c1, c2]]
+
+        # TODO: Should these be self.func?
+        comm_mul_self = Mul(*c1)
+        comm_mul_expr = Mul(*c2)
+
+        repl_dict = comm_mul_self.matches(comm_mul_expr, repl_dict, old)
+
+        # If the commutative arguments didn't match and aren't equal, then
+        # then the expression as a whole doesn't match
+        if not repl_dict and c1 != c2:
+            return None
+
+        # Now match the non-commutative arguments, expanding powers to
+        # multiplications
+        nc1 = Mul._matches_expand_pows(nc1)
+        nc2 = Mul._matches_expand_pows(nc2)
+
+        repl_dict = Mul._matches_noncomm(nc1, nc2, repl_dict)
+
+        return repl_dict or None
+
+    @staticmethod
+    def _matches_expand_pows(arg_list):
+        new_args = []
+        for arg in arg_list:
+            if arg.is_Pow and arg.exp > 0:
+                new_args.extend([arg.base] * arg.exp)
+            else:
+                new_args.append(arg)
+        return new_args
+
+    @staticmethod
+    def _matches_noncomm(nodes, targets, repl_dict=None):
+        """Non-commutative multiplication matcher.
+
+        `nodes` is a list of symbols within the matcher multiplication
+        expression, while `targets` is a list of arguments in the
+        multiplication expression being matched against.
+        """
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+
+        # List of possible future states to be considered
+        agenda = []
+        # The current matching state, storing index in nodes and targets
+        state = (0, 0)
+        node_ind, target_ind = state
+        # Mapping between wildcard indices and the index ranges they match
+        wildcard_dict = {}
+
+        while target_ind < len(targets) and node_ind < len(nodes):
+            node = nodes[node_ind]
+
+            if node.is_Wild:
+                Mul._matches_add_wildcard(wildcard_dict, state)
+
+            states_matches = Mul._matches_new_states(wildcard_dict, state,
+                                                     nodes, targets)
+            if states_matches:
+                new_states, new_matches = states_matches
+                agenda.extend(new_states)
+                if new_matches:
+                    for match in new_matches:
+                        repl_dict[match] = new_matches[match]
+            if not agenda:
+                return None
+            else:
+                state = agenda.pop()
+                node_ind, target_ind = state
+
+        return repl_dict
+
+    @staticmethod
+    def _matches_add_wildcard(dictionary, state):
+        node_ind, target_ind = state
+        if node_ind in dictionary:
+            begin, end = dictionary[node_ind]
+            dictionary[node_ind] = (begin, target_ind)
+        else:
+            dictionary[node_ind] = (target_ind, target_ind)
+
+    @staticmethod
+    def _matches_new_states(dictionary, state, nodes, targets):
+        node_ind, target_ind = state
+        node = nodes[node_ind]
+        target = targets[target_ind]
+
+        # Don't advance at all if we've exhausted the targets but not the nodes
+        if target_ind >= len(targets) - 1 and node_ind < len(nodes) - 1:
+            return None
+
+        if node.is_Wild:
+            match_attempt = Mul._matches_match_wilds(dictionary, node_ind,
+                                                     nodes, targets)
+            if match_attempt:
+                # If the same node has been matched before, don't return
+                # anything if the current match is diverging from the previous
+                # match
+                other_node_inds = Mul._matches_get_other_nodes(dictionary,
+                                                               nodes, node_ind)
+                for ind in other_node_inds:
+                    other_begin, other_end = dictionary[ind]
+                    curr_begin, curr_end = dictionary[node_ind]
+
+                    other_targets = targets[other_begin:other_end + 1]
+                    current_targets = targets[curr_begin:curr_end + 1]
+
+                    for curr, other in zip(current_targets, other_targets):
+                        if curr != other:
+                            return None
+
+                # A wildcard node can match more than one target, so only the
+                # target index is advanced
+                new_state = [(node_ind, target_ind + 1)]
+                # Only move on to the next node if there is one
+                if node_ind < len(nodes) - 1:
+                    new_state.append((node_ind + 1, target_ind + 1))
+                return new_state, match_attempt
+        else:
+            # If we're not at a wildcard, then make sure we haven't exhausted
+            # nodes but not targets, since in this case one node can only match
+            # one target
+            if node_ind >= len(nodes) - 1 and target_ind < len(targets) - 1:
+                return None
+
+            match_attempt = node.matches(target)
+
+            if match_attempt:
+                return [(node_ind + 1, target_ind + 1)], match_attempt
+            elif node == target:
+                return [(node_ind + 1, target_ind + 1)], None
+            else:
+                return None
+
+    @staticmethod
+    def _matches_match_wilds(dictionary, wildcard_ind, nodes, targets):
+        """Determine matches of a wildcard with sub-expression in `target`."""
+        wildcard = nodes[wildcard_ind]
+        begin, end = dictionary[wildcard_ind]
+        terms = targets[begin:end + 1]
+        # TODO: Should this be self.func?
+        mult = Mul(*terms) if len(terms) > 1 else terms[0]
+        return wildcard.matches(mult)
+
+    @staticmethod
+    def _matches_get_other_nodes(dictionary, nodes, node_ind):
+        """Find other wildcards that may have already been matched."""
+        ind_node = nodes[node_ind]
+        return [ind for ind in dictionary if nodes[ind] == ind_node]
+
+    @staticmethod
+    def _combine_inverse(lhs, rhs):
+        """
+        Returns lhs/rhs, but treats arguments like symbols, so things
+        like oo/oo return 1 (instead of a nan) and ``I`` behaves like
+        a symbol instead of sqrt(-1).
+        """
+        from sympy.simplify.simplify import signsimp
+        from .symbol import Dummy
+        if lhs == rhs:
+            return S.One
+
+        def check(l, r):
+            if l.is_Float and r.is_comparable:
+                # if both objects are added to 0 they will share the same "normalization"
+                # and are more likely to compare the same. Since Add(foo, 0) will not allow
+                # the 0 to pass, we use __add__ directly.
+                return l.__add__(0) == r.evalf().__add__(0)
+            return False
+        if check(lhs, rhs) or check(rhs, lhs):
+            return S.One
+        if any(i.is_Pow or i.is_Mul for i in (lhs, rhs)):
+            # gruntz and limit wants a literal I to not combine
+            # with a power of -1
+            d = Dummy('I')
+            _i = {S.ImaginaryUnit: d}
+            i_ = {d: S.ImaginaryUnit}
+            a = lhs.xreplace(_i).as_powers_dict()
+            b = rhs.xreplace(_i).as_powers_dict()
+            blen = len(b)
+            for bi in tuple(b.keys()):
+                if bi in a:
+                    a[bi] -= b.pop(bi)
+                    if not a[bi]:
+                        a.pop(bi)
+            if len(b) != blen:
+                lhs = Mul(*[k**v for k, v in a.items()]).xreplace(i_)
+                rhs = Mul(*[k**v for k, v in b.items()]).xreplace(i_)
+        rv = lhs/rhs
+        srv = signsimp(rv)
+        return srv if srv.is_Number else rv
+
+    def as_powers_dict(self):
+        d = defaultdict(int)
+        for term in self.args:
+            for b, e in term.as_powers_dict().items():
+                d[b] += e
+        return d
+
+    def as_numer_denom(self):
+        # don't use _from_args to rebuild the numerators and denominators
+        # as the order is not guaranteed to be the same once they have
+        # been separated from each other
+        numers, denoms = list(zip(*[f.as_numer_denom() for f in self.args]))
+        return self.func(*numers), self.func(*denoms)
+
+    def as_base_exp(self):
+        e1 = None
+        bases = []
+        nc = 0
+        for m in self.args:
+            b, e = m.as_base_exp()
+            if not b.is_commutative:
+                nc += 1
+            if e1 is None:
+                e1 = e
+            elif e != e1 or nc > 1:
+                return self, S.One
+            bases.append(b)
+        return self.func(*bases), e1
+
+    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)
+
+    _eval_is_commutative = lambda self: _fuzzy_group(
+        a.is_commutative for a in self.args)
+
+    def _eval_is_complex(self):
+        comp = _fuzzy_group(a.is_complex for a in self.args)
+        if comp is False:
+            if any(a.is_infinite for a in self.args):
+                if any(a.is_zero is not False for a in self.args):
+                    return None
+                return False
+        return comp
+
+    def _eval_is_zero_infinite_helper(self):
+        #
+        # Helper used by _eval_is_zero and _eval_is_infinite.
+        #
+        # Three-valued logic is tricky so let us reason this carefully. It
+        # would be nice to say that we just check is_zero/is_infinite in all
+        # args but we need to be careful about the case that one arg is zero
+        # and another is infinite like Mul(0, oo) or more importantly a case
+        # where it is not known if the arguments are zero or infinite like
+        # Mul(y, 1/x). If either y or x could be zero then there is a
+        # *possibility* that we have Mul(0, oo) which should give None for both
+        # is_zero and is_infinite.
+        #
+        # We keep track of whether we have seen a zero or infinity but we also
+        # need to keep track of whether we have *possibly* seen one which
+        # would be indicated by None.
+        #
+        # For each argument there is the possibility that is_zero might give
+        # True, False or None and likewise that is_infinite might give True,
+        # False or None, giving 9 combinations. The True cases for is_zero and
+        # is_infinite are mutually exclusive though so there are 3 main cases:
+        #
+        # - is_zero = True
+        # - is_infinite = True
+        # - is_zero and is_infinite are both either False or None
+        #
+        # At the end seen_zero and seen_infinite can be any of 9 combinations
+        # of True/False/None. Unless one is False though we cannot return
+        # anything except None:
+        #
+        # - is_zero=True needs seen_zero=True and seen_infinite=False
+        # - is_zero=False needs seen_zero=False
+        # - is_infinite=True needs seen_infinite=True and seen_zero=False
+        # - is_infinite=False needs seen_infinite=False
+        # - anything else gives both is_zero=None and is_infinite=None
+        #
+        # The loop only sets the flags to True or None and never back to False.
+        # Hence as soon as neither flag is False we exit early returning None.
+        # In particular as soon as we encounter a single arg that has
+        # is_zero=is_infinite=None we exit. This is a common case since it is
+        # the default assumptions for a Symbol and also the case for most
+        # expressions containing such a symbol. The early exit gives a big
+        # speedup for something like Mul(*symbols('x:1000')).is_zero.
+        #
+        seen_zero = seen_infinite = False
+
+        for a in self.args:
+            if a.is_zero:
+                if seen_infinite is not False:
+                    return None, None
+                seen_zero = True
+            elif a.is_infinite:
+                if seen_zero is not False:
+                    return None, None
+                seen_infinite = True
+            else:
+                if seen_zero is False and a.is_zero is None:
+                    if seen_infinite is not False:
+                        return None, None
+                    seen_zero = None
+                if seen_infinite is False and a.is_infinite is None:
+                    if seen_zero is not False:
+                        return None, None
+                    seen_infinite = None
+
+        return seen_zero, seen_infinite
+
+    def _eval_is_zero(self):
+        # True iff any arg is zero and no arg is infinite but need to handle
+        # three valued logic carefully.
+        seen_zero, seen_infinite = self._eval_is_zero_infinite_helper()
+
+        if seen_zero is False:
+            return False
+        elif seen_zero is True and seen_infinite is False:
+            return True
+        else:
+            return None
+
+    def _eval_is_infinite(self):
+        # True iff any arg is infinite and no arg is zero but need to handle
+        # three valued logic carefully.
+        seen_zero, seen_infinite = self._eval_is_zero_infinite_helper()
+
+        if seen_infinite is True and seen_zero is False:
+            return True
+        elif seen_infinite is False:
+            return False
+        else:
+            return None
+
+    # We do not need to implement _eval_is_finite because the assumptions
+    # system can infer it from finite = not infinite.
+
+    def _eval_is_rational(self):
+        r = _fuzzy_group((a.is_rational for a in self.args), quick_exit=True)
+        if r:
+            return r
+        elif r is False:
+            # All args except one are rational
+            if all(a.is_zero is False for a in self.args):
+                return False
+
+    def _eval_is_algebraic(self):
+        r = _fuzzy_group((a.is_algebraic for a in self.args), quick_exit=True)
+        if r:
+            return r
+        elif r is False:
+            # All args except one are algebraic
+            if all(a.is_zero is False for a in self.args):
+                return False
+
+    # without involving odd/even checks this code would suffice:
+    #_eval_is_integer = lambda self: _fuzzy_group(
+    #    (a.is_integer for a in self.args), quick_exit=True)
+    def _eval_is_integer(self):
+        from sympy.ntheory.factor_ import trailing
+        is_rational = self._eval_is_rational()
+        if is_rational is False:
+            return False
+
+        numerators = []
+        denominators = []
+        unknown = False
+        for a in self.args:
+            hit = False
+            if a.is_integer:
+                if abs(a) is not S.One:
+                    numerators.append(a)
+            elif a.is_Rational:
+                n, d = a.as_numer_denom()
+                if abs(n) is not S.One:
+                    numerators.append(n)
+                if d is not S.One:
+                    denominators.append(d)
+            elif a.is_Pow:
+                b, e = a.as_base_exp()
+                if not b.is_integer or not e.is_integer:
+                    hit = unknown = True
+                if e.is_negative:
+                    denominators.append(2 if a is S.Half else
+                        Pow(a, S.NegativeOne))
+                elif not hit:
+                    # int b and pos int e: a = b**e is integer
+                    assert not e.is_positive
+                    # for rational self and e equal to zero: a = b**e is 1
+                    assert not e.is_zero
+                    return # sign of e unknown -> self.is_integer unknown
+                else:
+                    # x**2, 2**x, or x**y with x and y int-unknown -> unknown
+                    return
+            else:
+                return
+
+        if not denominators and not unknown:
+            return True
+
+        allodd = lambda x: all(i.is_odd for i in x)
+        alleven = lambda x: all(i.is_even for i in x)
+        anyeven = lambda x: any(i.is_even for i in x)
+
+        from .relational import is_gt
+        if not numerators and denominators and all(
+                is_gt(_, S.One) for _ in denominators):
+            return False
+        elif unknown:
+            return
+        elif allodd(numerators) and anyeven(denominators):
+            return False
+        elif anyeven(numerators) and denominators == [2]:
+            return True
+        elif alleven(numerators) and allodd(denominators
+                ) and (Mul(*denominators, evaluate=False) - 1
+                ).is_positive:
+            return False
+        if len(denominators) == 1:
+            d = denominators[0]
+            if d.is_Integer and d.is_even:
+                # if minimal power of 2 in num vs den is not
+                # negative then we have an integer
+                if (Add(*[i.as_base_exp()[1] for i in
+                        numerators if i.is_even]) - trailing(d.p)
+                        ).is_nonnegative:
+                    return True
+        if len(numerators) == 1:
+            n = numerators[0]
+            if n.is_Integer and n.is_even:
+                # if minimal power of 2 in den vs num is positive
+                # then we have have a non-integer
+                if (Add(*[i.as_base_exp()[1] for i in
+                        denominators if i.is_even]) - trailing(n.p)
+                        ).is_positive:
+                    return False
+
+    def _eval_is_polar(self):
+        has_polar = any(arg.is_polar for arg in self.args)
+        return has_polar and \
+            all(arg.is_polar or arg.is_positive for arg in self.args)
+
+    def _eval_is_extended_real(self):
+        return self._eval_real_imag(True)
+
+    def _eval_real_imag(self, real):
+        zero = False
+        t_not_re_im = None
+
+        for t in self.args:
+            if (t.is_complex or t.is_infinite) is False and t.is_extended_real is False:
+                return False
+            elif t.is_imaginary:  # I
+                real = not real
+            elif t.is_extended_real:  # 2
+                if not zero:
+                    z = t.is_zero
+                    if not z and zero is False:
+                        zero = z
+                    elif z:
+                        if all(a.is_finite for a in self.args):
+                            return True
+                        return
+            elif t.is_extended_real is False:
+                # symbolic or literal like `2 + I` or symbolic imaginary
+                if t_not_re_im:
+                    return  # complex terms might cancel
+                t_not_re_im = t
+            elif t.is_imaginary is False:  # symbolic like `2` or `2 + I`
+                if t_not_re_im:
+                    return  # complex terms might cancel
+                t_not_re_im = t
+            else:
+                return
+
+        if t_not_re_im:
+            if t_not_re_im.is_extended_real is False:
+                if real:  # like 3
+                    return zero  # 3*(smthng like 2 + I or i) is not real
+            if t_not_re_im.is_imaginary is False:  # symbolic 2 or 2 + I
+                if not real:  # like I
+                    return zero  # I*(smthng like 2 or 2 + I) is not real
+        elif zero is False:
+            return real  # can't be trumped by 0
+        elif real:
+            return real  # doesn't matter what zero is
+
+    def _eval_is_imaginary(self):
+        if all(a.is_zero is False and a.is_finite for a in self.args):
+            return self._eval_real_imag(False)
+
+    def _eval_is_hermitian(self):
+        return self._eval_herm_antiherm(True)
+
+    def _eval_is_antihermitian(self):
+        return self._eval_herm_antiherm(False)
+
+    def _eval_herm_antiherm(self, herm):
+        for t in self.args:
+            if t.is_hermitian is None or t.is_antihermitian is None:
+                return
+            if t.is_hermitian:
+                continue
+            elif t.is_antihermitian:
+                herm = not herm
+            else:
+                return
+
+        if herm is not False:
+            return herm
+
+        is_zero = self._eval_is_zero()
+        if is_zero:
+            return True
+        elif is_zero is False:
+            return herm
+
+    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 and fuzzy_not(x.is_zero)) is True for x in others):
+                    return True
+                return
+            if a is None:
+                return
+        if all(x.is_real for x in self.args):
+            return False
+
+    def _eval_is_extended_positive(self):
+        """Return True if self is positive, False if not, and None if it
+        cannot be determined.
+
+        Explanation
+        ===========
+
+        This algorithm is non-recursive and works by keeping track of the
+        sign which changes when a negative or nonpositive is encountered.
+        Whether a nonpositive or nonnegative is seen is also tracked since
+        the presence of these makes it impossible to return True, but
+        possible to return False if the end result is nonpositive. e.g.
+
+            pos * neg * nonpositive -> pos or zero -> None is returned
+            pos * neg * nonnegative -> neg or zero -> False is returned
+        """
+        return self._eval_pos_neg(1)
+
+    def _eval_pos_neg(self, sign):
+        saw_NON = saw_NOT = False
+        for t in self.args:
+            if t.is_extended_positive:
+                continue
+            elif t.is_extended_negative:
+                sign = -sign
+            elif t.is_zero:
+                if all(a.is_finite for a in self.args):
+                    return False
+                return
+            elif t.is_extended_nonpositive:
+                sign = -sign
+                saw_NON = True
+            elif t.is_extended_nonnegative:
+                saw_NON = True
+            # FIXME: is_positive/is_negative is False doesn't take account of
+            # Symbol('x', infinite=True, extended_real=True) which has
+            # e.g. is_positive is False but has uncertain sign.
+            elif t.is_positive is False:
+                sign = -sign
+                if saw_NOT:
+                    return
+                saw_NOT = True
+            elif t.is_negative is False:
+                if saw_NOT:
+                    return
+                saw_NOT = True
+            else:
+                return
+        if sign == 1 and saw_NON is False and saw_NOT is False:
+            return True
+        if sign < 0:
+            return False
+
+    def _eval_is_extended_negative(self):
+        return self._eval_pos_neg(-1)
+
+    def _eval_is_odd(self):
+        is_integer = self._eval_is_integer()
+        if is_integer is not True:
+            return is_integer
+
+        from sympy.simplify.radsimp import fraction
+        n, d = fraction(self)
+        if d.is_Integer and d.is_even:
+            from sympy.ntheory.factor_ import trailing
+            # if minimal power of 2 in num vs den is
+            # positive then we have an even number
+            if (Add(*[i.as_base_exp()[1] for i in
+                    Mul.make_args(n) if i.is_even]) - trailing(d.p)
+                    ).is_positive:
+                return False
+            return
+        r, acc = True, 1
+        for t in self.args:
+            if abs(t) is S.One:
+                continue
+            if t.is_even:
+                return False
+            if r is False:
+                pass
+            elif acc != 1 and (acc + t).is_odd:
+                r = False
+            elif t.is_even is None:
+                r = None
+            acc = t
+        return r
+
+    def _eval_is_even(self):
+        from sympy.simplify.radsimp import fraction
+        n, d = fraction(self)
+        if n.is_Integer and n.is_even:
+            # if minimal power of 2 in den vs num is not
+            # negative then this is not an integer and
+            # can't be even
+            from sympy.ntheory.factor_ import trailing
+            if (Add(*[i.as_base_exp()[1] for i in
+                    Mul.make_args(d) if i.is_even]) - trailing(n.p)
+                    ).is_nonnegative:
+                return False
+
+    def _eval_is_composite(self):
+        """
+        Here we count the number of arguments that have a minimum value
+        greater than two.
+        If there are more than one of such a symbol then the result is composite.
+        Else, the result cannot be determined.
+        """
+        number_of_args = 0 # count of symbols with minimum value greater than one
+        for arg in self.args:
+            if not (arg.is_integer and arg.is_positive):
+                return None
+            if (arg-1).is_positive:
+                number_of_args += 1
+
+        if number_of_args > 1:
+            return True
+
+    def _eval_subs(self, old, new):
+        from sympy.functions.elementary.complexes import sign
+        from sympy.ntheory.factor_ import multiplicity
+        from sympy.simplify.powsimp import powdenest
+        from sympy.simplify.radsimp import fraction
+
+        if not old.is_Mul:
+            return None
+
+        # try keep replacement literal so -2*x doesn't replace 4*x
+        if old.args[0].is_Number and old.args[0] < 0:
+            if self.args[0].is_Number:
+                if self.args[0] < 0:
+                    return self._subs(-old, -new)
+                return None
+
+        def base_exp(a):
+            # if I and -1 are in a Mul, they get both end up with
+            # a -1 base (see issue 6421); all we want here are the
+            # true Pow or exp separated into base and exponent
+            from sympy.functions.elementary.exponential import exp
+            if a.is_Pow or isinstance(a, exp):
+                return a.as_base_exp()
+            return a, S.One
+
+        def breakup(eq):
+            """break up powers of eq when treated as a Mul:
+                   b**(Rational*e) -> b**e, Rational
+                commutatives come back as a dictionary {b**e: Rational}
+                noncommutatives come back as a list [(b**e, Rational)]
+            """
+
+            (c, nc) = (defaultdict(int), [])
+            for a in Mul.make_args(eq):
+                a = powdenest(a)
+                (b, e) = base_exp(a)
+                if e is not S.One:
+                    (co, _) = e.as_coeff_mul()
+                    b = Pow(b, e/co)
+                    e = co
+                if a.is_commutative:
+                    c[b] += e
+                else:
+                    nc.append([b, e])
+            return (c, nc)
+
+        def rejoin(b, co):
+            """
+            Put rational back with exponent; in general this is not ok, but
+            since we took it from the exponent for analysis, it's ok to put
+            it back.
+            """
+
+            (b, e) = base_exp(b)
+            return Pow(b, e*co)
+
+        def ndiv(a, b):
+            """if b divides a in an extractive way (like 1/4 divides 1/2
+            but not vice versa, and 2/5 does not divide 1/3) then return
+            the integer number of times it divides, else return 0.
+            """
+            if not b.q % a.q or not a.q % b.q:
+                return int(a/b)
+            return 0
+
+        # give Muls in the denominator a chance to be changed (see issue 5651)
+        # rv will be the default return value
+        rv = None
+        n, d = fraction(self)
+        self2 = self
+        if d is not S.One:
+            self2 = n._subs(old, new)/d._subs(old, new)
+            if not self2.is_Mul:
+                return self2._subs(old, new)
+            if self2 != self:
+                rv = self2
+
+        # Now continue with regular substitution.
+
+        # handle the leading coefficient and use it to decide if anything
+        # should even be started; we always know where to find the Rational
+        # so it's a quick test
+
+        co_self = self2.args[0]
+        co_old = old.args[0]
+        co_xmul = None
+        if co_old.is_Rational and co_self.is_Rational:
+            # if coeffs are the same there will be no updating to do
+            # below after breakup() step; so skip (and keep co_xmul=None)
+            if co_old != co_self:
+                co_xmul = co_self.extract_multiplicatively(co_old)
+        elif co_old.is_Rational:
+            return rv
+
+        # break self and old into factors
+
+        (c, nc) = breakup(self2)
+        (old_c, old_nc) = breakup(old)
+
+        # update the coefficients if we had an extraction
+        # e.g. if co_self were 2*(3/35*x)**2 and co_old = 3/5
+        # then co_self in c is replaced by (3/5)**2 and co_residual
+        # is 2*(1/7)**2
+
+        if co_xmul and co_xmul.is_Rational and abs(co_old) != 1:
+            mult = S(multiplicity(abs(co_old), co_self))
+            c.pop(co_self)
+            if co_old in c:
+                c[co_old] += mult
+            else:
+                c[co_old] = mult
+            co_residual = co_self/co_old**mult
+        else:
+            co_residual = 1
+
+        # do quick tests to see if we can't succeed
+
+        ok = True
+        if len(old_nc) > len(nc):
+            # more non-commutative terms
+            ok = False
+        elif len(old_c) > len(c):
+            # more commutative terms
+            ok = False
+        elif {i[0] for i in old_nc}.difference({i[0] for i in nc}):
+            # unmatched non-commutative bases
+            ok = False
+        elif set(old_c).difference(set(c)):
+            # unmatched commutative terms
+            ok = False
+        elif any(sign(c[b]) != sign(old_c[b]) for b in old_c):
+            # differences in sign
+            ok = False
+        if not ok:
+            return rv
+
+        if not old_c:
+            cdid = None
+        else:
+            rat = []
+            for (b, old_e) in old_c.items():
+                c_e = c[b]
+                rat.append(ndiv(c_e, old_e))
+                if not rat[-1]:
+                    return rv
+            cdid = min(rat)
+
+        if not old_nc:
+            ncdid = None
+            for i in range(len(nc)):
+                nc[i] = rejoin(*nc[i])
+        else:
+            ncdid = 0  # number of nc replacements we did
+            take = len(old_nc)  # how much to look at each time
+            limit = cdid or S.Infinity  # max number that we can take
+            failed = []  # failed terms will need subs if other terms pass
+            i = 0
+            while limit and i + take <= len(nc):
+                hit = False
+
+                # the bases must be equivalent in succession, and
+                # the powers must be extractively compatible on the
+                # first and last factor but equal in between.
+
+                rat = []
+                for j in range(take):
+                    if nc[i + j][0] != old_nc[j][0]:
+                        break
+                    elif j == 0:
+                        rat.append(ndiv(nc[i + j][1], old_nc[j][1]))
+                    elif j == take - 1:
+                        rat.append(ndiv(nc[i + j][1], old_nc[j][1]))
+                    elif nc[i + j][1] != old_nc[j][1]:
+                        break
+                    else:
+                        rat.append(1)
+                    j += 1
+                else:
+                    ndo = min(rat)
+                    if ndo:
+                        if take == 1:
+                            if cdid:
+                                ndo = min(cdid, ndo)
+                            nc[i] = Pow(new, ndo)*rejoin(nc[i][0],
+                                    nc[i][1] - ndo*old_nc[0][1])
+                        else:
+                            ndo = 1
+
+                            # the left residual
+
+                            l = rejoin(nc[i][0], nc[i][1] - ndo*
+                                    old_nc[0][1])
+
+                            # eliminate all middle terms
+
+                            mid = new
+
+                            # the right residual (which may be the same as the middle if take == 2)
+
+                            ir = i + take - 1
+                            r = (nc[ir][0], nc[ir][1] - ndo*
+                                 old_nc[-1][1])
+                            if r[1]:
+                                if i + take < len(nc):
+                                    nc[i:i + take] = [l*mid, r]
+                                else:
+                                    r = rejoin(*r)
+                                    nc[i:i + take] = [l*mid*r]
+                            else:
+
+                                # there was nothing left on the right
+
+                                nc[i:i + take] = [l*mid]
+
+                        limit -= ndo
+                        ncdid += ndo
+                        hit = True
+                if not hit:
+
+                    # do the subs on this failing factor
+
+                    failed.append(i)
+                i += 1
+            else:
+
+                if not ncdid:
+                    return rv
+
+                # although we didn't fail, certain nc terms may have
+                # failed so we rebuild them after attempting a partial
+                # subs on them
+
+                failed.extend(range(i, len(nc)))
+                for i in failed:
+                    nc[i] = rejoin(*nc[i]).subs(old, new)
+
+        # rebuild the expression
+
+        if cdid is None:
+            do = ncdid
+        elif ncdid is None:
+            do = cdid
+        else:
+            do = min(ncdid, cdid)
+
+        margs = []
+        for b in c:
+            if b in old_c:
+
+                # calculate the new exponent
+
+                e = c[b] - old_c[b]*do
+                margs.append(rejoin(b, e))
+            else:
+                margs.append(rejoin(b.subs(old, new), c[b]))
+        if cdid and not ncdid:
+
+            # in case we are replacing commutative with non-commutative,
+            # we want the new term to come at the front just like the
+            # rest of this routine
+
+            margs = [Pow(new, cdid)] + margs
+        return co_residual*self2.func(*margs)*self2.func(*nc)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from .function import PoleError
+        from sympy.functions.elementary.integers import ceiling
+        from sympy.series.order import Order
+
+        def coeff_exp(term, x):
+            lt = term.as_coeff_exponent(x)
+            if lt[0].has(x):
+                try:
+                    lt = term.leadterm(x)
+                except ValueError:
+                    return term, S.Zero
+            return lt
+
+        ords = []
+
+        try:
+            for t in self.args:
+                coeff, exp = t.leadterm(x)
+                if not coeff.has(x):
+                    ords.append((t, exp))
+                else:
+                    raise ValueError
+
+            n0 = sum(t[1] for t in ords if t[1].is_number)
+            facs = []
+            for t, m in ords:
+                n1 = ceiling(n - n0 + (m if m.is_number else 0))
+                s = t.nseries(x, n=n1, logx=logx, cdir=cdir)
+                ns = s.getn()
+                if ns is not None:
+                    if ns < n1:  # less than expected
+                        n -= n1 - ns    # reduce n
+                facs.append(s)
+
+        except (ValueError, NotImplementedError, TypeError, AttributeError, PoleError):
+            n0 = sympify(sum(t[1] for t in ords if t[1].is_number))
+            if n0.is_nonnegative:
+                n0 = S.Zero
+            facs = [t.nseries(x, n=ceiling(n-n0), logx=logx, cdir=cdir) for t in self.args]
+            from sympy.simplify.powsimp import powsimp
+            res = powsimp(self.func(*facs).expand(), combine='exp', deep=True)
+            if res.has(Order):
+                res += Order(x**n, x)
+            return res
+
+        res = S.Zero
+        ords2 = [Add.make_args(factor) for factor in facs]
+
+        for fac in product(*ords2):
+            ords3 = [coeff_exp(term, x) for term in fac]
+            coeffs, powers = zip(*ords3)
+            power = sum(powers)
+            if (power - n).is_negative:
+                res += Mul(*coeffs)*(x**power)
+
+        def max_degree(e, x):
+            if e is x:
+                return S.One
+            if e.is_Atom:
+                return S.Zero
+            if e.is_Add:
+                return max(max_degree(a, x) for a in e.args)
+            if e.is_Mul:
+                return Add(*[max_degree(a, x) for a in e.args])
+            if e.is_Pow:
+                return max_degree(e.base, x)*e.exp
+            return S.Zero
+
+        if self.is_polynomial(x):
+            from sympy.polys.polyerrors import PolynomialError
+            from sympy.polys.polytools import degree
+            try:
+                if max_degree(self, x) >= n or degree(self, x) != degree(res, x):
+                    res += Order(x**n, x)
+            except PolynomialError:
+                pass
+            else:
+                return res
+
+        if res != self:
+            if (self - res).subs(x, 0) == S.Zero and n > 0:
+                lt = self._eval_as_leading_term(x, logx=logx, cdir=cdir)
+                if lt == S.Zero:
+                    return res
+            res += Order(x**n, x)
+        return res
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        return self.func(*[t.as_leading_term(x, logx=logx, cdir=cdir) 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[::-1]])
+
+    def _eval_adjoint(self):
+        return self.func(*[t.adjoint() for t in self.args[::-1]])
+
+    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
+        >>> (-3*sqrt(2)*(2 - 2*sqrt(2))).as_content_primitive()
+        (6, -sqrt(2)*(1 - sqrt(2)))
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+
+        coef = S.One
+        args = []
+        for a in self.args:
+            c, p = a.as_content_primitive(radical=radical, clear=clear)
+            coef *= c
+            if p is not S.One:
+                args.append(p)
+        # don't use self._from_args here to reconstruct args
+        # since there may be identical args now that should be combined
+        # e.g. (2+2*x)*(3+3*x) should be (6, (1 + x)**2) not (6, (1+x)*(1+x))
+        return coef, self.func(*args)
+
+    def as_ordered_factors(self, order=None):
+        """Transform an expression into an ordered list of factors.
+
+        Examples
+        ========
+
+        >>> from sympy import sin, cos
+        >>> from sympy.abc import x, y
+
+        >>> (2*x*y*sin(x)*cos(x)).as_ordered_factors()
+        [2, x, y, sin(x), cos(x)]
+
+        """
+        cpart, ncpart = self.args_cnc()
+        cpart.sort(key=lambda expr: expr.sort_key(order=order))
+        return cpart + ncpart
+
+    @property
+    def _sorted_args(self):
+        return tuple(self.as_ordered_factors())
+
+mul = AssocOpDispatcher('mul')
+
+
+def prod(a, start=1):
+    """Return product of elements of a. Start with int 1 so if only
+       ints are included then an int result is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import prod, S
+    >>> prod(range(3))
+    0
+    >>> type(_) is int
+    True
+    >>> prod([S(2), 3])
+    6
+    >>> _.is_Integer
+    True
+
+    You can start the product at something other than 1:
+
+    >>> prod([1, 2], 3)
+    6
+
+    """
+    return reduce(operator.mul, a, start)
+
+
+def _keep_coeff(coeff, factors, clear=True, sign=False):
+    """Return ``coeff*factors`` unevaluated if necessary.
+
+    If ``clear`` is False, do not keep the coefficient as a factor
+    if it can be distributed on a single factor such that one or
+    more terms will still have integer coefficients.
+
+    If ``sign`` is True, allow a coefficient of -1 to remain factored out.
+
+    Examples
+    ========
+
+    >>> from sympy.core.mul import _keep_coeff
+    >>> from sympy.abc import x, y
+    >>> from sympy import S
+
+    >>> _keep_coeff(S.Half, x + 2)
+    (x + 2)/2
+    >>> _keep_coeff(S.Half, x + 2, clear=False)
+    x/2 + 1
+    >>> _keep_coeff(S.Half, (x + 2)*y, clear=False)
+    y*(x + 2)/2
+    >>> _keep_coeff(S(-1), x + y)
+    -x - y
+    >>> _keep_coeff(S(-1), x + y, sign=True)
+    -(x + y)
+    """
+    if not coeff.is_Number:
+        if factors.is_Number:
+            factors, coeff = coeff, factors
+        else:
+            return coeff*factors
+    if factors is S.One:
+        return coeff
+    if coeff is S.One:
+        return factors
+    elif coeff is S.NegativeOne and not sign:
+        return -factors
+    elif factors.is_Add:
+        if not clear and coeff.is_Rational and coeff.q != 1:
+            args = [i.as_coeff_Mul() for i in factors.args]
+            args = [(_keep_coeff(c, coeff), m) for c, m in args]
+            if any(c.is_Integer for c, _ in args):
+                return Add._from_args([Mul._from_args(
+                    i[1:] if i[0] == 1 else i) for i in args])
+        return Mul(coeff, factors, evaluate=False)
+    elif factors.is_Mul:
+        margs = list(factors.args)
+        if margs[0].is_Number:
+            margs[0] *= coeff
+            if margs[0] == 1:
+                margs.pop(0)
+        else:
+            margs.insert(0, coeff)
+        return Mul._from_args(margs)
+    else:
+        m = coeff*factors
+        if m.is_Number and not factors.is_Number:
+            m = Mul._from_args((coeff, factors))
+        return m
+
+def expand_2arg(e):
+    def do(e):
+        if e.is_Mul:
+            c, r = e.as_coeff_Mul()
+            if c.is_Number and r.is_Add:
+                return _unevaluated_Add(*[c*ri for ri in r.args])
+        return e
+    return bottom_up(e, do)
+
+
+from .numbers import Rational
+from .power import Pow
+from .add import Add, _unevaluated_Add

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

@@ -0,0 +1,161 @@
+"""Thread-safe global parameters"""
+
+from .cache import clear_cache
+from contextlib import contextmanager
+from threading import local
+
+class _global_parameters(local):
+    """
+    Thread-local global parameters.
+
+    Explanation
+    ===========
+
+    This class generates thread-local container for SymPy's global parameters.
+    Every global parameters must be passed as keyword argument when generating
+    its instance.
+    A variable, `global_parameters` is provided as default instance for this class.
+
+    WARNING! Although the global parameters are thread-local, SymPy's cache is not
+    by now.
+    This may lead to undesired result in multi-threading operations.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.core.cache import clear_cache
+    >>> from sympy.core.parameters import global_parameters as gp
+
+    >>> gp.evaluate
+    True
+    >>> x+x
+    2*x
+
+    >>> log = []
+    >>> def f():
+    ...     clear_cache()
+    ...     gp.evaluate = False
+    ...     log.append(x+x)
+    ...     clear_cache()
+    >>> import threading
+    >>> thread = threading.Thread(target=f)
+    >>> thread.start()
+    >>> thread.join()
+
+    >>> print(log)
+    [x + x]
+
+    >>> gp.evaluate
+    True
+    >>> x+x
+    2*x
+
+    References
+    ==========
+
+    .. [1] https://docs.python.org/3/library/threading.html
+
+    """
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+    def __setattr__(self, name, value):
+        if getattr(self, name) != value:
+            clear_cache()
+        return super().__setattr__(name, value)
+
+global_parameters = _global_parameters(evaluate=True, distribute=True, exp_is_pow=False)
+
+@contextmanager
+def evaluate(x):
+    """ Control automatic evaluation
+
+    Explanation
+    ===========
+
+    This context manager controls whether or not all SymPy functions evaluate
+    by default.
+
+    Note that much of SymPy expects evaluated expressions.  This functionality
+    is experimental and is unlikely to function as intended on large
+    expressions.
+
+    Examples
+    ========
+
+    >>> from sympy import evaluate
+    >>> from sympy.abc import x
+    >>> print(x + x)
+    2*x
+    >>> with evaluate(False):
+    ...     print(x + x)
+    x + x
+    """
+
+    old = global_parameters.evaluate
+
+    try:
+        global_parameters.evaluate = x
+        yield
+    finally:
+        global_parameters.evaluate = old
+
+
+@contextmanager
+def distribute(x):
+    """ Control automatic distribution of Number over Add
+
+    Explanation
+    ===========
+
+    This context manager controls whether or not Mul distribute Number over
+    Add. Plan is to avoid distributing Number over Add in all of sympy. Once
+    that is done, this contextmanager will be removed.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.core.parameters import distribute
+    >>> print(2*(x + 1))
+    2*x + 2
+    >>> with distribute(False):
+    ...     print(2*(x + 1))
+    2*(x + 1)
+    """
+
+    old = global_parameters.distribute
+
+    try:
+        global_parameters.distribute = x
+        yield
+    finally:
+        global_parameters.distribute = old
+
+
+@contextmanager
+def _exp_is_pow(x):
+    """
+    Control whether `e^x` should be represented as ``exp(x)`` or a ``Pow(E, x)``.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.abc import x
+    >>> from sympy.core.parameters import _exp_is_pow
+    >>> with _exp_is_pow(True): print(type(exp(x)))
+    <class 'sympy.core.power.Pow'>
+    >>> with _exp_is_pow(False): print(type(exp(x)))
+    exp
+    """
+    old = global_parameters.exp_is_pow
+
+    clear_cache()
+    try:
+        global_parameters.exp_is_pow = x
+        yield
+    finally:
+        clear_cache()
+        global_parameters.exp_is_pow = old

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

@@ -0,0 +1,20 @@
+"""This module contains functions which operate on discrete sequences.
+
+Transforms - ``fft``, ``ifft``, ``ntt``, ``intt``, ``fwht``, ``ifwht``,
+            ``mobius_transform``, ``inverse_mobius_transform``
+
+Convolutions - ``convolution``, ``convolution_fft``, ``convolution_ntt``,
+            ``convolution_fwht``, ``convolution_subset``,
+            ``covering_product``, ``intersecting_product``
+"""
+
+from .transforms import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from .convolutions import convolution, covering_product, intersecting_product
+
+__all__ = [
+    'fft', 'ifft', 'ntt', 'intt', 'fwht', 'ifwht', 'mobius_transform',
+    'inverse_mobius_transform',
+
+    'convolution', 'covering_product', 'intersecting_product',
+]

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

@@ -0,0 +1,488 @@
+"""
+Convolution (using **FFT**, **NTT**, **FWHT**), Subset Convolution,
+Covering Product, Intersecting Product
+"""
+
+from sympy.core import S, sympify
+from sympy.core.function import expand_mul
+from sympy.discrete.transforms import (
+    fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+def convolution(a, b, cycle=0, dps=None, prime=None, dyadic=None, subset=None):
+    """
+    Performs convolution by determining the type of desired
+    convolution using hints.
+
+    Exactly one of ``dps``, ``prime``, ``dyadic``, ``subset`` arguments
+    should be specified explicitly for identifying the type of convolution,
+    and the argument ``cycle`` can be specified optionally.
+
+    For the default arguments, linear convolution is performed using **FFT**.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    cycle : Integer
+        Specifies the length for doing cyclic convolution.
+    dps : Integer
+        Specifies the number of decimal digits for precision for
+        performing **FFT** on the sequence.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for
+        performing **NTT** on the sequence.
+    dyadic : bool
+        Identifies the convolution type as dyadic (*bitwise-XOR*)
+        convolution, which is performed using **FWHT**.
+    subset : bool
+        Identifies the convolution type as subset convolution.
+
+    Examples
+    ========
+
+    >>> from sympy import convolution, symbols, S, I
+    >>> u, v, w, x, y, z = symbols('u v w x y z')
+
+    >>> convolution([1 + 2*I, 4 + 3*I], [S(5)/4, 6], dps=3)
+    [1.25 + 2.5*I, 11.0 + 15.8*I, 24.0 + 18.0*I]
+    >>> convolution([1, 2, 3], [4, 5, 6], cycle=3)
+    [31, 31, 28]
+
+    >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1)
+    [1283, 19351, 14219]
+    >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1, cycle=2)
+    [15502, 19351]
+
+    >>> convolution([u, v], [x, y, z], dyadic=True)
+    [u*x + v*y, u*y + v*x, u*z, v*z]
+    >>> convolution([u, v], [x, y, z], dyadic=True, cycle=2)
+    [u*x + u*z + v*y, u*y + v*x + v*z]
+
+    >>> convolution([u, v, w], [x, y, z], subset=True)
+    [u*x, u*y + v*x, u*z + w*x, v*z + w*y]
+    >>> convolution([u, v, w], [x, y, z], subset=True, cycle=3)
+    [u*x + v*z + w*y, u*y + v*x, u*z + w*x]
+
+    """
+
+    c = as_int(cycle)
+    if c < 0:
+        raise ValueError("The length for cyclic convolution "
+                        "must be non-negative")
+
+    dyadic = True if dyadic else None
+    subset = True if subset else None
+    if sum(x is not None for x in (prime, dps, dyadic, subset)) > 1:
+        raise TypeError("Ambiguity in determining the type of convolution")
+
+    if prime is not None:
+        ls = convolution_ntt(a, b, prime=prime)
+        return ls if not c else [sum(ls[i::c]) % prime for i in range(c)]
+
+    if dyadic:
+        ls = convolution_fwht(a, b)
+    elif subset:
+        ls = convolution_subset(a, b)
+    else:
+        ls = convolution_fft(a, b, dps=dps)
+
+    return ls if not c else [sum(ls[i::c]) for i in range(c)]
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                       Convolution for Complex domain                       #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_fft(a, b, dps=None):
+    """
+    Performs linear convolution using Fast Fourier Transform.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import S, I
+    >>> from sympy.discrete.convolutions import convolution_fft
+
+    >>> convolution_fft([2, 3], [4, 5])
+    [8, 22, 15]
+    >>> convolution_fft([2, 5], [6, 7, 3])
+    [12, 44, 41, 15]
+    >>> convolution_fft([1 + 2*I, 4 + 3*I], [S(5)/4, 6])
+    [5/4 + 5*I/2, 11 + 63*I/4, 24 + 18*I]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convolution_theorem
+    .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    a, b = a[:], b[:]
+    n = m = len(a) + len(b) - 1 # convolution size
+
+    if n > 0 and n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = fft(a, dps), fft(b, dps)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = ifft(a, dps)[:m]
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Convolution for GF(p)                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_ntt(a, b, prime):
+    """
+    Performs linear convolution using Number Theoretic Transform.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.convolutions import convolution_ntt
+    >>> convolution_ntt([2, 3], [4, 5], prime=19*2**10 + 1)
+    [8, 22, 15]
+    >>> convolution_ntt([2, 5], [6, 7, 3], prime=19*2**10 + 1)
+    [12, 44, 41, 15]
+    >>> convolution_ntt([333, 555], [222, 666], prime=19*2**10 + 1)
+    [15555, 14219, 19404]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convolution_theorem
+    .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    a, b, p = a[:], b[:], as_int(prime)
+    n = m = len(a) + len(b) - 1 # convolution size
+
+    if n > 0 and n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [0]*(n - len(a))
+    b += [0]*(n - len(b))
+
+    a, b = ntt(a, p), ntt(b, p)
+    a = [x*y % p for x, y in zip(a, b)]
+    a = intt(a, p)[:m]
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Convolution for 2**n-group                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_fwht(a, b):
+    """
+    Performs dyadic (*bitwise-XOR*) convolution using Fast Walsh Hadamard
+    Transform.
+
+    The convolution is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I
+    >>> from sympy.discrete.convolutions import convolution_fwht
+
+    >>> u, v, x, y = symbols('u v x y')
+    >>> convolution_fwht([u, v], [x, y])
+    [u*x + v*y, u*y + v*x]
+
+    >>> convolution_fwht([2, 3], [4, 5])
+    [23, 22]
+    >>> convolution_fwht([2, 5 + 4*I, 7], [6*I, 7, 3 + 4*I])
+    [56 + 68*I, -10 + 30*I, 6 + 50*I, 48 + 32*I]
+
+    >>> convolution_fwht([S(33)/7, S(55)/6, S(7)/4], [S(2)/3, 5])
+    [2057/42, 1870/63, 7/6, 35/4]
+
+    References
+    ==========
+
+    .. [1] https://www.radioeng.cz/fulltexts/2002/02_03_40_42.pdf
+    .. [2] https://en.wikipedia.org/wiki/Hadamard_transform
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = fwht(a), fwht(b)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = ifwht(a)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Subset Convolution                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_subset(a, b):
+    """
+    Performs Subset Convolution of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S
+    >>> from sympy.discrete.convolutions import convolution_subset
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> convolution_subset([u, v], [x, y])
+    [u*x, u*y + v*x]
+    >>> convolution_subset([u, v, x], [y, z])
+    [u*y, u*z + v*y, x*y, x*z]
+
+    >>> convolution_subset([1, S(2)/3], [3, 4])
+    [3, 6]
+    >>> convolution_subset([1, 3, S(5)/7], [7])
+    [7, 21, 5, 0]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    if not iterable(a) or not iterable(b):
+        raise TypeError("Expected a sequence of coefficients for convolution")
+
+    a = [sympify(arg) for arg in a]
+    b = [sympify(arg) for arg in b]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    c = [S.Zero]*n
+
+    for mask in range(n):
+        smask = mask
+        while smask > 0:
+            c[mask] += expand_mul(a[smask] * b[mask^smask])
+            smask = (smask - 1)&mask
+
+        c[mask] += expand_mul(a[smask] * b[mask^smask])
+
+    return c
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Covering Product                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def covering_product(a, b):
+    """
+    Returns the covering product of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The covering product of given sequences is a sequence which contains
+    the sum of products of the elements of the given sequences grouped by
+    the *bitwise-OR* of the corresponding indices.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which covering product is to be obtained.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I, covering_product
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> covering_product([u, v], [x, y])
+    [u*x, u*y + v*x + v*y]
+    >>> covering_product([u, v, x], [y, z])
+    [u*y, u*z + v*y + v*z, x*y, x*z]
+
+    >>> covering_product([1, S(2)/3], [3, 4 + 5*I])
+    [3, 26/3 + 25*I/3]
+    >>> covering_product([1, 3, S(5)/7], [7, 8])
+    [7, 53, 5, 40/7]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = mobius_transform(a), mobius_transform(b)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = inverse_mobius_transform(a)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Intersecting Product                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def intersecting_product(a, b):
+    """
+    Returns the intersecting product of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The intersecting product of given sequences is the sequence which
+    contains the sum of products of the elements of the given sequences
+    grouped by the *bitwise-AND* of the corresponding indices.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which intersecting product is to be obtained.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I, intersecting_product
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> intersecting_product([u, v], [x, y])
+    [u*x + u*y + v*x, v*y]
+    >>> intersecting_product([u, v, x], [y, z])
+    [u*y + u*z + v*y + x*y + x*z, v*z, 0, 0]
+
+    >>> intersecting_product([1, S(2)/3], [3, 4 + 5*I])
+    [9 + 5*I, 8/3 + 10*I/3]
+    >>> intersecting_product([1, 3, S(5)/7], [7, 8])
+    [327/7, 24, 0, 0]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = mobius_transform(a, subset=False), mobius_transform(b, subset=False)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = inverse_mobius_transform(a, subset=False)
+
+    return a

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

@@ -0,0 +1,166 @@
+"""
+Recurrences
+"""
+
+from sympy.core import S, sympify
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+def linrec(coeffs, init, n):
+    r"""
+    Evaluation of univariate linear recurrences of homogeneous type
+    having coefficients independent of the recurrence variable.
+
+    Parameters
+    ==========
+
+    coeffs : iterable
+        Coefficients of the recurrence
+    init : iterable
+        Initial values of the recurrence
+    n : Integer
+        Point of evaluation for the recurrence
+
+    Notes
+    =====
+
+    Let `y(n)` be the recurrence of given type, ``c`` be the sequence
+    of coefficients, ``b`` be the sequence of initial/base values of the
+    recurrence and ``k`` (equal to ``len(c)``) be the order of recurrence.
+    Then,
+
+    .. math :: y(n) = \begin{cases} b_n & 0 \le n < k \\
+        c_0 y(n-1) + c_1 y(n-2) + \cdots + c_{k-1} y(n-k) & n \ge k
+        \end{cases}
+
+    Let `x_0, x_1, \ldots, x_n` be a sequence and consider the transformation
+    that maps each polynomial `f(x)` to `T(f(x))` where each power `x^i` is
+    replaced by the corresponding value `x_i`. The sequence is then a solution
+    of the recurrence if and only if `T(x^i p(x)) = 0` for each `i \ge 0` where
+    `p(x) = x^k - c_0 x^(k-1) - \cdots - c_{k-1}` is the characteristic
+    polynomial.
+
+    Then `T(f(x)p(x)) = 0` for each polynomial `f(x)` (as it is a linear
+    combination of powers `x^i`). Now, if `x^n` is congruent to
+    `g(x) = a_0 x^0 + a_1 x^1 + \cdots + a_{k-1} x^{k-1}` modulo `p(x)`, then
+    `T(x^n) = x_n` is equal to
+    `T(g(x)) = a_0 x_0 + a_1 x_1 + \cdots + a_{k-1} x_{k-1}`.
+
+    Computation of `x^n`,
+    given `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`
+    is performed using exponentiation by squaring (refer to [1_]) with
+    an additional reduction step performed to retain only first `k` powers
+    of `x` in the representation of `x^n`.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.recurrences import linrec
+    >>> from sympy.abc import x, y, z
+
+    >>> linrec(coeffs=[1, 1], init=[0, 1], n=10)
+    55
+
+    >>> linrec(coeffs=[1, 1], init=[x, y], n=10)
+    34*x + 55*y
+
+    >>> linrec(coeffs=[x, y], init=[0, 1], n=5)
+    x**2*y + x*(x**3 + 2*x*y) + y**2
+
+    >>> linrec(coeffs=[1, 2, 3, 0, 0, 4], init=[x, y, z], n=16)
+    13576*x + 5676*y + 2356*z
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Exponentiation_by_squaring
+    .. [2] https://en.wikipedia.org/w/index.php?title=Modular_exponentiation&section=6#Matrices
+
+    See Also
+    ========
+
+    sympy.polys.agca.extensions.ExtensionElement.__pow__
+
+    """
+
+    if not coeffs:
+        return S.Zero
+
+    if not iterable(coeffs):
+        raise TypeError("Expected a sequence of coefficients for"
+                        " the recurrence")
+
+    if not iterable(init):
+        raise TypeError("Expected a sequence of values for the initialization"
+                        " of the recurrence")
+
+    n = as_int(n)
+    if n < 0:
+        raise ValueError("Point of evaluation of recurrence must be a "
+                        "non-negative integer")
+
+    c = [sympify(arg) for arg in coeffs]
+    b = [sympify(arg) for arg in init]
+    k = len(c)
+
+    if len(b) > k:
+        raise TypeError("Count of initial values should not exceed the "
+                        "order of the recurrence")
+    else:
+        b += [S.Zero]*(k - len(b)) # remaining initial values default to zero
+
+    if n < k:
+        return b[n]
+    terms = [u*v for u, v in zip(linrec_coeffs(c, n), b)]
+    return sum(terms[:-1], terms[-1])
+
+
+def linrec_coeffs(c, n):
+    r"""
+    Compute the coefficients of n'th term in linear recursion
+    sequence defined by c.
+
+    `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`.
+
+    It computes the coefficients by using binary exponentiation.
+    This function is used by `linrec` and `_eval_pow_by_cayley`.
+
+    Parameters
+    ==========
+
+    c = coefficients of the divisor polynomial
+    n = exponent of x, so dividend is x^n
+
+    """
+
+    k = len(c)
+
+    def _square_and_reduce(u, offset):
+        # squares `(u_0 + u_1 x + u_2 x^2 + \cdots + u_{k-1} x^k)` (and
+        # multiplies by `x` if offset is 1) and reduces the above result of
+        # length upto `2k` to `k` using the characteristic equation of the
+        # recurrence given by, `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`
+
+        w = [S.Zero]*(2*len(u) - 1 + offset)
+        for i, p in enumerate(u):
+            for j, q in enumerate(u):
+                w[offset + i + j] += p*q
+
+        for j in range(len(w) - 1, k - 1, -1):
+            for i in range(k):
+                w[j - i - 1] += w[j]*c[i]
+
+        return w[:k]
+
+    def _final_coeffs(n):
+        # computes the final coefficient list - `cf` corresponding to the
+        # point at which recurrence is to be evalauted - `n`, such that,
+        # `y(n) = cf_0 y(k-1) + cf_1 y(k-2) + \cdots + cf_{k-1} y(0)`
+
+        if n < k:
+            return [S.Zero]*n + [S.One] + [S.Zero]*(k - n - 1)
+        else:
+            return _square_and_reduce(_final_coeffs(n // 2), n % 2)
+
+    return _final_coeffs(n)

llmeval-env/lib/python3.10/site-packages/sympy/discrete/tests/test_convolutions.py

@@ -0,0 +1,365 @@
+from sympy.core.numbers import (E, Rational, pi)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, symbols, I
+from sympy.discrete.convolutions import (
+    convolution, convolution_fft, convolution_ntt, convolution_fwht,
+    convolution_subset, covering_product, intersecting_product)
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+def test_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+    c = [3, 5, 3, 7, 8]
+    d = [1422, 6572, 3213, 5552]
+
+    assert convolution(a, b) == convolution_fft(a, b)
+    assert convolution(a, b, dps=9) == convolution_fft(a, b, dps=9)
+    assert convolution(a, d, dps=7) == convolution_fft(d, a, dps=7)
+    assert convolution(a, d[1:], dps=3) == convolution_fft(d[1:], a, dps=3)
+
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+
+    # ntt
+    assert convolution(d, b, prime=q) == convolution_ntt(b, d, prime=q)
+    assert convolution(c, b, prime=p) == convolution_ntt(b, c, prime=p)
+    assert convolution(d, c, prime=p) == convolution_ntt(c, d, prime=p)
+    raises(TypeError, lambda: convolution(b, d, dps=5, prime=q))
+    raises(TypeError, lambda: convolution(b, d, dps=6, prime=q))
+
+    # fwht
+    assert convolution(a, b, dyadic=True) == convolution_fwht(a, b)
+    assert convolution(a, b, dyadic=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(b, d, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, d, prime=p, dyadic=True))
+    raises(TypeError, lambda: convolution(a, b, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, c, prime=p, dyadic=True))
+
+    # subset
+    assert convolution(a, b, subset=True) == convolution_subset(a, b) == \
+            convolution(a, b, subset=True, dyadic=False) == \
+                convolution(a, b, subset=True)
+    assert convolution(a, b, subset=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(a, b, subset=True, dyadic=True))
+    raises(TypeError, lambda: convolution(c, d, subset=True, dps=6))
+    raises(TypeError, lambda: convolution(a, c, subset=True, prime=q))
+
+
+def test_cyclic_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=0) == \
+            convolution([1, 2, 3], [4, 5, 6], cycle=5) == \
+                convolution([1, 2, 3], [4, 5, 6])
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=3) == [31, 31, 28]
+
+    a = [Rational(1, 3), Rational(7, 3), Rational(5, 9), Rational(2, 7), Rational(5, 8)]
+    b = [Rational(3, 5), Rational(4, 7), Rational(7, 8), Rational(8, 9)]
+
+    assert convolution(a, b, cycle=0) == \
+            convolution(a, b, cycle=len(a) + len(b) - 1)
+
+    assert convolution(a, b, cycle=4) == [Rational(87277, 26460), Rational(30521, 11340),
+                            Rational(11125, 4032), Rational(3653, 1080)]
+
+    assert convolution(a, b, cycle=6) == [Rational(20177, 20160), Rational(676, 315), Rational(47, 24),
+                            Rational(3053, 1080), Rational(16397, 5292), Rational(2497, 2268)]
+
+    assert convolution(a, b, cycle=9) == \
+                convolution(a, b, cycle=0) + [S.Zero]
+
+    # ntt
+    a = [2313, 5323532, S(3232), 42142, 42242421]
+    b = [S(33456), 56757, 45754, 432423]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=0) == \
+            convolution(a, b, prime=19*2**10 + 1, cycle=8) == \
+                convolution(a, b, prime=19*2**10 + 1)
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=5) == [96, 17146, 2664,
+                                                                    15534, 3517]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=7) == [4643, 3458, 1260,
+                                                        15534, 3517, 16314, 13688]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=9) == \
+            convolution(a, b, prime=19*2**10 + 1) + [0]
+
+    # fwht
+    u, v, w, x, y = symbols('u v w x y')
+    p, q, r, s, t = symbols('p q r s t')
+    c = [u, v, w, x, y]
+    d = [p, q, r, s, t]
+
+    assert convolution(a, b, dyadic=True, cycle=3) == \
+                        [2499522285783, 19861417974796, 4702176579021]
+
+    assert convolution(a, b, dyadic=True, cycle=5) == [2718149225143,
+            2114320852171, 20571217906407, 246166418903, 1413262436976]
+
+    assert convolution(c, d, dyadic=True, cycle=4) == \
+            [p*u + p*y + q*v + r*w + s*x + t*u + t*y,
+             p*v + q*u + q*y + r*x + s*w + t*v,
+             p*w + q*x + r*u + r*y + s*v + t*w,
+             p*x + q*w + r*v + s*u + s*y + t*x]
+
+    assert convolution(c, d, dyadic=True, cycle=6) == \
+            [p*u + q*v + r*w + r*y + s*x + t*w + t*y,
+             p*v + q*u + r*x + s*w + s*y + t*x,
+             p*w + q*x + r*u + s*v,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u,
+             q*y + t*v]
+
+    # subset
+    assert convolution(a, b, subset=True, cycle=7) == [18266671799811,
+                    178235365533, 213958794, 246166418903, 1413262436976,
+                    2397553088697, 1932759730434]
+
+    assert convolution(a[1:], b, subset=True, cycle=4) == \
+            [178104086592, 302255835516, 244982785880, 3717819845434]
+
+    assert convolution(a, b[:-1], subset=True, cycle=6) == [1932837114162,
+            178235365533, 213958794, 245166224504, 1413262436976, 2397553088697]
+
+    assert convolution(c, d, subset=True, cycle=3) == \
+            [p*u + p*x + q*w + r*v + r*y + s*u + t*w,
+             p*v + p*y + q*u + s*y + t*u + t*x,
+             p*w + q*y + r*u + t*v]
+
+    assert convolution(c, d, subset=True, cycle=5) == \
+            [p*u + q*y + t*v,
+             p*v + q*u + r*y + t*w,
+             p*w + r*u + s*y + t*x,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u]
+
+    raises(ValueError, lambda: convolution([1, 2, 3], [4, 5, 6], cycle=-1))
+
+
+def test_convolution_fft():
+    assert all(convolution_fft([], x, dps=y) == [] for x in ([], [1]) for y in (None, 3))
+    assert convolution_fft([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_fft([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_fft([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+
+    assert convolution_fft([1 + 2*I], [2 + 3*I]) == [-4 + 7*I]
+    assert convolution_fft([1 + 2*I, 3 + 4*I, 5 + 3*I/5], [Rational(2, 5) + 4*I/7]) == \
+            [Rational(-26, 35) + I*48/35, Rational(-38, 35) + I*116/35, Rational(58, 35) + I*542/175]
+
+    assert convolution_fft([Rational(3, 4), Rational(5, 6)], [Rational(7, 8), Rational(1, 3), Rational(2, 5)]) == \
+                                    [Rational(21, 32), Rational(47, 48), Rational(26, 45), Rational(1, 3)]
+
+    assert convolution_fft([Rational(1, 9), Rational(2, 3), Rational(3, 5)], [Rational(2, 5), Rational(3, 7), Rational(4, 9)]) == \
+                                [Rational(2, 45), Rational(11, 35), Rational(8152, 14175), Rational(523, 945), Rational(4, 15)]
+
+    assert convolution_fft([pi, E, sqrt(2)], [sqrt(3), 1/pi, 1/E]) == \
+                    [sqrt(3)*pi, 1 + sqrt(3)*E, E/pi + pi*exp(-1) + sqrt(6),
+                                            sqrt(2)/pi + 1, sqrt(2)*exp(-1)]
+
+    assert convolution_fft([2321, 33123], [5321, 6321, 71323]) == \
+                        [12350041, 190918524, 374911166, 2362431729]
+
+    assert convolution_fft([312313, 31278232], [32139631, 319631]) == \
+                        [10037624576503, 1005370659728895, 9997492572392]
+
+    raises(TypeError, lambda: convolution_fft(x, y))
+    raises(ValueError, lambda: convolution_fft([x, y], [y, x]))
+
+
+def test_convolution_ntt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+    r = 2*500000003 + 1 # only for sequences of length 1 or 2
+    # s = 2*3*5*7 # composite modulus
+
+    assert all(convolution_ntt([], x, prime=y) == [] for x in ([], [1]) for y in (p, q, r))
+    assert convolution_ntt([2], [3], r) == [6]
+    assert convolution_ntt([2, 3], [4], r) == [8, 12]
+
+    assert convolution_ntt([32121, 42144, 4214, 4241], [32132, 3232, 87242], p) == [33867619,
+                                    459741727, 79180879, 831885249, 381344700, 369993322]
+    assert convolution_ntt([121913, 3171831, 31888131, 12], [17882, 21292, 29921, 312], q) == \
+                                                [8158, 3065, 3682, 7090, 1239, 2232, 3744]
+
+    assert convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], q)
+    assert convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], q)
+
+    raises(ValueError, lambda: convolution_ntt([2, 3], [4, 5], r))
+    raises(ValueError, lambda: convolution_ntt([x, y], [y, x], q))
+    raises(TypeError, lambda: convolution_ntt(x, y, p))
+
+
+def test_convolution_fwht():
+    assert convolution_fwht([], []) == []
+    assert convolution_fwht([], [1]) == []
+    assert convolution_fwht([1, 2, 3], [4, 5, 6]) == [32, 13, 18, 27]
+
+    assert convolution_fwht([Rational(5, 7), Rational(6, 8), Rational(7, 3)], [2, 4, Rational(6, 7)]) == \
+                                    [Rational(45, 7), Rational(61, 14), Rational(776, 147), Rational(419, 42)]
+
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5), 4 + 5*I]
+    b = [94, 51, 53, 45, 31, 27, 13]
+    c = [3 + 4*I, 5 + 7*I, 3, Rational(7, 6), 8]
+
+    assert convolution_fwht(a, b) == [53*sqrt(3) + 366 + 155*I,
+                                    45*sqrt(3) + Rational(5848, 15) + 135*I,
+                                    94*sqrt(3) + Rational(1257, 5) + 65*I,
+                                    51*sqrt(3) + Rational(3974, 15),
+                                    13*sqrt(3) + 452 + 470*I,
+                                    Rational(4513, 15) + 255*I,
+                                    31*sqrt(3) + Rational(1314, 5) + 265*I,
+                                    27*sqrt(3) + Rational(3676, 15) + 225*I]
+
+    assert convolution_fwht(b, c) == [Rational(1993, 2) + 733*I, Rational(6215, 6) + 862*I,
+        Rational(1659, 2) + 527*I, Rational(1988, 3) + 551*I, 1019 + 313*I, Rational(3955, 6) + 325*I,
+        Rational(1175, 2) + 52*I, Rational(3253, 6) + 91*I]
+
+    assert convolution_fwht(a[3:], c) == [Rational(-54, 5) + I*293/5, -1 + I*204/5,
+            Rational(133, 15) + I*35/6, Rational(409, 30) + 15*I, Rational(56, 5), 32 + 40*I, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_fwht([u, v], [x, y]) == [u*x + v*y, u*y + v*x]
+
+    assert convolution_fwht([u, v, w], [x, y]) == \
+        [u*x + v*y, u*y + v*x, w*x, w*y]
+
+    assert convolution_fwht([u, v, w], [x, y, z]) == \
+        [u*x + v*y + w*z, u*y + v*x, u*z + w*x, v*z + w*y]
+
+    raises(TypeError, lambda: convolution_fwht(x, y))
+    raises(TypeError, lambda: convolution_fwht(x*y, u + v))
+
+
+def test_convolution_subset():
+    assert convolution_subset([], []) == []
+    assert convolution_subset([], [Rational(1, 3)]) == []
+    assert convolution_subset([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 3), sqrt(3), 4 + 5*I]
+    b = [64, 71, 55, 47, 33, 29, 15]
+    c = [3 + I*2/3, 5 + 7*I, 7, Rational(7, 5), 9]
+
+    assert convolution_subset(a, b) == [64, Rational(533, 3), 55 + 64*sqrt(3),
+                                        71*sqrt(3) + Rational(1184, 3) + 320*I, 33, 84,
+                                        15 + 33*sqrt(3), 29*sqrt(3) + 157 + 165*I]
+
+    assert convolution_subset(b, c) == [192 + I*128/3, 533 + I*1486/3,
+                                        613 + I*110/3, Rational(5013, 5) + I*1249/3,
+                                        675 + 22*I, 891 + I*751/3,
+                                        771 + 10*I, Rational(3736, 5) + 105*I]
+
+    assert convolution_subset(a, c) == convolution_subset(c, a)
+    assert convolution_subset(a[:2], b) == \
+            [64, Rational(533, 3), 55, Rational(416, 3), 33, 84, 15, 25]
+
+    assert convolution_subset(a[:2], c) == \
+            [3 + I*2/3, 10 + I*73/9, 7, Rational(196, 15), 9, 15, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_subset([u, v, w], [x, y]) == [u*x, u*y + v*x, w*x, w*y]
+    assert convolution_subset([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y, w*y, w*z + x*y]
+
+    assert convolution_subset([u, v], [x, y, z]) == \
+                    convolution_subset([x, y, z], [u, v])
+
+    raises(TypeError, lambda: convolution_subset(x, z))
+    raises(TypeError, lambda: convolution_subset(Rational(7, 3), u))
+
+
+def test_covering_product():
+    assert covering_product([], []) == []
+    assert covering_product([], [Rational(1, 3)]) == []
+    assert covering_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 8), sqrt(7), 4 + 9*I]
+    b = [66, 81, 95, 49, 37, 89, 17]
+    c = [3 + I*2/3, 51 + 72*I, 7, Rational(7, 15), 91]
+
+    assert covering_product(a, b) == [66, Rational(1383, 8), 95 + 161*sqrt(7),
+                                        130*sqrt(7) + 1303 + 2619*I, 37,
+                                        Rational(671, 4), 17 + 54*sqrt(7),
+                                        89*sqrt(7) + Rational(4661, 8) + 1287*I]
+
+    assert covering_product(b, c) == [198 + 44*I, 7740 + 10638*I,
+                                        1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                        9484 + I*74/3, 22163 + I*27394/3,
+                                        10621 + I*34/3, Rational(90236, 15) + 1224*I]
+
+    assert covering_product(a, c) == covering_product(c, a)
+    assert covering_product(b, c[:-1]) == [198 + 44*I, 7740 + 10638*I,
+                                         1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                         111 + I*74/3, 6693 + I*27394/3,
+                                         429 + I*34/3, Rational(23351, 15) + 1224*I]
+
+    assert covering_product(a, c[:-1]) == [3 + I*2/3,
+                            Rational(339, 4) + I*1409/12, 7 + 10*sqrt(7) + 2*sqrt(7)*I/3,
+                            -403 + 772*sqrt(7)/15 + 72*sqrt(7)*I + I*12658/15]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert covering_product([u, v, w], [x, y]) == \
+                            [u*x, u*y + v*x + v*y, w*x, w*y]
+
+    assert covering_product([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y + v*z, w*y, w*z + x*y + x*z]
+
+    assert covering_product([u, v], [x, y, z]) == \
+                    covering_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: covering_product(x, z))
+    raises(TypeError, lambda: covering_product(Rational(7, 3), u))
+
+
+def test_intersecting_product():
+    assert intersecting_product([], []) == []
+    assert intersecting_product([], [Rational(1, 3)]) == []
+    assert intersecting_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, sqrt(5), Rational(3, 8) + 5*I, 4 + 7*I]
+    b = [67, 51, 65, 48, 36, 79, 27]
+    c = [3 + I*2/5, 5 + 9*I, 7, Rational(7, 19), 13]
+
+    assert intersecting_product(a, b) == [195*sqrt(5) + Rational(6979, 8) + 1886*I,
+                                178*sqrt(5) + 520 + 910*I, Rational(841, 2) + 1344*I,
+                                192 + 336*I, 0, 0, 0, 0]
+
+    assert intersecting_product(b, c) == [Rational(128553, 19) + I*9521/5,
+                Rational(17820, 19) + 1602*I, Rational(19264, 19), Rational(336, 19), 1846, 0, 0, 0]
+
+    assert intersecting_product(a, c) == intersecting_product(c, a)
+    assert intersecting_product(b[1:], c[:-1]) == [Rational(64788, 19) + I*8622/5,
+                    Rational(12804, 19) + 1152*I, Rational(11508, 19), Rational(252, 19), 0, 0, 0, 0]
+
+    assert intersecting_product(a, c[:-2]) == \
+                    [Rational(-99, 5) + 10*sqrt(5) + 2*sqrt(5)*I/5 + I*3021/40,
+                    -43 + 5*sqrt(5) + 9*sqrt(5)*I + 71*I, Rational(245, 8) + 84*I, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert intersecting_product([u, v, w], [x, y]) == \
+                            [u*x + u*y + v*x + w*x + w*y, v*y, 0, 0]
+
+    assert intersecting_product([u, v, w, x], [y, z]) == \
+                        [u*y + u*z + v*y + w*y + w*z + x*y, v*z + x*z, 0, 0]
+
+    assert intersecting_product([u, v], [x, y, z]) == \
+                    intersecting_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: intersecting_product(x, z))
+    raises(TypeError, lambda: intersecting_product(u, Rational(8, 3)))

llmeval-env/lib/python3.10/site-packages/sympy/discrete/tests/test_recurrences.py

@@ -0,0 +1,59 @@
+from sympy.core.numbers import Rational
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.core import S, symbols
+from sympy.testing.pytest import raises
+from sympy.discrete.recurrences import linrec
+
+def test_linrec():
+    assert linrec(coeffs=[1, 1], init=[1, 1], n=20) == 10946
+    assert linrec(coeffs=[1, 2, 3, 4, 5], init=[1, 1, 0, 2], n=10) == 1040
+    assert linrec(coeffs=[0, 0, 11, 13], init=[23, 27], n=25) == 59628567384
+    assert linrec(coeffs=[0, 0, 1, 1, 2], init=[1, 5, 3], n=15) == 165
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=70) == \
+        56889923441670659718376223533331214868804815612050381493741233489928913241
+    assert linrec(coeffs=[0]*55 + [1, 1, 2, 3], init=[0]*50 + [1, 2, 3], n=4000) == \
+        702633573874937994980598979769135096432444135301118916539
+
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**4)
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**5)
+
+    assert all(linrec(coeffs=[1, 1], init=[0, 1], n=n) == fibonacci(n)
+                                                    for n in range(95, 115))
+
+    assert all(linrec(coeffs=[1, 1], init=[1, 1], n=n) == fibonacci(n + 1)
+                                                    for n in range(595, 615))
+
+    a = [S.Half, Rational(3, 4), Rational(5, 6), 7, Rational(8, 9), Rational(3, 5)]
+    b = [1, 2, 8, Rational(5, 7), Rational(3, 7), Rational(2, 9), 6]
+    x, y, z = symbols('x y z')
+
+    assert linrec(coeffs=a[:5], init=b[:4], n=80) == \
+        Rational(1726244235456268979436592226626304376013002142588105090705187189,
+            1960143456748895967474334873705475211264)
+
+    assert linrec(coeffs=a[:4], init=b[:4], n=50) == \
+        Rational(368949940033050147080268092104304441, 504857282956046106624)
+
+    assert linrec(coeffs=a[3:], init=b[:3], n=35) == \
+        Rational(97409272177295731943657945116791049305244422833125109,
+            814315512679031689453125)
+
+    assert linrec(coeffs=[0]*60 + [Rational(2, 3), Rational(4, 5)], init=b, n=3000) == \
+        Rational(26777668739896791448594650497024, 48084516708184142230517578125)
+
+    raises(TypeError, lambda: linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4, 5], n=1))
+    raises(TypeError, lambda: linrec(coeffs=a[:4], init=b[:5], n=10000))
+    raises(ValueError, lambda: linrec(coeffs=a[:4], init=b[:4], n=-10000))
+    raises(TypeError, lambda: linrec(x, b, n=10000))
+    raises(TypeError, lambda: linrec(a, y, n=10000))
+
+    assert linrec(coeffs=[x, y, z], init=[1, 1, 1], n=4) == \
+        x**2  + x*y + x*z + y + z
+    assert linrec(coeffs=[1, 2, 1], init=[x, y, z], n=20) == \
+        269542*x + 664575*y + 578949*z
+    assert linrec(coeffs=[0, 3, 1, 2], init=[x, y], n=30) == \
+        58516436*x + 56372788*y
+    assert linrec(coeffs=[0]*50 + [1, 2, 3], init=[x, y, z], n=1000) == \
+        11477135884896*x + 25999077948732*y + 41975630244216*z
+    assert linrec(coeffs=[], init=[1, 1], n=20) == 0
+    assert linrec(coeffs=[x, y, z], init=[1, 2, 3], n=2) == 3

llmeval-env/lib/python3.10/site-packages/sympy/discrete/tests/test_transforms.py

@@ -0,0 +1,154 @@
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, Symbol, symbols, I, Rational
+from sympy.discrete import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.testing.pytest import raises
+
+
+def test_fft_ifft():
+    assert all(tf(ls) == ls for tf in (fft, ifft)
+                            for ls in ([], [Rational(5, 3)]))
+
+    ls = list(range(6))
+    fls = [15, -7*sqrt(2)/2 - 4 - sqrt(2)*I/2 + 2*I, 2 + 3*I,
+             -4 + 7*sqrt(2)/2 - 2*I - sqrt(2)*I/2, -3,
+             -4 + 7*sqrt(2)/2 + sqrt(2)*I/2 + 2*I,
+              2 - 3*I, -7*sqrt(2)/2 - 4 - 2*I + sqrt(2)*I/2]
+
+    assert fft(ls) == fls
+    assert ifft(fls) == ls + [S.Zero]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    ifls = [Rational(9, 4) + 3*I, I*Rational(-7, 4), Rational(3, 4) + I, -2 - I/4]
+
+    assert ifft(ls) == ifls
+    assert fft(ifls) == ls + [S.Zero]
+
+    x = Symbol('x', real=True)
+    raises(TypeError, lambda: fft(x))
+    raises(ValueError, lambda: ifft([x, 2*x, 3*x**2, 4*x**3]))
+
+
+def test_ntt_intt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 2*500000003 + 1 # only for sequences of length 1 or 2
+    r = 2*3*5*7 # composite modulus
+
+    assert all(tf(ls, p) == ls for tf in (ntt, intt)
+                                for ls in ([], [5]))
+
+    ls = list(range(6))
+    nls = [15, 801133602, 738493201, 334102277, 998244350, 849020224,
+            259751156, 12232587]
+
+    assert ntt(ls, p) == nls
+    assert intt(nls, p) == ls + [0]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    x = Symbol('x', integer=True)
+
+    raises(TypeError, lambda: ntt(x, p))
+    raises(ValueError, lambda: intt([x, 2*x, 3*x**2, 4*x**3], p))
+    raises(ValueError, lambda: intt(ls, p))
+    raises(ValueError, lambda: ntt([1.2, 2.1, 3.5], p))
+    raises(ValueError, lambda: ntt([3, 5, 6], q))
+    raises(ValueError, lambda: ntt([4, 5, 7], r))
+    raises(ValueError, lambda: ntt([1.0, 2.0, 3.0], p))
+
+
+def test_fwht_ifwht():
+    assert all(tf(ls) == ls for tf in (fwht, ifwht) \
+                        for ls in ([], [Rational(7, 4)]))
+
+    ls = [213, 321, 43235, 5325, 312, 53]
+    fls = [49459, 38061, -47661, -37759, 48729, 37543, -48391, -38277]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*2
+
+    ls = [S.Half + 2*I, Rational(3, 7) + 4*I, Rational(5, 6) + 6*I, Rational(7, 3), Rational(9, 4)]
+    ifls = [Rational(533, 672) + I*3/2, Rational(23, 224) + I/2, Rational(1, 672), Rational(107, 224) - I,
+        Rational(155, 672) + I*3/2, Rational(-103, 224) + I/2, Rational(-377, 672), Rational(-19, 224) - I]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls + [S.Zero]*3
+
+    x, y = symbols('x y')
+
+    raises(TypeError, lambda: fwht(x))
+
+    ls = [x, 2*x, 3*x**2, 4*x**3]
+    ifls = [x**3 + 3*x**2/4 + x*Rational(3, 4),
+        -x**3 + 3*x**2/4 - x/4,
+        -x**3 - 3*x**2/4 + x*Rational(3, 4),
+        x**3 - 3*x**2/4 - x/4]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls
+
+    ls = [x, y, x**2, y**2, x*y]
+    fls = [x**2 + x*y + x + y**2 + y,
+        x**2 + x*y + x - y**2 - y,
+        -x**2 + x*y + x - y**2 + y,
+        -x**2 + x*y + x + y**2 - y,
+        x**2 - x*y + x + y**2 + y,
+        x**2 - x*y + x - y**2 - y,
+        -x**2 - x*y + x - y**2 + y,
+        -x**2 - x*y + x + y**2 - y]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*3
+
+    ls = list(range(6))
+
+    assert fwht(ls) == [x*8 for x in ifwht(ls)]
+
+
+def test_mobius_transform():
+    assert all(tf(ls, subset=subset) == ls
+                for ls in ([], [Rational(7, 4)]) for subset in (True, False)
+                for tf in (mobius_transform, inverse_mobius_transform))
+
+    w, x, y, z = symbols('w x y z')
+
+    assert mobius_transform([x, y]) == [x, x + y]
+    assert inverse_mobius_transform([x, x + y]) == [x, y]
+    assert mobius_transform([x, y], subset=False) == [x + y, y]
+    assert inverse_mobius_transform([x + y, y], subset=False) == [x, y]
+
+    assert mobius_transform([w, x, y, z]) == [w, w + x, w + y, w + x + y + z]
+    assert inverse_mobius_transform([w, w + x, w + y, w + x + y + z]) == \
+            [w, x, y, z]
+    assert mobius_transform([w, x, y, z], subset=False) == \
+            [w + x + y + z, x + z, y + z, z]
+    assert inverse_mobius_transform([w + x + y + z, x + z, y + z, z], subset=False) == \
+            [w, x, y, z]
+
+    ls = [Rational(2, 3), Rational(6, 7), Rational(5, 8), 9, Rational(5, 3) + 7*I]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168),
+            Rational(7, 3) + 7*I, Rational(67, 21) + 7*I, Rational(71, 24) + 7*I,
+            Rational(2153, 168) + 7*I]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls + [S.Zero]*3
+
+    mls = [Rational(2153, 168) + 7*I, Rational(69, 7), Rational(77, 8), 9, Rational(5, 3) + 7*I, 0, 0, 0]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls + [S.Zero]*3
+
+    ls = ls[:-1]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168)]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls
+
+    mls = [Rational(1873, 168), Rational(69, 7), Rational(77, 8), 9]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls
+
+    raises(TypeError, lambda: mobius_transform(x, subset=True))
+    raises(TypeError, lambda: inverse_mobius_transform(y, subset=False))

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

@@ -0,0 +1,425 @@
+"""
+Discrete Fourier Transform, Number Theoretic Transform,
+Walsh Hadamard Transform, Mobius Transform
+"""
+
+from sympy.core import S, Symbol, sympify
+from sympy.core.function import expand_mul
+from sympy.core.numbers import pi, I
+from sympy.functions.elementary.trigonometric import sin, cos
+from sympy.ntheory import isprime, primitive_root
+from sympy.utilities.iterables import ibin, iterable
+from sympy.utilities.misc import as_int
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Discrete Fourier Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _fourier_transform(seq, dps, inverse=False):
+    """Utility function for the Discrete Fourier Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of numeric coefficients "
+                        "for Fourier Transform")
+
+    a = [sympify(arg) for arg in seq]
+    if any(x.has(Symbol) for x in a):
+        raise ValueError("Expected non-symbolic coefficients")
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1): # not a power of 2
+        b += 1
+        n = 2**b
+
+    a += [S.Zero]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    ang = -2*pi/n if inverse else 2*pi/n
+
+    if dps is not None:
+        ang = ang.evalf(dps + 2)
+
+    w = [cos(ang*i) + I*sin(ang*i) for i in range(n // 2)]
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], expand_mul(a[i + j + hf]*w[ut * j])
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [(x/n).evalf(dps) for x in a] if dps is not None \
+                            else [x/n for x in a]
+
+    return a
+
+
+def fft(seq, dps=None):
+    r"""
+    Performs the Discrete Fourier Transform (**DFT**) in the complex domain.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FFT* requires the number of sample points to be a power of 2.
+
+    This method should be used with default arguments only for short sequences
+    as the complexity of expressions increases with the size of the sequence.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import fft, ifft
+
+    >>> fft([1, 2, 3, 4])
+    [10, -2 - 2*I, -2, -2 + 2*I]
+    >>> ifft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 2, 3, 4])
+    [5/2, -1/2 + I/2, -1/2, -1/2 - I/2]
+    >>> fft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 7, 3, 4], dps=15)
+    [3.75, -0.5 - 0.75*I, -1.75, -0.5 + 0.75*I]
+    >>> fft(_)
+    [1.0, 7.0, 3.0, 4.0]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
+    .. [2] https://mathworld.wolfram.com/FastFourierTransform.html
+
+    """
+
+    return _fourier_transform(seq, dps=dps)
+
+
+def ifft(seq, dps=None):
+    return _fourier_transform(seq, dps=dps, inverse=True)
+
+ifft.__doc__ = fft.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Number Theoretic Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _number_theoretic_transform(seq, prime, inverse=False):
+    """Utility function for the Number Theoretic Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of integer coefficients "
+                        "for Number Theoretic Transform")
+
+    p = as_int(prime)
+    if not isprime(p):
+        raise ValueError("Expected prime modulus for "
+                        "Number Theoretic Transform")
+
+    a = [as_int(x) % p for x in seq]
+
+    n = len(a)
+    if n < 1:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1):
+        b += 1
+        n = 2**b
+
+    if (p - 1) % n:
+        raise ValueError("Expected prime modulus of the form (m*2**k + 1)")
+
+    a += [0]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    pr = primitive_root(p)
+
+    rt = pow(pr, (p - 1) // n, p)
+    if inverse:
+        rt = pow(rt, p - 2, p)
+
+    w = [1]*(n // 2)
+    for i in range(1, n // 2):
+        w[i] = w[i - 1]*rt % p
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]*w[ut * j]
+                a[i + j], a[i + j + hf] = (u + v) % p, (u - v) % p
+        h *= 2
+
+    if inverse:
+        rv = pow(n, p - 2, p)
+        a = [x*rv % p for x in a]
+
+    return a
+
+
+def ntt(seq, prime):
+    r"""
+    Performs the Number Theoretic Transform (**NTT**), which specializes the
+    Discrete Fourier Transform (**DFT**) over quotient ring `Z/pZ` for prime
+    `p` instead of complex numbers `C`.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 NTT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy import ntt, intt
+    >>> ntt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [10, 643, 767, 122]
+    >>> intt(_, 3*2**8 + 1)
+    [1, 2, 3, 4]
+    >>> intt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [387, 415, 384, 353]
+    >>> ntt(_, prime=3*2**8 + 1)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] http://www.apfloat.org/ntt.html
+    .. [2] https://mathworld.wolfram.com/NumberTheoreticTransform.html
+    .. [3] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    return _number_theoretic_transform(seq, prime=prime)
+
+
+def intt(seq, prime):
+    return _number_theoretic_transform(seq, prime=prime, inverse=True)
+
+intt.__doc__ = ntt.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                          Walsh Hadamard Transform                          #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _walsh_hadamard_transform(seq, inverse=False):
+    """Utility function for the Walsh Hadamard Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients "
+                        "for Walsh Hadamard Transform")
+
+    a = [sympify(arg) for arg in seq]
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+    h = 2
+    while h <= n:
+        hf = h // 2
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [x/n for x in a]
+
+    return a
+
+
+def fwht(seq):
+    r"""
+    Performs the Walsh Hadamard Transform (**WHT**), and uses Hadamard
+    ordering for the sequence.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which WHT is to be applied.
+
+    Examples
+    ========
+
+    >>> from sympy import fwht, ifwht
+    >>> fwht([4, 2, 2, 0, 0, 2, -2, 0])
+    [8, 0, 8, 0, 8, 8, 0, 0]
+    >>> ifwht(_)
+    [4, 2, 2, 0, 0, 2, -2, 0]
+
+    >>> ifwht([19, -1, 11, -9, -7, 13, -15, 5])
+    [2, 0, 4, 0, 3, 10, 0, 0]
+    >>> fwht(_)
+    [19, -1, 11, -9, -7, 13, -15, 5]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hadamard_transform
+    .. [2] https://en.wikipedia.org/wiki/Fast_Walsh%E2%80%93Hadamard_transform
+
+    """
+
+    return _walsh_hadamard_transform(seq)
+
+
+def ifwht(seq):
+    return _walsh_hadamard_transform(seq, inverse=True)
+
+ifwht.__doc__ = fwht.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                    Mobius Transform for Subset Lattice                     #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _mobius_transform(seq, sgn, subset):
+    r"""Utility function for performing Mobius Transform using
+    Yate's Dynamic Programming method"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients")
+
+    a = [sympify(arg) for arg in seq]
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+
+    if subset:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    else:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    continue
+                a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    return a
+
+
+def mobius_transform(seq, subset=True):
+    r"""
+    Performs the Mobius Transform for subset lattice with indices of
+    sequence as bitmasks.
+
+    The indices of each argument, considered as bit strings, correspond
+    to subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset/superset based on bitmasks (indices) requires
+    the size of sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which Mobius Transform is to be applied.
+    subset : bool
+        Specifies if Mobius Transform is applied by enumerating subsets
+        or supersets of the given set.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy import mobius_transform, inverse_mobius_transform
+    >>> x, y, z = symbols('x y z')
+
+    >>> mobius_transform([x, y, z])
+    [x, x + y, x + z, x + y + z]
+    >>> inverse_mobius_transform(_)
+    [x, y, z, 0]
+
+    >>> mobius_transform([x, y, z], subset=False)
+    [x + y + z, y, z, 0]
+    >>> inverse_mobius_transform(_, subset=False)
+    [x, y, z, 0]
+
+    >>> mobius_transform([1, 2, 3, 4])
+    [1, 3, 4, 10]
+    >>> inverse_mobius_transform(_)
+    [1, 2, 3, 4]
+    >>> mobius_transform([1, 2, 3, 4], subset=False)
+    [10, 6, 7, 4]
+    >>> inverse_mobius_transform(_, subset=False)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius_inversion_formula
+    .. [2] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+    .. [3] https://arxiv.org/pdf/1211.0189.pdf
+
+    """
+
+    return _mobius_transform(seq, sgn=+1, subset=subset)
+
+def inverse_mobius_transform(seq, subset=True):
+    return _mobius_transform(seq, sgn=-1, subset=subset)
+
+inverse_mobius_transform.__doc__ = mobius_transform.__doc__

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

@@ -0,0 +1,5 @@
+from .diophantine import diophantine, classify_diop, diop_solve
+
+__all__ = [
+    'diophantine', 'classify_diop', 'diop_solve'
+]

llmeval-env/lib/python3.10/site-packages/sympy/solvers/diophantine/tests/test_diophantine.py

@@ -0,0 +1,1037 @@
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import Matrix
+from sympy.ntheory.factor_ import factorint
+from sympy.simplify.powsimp import powsimp
+from sympy.core.function import _mexpand
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.functions.elementary.trigonometric import sin
+from sympy.solvers.diophantine import diophantine
+from sympy.solvers.diophantine.diophantine import (diop_DN,
+    diop_solve, diop_ternary_quadratic_normal,
+    diop_general_pythagorean, diop_ternary_quadratic, diop_linear,
+    diop_quadratic, diop_general_sum_of_squares, diop_general_sum_of_even_powers,
+    descent, diop_bf_DN, divisible, equivalent, find_DN, ldescent, length,
+    reconstruct, partition, power_representation,
+    prime_as_sum_of_two_squares, square_factor, sum_of_four_squares,
+    sum_of_three_squares, transformation_to_DN, transformation_to_normal,
+    classify_diop, base_solution_linear, cornacchia, sqf_normal, gaussian_reduce, holzer,
+    check_param, parametrize_ternary_quadratic, sum_of_powers, sum_of_squares,
+    _diop_ternary_quadratic_normal, _nint_or_floor,
+    _odd, _even, _remove_gcd, _can_do_sum_of_squares, DiophantineSolutionSet, GeneralPythagorean,
+    BinaryQuadratic)
+
+from sympy.testing.pytest import slow, raises, XFAIL
+from sympy.utilities.iterables import (
+        signed_permutations)
+
+a, b, c, d, p, q, x, y, z, w, t, u, v, X, Y, Z = symbols(
+    "a, b, c, d, p, q, x, y, z, w, t, u, v, X, Y, Z", integer=True)
+t_0, t_1, t_2, t_3, t_4, t_5, t_6 = symbols("t_:7", integer=True)
+m1, m2, m3 = symbols('m1:4', integer=True)
+n1 = symbols('n1', integer=True)
+
+
+def diop_simplify(eq):
+    return _mexpand(powsimp(_mexpand(eq)))
+
+
+def test_input_format():
+    raises(TypeError, lambda: diophantine(sin(x)))
+    raises(TypeError, lambda: diophantine(x/pi - 3))
+
+
+def test_nosols():
+    # diophantine should sympify eq so that these are equivalent
+    assert diophantine(3) == set()
+    assert diophantine(S(3)) == set()
+
+
+def test_univariate():
+    assert diop_solve((x - 1)*(x - 2)**2) == {(1,), (2,)}
+    assert diop_solve((x - 1)*(x - 2)) == {(1,), (2,)}
+
+
+def test_classify_diop():
+    raises(TypeError, lambda: classify_diop(x**2/3 - 1))
+    raises(ValueError, lambda: classify_diop(1))
+    raises(NotImplementedError, lambda: classify_diop(w*x*y*z - 1))
+    raises(NotImplementedError, lambda: classify_diop(x**3 + y**3 + z**4 - 90))
+    assert classify_diop(14*x**2 + 15*x - 42) == (
+        [x], {1: -42, x: 15, x**2: 14}, 'univariate')
+    assert classify_diop(x*y + z) == (
+        [x, y, z], {x*y: 1, z: 1}, 'inhomogeneous_ternary_quadratic')
+    assert classify_diop(x*y + z + w + x**2) == (
+        [w, x, y, z], {x*y: 1, w: 1, x**2: 1, z: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + x*z + x**2 + 1) == (
+        [x, y, z], {x*y: 1, x*z: 1, x**2: 1, 1: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + z + w + 42) == (
+        [w, x, y, z], {x*y: 1, w: 1, 1: 42, z: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + z*w) == (
+        [w, x, y, z], {x*y: 1, w*z: 1}, 'homogeneous_general_quadratic')
+    assert classify_diop(x*y**2 + 1) == (
+        [x, y], {x*y**2: 1, 1: 1}, 'cubic_thue')
+    assert classify_diop(x**4 + y**4 + z**4 - (1 + 16 + 81)) == (
+        [x, y, z], {1: -98, x**4: 1, z**4: 1, y**4: 1}, 'general_sum_of_even_powers')
+    assert classify_diop(x**2 + y**2 + z**2) == (
+        [x, y, z], {x**2: 1, y**2: 1, z**2: 1}, 'homogeneous_ternary_quadratic_normal')
+
+
+def test_linear():
+    assert diop_solve(x) == (0,)
+    assert diop_solve(1*x) == (0,)
+    assert diop_solve(3*x) == (0,)
+    assert diop_solve(x + 1) == (-1,)
+    assert diop_solve(2*x + 1) == (None,)
+    assert diop_solve(2*x + 4) == (-2,)
+    assert diop_solve(y + x) == (t_0, -t_0)
+    assert diop_solve(y + x + 0) == (t_0, -t_0)
+    assert diop_solve(y + x - 0) == (t_0, -t_0)
+    assert diop_solve(0*x - y - 5) == (-5,)
+    assert diop_solve(3*y + 2*x - 5) == (3*t_0 - 5, -2*t_0 + 5)
+    assert diop_solve(2*x - 3*y - 5) == (3*t_0 - 5, 2*t_0 - 5)
+    assert diop_solve(-2*x - 3*y - 5) == (3*t_0 + 5, -2*t_0 - 5)
+    assert diop_solve(7*x + 5*y) == (5*t_0, -7*t_0)
+    assert diop_solve(2*x + 4*y) == (2*t_0, -t_0)
+    assert diop_solve(4*x + 6*y - 4) == (3*t_0 - 2, -2*t_0 + 2)
+    assert diop_solve(4*x + 6*y - 3) == (None, None)
+    assert diop_solve(0*x + 3*y - 4*z + 5) == (4*t_0 + 5, 3*t_0 + 5)
+    assert diop_solve(4*x + 3*y - 4*z + 5) == (t_0, 8*t_0 + 4*t_1 + 5, 7*t_0 + 3*t_1 + 5)
+    assert diop_solve(4*x + 3*y - 4*z + 5, None) == (0, 5, 5)
+    assert diop_solve(4*x + 2*y + 8*z - 5) == (None, None, None)
+    assert diop_solve(5*x + 7*y - 2*z - 6) == (t_0, -3*t_0 + 2*t_1 + 6, -8*t_0 + 7*t_1 + 18)
+    assert diop_solve(3*x - 6*y + 12*z - 9) == (2*t_0 + 3, t_0 + 2*t_1, t_1)
+    assert diop_solve(6*w + 9*x + 20*y - z) == (t_0, t_1, t_1 + t_2, 6*t_0 + 29*t_1 + 20*t_2)
+
+    # to ignore constant factors, use diophantine
+    raises(TypeError, lambda: diop_solve(x/2))
+
+
+def test_quadratic_simple_hyperbolic_case():
+    # Simple Hyperbolic case: A = C = 0 and B != 0
+    assert diop_solve(3*x*y + 34*x - 12*y + 1) == \
+           {(-133, -11), (5, -57)}
+    assert diop_solve(6*x*y + 2*x + 3*y + 1) == set()
+    assert diop_solve(-13*x*y + 2*x - 4*y - 54) == {(27, 0)}
+    assert diop_solve(-27*x*y - 30*x - 12*y - 54) == {(-14, -1)}
+    assert diop_solve(2*x*y + 5*x + 56*y + 7) == {(-161, -3), (-47, -6), (-35, -12),
+                                                  (-29, -69), (-27, 64), (-21, 7),
+                                                  (-9, 1), (105, -2)}
+    assert diop_solve(6*x*y + 9*x + 2*y + 3) == set()
+    assert diop_solve(x*y + x + y + 1) == {(-1, t), (t, -1)}
+    assert diophantine(48*x*y)
+
+
+def test_quadratic_elliptical_case():
+    # Elliptical case: B**2 - 4AC < 0
+
+    assert diop_solve(42*x**2 + 8*x*y + 15*y**2 + 23*x + 17*y - 4915) == {(-11, -1)}
+    assert diop_solve(4*x**2 + 3*y**2 + 5*x - 11*y + 12) == set()
+    assert diop_solve(x**2 + y**2 + 2*x + 2*y + 2) == {(-1, -1)}
+    assert diop_solve(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950) == {(-15, 6)}
+    assert diop_solve(10*x**2 + 12*x*y + 12*y**2 - 34) == \
+           {(-1, -1), (-1, 2), (1, -2), (1, 1)}
+
+
+def test_quadratic_parabolic_case():
+    # Parabolic case: B**2 - 4AC = 0
+    assert check_solutions(8*x**2 - 24*x*y + 18*y**2 + 5*x + 7*y + 16)
+    assert check_solutions(8*x**2 - 24*x*y + 18*y**2 + 6*x + 12*y - 6)
+    assert check_solutions(8*x**2 + 24*x*y + 18*y**2 + 4*x + 6*y - 7)
+    assert check_solutions(-4*x**2 + 4*x*y - y**2 + 2*x - 3)
+    assert check_solutions(x**2 + 2*x*y + y**2 + 2*x + 2*y + 1)
+    assert check_solutions(x**2 - 2*x*y + y**2 + 2*x + 2*y + 1)
+    assert check_solutions(y**2 - 41*x + 40)
+
+
+def test_quadratic_perfect_square():
+    # B**2 - 4*A*C > 0
+    # B**2 - 4*A*C is a perfect square
+    assert check_solutions(48*x*y)
+    assert check_solutions(4*x**2 - 5*x*y + y**2 + 2)
+    assert check_solutions(-2*x**2 - 3*x*y + 2*y**2 -2*x - 17*y + 25)
+    assert check_solutions(12*x**2 + 13*x*y + 3*y**2 - 2*x + 3*y - 12)
+    assert check_solutions(8*x**2 + 10*x*y + 2*y**2 - 32*x - 13*y - 23)
+    assert check_solutions(4*x**2 - 4*x*y - 3*y- 8*x - 3)
+    assert check_solutions(- 4*x*y - 4*y**2 - 3*y- 5*x - 10)
+    assert check_solutions(x**2 - y**2 - 2*x - 2*y)
+    assert check_solutions(x**2 - 9*y**2 - 2*x - 6*y)
+    assert check_solutions(4*x**2 - 9*y**2 - 4*x - 12*y - 3)
+
+
+def test_quadratic_non_perfect_square():
+    # B**2 - 4*A*C is not a perfect square
+    # Used check_solutions() since the solutions are complex expressions involving
+    # square roots and exponents
+    assert check_solutions(x**2 - 2*x - 5*y**2)
+    assert check_solutions(3*x**2 - 2*y**2 - 2*x - 2*y)
+    assert check_solutions(x**2 - x*y - y**2 - 3*y)
+    assert check_solutions(x**2 - 9*y**2 - 2*x - 6*y)
+    assert BinaryQuadratic(x**2 + y**2 + 2*x + 2*y + 2).solve() == {(-1, -1)}
+
+
+def test_issue_9106():
+    eq = -48 - 2*x*(3*x - 1) + y*(3*y - 1)
+    v = (x, y)
+    for sol in diophantine(eq):
+        assert not diop_simplify(eq.xreplace(dict(zip(v, sol))))
+
+
+def test_issue_18138():
+    eq = x**2 - x - y**2
+    v = (x, y)
+    for sol in diophantine(eq):
+        assert not diop_simplify(eq.xreplace(dict(zip(v, sol))))
+
+
+@slow
+def test_quadratic_non_perfect_slow():
+    assert check_solutions(8*x**2 + 10*x*y - 2*y**2 - 32*x - 13*y - 23)
+    # This leads to very large numbers.
+    # assert check_solutions(5*x**2 - 13*x*y + y**2 - 4*x - 4*y - 15)
+    assert check_solutions(-3*x**2 - 2*x*y + 7*y**2 - 5*x - 7)
+    assert check_solutions(-4 - x + 4*x**2 - y - 3*x*y - 4*y**2)
+    assert check_solutions(1 + 2*x + 2*x**2 + 2*y + x*y - 2*y**2)
+
+
+def test_DN():
+    # Most of the test cases were adapted from,
+    # Solving the generalized Pell equation x**2 - D*y**2 = N, John P. Robertson, July 31, 2004.
+    # https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+    # others are verified using Wolfram Alpha.
+
+    # Covers cases where D <= 0 or D > 0 and D is a square or N = 0
+    # Solutions are straightforward in these cases.
+    assert diop_DN(3, 0) == [(0, 0)]
+    assert diop_DN(-17, -5) == []
+    assert diop_DN(-19, 23) == [(2, 1)]
+    assert diop_DN(-13, 17) == [(2, 1)]
+    assert diop_DN(-15, 13) == []
+    assert diop_DN(0, 5) == []
+    assert diop_DN(0, 9) == [(3, t)]
+    assert diop_DN(9, 0) == [(3*t, t)]
+    assert diop_DN(16, 24) == []
+    assert diop_DN(9, 180) == [(18, 4)]
+    assert diop_DN(9, -180) == [(12, 6)]
+    assert diop_DN(7, 0) == [(0, 0)]
+
+    # When equation is x**2 + y**2 = N
+    # Solutions are interchangeable
+    assert diop_DN(-1, 5) == [(2, 1), (1, 2)]
+    assert diop_DN(-1, 169) == [(12, 5), (5, 12), (13, 0), (0, 13)]
+
+    # D > 0 and D is not a square
+
+    # N = 1
+    assert diop_DN(13, 1) == [(649, 180)]
+    assert diop_DN(980, 1) == [(51841, 1656)]
+    assert diop_DN(981, 1) == [(158070671986249, 5046808151700)]
+    assert diop_DN(986, 1) == [(49299, 1570)]
+    assert diop_DN(991, 1) == [(379516400906811930638014896080, 12055735790331359447442538767)]
+    assert diop_DN(17, 1) == [(33, 8)]
+    assert diop_DN(19, 1) == [(170, 39)]
+
+    # N = -1
+    assert diop_DN(13, -1) == [(18, 5)]
+    assert diop_DN(991, -1) == []
+    assert diop_DN(41, -1) == [(32, 5)]
+    assert diop_DN(290, -1) == [(17, 1)]
+    assert diop_DN(21257, -1) == [(13913102721304, 95427381109)]
+    assert diop_DN(32, -1) == []
+
+    # |N| > 1
+    # Some tests were created using calculator at
+    # http://www.numbertheory.org/php/patz.html
+
+    assert diop_DN(13, -4) == [(3, 1), (393, 109), (36, 10)]
+    # Source I referred returned (3, 1), (393, 109) and (-3, 1) as fundamental solutions
+    # So (-3, 1) and (393, 109) should be in the same equivalent class
+    assert equivalent(-3, 1, 393, 109, 13, -4) == True
+
+    assert diop_DN(13, 27) == [(220, 61), (40, 11), (768, 213), (12, 3)]
+    assert set(diop_DN(157, 12)) == {(13, 1), (10663, 851), (579160, 46222),
+                                     (483790960, 38610722), (26277068347, 2097138361),
+                                     (21950079635497, 1751807067011)}
+    assert diop_DN(13, 25) == [(3245, 900)]
+    assert diop_DN(192, 18) == []
+    assert diop_DN(23, 13) == [(-6, 1), (6, 1)]
+    assert diop_DN(167, 2) == [(13, 1)]
+    assert diop_DN(167, -2) == []
+
+    assert diop_DN(123, -2) == [(11, 1)]
+    # One calculator returned [(11, 1), (-11, 1)] but both of these are in
+    # the same equivalence class
+    assert equivalent(11, 1, -11, 1, 123, -2)
+
+    assert diop_DN(123, -23) == [(-10, 1), (10, 1)]
+
+    assert diop_DN(0, 0, t) == [(0, t)]
+    assert diop_DN(0, -1, t) == []
+
+
+def test_bf_pell():
+    assert diop_bf_DN(13, -4) == [(3, 1), (-3, 1), (36, 10)]
+    assert diop_bf_DN(13, 27) == [(12, 3), (-12, 3), (40, 11), (-40, 11)]
+    assert diop_bf_DN(167, -2) == []
+    assert diop_bf_DN(1729, 1) == [(44611924489705, 1072885712316)]
+    assert diop_bf_DN(89, -8) == [(9, 1), (-9, 1)]
+    assert diop_bf_DN(21257, -1) == [(13913102721304, 95427381109)]
+    assert diop_bf_DN(340, -4) == [(756, 41)]
+    assert diop_bf_DN(-1, 0, t) == [(0, 0)]
+    assert diop_bf_DN(0, 0, t) == [(0, t)]
+    assert diop_bf_DN(4, 0, t) == [(2*t, t), (-2*t, t)]
+    assert diop_bf_DN(3, 0, t) == [(0, 0)]
+    assert diop_bf_DN(1, -2, t) == []
+
+
+def test_length():
+    assert length(2, 1, 0) == 1
+    assert length(-2, 4, 5) == 3
+    assert length(-5, 4, 17) == 4
+    assert length(0, 4, 13) == 6
+    assert length(7, 13, 11) == 23
+    assert length(1, 6, 4) == 2
+
+
+def is_pell_transformation_ok(eq):
+    """
+    Test whether X*Y, X, or Y terms are present in the equation
+    after transforming the equation using the transformation returned
+    by transformation_to_pell(). If they are not present we are good.
+    Moreover, coefficient of X**2 should be a divisor of coefficient of
+    Y**2 and the constant term.
+    """
+    A, B = transformation_to_DN(eq)
+    u = (A*Matrix([X, Y]) + B)[0]
+    v = (A*Matrix([X, Y]) + B)[1]
+    simplified = diop_simplify(eq.subs(zip((x, y), (u, v))))
+
+    coeff = dict([reversed(t.as_independent(*[X, Y])) for t in simplified.args])
+
+    for term in [X*Y, X, Y]:
+        if term in coeff.keys():
+            return False
+
+    for term in [X**2, Y**2, 1]:
+        if term not in coeff.keys():
+            coeff[term] = 0
+
+    if coeff[X**2] != 0:
+        return divisible(coeff[Y**2], coeff[X**2]) and \
+        divisible(coeff[1], coeff[X**2])
+
+    return True
+
+
+def test_transformation_to_pell():
+    assert is_pell_transformation_ok(-13*x**2 - 7*x*y + y**2 + 2*x - 2*y - 14)
+    assert is_pell_transformation_ok(-17*x**2 + 19*x*y - 7*y**2 - 5*x - 13*y - 23)
+    assert is_pell_transformation_ok(x**2 - y**2 + 17)
+    assert is_pell_transformation_ok(-x**2 + 7*y**2 - 23)
+    assert is_pell_transformation_ok(25*x**2 - 45*x*y + 5*y**2 - 5*x - 10*y + 5)
+    assert is_pell_transformation_ok(190*x**2 + 30*x*y + y**2 - 3*y - 170*x - 130)
+    assert is_pell_transformation_ok(x**2 - 2*x*y -190*y**2 - 7*y - 23*x - 89)
+    assert is_pell_transformation_ok(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950)
+
+
+def test_find_DN():
+    assert find_DN(x**2 - 2*x - y**2) == (1, 1)
+    assert find_DN(x**2 - 3*y**2 - 5) == (3, 5)
+    assert find_DN(x**2 - 2*x*y - 4*y**2 - 7) == (5, 7)
+    assert find_DN(4*x**2 - 8*x*y - y**2 - 9) == (20, 36)
+    assert find_DN(7*x**2 - 2*x*y - y**2 - 12) == (8, 84)
+    assert find_DN(-3*x**2 + 4*x*y -y**2) == (1, 0)
+    assert find_DN(-13*x**2 - 7*x*y + y**2 + 2*x - 2*y -14) == (101, -7825480)
+
+
+def test_ldescent():
+    # Equations which have solutions
+    u = ([(13, 23), (3, -11), (41, -113), (4, -7), (-7, 4), (91, -3), (1, 1), (1, -1),
+        (4, 32), (17, 13), (123689, 1), (19, -570)])
+    for a, b in u:
+        w, x, y = ldescent(a, b)
+        assert a*x**2 + b*y**2 == w**2
+    assert ldescent(-1, -1) is None
+
+
+def test_diop_ternary_quadratic_normal():
+    assert check_solutions(234*x**2 - 65601*y**2 - z**2)
+    assert check_solutions(23*x**2 + 616*y**2 - z**2)
+    assert check_solutions(5*x**2 + 4*y**2 - z**2)
+    assert check_solutions(3*x**2 + 6*y**2 - 3*z**2)
+    assert check_solutions(x**2 + 3*y**2 - z**2)
+    assert check_solutions(4*x**2 + 5*y**2 - z**2)
+    assert check_solutions(x**2 + y**2 - z**2)
+    assert check_solutions(16*x**2 + y**2 - 25*z**2)
+    assert check_solutions(6*x**2 - y**2 + 10*z**2)
+    assert check_solutions(213*x**2 + 12*y**2 - 9*z**2)
+    assert check_solutions(34*x**2 - 3*y**2 - 301*z**2)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+
+
+def is_normal_transformation_ok(eq):
+    A = transformation_to_normal(eq)
+    X, Y, Z = A*Matrix([x, y, z])
+    simplified = diop_simplify(eq.subs(zip((x, y, z), (X, Y, Z))))
+
+    coeff = dict([reversed(t.as_independent(*[X, Y, Z])) for t in simplified.args])
+    for term in [X*Y, Y*Z, X*Z]:
+        if term in coeff.keys():
+            return False
+
+    return True
+
+
+def test_transformation_to_normal():
+    assert is_normal_transformation_ok(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z)
+    assert is_normal_transformation_ok(x**2 + 3*y**2 - 100*z**2)
+    assert is_normal_transformation_ok(x**2 + 23*y*z)
+    assert is_normal_transformation_ok(3*y**2 - 100*z**2 - 12*x*y)
+    assert is_normal_transformation_ok(x**2 + 23*x*y - 34*y*z + 12*x*z)
+    assert is_normal_transformation_ok(z**2 + 34*x*y - 23*y*z + x*z)
+    assert is_normal_transformation_ok(x**2 + y**2 + z**2 - x*y - y*z - x*z)
+    assert is_normal_transformation_ok(x**2 + 2*y*z + 3*z**2)
+    assert is_normal_transformation_ok(x*y + 2*x*z + 3*y*z)
+    assert is_normal_transformation_ok(2*x*z + 3*y*z)
+
+
+def test_diop_ternary_quadratic():
+    assert check_solutions(2*x**2 + z**2 + y**2 - 4*x*y)
+    assert check_solutions(x**2 - y**2 - z**2 - x*y - y*z)
+    assert check_solutions(3*x**2 - x*y - y*z - x*z)
+    assert check_solutions(x**2 - y*z - x*z)
+    assert check_solutions(5*x**2 - 3*x*y - x*z)
+    assert check_solutions(4*x**2 - 5*y**2 - x*z)
+    assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z)
+    assert check_solutions(8*x**2 - 12*y*z)
+    assert check_solutions(45*x**2 - 7*y**2 - 8*x*y - z**2)
+    assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y -8*x*y)
+    assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 17*y*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 16*y*z + 12*x*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z)
+    assert check_solutions(x*y - 7*y*z + 13*x*z)
+
+    assert diop_ternary_quadratic_normal(x**2 + y**2 + z**2) == (None, None, None)
+    assert diop_ternary_quadratic_normal(x**2 + y**2) is None
+    raises(ValueError, lambda:
+        _diop_ternary_quadratic_normal((x, y, z),
+        {x*y: 1, x**2: 2, y**2: 3, z**2: 0}))
+    eq = -2*x*y - 6*x*z + 7*y**2 - 3*y*z + 4*z**2
+    assert diop_ternary_quadratic(eq) == (7, 2, 0)
+    assert diop_ternary_quadratic_normal(4*x**2 + 5*y**2 - z**2) == \
+        (1, 0, 2)
+    assert diop_ternary_quadratic(x*y + 2*y*z) == \
+        (-2, 0, n1)
+    eq = -5*x*y - 8*x*z - 3*y*z + 8*z**2
+    assert parametrize_ternary_quadratic(eq) == \
+        (8*p**2 - 3*p*q, -8*p*q + 8*q**2, 5*p*q)
+    # this cannot be tested with diophantine because it will
+    # factor into a product
+    assert diop_solve(x*y + 2*y*z) == (-2*p*q, -n1*p**2 + p**2, p*q)
+
+
+def test_square_factor():
+    assert square_factor(1) == square_factor(-1) == 1
+    assert square_factor(0) == 1
+    assert square_factor(5) == square_factor(-5) == 1
+    assert square_factor(4) == square_factor(-4) == 2
+    assert square_factor(12) == square_factor(-12) == 2
+    assert square_factor(6) == 1
+    assert square_factor(18) == 3
+    assert square_factor(52) == 2
+    assert square_factor(49) == 7
+    assert square_factor(392) == 14
+    assert square_factor(factorint(-12)) == 2
+
+
+def test_parametrize_ternary_quadratic():
+    assert check_solutions(x**2 + y**2 - z**2)
+    assert check_solutions(x**2 + 2*x*y + z**2)
+    assert check_solutions(234*x**2 - 65601*y**2 - z**2)
+    assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z)
+    assert check_solutions(x**2 - y**2 - z**2)
+    assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y - 8*x*y)
+    assert check_solutions(8*x*y + z**2)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+    assert check_solutions(236*x**2 - 225*y**2 - 11*x*y - 13*y*z - 17*x*z)
+    assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+
+
+def test_no_square_ternary_quadratic():
+    assert check_solutions(2*x*y + y*z - 3*x*z)
+    assert check_solutions(189*x*y - 345*y*z - 12*x*z)
+    assert check_solutions(23*x*y + 34*y*z)
+    assert check_solutions(x*y + y*z + z*x)
+    assert check_solutions(23*x*y + 23*y*z + 23*x*z)
+
+
+def test_descent():
+
+    u = ([(13, 23), (3, -11), (41, -113), (91, -3), (1, 1), (1, -1), (17, 13), (123689, 1), (19, -570)])
+    for a, b in u:
+        w, x, y = descent(a, b)
+        assert a*x**2 + b*y**2 == w**2
+    # the docstring warns against bad input, so these are expected results
+    # - can't both be negative
+    raises(TypeError, lambda: descent(-1, -3))
+    # A can't be zero unless B != 1
+    raises(ZeroDivisionError, lambda: descent(0, 3))
+    # supposed to be square-free
+    raises(TypeError, lambda: descent(4, 3))
+
+
+def test_diophantine():
+    assert check_solutions((x - y)*(y - z)*(z - x))
+    assert check_solutions((x - y)*(x**2 + y**2 - z**2))
+    assert check_solutions((x - 3*y + 7*z)*(x**2 + y**2 - z**2))
+    assert check_solutions(x**2 - 3*y**2 - 1)
+    assert check_solutions(y**2 + 7*x*y)
+    assert check_solutions(x**2 - 3*x*y + y**2)
+    assert check_solutions(z*(x**2 - y**2 - 15))
+    assert check_solutions(x*(2*y - 2*z + 5))
+    assert check_solutions((x**2 - 3*y**2 - 1)*(x**2 - y**2 - 15))
+    assert check_solutions((x**2 - 3*y**2 - 1)*(y - 7*z))
+    assert check_solutions((x**2 + y**2 - z**2)*(x - 7*y - 3*z + 4*w))
+    # Following test case caused problems in parametric representation
+    # But this can be solved by factoring out y.
+    # No need to use methods for ternary quadratic equations.
+    assert check_solutions(y**2 - 7*x*y + 4*y*z)
+    assert check_solutions(x**2 - 2*x + 1)
+
+    assert diophantine(x - y) == diophantine(Eq(x, y))
+    # 18196
+    eq = x**4 + y**4 - 97
+    assert diophantine(eq, permute=True) == diophantine(-eq, permute=True)
+    assert diophantine(3*x*pi - 2*y*pi) == {(2*t_0, 3*t_0)}
+    eq = x**2 + y**2 + z**2 - 14
+    base_sol = {(1, 2, 3)}
+    assert diophantine(eq) == base_sol
+    complete_soln = set(signed_permutations(base_sol.pop()))
+    assert diophantine(eq, permute=True) == complete_soln
+
+    assert diophantine(x**2 + x*Rational(15, 14) - 3) == set()
+    # test issue 11049
+    eq = 92*x**2 - 99*y**2 - z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(9, 7, 51)}
+    assert diophantine(eq) == {(
+        891*p**2 + 9*q**2, -693*p**2 - 102*p*q + 7*q**2,
+        5049*p**2 - 1386*p*q - 51*q**2)}
+    eq = 2*x**2 + 2*y**2 - z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(1, 1, 2)}
+    assert diophantine(eq) == {(
+        2*p**2 - q**2, -2*p**2 + 4*p*q - q**2,
+        4*p**2 - 4*p*q + 2*q**2)}
+    eq = 411*x**2+57*y**2-221*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(2021, 2645, 3066)}
+    assert diophantine(eq) == \
+           {(115197*p**2 - 446641*q**2, -150765*p**2 + 1355172*p*q -
+             584545*q**2, 174762*p**2 - 301530*p*q + 677586*q**2)}
+    eq = 573*x**2+267*y**2-984*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(49, 233, 127)}
+    assert diophantine(eq) == \
+           {(4361*p**2 - 16072*q**2, -20737*p**2 + 83312*p*q - 76424*q**2,
+             11303*p**2 - 41474*p*q + 41656*q**2)}
+    # this produces factors during reconstruction
+    eq = x**2 + 3*y**2 - 12*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(0, 2, 1)}
+    assert diophantine(eq) == \
+           {(24*p*q, 2*p**2 - 24*q**2, p**2 + 12*q**2)}
+    # solvers have not been written for every type
+    raises(NotImplementedError, lambda: diophantine(x*y**2 + 1))
+
+    # rational expressions
+    assert diophantine(1/x) == set()
+    assert diophantine(1/x + 1/y - S.Half) == {(6, 3), (-2, 1), (4, 4), (1, -2), (3, 6)}
+    assert diophantine(x**2 + y**2 +3*x- 5, permute=True) == \
+           {(-1, 1), (-4, -1), (1, -1), (1, 1), (-4, 1), (-1, -1), (4, 1), (4, -1)}
+
+
+    #test issue 18186
+    assert diophantine(y**4 + x**4 - 2**4 - 3**4, syms=(x, y), permute=True) == \
+           {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+    assert diophantine(y**4 + x**4 - 2**4 - 3**4, syms=(y, x), permute=True) == \
+           {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+
+    # issue 18122
+    assert check_solutions(x**2-y)
+    assert check_solutions(y**2-x)
+    assert diophantine((x**2-y), t) == {(t, t**2)}
+    assert diophantine((y**2-x), t) == {(t**2, -t)}
+
+
+def test_general_pythagorean():
+    from sympy.abc import a, b, c, d, e
+
+    assert check_solutions(a**2 + b**2 + c**2 - d**2)
+    assert check_solutions(a**2 + 4*b**2 + 4*c**2 - d**2)
+    assert check_solutions(9*a**2 + 4*b**2 + 4*c**2 - d**2)
+    assert check_solutions(9*a**2 + 4*b**2 - 25*d**2 + 4*c**2 )
+    assert check_solutions(9*a**2 - 16*d**2 + 4*b**2 + 4*c**2)
+    assert check_solutions(-e**2 + 9*a**2 + 4*b**2 + 4*c**2 + 25*d**2)
+    assert check_solutions(16*a**2 - b**2 + 9*c**2 + d**2 + 25*e**2)
+
+    assert GeneralPythagorean(a**2 + b**2 + c**2 - d**2).solve(parameters=[x, y, z]) == \
+           {(x**2 + y**2 - z**2, 2*x*z, 2*y*z, x**2 + y**2 + z**2)}
+
+
+def test_diop_general_sum_of_squares_quick():
+    for i in range(3, 10):
+        assert check_solutions(sum(i**2 for i in symbols(':%i' % i)) - i)
+
+    assert diop_general_sum_of_squares(x**2 + y**2 - 2) is None
+    assert diop_general_sum_of_squares(x**2 + y**2 + z**2 + 2) == set()
+    eq = x**2 + y**2 + z**2 - (1 + 4 + 9)
+    assert diop_general_sum_of_squares(eq) == \
+           {(1, 2, 3)}
+    eq = u**2 + v**2 + x**2 + y**2 + z**2 - 1313
+    assert len(diop_general_sum_of_squares(eq, 3)) == 3
+    # issue 11016
+    var = symbols(':5') + (symbols('6', negative=True),)
+    eq = Add(*[i**2 for i in var]) - 112
+
+    base_soln = {(0, 1, 1, 5, 6, -7), (1, 1, 1, 3, 6, -8), (2, 3, 3, 4, 5, -7), (0, 1, 1, 1, 3, -10),
+                 (0, 0, 4, 4, 4, -8), (1, 2, 3, 3, 5, -8), (0, 1, 2, 3, 7, -7), (2, 2, 4, 4, 6, -6),
+                 (1, 1, 3, 4, 6, -7), (0, 2, 3, 3, 3, -9), (0, 0, 2, 2, 2, -10), (1, 1, 2, 3, 4, -9),
+                 (0, 1, 1, 2, 5, -9), (0, 0, 2, 6, 6, -6), (1, 3, 4, 5, 5, -6), (0, 2, 2, 2, 6, -8),
+                 (0, 3, 3, 3, 6, -7), (0, 2, 3, 5, 5, -7), (0, 1, 5, 5, 5, -6)}
+    assert diophantine(eq) == base_soln
+    assert len(diophantine(eq, permute=True)) == 196800
+
+    # handle negated squares with signsimp
+    assert diophantine(12 - x**2 - y**2 - z**2) == {(2, 2, 2)}
+    # diophantine handles simplification, so classify_diop should
+    # not have to look for additional patterns that are removed
+    # by diophantine
+    eq = a**2 + b**2 + c**2 + d**2 - 4
+    raises(NotImplementedError, lambda: classify_diop(-eq))
+
+
+def test_issue_23807():
+    # fixes recursion error
+    eq = x**2 + y**2 + z**2 - 1000000
+    base_soln = {(0, 0, 1000), (0, 352, 936), (480, 600, 640), (24, 640, 768), (192, 640, 744),
+                 (192, 480, 856), (168, 224, 960), (0, 600, 800), (280, 576, 768), (152, 480, 864),
+                 (0, 280, 960), (352, 360, 864), (424, 480, 768), (360, 480, 800), (224, 600, 768),
+                 (96, 360, 928), (168, 576, 800), (96, 480, 872)}
+
+    assert diophantine(eq) == base_soln
+
+
+def test_diop_partition():
+    for n in [8, 10]:
+        for k in range(1, 8):
+            for p in partition(n, k):
+                assert len(p) == k
+    assert list(partition(3, 5)) == []
+    assert [list(p) for p in partition(3, 5, 1)] == [
+        [0, 0, 0, 0, 3], [0, 0, 0, 1, 2], [0, 0, 1, 1, 1]]
+    assert list(partition(0)) == [()]
+    assert list(partition(1, 0)) == [()]
+    assert [list(i) for i in partition(3)] == [[1, 1, 1], [1, 2], [3]]
+
+
+def test_prime_as_sum_of_two_squares():
+    for i in [5, 13, 17, 29, 37, 41, 2341, 3557, 34841, 64601]:
+        a, b = prime_as_sum_of_two_squares(i)
+        assert a**2 + b**2 == i
+    assert prime_as_sum_of_two_squares(7) is None
+    ans = prime_as_sum_of_two_squares(800029)
+    assert ans == (450, 773) and type(ans[0]) is int
+
+
+def test_sum_of_three_squares():
+    for i in [0, 1, 2, 34, 123, 34304595905, 34304595905394941, 343045959052344,
+              800, 801, 802, 803, 804, 805, 806]:
+        a, b, c = sum_of_three_squares(i)
+        assert a**2 + b**2 + c**2 == i
+
+    assert sum_of_three_squares(7) is None
+    assert sum_of_three_squares((4**5)*15) is None
+    assert sum_of_three_squares(25) == (5, 0, 0)
+    assert sum_of_three_squares(4) == (0, 0, 2)
+
+
+def test_sum_of_four_squares():
+    from sympy.core.random import randint
+
+    # this should never fail
+    n = randint(1, 100000000000000)
+    assert sum(i**2 for i in sum_of_four_squares(n)) == n
+
+    assert sum_of_four_squares(0) == (0, 0, 0, 0)
+    assert sum_of_four_squares(14) == (0, 1, 2, 3)
+    assert sum_of_four_squares(15) == (1, 1, 2, 3)
+    assert sum_of_four_squares(18) == (1, 2, 2, 3)
+    assert sum_of_four_squares(19) == (0, 1, 3, 3)
+    assert sum_of_four_squares(48) == (0, 4, 4, 4)
+
+
+def test_power_representation():
+    tests = [(1729, 3, 2), (234, 2, 4), (2, 1, 2), (3, 1, 3), (5, 2, 2), (12352, 2, 4),
+             (32760, 2, 3)]
+
+    for test in tests:
+        n, p, k = test
+        f = power_representation(n, p, k)
+
+        while True:
+            try:
+                l = next(f)
+                assert len(l) == k
+
+                chk_sum = 0
+                for l_i in l:
+                    chk_sum = chk_sum + l_i**p
+                assert chk_sum == n
+
+            except StopIteration:
+                break
+
+    assert list(power_representation(20, 2, 4, True)) == \
+        [(1, 1, 3, 3), (0, 0, 2, 4)]
+    raises(ValueError, lambda: list(power_representation(1.2, 2, 2)))
+    raises(ValueError, lambda: list(power_representation(2, 0, 2)))
+    raises(ValueError, lambda: list(power_representation(2, 2, 0)))
+    assert list(power_representation(-1, 2, 2)) == []
+    assert list(power_representation(1, 1, 1)) == [(1,)]
+    assert list(power_representation(3, 2, 1)) == []
+    assert list(power_representation(4, 2, 1)) == [(2,)]
+    assert list(power_representation(3**4, 4, 6, zeros=True)) == \
+        [(1, 2, 2, 2, 2, 2), (0, 0, 0, 0, 0, 3)]
+    assert list(power_representation(3**4, 4, 5, zeros=False)) == []
+    assert list(power_representation(-2, 3, 2)) == [(-1, -1)]
+    assert list(power_representation(-2, 4, 2)) == []
+    assert list(power_representation(0, 3, 2, True)) == [(0, 0)]
+    assert list(power_representation(0, 3, 2, False)) == []
+    # when we are dealing with squares, do feasibility checks
+    assert len(list(power_representation(4**10*(8*10 + 7), 2, 3))) == 0
+    # there will be a recursion error if these aren't recognized
+    big = 2**30
+    for i in [13, 10, 7, 5, 4, 2, 1]:
+        assert list(sum_of_powers(big, 2, big - i)) == []
+
+
+def test_assumptions():
+    """
+    Test whether diophantine respects the assumptions.
+    """
+    #Test case taken from the below so question regarding assumptions in diophantine module
+    #https://stackoverflow.com/questions/23301941/how-can-i-declare-natural-symbols-with-sympy
+    m, n = symbols('m n', integer=True, positive=True)
+    diof = diophantine(n**2 + m*n - 500)
+    assert diof == {(5, 20), (40, 10), (95, 5), (121, 4), (248, 2), (499, 1)}
+
+    a, b = symbols('a b', integer=True, positive=False)
+    diof = diophantine(a*b + 2*a + 3*b - 6)
+    assert diof == {(-15, -3), (-9, -4), (-7, -5), (-6, -6), (-5, -8), (-4, -14)}
+
+
+def check_solutions(eq):
+    """
+    Determines whether solutions returned by diophantine() satisfy the original
+    equation. Hope to generalize this so we can remove functions like check_ternay_quadratic,
+    check_solutions_normal, check_solutions()
+    """
+    s = diophantine(eq)
+
+    factors = Mul.make_args(eq)
+
+    var = list(eq.free_symbols)
+    var.sort(key=default_sort_key)
+
+    while s:
+        solution = s.pop()
+        for f in factors:
+            if diop_simplify(f.subs(zip(var, solution))) == 0:
+                break
+        else:
+            return False
+    return True
+
+
+def test_diopcoverage():
+    eq = (2*x + y + 1)**2
+    assert diop_solve(eq) == {(t_0, -2*t_0 - 1)}
+    eq = 2*x**2 + 6*x*y + 12*x + 4*y**2 + 18*y + 18
+    assert diop_solve(eq) == {(t, -t - 3), (2*t - 3, -t)}
+    assert diop_quadratic(x + y**2 - 3) == {(-t**2 + 3, -t)}
+
+    assert diop_linear(x + y - 3) == (t_0, 3 - t_0)
+
+    assert base_solution_linear(0, 1, 2, t=None) == (0, 0)
+    ans = (3*t - 1, -2*t + 1)
+    assert base_solution_linear(4, 8, 12, t) == ans
+    assert base_solution_linear(4, 8, 12, t=None) == tuple(_.subs(t, 0) for _ in ans)
+
+    assert cornacchia(1, 1, 20) is None
+    assert cornacchia(1, 1, 5) == {(2, 1)}
+    assert cornacchia(1, 2, 17) == {(3, 2)}
+
+    raises(ValueError, lambda: reconstruct(4, 20, 1))
+
+    assert gaussian_reduce(4, 1, 3) == (1, 1)
+    eq = -w**2 - x**2 - y**2 + z**2
+
+    assert diop_general_pythagorean(eq) == \
+        diop_general_pythagorean(-eq) == \
+            (m1**2 + m2**2 - m3**2, 2*m1*m3,
+            2*m2*m3, m1**2 + m2**2 + m3**2)
+
+    assert len(check_param(S(3) + x/3, S(4) + x/2, S(2), [x])) == 0
+    assert len(check_param(Rational(3, 2), S(4) + x, S(2), [x])) == 0
+    assert len(check_param(S(4) + x, Rational(3, 2), S(2), [x])) == 0
+
+    assert _nint_or_floor(16, 10) == 2
+    assert _odd(1) == (not _even(1)) == True
+    assert _odd(0) == (not _even(0)) == False
+    assert _remove_gcd(2, 4, 6) == (1, 2, 3)
+    raises(TypeError, lambda: _remove_gcd((2, 4, 6)))
+    assert sqf_normal(2*3**2*5, 2*5*11, 2*7**2*11)  == \
+        (11, 1, 5)
+
+    # it's ok if these pass some day when the solvers are implemented
+    raises(NotImplementedError, lambda: diophantine(x**2 + y**2 + x*y + 2*y*z - 12))
+    raises(NotImplementedError, lambda: diophantine(x**3 + y**2))
+    assert diop_quadratic(x**2 + y**2 - 1**2 - 3**4) == \
+           {(-9, -1), (-9, 1), (-1, -9), (-1, 9), (1, -9), (1, 9), (9, -1), (9, 1)}
+
+
+def test_holzer():
+    # if the input is good, don't let it diverge in holzer()
+    # (but see test_fail_holzer below)
+    assert holzer(2, 7, 13, 4, 79, 23) == (2, 7, 13)
+
+    # None in uv condition met; solution is not Holzer reduced
+    # so this will hopefully change but is here for coverage
+    assert holzer(2, 6, 2, 1, 1, 10) == (2, 6, 2)
+
+    raises(ValueError, lambda: holzer(2, 7, 14, 4, 79, 23))
+
+
+@XFAIL
+def test_fail_holzer():
+    eq = lambda x, y, z: a*x**2 + b*y**2 - c*z**2
+    a, b, c = 4, 79, 23
+    x, y, z = xyz = 26, 1, 11
+    X, Y, Z = ans = 2, 7, 13
+    assert eq(*xyz) == 0
+    assert eq(*ans) == 0
+    assert max(a*x**2, b*y**2, c*z**2) <= a*b*c
+    assert max(a*X**2, b*Y**2, c*Z**2) <= a*b*c
+    h = holzer(x, y, z, a, b, c)
+    assert h == ans  # it would be nice to get the smaller soln
+
+
+def test_issue_9539():
+    assert diophantine(6*w + 9*y + 20*x - z) == \
+           {(t_0, t_1, t_1 + t_2, 6*t_0 + 29*t_1 + 9*t_2)}
+
+
+def test_issue_8943():
+    assert diophantine(
+        3*(x**2 + y**2 + z**2) - 14*(x*y + y*z + z*x)) == \
+           {(0, 0, 0)}
+
+
+def test_diop_sum_of_even_powers():
+    eq = x**4 + y**4 + z**4 - 2673
+    assert diop_solve(eq) == {(3, 6, 6), (2, 4, 7)}
+    assert diop_general_sum_of_even_powers(eq, 2) == {(3, 6, 6), (2, 4, 7)}
+    raises(NotImplementedError, lambda: diop_general_sum_of_even_powers(-eq, 2))
+    neg = symbols('neg', negative=True)
+    eq = x**4 + y**4 + neg**4 - 2673
+    assert diop_general_sum_of_even_powers(eq) == {(-3, 6, 6)}
+    assert diophantine(x**4 + y**4 + 2) == set()
+    assert diop_general_sum_of_even_powers(x**4 + y**4 - 2, limit=0) == set()
+
+
+def test_sum_of_squares_powers():
+    tru = {(0, 0, 1, 1, 11), (0, 0, 5, 7, 7), (0, 1, 3, 7, 8), (0, 1, 4, 5, 9), (0, 3, 4, 7, 7), (0, 3, 5, 5, 8),
+           (1, 1, 2, 6, 9), (1, 1, 6, 6, 7), (1, 2, 3, 3, 10), (1, 3, 4, 4, 9), (1, 5, 5, 6, 6), (2, 2, 3, 5, 9),
+           (2, 3, 5, 6, 7), (3, 3, 4, 5, 8)}
+    eq = u**2 + v**2 + x**2 + y**2 + z**2 - 123
+    ans = diop_general_sum_of_squares(eq, oo)  # allow oo to be used
+    assert len(ans) == 14
+    assert ans == tru
+
+    raises(ValueError, lambda: list(sum_of_squares(10, -1)))
+    assert list(sum_of_squares(-10, 2)) == []
+    assert list(sum_of_squares(2, 3)) == []
+    assert list(sum_of_squares(0, 3, True)) == [(0, 0, 0)]
+    assert list(sum_of_squares(0, 3)) == []
+    assert list(sum_of_squares(4, 1)) == [(2,)]
+    assert list(sum_of_squares(5, 1)) == []
+    assert list(sum_of_squares(50, 2)) == [(5, 5), (1, 7)]
+    assert list(sum_of_squares(11, 5, True)) == [
+        (1, 1, 1, 2, 2), (0, 0, 1, 1, 3)]
+    assert list(sum_of_squares(8, 8)) == [(1, 1, 1, 1, 1, 1, 1, 1)]
+
+    assert [len(list(sum_of_squares(i, 5, True))) for i in range(30)] == [
+        1, 1, 1, 1, 2,
+        2, 1, 1, 2, 2,
+        2, 2, 2, 3, 2,
+        1, 3, 3, 3, 3,
+        4, 3, 3, 2, 2,
+        4, 4, 4, 4, 5]
+    assert [len(list(sum_of_squares(i, 5))) for i in range(30)] == [
+        0, 0, 0, 0, 0,
+        1, 0, 0, 1, 0,
+        0, 1, 0, 1, 1,
+        0, 1, 1, 0, 1,
+        2, 1, 1, 1, 1,
+        1, 1, 1, 1, 3]
+    for i in range(30):
+        s1 = set(sum_of_squares(i, 5, True))
+        assert not s1 or all(sum(j**2 for j in t) == i for t in s1)
+        s2 = set(sum_of_squares(i, 5))
+        assert all(sum(j**2 for j in t) == i for t in s2)
+
+    raises(ValueError, lambda: list(sum_of_powers(2, -1, 1)))
+    raises(ValueError, lambda: list(sum_of_powers(2, 1, -1)))
+    assert list(sum_of_powers(-2, 3, 2)) == [(-1, -1)]
+    assert list(sum_of_powers(-2, 4, 2)) == []
+    assert list(sum_of_powers(2, 1, 1)) == [(2,)]
+    assert list(sum_of_powers(2, 1, 3, True)) == [(0, 0, 2), (0, 1, 1)]
+    assert list(sum_of_powers(5, 1, 2, True)) == [(0, 5), (1, 4), (2, 3)]
+    assert list(sum_of_powers(6, 2, 2)) == []
+    assert list(sum_of_powers(3**5, 3, 1)) == []
+    assert list(sum_of_powers(3**6, 3, 1)) == [(9,)] and (9**3 == 3**6)
+    assert list(sum_of_powers(2**1000, 5, 2)) == []
+
+
+def test__can_do_sum_of_squares():
+    assert _can_do_sum_of_squares(3, -1) is False
+    assert _can_do_sum_of_squares(-3, 1) is False
+    assert _can_do_sum_of_squares(0, 1)
+    assert _can_do_sum_of_squares(4, 1)
+    assert _can_do_sum_of_squares(1, 2)
+    assert _can_do_sum_of_squares(2, 2)
+    assert _can_do_sum_of_squares(3, 2) is False
+
+
+def test_diophantine_permute_sign():
+    from sympy.abc import a, b, c, d, e
+    eq = a**4 + b**4 - (2**4 + 3**4)
+    base_sol = {(2, 3)}
+    assert diophantine(eq) == base_sol
+    complete_soln = set(signed_permutations(base_sol.pop()))
+    assert diophantine(eq, permute=True) == complete_soln
+
+    eq = a**2 + b**2 + c**2 + d**2 + e**2 - 234
+    assert len(diophantine(eq)) == 35
+    assert len(diophantine(eq, permute=True)) == 62000
+    soln = {(-1, -1), (-1, 2), (1, -2), (1, 1)}
+    assert diophantine(10*x**2 + 12*x*y + 12*y**2 - 34, permute=True) == soln
+
+
+@XFAIL
+def test_not_implemented():
+    eq = x**2 + y**4 - 1**2 - 3**4
+    assert diophantine(eq, syms=[x, y]) == {(9, 1), (1, 3)}
+
+
+def test_issue_9538():
+    eq = x - 3*y + 2
+    assert diophantine(eq, syms=[y,x]) == {(t_0, 3*t_0 - 2)}
+    raises(TypeError, lambda: diophantine(eq, syms={y, x}))
+
+
+def test_ternary_quadratic():
+    # solution with 3 parameters
+    s = diophantine(2*x**2 + y**2 - 2*z**2)
+    p, q, r = ordered(S(s).free_symbols)
+    assert s == {(
+        p**2 - 2*q**2,
+        -2*p**2 + 4*p*q - 4*p*r - 4*q**2,
+        p**2 - 4*p*q + 2*q**2 - 4*q*r)}
+    # solution with Mul in solution
+    s = diophantine(x**2 + 2*y**2 - 2*z**2)
+    assert s == {(4*p*q, p**2 - 2*q**2, p**2 + 2*q**2)}
+    # solution with no Mul in solution
+    s = diophantine(2*x**2 + 2*y**2 - z**2)
+    assert s == {(2*p**2 - q**2, -2*p**2 + 4*p*q - q**2,
+        4*p**2 - 4*p*q + 2*q**2)}
+    # reduced form when parametrized
+    s = diophantine(3*x**2 + 72*y**2 - 27*z**2)
+    assert s == {(24*p**2 - 9*q**2, 6*p*q, 8*p**2 + 3*q**2)}
+    assert parametrize_ternary_quadratic(
+        3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z) == (
+        2*p**2 - 2*p*q - q**2, 2*p**2 + 2*p*q - q**2, 2*p**2 -
+        2*p*q + 3*q**2)
+    assert parametrize_ternary_quadratic(
+        124*x**2 - 30*y**2 - 7729*z**2) == (
+        -1410*p**2 - 363263*q**2, 2700*p**2 + 30916*p*q -
+        695610*q**2, -60*p**2 + 5400*p*q + 15458*q**2)
+
+
+def test_diophantine_solution_set():
+    s1 = DiophantineSolutionSet([], [])
+    assert set(s1) == set()
+    assert s1.symbols == ()
+    assert s1.parameters == ()
+    raises(ValueError, lambda: s1.add((x,)))
+    assert list(s1.dict_iterator()) == []
+
+    s2 = DiophantineSolutionSet([x, y], [t, u])
+    assert s2.symbols == (x, y)
+    assert s2.parameters == (t, u)
+    raises(ValueError, lambda: s2.add((1,)))
+    s2.add((3, 4))
+    assert set(s2) == {(3, 4)}
+    s2.update((3, 4), (-1, u))
+    assert set(s2) == {(3, 4), (-1, u)}
+    raises(ValueError, lambda: s1.update(s2))
+    assert list(s2.dict_iterator()) == [{x: -1, y: u}, {x: 3, y: 4}]
+
+    s3 = DiophantineSolutionSet([x, y, z], [t, u])
+    assert len(s3.parameters) == 2
+    s3.add((t**2 + u, t - u, 1))
+    assert set(s3) == {(t**2 + u, t - u, 1)}
+    assert s3.subs(t, 2) == {(u + 4, 2 - u, 1)}
+    assert s3(2) == {(u + 4, 2 - u, 1)}
+    assert s3.subs({t: 7, u: 8}) == {(57, -1, 1)}
+    assert s3(7, 8) == {(57, -1, 1)}
+    assert s3.subs({t: 5}) == {(u + 25, 5 - u, 1)}
+    assert s3(5) == {(u + 25, 5 - u, 1)}
+    assert s3.subs(u, -3) == {(t**2 - 3, t + 3, 1)}
+    assert s3(None, -3) == {(t**2 - 3, t + 3, 1)}
+    assert s3.subs({t: 2, u: 8}) == {(12, -6, 1)}
+    assert s3(2, 8) == {(12, -6, 1)}
+    assert s3.subs({t: 5, u: -3}) == {(22, 8, 1)}
+    assert s3(5, -3) == {(22, 8, 1)}
+    raises(ValueError, lambda: s3.subs(x=1))
+    raises(ValueError, lambda: s3.subs(1, 2, 3))
+    raises(ValueError, lambda: s3.add(()))
+    raises(ValueError, lambda: s3.add((1, 2, 3, 4)))
+    raises(ValueError, lambda: s3.add((1, 2)))
+    raises(ValueError, lambda: s3(1, 2, 3))
+    raises(TypeError, lambda: s3(t=1))
+
+    s4 = DiophantineSolutionSet([x, y], [t, u])
+    s4.add((t, 11*t))
+    s4.add((-t, 22*t))
+    assert s4(0, 0) == {(0, 0)}
+
+
+def test_quadratic_parameter_passing():
+    eq = -33*x*y + 3*y**2
+    solution = BinaryQuadratic(eq).solve(parameters=[t, u])
+    # test that parameters are passed all the way to the final solution
+    assert solution == {(t, 11*t), (-t, 22*t)}
+    assert solution(0, 0) == {(0, 0)}