Add files using upload-large-folder tool

lib/python3.12/site-packages/sympy/core/__init__.py

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

lib/python3.12/site-packages/sympy/core/_print_helpers.py

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

lib/python3.12/site-packages/sympy/core/add.py

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

lib/python3.12/site-packages/sympy/core/alphabets.py

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

lib/python3.12/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() -> FactRules:
+    """ 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)

lib/python3.12/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}

lib/python3.12/site-packages/sympy/core/backend.py

@@ -0,0 +1,120 @@
+import os
+USE_SYMENGINE = os.getenv('USE_SYMENGINE', '0')
+USE_SYMENGINE = USE_SYMENGINE.lower() in ('1', 't', 'true')  # type: ignore
+
+if USE_SYMENGINE:
+    from symengine import (Symbol, Integer, sympify as sympify_symengine, S,
+        SympifyError, exp, log, gamma, sqrt, I, E, pi, Matrix,
+        sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, acsc, asec,
+        sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth,
+        lambdify, symarray, diff, zeros, eye, diag, ones,
+        expand, Function, symbols, var, Add, Mul, Derivative,
+        ImmutableMatrix, MatrixBase, Rational, Basic)
+    from symengine.lib.symengine_wrapper import gcd as igcd
+    from symengine import AppliedUndef
+
+    def sympify(a, *, strict=False):
+        """
+        Notes
+        =====
+
+        SymEngine's ``sympify`` does not accept keyword arguments and is
+        therefore not compatible with SymPy's ``sympify`` with ``strict=True``
+        (which ensures that only the types for which an explicit conversion has
+        been defined are converted). This wrapper adds an addiotional parameter
+        ``strict`` (with default ``False``) that will raise a ``SympifyError``
+        if ``strict=True`` and the argument passed to the parameter ``a`` is a
+        string.
+
+        See Also
+        ========
+
+        sympify: Converts an arbitrary expression to a type that can be used
+            inside SymPy.
+
+        """
+        # The parameter ``a`` is used for this function to keep compatibility
+        # with the SymEngine docstring.
+        if strict and isinstance(a, str):
+            raise SympifyError(a)
+        return sympify_symengine(a)
+
+    # Keep the SymEngine docstring and append the additional "Notes" and "See
+    # Also" sections. Replacement of spaces is required to correctly format the
+    # indentation of the combined docstring.
+    sympify.__doc__ = (
+        sympify_symengine.__doc__
+        + sympify.__doc__.replace('        ', '    ')  # type: ignore
+    )
+else:
+    from sympy.core.add import Add
+    from sympy.core.basic import Basic
+    from sympy.core.function import (diff, Function, AppliedUndef,
+        expand, Derivative)
+    from sympy.core.mul import Mul
+    from sympy.core.intfunc import igcd
+    from sympy.core.numbers import pi, I, Integer, Rational, E
+    from sympy.core.singleton import S
+    from sympy.core.symbol import Symbol, var, symbols
+    from sympy.core.sympify import SympifyError, sympify
+    from sympy.functions.elementary.exponential import log, exp
+    from sympy.functions.elementary.hyperbolic import (coth, sinh,
+        acosh, acoth, tanh, asinh, atanh, cosh)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (csc,
+        asec, cos, atan, sec, acot, asin, tan, sin, cot, acsc, acos)
+    from sympy.functions.special.gamma_functions import gamma
+    from sympy.matrices.dense import (eye, zeros, diag, Matrix,
+        ones, symarray)
+    from sympy.matrices.immutable import ImmutableMatrix
+    from sympy.matrices.matrixbase import MatrixBase
+    from sympy.utilities.lambdify import lambdify
+
+
+#
+# XXX: Handling of immutable and mutable matrices in SymEngine is inconsistent
+# with SymPy's matrix classes in at least SymEngine version 0.7.0. Until that
+# is fixed the function below is needed for consistent behaviour when
+# attempting to simplify a matrix.
+#
+# Expected behaviour of a SymPy mutable/immutable matrix .simplify() method:
+#
+#   Matrix.simplify() : works in place, returns None
+#   ImmutableMatrix.simplify() : returns a simplified copy
+#
+# In SymEngine both mutable and immutable matrices simplify in place and return
+# None. This is inconsistent with the matrix being "immutable" and also the
+# returned None leads to problems in the mechanics module.
+#
+# The simplify function should not be used because simplify(M) sympifies the
+# matrix M and the SymEngine matrices all sympify to SymPy matrices. If we want
+# to work with SymEngine matrices then we need to use their .simplify() method
+# but that method does not work correctly with immutable matrices.
+#
+# The _simplify_matrix function can be removed when the SymEngine bug is fixed.
+# Since this should be a temporary problem we do not make this function part of
+# the public API.
+#
+#   SymEngine issue: https://github.com/symengine/symengine.py/issues/363
+#
+
+def _simplify_matrix(M):
+    """Return a simplified copy of the matrix M"""
+    if not isinstance(M, (Matrix, ImmutableMatrix)):
+        raise TypeError("The matrix M must be an instance of Matrix or ImmutableMatrix")
+    Mnew = M.as_mutable() # makes a copy if mutable
+    Mnew.simplify()
+    if isinstance(M, ImmutableMatrix):
+        Mnew = Mnew.as_immutable()
+    return Mnew
+
+
+__all__ = [
+    'Symbol', 'Integer', 'sympify', 'S', 'SympifyError', 'exp', 'log',
+    'gamma', 'sqrt', 'I', 'E', 'pi', 'Matrix', 'sin', 'cos', 'tan', 'cot',
+    'csc', 'sec', 'asin', 'acos', 'atan', 'acot', 'acsc', 'asec', 'sinh',
+    'cosh', 'tanh', 'coth', 'asinh', 'acosh', 'atanh', 'acoth', 'lambdify',
+    'symarray', 'diff', 'zeros', 'eye', 'diag', 'ones', 'expand', 'Function',
+    'symbols', 'var', 'Add', 'Mul', 'Derivative', 'ImmutableMatrix',
+    'MatrixBase', 'Rational', 'Basic', 'igcd', 'AppliedUndef',
+]

lib/python3.12/site-packages/sympy/core/basic.py

@@ -0,0 +1,2339 @@
+"""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 functools import cmp_to_key
+
+from .assumptions import _prepare_class_assumptions
+from .cache import cacheit
+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))
+
+
+# Key for sorting commutative args in canonical order
+# by name. This is used for canonical ordering of the
+# args for Add and Mul *if* the names of both classes
+# being compared appear here. Some things in this list
+# are not spelled the same as their name so they do not,
+# in effect, appear here. See Basic.compare.
+ordering_of_classes = [
+    # singleton numbers
+    'Zero', 'One', 'Half', 'Infinity', 'NaN', 'NegativeOne', 'NegativeInfinity',
+    # numbers
+    'Integer', 'Rational', 'Float',
+    # singleton symbols
+    'Exp1', 'Pi', 'ImaginaryUnit',
+    # symbols
+    'Symbol', 'Wild',
+    # arithmetic operations
+    'Pow', 'Mul', 'Add',
+    # function values
+    'Derivative', 'Integral',
+    # defined singleton functions
+    'Abs', 'Sign', 'Sqrt',
+    'Floor', 'Ceiling',
+    'Re', 'Im', 'Arg',
+    'Conjugate',
+    'Exp', 'Log',
+    'Sin', 'Cos', 'Tan', 'Cot', 'ASin', 'ACos', 'ATan', 'ACot',
+    'Sinh', 'Cosh', 'Tanh', 'Coth', 'ASinh', 'ACosh', 'ATanh', 'ACoth',
+    'RisingFactorial', 'FallingFactorial',
+    'factorial', 'binomial',
+    'Gamma', 'LowerGamma', 'UpperGamma', 'PolyGamma',
+    'Erf',
+    # special polynomials
+    'Chebyshev', 'Chebyshev2',
+    # undefined functions
+    'Function', 'WildFunction',
+    # anonymous functions
+    'Lambda',
+    # Landau O symbol
+    'Order',
+    # relational operations
+    'Equality', 'Unequality', 'StrictGreaterThan', 'StrictLessThan',
+    'GreaterThan', 'LessThan',
+]
+
+def _cmp_name(x: type, y: type) -> int:
+    """return -1, 0, 1 if the name of x is before that of y.
+    A string comparison is done if either name does not appear
+    in `ordering_of_classes`. This is the helper for
+    ``Basic.compare``
+
+    Examples
+    ========
+
+    >>> from sympy import cos, tan, sin
+    >>> from sympy.core import basic
+    >>> save = basic.ordering_of_classes
+    >>> basic.ordering_of_classes = ()
+    >>> basic._cmp_name(cos, tan)
+    -1
+    >>> basic.ordering_of_classes = ["tan", "sin", "cos"]
+    >>> basic._cmp_name(cos, tan)
+    1
+    >>> basic._cmp_name(sin, cos)
+    -1
+    >>> basic.ordering_of_classes = save
+
+    """
+    # 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.
+        super().__init_subclass__()
+        _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 less than, equal,
+        or greater than other in a canonical sense.
+        Non-Basic are always greater than Basic.
+        If both names of the classes being compared appear
+        in the `ordering_of_classes` then the ordering will
+        depend on the appearance of the names there.
+        If either does not appear in that list, then the
+        comparison is based on the class name.
+        If the names are the same then a comparison is made
+        on the length of the hashable content.
+        Items of the equal-lengthed contents are then
+        successively compared using the same rules. If there
+        is never a difference then 0 is returned.
+
+        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 = _cmp_name(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):
+        """return -1, 0, 1 if a is canonically less, equal or
+        greater than b. This is used when 'order=old' is selected
+        for printing. This puts Order last, orders Rationals
+        according to value, puts terms in order wrt the power of
+        the last power appearing in a term. Ties are broken using
+        Basic.compare.
+        """
+        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
+
+        # break ties
+        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
+
+    def is_same(a, b, approx=None):
+        """Return True if a and b are structurally the same, else False.
+        If `approx` is supplied, it will be used to test whether two
+        numbers are the same or not. By default, only numbers of the
+        same type will compare equal, so S.Half != Float(0.5).
+
+        Examples
+        ========
+
+        In SymPy (unlike Python) two numbers do not compare the same if they are
+        not of the same type:
+
+        >>> from sympy import S
+        >>> 2.0 == S(2)
+        False
+        >>> 0.5 == S.Half
+        False
+
+        By supplying a function with which to compare two numbers, such
+        differences can be ignored. e.g. `equal_valued` will return True
+        for decimal numbers having a denominator that is a power of 2,
+        regardless of precision.
+
+        >>> from sympy import Float
+        >>> from sympy.core.numbers import equal_valued
+        >>> (S.Half/4).is_same(Float(0.125, 1), equal_valued)
+        True
+        >>> Float(1, 2).is_same(Float(1, 10), equal_valued)
+        True
+
+        But decimals without a power of 2 denominator will compare
+        as not being the same.
+
+        >>> Float(0.1, 9).is_same(Float(0.1, 10), equal_valued)
+        False
+
+        But arbitrary differences can be ignored by supplying a function
+        to test the equivalence of two numbers:
+
+        >>> import math
+        >>> Float(0.1, 9).is_same(Float(0.1, 10), math.isclose)
+        True
+
+        Other objects might compare the same even though types are not the
+        same. This routine will only return True if two expressions are
+        identical in terms of class types.
+
+        >>> from sympy import eye, Basic
+        >>> eye(1) == S(eye(1))  # mutable vs immutable
+        True
+        >>> Basic.is_same(eye(1), S(eye(1)))
+        False
+
+        """
+        from .numbers import Number
+        from .traversal import postorder_traversal as pot
+        for t in zip_longest(pot(a), pot(b)):
+            if None in t:
+                return False
+            a, b = t
+            if isinstance(a, Number):
+                if not isinstance(b, Number):
+                    return False
+                if approx:
+                    return approx(a, b)
+            if not (a == b and a.__class__ == b.__class__):
+                return False
+        return True
+
+_aresame = Basic.is_same  # for sake of others importing this
+
+# key used by Mul and Add to make canonical args
+_args_sortkey = cmp_to_key(Basic.compare)
+
+# 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 _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)

lib/python3.12/site-packages/sympy/core/cache.py

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

lib/python3.12/site-packages/sympy/core/compatibility.py

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

lib/python3.12/site-packages/sympy/core/containers.py

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

lib/python3.12/site-packages/sympy/core/core.py

@@ -0,0 +1,21 @@
+""" The core's core. """
+from __future__ import annotations
+
+
+class Registry:
+    """
+    Base class for registry objects.
+
+    Registries map a name to an object using attribute notation. Registry
+    classes behave singletonically: all their instances share the same state,
+    which is stored in the class object.
+
+    All subclasses should set `__slots__ = ()`.
+    """
+    __slots__ = ()
+
+    def __setattr__(self, name, obj):
+        setattr(self.__class__, name, obj)
+
+    def __delattr__(self, name):
+        delattr(self.__class__, name)

lib/python3.12/site-packages/sympy/core/coreerrors.py

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

lib/python3.12/site-packages/sympy/core/decorators.py

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

lib/python3.12/site-packages/sympy/core/evalf.py

@@ -0,0 +1,1802 @@
+"""
+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.log2(10)
+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:
+                # use strict=False with as_int because we take
+                # 2.0 == 2
+                def is_int_reim(x):
+                    """Check for integer or integer + I*integer."""
+                    try:
+                        as_int(x, strict=False)
+                        return True
+                    except ValueError:
+                        try:
+                            [as_int(i, strict=False) for i in x.as_real_imag()]
+                            return True
+                        except ValueError:
+                            return False
+
+                if all(is_int_reim(v) for v in s.values()):
+                    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.log2(abs(p)))
+        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)